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
2582 /* A pointer to the most recently used stub hash entry against this
2612 #define aarch64_stub_hash_lookup(table, string, create, copy) \
2614 bfd_hash_lookup ((table), (string), (create), (copy)))
2622 /* Nonzero to force PIC branch veneers. */
2634 /* The number of bytes in the initial entry in the PLT. */
2640 /* The number of bytes in the subsequent PLT entries. */
2663 /* Array to keep track of which stub sections have been created, and
2667 /* This is the section to which stubs in the group will be
2682 /* The number of bytes in the PLT enty for the TLS descriptor. */
2695 const char *string)
2711 table, string));
2727 struct bfd_hash_table *table, const char *string)
2741 entry = bfd_hash_newfunc (entry, table, string);
2870 h->root.root.string, isym_sto);
3000 /* We don't want to redirect any old unconditional jump in this way,
3002 acceptable for the IP0 and IP1 registers to be clobbered. */
3026 len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 16 + 1;
3031 hash->root.root.root.string,
3051 functions, the function symbols are not added to the hash table. */
3085 Stub names need to include a section id, as there may well be
3086 more than one stub used to reach say, printf, and we need to
3139 Fix or create the stub section used to collect stubs attached to
3166 section to the stub hash. Not all fields of the new stub entry are
3199 /* Add a new stub entry in the final stub section to the stub hash.
3247 /* Massage our args to the form they really have. */
3252 /* Fail if the target section could not be assigned to an output
3256 info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
3330 /* We want the value relative to the address 12 bytes back from the
3376 /* Massage our args to the form they really have. */
3429 /* Count the number of input BFDs and find the top input section id. */
3448 /* We can't use output_bfd->section_count here to find the top output
3487 Build lists of input sections to determine groupings between which
3503 /* This happens to make the list in reverse order,
3512 sections may result in fewer stubs. More importantly, we need to
3565 /* Add NEXT to the group. */
3569 /* OK, the size from the start to the start of CURR is less
3574 stubs added here, as stubs contribute to the final output
3584 /* But wait, there's more! Input sections up to stub_group_size
3596 /* Add NEXT to the stub group. */
3654 is set equal to RT.
3805 it is possible for a 64-bit multiply-accumulate instruction to generate an
3806 incorrect result. The details are quite complex and hard to
3812 the original instruction with a branch to the patch. This function checks
3856 /* Used to order a list of mapping symbols by address. */
3990 /* Helper predicate to look for cortex-a53 erratum 843419 sequence 1. */
4013 seen set P_VENEER_I to the offset of the final LOAD/STORE
4083 /* Add space for a branch. Add 8 bytes to keep section 8 byte aligned,
4089 4096. This is important in order to ensure that the insertion
4147 attached to the input section in which an erratum sequence has
4151 copied instruction will have had any relocations applied to it.
4181 Return TRUE on successful scan, FALSE on failure to scan.
4259 The basic idea here is to examine all the relocations looking for
4260 PC-relative calls to a target that is unreachable with a "bl"
4278 /* Propagate mach to stub bfd, because it may not have been
4369 /* Walk over each section attached to the input bfd. */
4376 to do. */
4497 use the PLT stub as target address to
4521 target address to decide whether a long
4547 sym_name = hash->root.root.root.string;
4619 /* Ask the linker to do its stuff. */
4631 stubs are kept in a hash table attached to the main linker hash
4654 /* Allocate memory to hold the linker stubs. */
4661 /* Add a branch around the stub section, and a nop, to keep it 8 byte
4676 /* Add an entry to the code/data map for section SEC. */
4728 should contain the number of local symbols, which should come before any
4863 the least significant bit to record whether we have
4866 entry to initialize the value. This is done in the
4885 /* Change R_TYPE to a more efficient access model where possible,
5109 referred to in h. */
5155 referred to in h. */
5210 /* Helper to insert branches to erratum 835769 stubs in the right
5289 we're allowed to use the ADRP errata workaround, otherwise it is not
5378 /* Fix code to point to erratum 835769 stubs. */
5463 which refer to the same offset. */
5495 if (h->root.root.string)
5496 name = h->root.root.string;
5519 if (h->root.root.string)
5520 name = h->root.root.string;
5535 if (h->root.root.string)
5536 name = h->root.root.string;
5556 /* Need a dynamic relocation to get the real function
5589 do not want to fiddle with the addend. Otherwise,
5590 we need to include the symbol value so that it
5623 /* We can't use h->got.offset here to save state, or
5648 we use the least significant bit to record
5652 relocation entry to initialize the value. This
5702 relocations are copied into the output file to be resolved at
5711 /* Or we are creating an executable, we may need to keep relocations
5712 for symbols satisfied by a dynamic library if we manage to avoid
5786 /* Sanity to check that we have previously allocated
5788 number of relocations we actually want to emit. */
5792 /* If this reloc is against an external symbol, we do not want to
5793 fiddle with the addend. Otherwise, we need to include the symbol
5813 /* A call to an undefined weak symbol is converted to a jump to
5815 The jump to the next instruction is optimized as a NOP.
5823 /* If the call goes through a PLT entry, make sure to
5824 check distance to the right destination address. */
5829 /* Check if a stub has to be inserted because the destination
5833 /* If the branch destination is directed to plt stub, "value" will be
5835 contain non-zero value, for example call to local function symbol
5840 /* The target is out of reach, so redirect the branch to
5850 /* We have redirected the destination to stub entry address,
5888 h->root.root.string);
5904 (_("%pB: conditional branch to undefined symbol `%s' "
5905 "not allowed"), input_bfd, h->root.root.string);
6008 linking stage. While for shared library, we need to update the
6009 content of GOT entry according to the shared object's runtime
6010 base address. So, we need to generate a R_AARCH64_RELATIVE reloc
6018 /* Update the relocation value to GOT entry addr as we have transformed
6107 h->root.root.string);
6144 h->root.root.string);
6240 /* Structure to hold payload for _bfd_aarch64_erratum_843419_clear_stub,
6241 it is used to identify the stub information to reset. */
6251 stub_type to none. */
6279 sequence. In this case the erratum no longer applies and we need to remove
6303 is to then call final_link_relocate. Return other values in the
6331 /* We have relaxed the adrp into a mov, we may have to clear any
6413 /* Move the current relocation to the second instruction in
6543 /* We choose to fixup the BL and NOP instructions using the
6544 offset from the second relocation to allow flexibility in
6624 /* We have relaxed the adrp into a mov, we may have to clear any
6764 /* An object file might have a reference to a local
6811 name = h->root.root.string;
6839 from a reloc type to another.
6859 same offset. In that case we are supposed to treat the
6942 relocation to fixup the tls offset at load
7064 section to hold our R_AARCH64_TLSDESC, the next
7107 h->root.root.string);
7141 enum does not have a value to cover that situation).
7143 Try to catch this situation here and provide a more helpful
7144 error message to the user. */
7198 /* Set the right machine number. */
7211 /* Function to keep AArch64 specific flags in the ELF header. */
7228 /* Merge backend specific data from an object file to the output
7248 /* The following seems bogus to me -- The flags are initialized in
7260 architecture, instead allow future merges to do this. If no
7263 to the default values. */
7283 /* Check to see if the input BFD actually contains any sections. If
7289 Also check to see if there are no code sections in the input.
7290 In this case there is no need to check for code specific flags.
7291 XXX - do we need to worry about floating-point format compatability
7354 /* If there is any pc-relative reference, we need to keep copy relocation
7355 to avoid propagating the relocation into runtime that current glibc
7371 dynamic object, but we're not including those sections. We have to
7372 change the definition to something the rest of the link can
7394 an input file, but the symbol wasn't referred to
7405 /* Otherwise, reset to -1. */
7410 processor independent code will have arranged for us to see the
7424 only references to the symbol are via the global offset table.
7430 /* If there are no references to this symbol that do not use the
7431 GOT, we don't need to generate a copy reloc. */
7459 from the dynamic object to this symbol will go through the global
7460 offset table. The dynamic linker will use the .dynsym entry to
7462 both the dynamic object and the regular object will refer to the
7467 /* We must generate a R_AARCH64_COPY reloc to tell the dynamic linker
7468 to copy the initial value out of the dynamic object and into the
7491 elfNN_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
7498 bfd_zalloc (abfd, number * sizeof (struct elf_aarch64_local_symbol));
7506 /* Create the .got section to hold the global offset table. */
7544 because we don't want to define the symbol if we are not creating
7651 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
7653 when calculating the pc-relative address to .got section which is
7654 used to initialize the gp register. */
7655 if (h->root.root.string
7656 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7725 (h) ? h->root.root.string : "a local symbol");
7744 (h) ? h->root.root.string : "a local symbol");
7769 /* We don't need to handle relocs into sections not going into
7783 /* No need to do anything if we're not creating a shared
7787 may need to keep relocations for symbols satisfied by a
7788 dynamic library if we manage to avoid copy relocs for the
7798 information to make correct decision later in
7827 /* If this is a global symbol, we count the number of
7836 We really need local syms available to do this
7877 /* RR: We probably want to keep a consistency check that
7948 are able to relax. Turn off the GD flag, without
8007 function size and set *CODE_OFF to the function's entry point,
8096 _bfd_error_handler (_("%pB symbol number %lu references"
8130 /* There ought to be a place to keep ELF backend specific flags, but
8150 /* A structure used to record a list of sections, independently
8160 /* Unfortunately we need to keep a list of sections for which
8163 to be called on a section which has had an elf_data_structure
8192 to the sections_with_aarch64_elf_section_data list in forward order and
8194 to the ld-srec/sec64k.exp linker test. */
8209 /* Record the entry prior to this one - it is the entry we are
8210 most likely to want to locate next time. Also this way if we
8213 be caching a pointer that is about to be freed. */
8300 /* Massage our args to the form they really have. */
8306 /* Ensure this stub is attached to the current section being
8476 /* We need to create .got section. */
8499 There is no need to process bfd_link_hash_indirect symbols here
8502 called to copy all relevant data from the generic to the concrete
8541 not generating a shared library, then set the symbol to this
8542 location in the .plt. This is required to make function
8552 small model PLT entries. We later need to find a way
8556 /* We also need to make an entry in the .got.plt section, which
8560 /* We also need to make an entry in the .rela.plt section. */
8563 /* We need to ensure that all GOT entries that serve the PLT
8568 sizing we adjust reloc_count to indicate the number of
8628 /* Undefined weak symbol in static PIE resolves to 0 without
8694 dynamic pc-relative relocs against symbols which turn out to be
8696 space for pc-relative relocs that have become local due to symbol
8703 We want calls to protected symbols to resolve directly to the
8705 function pointer comparisons to work as expected then they
8743 symbols which turn out to need copy relocs or are not
8801 There is no need to process bfd_link_hash_indirect symbols here
8804 called to copy all relevant data from the generic to the concrete
8900 it is a copy of a linkonce section or due to
8995 it's not incremented, so in order to compute the space reserved
8996 for them, it suffices to multiply the reloc count by the jump
9021 /* Init mapping symbols information to use later to distingush between
9056 to copy relocs into the output file. */
9069 output file. This is mostly to handle .rela.bss and
9072 before the linker maps input sections to output
9075 function which decides whether anything needs to go
9096 /* Add some entries to the .dynamic section. We fill in the
9174 corresponds to this symbol. This is the index of this symbol
9179 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
9227 /* All the GOTPLT Entries are essentially initialized to PLT0. */
9254 /* Compute the relocation entry to used based on PLT index and do
9256 to account for this entry. */
9261 /* Size sections even though they're not dynamic. We use it to setup
9355 /* If the symbol is weak we need to clear the value.
9360 (this is a clue for the dynamic linker, to make function
9370 /* Undefined weak symbol in static PIE resolves to 0 without
9507 PLT0 will be slightly different in ELF32 due to different got entry
9516 /* PR 26312: Explicitly set the sh_entsize to 0 so that
9830 It also allows a period initiated suffix to be added to the symbol, ie:
9840 longer conform to the ARM ELF ABI. */
9849 "strip --strip-unneeded" tool. These symbols might needed in order to
9851 it should be safe to remove them. */
9863 wrapper function for _bfd_aarch64_elf_link_setup_gnu_properties to account
9878 wrapper function for _bfd_aarch64_elf_merge_gnu_properties to account
9898 if ((aprop && !(aprop->u.number & GNU_PROPERTY_AARCH64_FEATURE_1_BTI))
9905 if ((bprop && !(bprop->u.number & GNU_PROPERTY_AARCH64_FEATURE_1_BTI))
10013 to them in our hash. */