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