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