if (profile && _dl_name_match_p (_dl_profile, map))
if (profile && _dl_name_match_p (GL(dl_profile), map))
__elf_machine_runtime_setup (struct link_map *map, int lazy, int profile){  if (map->l_info[DT_JMPREL])    {      Elf32_Word i;      Elf32_Word *plt = (Elf32_Word *) D_PTR (map, l_info[DT_PLTGOT]);      Elf32_Word num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val				    / sizeof (Elf32_Rela));      Elf32_Word rel_offset_words = PLT_DATA_START_WORDS (num_plt_entries);      Elf32_Word data_words = (Elf32_Word) (plt + rel_offset_words);      Elf32_Word size_modified;      extern void _dl_runtime_resolve (void);      extern void _dl_prof_resolve (void);      /* Convert the index in r11 into an actual address, and get the	 word at that address.  */      plt[PLT_LONGBRANCH_ENTRY_WORDS] = OPCODE_ADDIS_HI (11, 11, data_words);      plt[PLT_LONGBRANCH_ENTRY_WORDS + 1] = OPCODE_LWZ (11, data_words, 11);      /* Call the procedure at that address.  */      plt[PLT_LONGBRANCH_ENTRY_WORDS + 2] = OPCODE_MTCTR (11);      plt[PLT_LONGBRANCH_ENTRY_WORDS + 3] = OPCODE_BCTR ();      if (lazy)	{	  Elf32_Word *tramp = plt + PLT_TRAMPOLINE_ENTRY_WORDS;	  Elf32_Word dlrr = (Elf32_Word)(profile					 ? _dl_prof_resolve					 : _dl_runtime_resolve);	  Elf32_Word offset;	  if (profile && _dl_name_match_p (_dl_profile, map))	    /* This is the object we are looking for.  Say that we really	       want profiling and the timers are started.  */	    _dl_profile_map = map;	  /* For the long entries, subtract off data_words.  */	  tramp[0] = OPCODE_ADDIS_HI (11, 11, -data_words);	  tramp[1] = OPCODE_ADDI (11, 11, -data_words);	  /* Multiply index of entry by 3 (in r11).  */	  tramp[2] = OPCODE_SLWI (12, 11, 1);	  tramp[3] = OPCODE_ADD (11, 12, 11);	  if (dlrr <= 0x01fffffc || dlrr >= 0xfe000000)	    {	      /* Load address of link map in r12.  */	      tramp[4] = OPCODE_LI (12, (Elf32_Word) map);	      tramp[5] = OPCODE_ADDIS_HI (12, 12, (Elf32_Word) map);	      /* Call _dl_runtime_resolve.  */	      tramp[6] = OPCODE_BA (dlrr);	    }	  else	    {	      /* Get address of _dl_runtime_resolve in CTR.  */	      tramp[4] = OPCODE_LI (12, dlrr);	      tramp[5] = OPCODE_ADDIS_HI (12, 12, dlrr);	      tramp[6] = OPCODE_MTCTR (12);	      /* Load address of link map in r12.  */	      tramp[7] = OPCODE_LI (12, (Elf32_Word) map);	      tramp[8] = OPCODE_ADDIS_HI (12, 12, (Elf32_Word) map);	      /* Call _dl_runtime_resolve.  */	      tramp[9] = OPCODE_BCTR ();	    }	  /* Set up the lazy PLT entries.  */	  offset = PLT_INITIAL_ENTRY_WORDS;	  i = 0;	  while (i < num_plt_entries && i < PLT_DOUBLE_SIZE)	    {	      plt[offset  ] = OPCODE_LI (11, i * 4);	      plt[offset+1] = OPCODE_B ((PLT_TRAMPOLINE_ENTRY_WORDS + 2					 - (offset+1))					* 4);	      i++;	      offset += 2;	    }	  while (i < num_plt_entries)	    {	      plt[offset  ] = OPCODE_LIS_HI (11, i * 4 + data_words);	      plt[offset+1] = OPCODE_LWZU (12, i * 4 + data_words, 11);	      plt[offset+2] = OPCODE_B ((PLT_TRAMPOLINE_ENTRY_WORDS					 - (offset+2))					* 4);	      plt[offset+3] = OPCODE_BCTR ();	      i++;	      offset += 4;	    }	}      /* Now, we've modified code.  We need to write the changes from	 the data cache to a second-level unified cache, then make	 sure that stale data in the instruction cache is removed.	 (In a multiprocessor system, the effect is more complex.)	 Most of the PLT shouldn't be in the instruction cache, but	 there may be a little overlap at the start and the end.	 Assumes that dcbst and icbi apply to lines of 16 bytes or	 more.  Current known line sizes are 16, 32, and 128 bytes.  */      size_modified = lazy ? rel_offset_words : 6;      for (i = 0; i < size_modified; i += 4)	PPC_DCBST (plt + i);      PPC_DCBST (plt + size_modified - 1);      PPC_SYNC;      PPC_ICBI (plt);      PPC_ICBI (plt + size_modified - 1);      PPC_ISYNC;    }  return lazy;}