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