1/* BFD back-end data structures for ELF files. 2 Copyright (C) 1992-2022 Free Software Foundation, Inc. 3 Written by Cygnus Support. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22#ifndef _LIBELF_H_ 23#define _LIBELF_H_ 1 24 25#include <stdlib.h> 26 27#include "elf/common.h" 28#include "elf/external.h" 29#include "elf/internal.h" 30#include "bfdlink.h" 31 32#ifndef ENABLE_CHECKING 33#define ENABLE_CHECKING 0 34#endif 35 36#ifdef __cplusplus 37extern "C" { 38#endif 39 40/* The number of entries in a section is its size divided by the size 41 of a single entry. This is normally only applicable to reloc and 42 symbol table sections. 43 PR 9934: It is possible to have relocations that do not refer to 44 symbols, thus it is also possible to have a relocation section in 45 an object file, but no symbol table. */ 46#define NUM_SHDR_ENTRIES(shdr) ((shdr)->sh_entsize > 0 ? (shdr)->sh_size / (shdr)->sh_entsize : 0) 47 48/* If size isn't specified as 64 or 32, NAME macro should fail. */ 49#ifndef NAME 50#if ARCH_SIZE == 64 51#define NAME(x, y) x ## 64 ## _ ## y 52#endif 53#if ARCH_SIZE == 32 54#define NAME(x, y) x ## 32 ## _ ## y 55#endif 56#endif 57 58#ifndef NAME 59#define NAME(x, y) x ## NOSIZE ## _ ## y 60#endif 61 62#define ElfNAME(X) NAME(Elf,X) 63#define elfNAME(X) NAME(elf,X) 64 65/* Information held for an ELF symbol. The first field is the 66 corresponding asymbol. Every symbol is an ELF file is actually a 67 pointer to this structure, although it is often handled as a 68 pointer to an asymbol. */ 69 70typedef struct 71{ 72 /* The BFD symbol. */ 73 asymbol symbol; 74 /* ELF symbol information. */ 75 Elf_Internal_Sym internal_elf_sym; 76 /* Backend specific information. */ 77 union 78 { 79 unsigned int hppa_arg_reloc; 80 void *mips_extr; 81 void *any; 82 } 83 tc_data; 84 85 /* Version information. This is from an Elf_Internal_Versym 86 structure in a SHT_GNU_versym section. It is zero if there is no 87 version information. */ 88 unsigned short version; 89 90} elf_symbol_type; 91 92struct elf_strtab_hash; 93struct got_entry; 94struct plt_entry; 95 96union gotplt_union 97 { 98 bfd_signed_vma refcount; 99 bfd_vma offset; 100 struct got_entry *glist; 101 struct plt_entry *plist; 102 }; 103 104struct elf_link_virtual_table_entry 105 { 106 /* Virtual table entry use information. This array is nominally of size 107 size/sizeof(target_void_pointer), though we have to be able to assume 108 and track a size while the symbol is still undefined. It is indexed 109 via offset/sizeof(target_void_pointer). */ 110 size_t size; 111 bool *used; 112 113 /* Virtual table derivation info. */ 114 struct elf_link_hash_entry *parent; 115 }; 116 117/* ELF symbol version. */ 118enum elf_symbol_version 119 { 120 unknown = 0, 121 unversioned, 122 versioned, 123 versioned_hidden 124 }; 125 126/* ELF linker hash table entries. */ 127 128struct elf_link_hash_entry 129{ 130 struct bfd_link_hash_entry root; 131 132 /* Symbol index in output file. This is initialized to -1. It is 133 set to -2 if the symbol is used by a reloc. It is set to -3 if 134 this symbol is defined in a discarded section. */ 135 long indx; 136 137 /* Symbol index as a dynamic symbol. Initialized to -1, and remains 138 -1 if this is not a dynamic symbol. */ 139 /* ??? Note that this is consistently used as a synonym for tests 140 against whether we can perform various simplifying transformations 141 to the code. (E.g. changing a pc-relative jump to a PLT entry 142 into a pc-relative jump to the target function.) That test, which 143 is often relatively complex, and someplaces wrong or incomplete, 144 should really be replaced by a predicate in elflink.c. 145 146 End result: this field -1 does not indicate that the symbol is 147 not in the dynamic symbol table, but rather that the symbol is 148 not visible outside this DSO. */ 149 long dynindx; 150 151 /* If this symbol requires an entry in the global offset table, the 152 processor specific backend uses this field to track usage and 153 final offset. Two schemes are supported: The first assumes that 154 a symbol may only have one GOT entry, and uses REFCOUNT until 155 size_dynamic_sections, at which point the contents of the .got is 156 fixed. Afterward, if OFFSET is -1, then the symbol does not 157 require a global offset table entry. The second scheme allows 158 multiple GOT entries per symbol, managed via a linked list 159 pointed to by GLIST. */ 160 union gotplt_union got; 161 162 /* Same, but tracks a procedure linkage table entry. */ 163 union gotplt_union plt; 164 165 /* Symbol size. NB: All fields starting from here are cleared by 166 _bfd_elf_link_hash_newfunc. */ 167 bfd_size_type size; 168 169 /* Track dynamic relocs copied for this symbol. */ 170 struct elf_dyn_relocs *dyn_relocs; 171 172 /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.). */ 173 unsigned int type : 8; 174 175 /* Symbol st_other value, symbol visibility. */ 176 unsigned int other : 8; 177 178 /* The symbol's st_target_internal value (see Elf_Internal_Sym). */ 179 unsigned int target_internal : 8; 180 181 /* Symbol is referenced by a non-shared object (other than the object 182 in which it is defined). */ 183 unsigned int ref_regular : 1; 184 /* Symbol is defined by a non-shared object. */ 185 unsigned int def_regular : 1; 186 /* Symbol is referenced by a shared object. */ 187 unsigned int ref_dynamic : 1; 188 /* Symbol is defined by a shared object. */ 189 unsigned int def_dynamic : 1; 190 /* Symbol has a non-weak reference from a non-shared object (other than 191 the object in which it is defined). */ 192 unsigned int ref_regular_nonweak : 1; 193 /* Symbol has a non-weak reference from a LTO IR object file. */ 194 unsigned int ref_ir_nonweak : 1; 195 /* Dynamic symbol has been adjustd. */ 196 unsigned int dynamic_adjusted : 1; 197 /* Symbol needs a copy reloc. */ 198 unsigned int needs_copy : 1; 199 /* Symbol needs a procedure linkage table entry. */ 200 unsigned int needs_plt : 1; 201 /* Symbol appears in a non-ELF input file. */ 202 unsigned int non_elf : 1; 203 /* Symbol version information. */ 204 ENUM_BITFIELD (elf_symbol_version) versioned : 2; 205 /* Symbol was forced to local scope due to a version script file. */ 206 unsigned int forced_local : 1; 207 /* Symbol was forced to be dynamic due to a version script file. */ 208 unsigned int dynamic : 1; 209 /* Symbol was marked during garbage collection. */ 210 unsigned int mark : 1; 211 /* Symbol is referenced by a non-GOT/non-PLT relocation. This is 212 not currently set by all the backends. */ 213 unsigned int non_got_ref : 1; 214 /* Symbol has a definition in a shared object. 215 FIXME: There is no real need for this field if def_dynamic is never 216 cleared and all places that test def_dynamic also test def_regular. */ 217 unsigned int dynamic_def : 1; 218 /* Symbol has a non-weak reference from a shared object. */ 219 unsigned int ref_dynamic_nonweak : 1; 220 /* Symbol is referenced with a relocation where C/C++ pointer equality 221 matters. */ 222 unsigned int pointer_equality_needed : 1; 223 /* Symbol is a unique global symbol. */ 224 unsigned int unique_global : 1; 225 /* Symbol is defined by a shared library with non-default visibility 226 in a read/write section. */ 227 unsigned int protected_def : 1; 228 /* Symbol is __start_SECNAME or __stop_SECNAME to mark section 229 SECNAME. */ 230 unsigned int start_stop : 1; 231 /* Symbol is or was a weak defined symbol from a dynamic object with 232 a strong defined symbol alias. U.ALIAS points to a list of aliases, 233 the definition having is_weakalias clear. */ 234 unsigned int is_weakalias : 1; 235 236 /* String table index in .dynstr if this is a dynamic symbol. */ 237 unsigned long dynstr_index; 238 239 union 240 { 241 /* Points to a circular list of non-function symbol aliases. */ 242 struct elf_link_hash_entry *alias; 243 244 /* Hash value of the name computed using the ELF hash function. 245 Used part way through size_dynamic_sections, after we've finished 246 with aliases. */ 247 unsigned long elf_hash_value; 248 } u; 249 250 /* Version information. */ 251 union 252 { 253 /* This field is used for a symbol which is not defined in a 254 regular object. It points to the version information read in 255 from the dynamic object. */ 256 Elf_Internal_Verdef *verdef; 257 /* This field is used for a symbol which is defined in a regular 258 object. It is set up in size_dynamic_sections. It points to 259 the version information we should write out for this symbol. */ 260 struct bfd_elf_version_tree *vertree; 261 } verinfo; 262 263 union 264 { 265 /* For __start_SECNAME and __stop_SECNAME symbols, record the first 266 input section whose section name is SECNAME. */ 267 asection *start_stop_section; 268 269 /* Vtable information. */ 270 struct elf_link_virtual_table_entry *vtable; 271 } u2; 272}; 273 274/* Return the strong definition for a weak symbol with aliases. */ 275 276static inline struct elf_link_hash_entry * 277weakdef (struct elf_link_hash_entry *h) 278{ 279 while (h->is_weakalias) 280 h = h->u.alias; 281 return h; 282} 283 284/* Will references to this symbol always reference the symbol 285 in this object? */ 286#define SYMBOL_REFERENCES_LOCAL(INFO, H) \ 287 _bfd_elf_symbol_refs_local_p (H, INFO, 0) 288 289/* Will _calls_ to this symbol always call the version in this object? */ 290#define SYMBOL_CALLS_LOCAL(INFO, H) \ 291 _bfd_elf_symbol_refs_local_p (H, INFO, 1) 292 293/* Whether an undefined weak symbol should resolve to its link-time 294 value, even in PIC or PIE objects. The linker_def test is to 295 handle symbols like __ehdr_start that may be undefweak in early 296 stages of linking but are guaranteed to be defined later. */ 297#define UNDEFWEAK_NO_DYNAMIC_RELOC(INFO, H) \ 298 ((H)->root.type == bfd_link_hash_undefweak \ 299 && !(H)->root.linker_def \ 300 && (ELF_ST_VISIBILITY ((H)->other) != STV_DEFAULT \ 301 || (INFO)->dynamic_undefined_weak == 0)) 302 303/* Common symbols that are turned into definitions don't have the 304 DEF_REGULAR flag set, so they might appear to be undefined. 305 Symbols defined in linker scripts also don't have DEF_REGULAR set. */ 306#define ELF_COMMON_DEF_P(H) \ 307 (!(H)->def_regular \ 308 && !(H)->def_dynamic \ 309 && (H)->root.type == bfd_link_hash_defined) 310 311/* Records local symbols to be emitted in the dynamic symbol table. */ 312 313struct elf_link_local_dynamic_entry 314{ 315 struct elf_link_local_dynamic_entry *next; 316 317 /* The input bfd this symbol came from. */ 318 bfd *input_bfd; 319 320 /* The index of the local symbol being copied. */ 321 long input_indx; 322 323 /* The index in the outgoing dynamic symbol table. */ 324 long dynindx; 325 326 /* A copy of the input symbol. */ 327 Elf_Internal_Sym isym; 328}; 329 330struct elf_link_loaded_list 331{ 332 struct elf_link_loaded_list *next; 333 bfd *abfd; 334}; 335 336/* Structures used by the eh_frame optimization code. */ 337struct eh_cie_fde 338{ 339 union { 340 struct { 341 /* If REMOVED == 1, this is the CIE that the FDE originally used. 342 The CIE belongs to the same .eh_frame input section as the FDE. 343 344 If REMOVED == 0, this is the CIE that we have chosen to use for 345 the output FDE. The CIE's REMOVED field is also 0, but the CIE 346 might belong to a different .eh_frame input section from the FDE. 347 348 May be NULL to signify that the FDE should be discarded. */ 349 struct eh_cie_fde *cie_inf; 350 struct eh_cie_fde *next_for_section; 351 } fde; 352 struct { 353 /* CIEs have three states: 354 355 - REMOVED && !MERGED: Slated for removal because we haven't yet 356 proven that an FDE needs it. FULL_CIE, if nonnull, points to 357 more detailed information about the CIE. 358 359 - REMOVED && MERGED: We have merged this CIE with MERGED_WITH, 360 which may not belong to the same input section. 361 362 - !REMOVED: We have decided to keep this CIE. SEC is the 363 .eh_frame input section that contains the CIE. */ 364 union { 365 struct cie *full_cie; 366 struct eh_cie_fde *merged_with; 367 asection *sec; 368 } u; 369 370 /* The offset of the personality data from the start of the CIE, 371 or 0 if the CIE doesn't have any. */ 372 unsigned int personality_offset : 8; 373 374 /* Length of augmentation. aug_str_len is the length of the 375 string including null terminator. aug_data_len is the length 376 of the rest up to the initial insns. */ 377 unsigned int aug_str_len : 3; 378 unsigned int aug_data_len : 5; 379 380 /* True if we have marked relocations associated with this CIE. */ 381 unsigned int gc_mark : 1; 382 383 /* True if we have decided to turn an absolute LSDA encoding into 384 a PC-relative one. */ 385 unsigned int make_lsda_relative : 1; 386 387 /* True if we have decided to turn an absolute personality 388 encoding into a PC-relative one. */ 389 unsigned int make_per_encoding_relative : 1; 390 391 /* True if the CIE contains personality data and if that 392 data uses a PC-relative encoding. Always true when 393 make_per_encoding_relative is. */ 394 unsigned int per_encoding_relative : 1; 395 396 /* True if the CIE contains personality data aligned to a 397 multiple of eight bytes. */ 398 unsigned int per_encoding_aligned8 : 1; 399 400 /* True if we need to add an 'R' (FDE encoding) entry to the 401 CIE's augmentation data. */ 402 unsigned int add_fde_encoding : 1; 403 404 /* True if we have merged this CIE with another. */ 405 unsigned int merged : 1; 406 407 /* Unused bits. */ 408 unsigned int pad1 : 9; 409 } cie; 410 } u; 411 unsigned int reloc_index; 412 unsigned int size; 413 unsigned int offset; 414 unsigned int new_offset; 415 unsigned int fde_encoding : 8; 416 unsigned int lsda_encoding : 8; 417 unsigned int lsda_offset : 8; 418 419 /* True if this entry represents a CIE, false if it represents an FDE. */ 420 unsigned int cie : 1; 421 422 /* True if this entry is currently marked for removal. */ 423 unsigned int removed : 1; 424 425 /* True if we need to add a 'z' (augmentation size) entry to the CIE's 426 augmentation data, and an associated byte to each of the CIE's FDEs. */ 427 unsigned int add_augmentation_size : 1; 428 429 /* True if we have decided to convert absolute FDE relocations into 430 relative ones. This applies to the first relocation in the FDE, 431 which is against the code that the FDE describes. */ 432 unsigned int make_relative : 1; 433 434 /* Unused bits. */ 435 unsigned int pad1 : 4; 436 437 unsigned int *set_loc; 438}; 439 440struct eh_frame_sec_info 441{ 442 unsigned int count; 443 struct cie *cies; 444 struct eh_cie_fde entry[1]; 445}; 446 447struct eh_frame_array_ent 448{ 449 bfd_vma initial_loc; 450 bfd_size_type range; 451 bfd_vma fde; 452}; 453 454struct htab; 455 456#define DWARF2_EH_HDR 1 457#define COMPACT_EH_HDR 2 458 459/* Endian-neutral code indicating that a function cannot be unwound. */ 460#define COMPACT_EH_CANT_UNWIND_OPCODE 0x015d5d01 461 462struct dwarf_eh_frame_hdr_info 463{ 464 struct htab *cies; 465 unsigned int fde_count; 466 /* TRUE if .eh_frame_hdr should contain the sorted search table. 467 We build it if we successfully read all .eh_frame input sections 468 and recognize them. */ 469 bool table; 470 struct eh_frame_array_ent *array; 471}; 472 473struct compact_eh_frame_hdr_info 474{ 475 unsigned int allocated_entries; 476 /* eh_frame_entry fragments. */ 477 asection **entries; 478}; 479 480struct eh_frame_hdr_info 481{ 482 asection *hdr_sec; 483 unsigned int array_count; 484 bool frame_hdr_is_compact; 485 union 486 { 487 struct dwarf_eh_frame_hdr_info dwarf; 488 struct compact_eh_frame_hdr_info compact; 489 } 490 u; 491}; 492 493/* Additional information for each function (used at link time). */ 494struct sframe_func_bfdinfo 495{ 496 /* Whether the function has been discarded from the final output. */ 497 bool func_deleted_p; 498 /* Relocation offset. */ 499 unsigned int func_r_offset; 500 /* Relocation index. */ 501 unsigned int func_reloc_index; 502}; 503 504/* SFrame decoder info. 505 Contains all information for a decoded .sframe section. */ 506struct sframe_dec_info 507{ 508 /* Decoder context. */ 509 struct sframe_decoder_ctx *sfd_ctx; 510 /* Number of function descriptor entries in this .sframe. */ 511 unsigned int sfd_fde_count; 512 /* Additional information for linking. */ 513 struct sframe_func_bfdinfo *sfd_func_bfdinfo; 514}; 515 516/* SFrame encoder info. 517 Contains all information for an encoded .sframe section to be 518 written out. */ 519struct sframe_enc_info 520{ 521 /* Encoder context. */ 522 struct sframe_encoder_ctx *sfe_ctx; 523 /* Output section. */ 524 asection *sframe_section; 525}; 526 527/* Enum used to identify target specific extensions to the elf_obj_tdata 528 and elf_link_hash_table structures. Note the enums deliberately start 529 from 1 so that we can detect an uninitialized field. The generic value 530 is last so that additions to this enum do not need to modify more than 531 one line. */ 532enum elf_target_id 533{ 534 AARCH64_ELF_DATA = 1, 535 ALPHA_ELF_DATA, 536 AMDGCN_ELF_DATA, 537 ARC_ELF_DATA, 538 ARM_ELF_DATA, 539 AVR_ELF_DATA, 540 BFIN_ELF_DATA, 541 CRIS_ELF_DATA, 542 CSKY_ELF_DATA, 543 FRV_ELF_DATA, 544 HPPA32_ELF_DATA, 545 HPPA64_ELF_DATA, 546 I386_ELF_DATA, 547 IA64_ELF_DATA, 548 LM32_ELF_DATA, 549 LARCH_ELF_DATA, 550 M32R_ELF_DATA, 551 M68HC11_ELF_DATA, 552 M68K_ELF_DATA, 553 METAG_ELF_DATA, 554 MICROBLAZE_ELF_DATA, 555 MIPS_ELF_DATA, 556 MN10300_ELF_DATA, 557 NDS32_ELF_DATA, 558 NIOS2_ELF_DATA, 559 OR1K_ELF_DATA, 560 PPC32_ELF_DATA, 561 PPC64_ELF_DATA, 562 PRU_ELF_DATA, 563 S390_ELF_DATA, 564 SH_ELF_DATA, 565 SPARC_ELF_DATA, 566 SPU_ELF_DATA, 567 TIC6X_ELF_DATA, 568 X86_64_ELF_DATA, 569 XTENSA_ELF_DATA, 570 TILEGX_ELF_DATA, 571 TILEPRO_ELF_DATA, 572 RISCV_ELF_DATA, 573 GENERIC_ELF_DATA 574}; 575 576struct elf_sym_strtab 577{ 578 Elf_Internal_Sym sym; 579 unsigned long dest_index; 580}; 581 582struct bfd_link_needed_list 583{ 584 struct bfd_link_needed_list *next; 585 bfd *by; 586 const char *name; 587}; 588 589enum elf_target_os 590{ 591 is_normal, 592 is_solaris, /* Solaris. */ 593 is_vxworks, /* VxWorks. */ 594 is_nacl /* Native Client. */ 595}; 596 597/* Used by bfd_sym_from_r_symndx to cache a small number of local 598 symbols. */ 599#define LOCAL_SYM_CACHE_SIZE 32 600struct sym_cache 601{ 602 bfd *abfd; 603 unsigned long indx[LOCAL_SYM_CACHE_SIZE]; 604 Elf_Internal_Sym sym[LOCAL_SYM_CACHE_SIZE]; 605}; 606 607/* ELF linker hash table. */ 608 609struct elf_link_hash_table 610{ 611 struct bfd_link_hash_table root; 612 613 /* An identifier used to distinguish different target 614 specific extensions to this structure. */ 615 enum elf_target_id hash_table_id; 616 617 /* Whether we have created the special dynamic sections required 618 when linking against or generating a shared object. */ 619 bool dynamic_sections_created; 620 621 /* Whether dynamic relocations are present. */ 622 bool dynamic_relocs; 623 624 /* True if this target has relocatable executables, so needs dynamic 625 section symbols. */ 626 bool is_relocatable_executable; 627 628 /* TRUE if there are IFUNC resolvers. */ 629 bool ifunc_resolvers; 630 631 /* TRUE if DT_PLTGOT is a required dynamic tag. */ 632 bool dt_pltgot_required; 633 634 /* TRUE if DT_JMPREL is a required dynamic tag. */ 635 bool dt_jmprel_required; 636 637 /* TRUE when we are handling DT_NEEDED entries. */ 638 bool handling_dt_needed; 639 640 /* The BFD used to hold special sections created by the linker. 641 This will be the first BFD found which requires these sections to 642 be created. */ 643 bfd *dynobj; 644 645 /* The value to use when initialising got.refcount/offset and 646 plt.refcount/offset in an elf_link_hash_entry. Set to zero when 647 the values are refcounts. Set to init_got_offset/init_plt_offset 648 in size_dynamic_sections when the values may be offsets. */ 649 union gotplt_union init_got_refcount; 650 union gotplt_union init_plt_refcount; 651 652 /* The value to use for got.refcount/offset and plt.refcount/offset 653 when the values may be offsets. Normally (bfd_vma) -1. */ 654 union gotplt_union init_got_offset; 655 union gotplt_union init_plt_offset; 656 657 /* The number of symbols found in the link which is intended for the 658 mandatory DT_SYMTAB tag (.dynsym section) in .dynamic section. */ 659 bfd_size_type dynsymcount; 660 bfd_size_type local_dynsymcount; 661 662 /* The string table of dynamic symbols, which becomes the .dynstr 663 section. */ 664 struct elf_strtab_hash *dynstr; 665 666 /* The array size of the symbol string table, which becomes the 667 .strtab section. */ 668 bfd_size_type strtabsize; 669 670 /* The array of strings, which becomes the .strtab section. */ 671 struct elf_sym_strtab *strtab; 672 673 /* The number of buckets in the hash table in the .hash section. 674 This is based on the number of dynamic symbols. */ 675 bfd_size_type bucketcount; 676 677 /* A linked list of DT_NEEDED names found in dynamic objects 678 included in the link. */ 679 struct bfd_link_needed_list *needed; 680 681 /* Sections in the output bfd that provides a section symbol 682 to be used by relocations emitted against local symbols. 683 Most targets will not use data_index_section. */ 684 asection *text_index_section; 685 asection *data_index_section; 686 687 /* The _GLOBAL_OFFSET_TABLE_ symbol. */ 688 struct elf_link_hash_entry *hgot; 689 690 /* The _PROCEDURE_LINKAGE_TABLE_ symbol. */ 691 struct elf_link_hash_entry *hplt; 692 693 /* The _DYNAMIC symbol. */ 694 struct elf_link_hash_entry *hdynamic; 695 696 /* A pointer to information used to merge SEC_MERGE sections. */ 697 void *merge_info; 698 699 /* Used to link stabs in sections. */ 700 struct stab_info stab_info; 701 702 /* Used by eh_frame code when editing .eh_frame. */ 703 struct eh_frame_hdr_info eh_info; 704 705 /* Used to link unwind data in .sframe sections. */ 706 struct sframe_enc_info sfe_info; 707 708 /* A linked list of local symbols to be added to .dynsym. */ 709 struct elf_link_local_dynamic_entry *dynlocal; 710 711 /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic 712 objects included in the link. */ 713 struct bfd_link_needed_list *runpath; 714 715 /* Cached first output tls section and size of PT_TLS segment. */ 716 asection *tls_sec; 717 bfd_size_type tls_size; /* Bytes. */ 718 719 /* The offset into splt of the PLT entry for the TLS descriptor 720 resolver. Special values are 0, if not necessary (or not found 721 to be necessary yet), and -1 if needed but not determined 722 yet. */ 723 bfd_vma tlsdesc_plt; 724 725 /* The GOT offset for the lazy trampoline. Communicated to the 726 loader via DT_TLSDESC_GOT. The magic value (bfd_vma) -1 727 indicates an offset is not allocated. */ 728 bfd_vma tlsdesc_got; 729 730 /* Target OS for linker output. */ 731 enum elf_target_os target_os; 732 733 /* A linked list of dynamic BFD's loaded in the link. */ 734 struct elf_link_loaded_list *dyn_loaded; 735 736 /* Small local sym cache. */ 737 struct sym_cache sym_cache; 738 739 /* Short-cuts to get to dynamic linker sections. */ 740 asection *sgot; 741 asection *sgotplt; 742 asection *srelgot; 743 asection *splt; 744 asection *srelplt; 745 asection *sdynbss; 746 asection *srelbss; 747 asection *sdynrelro; 748 asection *sreldynrelro; 749 asection *igotplt; 750 asection *iplt; 751 asection *irelplt; 752 asection *irelifunc; 753 asection *dynsym; 754 asection *srelrdyn; 755}; 756 757/* Returns TRUE if the hash table is a struct elf_link_hash_table. */ 758 759static inline bool 760is_elf_hash_table (const struct bfd_link_hash_table *htab) 761{ 762 return htab->type == bfd_link_elf_hash_table; 763} 764 765/* Look up an entry in an ELF linker hash table. */ 766 767static inline struct elf_link_hash_entry * 768elf_link_hash_lookup (struct elf_link_hash_table *table, const char *string, 769 bool create, bool copy, bool follow) 770{ 771 if (ENABLE_CHECKING && !is_elf_hash_table (&table->root)) 772 abort (); 773 return (struct elf_link_hash_entry *) 774 bfd_link_hash_lookup (&table->root, string, create, copy, follow); 775} 776 777/* Traverse an ELF linker hash table. */ 778 779static inline void 780elf_link_hash_traverse (struct elf_link_hash_table *table, 781 bool (*f) (struct elf_link_hash_entry *, void *), 782 void *info) 783{ 784 if (ENABLE_CHECKING && !is_elf_hash_table (&table->root)) 785 abort (); 786 bfd_link_hash_traverse (&table->root, 787 (bool (*) (struct bfd_link_hash_entry *, void *)) f, 788 info); 789} 790 791/* Get the ELF linker hash table from a link_info structure. */ 792 793static inline struct elf_link_hash_table * 794elf_hash_table (const struct bfd_link_info *info) 795{ 796 return (struct elf_link_hash_table *) info->hash; 797} 798 799static inline enum elf_target_id 800elf_hash_table_id (const struct elf_link_hash_table *table) 801{ 802 return table->hash_table_id; 803} 804 805/* Constant information held for an ELF backend. */ 806 807struct elf_size_info { 808 unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr; 809 unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note; 810 811 /* The size of entries in the .hash section. */ 812 unsigned char sizeof_hash_entry; 813 814 /* The number of internal relocations to allocate per external 815 relocation entry. */ 816 unsigned char int_rels_per_ext_rel; 817 /* We use some fixed size arrays. This should be large enough to 818 handle all back-ends. */ 819#define MAX_INT_RELS_PER_EXT_REL 3 820 821 unsigned char arch_size, log_file_align; 822 unsigned char elfclass, ev_current; 823 int (*write_out_phdrs) 824 (bfd *, const Elf_Internal_Phdr *, unsigned int); 825 bool (*write_shdrs_and_ehdr) (bfd *); 826 bool (*checksum_contents) 827 (bfd * , void (*) (const void *, size_t, void *), void *); 828 void (*write_relocs) 829 (bfd *, asection *, void *); 830 bool (*swap_symbol_in) 831 (bfd *, const void *, const void *, Elf_Internal_Sym *); 832 void (*swap_symbol_out) 833 (bfd *, const Elf_Internal_Sym *, void *, void *); 834 bool (*slurp_reloc_table) 835 (bfd *, asection *, asymbol **, bool); 836 long (*slurp_symbol_table) 837 (bfd *, asymbol **, bool); 838 void (*swap_dyn_in) 839 (bfd *, const void *, Elf_Internal_Dyn *); 840 void (*swap_dyn_out) 841 (bfd *, const Elf_Internal_Dyn *, void *); 842 843 /* This function is called to swap in a REL relocation. If an 844 external relocation corresponds to more than one internal 845 relocation, then all relocations are swapped in at once. */ 846 void (*swap_reloc_in) 847 (bfd *, const bfd_byte *, Elf_Internal_Rela *); 848 849 /* This function is called to swap out a REL relocation. */ 850 void (*swap_reloc_out) 851 (bfd *, const Elf_Internal_Rela *, bfd_byte *); 852 853 /* This function is called to swap in a RELA relocation. If an 854 external relocation corresponds to more than one internal 855 relocation, then all relocations are swapped in at once. */ 856 void (*swap_reloca_in) 857 (bfd *, const bfd_byte *, Elf_Internal_Rela *); 858 859 /* This function is called to swap out a RELA relocation. */ 860 void (*swap_reloca_out) 861 (bfd *, const Elf_Internal_Rela *, bfd_byte *); 862}; 863 864#define elf_symbol_from(S) \ 865 ((((S)->flags & BSF_SYNTHETIC) == 0 \ 866 && (S)->the_bfd != NULL \ 867 && (S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \ 868 && (S)->the_bfd->tdata.elf_obj_data != 0) \ 869 ? (elf_symbol_type *) (S) \ 870 : 0) 871 872enum elf_reloc_type_class { 873 reloc_class_normal, 874 reloc_class_relative, 875 reloc_class_copy, 876 reloc_class_ifunc, 877 reloc_class_plt 878}; 879 880struct elf_reloc_cookie 881{ 882 Elf_Internal_Rela *rels, *rel, *relend; 883 Elf_Internal_Sym *locsyms; 884 bfd *abfd; 885 size_t locsymcount; 886 size_t extsymoff; 887 struct elf_link_hash_entry **sym_hashes; 888 int r_sym_shift; 889 bool bad_symtab; 890}; 891 892/* The level of IRIX compatibility we're striving for. */ 893 894typedef enum { 895 ict_none, 896 ict_irix5, 897 ict_irix6 898} irix_compat_t; 899 900/* Mapping of ELF section names and types. */ 901struct bfd_elf_special_section 902{ 903 const char *prefix; 904 unsigned int prefix_length; 905 /* 0 means name must match PREFIX exactly. 906 -1 means name must start with PREFIX followed by an arbitrary string. 907 -2 means name must match PREFIX exactly or consist of PREFIX followed 908 by a dot then anything. 909 > 0 means name must start with the first PREFIX_LENGTH chars of 910 PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX. */ 911 signed int suffix_length; 912 unsigned int type; 913 bfd_vma attr; 914}; 915 916enum action_discarded 917 { 918 COMPLAIN = 1, 919 PRETEND = 2 920 }; 921 922typedef asection * (*elf_gc_mark_hook_fn) 923 (asection *, struct bfd_link_info *, Elf_Internal_Rela *, 924 struct elf_link_hash_entry *, Elf_Internal_Sym *); 925 926enum elf_property_kind 927 { 928 /* A new property. */ 929 property_unknown = 0, 930 /* A property ignored by backend. */ 931 property_ignored, 932 /* A corrupt property reported by backend. */ 933 property_corrupt, 934 /* A property should be removed due to property merge. */ 935 property_remove, 936 /* A property which is a number. */ 937 property_number 938 }; 939 940typedef struct elf_property 941{ 942 unsigned int pr_type; 943 unsigned int pr_datasz; 944 union 945 { 946 /* For property_number, this is a number. */ 947 bfd_vma number; 948 /* Add a new one if elf_property_kind is updated. */ 949 } u; 950 enum elf_property_kind pr_kind; 951} elf_property; 952 953typedef struct elf_property_list 954{ 955 struct elf_property_list *next; 956 struct elf_property property; 957} elf_property_list; 958 959struct bfd_elf_section_reloc_data; 960 961struct elf_backend_data 962{ 963 /* The architecture for this backend. */ 964 enum bfd_architecture arch; 965 966 /* An identifier used to distinguish different target specific 967 extensions to elf_obj_tdata and elf_link_hash_table structures. */ 968 enum elf_target_id target_id; 969 970 /* Target OS. */ 971 enum elf_target_os target_os; 972 973 /* The ELF machine code (EM_xxxx) for this backend. */ 974 int elf_machine_code; 975 976 /* EI_OSABI. */ 977 int elf_osabi; 978 979 /* The maximum page size for this backend. */ 980 bfd_vma maxpagesize; 981 982 /* The minimum page size for this backend. An input object will not be 983 considered page aligned unless its sections are correctly aligned for 984 pages at least this large. May be smaller than maxpagesize. */ 985 bfd_vma minpagesize; 986 987 /* The common page size for this backend. */ 988 bfd_vma commonpagesize; 989 990 /* The p_align value for this backend. If it is set, p_align of 991 PT_LOAD alignment will be to p_align by default. */ 992 bfd_vma p_align; 993 994 /* The BFD flags applied to sections created for dynamic linking. */ 995 flagword dynamic_sec_flags; 996 997 /* Architecture-specific data for this backend. 998 This is actually a pointer to some type like struct elf_ARCH_data. */ 999 const void *arch_data; 1000 1001 /* A function to translate an ELF RELA relocation to a BFD arelent 1002 structure. Returns TRUE upon success, FALSE otherwise. */ 1003 bool (*elf_info_to_howto) 1004 (bfd *, arelent *, Elf_Internal_Rela *); 1005 1006 /* A function to translate an ELF REL relocation to a BFD arelent 1007 structure. Returns TRUE upon success, FALSE otherwise. */ 1008 bool (*elf_info_to_howto_rel) 1009 (bfd *, arelent *, Elf_Internal_Rela *); 1010 1011 /* A function to determine whether a symbol is global when 1012 partitioning the symbol table into local and global symbols. 1013 This should be NULL for most targets, in which case the correct 1014 thing will be done. MIPS ELF, at least on the Irix 5, has 1015 special requirements. */ 1016 bool (*elf_backend_sym_is_global) 1017 (bfd *, asymbol *); 1018 1019 /* The remaining functions are hooks which are called only if they 1020 are not NULL. */ 1021 1022 /* A function to permit a backend specific check on whether a 1023 particular BFD format is relevant for an object file, and to 1024 permit the backend to set any global information it wishes. When 1025 this is called elf_elfheader is set, but anything else should be 1026 used with caution. If this returns FALSE, the check_format 1027 routine will return a bfd_error_wrong_format error. */ 1028 bool (*elf_backend_object_p) 1029 (bfd *); 1030 1031 /* A function to do additional symbol processing when reading the 1032 ELF symbol table. This is where any processor-specific special 1033 section indices are handled. */ 1034 void (*elf_backend_symbol_processing) 1035 (bfd *, asymbol *); 1036 1037 /* A function to do additional symbol processing after reading the 1038 entire ELF symbol table. */ 1039 bool (*elf_backend_symbol_table_processing) 1040 (bfd *, elf_symbol_type *, unsigned int); 1041 1042 /* A function to set the type of the info field. Processor-specific 1043 types should be handled here. */ 1044 int (*elf_backend_get_symbol_type) 1045 (Elf_Internal_Sym *, int); 1046 1047 /* A function to return the linker hash table entry of a symbol that 1048 might be satisfied by an archive symbol. */ 1049 struct bfd_link_hash_entry * (*elf_backend_archive_symbol_lookup) 1050 (bfd *, struct bfd_link_info *, const char *); 1051 1052 /* Return true if local section symbols should have a non-null st_name. 1053 NULL implies false. */ 1054 bool (*elf_backend_name_local_section_symbols) 1055 (bfd *); 1056 1057 /* A function to do additional processing on the ELF section header 1058 just before writing it out. This is used to set the flags and 1059 type fields for some sections, or to actually write out data for 1060 unusual sections. */ 1061 bool (*elf_backend_section_processing) 1062 (bfd *, Elf_Internal_Shdr *); 1063 1064 /* A function to handle unusual section types when creating BFD 1065 sections from ELF sections. */ 1066 bool (*elf_backend_section_from_shdr) 1067 (bfd *, Elf_Internal_Shdr *, const char *, int); 1068 1069 /* A function to convert machine dependent ELF section header flags to 1070 BFD internal section header flags. */ 1071 bool (*elf_backend_section_flags) 1072 (const Elf_Internal_Shdr *); 1073 1074 /* A function that returns a struct containing ELF section flags and 1075 type for the given BFD section. */ 1076 const struct bfd_elf_special_section * (*get_sec_type_attr) 1077 (bfd *, asection *); 1078 1079 /* A function to handle unusual program segment types when creating BFD 1080 sections from ELF program segments. */ 1081 bool (*elf_backend_section_from_phdr) 1082 (bfd *, Elf_Internal_Phdr *, int, const char *); 1083 1084 /* A function to set up the ELF section header for a BFD section in 1085 preparation for writing it out. This is where the flags and type 1086 fields are set for unusual sections. */ 1087 bool (*elf_backend_fake_sections) 1088 (bfd *, Elf_Internal_Shdr *, asection *); 1089 1090 /* A function to get the ELF section index for a BFD section. If 1091 this returns TRUE, the section was found. If it is a normal ELF 1092 section, *RETVAL should be left unchanged. If it is not a normal 1093 ELF section *RETVAL should be set to the SHN_xxxx index. */ 1094 bool (*elf_backend_section_from_bfd_section) 1095 (bfd *, asection *, int *retval); 1096 1097 /* If this field is not NULL, it is called by the add_symbols phase 1098 of a link just before adding a symbol to the global linker hash 1099 table. It may modify any of the fields as it wishes. If *NAME 1100 is set to NULL, the symbol will be skipped rather than being 1101 added to the hash table. This function is responsible for 1102 handling all processor dependent symbol bindings and section 1103 indices, and must set at least *FLAGS and *SEC for each processor 1104 dependent case; failure to do so will cause a link error. */ 1105 bool (*elf_add_symbol_hook) 1106 (bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *, 1107 const char **name, flagword *flags, asection **sec, bfd_vma *value); 1108 1109 /* If this field is not NULL, it is called by the elf_link_output_sym 1110 phase of a link for each symbol which will appear in the object file. 1111 On error, this function returns 0. 1 is returned when the symbol 1112 should be output, 2 is returned when the symbol should be discarded. */ 1113 int (*elf_backend_link_output_symbol_hook) 1114 (struct bfd_link_info *info, const char *, Elf_Internal_Sym *, 1115 asection *, struct elf_link_hash_entry *); 1116 1117 /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend 1118 linker the first time it encounters a dynamic object in the link. 1119 This function must create any sections required for dynamic 1120 linking. The ABFD argument is a dynamic object. The .interp, 1121 .dynamic, .dynsym, .dynstr, and .hash functions have already been 1122 created, and this function may modify the section flags if 1123 desired. This function will normally create the .got and .plt 1124 sections, but different backends have different requirements. */ 1125 bool (*elf_backend_create_dynamic_sections) 1126 (bfd *abfd, struct bfd_link_info *info); 1127 1128 /* When creating a shared library, determine whether to omit the 1129 dynamic symbol for the section. */ 1130 bool (*elf_backend_omit_section_dynsym) 1131 (bfd *output_bfd, struct bfd_link_info *info, asection *osec); 1132 1133 /* Return TRUE if relocations of targets are compatible to the extent 1134 that CHECK_RELOCS will properly process them. PR 4424. */ 1135 bool (*relocs_compatible) (const bfd_target *, const bfd_target *); 1136 1137 /* The CHECK_RELOCS function is called after all input files have been 1138 opened. It is called once for each section with relocs of an object 1139 file. The function must look through the relocs and do any special 1140 handling required. This generally means allocating space in the 1141 global offset table, and perhaps allocating space for a reloc. The 1142 relocs are always passed as Rela structures; if the section 1143 actually uses Rel structures, the r_addend field will always be 1144 zero. */ 1145 bool (*check_relocs) 1146 (bfd *abfd, struct bfd_link_info *info, asection *o, 1147 const Elf_Internal_Rela *relocs); 1148 1149 /* The SIZE_RELATIVE_RELOCS function is called to size relative 1150 relocations when mappig sections to segments. */ 1151 bool (*size_relative_relocs) 1152 (struct bfd_link_info *info, bool *need_layout); 1153 1154 /* The FINISH_RELATIVE_RELOCS function is called to finish relative 1155 relocations in bfd_elf_final_link. */ 1156 bool (*finish_relative_relocs) 1157 (struct bfd_link_info *info); 1158 1159 /* The CHECK_DIRECTIVES function is called once per input file by 1160 the add_symbols phase of the ELF backend linker. The function 1161 must inspect the bfd and create any additional symbols according 1162 to any custom directives in the bfd. */ 1163 bool (*check_directives) 1164 (bfd *abfd, struct bfd_link_info *info); 1165 1166 /* The NOTICE_AS_NEEDED function is called as the linker is about to 1167 handle an as-needed lib (ACT = notice_as_needed), and after the 1168 linker has decided to keep the lib (ACT = notice_needed) or when 1169 the lib is not needed (ACT = notice_not_needed). */ 1170 bool (*notice_as_needed) 1171 (bfd *abfd, struct bfd_link_info *info, enum notice_asneeded_action act); 1172 1173 /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend 1174 linker for every symbol which is defined by a dynamic object and 1175 referenced by a regular object. This is called after all the 1176 input files have been seen, but before the SIZE_DYNAMIC_SECTIONS 1177 function has been called. The hash table entry should be 1178 bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be 1179 defined in a section from a dynamic object. Dynamic object 1180 sections are not included in the final link, and this function is 1181 responsible for changing the value to something which the rest of 1182 the link can deal with. This will normally involve adding an 1183 entry to the .plt or .got or some such section, and setting the 1184 symbol to point to that. */ 1185 bool (*elf_backend_adjust_dynamic_symbol) 1186 (struct bfd_link_info *info, struct elf_link_hash_entry *h); 1187 1188 /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker 1189 after all the linker input files have been seen but before the 1190 section sizes have been set. This is called after 1191 ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS. */ 1192 bool (*elf_backend_always_size_sections) 1193 (bfd *output_bfd, struct bfd_link_info *info); 1194 1195 /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend 1196 linker after all the linker input files have been seen but before 1197 the sections sizes have been set. This is called after 1198 ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols. 1199 It is only called when linking against a dynamic object. It must 1200 set the sizes of the dynamic sections, and may fill in their 1201 contents as well. The generic ELF linker can handle the .dynsym, 1202 .dynstr and .hash sections. This function must handle the 1203 .interp section and any sections created by the 1204 CREATE_DYNAMIC_SECTIONS entry point. */ 1205 bool (*elf_backend_size_dynamic_sections) 1206 (bfd *output_bfd, struct bfd_link_info *info); 1207 1208 /* The STRIP_ZERO_SIZED_DYNAMIC_SECTIONS function is called by the 1209 ELF backend linker to strip zero-sized dynamic sections after 1210 the section sizes have been set. */ 1211 bool (*elf_backend_strip_zero_sized_dynamic_sections) 1212 (struct bfd_link_info *info); 1213 1214 /* Set TEXT_INDEX_SECTION and DATA_INDEX_SECTION, the output sections 1215 we keep to use as a base for relocs and symbols. */ 1216 void (*elf_backend_init_index_section) 1217 (bfd *output_bfd, struct bfd_link_info *info); 1218 1219 /* The RELOCATE_SECTION function is called by the ELF backend linker 1220 to handle the relocations for a section. 1221 1222 The relocs are always passed as Rela structures; if the section 1223 actually uses Rel structures, the r_addend field will always be 1224 zero. 1225 1226 This function is responsible for adjust the section contents as 1227 necessary, and (if using Rela relocs and generating a 1228 relocatable output file) adjusting the reloc addend as 1229 necessary. 1230 1231 This function does not have to worry about setting the reloc 1232 address or the reloc symbol index. 1233 1234 LOCAL_SYMS is a pointer to the swapped in local symbols. 1235 1236 LOCAL_SECTIONS is an array giving the section in the input file 1237 corresponding to the st_shndx field of each local symbol. 1238 1239 The global hash table entry for the global symbols can be found 1240 via elf_sym_hashes (input_bfd). 1241 1242 When generating relocatable output, this function must handle 1243 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1244 going to be the section symbol corresponding to the output 1245 section, which means that the addend must be adjusted 1246 accordingly. 1247 1248 Returns FALSE on error, TRUE on success, 2 if successful and 1249 relocations should be written for this section. */ 1250 int (*elf_backend_relocate_section) 1251 (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd, 1252 asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs, 1253 Elf_Internal_Sym *local_syms, asection **local_sections); 1254 1255 /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend 1256 linker just before it writes a symbol out to the .dynsym section. 1257 The processor backend may make any required adjustment to the 1258 symbol. It may also take the opportunity to set contents of the 1259 dynamic sections. Note that FINISH_DYNAMIC_SYMBOL is called on 1260 all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called 1261 on those symbols which are defined by a dynamic object. */ 1262 bool (*elf_backend_finish_dynamic_symbol) 1263 (bfd *output_bfd, struct bfd_link_info *info, 1264 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym); 1265 1266 /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend 1267 linker just before it writes all the dynamic sections out to the 1268 output file. The FINISH_DYNAMIC_SYMBOL will have been called on 1269 all dynamic symbols. */ 1270 bool (*elf_backend_finish_dynamic_sections) 1271 (bfd *output_bfd, struct bfd_link_info *info); 1272 1273 /* A function to do any beginning processing needed for the ELF file 1274 before building the ELF headers and computing file positions. */ 1275 void (*elf_backend_begin_write_processing) 1276 (bfd *, struct bfd_link_info *); 1277 1278 /* A function to do any final processing needed for the ELF file 1279 before writing it out. */ 1280 bool (*elf_backend_final_write_processing) 1281 (bfd *); 1282 1283 /* This function is called by get_program_header_size. It should 1284 return the number of additional program segments which this BFD 1285 will need. It should return -1 on error. */ 1286 int (*elf_backend_additional_program_headers) 1287 (bfd *, struct bfd_link_info *); 1288 1289 /* This function is called to modify an existing segment map in a 1290 backend specific fashion. */ 1291 bool (*elf_backend_modify_segment_map) 1292 (bfd *, struct bfd_link_info *); 1293 1294 /* This function is called to modify program headers just before 1295 they are written. */ 1296 bool (*elf_backend_modify_headers) 1297 (bfd *, struct bfd_link_info *); 1298 1299 /* This function is called to see if the PHDR header should be 1300 checked for validity. */ 1301 bool (*elf_backend_allow_non_load_phdr) 1302 (bfd *, const Elf_Internal_Phdr *, unsigned); 1303 1304 /* This function is called before section garbage collection to 1305 mark entry symbol sections. */ 1306 void (*gc_keep) 1307 (struct bfd_link_info *); 1308 1309 /* This function is called during section garbage collection to 1310 mark sections that define global symbols. */ 1311 bool (*gc_mark_dynamic_ref) 1312 (struct elf_link_hash_entry *, void *); 1313 1314 /* This function is called during section gc to discover the section a 1315 particular relocation refers to. */ 1316 elf_gc_mark_hook_fn gc_mark_hook; 1317 1318 /* This function, if defined, is called after the first gc marking pass 1319 to allow the backend to mark additional sections. */ 1320 bool (*gc_mark_extra_sections) 1321 (struct bfd_link_info *, elf_gc_mark_hook_fn); 1322 1323 /* This function is called to initialise ELF file header info. 1324 Customised versions can modify things like the OS and ABI version. */ 1325 bool (*elf_backend_init_file_header) 1326 (bfd *, struct bfd_link_info *); 1327 1328 /* This function, if defined, prints a symbol to file and returns the 1329 name of the symbol to be printed. It should return NULL to fall 1330 back to default symbol printing. */ 1331 const char *(*elf_backend_print_symbol_all) 1332 (bfd *, void *, asymbol *); 1333 1334 /* This function, if defined, is called after all local symbols and 1335 global symbols converted to locals are emitted into the symtab 1336 section. It allows the backend to emit special local symbols 1337 not handled in the hash table. */ 1338 bool (*elf_backend_output_arch_local_syms) 1339 (bfd *, struct bfd_link_info *, void *, 1340 int (*) (void *, const char *, Elf_Internal_Sym *, asection *, 1341 struct elf_link_hash_entry *)); 1342 1343 /* This function, if defined, is called after all symbols are emitted 1344 into the symtab section. It allows the backend to emit special 1345 global symbols not handled in the hash table. */ 1346 bool (*elf_backend_output_arch_syms) 1347 (bfd *, struct bfd_link_info *, void *, 1348 int (*) (void *, const char *, Elf_Internal_Sym *, asection *, 1349 struct elf_link_hash_entry *)); 1350 1351 /* Filter what symbols of the output file to include in the import 1352 library if one is created. */ 1353 unsigned int (*elf_backend_filter_implib_symbols) 1354 (bfd *, struct bfd_link_info *, asymbol **, long); 1355 1356 /* Copy any information related to dynamic linking from a pre-existing 1357 symbol to a newly created symbol. Also called to copy flags and 1358 other back-end info to a weakdef, in which case the symbol is not 1359 newly created and plt/got refcounts and dynamic indices should not 1360 be copied. */ 1361 void (*elf_backend_copy_indirect_symbol) 1362 (struct bfd_link_info *, struct elf_link_hash_entry *, 1363 struct elf_link_hash_entry *); 1364 1365 /* Modify any information related to dynamic linking such that the 1366 symbol is not exported. */ 1367 void (*elf_backend_hide_symbol) 1368 (struct bfd_link_info *, struct elf_link_hash_entry *, bool); 1369 1370 /* A function to do additional symbol fixup, called by 1371 _bfd_elf_fix_symbol_flags. */ 1372 bool (*elf_backend_fixup_symbol) 1373 (struct bfd_link_info *, struct elf_link_hash_entry *); 1374 1375 /* Merge the backend specific symbol attribute. */ 1376 void (*elf_backend_merge_symbol_attribute) 1377 (struct elf_link_hash_entry *, unsigned int, bool, bool); 1378 1379 /* This function, if defined, will return a string containing the 1380 name of a target-specific dynamic tag. */ 1381 char *(*elf_backend_get_target_dtag) 1382 (bfd_vma); 1383 1384 /* Decide whether an undefined symbol is special and can be ignored. 1385 This is the case for OPTIONAL symbols on IRIX. */ 1386 bool (*elf_backend_ignore_undef_symbol) 1387 (struct elf_link_hash_entry *); 1388 1389 /* Emit relocations. Overrides default routine for emitting relocs, 1390 except during a relocatable link, or if all relocs are being emitted. */ 1391 bool (*elf_backend_emit_relocs) 1392 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *, 1393 struct elf_link_hash_entry **); 1394 1395 /* Update relocations. It is allowed to change the number and the order. 1396 In such a case hashes should be invalidated. */ 1397 void (*elf_backend_update_relocs) 1398 (asection *, struct bfd_elf_section_reloc_data *); 1399 1400 /* Count relocations. Not called for relocatable links 1401 or if all relocs are being preserved in the output. */ 1402 unsigned int (*elf_backend_count_relocs) 1403 (struct bfd_link_info *, asection *); 1404 1405 /* Count additionals relocations. Called for relocatable links if 1406 additional relocations needs to be created. */ 1407 unsigned int (*elf_backend_count_additional_relocs) 1408 (asection *); 1409 1410 /* Say whether to sort relocs output by ld -r and ld --emit-relocs, 1411 by r_offset. If NULL, default to true. */ 1412 bool (*sort_relocs_p) 1413 (asection *); 1414 1415 /* This function, if defined, is called when an NT_PRSTATUS note is found 1416 in a core file. */ 1417 bool (*elf_backend_grok_prstatus) 1418 (bfd *, Elf_Internal_Note *); 1419 1420 /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO 1421 note is found in a core file. */ 1422 bool (*elf_backend_grok_psinfo) 1423 (bfd *, Elf_Internal_Note *); 1424 1425 /* This function, if defined, is called when a "FreeBSD" NT_PRSTATUS 1426 note is found in a core file. */ 1427 bool (*elf_backend_grok_freebsd_prstatus) 1428 (bfd *, Elf_Internal_Note *); 1429 1430 /* This function, if defined, is called to write a note to a corefile. */ 1431 char *(*elf_backend_write_core_note) 1432 (bfd *abfd, char *buf, int *bufsiz, int note_type, ...); 1433 1434 /* This function, if defined, is called to convert target-specific 1435 section flag names into hex values. */ 1436 flagword (*elf_backend_lookup_section_flags_hook) 1437 (char *); 1438 1439 /* This function returns class of a reloc type. */ 1440 enum elf_reloc_type_class (*elf_backend_reloc_type_class) 1441 (const struct bfd_link_info *, const asection *, const Elf_Internal_Rela *); 1442 1443 /* This function, if defined, removes information about discarded functions 1444 from other sections which mention them. */ 1445 bool (*elf_backend_discard_info) 1446 (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *); 1447 1448 /* This function, if defined, signals that the function above has removed 1449 the discarded relocations for this section. */ 1450 bool (*elf_backend_ignore_discarded_relocs) 1451 (asection *); 1452 1453 /* What to do when ld finds relocations against symbols defined in 1454 discarded sections. */ 1455 unsigned int (*action_discarded) 1456 (asection *); 1457 1458 /* This function returns the width of FDE pointers in bytes, or 0 if 1459 that can't be determined for some reason. The default definition 1460 goes by the bfd's EI_CLASS. */ 1461 unsigned int (*elf_backend_eh_frame_address_size) 1462 (bfd *, const asection *); 1463 1464 /* These functions tell elf-eh-frame whether to attempt to turn 1465 absolute or lsda encodings into pc-relative ones. The default 1466 definition enables these transformations. */ 1467 bool (*elf_backend_can_make_relative_eh_frame) 1468 (bfd *, struct bfd_link_info *, asection *); 1469 bool (*elf_backend_can_make_lsda_relative_eh_frame) 1470 (bfd *, struct bfd_link_info *, asection *); 1471 1472 /* Tell linker to support multiple eh_frame sections. */ 1473 bool elf_backend_can_make_multiple_eh_frame; 1474 1475 /* This function returns an encoding after computing the encoded 1476 value (and storing it in ENCODED) for the given OFFSET into OSEC, 1477 to be stored in at LOC_OFFSET into the LOC_SEC input section. 1478 The default definition chooses a 32-bit PC-relative encoding. */ 1479 bfd_byte (*elf_backend_encode_eh_address) 1480 (bfd *abfd, struct bfd_link_info *info, 1481 asection *osec, bfd_vma offset, 1482 asection *loc_sec, bfd_vma loc_offset, 1483 bfd_vma *encoded); 1484 1485 /* This function, if defined, may write out the given section. 1486 Returns TRUE if it did so and FALSE if the caller should. */ 1487 bool (*elf_backend_write_section) 1488 (bfd *, struct bfd_link_info *, asection *, bfd_byte *); 1489 1490 /* This function, if defined, returns TRUE if it is section symbols 1491 only that are considered local for the purpose of partitioning the 1492 symbol table into local and global symbols. This should be NULL 1493 for most targets, in which case the correct thing will be done. 1494 MIPS ELF, at least on the Irix 5, has special requirements. */ 1495 bool (*elf_backend_elfsym_local_is_section) 1496 (bfd *); 1497 1498 /* The level of IRIX compatibility we're striving for. 1499 MIPS ELF specific function. */ 1500 irix_compat_t (*elf_backend_mips_irix_compat) 1501 (bfd *); 1502 1503 reloc_howto_type *(*elf_backend_mips_rtype_to_howto) 1504 (bfd *, unsigned int, bool); 1505 1506 /* The swapping table to use when dealing with ECOFF information. 1507 Used for the MIPS ELF .mdebug section. */ 1508 const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap; 1509 1510 /* This function implements `bfd_elf_bfd_from_remote_memory'; 1511 see elf.c, elfcode.h. */ 1512 bfd *(*elf_backend_bfd_from_remote_memory) 1513 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep, 1514 int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, 1515 bfd_size_type len)); 1516 1517 bool (*elf_backend_core_find_build_id) (bfd *, bfd_vma); 1518 1519 /* This function is used by `_bfd_elf_get_synthetic_symtab'; 1520 see elf.c. */ 1521 bfd_vma (*plt_sym_val) (bfd_vma, const asection *, const arelent *); 1522 1523 /* Is symbol defined in common section? */ 1524 bool (*common_definition) (Elf_Internal_Sym *); 1525 1526 /* Return a common section index for section. */ 1527 unsigned int (*common_section_index) (asection *); 1528 1529 /* Return a common section for section. */ 1530 asection *(*common_section) (asection *); 1531 1532 /* Return TRUE if we can merge 2 definitions. */ 1533 bool (*merge_symbol) (struct elf_link_hash_entry *, 1534 const Elf_Internal_Sym *, asection **, 1535 bool, bool, 1536 bfd *, const asection *); 1537 1538 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 1539 bool (*elf_hash_symbol) (struct elf_link_hash_entry *); 1540 1541 /* If non-NULL, called to register the location of XLAT_LOC within 1542 .MIPS.xhash at which real final dynindx for H will be written. 1543 If XLAT_LOC is zero, the symbol is not included in 1544 .MIPS.xhash and no dynindx will be written. */ 1545 void (*record_xhash_symbol) 1546 (struct elf_link_hash_entry *h, bfd_vma xlat_loc); 1547 1548 /* Return TRUE if type is a function symbol type. */ 1549 bool (*is_function_type) (unsigned int type); 1550 1551 /* If the ELF symbol SYM might be a function in SEC, return the 1552 function size and set *CODE_OFF to the function's entry point, 1553 otherwise return zero. */ 1554 bfd_size_type (*maybe_function_sym) (const asymbol *sym, asection *sec, 1555 bfd_vma *code_off); 1556 1557 /* Given NAME, the name of a relocation section stripped of its 1558 .rel/.rela prefix, return the section in ABFD to which the 1559 relocations apply. */ 1560 asection *(*get_reloc_section) (bfd *abfd, const char *name); 1561 1562 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which 1563 has a type >= SHT_LOOS. Returns TRUE if the fields were initialised, 1564 FALSE otherwise. Can be called multiple times for a given section, 1565 until it returns TRUE. Most of the times it is called ISECTION will be 1566 set to an input section that might be associated with the output section. 1567 The last time that it is called, ISECTION will be set to NULL. */ 1568 bool (*elf_backend_copy_special_section_fields) 1569 (const bfd *ibfd, bfd *obfd, const Elf_Internal_Shdr *isection, 1570 Elf_Internal_Shdr *osection); 1571 1572 /* Used to handle bad SHF_LINK_ORDER input. */ 1573 void (*link_order_error_handler) (const char *, ...); 1574 1575 /* Name of the PLT relocation section. */ 1576 const char *relplt_name; 1577 1578 /* Alternate EM_xxxx machine codes for this backend. */ 1579 int elf_machine_alt1; 1580 int elf_machine_alt2; 1581 1582 const struct elf_size_info *s; 1583 1584 /* An array of target specific special sections. */ 1585 const struct bfd_elf_special_section *special_sections; 1586 1587 /* The size in bytes of the header for the GOT. This includes the 1588 so-called reserved entries on some systems. */ 1589 bfd_vma got_header_size; 1590 1591 /* The size of the GOT entry for the symbol pointed to by H if non-NULL, 1592 otherwise by the local symbol with index SYMNDX in IBFD. */ 1593 bfd_vma (*got_elt_size) (bfd *, struct bfd_link_info *, 1594 struct elf_link_hash_entry *h, 1595 bfd *ibfd, unsigned long symndx); 1596 1597 /* The vendor name to use for a processor-standard attributes section. */ 1598 const char *obj_attrs_vendor; 1599 1600 /* The section name to use for a processor-standard attributes section. */ 1601 const char *obj_attrs_section; 1602 1603 /* Return 1, 2 or 3 to indicate what type of arguments a 1604 processor-specific tag takes. */ 1605 int (*obj_attrs_arg_type) (int); 1606 1607 /* The section type to use for an attributes section. */ 1608 unsigned int obj_attrs_section_type; 1609 1610 /* This function determines the order in which any attributes are 1611 written. It must be defined for input in the range 1612 LEAST_KNOWN_OBJ_ATTRIBUTE..NUM_KNOWN_OBJ_ATTRIBUTES-1 (this range 1613 is used in order to make unity easy). The returned value is the 1614 actual tag number to place in the input position. */ 1615 int (*obj_attrs_order) (int); 1616 1617 /* Handle merging unknown attributes; either warn and return TRUE, 1618 or give an error and return FALSE. */ 1619 bool (*obj_attrs_handle_unknown) (bfd *, int); 1620 1621 /* Parse GNU properties. Return the property kind. If the property 1622 is corrupt, issue an error message and return property_corrupt. */ 1623 enum elf_property_kind (*parse_gnu_properties) (bfd *, unsigned int, 1624 bfd_byte *, 1625 unsigned int); 1626 1627 /* Merge GNU properties. Return TRUE if property is updated. */ 1628 bool (*merge_gnu_properties) (struct bfd_link_info *, bfd *, bfd *, 1629 elf_property *, elf_property *); 1630 1631 /* Set up GNU properties. */ 1632 bfd *(*setup_gnu_properties) (struct bfd_link_info *); 1633 1634 /* Fix up GNU properties. */ 1635 void (*fixup_gnu_properties) (struct bfd_link_info *, 1636 elf_property_list **); 1637 1638 /* Encoding used for compact EH tables. */ 1639 int (*compact_eh_encoding) (struct bfd_link_info *); 1640 1641 /* Opcode representing no unwind. */ 1642 int (*cant_unwind_opcode) (struct bfd_link_info *); 1643 1644 /* Called when emitting an ELF symbol whoes input version had an 1645 ST_SHNDX field set to a value in the range SHN_LOPROC..SHN_HIOS. 1646 Returns the value to be installed in the ST_SHNDX field of the 1647 emitted symbol. If not defined, the value is left unchanged. */ 1648 unsigned int (*symbol_section_index) (bfd *, elf_symbol_type *); 1649 1650 /* Called when a section has extra reloc sections. */ 1651 bool (*init_secondary_reloc_section) (bfd *, Elf_Internal_Shdr *, 1652 const char *, unsigned int); 1653 1654 /* Called when after loading the normal relocs for a section. */ 1655 bool (*slurp_secondary_relocs) (bfd *, asection *, asymbol **, bool); 1656 1657 /* Called after writing the normal relocs for a section. */ 1658 bool (*write_secondary_relocs) (bfd *, asection *); 1659 1660 /* This is non-zero if static TLS segments require a special alignment. */ 1661 unsigned static_tls_alignment; 1662 1663 /* Alignment for the PT_GNU_STACK segment. */ 1664 unsigned stack_align; 1665 1666 /* Flag bits to assign to a section of type SHT_STRTAB. */ 1667 unsigned long elf_strtab_flags; 1668 1669 /* This is TRUE if the linker should act like collect and gather 1670 global constructors and destructors by name. This is TRUE for 1671 MIPS ELF because the Irix 5 tools can not handle the .init 1672 section. */ 1673 unsigned collect : 1; 1674 1675 /* This is TRUE if the linker should ignore changes to the type of a 1676 symbol. This is TRUE for MIPS ELF because some Irix 5 objects 1677 record undefined functions as STT_OBJECT although the definitions 1678 are STT_FUNC. */ 1679 unsigned type_change_ok : 1; 1680 1681 /* Whether the backend may use REL relocations. (Some backends use 1682 both REL and RELA relocations, and this flag is set for those 1683 backends.) */ 1684 unsigned may_use_rel_p : 1; 1685 1686 /* Whether the backend may use RELA relocations. (Some backends use 1687 both REL and RELA relocations, and this flag is set for those 1688 backends.) */ 1689 unsigned may_use_rela_p : 1; 1690 1691 /* Whether the default relocation type is RELA. If a backend with 1692 this flag set wants REL relocations for a particular section, 1693 it must note that explicitly. Similarly, if this flag is clear, 1694 and the backend wants RELA relocations for a particular 1695 section. */ 1696 unsigned default_use_rela_p : 1; 1697 1698 /* True if PLT and copy relocations should be RELA by default. */ 1699 unsigned rela_plts_and_copies_p : 1; 1700 1701 /* Set if RELA relocations for a relocatable link can be handled by 1702 generic code. Backends that set this flag need do nothing in the 1703 backend relocate_section routine for relocatable linking. */ 1704 unsigned rela_normal : 1; 1705 1706 /* Set if DT_REL/DT_RELA/DT_RELSZ/DT_RELASZ should not include PLT 1707 relocations. */ 1708 unsigned dtrel_excludes_plt : 1; 1709 1710 /* TRUE if addresses "naturally" sign extend. This is used when 1711 swapping in from Elf32 when BFD64. */ 1712 unsigned sign_extend_vma : 1; 1713 1714 unsigned want_got_plt : 1; 1715 unsigned plt_readonly : 1; 1716 unsigned want_plt_sym : 1; 1717 unsigned plt_not_loaded : 1; 1718 unsigned plt_alignment : 4; 1719 unsigned can_gc_sections : 1; 1720 unsigned can_refcount : 1; 1721 unsigned want_got_sym : 1; 1722 unsigned want_dynbss : 1; 1723 unsigned want_dynrelro : 1; 1724 1725 /* Targets which do not support physical addressing often require 1726 that the p_paddr field in the section header to be set to zero. 1727 This field indicates whether this behavior is required. */ 1728 unsigned want_p_paddr_set_to_zero : 1; 1729 1730 /* Target has broken hardware and/or kernel that requires pages not 1731 to be mapped twice with different permissions. */ 1732 unsigned no_page_alias : 1; 1733 1734 /* True if an object file lacking a .note.GNU-stack section 1735 should be assumed to be requesting exec stack. At least one 1736 other file in the link needs to have a .note.GNU-stack section 1737 for a PT_GNU_STACK segment to be created. */ 1738 unsigned default_execstack : 1; 1739 1740 /* True if elf_section_data(sec)->this_hdr.contents is sec->rawsize 1741 in length rather than sec->size in length, if sec->rawsize is 1742 non-zero and smaller than sec->size. */ 1743 unsigned caches_rawsize : 1; 1744 1745 /* Address of protected data defined in the shared library may be 1746 external, i.e., due to copy relocation. */ 1747 unsigned extern_protected_data : 1; 1748 1749 /* True if `_bfd_elf_link_renumber_dynsyms' must be called even for 1750 static binaries. */ 1751 unsigned always_renumber_dynsyms : 1; 1752 1753 /* True if the 32-bit Linux PRPSINFO structure's `pr_uid' and `pr_gid' 1754 members use a 16-bit data type. */ 1755 unsigned linux_prpsinfo32_ugid16 : 1; 1756 1757 /* True if the 64-bit Linux PRPSINFO structure's `pr_uid' and `pr_gid' 1758 members use a 16-bit data type. */ 1759 unsigned linux_prpsinfo64_ugid16 : 1; 1760}; 1761 1762/* Information about reloc sections associated with a bfd_elf_section_data 1763 structure. */ 1764struct bfd_elf_section_reloc_data 1765{ 1766 /* The ELF header for the reloc section associated with this 1767 section, if any. */ 1768 Elf_Internal_Shdr *hdr; 1769 /* The number of relocations currently assigned to HDR. */ 1770 unsigned int count; 1771 /* The ELF section number of the reloc section. Only used for an 1772 output file. */ 1773 int idx; 1774 /* Used by the backend linker to store the symbol hash table entries 1775 associated with relocs against global symbols. */ 1776 struct elf_link_hash_entry **hashes; 1777}; 1778 1779/* Information stored for each BFD section in an ELF file. This 1780 structure is allocated by elf_new_section_hook. */ 1781 1782struct bfd_elf_section_data 1783{ 1784 /* The ELF header for this section. */ 1785 Elf_Internal_Shdr this_hdr; 1786 1787 /* INPUT_SECTION_FLAGS if specified in the linker script. */ 1788 struct flag_info *section_flag_info; 1789 1790 /* Information about the REL and RELA reloc sections associated 1791 with this section, if any. */ 1792 struct bfd_elf_section_reloc_data rel, rela; 1793 1794 /* The ELF section number of this section. */ 1795 int this_idx; 1796 1797 /* Used by the backend linker when generating a shared library to 1798 record the dynamic symbol index for a section symbol 1799 corresponding to this section. A value of 0 means that there is 1800 no dynamic symbol for this section. */ 1801 int dynindx; 1802 1803 /* A pointer to the linked-to section for SHF_LINK_ORDER. */ 1804 asection *linked_to; 1805 1806 /* A pointer to the swapped relocs. If the section uses REL relocs, 1807 rather than RELA, all the r_addend fields will be zero. This 1808 pointer may be NULL. It is used by the backend linker. */ 1809 Elf_Internal_Rela *relocs; 1810 1811 /* A pointer to a linked list tracking dynamic relocs copied for 1812 local symbols. */ 1813 void *local_dynrel; 1814 1815 /* A pointer to the bfd section used for dynamic relocs. */ 1816 asection *sreloc; 1817 1818 union { 1819 /* Group name, if this section is a member of a group. */ 1820 const char *name; 1821 1822 /* Group signature sym, if this is the SHT_GROUP section. */ 1823 struct bfd_symbol *id; 1824 } group; 1825 1826 /* For a member of a group, points to the SHT_GROUP section. 1827 NULL for the SHT_GROUP section itself and non-group sections. */ 1828 asection *sec_group; 1829 1830 /* A linked list of member sections in the group. Circular when used by 1831 the linker. For the SHT_GROUP section, points at first member. */ 1832 asection *next_in_group; 1833 1834 /* The FDEs associated with this section. The u.fde.next_in_section 1835 field acts as a chain pointer. */ 1836 struct eh_cie_fde *fde_list; 1837 1838 /* Link from a text section to its .eh_frame_entry section. */ 1839 asection *eh_frame_entry; 1840 1841 /* TRUE if the section has secondary reloc sections associated with it. 1842 FIXME: In the future it might be better to change this into a list 1843 of secondary reloc sections, making lookup easier and faster. */ 1844 bool has_secondary_relocs; 1845 1846 /* A pointer used for various section optimizations. */ 1847 void *sec_info; 1848}; 1849 1850#define elf_section_data(sec) ((struct bfd_elf_section_data*)(sec)->used_by_bfd) 1851#define elf_linked_to_section(sec) (elf_section_data(sec)->linked_to) 1852#define elf_section_type(sec) (elf_section_data(sec)->this_hdr.sh_type) 1853#define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags) 1854#define elf_section_info(sec) (elf_section_data(sec)->this_hdr.sh_info) 1855#define elf_group_name(sec) (elf_section_data(sec)->group.name) 1856#define elf_group_id(sec) (elf_section_data(sec)->group.id) 1857#define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group) 1858#define elf_fde_list(sec) (elf_section_data(sec)->fde_list) 1859#define elf_sec_group(sec) (elf_section_data(sec)->sec_group) 1860#define elf_section_eh_frame_entry(sec) (elf_section_data(sec)->eh_frame_entry) 1861 1862#define xvec_get_elf_backend_data(xvec) \ 1863 ((const struct elf_backend_data *) (xvec)->backend_data) 1864 1865#define get_elf_backend_data(abfd) \ 1866 xvec_get_elf_backend_data ((abfd)->xvec) 1867 1868/* The least object attributes (within an attributes subsection) known 1869 for any target. Some code assumes that the value 0 is not used and 1870 the field for that attribute can instead be used as a marker to 1871 indicate that attributes have been initialized. */ 1872#define LEAST_KNOWN_OBJ_ATTRIBUTE 2 1873 1874/* The maximum number of known object attributes for any target. */ 1875#define NUM_KNOWN_OBJ_ATTRIBUTES 77 1876 1877/* The value of an object attribute. The type indicates whether the attribute 1878 holds and integer, a string, or both. It can also indicate that there can 1879 be no default (i.e. all values must be written to file, even zero), or 1880 that the value is in error and should not be written to file. */ 1881 1882typedef struct obj_attribute 1883{ 1884#define ATTR_TYPE_FLAG_INT_VAL (1 << 0) 1885#define ATTR_TYPE_FLAG_STR_VAL (1 << 1) 1886#define ATTR_TYPE_FLAG_NO_DEFAULT (1 << 2) 1887#define ATTR_TYPE_FLAG_ERROR (1 << 3) 1888 1889#define ATTR_TYPE_HAS_INT_VAL(TYPE) ((TYPE) & ATTR_TYPE_FLAG_INT_VAL) 1890#define ATTR_TYPE_HAS_STR_VAL(TYPE) ((TYPE) & ATTR_TYPE_FLAG_STR_VAL) 1891#define ATTR_TYPE_HAS_NO_DEFAULT(TYPE) ((TYPE) & ATTR_TYPE_FLAG_NO_DEFAULT) 1892#define ATTR_TYPE_HAS_ERROR(TYPE) ((TYPE) & ATTR_TYPE_FLAG_ERROR) 1893 1894 int type; 1895 unsigned int i; 1896 char *s; 1897} obj_attribute; 1898 1899typedef struct obj_attribute_list 1900{ 1901 struct obj_attribute_list *next; 1902 unsigned int tag; 1903 obj_attribute attr; 1904} obj_attribute_list; 1905 1906/* Object attributes may either be defined by the processor ABI, index 1907 OBJ_ATTR_PROC in the *_obj_attributes arrays, or be GNU-specific 1908 (and possibly also processor-specific), index OBJ_ATTR_GNU. */ 1909#define OBJ_ATTR_PROC 0 1910#define OBJ_ATTR_GNU 1 1911#define OBJ_ATTR_FIRST OBJ_ATTR_PROC 1912#define OBJ_ATTR_LAST OBJ_ATTR_GNU 1913 1914/* The following object attribute tags are taken as generic, for all 1915 targets and for "gnu" where there is no target standard. */ 1916enum 1917{ 1918 Tag_NULL = 0, 1919 Tag_File = 1, 1920 Tag_Section = 2, 1921 Tag_Symbol = 3, 1922 Tag_compatibility = 32 1923}; 1924 1925/* The following struct stores information about every SystemTap section 1926 found in the object file. */ 1927struct sdt_note 1928{ 1929 struct sdt_note *next; 1930 bfd_size_type size; 1931 bfd_byte data[1]; 1932}; 1933 1934/* tdata information grabbed from an elf core file. */ 1935struct core_elf_obj_tdata 1936{ 1937 int signal; 1938 int pid; 1939 int lwpid; 1940 char* program; 1941 char* command; 1942}; 1943 1944/* Extra tdata information held for output ELF BFDs. */ 1945struct output_elf_obj_tdata 1946{ 1947 struct elf_segment_map *seg_map; 1948 struct elf_strtab_hash *strtab_ptr; 1949 1950 /* STT_SECTION symbols for each section */ 1951 asymbol **section_syms; 1952 1953 /* NT_GNU_BUILD_ID note type info. */ 1954 struct 1955 { 1956 bool (*after_write_object_contents) (bfd *); 1957 const char *style; 1958 asection *sec; 1959 } build_id; 1960 1961 /* FDO_PACKAGING_METADATA note type info. */ 1962 struct 1963 { 1964 bool (*after_write_object_contents) (bfd *); 1965 const char *json; 1966 asection *sec; 1967 } package_metadata; 1968 1969 /* Records the result of `get_program_header_size'. */ 1970 bfd_size_type program_header_size; 1971 1972 /* Used when laying out sections. */ 1973 file_ptr next_file_pos; 1974 1975 /* Linker information. */ 1976 struct bfd_link_info *link_info; 1977 1978 unsigned int num_section_syms; 1979 unsigned int shstrtab_section, strtab_section; 1980 1981 /* Segment flags for the PT_GNU_STACK segment. */ 1982 unsigned int stack_flags; 1983 1984 /* Used to determine if PT_GNU_SFRAME segment header should be 1985 created. */ 1986 asection *sframe; 1987 1988 /* Used to determine if the e_flags field has been initialized */ 1989 bool flags_init; 1990}; 1991 1992/* Indicate if the bfd contains SHF_GNU_MBIND/SHF_GNU_RETAIN sections or 1993 symbols that have the STT_GNU_IFUNC symbol type or STB_GNU_UNIQUE 1994 binding. Used to set the osabi field in the ELF header structure. */ 1995enum elf_gnu_osabi 1996{ 1997 elf_gnu_osabi_mbind = 1 << 0, 1998 elf_gnu_osabi_ifunc = 1 << 1, 1999 elf_gnu_osabi_unique = 1 << 2, 2000 elf_gnu_osabi_retain = 1 << 3, 2001}; 2002 2003typedef struct elf_section_list 2004{ 2005 Elf_Internal_Shdr hdr; 2006 unsigned int ndx; 2007 struct elf_section_list * next; 2008} elf_section_list; 2009 2010enum dynamic_lib_link_class { 2011 DYN_NORMAL = 0, 2012 DYN_AS_NEEDED = 1, 2013 DYN_DT_NEEDED = 2, 2014 DYN_NO_ADD_NEEDED = 4, 2015 DYN_NO_NEEDED = 8 2016}; 2017 2018/* Some private data is stashed away for future use using the tdata pointer 2019 in the bfd structure. */ 2020 2021struct elf_obj_tdata 2022{ 2023 Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */ 2024 Elf_Internal_Shdr **elf_sect_ptr; 2025 Elf_Internal_Phdr *phdr; 2026 Elf_Internal_Shdr symtab_hdr; 2027 Elf_Internal_Shdr shstrtab_hdr; 2028 Elf_Internal_Shdr strtab_hdr; 2029 Elf_Internal_Shdr dynsymtab_hdr; 2030 Elf_Internal_Shdr dynstrtab_hdr; 2031 Elf_Internal_Shdr dynversym_hdr; 2032 Elf_Internal_Shdr dynverref_hdr; 2033 Elf_Internal_Shdr dynverdef_hdr; 2034 elf_section_list * symtab_shndx_list; 2035 bfd_vma gp; /* The gp value */ 2036 unsigned int gp_size; /* The gp size */ 2037 unsigned int num_elf_sections; /* elf_sect_ptr size */ 2038 unsigned char *being_created; 2039 2040 /* A mapping from external symbols to entries in the linker hash 2041 table, used when linking. This is indexed by the symbol index 2042 minus the sh_info field of the symbol table header. */ 2043 struct elf_link_hash_entry **sym_hashes; 2044 2045 /* Track usage and final offsets of GOT entries for local symbols. 2046 This array is indexed by symbol index. Elements are used 2047 identically to "got" in struct elf_link_hash_entry. */ 2048 union 2049 { 2050 bfd_signed_vma *refcounts; 2051 bfd_vma *offsets; 2052 struct got_entry **ents; 2053 } local_got; 2054 2055 /* The linker ELF emulation code needs to let the backend ELF linker 2056 know what filename should be used for a dynamic object if the 2057 dynamic object is found using a search. The emulation code then 2058 sometimes needs to know what name was actually used. Until the 2059 file has been added to the linker symbol table, this field holds 2060 the name the linker wants. After it has been added, it holds the 2061 name actually used, which will be the DT_SONAME entry if there is 2062 one. */ 2063 const char *dt_name; 2064 2065 /* The linker emulation needs to know what audit libs 2066 are used by a dynamic object. */ 2067 const char *dt_audit; 2068 2069 /* Used by find_nearest_line entry point. */ 2070 void *line_info; 2071 2072 /* A place to stash dwarf1 info for this bfd. */ 2073 struct dwarf1_debug *dwarf1_find_line_info; 2074 2075 /* A place to stash dwarf2 info for this bfd. */ 2076 void *dwarf2_find_line_info; 2077 2078 /* Stash away info for yet another find line/function variant. */ 2079 void *elf_find_function_cache; 2080 2081 /* Number of symbol version definitions we are about to emit. */ 2082 unsigned int cverdefs; 2083 2084 /* Number of symbol version references we are about to emit. */ 2085 unsigned int cverrefs; 2086 2087 /* Symbol version definitions in external objects. */ 2088 Elf_Internal_Verdef *verdef; 2089 2090 /* Symbol version references to external objects. */ 2091 Elf_Internal_Verneed *verref; 2092 2093 /* A pointer to the .eh_frame section. */ 2094 asection *eh_frame_section; 2095 2096 /* Symbol buffer. */ 2097 void *symbuf; 2098 2099 /* List of GNU properties. Will be updated by setup_gnu_properties 2100 after all input GNU properties are merged for output. */ 2101 elf_property_list *properties; 2102 2103 obj_attribute known_obj_attributes[2][NUM_KNOWN_OBJ_ATTRIBUTES]; 2104 obj_attribute_list *other_obj_attributes[2]; 2105 2106 /* Linked-list containing information about every Systemtap section 2107 found in the object file. Each section corresponds to one entry 2108 in the list. */ 2109 struct sdt_note *sdt_note_head; 2110 2111 Elf_Internal_Shdr **group_sect_ptr; 2112 unsigned int num_group; 2113 2114 /* Index into group_sect_ptr, updated by setup_group when finding a 2115 section's group. Used to optimize subsequent group searches. */ 2116 unsigned int group_search_offset; 2117 2118 unsigned int symtab_section, dynsymtab_section; 2119 unsigned int dynversym_section, dynverdef_section, dynverref_section; 2120 2121 /* An identifier used to distinguish different target 2122 specific extensions to this structure. */ 2123 ENUM_BITFIELD (elf_target_id) object_id : 6; 2124 2125 /* Whether a dyanmic object was specified normally on the linker 2126 command line, or was specified when --as-needed was in effect, 2127 or was found via a DT_NEEDED entry. */ 2128 ENUM_BITFIELD (dynamic_lib_link_class) dyn_lib_class : 4; 2129 2130 /* Whether the bfd uses OS specific bits that require ELFOSABI_GNU. */ 2131 ENUM_BITFIELD (elf_gnu_osabi) has_gnu_osabi : 4; 2132 2133 /* Whether if the bfd contains the GNU_PROPERTY_NO_COPY_ON_PROTECTED 2134 property. */ 2135 unsigned int has_no_copy_on_protected : 1; 2136 2137 /* Whether if the bfd contains the 2138 GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS property. */ 2139 unsigned int has_indirect_extern_access : 1; 2140 2141 /* Irix 5 often screws up the symbol table, sorting local symbols 2142 after global symbols. This flag is set if the symbol table in 2143 this BFD appears to be screwed up. If it is, we ignore the 2144 sh_info field in the symbol table header, and always read all the 2145 symbols. */ 2146 unsigned int bad_symtab : 1; 2147 2148 /* Set if DT_FLAGS_1 has DF_1_PIE set. */ 2149 unsigned int is_pie : 1; 2150 2151 /* Information grabbed from an elf core file. */ 2152 struct core_elf_obj_tdata *core; 2153 2154 /* More information held for output ELF BFDs. */ 2155 struct output_elf_obj_tdata *o; 2156}; 2157 2158#define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data) 2159 2160#define elf_object_id(bfd) (elf_tdata(bfd) -> object_id) 2161#define elf_program_header_size(bfd) (elf_tdata(bfd) -> o->program_header_size) 2162#define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header) 2163#define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr) 2164#define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections) 2165#define elf_seg_map(bfd) (elf_tdata(bfd) -> o->seg_map) 2166#define elf_link_info(bfd) (elf_tdata(bfd) -> o->link_info) 2167#define elf_next_file_pos(bfd) (elf_tdata(bfd) -> o->next_file_pos) 2168#define elf_stack_flags(bfd) (elf_tdata(bfd) -> o->stack_flags) 2169#define elf_sframe(bfd) (elf_tdata(bfd) -> o->sframe) 2170#define elf_shstrtab(bfd) (elf_tdata(bfd) -> o->strtab_ptr) 2171#define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section) 2172#define elf_symtab_shndx_list(bfd) (elf_tdata(bfd) -> symtab_shndx_list) 2173#define elf_strtab_sec(bfd) (elf_tdata(bfd) -> o->strtab_section) 2174#define elf_shstrtab_sec(bfd) (elf_tdata(bfd) -> o->shstrtab_section) 2175#define elf_symtab_hdr(bfd) (elf_tdata(bfd) -> symtab_hdr) 2176#define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section) 2177#define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section) 2178#define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section) 2179#define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section) 2180#define elf_eh_frame_section(bfd) \ 2181 (elf_tdata(bfd) -> eh_frame_section) 2182#define elf_section_syms(bfd) (elf_tdata(bfd) -> o->section_syms) 2183#define elf_num_section_syms(bfd) (elf_tdata(bfd) -> o->num_section_syms) 2184#define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo) 2185#define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus) 2186#define elf_gp(bfd) (elf_tdata(bfd) -> gp) 2187#define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size) 2188#define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes) 2189#define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts) 2190#define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets) 2191#define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents) 2192#define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name) 2193#define elf_dt_audit(bfd) (elf_tdata(bfd) -> dt_audit) 2194#define elf_dyn_lib_class(bfd) (elf_tdata(bfd) -> dyn_lib_class) 2195#define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab) 2196#define elf_flags_init(bfd) (elf_tdata(bfd) -> o->flags_init) 2197#define elf_known_obj_attributes(bfd) (elf_tdata (bfd) -> known_obj_attributes) 2198#define elf_other_obj_attributes(bfd) (elf_tdata (bfd) -> other_obj_attributes) 2199#define elf_known_obj_attributes_proc(bfd) \ 2200 (elf_known_obj_attributes (bfd) [OBJ_ATTR_PROC]) 2201#define elf_other_obj_attributes_proc(bfd) \ 2202 (elf_other_obj_attributes (bfd) [OBJ_ATTR_PROC]) 2203#define elf_properties(bfd) (elf_tdata (bfd) -> properties) 2204#define elf_has_no_copy_on_protected(bfd) \ 2205 (elf_tdata(bfd) -> has_no_copy_on_protected) 2206#define elf_has_indirect_extern_access(bfd) \ 2207 (elf_tdata(bfd) -> has_indirect_extern_access) 2208 2209extern void _bfd_elf_swap_verdef_in 2210 (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *); 2211extern void _bfd_elf_swap_verdef_out 2212 (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *); 2213extern void _bfd_elf_swap_verdaux_in 2214 (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *); 2215extern void _bfd_elf_swap_verdaux_out 2216 (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *); 2217extern void _bfd_elf_swap_verneed_in 2218 (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *); 2219extern void _bfd_elf_swap_verneed_out 2220 (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *); 2221extern void _bfd_elf_swap_vernaux_in 2222 (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *); 2223extern void _bfd_elf_swap_vernaux_out 2224 (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *); 2225extern void _bfd_elf_swap_versym_in 2226 (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *); 2227extern void _bfd_elf_swap_versym_out 2228 (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *); 2229 2230extern unsigned int _bfd_elf_section_from_bfd_section 2231 (bfd *, asection *); 2232extern char *bfd_elf_string_from_elf_section 2233 (bfd *, unsigned, unsigned); 2234extern Elf_Internal_Sym *bfd_elf_get_elf_syms 2235 (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *, 2236 Elf_External_Sym_Shndx *); 2237extern char * bfd_elf_get_str_section (bfd *, unsigned int); 2238extern const char *bfd_elf_sym_name 2239 (bfd *, Elf_Internal_Shdr *, Elf_Internal_Sym *, asection *); 2240 2241extern bool _bfd_elf_copy_private_bfd_data 2242 (bfd *, bfd *); 2243extern bool _bfd_elf_print_private_bfd_data 2244 (bfd *, void *); 2245const char * _bfd_elf_get_symbol_version_string 2246 (bfd *, asymbol *, bool, bool *); 2247extern void bfd_elf_print_symbol 2248 (bfd *, void *, asymbol *, bfd_print_symbol_type); 2249 2250extern unsigned int _bfd_elf_eh_frame_address_size 2251 (bfd *, const asection *); 2252extern bfd_byte _bfd_elf_encode_eh_address 2253 (bfd *abfd, struct bfd_link_info *info, asection *osec, bfd_vma offset, 2254 asection *loc_sec, bfd_vma loc_offset, bfd_vma *encoded); 2255extern bool _bfd_elf_can_make_relative 2256 (bfd *input_bfd, struct bfd_link_info *info, asection *eh_frame_section); 2257 2258extern enum elf_reloc_type_class _bfd_elf_reloc_type_class 2259 (const struct bfd_link_info *, const asection *, 2260 const Elf_Internal_Rela *); 2261extern bfd_vma _bfd_elf_rela_local_sym 2262 (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *); 2263extern bfd_vma _bfd_elf_rel_local_sym 2264 (bfd *, Elf_Internal_Sym *, asection **, bfd_vma); 2265extern bfd_vma _bfd_elf_section_offset 2266 (bfd *, struct bfd_link_info *, asection *, bfd_vma); 2267 2268extern unsigned long bfd_elf_hash 2269 (const char *); 2270extern unsigned long bfd_elf_gnu_hash 2271 (const char *); 2272 2273extern bfd_reloc_status_type bfd_elf_generic_reloc 2274 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 2275extern bool bfd_elf_allocate_object 2276 (bfd *, size_t, enum elf_target_id); 2277extern bool bfd_elf_make_object 2278 (bfd *); 2279extern bool bfd_elf_mkcorefile 2280 (bfd *); 2281extern bool _bfd_elf_make_section_from_shdr 2282 (bfd *, Elf_Internal_Shdr *, const char *, int); 2283extern bool _bfd_elf_make_section_from_phdr 2284 (bfd *, Elf_Internal_Phdr *, int, const char *); 2285extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc 2286 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); 2287extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create 2288 (bfd *); 2289extern void _bfd_elf_link_hash_table_free 2290 (bfd *); 2291extern void _bfd_elf_link_hash_copy_indirect 2292 (struct bfd_link_info *, struct elf_link_hash_entry *, 2293 struct elf_link_hash_entry *); 2294extern void _bfd_elf_link_hash_hide_symbol 2295 (struct bfd_link_info *, struct elf_link_hash_entry *, bool); 2296extern void _bfd_elf_link_hide_symbol 2297 (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *); 2298extern bool _bfd_elf_link_hash_fixup_symbol 2299 (struct bfd_link_info *, struct elf_link_hash_entry *); 2300extern bool _bfd_elf_link_hash_table_init 2301 (struct elf_link_hash_table *, bfd *, 2302 struct bfd_hash_entry *(*) 2303 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *), 2304 unsigned int, enum elf_target_id); 2305extern bool _bfd_elf_slurp_version_tables 2306 (bfd *, bool); 2307extern bool _bfd_elf_merge_sections 2308 (bfd *, struct bfd_link_info *); 2309extern bool _bfd_elf_match_sections_by_type 2310 (bfd *, const asection *, bfd *, const asection *); 2311extern bool bfd_elf_is_group_section 2312 (bfd *, const struct bfd_section *); 2313extern const char *bfd_elf_group_name 2314 (bfd *, const struct bfd_section *); 2315extern bool _bfd_elf_section_already_linked 2316 (bfd *, asection *, struct bfd_link_info *); 2317extern void bfd_elf_set_group_contents 2318 (bfd *, asection *, void *); 2319extern unsigned int _bfd_elf_filter_global_symbols 2320 (bfd *, struct bfd_link_info *, asymbol **, long); 2321extern asection *_bfd_elf_check_kept_section 2322 (asection *, struct bfd_link_info *); 2323#define _bfd_elf_link_just_syms _bfd_generic_link_just_syms 2324extern void _bfd_elf_copy_link_hash_symbol_type 2325 (bfd *, struct bfd_link_hash_entry *, struct bfd_link_hash_entry *); 2326extern bool _bfd_elf_size_group_sections 2327 (struct bfd_link_info *); 2328extern bool _bfd_elf_fixup_group_sections 2329(bfd *, asection *); 2330extern bool _bfd_elf_copy_private_header_data 2331 (bfd *, bfd *); 2332extern bool _bfd_elf_copy_private_symbol_data 2333 (bfd *, asymbol *, bfd *, asymbol *); 2334#define _bfd_generic_init_private_section_data \ 2335 _bfd_elf_init_private_section_data 2336extern bool _bfd_elf_init_private_section_data 2337 (bfd *, asection *, bfd *, asection *, struct bfd_link_info *); 2338extern bool _bfd_elf_copy_private_section_data 2339 (bfd *, asection *, bfd *, asection *); 2340extern bool _bfd_elf_write_object_contents 2341 (bfd *); 2342extern bool _bfd_elf_write_corefile_contents 2343 (bfd *); 2344extern bool _bfd_elf_set_section_contents 2345 (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type); 2346extern long _bfd_elf_get_symtab_upper_bound 2347 (bfd *); 2348extern long _bfd_elf_canonicalize_symtab 2349 (bfd *, asymbol **); 2350extern long _bfd_elf_get_dynamic_symtab_upper_bound 2351 (bfd *); 2352extern long _bfd_elf_canonicalize_dynamic_symtab 2353 (bfd *, asymbol **); 2354extern long _bfd_elf_get_synthetic_symtab 2355 (bfd *, long, asymbol **, long, asymbol **, asymbol **); 2356extern long _bfd_elf_get_reloc_upper_bound 2357 (bfd *, sec_ptr); 2358extern long _bfd_elf_canonicalize_reloc 2359 (bfd *, sec_ptr, arelent **, asymbol **); 2360extern asection * _bfd_elf_get_dynamic_reloc_section 2361 (bfd *, asection *, bool); 2362extern asection * _bfd_elf_make_dynamic_reloc_section 2363 (asection *, bfd *, unsigned int, bfd *, bool); 2364extern long _bfd_elf_get_dynamic_reloc_upper_bound 2365 (bfd *); 2366extern long _bfd_elf_canonicalize_dynamic_reloc 2367 (bfd *, arelent **, asymbol **); 2368extern asymbol *_bfd_elf_make_empty_symbol 2369 (bfd *); 2370extern void _bfd_elf_get_symbol_info 2371 (bfd *, asymbol *, symbol_info *); 2372extern bool _bfd_elf_is_local_label_name 2373 (bfd *, const char *); 2374extern alent *_bfd_elf_get_lineno 2375 (bfd *, asymbol *); 2376extern bool _bfd_elf_set_arch_mach 2377 (bfd *, enum bfd_architecture, unsigned long); 2378extern bool _bfd_elf_find_nearest_line 2379 (bfd *, asymbol **, asection *, bfd_vma, 2380 const char **, const char **, unsigned int *, unsigned int *); 2381extern bool _bfd_elf_find_nearest_line_with_alt 2382 (bfd *, const char *, asymbol **, asection *, bfd_vma, 2383 const char **, const char **, unsigned int *, unsigned int *); 2384extern bool _bfd_elf_find_line 2385 (bfd *, asymbol **, asymbol *, const char **, unsigned int *); 2386extern bool _bfd_elf_find_inliner_info 2387 (bfd *, const char **, const char **, unsigned int *); 2388extern asymbol *_bfd_elf_find_function 2389 (bfd *, asymbol **, asection *, bfd_vma, const char **, const char **); 2390#define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols 2391#define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 2392extern int _bfd_elf_sizeof_headers 2393 (bfd *, struct bfd_link_info *); 2394extern bool _bfd_elf_new_section_hook 2395 (bfd *, asection *); 2396extern const struct bfd_elf_special_section *_bfd_elf_get_special_section 2397 (const char *, const struct bfd_elf_special_section *, unsigned int); 2398extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr 2399 (bfd *, asection *); 2400 2401extern bool _bfd_elf_link_hide_sym_by_version 2402 (struct bfd_link_info *, struct elf_link_hash_entry *); 2403 2404/* If the target doesn't have reloc handling written yet: */ 2405extern bool _bfd_elf_no_info_to_howto 2406 (bfd *, arelent *, Elf_Internal_Rela *); 2407 2408extern bool bfd_section_from_shdr 2409 (bfd *, unsigned int shindex); 2410extern bool bfd_section_from_phdr 2411 (bfd *, Elf_Internal_Phdr *, int); 2412 2413extern int _bfd_elf_symbol_from_bfd_symbol 2414 (bfd *, asymbol **); 2415 2416extern Elf_Internal_Sym *bfd_sym_from_r_symndx 2417 (struct sym_cache *, bfd *, unsigned long); 2418extern asection *bfd_section_from_elf_index 2419 (bfd *, unsigned int); 2420 2421extern struct elf_strtab_hash * _bfd_elf_strtab_init 2422 (void); 2423extern void _bfd_elf_strtab_free 2424 (struct elf_strtab_hash *); 2425extern size_t _bfd_elf_strtab_add 2426 (struct elf_strtab_hash *, const char *, bool); 2427extern void _bfd_elf_strtab_addref 2428 (struct elf_strtab_hash *, size_t); 2429extern void _bfd_elf_strtab_delref 2430 (struct elf_strtab_hash *, size_t); 2431extern unsigned int _bfd_elf_strtab_refcount 2432 (struct elf_strtab_hash *, size_t); 2433extern void _bfd_elf_strtab_clear_all_refs 2434 (struct elf_strtab_hash *); 2435extern void *_bfd_elf_strtab_save 2436 (struct elf_strtab_hash *); 2437extern void _bfd_elf_strtab_restore 2438 (struct elf_strtab_hash *, void *); 2439extern bfd_size_type _bfd_elf_strtab_size 2440 (struct elf_strtab_hash *); 2441extern bfd_size_type _bfd_elf_strtab_len 2442 (struct elf_strtab_hash *); 2443extern bfd_size_type _bfd_elf_strtab_offset 2444 (struct elf_strtab_hash *, size_t); 2445extern const char * _bfd_elf_strtab_str 2446 (struct elf_strtab_hash *, size_t idx, bfd_size_type *offset); 2447extern bool _bfd_elf_strtab_emit 2448 (bfd *, struct elf_strtab_hash *); 2449extern void _bfd_elf_strtab_finalize 2450 (struct elf_strtab_hash *); 2451 2452extern bool bfd_elf_parse_eh_frame_entries 2453 (bfd *, struct bfd_link_info *); 2454extern bool _bfd_elf_parse_eh_frame_entry 2455 (struct bfd_link_info *, asection *, struct elf_reloc_cookie *); 2456extern void _bfd_elf_parse_eh_frame 2457 (bfd *, struct bfd_link_info *, asection *, struct elf_reloc_cookie *); 2458extern bool _bfd_elf_end_eh_frame_parsing 2459 (struct bfd_link_info *info); 2460 2461extern bool _bfd_elf_discard_section_eh_frame 2462 (bfd *, struct bfd_link_info *, asection *, 2463 bool (*) (bfd_vma, void *), struct elf_reloc_cookie *); 2464extern bool _bfd_elf_adjust_eh_frame_global_symbol 2465 (struct elf_link_hash_entry *, void *); 2466extern bool _bfd_elf_discard_section_eh_frame_hdr 2467 (struct bfd_link_info *); 2468extern bfd_vma _bfd_elf_eh_frame_section_offset 2469 (bfd *, struct bfd_link_info *, asection *, bfd_vma); 2470extern bool _bfd_elf_write_section_eh_frame 2471 (bfd *, struct bfd_link_info *, asection *, bfd_byte *); 2472bool _bfd_elf_write_section_eh_frame_entry 2473 (bfd *, struct bfd_link_info *, asection *, bfd_byte *); 2474extern bool _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *); 2475extern bool _bfd_elf_write_section_eh_frame_hdr 2476 (bfd *, struct bfd_link_info *); 2477extern bool _bfd_elf_eh_frame_present 2478 (struct bfd_link_info *); 2479extern bool _bfd_elf_eh_frame_entry_present 2480 (struct bfd_link_info *); 2481extern bool _bfd_elf_maybe_strip_eh_frame_hdr 2482 (struct bfd_link_info *); 2483 2484extern bool _bfd_elf_sframe_present 2485 (struct bfd_link_info *); 2486extern bool _bfd_elf_parse_sframe 2487 (bfd *, struct bfd_link_info *, asection *, struct elf_reloc_cookie *); 2488extern bool _bfd_elf_discard_section_sframe 2489 (asection *, bool (*) (bfd_vma, void *), struct elf_reloc_cookie *); 2490extern bool _bfd_elf_merge_section_sframe 2491 (bfd *, struct bfd_link_info *, asection *, bfd_byte *); 2492extern bool _bfd_elf_write_section_sframe 2493 (bfd *, struct bfd_link_info *); 2494extern bool _bfd_elf_set_section_sframe (bfd *, struct bfd_link_info *); 2495 2496extern bool _bfd_elf_hash_symbol (struct elf_link_hash_entry *); 2497 2498extern long _bfd_elf_link_lookup_local_dynindx 2499 (struct bfd_link_info *, bfd *, long); 2500extern bool _bfd_elf_compute_section_file_positions 2501 (bfd *, struct bfd_link_info *); 2502extern file_ptr _bfd_elf_assign_file_position_for_section 2503 (Elf_Internal_Shdr *, file_ptr, bool); 2504extern bool _bfd_elf_modify_headers 2505 (bfd *, struct bfd_link_info *); 2506 2507extern bool _bfd_elf_validate_reloc 2508 (bfd *, arelent *); 2509 2510extern bool bfd_elf_record_link_assignment 2511 (bfd *, struct bfd_link_info *, const char *, bool, 2512 bool); 2513extern bool bfd_elf_stack_segment_size (bfd *, struct bfd_link_info *, 2514 const char *, bfd_vma); 2515extern bool bfd_elf_size_dynamic_sections 2516 (bfd *, const char *, const char *, const char *, const char *, const char *, 2517 const char * const *, struct bfd_link_info *, struct bfd_section **); 2518extern bool bfd_elf_size_dynsym_hash_dynstr 2519 (bfd *, struct bfd_link_info *); 2520extern bool bfd_elf_get_bfd_needed_list 2521 (bfd *, struct bfd_link_needed_list **); 2522extern struct bfd_link_needed_list *bfd_elf_get_needed_list 2523 (bfd *, struct bfd_link_info *); 2524extern void bfd_elf_set_dt_needed_name 2525 (bfd *, const char *); 2526extern const char *bfd_elf_get_dt_soname 2527 (bfd *); 2528extern void bfd_elf_set_dyn_lib_class 2529 (bfd *, enum dynamic_lib_link_class); 2530extern int bfd_elf_get_dyn_lib_class 2531 (bfd *); 2532extern struct bfd_link_needed_list *bfd_elf_get_runpath_list 2533 (bfd *, struct bfd_link_info *); 2534extern int bfd_elf_discard_info 2535 (bfd *, struct bfd_link_info *); 2536extern unsigned int _bfd_elf_default_action_discarded 2537 (struct bfd_section *); 2538extern struct bfd_section *_bfd_elf_tls_setup 2539 (bfd *, struct bfd_link_info *); 2540 2541extern bool _bfd_elf_link_create_dynamic_sections 2542 (bfd *, struct bfd_link_info *); 2543extern bool _bfd_elf_omit_section_dynsym_default 2544 (bfd *, struct bfd_link_info *, asection *); 2545extern bool _bfd_elf_omit_section_dynsym_all 2546 (bfd *, struct bfd_link_info *, asection *); 2547extern bool _bfd_elf_create_dynamic_sections 2548 (bfd *, struct bfd_link_info *); 2549extern bool _bfd_elf_create_got_section 2550 (bfd *, struct bfd_link_info *); 2551extern asection *_bfd_elf_section_for_symbol 2552 (struct elf_reloc_cookie *, unsigned long, bool); 2553extern struct elf_link_hash_entry *_bfd_elf_define_linkage_sym 2554 (bfd *, struct bfd_link_info *, asection *, const char *); 2555extern void _bfd_elf_init_1_index_section 2556 (bfd *, struct bfd_link_info *); 2557extern void _bfd_elf_init_2_index_sections 2558 (bfd *, struct bfd_link_info *); 2559 2560extern bool _bfd_elfcore_make_pseudosection 2561 (bfd *, char *, size_t, ufile_ptr); 2562extern char *_bfd_elfcore_strndup 2563 (bfd *, char *, size_t); 2564 2565extern Elf_Internal_Rela *_bfd_elf_link_read_relocs 2566 (bfd *, asection *, void *, Elf_Internal_Rela *, bool); 2567extern Elf_Internal_Rela *_bfd_elf_link_info_read_relocs 2568 (bfd *, struct bfd_link_info *, asection *, void *, Elf_Internal_Rela *, 2569 bool); 2570 2571extern bool _bfd_elf_link_output_relocs 2572 (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *, 2573 struct elf_link_hash_entry **); 2574 2575extern bool _bfd_elf_adjust_dynamic_copy 2576 (struct bfd_link_info *, struct elf_link_hash_entry *, asection *); 2577 2578extern bool _bfd_elf_dynamic_symbol_p 2579 (struct elf_link_hash_entry *, struct bfd_link_info *, bool); 2580 2581extern bool _bfd_elf_symbol_refs_local_p 2582 (struct elf_link_hash_entry *, struct bfd_link_info *, bool); 2583 2584extern bfd_reloc_status_type bfd_elf_perform_complex_relocation 2585 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma); 2586 2587extern bool _bfd_elf_setup_sections 2588 (bfd *); 2589 2590extern struct bfd_link_hash_entry *bfd_elf_define_start_stop 2591 (struct bfd_link_info *, const char *, asection *); 2592 2593extern bool _bfd_elf_init_file_header (bfd *, struct bfd_link_info *); 2594 2595extern bool _bfd_elf_final_write_processing (bfd *); 2596 2597extern bfd_cleanup bfd_elf32_object_p 2598 (bfd *); 2599extern bfd_cleanup bfd_elf32_core_file_p 2600 (bfd *); 2601extern char *bfd_elf32_core_file_failing_command 2602 (bfd *); 2603extern int bfd_elf32_core_file_failing_signal 2604 (bfd *); 2605extern bool bfd_elf32_core_file_matches_executable_p 2606 (bfd *, bfd *); 2607extern int bfd_elf32_core_file_pid 2608 (bfd *); 2609extern bool _bfd_elf32_core_find_build_id 2610 (bfd *, bfd_vma); 2611 2612extern bool bfd_elf32_swap_symbol_in 2613 (bfd *, const void *, const void *, Elf_Internal_Sym *); 2614extern void bfd_elf32_swap_symbol_out 2615 (bfd *, const Elf_Internal_Sym *, void *, void *); 2616extern void bfd_elf32_swap_reloc_in 2617 (bfd *, const bfd_byte *, Elf_Internal_Rela *); 2618extern void bfd_elf32_swap_reloc_out 2619 (bfd *, const Elf_Internal_Rela *, bfd_byte *); 2620extern void bfd_elf32_swap_reloca_in 2621 (bfd *, const bfd_byte *, Elf_Internal_Rela *); 2622extern void bfd_elf32_swap_reloca_out 2623 (bfd *, const Elf_Internal_Rela *, bfd_byte *); 2624extern void bfd_elf32_swap_phdr_in 2625 (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *); 2626extern void bfd_elf32_swap_phdr_out 2627 (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *); 2628extern void bfd_elf32_swap_dyn_in 2629 (bfd *, const void *, Elf_Internal_Dyn *); 2630extern void bfd_elf32_swap_dyn_out 2631 (bfd *, const Elf_Internal_Dyn *, void *); 2632extern long bfd_elf32_slurp_symbol_table 2633 (bfd *, asymbol **, bool); 2634extern bool bfd_elf32_write_shdrs_and_ehdr 2635 (bfd *); 2636extern int bfd_elf32_write_out_phdrs 2637 (bfd *, const Elf_Internal_Phdr *, unsigned int); 2638extern bool bfd_elf32_checksum_contents 2639 (bfd * , void (*) (const void *, size_t, void *), void *); 2640extern void bfd_elf32_write_relocs 2641 (bfd *, asection *, void *); 2642extern bool bfd_elf32_slurp_reloc_table 2643 (bfd *, asection *, asymbol **, bool); 2644 2645extern bfd_cleanup bfd_elf64_object_p 2646 (bfd *); 2647extern bfd_cleanup bfd_elf64_core_file_p 2648 (bfd *); 2649extern char *bfd_elf64_core_file_failing_command 2650 (bfd *); 2651extern int bfd_elf64_core_file_failing_signal 2652 (bfd *); 2653extern bool bfd_elf64_core_file_matches_executable_p 2654 (bfd *, bfd *); 2655extern int bfd_elf64_core_file_pid 2656 (bfd *); 2657extern bool _bfd_elf64_core_find_build_id 2658 (bfd *, bfd_vma); 2659 2660extern bool bfd_elf64_swap_symbol_in 2661 (bfd *, const void *, const void *, Elf_Internal_Sym *); 2662extern void bfd_elf64_swap_symbol_out 2663 (bfd *, const Elf_Internal_Sym *, void *, void *); 2664extern void bfd_elf64_swap_reloc_in 2665 (bfd *, const bfd_byte *, Elf_Internal_Rela *); 2666extern void bfd_elf64_swap_reloc_out 2667 (bfd *, const Elf_Internal_Rela *, bfd_byte *); 2668extern void bfd_elf64_swap_reloca_in 2669 (bfd *, const bfd_byte *, Elf_Internal_Rela *); 2670extern void bfd_elf64_swap_reloca_out 2671 (bfd *, const Elf_Internal_Rela *, bfd_byte *); 2672extern void bfd_elf64_swap_phdr_in 2673 (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *); 2674extern void bfd_elf64_swap_phdr_out 2675 (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *); 2676extern void bfd_elf64_swap_dyn_in 2677 (bfd *, const void *, Elf_Internal_Dyn *); 2678extern void bfd_elf64_swap_dyn_out 2679 (bfd *, const Elf_Internal_Dyn *, void *); 2680extern long bfd_elf64_slurp_symbol_table 2681 (bfd *, asymbol **, bool); 2682extern bool bfd_elf64_write_shdrs_and_ehdr 2683 (bfd *); 2684extern int bfd_elf64_write_out_phdrs 2685 (bfd *, const Elf_Internal_Phdr *, unsigned int); 2686extern bool bfd_elf64_checksum_contents 2687 (bfd * , void (*) (const void *, size_t, void *), void *); 2688extern void bfd_elf64_write_relocs 2689 (bfd *, asection *, void *); 2690extern bool bfd_elf64_slurp_reloc_table 2691 (bfd *, asection *, asymbol **, bool); 2692 2693extern bool _bfd_elf_default_relocs_compatible 2694 (const bfd_target *, const bfd_target *); 2695 2696extern bool _bfd_elf_relocs_compatible 2697 (const bfd_target *, const bfd_target *); 2698extern bool _bfd_elf_notice_as_needed 2699 (bfd *, struct bfd_link_info *, enum notice_asneeded_action); 2700 2701extern struct bfd_link_hash_entry *_bfd_elf_archive_symbol_lookup 2702 (bfd *, struct bfd_link_info *, const char *); 2703extern bool bfd_elf_link_add_symbols 2704 (bfd *, struct bfd_link_info *); 2705extern bool _bfd_elf_add_dynamic_entry 2706 (struct bfd_link_info *, bfd_vma, bfd_vma); 2707extern bool _bfd_elf_strip_zero_sized_dynamic_sections 2708 (struct bfd_link_info *); 2709extern int bfd_elf_add_dt_needed_tag 2710 (bfd *, struct bfd_link_info *); 2711extern bool _bfd_elf_link_check_relocs 2712 (bfd *, struct bfd_link_info *); 2713extern bool _bfd_elf_link_iterate_on_relocs 2714 (bfd *, struct bfd_link_info *, 2715 bool (*) (bfd *, struct bfd_link_info *, asection *, 2716 const Elf_Internal_Rela *)); 2717 2718extern bool bfd_elf_link_record_dynamic_symbol 2719 (struct bfd_link_info *, struct elf_link_hash_entry *); 2720 2721extern int bfd_elf_link_record_local_dynamic_symbol 2722 (struct bfd_link_info *, bfd *, long); 2723 2724extern bool _bfd_elf_close_and_cleanup 2725 (bfd *); 2726 2727extern bool _bfd_elf_common_definition 2728 (Elf_Internal_Sym *); 2729 2730extern unsigned int _bfd_elf_common_section_index 2731 (asection *); 2732 2733extern asection *_bfd_elf_common_section 2734 (asection *); 2735 2736extern bfd_vma _bfd_elf_default_got_elt_size 2737(bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, bfd *, 2738 unsigned long); 2739 2740extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn 2741 (bfd *, arelent *, struct bfd_symbol *, void *, 2742 asection *, bfd *, char **); 2743 2744extern bool bfd_elf_final_link 2745 (bfd *, struct bfd_link_info *); 2746 2747extern void _bfd_elf_gc_keep 2748 (struct bfd_link_info *info); 2749 2750extern bool bfd_elf_gc_mark_dynamic_ref_symbol 2751 (struct elf_link_hash_entry *h, void *inf); 2752 2753extern bool bfd_elf_gc_sections 2754 (bfd *, struct bfd_link_info *); 2755 2756extern bool bfd_elf_gc_record_vtinherit 2757 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma); 2758 2759extern bool bfd_elf_gc_record_vtentry 2760 (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma); 2761 2762extern asection *_bfd_elf_gc_mark_hook 2763 (asection *, struct bfd_link_info *, Elf_Internal_Rela *, 2764 struct elf_link_hash_entry *, Elf_Internal_Sym *); 2765 2766extern asection *_bfd_elf_gc_mark_rsec 2767 (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn, 2768 struct elf_reloc_cookie *, bool *); 2769 2770extern bool _bfd_elf_gc_mark_reloc 2771 (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn, 2772 struct elf_reloc_cookie *); 2773 2774extern bool _bfd_elf_gc_mark_fdes 2775 (struct bfd_link_info *, asection *, asection *, elf_gc_mark_hook_fn, 2776 struct elf_reloc_cookie *); 2777 2778extern bool _bfd_elf_gc_mark 2779 (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn); 2780 2781extern bool _bfd_elf_gc_mark_extra_sections 2782 (struct bfd_link_info *, elf_gc_mark_hook_fn); 2783 2784extern bool bfd_elf_gc_common_finalize_got_offsets 2785 (bfd *, struct bfd_link_info *); 2786 2787extern bool bfd_elf_gc_common_final_link 2788 (bfd *, struct bfd_link_info *); 2789 2790extern bool bfd_elf_reloc_symbol_deleted_p 2791 (bfd_vma, void *); 2792 2793extern struct elf_segment_map * _bfd_elf_make_dynamic_segment 2794 (bfd *, asection *); 2795 2796extern bool _bfd_elf_map_sections_to_segments 2797 (bfd *, struct bfd_link_info *, bool *); 2798 2799extern bool _bfd_elf_is_function_type (unsigned int); 2800 2801extern bfd_size_type _bfd_elf_maybe_function_sym (const asymbol *, asection *, 2802 bfd_vma *); 2803 2804extern asection *_bfd_elf_plt_get_reloc_section (bfd *, const char *); 2805 2806extern int bfd_elf_get_default_section_type (flagword); 2807 2808extern bool bfd_elf_lookup_section_flags 2809 (struct bfd_link_info *, struct flag_info *, asection *); 2810 2811extern Elf_Internal_Phdr * _bfd_elf_find_segment_containing_section 2812 (bfd * abfd, asection * section); 2813 2814/* PowerPC @tls opcode transform/validate. */ 2815extern unsigned int _bfd_elf_ppc_at_tls_transform 2816 (unsigned int, unsigned int); 2817/* PowerPC @tprel opcode transform/validate. */ 2818extern unsigned int _bfd_elf_ppc_at_tprel_transform 2819 (unsigned int, unsigned int); 2820/* PowerPC elf_object_p tweak. */ 2821extern bool _bfd_elf_ppc_set_arch (bfd *); 2822/* PowerPC .gnu.attributes handling common to both 32-bit and 64-bit. */ 2823extern bool _bfd_elf_ppc_merge_fp_attributes 2824 (bfd *, struct bfd_link_info *); 2825 2826/* Return an upper bound on the number of bytes required to store a 2827 copy of ABFD's program header table entries. Return -1 if an error 2828 occurs; bfd_get_error will return an appropriate code. */ 2829extern long bfd_get_elf_phdr_upper_bound 2830 (bfd *abfd); 2831 2832/* Copy ABFD's program header table entries to *PHDRS. The entries 2833 will be stored as an array of Elf_Internal_Phdr structures, as 2834 defined in include/elf/internal.h. To find out how large the 2835 buffer needs to be, call bfd_get_elf_phdr_upper_bound. 2836 2837 Return the number of program header table entries read, or -1 if an 2838 error occurs; bfd_get_error will return an appropriate code. */ 2839extern int bfd_get_elf_phdrs 2840 (bfd *abfd, void *phdrs); 2841 2842/* Exported interface for writing elf corefile notes. */ 2843extern char *elfcore_write_note 2844 (bfd *, char *, int *, const char *, int, const void *, int); 2845extern char *elfcore_write_prpsinfo 2846 (bfd *, char *, int *, const char *, const char *); 2847extern char *elfcore_write_prstatus 2848 (bfd *, char *, int *, long, int, const void *); 2849extern char * elfcore_write_pstatus 2850 (bfd *, char *, int *, long, int, const void *); 2851extern char *elfcore_write_prfpreg 2852 (bfd *, char *, int *, const void *, int); 2853extern char *elfcore_write_prxfpreg 2854 (bfd *, char *, int *, const void *, int); 2855extern char *elfcore_write_xstatereg 2856 (bfd *, char *, int *, const void *, int); 2857extern char *elfcore_write_x86_segbases 2858 (bfd *, char *, int *, const void *, int); 2859extern char *elfcore_write_ppc_vmx 2860 (bfd *, char *, int *, const void *, int); 2861extern char *elfcore_write_ppc_vsx 2862 (bfd *, char *, int *, const void *, int); 2863extern char *elfcore_write_ppc_tar 2864 (bfd *, char *, int *, const void *, int); 2865extern char *elfcore_write_ppc_ppr 2866 (bfd *, char *, int *, const void *, int); 2867extern char *elfcore_write_ppc_dscr 2868 (bfd *, char *, int *, const void *, int); 2869extern char *elfcore_write_ppc_ebb 2870 (bfd *, char *, int *, const void *, int); 2871extern char *elfcore_write_ppc_pmu 2872 (bfd *, char *, int *, const void *, int); 2873extern char *elfcore_write_ppc_tm_cgpr 2874 (bfd *, char *, int *, const void *, int); 2875extern char *elfcore_write_ppc_tm_cfpr 2876 (bfd *, char *, int *, const void *, int); 2877extern char *elfcore_write_ppc_tm_cvmx 2878 (bfd *, char *, int *, const void *, int); 2879extern char *elfcore_write_ppc_tm_cvsx 2880 (bfd *, char *, int *, const void *, int); 2881extern char *elfcore_write_ppc_tm_spr 2882 (bfd *, char *, int *, const void *, int); 2883extern char *elfcore_write_ppc_tm_ctar 2884 (bfd *, char *, int *, const void *, int); 2885extern char *elfcore_write_ppc_tm_cppr 2886 (bfd *, char *, int *, const void *, int); 2887extern char *elfcore_write_ppc_tm_cdscr 2888 (bfd *, char *, int *, const void *, int); 2889extern char *elfcore_write_s390_timer 2890 (bfd *, char *, int *, const void *, int); 2891extern char *elfcore_write_s390_todcmp 2892 (bfd *, char *, int *, const void *, int); 2893extern char *elfcore_write_s390_todpreg 2894 (bfd *, char *, int *, const void *, int); 2895extern char *elfcore_write_s390_ctrs 2896 (bfd *, char *, int *, const void *, int); 2897extern char *elfcore_write_s390_prefix 2898 (bfd *, char *, int *, const void *, int); 2899extern char *elfcore_write_s390_last_break 2900 (bfd *, char *, int *, const void *, int); 2901extern char *elfcore_write_s390_system_call 2902 (bfd *, char *, int *, const void *, int); 2903extern char *elfcore_write_s390_tdb 2904 (bfd *, char *, int *, const void *, int); 2905extern char *elfcore_write_s390_vxrs_low 2906 (bfd *, char *, int *, const void *, int); 2907extern char *elfcore_write_s390_vxrs_high 2908 (bfd *, char *, int *, const void *, int); 2909extern char *elfcore_write_s390_gs_cb 2910 (bfd *, char *, int *, const void *, int); 2911extern char *elfcore_write_s390_gs_bc 2912 (bfd *, char *, int *, const void *, int); 2913extern char *elfcore_write_arm_vfp 2914 (bfd *, char *, int *, const void *, int); 2915extern char *elfcore_write_aarch_tls 2916 (bfd *, char *, int *, const void *, int); 2917extern char *elfcore_write_aarch_hw_break 2918 (bfd *, char *, int *, const void *, int); 2919extern char *elfcore_write_aarch_hw_watch 2920 (bfd *, char *, int *, const void *, int); 2921extern char *elfcore_write_aarch_sve 2922 (bfd *, char *, int *, const void *, int); 2923extern char *elfcore_write_aarch_pauth 2924 (bfd *, char *, int *, const void *, int); 2925extern char *elfcore_write_aarch_mte 2926 (bfd *, char *, int *, const void *, int); 2927extern char *elfcore_write_arc_v2 2928 (bfd *, char *, int *, const void *, int); 2929extern char *elfcore_write_riscv_csr 2930 (bfd *, char *, int *, const void *, int); 2931extern char *elfcore_write_gdb_tdesc 2932 (bfd *, char *, int *, const void *, int); 2933extern char *elfcore_write_lwpstatus 2934 (bfd *, char *, int *, long, int, const void *); 2935extern char *elfcore_write_register_note 2936 (bfd *, char *, int *, const char *, const void *, int); 2937extern char *elfcore_write_file_note 2938 (bfd *, char *, int *, const void*, int); 2939extern char *elfcore_write_loongarch_cpucfg 2940 (bfd *, char *, int *, const void*, int); 2941extern char *elfcore_write_loongarch_lbt 2942 (bfd *, char *, int *, const void*, int); 2943extern char *elfcore_write_loongarch_lsx 2944 (bfd *, char *, int *, const void*, int); 2945extern char *elfcore_write_loongarch_lasx 2946 (bfd *, char *, int *, const void*, int); 2947 2948/* Internal structure which holds information to be included in the 2949 PRPSINFO section of Linux core files. 2950 2951 This is an "internal" structure in the sense that it should be used 2952 to pass information to BFD (via the `elfcore_write_linux_prpsinfo' 2953 function), so things like endianess shouldn't be an issue. This 2954 structure will eventually be converted in one of the 2955 `elf_external_linux_*' structures and written out to an output bfd 2956 by one of the functions declared below. */ 2957 2958struct elf_internal_linux_prpsinfo 2959 { 2960 char pr_state; /* Numeric process state. */ 2961 char pr_sname; /* Char for pr_state. */ 2962 char pr_zomb; /* Zombie. */ 2963 char pr_nice; /* Nice val. */ 2964 unsigned long pr_flag; /* Flags. */ 2965 unsigned int pr_uid; 2966 unsigned int pr_gid; 2967 int pr_pid, pr_ppid, pr_pgrp, pr_sid; 2968 char pr_fname[16 + 1]; /* Filename of executable. */ 2969 char pr_psargs[80 + 1]; /* Initial part of arg list. */ 2970 }; 2971 2972/* Linux/most 32-bit archs. */ 2973extern char *elfcore_write_linux_prpsinfo32 2974 (bfd *, char *, int *, const struct elf_internal_linux_prpsinfo *); 2975 2976/* Linux/most 64-bit archs. */ 2977extern char *elfcore_write_linux_prpsinfo64 2978 (bfd *, char *, int *, const struct elf_internal_linux_prpsinfo *); 2979 2980extern bfd *_bfd_elf32_bfd_from_remote_memory 2981 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep, 2982 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type)); 2983extern bfd *_bfd_elf64_bfd_from_remote_memory 2984 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep, 2985 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type)); 2986 2987extern bfd_vma bfd_elf_obj_attr_size (bfd *); 2988extern void bfd_elf_set_obj_attr_contents (bfd *, bfd_byte *, bfd_vma); 2989extern int bfd_elf_get_obj_attr_int (bfd *, int, unsigned int); 2990extern void bfd_elf_add_obj_attr_int (bfd *, int, unsigned int, unsigned int); 2991#define bfd_elf_add_proc_attr_int(BFD, TAG, VALUE) \ 2992 bfd_elf_add_obj_attr_int ((BFD), OBJ_ATTR_PROC, (TAG), (VALUE)) 2993extern void bfd_elf_add_obj_attr_string (bfd *, int, unsigned int, const char *); 2994#define bfd_elf_add_proc_attr_string(BFD, TAG, VALUE) \ 2995 bfd_elf_add_obj_attr_string ((BFD), OBJ_ATTR_PROC, (TAG), (VALUE)) 2996extern void bfd_elf_add_obj_attr_int_string (bfd *, int, unsigned int, 2997 unsigned int, const char *); 2998#define bfd_elf_add_proc_attr_int_string(BFD, TAG, INTVAL, STRVAL) \ 2999 bfd_elf_add_obj_attr_int_string ((BFD), OBJ_ATTR_PROC, (TAG), \ 3000 (INTVAL), (STRVAL)) 3001 3002extern char *_bfd_elf_attr_strdup (bfd *, const char *); 3003extern void _bfd_elf_copy_obj_attributes (bfd *, bfd *); 3004extern int _bfd_elf_obj_attrs_arg_type (bfd *, int, unsigned int); 3005extern void _bfd_elf_parse_attributes (bfd *, Elf_Internal_Shdr *); 3006extern bool _bfd_elf_merge_object_attributes 3007 (bfd *, struct bfd_link_info *); 3008extern bool _bfd_elf_merge_unknown_attribute_low (bfd *, bfd *, int); 3009extern bool _bfd_elf_merge_unknown_attribute_list (bfd *, bfd *); 3010extern Elf_Internal_Shdr *_bfd_elf_single_rel_hdr (asection *sec); 3011extern bool elf_read_notes (bfd *, file_ptr, bfd_size_type, size_t); 3012 3013extern bool _bfd_elf_parse_gnu_properties 3014 (bfd *, Elf_Internal_Note *); 3015extern elf_property * _bfd_elf_get_property 3016 (bfd *, unsigned int, unsigned int); 3017extern bfd *_bfd_elf_link_setup_gnu_properties 3018 (struct bfd_link_info *); 3019extern bfd_size_type _bfd_elf_convert_gnu_property_size 3020 (bfd *, bfd *); 3021extern bool _bfd_elf_convert_gnu_properties 3022 (bfd *, asection *, bfd *, bfd_byte **, bfd_size_type *); 3023 3024/* The linker may need to keep track of the number of relocs that it 3025 decides to copy as dynamic relocs in check_relocs for each symbol. 3026 This is so that it can later discard them if they are found to be 3027 unnecessary. We can store the information in a field extending the 3028 regular ELF linker hash table. */ 3029 3030struct elf_dyn_relocs 3031{ 3032 struct elf_dyn_relocs *next; 3033 3034 /* The input section of the reloc. */ 3035 asection *sec; 3036 3037 /* Total number of relocs copied for the input section. */ 3038 bfd_size_type count; 3039 3040 /* Number of pc-relative relocs copied for the input section. */ 3041 bfd_size_type pc_count; 3042}; 3043 3044extern bool _bfd_elf_create_ifunc_sections 3045 (bfd *, struct bfd_link_info *); 3046extern bool _bfd_elf_allocate_ifunc_dyn_relocs 3047 (struct bfd_link_info *, struct elf_link_hash_entry *, 3048 struct elf_dyn_relocs **, unsigned int, unsigned int, 3049 unsigned int, bool); 3050 3051extern void elf_append_rela (bfd *, asection *, Elf_Internal_Rela *); 3052extern void elf_append_rel (bfd *, asection *, Elf_Internal_Rela *); 3053 3054extern bfd_vma elf64_r_info (bfd_vma, bfd_vma); 3055extern bfd_vma elf64_r_sym (bfd_vma); 3056extern bfd_vma elf32_r_info (bfd_vma, bfd_vma); 3057extern bfd_vma elf32_r_sym (bfd_vma); 3058 3059extern bool is_debuginfo_file (bfd *); 3060 3061 3062extern bool _bfd_elf_init_secondary_reloc_section 3063 (bfd *, Elf_Internal_Shdr *, const char *, unsigned int); 3064extern bool _bfd_elf_slurp_secondary_reloc_section 3065 (bfd *, asection *, asymbol **, bool); 3066extern bool _bfd_elf_copy_special_section_fields 3067 (const bfd *, bfd *, const Elf_Internal_Shdr *, Elf_Internal_Shdr *); 3068extern bool _bfd_elf_write_secondary_reloc_section 3069 (bfd *, asection *); 3070extern unsigned int _bfd_elf_symbol_section_index 3071 (bfd *, elf_symbol_type *); 3072 3073extern asection *_bfd_elf_readonly_dynrelocs 3074 (struct elf_link_hash_entry *); 3075extern bool _bfd_elf_maybe_set_textrel 3076 (struct elf_link_hash_entry *, void *); 3077 3078extern bool _bfd_elf_add_dynamic_tags 3079 (bfd *, struct bfd_link_info *, bool); 3080 3081/* Large common section. */ 3082extern asection _bfd_elf_large_com_section; 3083 3084/* Hash for local symbol with the first section id, ID, in the input 3085 file and the local symbol index, SYM. */ 3086#define ELF_LOCAL_SYMBOL_HASH(ID, SYM) \ 3087 (((((ID) & 0xffU) << 24) | (((ID) & 0xff00) << 8)) \ 3088 ^ (SYM) ^ (((ID) & 0xffff0000U) >> 16)) 3089 3090/* This is the condition under which finish_dynamic_symbol will be called. 3091 If our finish_dynamic_symbol isn't called, we'll need to do something 3092 about initializing any .plt and .got entries in relocate_section. */ 3093#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \ 3094 ((DYN) \ 3095 && ((SHARED) || !(H)->forced_local) \ 3096 && ((H)->dynindx != -1 || (H)->forced_local)) 3097 3098/* This macro is to avoid lots of duplicated code in the body 3099 of xxx_relocate_section() in the various elfxx-xxxx.c files. */ 3100#define RELOC_FOR_GLOBAL_SYMBOL(info, input_bfd, input_section, rel, \ 3101 r_symndx, symtab_hdr, sym_hashes, \ 3102 h, sec, relocation, \ 3103 unresolved_reloc, warned, ignored) \ 3104 do \ 3105 { \ 3106 /* It seems this can happen with erroneous or unsupported \ 3107 input (mixing a.out and elf in an archive, for example.) */ \ 3108 if (sym_hashes == NULL) \ 3109 return false; \ 3110 \ 3111 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; \ 3112 \ 3113 if (info->wrap_hash != NULL \ 3114 && (input_section->flags & SEC_DEBUGGING) != 0) \ 3115 h = ((struct elf_link_hash_entry *) \ 3116 unwrap_hash_lookup (info, input_bfd, &h->root)); \ 3117 \ 3118 while (h->root.type == bfd_link_hash_indirect \ 3119 || h->root.type == bfd_link_hash_warning) \ 3120 h = (struct elf_link_hash_entry *) h->root.u.i.link; \ 3121 \ 3122 warned = false; \ 3123 ignored = false; \ 3124 unresolved_reloc = false; \ 3125 relocation = 0; \ 3126 if (h->root.type == bfd_link_hash_defined \ 3127 || h->root.type == bfd_link_hash_defweak) \ 3128 { \ 3129 sec = h->root.u.def.section; \ 3130 if (sec == NULL \ 3131 || sec->output_section == NULL) \ 3132 /* Set a flag that will be cleared later if we find a \ 3133 relocation value for this symbol. output_section \ 3134 is typically NULL for symbols satisfied by a shared \ 3135 library. */ \ 3136 unresolved_reloc = true; \ 3137 else \ 3138 relocation = (h->root.u.def.value \ 3139 + sec->output_section->vma \ 3140 + sec->output_offset); \ 3141 } \ 3142 else if (h->root.type == bfd_link_hash_undefweak) \ 3143 ; \ 3144 else if (info->unresolved_syms_in_objects == RM_IGNORE \ 3145 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) \ 3146 ignored = true; \ 3147 else if (!bfd_link_relocatable (info)) \ 3148 { \ 3149 bool err = ((info->unresolved_syms_in_objects == RM_DIAGNOSE \ 3150 && !info->warn_unresolved_syms) \ 3151 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT); \ 3152 (*info->callbacks->undefined_symbol) (info, \ 3153 h->root.root.string, \ 3154 input_bfd, \ 3155 input_section, \ 3156 rel->r_offset, err); \ 3157 warned = true; \ 3158 } \ 3159 (void) unresolved_reloc; \ 3160 (void) warned; \ 3161 (void) ignored; \ 3162 } \ 3163 while (0) 3164 3165/* This macro is to avoid lots of duplicated code in the body of the 3166 loop over relocations in xxx_relocate_section() in the various 3167 elfxx-xxxx.c files. 3168 3169 Handle relocations against symbols from removed linkonce sections, 3170 or sections discarded by a linker script. When doing a relocatable 3171 link, we remove such relocations. Otherwise, we just want the 3172 section contents zeroed and avoid any special processing. */ 3173#define RELOC_AGAINST_DISCARDED_SECTION(info, input_bfd, input_section, \ 3174 rel, count, relend, \ 3175 howto, index, contents) \ 3176 { \ 3177 int i_; \ 3178 _bfd_clear_contents (howto, input_bfd, input_section, \ 3179 contents, rel[index].r_offset); \ 3180 \ 3181 if (bfd_link_relocatable (info) \ 3182 && (input_section->flags & SEC_DEBUGGING)) \ 3183 { \ 3184 /* Only remove relocations in debug sections since other \ 3185 sections may require relocations. */ \ 3186 Elf_Internal_Shdr *rel_hdr; \ 3187 \ 3188 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); \ 3189 \ 3190 /* Avoid empty output section. */ \ 3191 if (rel_hdr->sh_size > rel_hdr->sh_entsize) \ 3192 { \ 3193 rel_hdr->sh_size -= rel_hdr->sh_entsize; \ 3194 rel_hdr = _bfd_elf_single_rel_hdr (input_section); \ 3195 rel_hdr->sh_size -= rel_hdr->sh_entsize; \ 3196 \ 3197 memmove (rel, rel + count, \ 3198 (relend - rel - count) * sizeof (*rel)); \ 3199 \ 3200 input_section->reloc_count -= count; \ 3201 relend -= count; \ 3202 rel--; \ 3203 continue; \ 3204 } \ 3205 } \ 3206 \ 3207 for (i_ = 0; i_ < count; i_++) \ 3208 { \ 3209 rel[i_].r_info = 0; \ 3210 rel[i_].r_addend = 0; \ 3211 } \ 3212 rel += count - 1; \ 3213 continue; \ 3214 } 3215 3216/* Will a symbol be bound to the definition within the shared 3217 library, if any. A unique symbol can never be bound locally. */ 3218#define SYMBOLIC_BIND(INFO, H) \ 3219 (!(H)->unique_global \ 3220 && ((INFO)->symbolic \ 3221 || (H)->start_stop \ 3222 || ((INFO)->dynamic && !(H)->dynamic))) 3223 3224/* Determine if a section contains CTF data, using its name. */ 3225static inline bool 3226bfd_section_is_ctf (const asection *sec) 3227{ 3228 const char *name = bfd_section_name (sec); 3229 return startswith (name, ".ctf") && (name[4] == 0 || name[4] == '.'); 3230} 3231 3232#ifdef __cplusplus 3233} 3234#endif 3235#endif /* _LIBELF_H_ */ 3236