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