elf-bfd.h revision 99461
1/* BFD back-end data structures for ELF files. 2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 3 2002 Free Software Foundation, Inc. 4 Written by Cygnus Support. 5 6This file is part of BFD, the Binary File Descriptor library. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2 of the License, or 11(at your option) any later version. 12 13This program is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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/* Do not "beautify" the CONCAT* macro args. Traditional C will not 37 remove whitespace added here, and thus will fail to concatenate 38 the tokens. */ 39#ifndef NAME 40#if ARCH_SIZE==64 41#define NAME(x,y) CONCAT4 (x,64,_,y) 42#endif 43#if ARCH_SIZE==32 44#define NAME(x,y) CONCAT4 (x,32,_,y) 45#endif 46#endif 47 48#ifndef NAME 49#define NAME(x,y) CONCAT4 (x,NOSIZE,_,y) 50#endif 51 52#define ElfNAME(X) NAME(Elf,X) 53#define elfNAME(X) NAME(elf,X) 54 55/* Information held for an ELF symbol. The first field is the 56 corresponding asymbol. Every symbol is an ELF file is actually a 57 pointer to this structure, although it is often handled as a 58 pointer to an asymbol. */ 59 60typedef struct 61{ 62 /* The BFD symbol. */ 63 asymbol symbol; 64 /* ELF symbol information. */ 65 Elf_Internal_Sym internal_elf_sym; 66 /* Backend specific information. */ 67 union 68 { 69 unsigned int hppa_arg_reloc; 70 PTR mips_extr; 71 PTR any; 72 } 73 tc_data; 74 75 /* Version information. This is from an Elf_Internal_Versym 76 structure in a SHT_GNU_versym section. It is zero if there is no 77 version information. */ 78 unsigned short version; 79 80} elf_symbol_type; 81 82struct elf_strtab_hash; 83 84/* ELF linker hash table entries. */ 85 86struct elf_link_hash_entry 87{ 88 struct bfd_link_hash_entry root; 89 90 /* Symbol index in output file. This is initialized to -1. It is 91 set to -2 if the symbol is used by a reloc. */ 92 long indx; 93 94 /* Symbol index as a dynamic symbol. Initialized to -1, and remains 95 -1 if this is not a dynamic symbol. */ 96 /* ??? Note that this is consistently used as a synonym for tests 97 against whether we can perform various simplifying transformations 98 to the code. (E.g. changing a pc-relative jump to a PLT entry 99 into a pc-relative jump to the target function.) That test, which 100 is often relatively complex, and someplaces wrong or incomplete, 101 should really be replaced by a predicate in elflink.c. 102 103 End result: this field -1 does not indicate that the symbol is 104 not in the dynamic symbol table, but rather that the symbol is 105 not visible outside this DSO. */ 106 long dynindx; 107 108 /* String table index in .dynstr if this is a dynamic symbol. */ 109 unsigned long dynstr_index; 110 111 /* Hash value of the name computed using the ELF hash function. */ 112 unsigned long elf_hash_value; 113 114 /* If this is a weak defined symbol from a dynamic object, this 115 field points to a defined symbol with the same value, if there is 116 one. Otherwise it is NULL. */ 117 struct elf_link_hash_entry *weakdef; 118 119 /* If this symbol is used in the linker created sections, the processor 120 specific backend uses this field to map the field into the offset 121 from the beginning of the section. */ 122 struct elf_linker_section_pointers *linker_section_pointer; 123 124 /* Version information. */ 125 union 126 { 127 /* This field is used for a symbol which is not defined in a 128 regular object. It points to the version information read in 129 from the dynamic object. */ 130 Elf_Internal_Verdef *verdef; 131 /* This field is used for a symbol which is defined in a regular 132 object. It is set up in size_dynamic_sections. It points to 133 the version information we should write out for this symbol. */ 134 struct bfd_elf_version_tree *vertree; 135 } verinfo; 136 137 /* Virtual table entry use information. This array is nominally of size 138 size/sizeof(target_void_pointer), though we have to be able to assume 139 and track a size while the symbol is still undefined. It is indexed 140 via offset/sizeof(target_void_pointer). */ 141 size_t vtable_entries_size; 142 boolean *vtable_entries_used; 143 144 /* Virtual table derivation info. */ 145 struct elf_link_hash_entry *vtable_parent; 146 147 /* If this symbol requires an entry in the global offset table, the 148 processor specific backend uses this field to track usage and 149 final offset. We use a union and two names primarily to document 150 the intent of any particular piece of code. The field should be 151 used as a count until size_dynamic_sections, at which point the 152 contents of the .got is fixed. Afterward, if this field is -1, 153 then the symbol does not require a global offset table entry. */ 154 union 155 { 156 bfd_signed_vma refcount; 157 bfd_vma offset; 158 } got; 159 160 /* Same, but tracks a procedure linkage table entry. */ 161 union 162 { 163 bfd_signed_vma refcount; 164 bfd_vma offset; 165 } plt; 166 167 /* Symbol size. */ 168 bfd_size_type size; 169 170 /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.). */ 171 char type; 172 173 /* Symbol st_other value, symbol visibility. */ 174 unsigned char other; 175 176 /* Some flags; legal values follow. */ 177 unsigned short elf_link_hash_flags; 178 /* Symbol is referenced by a non-shared object. */ 179#define ELF_LINK_HASH_REF_REGULAR 01 180 /* Symbol is defined by a non-shared object. */ 181#define ELF_LINK_HASH_DEF_REGULAR 02 182 /* Symbol is referenced by a shared object. */ 183#define ELF_LINK_HASH_REF_DYNAMIC 04 184 /* Symbol is defined by a shared object. */ 185#define ELF_LINK_HASH_DEF_DYNAMIC 010 186 /* Symbol has a non-weak reference from a non-shared object. */ 187#define ELF_LINK_HASH_REF_REGULAR_NONWEAK 020 188 /* Dynamic symbol has been adjustd. */ 189#define ELF_LINK_HASH_DYNAMIC_ADJUSTED 040 190 /* Symbol needs a copy reloc. */ 191#define ELF_LINK_HASH_NEEDS_COPY 0100 192 /* Symbol needs a procedure linkage table entry. */ 193#define ELF_LINK_HASH_NEEDS_PLT 0200 194 /* Symbol appears in a non-ELF input file. */ 195#define ELF_LINK_NON_ELF 0400 196 /* Symbol should be marked as hidden in the version information. */ 197#define ELF_LINK_HIDDEN 01000 198 /* Symbol was forced to local scope due to a version script file. */ 199#define ELF_LINK_FORCED_LOCAL 02000 200 /* Symbol was marked during garbage collection. */ 201#define ELF_LINK_HASH_MARK 04000 202 /* Symbol is referenced by a non-GOT/non-PLT relocation. This is 203 not currently set by all the backends. */ 204#define ELF_LINK_NON_GOT_REF 010000 205}; 206 207/* Records local symbols to be emitted in the dynamic symbol table. */ 208 209struct elf_link_local_dynamic_entry 210{ 211 struct elf_link_local_dynamic_entry *next; 212 213 /* The input bfd this symbol came from. */ 214 bfd *input_bfd; 215 216 /* The index of the local symbol being copied. */ 217 long input_indx; 218 219 /* The index in the outgoing dynamic symbol table. */ 220 long dynindx; 221 222 /* A copy of the input symbol. */ 223 Elf_Internal_Sym isym; 224}; 225 226enum elf_link_info_type 227{ 228 ELF_INFO_TYPE_NONE, 229 ELF_INFO_TYPE_STABS, 230 ELF_INFO_TYPE_MERGE, 231 ELF_INFO_TYPE_EH_FRAME, 232 ELF_INFO_TYPE_EH_FRAME_HDR, 233 ELF_INFO_TYPE_LAST 234}; 235 236/* ELF linker hash table. */ 237 238struct elf_link_hash_table 239{ 240 struct bfd_link_hash_table root; 241 242 /* Whether we have created the special dynamic sections required 243 when linking against or generating a shared object. */ 244 boolean dynamic_sections_created; 245 246 /* The BFD used to hold special sections created by the linker. 247 This will be the first BFD found which requires these sections to 248 be created. */ 249 bfd *dynobj; 250 251 /* The value to use when initialising got.refcount/offset and 252 plt.refcount/offset in an elf_link_hash_entry. Set to zero when 253 the values are refcounts. Set to -1 in size_dynamic_sections 254 when the values may be offsets. */ 255 bfd_signed_vma init_refcount; 256 257 /* The number of symbols found in the link which must be put into 258 the .dynsym section. */ 259 bfd_size_type dynsymcount; 260 261 /* The string table of dynamic symbols, which becomes the .dynstr 262 section. */ 263 struct elf_strtab_hash *dynstr; 264 265 /* The number of buckets in the hash table in the .hash section. 266 This is based on the number of dynamic symbols. */ 267 bfd_size_type bucketcount; 268 269 /* A linked list of DT_NEEDED names found in dynamic objects 270 included in the link. */ 271 struct bfd_link_needed_list *needed; 272 273 /* The _GLOBAL_OFFSET_TABLE_ symbol. */ 274 struct elf_link_hash_entry *hgot; 275 276 /* A pointer to information used to link stabs in sections. */ 277 PTR stab_info; 278 279 /* A pointer to information used to merge SEC_MERGE sections. */ 280 PTR merge_info; 281 282 /* A linked list of local symbols to be added to .dynsym. */ 283 struct elf_link_local_dynamic_entry *dynlocal; 284 285 /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic 286 objects included in the link. */ 287 struct bfd_link_needed_list *runpath; 288}; 289 290/* Look up an entry in an ELF linker hash table. */ 291 292#define elf_link_hash_lookup(table, string, create, copy, follow) \ 293 ((struct elf_link_hash_entry *) \ 294 bfd_link_hash_lookup (&(table)->root, (string), (create), \ 295 (copy), (follow))) 296 297/* Traverse an ELF linker hash table. */ 298 299#define elf_link_hash_traverse(table, func, info) \ 300 (bfd_link_hash_traverse \ 301 (&(table)->root, \ 302 (boolean (*) PARAMS ((struct bfd_link_hash_entry *, PTR))) (func), \ 303 (info))) 304 305/* Get the ELF linker hash table from a link_info structure. */ 306 307#define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash)) 308 309/* Returns true if the hash table is a struct elf_link_hash_table. */ 310#define is_elf_hash_table(p) \ 311 ((p)->hash->type == bfd_link_elf_hash_table) 312 313/* Used by bfd_section_from_r_symndx to cache a small number of local 314 symbol to section mappings. */ 315#define LOCAL_SYM_CACHE_SIZE 32 316struct sym_sec_cache 317{ 318 bfd *abfd; 319 unsigned long indx[LOCAL_SYM_CACHE_SIZE]; 320 asection *sec[LOCAL_SYM_CACHE_SIZE]; 321}; 322 323/* Constant information held for an ELF backend. */ 324 325struct elf_size_info { 326 unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr; 327 unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note; 328 329 /* The size of entries in the .hash section. */ 330 unsigned char sizeof_hash_entry; 331 332 /* The number of internal relocations to allocate per external 333 relocation entry. */ 334 unsigned char int_rels_per_ext_rel; 335 336 unsigned char arch_size, file_align; 337 unsigned char elfclass, ev_current; 338 int (*write_out_phdrs) 339 PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int)); 340 boolean (*write_shdrs_and_ehdr) 341 PARAMS ((bfd *)); 342 void (*write_relocs) 343 PARAMS ((bfd *, asection *, PTR)); 344 void (*swap_symbol_out) 345 PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR)); 346 boolean (*slurp_reloc_table) 347 PARAMS ((bfd *, asection *, asymbol **, boolean)); 348 long (*slurp_symbol_table) 349 PARAMS ((bfd *, asymbol **, boolean)); 350 void (*swap_dyn_in) 351 PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *)); 352 void (*swap_dyn_out) 353 PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR)); 354 355 /* This function, if defined, is called to swap in a REL 356 relocation. If an external relocation corresponds to more than 357 one internal relocation, then all relocations are swapped in at 358 once. */ 359 void (*swap_reloc_in) 360 PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rel *)); 361 362 /* This function, if defined, is called to swap out a REL 363 relocation. */ 364 void (*swap_reloc_out) 365 PARAMS ((bfd *, const Elf_Internal_Rel *, bfd_byte *)); 366 367 /* This function, if defined, is called to swap in a RELA 368 relocation. If an external relocation corresponds to more than 369 one internal relocation, then all relocations are swapped in at 370 once. */ 371 void (*swap_reloca_in) 372 PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *)); 373 374 /* This function, if defined, is called to swap out a RELA 375 relocation. */ 376 void (*swap_reloca_out) 377 PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *)); 378 379}; 380 381#define elf_symbol_from(ABFD,S) \ 382 (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \ 383 && (S)->the_bfd->tdata.elf_obj_data != 0) \ 384 ? (elf_symbol_type *) (S) \ 385 : 0) 386 387enum elf_reloc_type_class { 388 reloc_class_normal, 389 reloc_class_relative, 390 reloc_class_plt, 391 reloc_class_copy 392}; 393 394struct elf_reloc_cookie 395{ 396 Elf_Internal_Rela *rels, *rel, *relend; 397 PTR locsyms; 398 PTR locsym_shndx; 399 bfd *abfd; 400 size_t locsymcount; 401 size_t extsymoff; 402 struct elf_link_hash_entry **sym_hashes; 403 boolean bad_symtab; 404}; 405 406struct elf_backend_data 407{ 408 /* The architecture for this backend. */ 409 enum bfd_architecture arch; 410 411 /* The ELF machine code (EM_xxxx) for this backend. */ 412 int elf_machine_code; 413 414 /* The maximum page size for this backend. */ 415 bfd_vma maxpagesize; 416 417 /* A function to translate an ELF RELA relocation to a BFD arelent 418 structure. */ 419 void (*elf_info_to_howto) 420 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 421 422 /* A function to translate an ELF REL relocation to a BFD arelent 423 structure. */ 424 void (*elf_info_to_howto_rel) 425 PARAMS ((bfd *, arelent *, Elf_Internal_Rel *)); 426 427 /* A function to determine whether a symbol is global when 428 partitioning the symbol table into local and global symbols. 429 This should be NULL for most targets, in which case the correct 430 thing will be done. MIPS ELF, at least on the Irix 5, has 431 special requirements. */ 432 boolean (*elf_backend_sym_is_global) 433 PARAMS ((bfd *, asymbol *)); 434 435 /* The remaining functions are hooks which are called only if they 436 are not NULL. */ 437 438 /* A function to permit a backend specific check on whether a 439 particular BFD format is relevant for an object file, and to 440 permit the backend to set any global information it wishes. When 441 this is called elf_elfheader is set, but anything else should be 442 used with caution. If this returns false, the check_format 443 routine will return a bfd_error_wrong_format error. */ 444 boolean (*elf_backend_object_p) 445 PARAMS ((bfd *)); 446 447 /* A function to do additional symbol processing when reading the 448 ELF symbol table. This is where any processor-specific special 449 section indices are handled. */ 450 void (*elf_backend_symbol_processing) 451 PARAMS ((bfd *, asymbol *)); 452 453 /* A function to do additional symbol processing after reading the 454 entire ELF symbol table. */ 455 boolean (*elf_backend_symbol_table_processing) 456 PARAMS ((bfd *, elf_symbol_type *, unsigned int)); 457 458 /* A function to set the type of the info field. Processor-specific 459 types should be handled here. */ 460 int (*elf_backend_get_symbol_type) 461 PARAMS (( Elf_Internal_Sym *, int)); 462 463 /* A function to do additional processing on the ELF section header 464 just before writing it out. This is used to set the flags and 465 type fields for some sections, or to actually write out data for 466 unusual sections. */ 467 boolean (*elf_backend_section_processing) 468 PARAMS ((bfd *, Elf32_Internal_Shdr *)); 469 470 /* A function to handle unusual section types when creating BFD 471 sections from ELF sections. */ 472 boolean (*elf_backend_section_from_shdr) 473 PARAMS ((bfd *, Elf32_Internal_Shdr *, char *)); 474 475 /* A function to convert machine dependent section header flags to 476 BFD internal section header flags. */ 477 boolean (*elf_backend_section_flags) 478 PARAMS ((flagword *, Elf32_Internal_Shdr *)); 479 480 /* A function to handle unusual program segment types when creating BFD 481 sections from ELF program segments. */ 482 boolean (*elf_backend_section_from_phdr) 483 PARAMS ((bfd *, Elf32_Internal_Phdr *, int)); 484 485 /* A function to set up the ELF section header for a BFD section in 486 preparation for writing it out. This is where the flags and type 487 fields are set for unusual sections. */ 488 boolean (*elf_backend_fake_sections) 489 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *)); 490 491 /* A function to get the ELF section index for a BFD section. If 492 this returns true, the section was found. If it is a normal ELF 493 section, *RETVAL should be left unchanged. If it is not a normal 494 ELF section *RETVAL should be set to the SHN_xxxx index. */ 495 boolean (*elf_backend_section_from_bfd_section) 496 PARAMS ((bfd *, asection *, int *retval)); 497 498 /* If this field is not NULL, it is called by the add_symbols phase 499 of a link just before adding a symbol to the global linker hash 500 table. It may modify any of the fields as it wishes. If *NAME 501 is set to NULL, the symbol will be skipped rather than being 502 added to the hash table. This function is responsible for 503 handling all processor dependent symbol bindings and section 504 indices, and must set at least *FLAGS and *SEC for each processor 505 dependent case; failure to do so will cause a link error. */ 506 boolean (*elf_add_symbol_hook) 507 PARAMS ((bfd *abfd, struct bfd_link_info *info, 508 const Elf_Internal_Sym *, const char **name, 509 flagword *flags, asection **sec, bfd_vma *value)); 510 511 /* If this field is not NULL, it is called by the elf_link_output_sym 512 phase of a link for each symbol which will appear in the object file. */ 513 boolean (*elf_backend_link_output_symbol_hook) 514 PARAMS ((bfd *, struct bfd_link_info *info, const char *, 515 Elf_Internal_Sym *, asection *)); 516 517 /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend 518 linker the first time it encounters a dynamic object in the link. 519 This function must create any sections required for dynamic 520 linking. The ABFD argument is a dynamic object. The .interp, 521 .dynamic, .dynsym, .dynstr, and .hash functions have already been 522 created, and this function may modify the section flags if 523 desired. This function will normally create the .got and .plt 524 sections, but different backends have different requirements. */ 525 boolean (*elf_backend_create_dynamic_sections) 526 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 527 528 /* The CHECK_RELOCS function is called by the add_symbols phase of 529 the ELF backend linker. It is called once for each section with 530 relocs of an object file, just after the symbols for the object 531 file have been added to the global linker hash table. The 532 function must look through the relocs and do any special handling 533 required. This generally means allocating space in the global 534 offset table, and perhaps allocating space for a reloc. The 535 relocs are always passed as Rela structures; if the section 536 actually uses Rel structures, the r_addend field will always be 537 zero. */ 538 boolean (*check_relocs) 539 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o, 540 const Elf_Internal_Rela *relocs)); 541 542 /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend 543 linker for every symbol which is defined by a dynamic object and 544 referenced by a regular object. This is called after all the 545 input files have been seen, but before the SIZE_DYNAMIC_SECTIONS 546 function has been called. The hash table entry should be 547 bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be 548 defined in a section from a dynamic object. Dynamic object 549 sections are not included in the final link, and this function is 550 responsible for changing the value to something which the rest of 551 the link can deal with. This will normally involve adding an 552 entry to the .plt or .got or some such section, and setting the 553 symbol to point to that. */ 554 boolean (*elf_backend_adjust_dynamic_symbol) 555 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h)); 556 557 /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker 558 after all the linker input files have been seen but before the 559 section sizes have been set. This is called after 560 ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS. */ 561 boolean (*elf_backend_always_size_sections) 562 PARAMS ((bfd *output_bfd, struct bfd_link_info *info)); 563 564 /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend 565 linker after all the linker input files have been seen but before 566 the sections sizes have been set. This is called after 567 ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols. 568 It is only called when linking against a dynamic object. It must 569 set the sizes of the dynamic sections, and may fill in their 570 contents as well. The generic ELF linker can handle the .dynsym, 571 .dynstr and .hash sections. This function must handle the 572 .interp section and any sections created by the 573 CREATE_DYNAMIC_SECTIONS entry point. */ 574 boolean (*elf_backend_size_dynamic_sections) 575 PARAMS ((bfd *output_bfd, struct bfd_link_info *info)); 576 577 /* The RELOCATE_SECTION function is called by the ELF backend linker 578 to handle the relocations for a section. 579 580 The relocs are always passed as Rela structures; if the section 581 actually uses Rel structures, the r_addend field will always be 582 zero. 583 584 This function is responsible for adjust the section contents as 585 necessary, and (if using Rela relocs and generating a 586 relocateable output file) adjusting the reloc addend as 587 necessary. 588 589 This function does not have to worry about setting the reloc 590 address or the reloc symbol index. 591 592 LOCAL_SYMS is a pointer to the swapped in local symbols. 593 594 LOCAL_SECTIONS is an array giving the section in the input file 595 corresponding to the st_shndx field of each local symbol. 596 597 The global hash table entry for the global symbols can be found 598 via elf_sym_hashes (input_bfd). 599 600 When generating relocateable output, this function must handle 601 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 602 going to be the section symbol corresponding to the output 603 section, which means that the addend must be adjusted 604 accordingly. */ 605 boolean (*elf_backend_relocate_section) 606 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, 607 bfd *input_bfd, asection *input_section, bfd_byte *contents, 608 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms, 609 asection **local_sections)); 610 611 /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend 612 linker just before it writes a symbol out to the .dynsym section. 613 The processor backend may make any required adjustment to the 614 symbol. It may also take the opportunity to set contents of the 615 dynamic sections. Note that FINISH_DYNAMIC_SYMBOL is called on 616 all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called 617 on those symbols which are defined by a dynamic object. */ 618 boolean (*elf_backend_finish_dynamic_symbol) 619 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, 620 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)); 621 622 /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend 623 linker just before it writes all the dynamic sections out to the 624 output file. The FINISH_DYNAMIC_SYMBOL will have been called on 625 all dynamic symbols. */ 626 boolean (*elf_backend_finish_dynamic_sections) 627 PARAMS ((bfd *output_bfd, struct bfd_link_info *info)); 628 629 /* A function to do any beginning processing needed for the ELF file 630 before building the ELF headers and computing file positions. */ 631 void (*elf_backend_begin_write_processing) 632 PARAMS ((bfd *, struct bfd_link_info *)); 633 634 /* A function to do any final processing needed for the ELF file 635 before writing it out. The LINKER argument is true if this BFD 636 was created by the ELF backend linker. */ 637 void (*elf_backend_final_write_processing) 638 PARAMS ((bfd *, boolean linker)); 639 640 /* This function is called by get_program_header_size. It should 641 return the number of additional program segments which this BFD 642 will need. It should return -1 on error. */ 643 int (*elf_backend_additional_program_headers) 644 PARAMS ((bfd *)); 645 646 /* This function is called to modify an existing segment map in a 647 backend specific fashion. */ 648 boolean (*elf_backend_modify_segment_map) 649 PARAMS ((bfd *)); 650 651 /* This function is called during section gc to discover the section a 652 particular relocation refers to. It need not be defined for hosts 653 that have no queer relocation types. */ 654 asection * (*gc_mark_hook) 655 PARAMS ((bfd *abfd, struct bfd_link_info *, Elf_Internal_Rela *, 656 struct elf_link_hash_entry *h, Elf_Internal_Sym *)); 657 658 /* This function, if defined, is called during the sweep phase of gc 659 in order that a backend might update any data structures it might 660 be maintaining. */ 661 boolean (*gc_sweep_hook) 662 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *o, 663 const Elf_Internal_Rela *relocs)); 664 665 /* This function, if defined, is called after the ELF headers have 666 been created. This allows for things like the OS and ABI versions 667 to be changed. */ 668 void (*elf_backend_post_process_headers) 669 PARAMS ((bfd *, struct bfd_link_info *)); 670 671 /* This function, if defined, prints a symbol to file and returns the 672 name of the symbol to be printed. It should return NULL to fall 673 back to default symbol printing. */ 674 const char *(*elf_backend_print_symbol_all) 675 PARAMS ((bfd *, PTR, asymbol *)); 676 677 /* This function, if defined, is called after all local symbols and 678 global symbols converted to locals are emited into the symtab 679 section. It allows the backend to emit special global symbols 680 not handled in the hash table. */ 681 boolean (*elf_backend_output_arch_syms) 682 PARAMS ((bfd *, struct bfd_link_info *, PTR, 683 boolean (*) (PTR, const char *, Elf_Internal_Sym *, asection *))); 684 685 /* Copy any information related to dynamic linking from a pre-existing 686 symbol to a newly created symbol. Also called to copy flags and 687 other back-end info to a weakdef, in which case the symbol is not 688 newly created and plt/got refcounts and dynamic indices should not 689 be copied. */ 690 void (*elf_backend_copy_indirect_symbol) 691 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *)); 692 693 /* Modify any information related to dynamic linking such that the 694 symbol is not exported. */ 695 void (*elf_backend_hide_symbol) 696 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean)); 697 698 /* Emit relocations. Overrides default routine for emitting relocs, 699 except during a relocatable link, or if all relocs are being emitted. */ 700 void (*elf_backend_emit_relocs) 701 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *)); 702 703 /* Count relocations. Not called for relocatable links 704 or if all relocs are being preserved in the output. */ 705 unsigned int (*elf_backend_count_relocs) 706 PARAMS ((asection *, Elf_Internal_Rela *)); 707 708 /* This function, if defined, is called when an NT_PRSTATUS note is found 709 in a core file. */ 710 boolean (*elf_backend_grok_prstatus) 711 PARAMS ((bfd *, Elf_Internal_Note *)); 712 713 /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO 714 note is found in a core file. */ 715 boolean (*elf_backend_grok_psinfo) 716 PARAMS ((bfd *, Elf_Internal_Note *)); 717 718 /* Functions to print VMAs. Special code to handle 64 bit ELF files. */ 719 void (* elf_backend_sprintf_vma) 720 PARAMS ((bfd *, char *, bfd_vma)); 721 void (* elf_backend_fprintf_vma) 722 PARAMS ((bfd *, PTR, bfd_vma)); 723 724 /* This function returns class of a reloc type. */ 725 enum elf_reloc_type_class (*elf_backend_reloc_type_class) 726 PARAMS ((const Elf_Internal_Rela *)); 727 728 /* This function, if defined, removes information about discarded functions 729 from other sections which mention them. */ 730 boolean (*elf_backend_discard_info) 731 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *)); 732 733 /* This function, if defined, signals that the function above has removed 734 the discarded relocations for this section. */ 735 boolean (*elf_backend_ignore_discarded_relocs) 736 PARAMS ((asection *)); 737 738 /* This function, if defined, may write out the given section. 739 Returns true if it did so and false if the caller should. */ 740 boolean (*elf_backend_write_section) 741 PARAMS ((bfd *, asection *, bfd_byte *)); 742 743 /* The swapping table to use when dealing with ECOFF information. 744 Used for the MIPS ELF .mdebug section. */ 745 const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap; 746 747 /* Alternate EM_xxxx machine codes for this backend. */ 748 int elf_machine_alt1; 749 int elf_machine_alt2; 750 751 const struct elf_size_info *s; 752 753 /* offset of the _GLOBAL_OFFSET_TABLE_ symbol from the start of the 754 .got section */ 755 bfd_vma got_symbol_offset; 756 757 /* The size in bytes of the headers for the GOT and PLT. This includes 758 the so-called reserved entries on some systems. */ 759 bfd_vma got_header_size; 760 bfd_vma plt_header_size; 761 762 /* This is true if the linker should act like collect and gather 763 global constructors and destructors by name. This is true for 764 MIPS ELF because the Irix 5 tools can not handle the .init 765 section. */ 766 unsigned collect : 1; 767 768 /* This is true if the linker should ignore changes to the type of a 769 symbol. This is true for MIPS ELF because some Irix 5 objects 770 record undefined functions as STT_OBJECT although the definitions 771 are STT_FUNC. */ 772 unsigned type_change_ok : 1; 773 774 /* Whether the backend may use REL relocations. (Some backends use 775 both REL and RELA relocations, and this flag is set for those 776 backends.) */ 777 unsigned may_use_rel_p : 1; 778 779 /* Whether the backend may use RELA relocations. (Some backends use 780 both REL and RELA relocations, and this flag is set for those 781 backends.) */ 782 unsigned may_use_rela_p : 1; 783 784 /* Whether the default relocation type is RELA. If a backend with 785 this flag set wants REL relocations for a particular section, 786 it must note that explicitly. Similarly, if this flag is clear, 787 and the backend wants RELA relocations for a particular 788 section. */ 789 unsigned default_use_rela_p : 1; 790 791 /* Set if RELA relocations for a relocatable link can be handled by 792 generic code. Backends that set this flag need do nothing in the 793 backend relocate_section routine for relocatable linking. */ 794 unsigned rela_normal : 1; 795 796 /* True if addresses "naturally" sign extend. This is used when 797 swapping in from Elf32 when BFD64. */ 798 unsigned sign_extend_vma : 1; 799 800 unsigned want_got_plt : 1; 801 unsigned plt_readonly : 1; 802 unsigned want_plt_sym : 1; 803 unsigned plt_not_loaded : 1; 804 unsigned plt_alignment : 4; 805 unsigned can_gc_sections : 1; 806 unsigned can_refcount : 1; 807 unsigned want_got_sym : 1; 808 unsigned want_dynbss : 1; 809}; 810 811/* Information stored for each BFD section in an ELF file. This 812 structure is allocated by elf_new_section_hook. */ 813 814struct bfd_elf_section_data 815{ 816 /* The ELF header for this section. */ 817 Elf_Internal_Shdr this_hdr; 818 819 /* The ELF header for the reloc section associated with this 820 section, if any. */ 821 Elf_Internal_Shdr rel_hdr; 822 823 /* If there is a second reloc section associated with this section, 824 as can happen on Irix 6, this field points to the header. */ 825 Elf_Internal_Shdr *rel_hdr2; 826 827 /* The number of relocations currently assigned to REL_HDR. */ 828 unsigned int rel_count; 829 830 /* The number of relocations currently assigned to REL_HDR2. */ 831 unsigned int rel_count2; 832 833 /* A pointer to a linked list tracking dynamic relocs copied for 834 local symbols. */ 835 PTR local_dynrel; 836 837 /* A pointer to the bfd section used for dynamic relocs. */ 838 asection *sreloc; 839 840 /* The ELF section number of this section. Only used for an output 841 file. */ 842 int this_idx; 843 844 /* The ELF section number of the reloc section indicated by 845 REL_HDR if any. Only used for an output file. */ 846 int rel_idx; 847 848 /* The ELF section number of the reloc section indicated by 849 REL_HDR2 if any. Only used for an output file. */ 850 int rel_idx2; 851 852 /* Used by the backend linker to store the symbol hash table entries 853 associated with relocs against global symbols. */ 854 struct elf_link_hash_entry **rel_hashes; 855 856 /* A pointer to the swapped relocs. If the section uses REL relocs, 857 rather than RELA, all the r_addend fields will be zero. This 858 pointer may be NULL. It is used by the backend linker. */ 859 Elf_Internal_Rela *relocs; 860 861 /* Used by the backend linker when generating a shared library to 862 record the dynamic symbol index for a section symbol 863 corresponding to this section. A value of 0 means that there is 864 no dynamic symbol for this section. */ 865 long dynindx; 866 867 /* A pointer used for various section optimizations. */ 868 PTR sec_info; 869 870 /* Type of that information. */ 871 enum elf_link_info_type sec_info_type; 872 873 /* Group name, if this section is part of a group. */ 874 const char *group_name; 875 876 /* A linked list of sections in the group. Circular when used by 877 the linker. */ 878 asection *next_in_group; 879 880 /* A pointer available for the processor specific ELF backend. */ 881 PTR tdata; 882 883 /* Nonzero if this section uses RELA relocations, rather than REL. */ 884 unsigned int use_rela_p:1; 885}; 886 887#define elf_section_data(sec) ((struct bfd_elf_section_data*)sec->used_by_bfd) 888#define elf_group_name(sec) (elf_section_data(sec)->group_name) 889#define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group) 890 891/* Return true if section has been discarded. */ 892#define elf_discarded_section(sec) \ 893 (!bfd_is_abs_section(sec) \ 894 && bfd_is_abs_section((sec)->output_section) \ 895 && elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE) 896 897#define get_elf_backend_data(abfd) \ 898 ((struct elf_backend_data *) (abfd)->xvec->backend_data) 899 900/* Enumeration to specify the special section. */ 901typedef enum elf_linker_section_enum 902{ 903 LINKER_SECTION_UNKNOWN, /* not used */ 904 LINKER_SECTION_GOT, /* .got section for global offset pointers */ 905 LINKER_SECTION_PLT, /* .plt section for generated procedure stubs */ 906 LINKER_SECTION_SDATA, /* .sdata/.sbss section for PowerPC */ 907 LINKER_SECTION_SDATA2, /* .sdata2/.sbss2 section for PowerPC */ 908 LINKER_SECTION_MAX /* # of linker sections */ 909} elf_linker_section_enum_t; 910 911/* Sections created by the linker. */ 912 913typedef struct elf_linker_section 914{ 915 char *name; /* name of the section */ 916 char *rel_name; /* name of the associated .rel{,a}. section */ 917 char *bss_name; /* name of a related .bss section */ 918 char *sym_name; /* name of symbol to reference this section */ 919 asection *section; /* pointer to the section */ 920 asection *bss_section; /* pointer to the bss section associated with this */ 921 asection *rel_section; /* pointer to the relocations needed for this section */ 922 struct elf_link_hash_entry *sym_hash; /* pointer to the created symbol hash value */ 923 bfd_vma initial_size; /* initial size before any linker generated allocations */ 924 bfd_vma sym_offset; /* offset of symbol from beginning of section */ 925 bfd_vma hole_size; /* size of reserved address hole in allocation */ 926 bfd_vma hole_offset; /* current offset for the hole */ 927 bfd_vma max_hole_offset; /* maximum offset for the hole */ 928 elf_linker_section_enum_t which; /* which section this is */ 929 boolean hole_written_p; /* whether the hole has been initialized */ 930 unsigned int alignment; /* alignment for the section */ 931 flagword flags; /* flags to use to create the section */ 932} elf_linker_section_t; 933 934/* Linked list of allocated pointer entries. This hangs off of the symbol lists, and 935 provides allows us to return different pointers, based on different addend's. */ 936 937typedef struct elf_linker_section_pointers 938{ 939 struct elf_linker_section_pointers *next; /* next allocated pointer for this symbol */ 940 bfd_vma offset; /* offset of pointer from beginning of section */ 941 bfd_vma addend; /* addend used */ 942 elf_linker_section_enum_t which; /* which linker section this is */ 943 boolean written_address_p; /* whether address was written yet */ 944} elf_linker_section_pointers_t; 945 946/* Some private data is stashed away for future use using the tdata pointer 947 in the bfd structure. */ 948 949struct elf_obj_tdata 950{ 951 Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */ 952 Elf_Internal_Shdr **elf_sect_ptr; 953 Elf_Internal_Phdr *phdr; 954 struct elf_segment_map *segment_map; 955 struct elf_strtab_hash *strtab_ptr; 956 int num_locals; 957 int num_globals; 958 unsigned int num_elf_sections; /* elf_sect_ptr size */ 959 int num_section_syms; 960 asymbol **section_syms; /* STT_SECTION symbols for each section */ 961 Elf_Internal_Shdr symtab_hdr; 962 Elf_Internal_Shdr shstrtab_hdr; 963 Elf_Internal_Shdr strtab_hdr; 964 Elf_Internal_Shdr dynsymtab_hdr; 965 Elf_Internal_Shdr dynstrtab_hdr; 966 Elf_Internal_Shdr dynversym_hdr; 967 Elf_Internal_Shdr dynverref_hdr; 968 Elf_Internal_Shdr dynverdef_hdr; 969 Elf_Internal_Shdr symtab_shndx_hdr; 970 unsigned int symtab_section, shstrtab_section; 971 unsigned int strtab_section, dynsymtab_section; 972 unsigned int symtab_shndx_section; 973 unsigned int dynversym_section, dynverdef_section, dynverref_section; 974 file_ptr next_file_pos; 975#if 0 976 /* we don't need these inside bfd anymore, and I think 977 these weren't used outside bfd. */ 978 void *prstatus; /* The raw /proc prstatus structure */ 979 void *prpsinfo; /* The raw /proc prpsinfo structure */ 980#endif 981 bfd_vma gp; /* The gp value */ 982 unsigned int gp_size; /* The gp size */ 983 984 Elf_Internal_Shdr **group_sect_ptr; 985 int num_group; 986 987 /* Information grabbed from an elf core file. */ 988 int core_signal; 989 int core_pid; 990 int core_lwpid; 991 char* core_program; 992 char* core_command; 993 994 /* This is set to true if the object was created by the backend 995 linker. */ 996 boolean linker; 997 998 /* A mapping from external symbols to entries in the linker hash 999 table, used when linking. This is indexed by the symbol index 1000 minus the sh_info field of the symbol table header. */ 1001 struct elf_link_hash_entry **sym_hashes; 1002 1003 /* A mapping from local symbols to offsets into the global offset 1004 table, used when linking. This is indexed by the symbol index. 1005 Like for the globals, we use a union and two names primarily to 1006 document the intent of any particular piece of code. The field 1007 should be used as a count until size_dynamic_sections, at which 1008 point the contents of the .got is fixed. Afterward, if an entry 1009 is -1, then the symbol does not require a global offset table entry. */ 1010 union 1011 { 1012 bfd_signed_vma *refcounts; 1013 bfd_vma *offsets; 1014 } local_got; 1015 1016 /* A mapping from local symbols to offsets into the various linker 1017 sections added. This is index by the symbol index. */ 1018 elf_linker_section_pointers_t **linker_section_pointers; 1019 1020 /* The linker ELF emulation code needs to let the backend ELF linker 1021 know what filename should be used for a dynamic object if the 1022 dynamic object is found using a search. The emulation code then 1023 sometimes needs to know what name was actually used. Until the 1024 file has been added to the linker symbol table, this field holds 1025 the name the linker wants. After it has been added, it holds the 1026 name actually used, which will be the DT_SONAME entry if there is 1027 one. */ 1028 const char *dt_name; 1029 1030 /* When a reference in a regular object is resolved by a shared 1031 object is loaded into via the DT_NEEDED entries by the linker 1032 ELF emulation code, we need to add the shared object to the 1033 DT_NEEDED list of the resulting binary to indicate the dependency 1034 as if the -l option is passed to the linker. This field holds the 1035 name of the loaded shared object. */ 1036 const char *dt_soname; 1037 1038 /* Irix 5 often screws up the symbol table, sorting local symbols 1039 after global symbols. This flag is set if the symbol table in 1040 this BFD appears to be screwed up. If it is, we ignore the 1041 sh_info field in the symbol table header, and always read all the 1042 symbols. */ 1043 boolean bad_symtab; 1044 1045 /* Records the result of `get_program_header_size'. */ 1046 bfd_size_type program_header_size; 1047 1048 /* Used by find_nearest_line entry point. */ 1049 PTR line_info; 1050 1051 /* Used by MIPS ELF find_nearest_line entry point. The structure 1052 could be included directly in this one, but there's no point to 1053 wasting the memory just for the infrequently called 1054 find_nearest_line. */ 1055 struct mips_elf_find_line *find_line_info; 1056 1057 /* A place to stash dwarf1 info for this bfd. */ 1058 struct dwarf1_debug *dwarf1_find_line_info; 1059 1060 /* A place to stash dwarf2 info for this bfd. */ 1061 PTR dwarf2_find_line_info; 1062 1063 /* An array of stub sections indexed by symbol number, used by the 1064 MIPS ELF linker. FIXME: We should figure out some way to only 1065 include this field for a MIPS ELF target. */ 1066 asection **local_stubs; 1067 1068 /* Used to determine if the e_flags field has been initialized */ 1069 boolean flags_init; 1070 1071 /* Used to determine if PT_GNU_EH_FRAME segment header should be 1072 created. */ 1073 boolean eh_frame_hdr; 1074 1075 /* Number of symbol version definitions we are about to emit. */ 1076 unsigned int cverdefs; 1077 1078 /* Number of symbol version references we are about to emit. */ 1079 unsigned int cverrefs; 1080 1081 /* Symbol version definitions in external objects. */ 1082 Elf_Internal_Verdef *verdef; 1083 1084 /* Symbol version references to external objects. */ 1085 Elf_Internal_Verneed *verref; 1086 1087 /* Linker sections that we are interested in. */ 1088 struct elf_linker_section *linker_section[ (int)LINKER_SECTION_MAX ]; 1089 1090 /* The Irix 5 support uses two virtual sections, which represent 1091 text/data symbols defined in dynamic objects. */ 1092 asymbol *elf_data_symbol; 1093 asymbol *elf_text_symbol; 1094 asection *elf_data_section; 1095 asection *elf_text_section; 1096}; 1097 1098#define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data) 1099#define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header) 1100#define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr) 1101#define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections) 1102#define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr) 1103#define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section) 1104#define elf_symtab_shndx(bfd) (elf_tdata(bfd) -> symtab_shndx_section) 1105#define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section) 1106#define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section) 1107#define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section) 1108#define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section) 1109#define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals) 1110#define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals) 1111#define elf_section_syms(bfd) (elf_tdata(bfd) -> section_syms) 1112#define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms) 1113#define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo) 1114#define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus) 1115#define elf_gp(bfd) (elf_tdata(bfd) -> gp) 1116#define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size) 1117#define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes) 1118#define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts) 1119#define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets) 1120#define elf_local_ptr_offsets(bfd) (elf_tdata(bfd) -> linker_section_pointers) 1121#define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name) 1122#define elf_dt_soname(bfd) (elf_tdata(bfd) -> dt_soname) 1123#define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab) 1124#define elf_flags_init(bfd) (elf_tdata(bfd) -> flags_init) 1125#define elf_linker_section(bfd,n) (elf_tdata(bfd) -> linker_section[(int)n]) 1126 1127extern void _bfd_elf_swap_verdef_in 1128 PARAMS ((bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *)); 1129extern void _bfd_elf_swap_verdef_out 1130 PARAMS ((bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *)); 1131extern void _bfd_elf_swap_verdaux_in 1132 PARAMS ((bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *)); 1133extern void _bfd_elf_swap_verdaux_out 1134 PARAMS ((bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *)); 1135extern void _bfd_elf_swap_verneed_in 1136 PARAMS ((bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *)); 1137extern void _bfd_elf_swap_verneed_out 1138 PARAMS ((bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *)); 1139extern void _bfd_elf_swap_vernaux_in 1140 PARAMS ((bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *)); 1141extern void _bfd_elf_swap_vernaux_out 1142 PARAMS ((bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *)); 1143extern void _bfd_elf_swap_versym_in 1144 PARAMS ((bfd *, const Elf_External_Versym *, Elf_Internal_Versym *)); 1145extern void _bfd_elf_swap_versym_out 1146 PARAMS ((bfd *, const Elf_Internal_Versym *, Elf_External_Versym *)); 1147 1148extern int _bfd_elf_section_from_bfd_section 1149 PARAMS ((bfd *, asection *)); 1150extern char *bfd_elf_string_from_elf_section 1151 PARAMS ((bfd *, unsigned, unsigned)); 1152extern char *bfd_elf_get_str_section 1153 PARAMS ((bfd *, unsigned)); 1154 1155extern boolean _bfd_elf_copy_private_bfd_data 1156 PARAMS ((bfd *, bfd *)); 1157extern boolean _bfd_elf_print_private_bfd_data 1158 PARAMS ((bfd *, PTR)); 1159extern void bfd_elf_print_symbol 1160 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type)); 1161 1162#define elf_string_from_elf_strtab(abfd, strindex) \ 1163 bfd_elf_string_from_elf_section(abfd, elf_elfheader(abfd)->e_shstrndx, \ 1164 strindex) 1165 1166#define bfd_elf32_print_symbol bfd_elf_print_symbol 1167#define bfd_elf64_print_symbol bfd_elf_print_symbol 1168 1169extern void _bfd_elf_sprintf_vma 1170 PARAMS ((bfd *, char *, bfd_vma)); 1171extern void _bfd_elf_fprintf_vma 1172 PARAMS ((bfd *, PTR, bfd_vma)); 1173 1174extern enum elf_reloc_type_class _bfd_elf_reloc_type_class 1175 PARAMS ((const Elf_Internal_Rela *)); 1176extern bfd_vma _bfd_elf_rela_local_sym 1177 PARAMS ((bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *)); 1178extern bfd_vma _bfd_elf_rel_local_sym 1179 PARAMS ((bfd *, Elf_Internal_Sym *, asection **, bfd_vma)); 1180extern bfd_vma _bfd_elf_section_offset 1181 PARAMS ((bfd *, struct bfd_link_info *, asection *, bfd_vma)); 1182 1183extern unsigned long bfd_elf_hash 1184 PARAMS ((const char *)); 1185 1186extern bfd_reloc_status_type bfd_elf_generic_reloc 1187 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1188extern boolean bfd_elf_mkobject 1189 PARAMS ((bfd *)); 1190extern boolean bfd_elf_mkcorefile 1191 PARAMS ((bfd *)); 1192extern Elf_Internal_Shdr *bfd_elf_find_section 1193 PARAMS ((bfd *, char *)); 1194extern boolean _bfd_elf_make_section_from_shdr 1195 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *)); 1196extern boolean _bfd_elf_make_section_from_phdr 1197 PARAMS ((bfd *, Elf_Internal_Phdr *, int, const char *)); 1198extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc 1199 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 1200extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create 1201 PARAMS ((bfd *)); 1202extern void _bfd_elf_link_hash_copy_indirect 1203 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *)); 1204extern void _bfd_elf_link_hash_hide_symbol 1205 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean)); 1206extern boolean _bfd_elf_link_hash_table_init 1207 PARAMS ((struct elf_link_hash_table *, bfd *, 1208 struct bfd_hash_entry *(*) (struct bfd_hash_entry *, 1209 struct bfd_hash_table *, 1210 const char *))); 1211extern boolean _bfd_elf_slurp_version_tables 1212 PARAMS ((bfd *)); 1213 1214extern boolean _bfd_elf_merge_sections 1215 PARAMS ((bfd *, struct bfd_link_info *)); 1216 1217extern boolean _bfd_elf_copy_private_symbol_data 1218 PARAMS ((bfd *, asymbol *, bfd *, asymbol *)); 1219extern boolean _bfd_elf_copy_private_section_data 1220 PARAMS ((bfd *, asection *, bfd *, asection *)); 1221extern boolean _bfd_elf_write_object_contents 1222 PARAMS ((bfd *)); 1223extern boolean _bfd_elf_write_corefile_contents 1224 PARAMS ((bfd *)); 1225extern boolean _bfd_elf_set_section_contents 1226 PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); 1227extern long _bfd_elf_get_symtab_upper_bound 1228 PARAMS ((bfd *)); 1229extern long _bfd_elf_get_symtab 1230 PARAMS ((bfd *, asymbol **)); 1231extern long _bfd_elf_get_dynamic_symtab_upper_bound 1232 PARAMS ((bfd *)); 1233extern long _bfd_elf_canonicalize_dynamic_symtab 1234 PARAMS ((bfd *, asymbol **)); 1235extern long _bfd_elf_get_reloc_upper_bound 1236 PARAMS ((bfd *, sec_ptr)); 1237extern long _bfd_elf_canonicalize_reloc 1238 PARAMS ((bfd *, sec_ptr, arelent **, asymbol **)); 1239extern long _bfd_elf_get_dynamic_reloc_upper_bound 1240 PARAMS ((bfd *)); 1241extern long _bfd_elf_canonicalize_dynamic_reloc 1242 PARAMS ((bfd *, arelent **, asymbol **)); 1243extern asymbol *_bfd_elf_make_empty_symbol 1244 PARAMS ((bfd *)); 1245extern void _bfd_elf_get_symbol_info 1246 PARAMS ((bfd *, asymbol *, symbol_info *)); 1247extern boolean _bfd_elf_is_local_label_name 1248 PARAMS ((bfd *, const char *)); 1249extern alent *_bfd_elf_get_lineno 1250 PARAMS ((bfd *, asymbol *)); 1251extern boolean _bfd_elf_set_arch_mach 1252 PARAMS ((bfd *, enum bfd_architecture, unsigned long)); 1253extern boolean _bfd_elf_find_nearest_line 1254 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **, 1255 const char **, unsigned int *)); 1256#define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols 1257#define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 1258extern int _bfd_elf_sizeof_headers 1259 PARAMS ((bfd *, boolean)); 1260extern boolean _bfd_elf_new_section_hook 1261 PARAMS ((bfd *, asection *)); 1262extern boolean _bfd_elf_init_reloc_shdr 1263 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *, boolean)); 1264 1265/* If the target doesn't have reloc handling written yet: */ 1266extern void _bfd_elf_no_info_to_howto 1267 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 1268 1269extern boolean bfd_section_from_shdr 1270 PARAMS ((bfd *, unsigned int shindex)); 1271extern boolean bfd_section_from_phdr 1272 PARAMS ((bfd *, Elf_Internal_Phdr *, int)); 1273 1274extern int _bfd_elf_symbol_from_bfd_symbol 1275 PARAMS ((bfd *, asymbol **)); 1276 1277extern asection *bfd_section_from_r_symndx 1278 PARAMS ((bfd *, struct sym_sec_cache *, asection *, unsigned long)); 1279extern asection *bfd_section_from_elf_index 1280 PARAMS ((bfd *, unsigned int)); 1281extern boolean _bfd_elf_create_dynamic_sections 1282 PARAMS ((bfd *, struct bfd_link_info *)); 1283extern struct bfd_strtab_hash *_bfd_elf_stringtab_init 1284 PARAMS ((void)); 1285 1286extern struct elf_strtab_hash * _bfd_elf_strtab_init 1287 PARAMS ((void)); 1288extern void _bfd_elf_strtab_free 1289 PARAMS ((struct elf_strtab_hash *)); 1290extern bfd_size_type _bfd_elf_strtab_add 1291 PARAMS ((struct elf_strtab_hash *, const char *, boolean)); 1292extern void _bfd_elf_strtab_addref 1293 PARAMS ((struct elf_strtab_hash *, bfd_size_type)); 1294extern void _bfd_elf_strtab_delref 1295 PARAMS ((struct elf_strtab_hash *, bfd_size_type)); 1296extern void _bfd_elf_strtab_clear_all_refs 1297 PARAMS ((struct elf_strtab_hash *)); 1298extern bfd_size_type _bfd_elf_strtab_size 1299 PARAMS ((struct elf_strtab_hash *)); 1300extern bfd_size_type _bfd_elf_strtab_offset 1301 PARAMS ((struct elf_strtab_hash *, bfd_size_type)); 1302extern boolean _bfd_elf_strtab_emit 1303 PARAMS ((bfd *, struct elf_strtab_hash *)); 1304extern void _bfd_elf_strtab_finalize 1305 PARAMS ((struct elf_strtab_hash *)); 1306 1307extern boolean _bfd_elf_discard_section_eh_frame 1308 PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *, 1309 boolean (*) (bfd_vma, PTR), struct elf_reloc_cookie *)); 1310extern boolean _bfd_elf_discard_section_eh_frame_hdr 1311 PARAMS ((bfd *, struct bfd_link_info *, asection *)); 1312extern bfd_vma _bfd_elf_eh_frame_section_offset 1313 PARAMS ((bfd *, asection *, bfd_vma)); 1314extern boolean _bfd_elf_write_section_eh_frame 1315 PARAMS ((bfd *, asection *, asection *, bfd_byte *)); 1316extern boolean _bfd_elf_write_section_eh_frame_hdr 1317 PARAMS ((bfd *, asection *)); 1318extern boolean _bfd_elf_maybe_strip_eh_frame_hdr 1319 PARAMS ((struct bfd_link_info *)); 1320 1321extern boolean _bfd_elf_link_record_dynamic_symbol 1322 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 1323extern long _bfd_elf_link_lookup_local_dynindx 1324 PARAMS ((struct bfd_link_info *, bfd *, long)); 1325extern boolean _bfd_elf_compute_section_file_positions 1326 PARAMS ((bfd *, struct bfd_link_info *)); 1327extern void _bfd_elf_assign_file_positions_for_relocs 1328 PARAMS ((bfd *)); 1329extern file_ptr _bfd_elf_assign_file_position_for_section 1330 PARAMS ((Elf_Internal_Shdr *, file_ptr, boolean)); 1331 1332extern boolean _bfd_elf_validate_reloc 1333 PARAMS ((bfd *, arelent *)); 1334 1335extern boolean _bfd_elf_create_dynamic_sections 1336 PARAMS ((bfd *, struct bfd_link_info *)); 1337extern boolean _bfd_elf_create_got_section 1338 PARAMS ((bfd *, struct bfd_link_info *)); 1339extern unsigned long _bfd_elf_link_renumber_dynsyms 1340 PARAMS ((bfd *, struct bfd_link_info *)); 1341 1342extern boolean _bfd_elfcore_make_pseudosection 1343 PARAMS ((bfd *, char *, size_t, ufile_ptr)); 1344extern char *_bfd_elfcore_strndup 1345 PARAMS ((bfd *, char *, size_t)); 1346 1347extern elf_linker_section_t *_bfd_elf_create_linker_section 1348 PARAMS ((bfd *, struct bfd_link_info *, enum elf_linker_section_enum, 1349 elf_linker_section_t *)); 1350 1351extern elf_linker_section_pointers_t *_bfd_elf_find_pointer_linker_section 1352 PARAMS ((elf_linker_section_pointers_t *, bfd_vma, 1353 elf_linker_section_enum_t)); 1354 1355extern boolean bfd_elf32_create_pointer_linker_section 1356 PARAMS ((bfd *, struct bfd_link_info *, elf_linker_section_t *, 1357 struct elf_link_hash_entry *, const Elf32_Internal_Rela *)); 1358 1359extern bfd_vma bfd_elf32_finish_pointer_linker_section 1360 PARAMS ((bfd *, bfd *, struct bfd_link_info *, elf_linker_section_t *, 1361 struct elf_link_hash_entry *, bfd_vma, 1362 const Elf32_Internal_Rela *, int)); 1363 1364extern boolean bfd_elf64_create_pointer_linker_section 1365 PARAMS ((bfd *, struct bfd_link_info *, elf_linker_section_t *, 1366 struct elf_link_hash_entry *, const Elf64_Internal_Rela *)); 1367 1368extern bfd_vma bfd_elf64_finish_pointer_linker_section 1369 PARAMS ((bfd *, bfd *, struct bfd_link_info *, elf_linker_section_t *, 1370 struct elf_link_hash_entry *, bfd_vma, 1371 const Elf64_Internal_Rela *, int)); 1372 1373extern boolean _bfd_elf_make_linker_section_rela 1374 PARAMS ((bfd *, elf_linker_section_t *, int)); 1375 1376extern const bfd_target *bfd_elf32_object_p 1377 PARAMS ((bfd *)); 1378extern const bfd_target *bfd_elf32_core_file_p 1379 PARAMS ((bfd *)); 1380extern char *bfd_elf32_core_file_failing_command 1381 PARAMS ((bfd *)); 1382extern int bfd_elf32_core_file_failing_signal 1383 PARAMS ((bfd *)); 1384extern boolean bfd_elf32_core_file_matches_executable_p 1385 PARAMS ((bfd *, bfd *)); 1386 1387extern boolean bfd_elf32_bfd_link_add_symbols 1388 PARAMS ((bfd *, struct bfd_link_info *)); 1389extern boolean bfd_elf32_bfd_final_link 1390 PARAMS ((bfd *, struct bfd_link_info *)); 1391 1392extern void bfd_elf32_swap_symbol_in 1393 PARAMS ((bfd *, const Elf32_External_Sym *, const Elf_External_Sym_Shndx *, 1394 Elf_Internal_Sym *)); 1395extern void bfd_elf32_swap_symbol_out 1396 PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR)); 1397extern void bfd_elf32_swap_reloc_in 1398 PARAMS ((bfd *, const Elf32_External_Rel *, Elf_Internal_Rel *)); 1399extern void bfd_elf32_swap_reloc_out 1400 PARAMS ((bfd *, const Elf_Internal_Rel *, Elf32_External_Rel *)); 1401extern void bfd_elf32_swap_reloca_in 1402 PARAMS ((bfd *, const Elf32_External_Rela *, Elf_Internal_Rela *)); 1403extern void bfd_elf32_swap_reloca_out 1404 PARAMS ((bfd *, const Elf_Internal_Rela *, Elf32_External_Rela *)); 1405extern void bfd_elf32_swap_phdr_in 1406 PARAMS ((bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *)); 1407extern void bfd_elf32_swap_phdr_out 1408 PARAMS ((bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *)); 1409extern void bfd_elf32_swap_dyn_in 1410 PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *)); 1411extern void bfd_elf32_swap_dyn_out 1412 PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR)); 1413extern long bfd_elf32_slurp_symbol_table 1414 PARAMS ((bfd *, asymbol **, boolean)); 1415extern boolean bfd_elf32_write_shdrs_and_ehdr 1416 PARAMS ((bfd *)); 1417extern int bfd_elf32_write_out_phdrs 1418 PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int)); 1419extern void bfd_elf32_write_relocs 1420 PARAMS ((bfd *, asection *, PTR)); 1421extern boolean bfd_elf32_slurp_reloc_table 1422 PARAMS ((bfd *, asection *, asymbol **, boolean)); 1423extern boolean bfd_elf32_add_dynamic_entry 1424 PARAMS ((struct bfd_link_info *, bfd_vma, bfd_vma)); 1425extern boolean bfd_elf32_link_create_dynamic_sections 1426 PARAMS ((bfd *, struct bfd_link_info *)); 1427extern Elf_Internal_Rela *_bfd_elf32_link_read_relocs 1428 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean)); 1429 1430extern const bfd_target *bfd_elf64_object_p 1431 PARAMS ((bfd *)); 1432extern const bfd_target *bfd_elf64_core_file_p 1433 PARAMS ((bfd *)); 1434extern char *bfd_elf64_core_file_failing_command 1435 PARAMS ((bfd *)); 1436extern int bfd_elf64_core_file_failing_signal 1437 PARAMS ((bfd *)); 1438extern boolean bfd_elf64_core_file_matches_executable_p 1439 PARAMS ((bfd *, bfd *)); 1440extern boolean bfd_elf64_bfd_link_add_symbols 1441 PARAMS ((bfd *, struct bfd_link_info *)); 1442extern boolean bfd_elf64_bfd_final_link 1443 PARAMS ((bfd *, struct bfd_link_info *)); 1444 1445extern void bfd_elf64_swap_symbol_in 1446 PARAMS ((bfd *, const Elf64_External_Sym *, const Elf_External_Sym_Shndx *, 1447 Elf_Internal_Sym *)); 1448extern void bfd_elf64_swap_symbol_out 1449 PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR)); 1450extern void bfd_elf64_swap_reloc_in 1451 PARAMS ((bfd *, const Elf64_External_Rel *, Elf_Internal_Rel *)); 1452extern void bfd_elf64_swap_reloc_out 1453 PARAMS ((bfd *, const Elf_Internal_Rel *, Elf64_External_Rel *)); 1454extern void bfd_elf64_swap_reloca_in 1455 PARAMS ((bfd *, const Elf64_External_Rela *, Elf_Internal_Rela *)); 1456extern void bfd_elf64_swap_reloca_out 1457 PARAMS ((bfd *, const Elf_Internal_Rela *, Elf64_External_Rela *)); 1458extern void bfd_elf64_swap_phdr_in 1459 PARAMS ((bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *)); 1460extern void bfd_elf64_swap_phdr_out 1461 PARAMS ((bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *)); 1462extern void bfd_elf64_swap_dyn_in 1463 PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *)); 1464extern void bfd_elf64_swap_dyn_out 1465 PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR)); 1466extern long bfd_elf64_slurp_symbol_table 1467 PARAMS ((bfd *, asymbol **, boolean)); 1468extern boolean bfd_elf64_write_shdrs_and_ehdr 1469 PARAMS ((bfd *)); 1470extern int bfd_elf64_write_out_phdrs 1471 PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int)); 1472extern void bfd_elf64_write_relocs 1473 PARAMS ((bfd *, asection *, PTR)); 1474extern boolean bfd_elf64_slurp_reloc_table 1475 PARAMS ((bfd *, asection *, asymbol **, boolean)); 1476extern boolean bfd_elf64_add_dynamic_entry 1477 PARAMS ((struct bfd_link_info *, bfd_vma, bfd_vma)); 1478extern boolean bfd_elf64_link_create_dynamic_sections 1479 PARAMS ((bfd *, struct bfd_link_info *)); 1480extern Elf_Internal_Rela *_bfd_elf64_link_read_relocs 1481 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean)); 1482 1483#define bfd_elf32_link_record_dynamic_symbol \ 1484 _bfd_elf_link_record_dynamic_symbol 1485#define bfd_elf64_link_record_dynamic_symbol \ 1486 _bfd_elf_link_record_dynamic_symbol 1487 1488extern boolean _bfd_elf32_link_record_local_dynamic_symbol 1489 PARAMS ((struct bfd_link_info *, bfd *, long)); 1490extern boolean _bfd_elf64_link_record_local_dynamic_symbol 1491 PARAMS ((struct bfd_link_info *, bfd *, long)); 1492 1493extern boolean _bfd_elf_close_and_cleanup 1494 PARAMS ((bfd *)); 1495extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn 1496 PARAMS ((bfd *, arelent *, struct symbol_cache_entry *, PTR, 1497 asection *, bfd *, char **)); 1498 1499extern boolean _bfd_elf32_gc_sections 1500 PARAMS ((bfd *, struct bfd_link_info *)); 1501extern boolean _bfd_elf32_gc_common_finalize_got_offsets 1502 PARAMS ((bfd *, struct bfd_link_info *)); 1503extern boolean _bfd_elf32_gc_common_final_link 1504 PARAMS ((bfd *, struct bfd_link_info *)); 1505extern boolean _bfd_elf32_gc_record_vtinherit 1506 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1507extern boolean _bfd_elf32_gc_record_vtentry 1508 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1509 1510extern boolean _bfd_elf64_gc_sections 1511 PARAMS ((bfd *, struct bfd_link_info *)); 1512extern boolean _bfd_elf64_gc_common_finalize_got_offsets 1513 PARAMS ((bfd *, struct bfd_link_info *)); 1514extern boolean _bfd_elf64_gc_common_final_link 1515 PARAMS ((bfd *, struct bfd_link_info *)); 1516extern boolean _bfd_elf64_gc_record_vtinherit 1517 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1518extern boolean _bfd_elf64_gc_record_vtentry 1519 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1520 1521extern boolean _bfd_elf32_reloc_symbol_deleted_p 1522 PARAMS ((bfd_vma, PTR)); 1523extern boolean _bfd_elf64_reloc_symbol_deleted_p 1524 PARAMS ((bfd_vma, PTR)); 1525 1526/* Exported interface for writing elf corefile notes. */ 1527extern char *elfcore_write_note 1528 PARAMS ((bfd *, char *, int *, char *, int, void *, int)); 1529extern char *elfcore_write_prpsinfo 1530 PARAMS ((bfd *, char *, int *, char *, char *)); 1531extern char *elfcore_write_prstatus 1532 PARAMS ((bfd *, char *, int *, long, int, void *)); 1533extern char * elfcore_write_pstatus 1534 PARAMS ((bfd *, char *, int *, long, int, void *)); 1535extern char *elfcore_write_prfpreg 1536 PARAMS ((bfd *, char *, int *, void *, int)); 1537extern char *elfcore_write_prxfpreg 1538 PARAMS ((bfd *, char *, int *, void *, int)); 1539extern char *elfcore_write_lwpstatus 1540 PARAMS ((bfd*, char*, int*, long, int, void*)); 1541 1542/* MIPS ELF specific routines. */ 1543 1544extern boolean _bfd_mips_elf_object_p 1545 PARAMS ((bfd *)); 1546extern boolean _bfd_mips_elf_section_from_shdr 1547 PARAMS ((bfd *, Elf_Internal_Shdr *, char *)); 1548extern boolean _bfd_mips_elf_fake_sections 1549 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *)); 1550extern boolean _bfd_mips_elf_section_from_bfd_section 1551 PARAMS ((bfd *, asection *, int *)); 1552extern boolean _bfd_mips_elf_section_processing 1553 PARAMS ((bfd *, Elf_Internal_Shdr *)); 1554extern void _bfd_mips_elf_symbol_processing 1555 PARAMS ((bfd *, asymbol *)); 1556extern boolean _bfd_mips_elf_read_ecoff_info 1557 PARAMS ((bfd *, asection *, struct ecoff_debug_info *)); 1558extern void _bfd_mips_elf_final_write_processing 1559 PARAMS ((bfd *, boolean)); 1560extern bfd_reloc_status_type _bfd_mips_elf_hi16_reloc 1561 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1562extern bfd_reloc_status_type _bfd_mips_elf_lo16_reloc 1563 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1564extern bfd_reloc_status_type _bfd_mips_elf_gprel16_reloc 1565 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1566extern bfd_reloc_status_type _bfd_mips_elf_got16_reloc 1567 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1568extern bfd_reloc_status_type _bfd_mips_elf_gprel32_reloc 1569 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1570extern boolean _bfd_mips_elf_set_private_flags 1571 PARAMS ((bfd *, flagword)); 1572extern boolean _bfd_mips_elf_merge_private_bfd_data 1573 PARAMS ((bfd *, bfd *)); 1574extern boolean _bfd_mips_elf_find_nearest_line 1575 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **, 1576 const char **, unsigned int *)); 1577extern boolean _bfd_mips_elf_set_section_contents 1578 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type)); 1579extern boolean _bfd_mips_elf_create_dynamic_sections 1580 PARAMS ((bfd *, struct bfd_link_info *)); 1581extern boolean _bfd_mips_elf_add_symbol_hook 1582 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, 1583 const char **, flagword *, asection **, bfd_vma *)); 1584extern boolean _bfd_mips_elf_adjust_dynamic_symbol 1585 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 1586extern boolean _bfd_mips_elf_finish_dynamic_symbol 1587 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 1588 Elf_Internal_Sym *)); 1589extern boolean _bfd_mips_elf_finish_dynamic_sections 1590 PARAMS ((bfd *, struct bfd_link_info *)); 1591extern asection * _bfd_mips_elf_gc_mark_hook 1592 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *, 1593 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 1594extern boolean _bfd_mips_elf_gc_sweep_hook 1595 PARAMS ((bfd *, struct bfd_link_info *, asection *, 1596 const Elf_Internal_Rela *)); 1597extern boolean _bfd_mips_elf_always_size_sections 1598 PARAMS ((bfd *, struct bfd_link_info *)); 1599extern boolean _bfd_mips_elf_size_dynamic_sections 1600 PARAMS ((bfd *, struct bfd_link_info *)); 1601extern boolean _bfd_mips_elf_check_relocs 1602 PARAMS ((bfd *, struct bfd_link_info *, asection *, 1603 const Elf_Internal_Rela *)); 1604extern struct bfd_link_hash_table *_bfd_mips_elf_link_hash_table_create 1605 PARAMS ((bfd *)); 1606extern boolean _bfd_mips_elf_print_private_bfd_data 1607 PARAMS ((bfd *, PTR)); 1608extern boolean _bfd_mips_elf_link_output_symbol_hook 1609 PARAMS ((bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *, 1610 asection *)); 1611extern boolean _bfd_mips_elf_final_link 1612 PARAMS ((bfd *, struct bfd_link_info *)); 1613extern int _bfd_mips_elf_additional_program_headers 1614 PARAMS ((bfd *)); 1615extern boolean _bfd_mips_elf_modify_segment_map 1616 PARAMS ((bfd *)); 1617extern boolean _bfd_mips_elf_relocate_section 1618 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 1619 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 1620 1621/* SH ELF specific routine. */ 1622 1623extern boolean _sh_elf_set_mach_from_flags 1624 PARAMS ((bfd *)); 1625 1626#endif /* _LIBELF_H_ */ 1627