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