Lines Matching refs:entry
415 /* A 24-bit pc-relative relocation referencing the TLS PLT entry for
544 /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
560 /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
576 /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
626 symbol+addend whose TLS resolver entry point is given by the sum
643 symbol+addend whose TLS offset GOT entry is given by the sum of
757 an entry point, and the second resolves to a special argument.
758 If the symbol turns out to be in static TLS, the entry point is a
760 for the symbol. If it's in dynamic TLS, the entry point is a TLS
814 /* Location of the first non-lazy PLT entry, i.e., the number of
856 FIXME: if there's any TLS PLT entry that uses local-exec or
921 used for the next got entry, otherwise CUR is used and
987 /* If symndx == -1, the hash table entry corresponding to a global
995 /* The fields above are used to identify an entry. The fields below
996 contain information on how an entry is used and, later on, which
1019 tlspltimm, to tell what kind of TLS PLT entry we're generating.
1044 /* Whether we need a PLT entry for a symbol. Should be implied by
1054 /* Whether a lazy PLT entry is needed for this symbol+addend.
1084 /* The offset of the TLS offset PLT entry. */
1088 /* Compute a hash with the key fields of an frvfdpic_relocs_info entry. */
1092 const struct frvfdpic_relocs_info *entry = entry_;
1094 return (entry->symndx == -1
1095 ? (long) entry->d.h->root.root.hash
1096 : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1111 /* Find or create an entry in a hash table HT that matches the key
1113 entry is allocated in ABFD's obstack. */
1117 const struct frvfdpic_relocs_info *entry,
1121 (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1134 (*loc)->symndx = entry->symndx;
1135 (*loc)->d = entry->d;
1136 (*loc)->addend = entry->addend;
1144 /* Obtain the address of the entry in HT associated with H's symbol +
1145 addend, creating a new entry if none existed. ABFD is only used
1154 struct frvfdpic_relocs_info entry;
1156 entry.symndx = -1;
1157 entry.d.h = h;
1158 entry.addend = addend;
1160 return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1163 /* Obtain the address of the entry in HT associated with the SYMNDXth
1165 entry if none existed. */
1173 struct frvfdpic_relocs_info entry;
1175 entry.symndx = symndx;
1176 entry.d.abfd = abfd;
1177 entry.addend = addend;
1179 return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1212 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1224 struct frvfdpic_relocs_info *entry)
1239 /* If the entry's index is zero, this relocation was probably to a
1241 relocation, but it was for another entry than the one we got at
1246 if (entry->symndx)
1248 BFD_ASSERT (entry->dynrelocs > 0);
1249 entry->dynrelocs--;
1259 struct frvfdpic_relocs_info *entry)
1274 if (entry && entry->symndx)
1278 BFD_ASSERT (entry->fixups > 0);
1279 entry->fixups--;
1323 _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
1334 if (entry->done)
1336 entry->done = 1;
1338 if (entry->got_entry || entry->fdgot_entry || entry->fd_entry
1339 || entry->tlsoff_entry || entry->tlsdesc_entry)
1343 if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1344 dynindx = entry->d.h->dynindx;
1357 /* Generate relocation for GOT entry pointing to the symbol. */
1358 if (entry->got_entry)
1365 if (sec && (entry->symndx != -1
1366 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1368 if (entry->symndx == -1)
1369 ad += entry->d.h->root.u.def.value;
1383 && (entry->symndx != -1
1384 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1388 if (entry->symndx != -1
1389 || entry->d.h->root.type != bfd_link_hash_undefweak)
1396 + entry->got_entry, entry);
1404 + entry->got_entry)
1408 R_FRV_32, idx, ad, entry);
1413 + entry->got_entry);
1416 /* Generate relocation for GOT entry pointing to a canonical
1418 if (entry->fdgot_entry)
1423 if (! (entry->symndx == -1
1424 && entry->d.h->root.type == bfd_link_hash_undefweak
1425 && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1434 if (entry->symndx == -1
1435 && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1436 && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
1440 idx = elf_section_data (entry->d.h->root.u.def.section
1442 ad = entry->d.h->root.u.def.section->output_offset
1443 + entry->d.h->root.u.def.value;
1445 else if (entry->symndx == -1
1446 && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1457 entry->fdgot_entry);
1466 BFD_ASSERT (entry->privfd);
1471 + frvfdpic_got_initial_offset (info) + entry->fd_entry;
1477 dynamic symbol entry for the got section, so idx will be
1481 && (entry->symndx != -1
1482 || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1492 + entry->fdgot_entry, entry);
1501 + entry->fdgot_entry)
1506 reloc, idx, ad, entry);
1512 + entry->fdgot_entry);
1517 if (entry->fd_entry)
1526 if (sec && (entry->symndx != -1
1527 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1529 if (entry->symndx == -1)
1530 ad += entry->d.h->root.u.def.value;
1544 && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1549 if (entry->symndx != -1
1550 || entry->d.h->root.type != bfd_link_hash_undefweak)
1559 + entry->fd_entry, entry);
1567 + entry->fd_entry + 4, entry);
1574 entry->lazyplt
1581 + entry->fd_entry)
1586 R_FRV_FUNCDESC_VALUE, idx, ad, entry);
1600 else if (entry->lazyplt)
1608 entry->fd_entry);
1617 the low word contains the address of the lazy PLT entry
1618 entry point, that must be within the memory region
1620 lowword = entry->lzplt_entry + 4
1633 || (entry->symndx == -1 && entry->d.h->dynindx != -1
1634 && entry->d.h->dynindx == idx))
1644 + entry->fd_entry);
1648 + entry->fd_entry + 4);
1651 /* Generate code for the PLT entry. */
1652 if (entry->plt_entry != (bfd_vma) -1)
1655 + entry->plt_entry;
1657 BFD_ASSERT (entry->fd_entry);
1659 /* Figure out what kind of PLT entry we need, depending on the
1661 if (entry->fd_entry >= -(1 << (12 - 1))
1662 && entry->fd_entry < (1 << (12 - 1)))
1666 0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1672 if (entry->fd_entry >= -(1 << (16 - 1))
1673 && entry->fd_entry < (1 << (16 - 1)))
1678 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1688 | ((entry->fd_entry >> 16)
1694 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1706 /* Generate code for the lazy PLT entry. */
1707 if (entry->lzplt_entry != (bfd_vma) -1)
1710 + entry->lzplt_entry;
1716 resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
1721 if (entry->lzplt_entry == resolverStub_addr)
1723 /* This is a lazy PLT entry that includes a resolver call. */
1734 | (((resolverStub_addr - entry->lzplt_entry)
1740 /* Generate relocation for GOT entry holding the TLS offset. */
1741 if (entry->tlsoff_entry)
1746 if (entry->symndx != -1
1747 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))
1753 if (entry->symndx == -1)
1754 ad += entry->d.h->root.u.def.value;
1776 && (entry->symndx != -1
1777 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1792 frvfdpic_got_section (info), entry->tlsoff_entry, true);
1803 + entry->tlsoff_entry)
1808 R_FRV_TLSOFF, idx, ad, entry);
1814 + entry->tlsoff_entry);
1817 if (entry->tlsdesc_entry)
1824 if (sec && (entry->symndx != -1
1825 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1827 if (entry->symndx == -1)
1828 ad += entry->d.h->root.u.def.value;
1838 /* If we didn't set up a TLS offset entry, but we're linking an
1841 if (bfd_link_executable (info) && ! entry->tlsoff_entry)
1842 entry->tlsoff_entry = entry->tlsdesc_entry + 4;
1848 || entry->symndx != -1
1849 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1869 + entry->tlsdesc_entry);
1878 + entry->tlsdesc_entry, entry);
1906 frvfdpic_got_section (info), entry->tlsdesc_entry, true);
1918 + entry->tlsdesc_entry)
1923 R_FRV_TLSDESC_VALUE, idx, ad, entry);
1928 + entry->tlsdesc_entry);
1934 + entry->tlsdesc_entry + 4);
1937 /* Generate code for the get-TLS-offset PLT entry. */
1938 if (entry->tlsplt_entry != (bfd_vma) -1)
1941 + entry->tlsplt_entry;
1944 && (entry->symndx != -1
1945 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1954 BFD_ASSERT (entry->symndx == -1
1955 && entry->d.h->root.type == bfd_link_hash_undefweak);
1959 if (entry->symndx == -1)
1960 ad += entry->d.h->root.u.def.value;
2014 else if (entry->tlsoff_entry)
2016 /* Figure out what kind of PLT entry we need, depending on the
2018 if (entry->tlsoff_entry >= -(1 << (12 - 1))
2019 && entry->tlsoff_entry < (1 << (12 - 1)))
2023 0x92c8f000 | (entry->tlsoff_entry
2030 if (entry->tlsoff_entry >= -(1 << (16 - 1))
2031 && entry->tlsoff_entry < (1 << (16 - 1)))
2036 | (entry->tlsoff_entry
2047 | ((entry->tlsoff_entry >> 16)
2053 | (entry->tlsoff_entry
2067 BFD_ASSERT (entry->tlsdesc_entry);
2069 /* Figure out what kind of PLT entry we need, depending on the
2071 if (entry->tlsdesc_entry >= -(1 << (12 - 1))
2072 && entry->tlsdesc_entry < (1 << (12 - 1)))
2076 0x90ccf000 | (entry->tlsdesc_entry
2083 if (entry->tlsdesc_entry >= -(1 << (16 - 1))
2084 && entry->tlsdesc_entry < (1 << (16 - 1)))
2089 | (entry->tlsdesc_entry
2100 | ((entry->tlsdesc_entry >> 16)
2106 | (entry->tlsdesc_entry
2649 The global hash table entry for the global symbols can be found
2821 /* In order to find the entry we created before, we must
3569 dynamic symbol entry for the got section, so idx will
3792 contains the offset of the lazy PLT entry entry
3966 /* When referencing a GOT entry, a function descriptor or a
3968 but rather to the referenced symbol. The actual entry
4391 range. Symbols may require up to 4 words in the GOT: an entry
4392 pointing to the symbol, an entry pointing to its function
4397 _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4400 /* Allocate space for a GOT entry pointing to the symbol. */
4401 if (entry->got12)
4403 else if (entry->gotlos)
4405 else if (entry->gothilo)
4408 entry->relocs32--;
4409 entry->relocs32++;
4411 /* Allocate space for a GOT entry pointing to the function
4413 if (entry->fdgot12)
4415 else if (entry->fdgotlos)
4417 else if (entry->fdgothilo)
4420 entry->relocsfd--;
4421 entry->relocsfd++;
4423 /* Decide whether we need a PLT entry, a function descriptor in the
4424 GOT, and a lazy PLT entry for this symbol. */
4425 entry->plt = entry->call
4426 && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4428 entry->privfd = entry->plt
4429 || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4430 || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4431 && (entry->symndx != -1
4432 || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4433 entry->lazyplt = entry->privfd
4434 && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4439 if (entry->fdgoff12)
4441 else if (entry->fdgofflos)
4443 else if (entry->privfd && entry->plt)
4445 else if (entry->privfd)
4448 entry->relocsfdv--;
4449 entry->relocsfdv++;
4451 if (entry->lazyplt)
4456 range. Symbols may require up to 5 words in the GOT: an entry
4457 holding the TLS offset for the symbol, and an entry with a full TLS
4461 _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4467 /* Allocate space for a GOT entry with the TLS offset of the
4469 if (entry->tlsoff12)
4471 else if (entry->tlsofflos)
4473 else if (entry->tlsoffhilo)
4476 entry->relocstlsoff -= l;
4477 entry->relocstlsoff += l;
4484 if (entry->relocstlsoff)
4488 if (entry->tlsdesc12)
4490 else if (entry->tlsdesclos)
4492 else if (entry->tlsplt)
4494 else if (entry->tlsdeschilo)
4497 entry->relocstlsd -= l;
4498 entry->relocstlsd += l;
4506 _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4514 relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4515 + entry->relocstlsd;
4525 || (entry->symndx == -1
4526 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4527 relocs += entry->relocstlsoff;
4531 if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4533 if (entry->symndx != -1
4534 || entry->d.h->root.type != bfd_link_hash_undefweak)
4535 fixups += entry->relocs32 + 2 * entry->relocsfdv;
4536 fixups += entry->relocstlsd;
4537 tlsrets += entry->relocstlsd;
4541 relocs += entry->relocs32 + entry->relocsfdv
4542 + entry->relocstlsoff + entry->relocstlsd;
4545 if (entry->symndx != -1
4546 || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4548 if (entry->symndx != -1
4549 || entry->d.h->root.type != bfd_link_hash_undefweak)
4550 fixups += entry->relocsfd;
4553 relocs += entry->relocsfd;
4563 entry->dynrelocs += relocs;
4564 entry->fixups += fixups;
4577 _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4586 if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4590 _frvfdpic_count_relocs_fixups (entry, dinfo, true);
4591 _frvfdpic_count_tls_entries (entry, dinfo, true);
4599 to GOTTLSOFF, we must keep the GOT entry in range. We know
4603 || (entry->symndx == -1
4604 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4606 entry->tlsoff12 |= entry->tlsdesc12;
4607 entry->tlsofflos |= entry->tlsdesclos;
4608 entry->tlsoffhilo |= entry->tlsdeschilo;
4611 entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4616 in range for a setlos. For symbols with a hash entry, we can
4619 approximation. If we get it wrong, we'll retain a GOT entry
4624 if ((entry->tlsplt
4625 || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4627 && ((entry->symndx == -1
4628 && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4632 && (entry->d.h->root.type == bfd_link_hash_undefweak
4633 || (bfd_vma)(entry->d.h->root.u.def.value
4634 + (entry->d.h->root.u.def.section
4636 + entry->d.h->root.u.def.section->output_offset
4637 + entry->addend
4640 || (entry->symndx != -1
4642 + entry->addend < 32768 + FRVFDPIC_TLS_BIAS))))
4646 _frvfdpic_count_relocs_fixups (entry, dinfo, true);
4647 _frvfdpic_count_tls_entries (entry, dinfo, true);
4651 entry->tlsplt =
4652 entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4656 have a #gottlsoff12 relocation for this entry, or if we can fit
4658 if (entry->tlsplt
4659 && (entry->tlsoff12
4668 _frvfdpic_count_relocs_fixups (entry, dinfo, true);
4669 _frvfdpic_count_tls_entries (entry, dinfo, true);
4673 entry->tlsoff12 = 1;
4674 entry->tlsplt = 0;
4679 _frvfdpic_count_tls_entries (entry, dinfo, false);
4680 _frvfdpic_count_relocs_fixups (entry, dinfo, false);
4687 Symbols may require up to 4 words in the GOT: an entry pointing to
4688 the symbol, an entry pointing to its function descriptor, and a
4694 struct frvfdpic_relocs_info *entry = *entryp;
4697 _frvfdpic_count_nontls_entries (entry, dinfo);
4701 _frvfdpic_relax_tls_entries (entry, dinfo, false);
4704 _frvfdpic_count_tls_entries (entry, dinfo, false);
4705 _frvfdpic_count_relocs_fixups (entry, dinfo, false);
4715 an ODD entry that may have been left behind. GOT and FD indicate
4746 unpaired GOT entry. */
4756 /* If we're left with an unpaired GOT entry, compute its location
4902 /* Compute the location of the next GOT entry, given the allocation
4931 /* Compute the location of the next function descriptor entry in the
4944 /* Compute the location of the next TLS descriptor entry in the GOT,
4962 /* Assign GOT offsets for every GOT entry and function descriptor.
4968 struct frvfdpic_relocs_info *entry = *entryp;
4971 if (entry->got12)
4972 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
4973 else if (entry->gotlos)
4974 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
4975 else if (entry->gothilo)
4976 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
4978 if (entry->fdgot12)
4979 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
4980 else if (entry->fdgotlos)
4981 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
4982 else if (entry->fdgothilo)
4983 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
4985 if (entry->fdgoff12)
4986 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
4987 else if (entry->plt && dinfo->got12.fdplt)
4990 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
4992 else if (entry->fdgofflos)
4993 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
4994 else if (entry->plt && dinfo->gotlos.fdplt)
4997 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
4999 else if (entry->plt)
5002 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5004 else if (entry->privfd)
5005 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5007 if (entry->tlsoff12)
5008 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5009 else if (entry->tlsofflos)
5010 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5011 else if (entry->tlsoffhilo)
5012 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5014 if (entry->tlsdesc12)
5015 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5016 else if (entry->tlsplt && dinfo->got12.tlsdplt)
5019 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5021 else if (entry->tlsdesclos)
5022 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5023 else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5026 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5028 else if (entry->tlsplt)
5031 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5033 else if (entry->tlsdeschilo)
5034 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5046 struct frvfdpic_relocs_info *entry = *entryp;
5049 if (entry->privfd)
5050 BFD_ASSERT (entry->fd_entry);
5052 if (entry->plt)
5057 next PLT entry. */
5058 entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5060 /* Figure out the length of this PLT entry based on the
5062 BFD_ASSERT (entry->fd_entry);
5063 if (entry->fd_entry >= -(1 << (12 - 1))
5064 && entry->fd_entry < (1 << (12 - 1)))
5066 else if (entry->fd_entry >= -(1 << (16 - 1))
5067 && entry->fd_entry < (1 << (16 - 1)))
5075 if (entry->lazyplt)
5077 entry->lzplt_entry = dinfo->g.lzplt;
5079 /* If this entry is the one that gets the resolver stub, account
5081 if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5086 if (entry->tlsplt)
5090 entry->tlsplt_entry
5094 && (entry->symndx != -1
5095 || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5097 if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5106 + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5111 else if (entry->tlsoff_entry)
5113 if (entry->tlsoff_entry >= -(1 << (12 - 1))
5114 && entry->tlsoff_entry < (1 << (12 - 1)))
5116 else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5117 && entry->tlsoff_entry < (1 << (16 - 1)))
5124 BFD_ASSERT (entry->tlsdesc_entry);
5126 if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5127 && entry->tlsdesc_entry < (1 << (12 - 1)))
5129 else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5130 && entry->tlsdesc_entry < (1 << (16 - 1)))
5148 struct frvfdpic_relocs_info *entry = *entryp;
5150 entry->got_entry = 0;
5151 entry->fdgot_entry = 0;
5152 entry->fd_entry = 0;
5153 entry->plt_entry = (bfd_vma)-1;
5154 entry->lzplt_entry = (bfd_vma)-1;
5155 entry->tlsoff_entry = 0;
5156 entry->tlsdesc_entry = 0;
5157 entry->tlsplt_entry = (bfd_vma)-1;
5162 /* Follow indirect and warning hash entries so that each got entry
5171 struct frvfdpic_relocs_info *entry = *entryp;
5174 if (entry->symndx == -1)
5176 struct elf_link_hash_entry *h = entry->d.h;
5183 if (entry->d.h == h)
5186 oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5192 frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5197 entry->d.h = h;
5199 /* If we can't find this entry with the new bfd hash, re-insert
5201 if (! htab_find (*htab, entry))
5204 entryp = htab_find_slot (*htab, entry, INSERT);
5206 *entryp = entry;
5611 struct frvfdpic_relocs_info *entry = *entryp;
5614 _frvfdpic_relax_tls_entries (entry, dinfo, true);
5913 the target of a call is a dynamic symbol, a PLT entry must be
5915 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
5921 exist. LABEL24 might as well, since it may require a PLT entry,
5924 Non-FUNCDESC GOT relocations require a GOT entry to be created
5929 for the GOT entry always has to be created, be it to offset a
5933 FUNCDESC GOT relocations require a GOT entry to be created, and
5934 handled as if a FUNCDESC relocation was applied to the GOT entry in
5952 dynamic, a lazy PLT entry. Since we can't tell at this point
5954 whether to create a lazy PLT entry or bind the descriptor directly
5967 entry to be present.
5987 the most distant location from the first lazy PLT entry such that
5998 PLT entry should be faster), or taking hints from the compiler.