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