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