Lines Matching +defs:string +defs:to +defs:number
62 global and local TLS symbols. Note that this is different to none
65 In the traditional TLS mechanism, the double GOT entry is used to
76 In the TLS descriptor mechanism the double GOT entry is used to
83 The handling of TLS symbols is implemented across a number of
120 local symbol structure to record the GOT offset allocated.
129 encountered. The implementation uses the LSB of the GOT offset to
131 emitted. All of the TLS code that uses the GOT offset needs to take
132 care to mask out this flag bit before using the offset.
288 in x16 and needs to work out PLTGOT[1] by using an address of
433 Therefore, the table needs to be synced with BFD_RELOC_AARCH64_*
560 /* Group relocations to create a 16, 32, 48 or 64 bit
668 /* Group relocations to create high part of a 16, 32, 48 or 64 bit
670 to MOVN or MOVZ depending on sign of calculated value. */
717 /* Group relocations to create a 16, 32, 48 or 64 bit
825 /* Relocations to generate 19, 21 and 33 bit PC-relative load/store
1040 /* Set a load-literal immediate field to bits
1056 /* Get to the page for the GOT entry for the symbol
1147 /* LD32: GOT offset to the page address of GOT table.
1163 /* LD64: GOT offset to the page address of GOT table.
1179 /* Get to the page for the GOT entry for the symbol
1224 /* Lower 16 bits of GOT offset to tls_index. */
1239 /* Higher 16 bits of GOT offset to tls_index. */
1338 /* ADD: bit[23:12] of byte offset to module TLS base address. */
1353 /* Unsigned 12 bit byte offset to module TLS base address. */
1398 /* Get to the page for the GOT entry for the symbol
1428 /* LD/ST16: bit[11:1] of byte offset to module TLS base address. */
1458 /* LD/ST32: bit[11:2] of byte offset to module TLS base address. */
1488 /* LD/ST64: bit[11:3] of byte offset to module TLS base address. */
1518 /* LD/ST8: bit[11:0] of byte offset to module TLS base address. */
1548 /* MOVZ: bit[15:0] of byte offset to module TLS base address. */
1578 /* MOVZ: bit[31:16] of byte offset to module TLS base address. */
1608 /* MOVZ: bit[47:32] of byte offset to module TLS base address. */
1735 /* LD/ST16: bit[11:1] of byte offset to module TLS base address. */
1765 /* LD/ST32: bit[11:2] of byte offset to module TLS base address. */
1795 /* LD/ST64: bit[11:3] of byte offset to module TLS base address. */
1825 /* LD/ST8: bit[11:0] of byte offset to module TLS base address. */
1883 /* Get to the page for the GOT entry for the symbol
2227 bfd_reloc_code_real_type to;
2230 /* Map bfd generic reloc to AArch64-specific reloc. */
2253 /* Convert bfd generic reloc to AArch64-specific reloc. */
2259 code = elf_aarch64_reloc_map[i].to;
2352 The entry_names are used to do simple name mangling on the stubs.
2422 string. */
2446 value when building the stubs (so the stub knows where to jump). */
2463 stub name in the hash table has to be unique; this does not, so
2467 /* The instruction which caused this stub to be generated (only valid for
2475 /* Used to build a map of a section. This is required for mixed-endian
2498 /* The size of the thread control block which is defined to be two pointers. */
2523 /* Zero to warn when linking objects with incompatible enum sizes. */
2526 /* Zero to warn when linking objects with incompatible wchar_t sizes. */
2532 /* Zero to warn when linking objects with incompatible
2573 /* Since PLT entries have variable size, we need to record the
2585 /* A pointer to the most recently used stub hash entry against this
2615 #define aarch64_stub_hash_lookup(table, string, create, copy) \
2617 bfd_hash_lookup ((table), (string), (create), (copy)))
2625 /* Nonzero to force PIC branch veneers. */
2637 /* The number of bytes in the initial entry in the PLT. */
2643 /* The number of bytes in the subsequent PLT entries. */
2666 /* Array to keep track of which stub sections have been created, and
2670 /* This is the section to which stubs in the group will be
2685 /* The number of bytes in the PLT enty for the TLS descriptor. */
2698 const char *string)
2714 table, string));
2731 struct bfd_hash_table *table, const char *string)
2745 entry = bfd_hash_newfunc (entry, table, string);
2881 h->root.root.string, isym_sto);
3011 /* We don't want to redirect any old unconditional jump in this way,
3013 acceptable for the IP0 and IP1 registers to be clobbered. */
3037 len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 16 + 1;
3042 hash->root.root.root.string,
3062 functions, the function symbols are not added to the hash table. */
3096 Stub names need to include a section id, as there may well be
3097 more than one stub used to reach say, printf, and we need to
3150 Fix or create the stub section used to collect stubs attached to
3177 section to the stub hash. Not all fields of the new stub entry are
3210 /* Add a new stub entry in the final stub section to the stub hash.
3258 /* Massage our args to the form they really have. */
3263 /* Fail if the target section could not be assigned to an output
3267 info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
3341 /* We want the value relative to the address 12 bytes back from the
3387 /* Massage our args to the form they really have. */
3440 /* Count the number of input BFDs and find the top input section id. */
3459 /* We can't use output_bfd->section_count here to find the top output
3498 Build lists of input sections to determine groupings between which
3514 /* This happens to make the list in reverse order,
3523 sections may result in fewer stubs. More importantly, we need to
3576 /* Add NEXT to the group. */
3580 /* OK, the size from the start to the start of CURR is less
3585 stubs added here, as stubs contribute to the final output
3595 /* But wait, there's more! Input sections up to stub_group_size
3607 /* Add NEXT to the stub group. */
3665 is set equal to RT.
3816 it is possible for a 64-bit multiply-accumulate instruction to generate an
3817 incorrect result. The details are quite complex and hard to
3823 the original instruction with a branch to the patch. This function checks
3867 /* Used to order a list of mapping symbols by address. */
4001 /* Helper predicate to look for cortex-a53 erratum 843419 sequence 1. */
4024 seen set P_VENEER_I to the offset of the final LOAD/STORE
4094 /* Add space for a branch. Add 8 bytes to keep section 8 byte aligned,
4100 4096. This is important in order to ensure that the insertion
4158 attached to the input section in which an erratum sequence has
4162 copied instruction will have had any relocations applied to it.
4192 Return TRUE on successful scan, FALSE on failure to scan.
4270 The basic idea here is to examine all the relocations looking for
4271 PC-relative calls to a target that is unreachable with a "bl"
4289 /* Propagate mach to stub bfd, because it may not have been
4380 /* Walk over each section attached to the input bfd. */
4387 to do. */
4508 use the PLT stub as target address to
4532 target address to decide whether a long
4558 sym_name = hash->root.root.root.string;
4630 /* Ask the linker to do its stuff. */
4642 stubs are kept in a hash table attached to the main linker hash
4665 /* Allocate memory to hold the linker stubs. */
4672 /* Add a branch around the stub section, and a nop, to keep it 8 byte
4687 /* Add an entry to the code/data map for section SEC. */
4739 should contain the number of local symbols, which should come before any
4874 the least significant bit to record whether we have
4877 entry to initialize the value. This is done in the
4896 /* Change R_TYPE to a more efficient access model where possible,
5120 referred to in h. */
5166 referred to in h. */
5221 /* Helper to insert branches to erratum 835769 stubs in the right
5300 we're allowed to use the ADRP errata workaround, otherwise it is not
5392 /* Fix code to point to erratum 835769 stubs. */
5477 which refer to the same offset. */
5509 if (h->root.root.string)
5510 name = h->root.root.string;
5533 if (h->root.root.string)
5534 name = h->root.root.string;
5549 if (h->root.root.string)
5550 name = h->root.root.string;
5570 /* Need a dynamic relocation to get the real function
5603 do not want to fiddle with the addend. Otherwise,
5604 we need to include the symbol value so that it
5637 /* We can't use h->got.offset here to save state, or
5662 we use the least significant bit to record
5666 relocation entry to initialize the value. This
5716 relocations are copied into the output file to be resolved at
5725 /* Or we are creating an executable, we may need to keep relocations
5726 for symbols satisfied by a dynamic library if we manage to avoid
5800 /* Sanity to check that we have previously allocated
5802 number of relocations we actually want to emit. */
5806 /* If this reloc is against an external symbol, we do not want to
5807 fiddle with the addend. Otherwise, we need to include the symbol
5827 /* A call to an undefined weak symbol is converted to a jump to
5829 The jump to the next instruction is optimized as a NOP.
5837 /* If the call goes through a PLT entry, make sure to
5838 check distance to the right destination address. */
5843 /* Check if a stub has to be inserted because the destination
5847 /* If the branch destination is directed to plt stub, "value" will be
5849 contain non-zero value, for example call to local function symbol
5854 /* The target is out of reach, so redirect the branch to
5864 /* We have redirected the destination to stub entry address,
5902 h->root.root.string);
5918 (_("%pB: conditional branch to undefined symbol `%s' "
5919 "not allowed"), input_bfd, h->root.root.string);
6022 linking stage. While for shared library, we need to update the
6023 content of GOT entry according to the shared object's runtime
6024 base address. So, we need to generate a R_AARCH64_RELATIVE reloc
6032 /* Update the relocation value to GOT entry addr as we have transformed
6121 h->root.root.string);
6158 h->root.root.string);
6254 /* Structure to hold payload for _bfd_aarch64_erratum_843419_clear_stub,
6255 it is used to identify the stub information to reset. */
6265 stub_type to none. */
6293 sequence. In this case the erratum no longer applies and we need to remove
6317 is to then call final_link_relocate. Return other values in the
6345 /* We have relaxed the adrp into a mov, we may have to clear any
6427 /* Move the current relocation to the second instruction in
6557 /* We choose to fixup the BL and NOP instructions using the
6558 offset from the second relocation to allow flexibility in
6638 /* We have relaxed the adrp into a mov, we may have to clear any
6778 /* An object file might have a reference to a local
6825 name = h->root.root.string;
6853 from a reloc type to another.
6873 same offset. In that case we are supposed to treat the
6956 relocation to fixup the tls offset at load
7078 section to hold our R_AARCH64_TLSDESC, the next
7121 h->root.root.string);
7155 enum does not have a value to cover that situation).
7157 Try to catch this situation here and provide a more helpful
7158 error message to the user. */
7212 /* Set the right machine number. */
7225 /* Function to keep AArch64 specific flags in the ELF header. */
7242 /* Merge backend specific data from an object file to the output
7262 /* The following seems bogus to me -- The flags are initialized in
7274 architecture, instead allow future merges to do this. If no
7277 to the default values. */
7297 /* Check to see if the input BFD actually contains any sections. If
7303 Also check to see if there are no code sections in the input.
7304 In this case there is no need to check for code specific flags.
7305 XXX - do we need to worry about floating-point format compatability
7368 /* If there is any pc-relative reference, we need to keep copy relocation
7369 to avoid propagating the relocation into runtime that current glibc
7385 dynamic object, but we're not including those sections. We have to
7386 change the definition to something the rest of the link can
7408 an input file, but the symbol wasn't referred to
7419 /* Otherwise, reset to -1. */
7424 processor independent code will have arranged for us to see the
7438 only references to the symbol are via the global offset table.
7444 /* If there are no references to this symbol that do not use the
7445 GOT, we don't need to generate a copy reloc. */
7473 from the dynamic object to this symbol will go through the global
7474 offset table. The dynamic linker will use the .dynsym entry to
7476 both the dynamic object and the regular object will refer to the
7481 /* We must generate a R_AARCH64_COPY reloc to tell the dynamic linker
7482 to copy the initial value out of the dynamic object and into the
7505 elfNN_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
7512 bfd_zalloc (abfd, number * sizeof (struct elf_aarch64_local_symbol));
7520 /* Create the .got section to hold the global offset table. */
7558 because we don't want to define the symbol if we are not creating
7665 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
7667 when calculating the pc-relative address to .got section which is
7668 used to initialize the gp register. */
7669 if (h->root.root.string
7670 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7739 (h) ? h->root.root.string : "a local symbol");
7758 (h) ? h->root.root.string : "a local symbol");
7783 /* We don't need to handle relocs into sections not going into
7797 /* No need to do anything if we're not creating a shared
7801 may need to keep relocations for symbols satisfied by a
7802 dynamic library if we manage to avoid copy relocs for the
7812 information to make correct decision later in
7841 /* If this is a global symbol, we count the number of
7850 We really need local syms available to do this
7891 /* RR: We probably want to keep a consistency check that
7962 are able to relax. Turn off the GD flag, without
8021 function size and set *CODE_OFF to the function's entry point,
8118 _bfd_error_handler (_("%pB symbol number %lu references"
8152 /* There ought to be a place to keep ELF backend specific flags, but
8172 /* A structure used to record a list of sections, independently
8182 /* Unfortunately we need to keep a list of sections for which
8185 to be called on a section which has had an elf_data_structure
8214 to the sections_with_aarch64_elf_section_data list in forward order and
8216 to the ld-srec/sec64k.exp linker test. */
8231 /* Record the entry prior to this one - it is the entry we are
8232 most likely to want to locate next time. Also this way if we
8235 be caching a pointer that is about to be freed. */
8322 /* Massage our args to the form they really have. */
8328 /* Ensure this stub is attached to the current section being
8498 /* We need to create .got section. */
8521 There is no need to process bfd_link_hash_indirect symbols here
8524 called to copy all relevant data from the generic to the concrete
8563 not generating a shared library, then set the symbol to this
8564 location in the .plt. This is required to make function
8574 small model PLT entries. We later need to find a way
8578 /* We also need to make an entry in the .got.plt section, which
8582 /* We also need to make an entry in the .rela.plt section. */
8585 /* We need to ensure that all GOT entries that serve the PLT
8590 sizing we adjust reloc_count to indicate the number of
8650 /* Undefined weak symbol in static PIE resolves to 0 without
8726 p->sec->owner, h->root.root.string);
8732 dynamic pc-relative relocs against symbols which turn out to be
8734 space for pc-relative relocs that have become local due to symbol
8741 We want calls to protected symbols to resolve directly to the
8743 function pointer comparisons to work as expected then they
8781 symbols which turn out to need copy relocs or are not
8839 There is no need to process bfd_link_hash_indirect symbols here
8842 called to copy all relevant data from the generic to the concrete
8938 it is a copy of a linkonce section or due to
9033 it's not incremented, so in order to compute the space reserved
9034 for them, it suffices to multiply the reloc count by the jump
9059 /* Init mapping symbols information to use later to distingush between
9094 to copy relocs into the output file. */
9107 output file. This is mostly to handle .rela.bss and
9110 before the linker maps input sections to output
9113 function which decides whether anything needs to go
9134 /* Add some entries to the .dynamic section. We fill in the
9212 corresponds to this symbol. This is the index of this symbol
9217 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
9265 /* All the GOTPLT Entries are essentially initialized to PLT0. */
9292 /* Compute the relocation entry to used based on PLT index and do
9294 to account for this entry. */
9299 /* Size sections even though they're not dynamic. We use it to setup
9393 /* If the symbol is weak we need to clear the value.
9398 (this is a clue for the dynamic linker, to make function
9408 /* Undefined weak symbol in static PIE resolves to 0 without
9545 PLT0 will be slightly different in ELF32 due to different got entry
9554 /* PR 26312: Explicitly set the sh_entsize to 0 so that
9870 It also allows a period initiated suffix to be added to the symbol, ie:
9880 longer conform to the ARM ELF ABI. */
9889 "strip --strip-unneeded" tool. These symbols might needed in order to
9891 it should be safe to remove them. */
9903 wrapper function for _bfd_aarch64_elf_link_setup_gnu_properties to account
9918 wrapper function for _bfd_aarch64_elf_merge_gnu_properties to account
9938 if ((aprop && !(aprop->u.number & GNU_PROPERTY_AARCH64_FEATURE_1_BTI))
9945 if ((bprop && !(bprop->u.number & GNU_PROPERTY_AARCH64_FEATURE_1_BTI))
10052 to them in our hash. */