elf-bfd.h revision 89857
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 /* True if addresses "naturally" sign extend. This is used when 792 swapping in from Elf32 when BFD64. */ 793 unsigned sign_extend_vma : 1; 794 795 unsigned want_got_plt : 1; 796 unsigned plt_readonly : 1; 797 unsigned want_plt_sym : 1; 798 unsigned plt_not_loaded : 1; 799 unsigned plt_alignment : 4; 800 unsigned can_gc_sections : 1; 801 unsigned can_refcount : 1; 802 unsigned want_got_sym : 1; 803 unsigned want_dynbss : 1; 804}; 805 806/* Information stored for each BFD section in an ELF file. This 807 structure is allocated by elf_new_section_hook. */ 808 809struct bfd_elf_section_data 810{ 811 /* The ELF header for this section. */ 812 Elf_Internal_Shdr this_hdr; 813 814 /* The ELF header for the reloc section associated with this 815 section, if any. */ 816 Elf_Internal_Shdr rel_hdr; 817 818 /* If there is a second reloc section associated with this section, 819 as can happen on Irix 6, this field points to the header. */ 820 Elf_Internal_Shdr *rel_hdr2; 821 822 /* The number of relocations currently assigned to REL_HDR. */ 823 unsigned int rel_count; 824 825 /* The number of relocations currently assigned to REL_HDR2. */ 826 unsigned int rel_count2; 827 828 /* A pointer to a linked list tracking dynamic relocs copied for 829 local symbols. */ 830 PTR local_dynrel; 831 832 /* A pointer to the bfd section used for dynamic relocs. */ 833 asection *sreloc; 834 835 /* The ELF section number of this section. Only used for an output 836 file. */ 837 int this_idx; 838 839 /* The ELF section number of the reloc section indicated by 840 REL_HDR if any. Only used for an output file. */ 841 int rel_idx; 842 843 /* The ELF section number of the reloc section indicated by 844 REL_HDR2 if any. Only used for an output file. */ 845 int rel_idx2; 846 847 /* Used by the backend linker to store the symbol hash table entries 848 associated with relocs against global symbols. */ 849 struct elf_link_hash_entry **rel_hashes; 850 851 /* A pointer to the swapped relocs. If the section uses REL relocs, 852 rather than RELA, all the r_addend fields will be zero. This 853 pointer may be NULL. It is used by the backend linker. */ 854 Elf_Internal_Rela *relocs; 855 856 /* Used by the backend linker when generating a shared library to 857 record the dynamic symbol index for a section symbol 858 corresponding to this section. A value of 0 means that there is 859 no dynamic symbol for this section. */ 860 long dynindx; 861 862 /* A pointer used for various section optimizations. */ 863 PTR sec_info; 864 865 /* Type of that information. */ 866 enum elf_link_info_type sec_info_type; 867 868 /* Group name, if this section is part of a group. */ 869 const char *group_name; 870 871 /* A linked list of sections in the group. Circular when used by 872 the linker. */ 873 asection *next_in_group; 874 875 /* A pointer available for the processor specific ELF backend. */ 876 PTR tdata; 877 878 /* Nonzero if this section uses RELA relocations, rather than REL. */ 879 unsigned int use_rela_p:1; 880}; 881 882#define elf_section_data(sec) ((struct bfd_elf_section_data*)sec->used_by_bfd) 883#define elf_group_name(sec) (elf_section_data(sec)->group_name) 884#define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group) 885 886/* Return true if section has been discarded. */ 887#define elf_discarded_section(sec) \ 888 (!bfd_is_abs_section(sec) \ 889 && bfd_is_abs_section((sec)->output_section) \ 890 && elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE) 891 892#define get_elf_backend_data(abfd) \ 893 ((struct elf_backend_data *) (abfd)->xvec->backend_data) 894 895/* Enumeration to specify the special section. */ 896typedef enum elf_linker_section_enum 897{ 898 LINKER_SECTION_UNKNOWN, /* not used */ 899 LINKER_SECTION_GOT, /* .got section for global offset pointers */ 900 LINKER_SECTION_PLT, /* .plt section for generated procedure stubs */ 901 LINKER_SECTION_SDATA, /* .sdata/.sbss section for PowerPC */ 902 LINKER_SECTION_SDATA2, /* .sdata2/.sbss2 section for PowerPC */ 903 LINKER_SECTION_MAX /* # of linker sections */ 904} elf_linker_section_enum_t; 905 906/* Sections created by the linker. */ 907 908typedef struct elf_linker_section 909{ 910 char *name; /* name of the section */ 911 char *rel_name; /* name of the associated .rel{,a}. section */ 912 char *bss_name; /* name of a related .bss section */ 913 char *sym_name; /* name of symbol to reference this section */ 914 asection *section; /* pointer to the section */ 915 asection *bss_section; /* pointer to the bss section associated with this */ 916 asection *rel_section; /* pointer to the relocations needed for this section */ 917 struct elf_link_hash_entry *sym_hash; /* pointer to the created symbol hash value */ 918 bfd_vma initial_size; /* initial size before any linker generated allocations */ 919 bfd_vma sym_offset; /* offset of symbol from beginning of section */ 920 bfd_vma hole_size; /* size of reserved address hole in allocation */ 921 bfd_vma hole_offset; /* current offset for the hole */ 922 bfd_vma max_hole_offset; /* maximum offset for the hole */ 923 elf_linker_section_enum_t which; /* which section this is */ 924 boolean hole_written_p; /* whether the hole has been initialized */ 925 unsigned int alignment; /* alignment for the section */ 926 flagword flags; /* flags to use to create the section */ 927} elf_linker_section_t; 928 929/* Linked list of allocated pointer entries. This hangs off of the symbol lists, and 930 provides allows us to return different pointers, based on different addend's. */ 931 932typedef struct elf_linker_section_pointers 933{ 934 struct elf_linker_section_pointers *next; /* next allocated pointer for this symbol */ 935 bfd_vma offset; /* offset of pointer from beginning of section */ 936 bfd_vma addend; /* addend used */ 937 elf_linker_section_enum_t which; /* which linker section this is */ 938 boolean written_address_p; /* whether address was written yet */ 939} elf_linker_section_pointers_t; 940 941/* Some private data is stashed away for future use using the tdata pointer 942 in the bfd structure. */ 943 944struct elf_obj_tdata 945{ 946 Elf_Internal_Ehdr elf_header[1]; /* Actual data, but ref like ptr */ 947 Elf_Internal_Shdr **elf_sect_ptr; 948 Elf_Internal_Phdr *phdr; 949 struct elf_segment_map *segment_map; 950 struct elf_strtab_hash *strtab_ptr; 951 int num_locals; 952 int num_globals; 953 unsigned int num_elf_sections; /* elf_sect_ptr size */ 954 int num_section_syms; 955 asymbol **section_syms; /* STT_SECTION symbols for each section */ 956 Elf_Internal_Shdr symtab_hdr; 957 Elf_Internal_Shdr shstrtab_hdr; 958 Elf_Internal_Shdr strtab_hdr; 959 Elf_Internal_Shdr dynsymtab_hdr; 960 Elf_Internal_Shdr dynstrtab_hdr; 961 Elf_Internal_Shdr dynversym_hdr; 962 Elf_Internal_Shdr dynverref_hdr; 963 Elf_Internal_Shdr dynverdef_hdr; 964 Elf_Internal_Shdr symtab_shndx_hdr; 965 unsigned int symtab_section, shstrtab_section; 966 unsigned int strtab_section, dynsymtab_section; 967 unsigned int symtab_shndx_section; 968 unsigned int dynversym_section, dynverdef_section, dynverref_section; 969 file_ptr next_file_pos; 970#if 0 971 /* we don't need these inside bfd anymore, and I think 972 these weren't used outside bfd. */ 973 void *prstatus; /* The raw /proc prstatus structure */ 974 void *prpsinfo; /* The raw /proc prpsinfo structure */ 975#endif 976 bfd_vma gp; /* The gp value */ 977 unsigned int gp_size; /* The gp size */ 978 979 Elf_Internal_Shdr **group_sect_ptr; 980 int num_group; 981 982 /* Information grabbed from an elf core file. */ 983 int core_signal; 984 int core_pid; 985 int core_lwpid; 986 char* core_program; 987 char* core_command; 988 989 /* This is set to true if the object was created by the backend 990 linker. */ 991 boolean linker; 992 993 /* A mapping from external symbols to entries in the linker hash 994 table, used when linking. This is indexed by the symbol index 995 minus the sh_info field of the symbol table header. */ 996 struct elf_link_hash_entry **sym_hashes; 997 998 /* A mapping from local symbols to offsets into the global offset 999 table, used when linking. This is indexed by the symbol index. 1000 Like for the globals, we use a union and two names primarily to 1001 document the intent of any particular piece of code. The field 1002 should be used as a count until size_dynamic_sections, at which 1003 point the contents of the .got is fixed. Afterward, if an entry 1004 is -1, then the symbol does not require a global offset table entry. */ 1005 union 1006 { 1007 bfd_signed_vma *refcounts; 1008 bfd_vma *offsets; 1009 } local_got; 1010 1011 /* A mapping from local symbols to offsets into the various linker 1012 sections added. This is index by the symbol index. */ 1013 elf_linker_section_pointers_t **linker_section_pointers; 1014 1015 /* The linker ELF emulation code needs to let the backend ELF linker 1016 know what filename should be used for a dynamic object if the 1017 dynamic object is found using a search. The emulation code then 1018 sometimes needs to know what name was actually used. Until the 1019 file has been added to the linker symbol table, this field holds 1020 the name the linker wants. After it has been added, it holds the 1021 name actually used, which will be the DT_SONAME entry if there is 1022 one. */ 1023 const char *dt_name; 1024 1025 /* When a reference in a regular object is resolved by a shared 1026 object is loaded into via the DT_NEEDED entries by the linker 1027 ELF emulation code, we need to add the shared object to the 1028 DT_NEEDED list of the resulting binary to indicate the dependency 1029 as if the -l option is passed to the linker. This field holds the 1030 name of the loaded shared object. */ 1031 const char *dt_soname; 1032 1033 /* Irix 5 often screws up the symbol table, sorting local symbols 1034 after global symbols. This flag is set if the symbol table in 1035 this BFD appears to be screwed up. If it is, we ignore the 1036 sh_info field in the symbol table header, and always read all the 1037 symbols. */ 1038 boolean bad_symtab; 1039 1040 /* Records the result of `get_program_header_size'. */ 1041 bfd_size_type program_header_size; 1042 1043 /* Used by find_nearest_line entry point. */ 1044 PTR line_info; 1045 1046 /* Used by MIPS ELF find_nearest_line entry point. The structure 1047 could be included directly in this one, but there's no point to 1048 wasting the memory just for the infrequently called 1049 find_nearest_line. */ 1050 struct mips_elf_find_line *find_line_info; 1051 1052 /* A place to stash dwarf1 info for this bfd. */ 1053 struct dwarf1_debug *dwarf1_find_line_info; 1054 1055 /* A place to stash dwarf2 info for this bfd. */ 1056 PTR dwarf2_find_line_info; 1057 1058 /* An array of stub sections indexed by symbol number, used by the 1059 MIPS ELF linker. FIXME: We should figure out some way to only 1060 include this field for a MIPS ELF target. */ 1061 asection **local_stubs; 1062 1063 /* Used to determine if the e_flags field has been initialized */ 1064 boolean flags_init; 1065 1066 /* Used to determine if PT_GNU_EH_FRAME segment header should be 1067 created. */ 1068 boolean eh_frame_hdr; 1069 1070 /* Number of symbol version definitions we are about to emit. */ 1071 unsigned int cverdefs; 1072 1073 /* Number of symbol version references we are about to emit. */ 1074 unsigned int cverrefs; 1075 1076 /* Symbol version definitions in external objects. */ 1077 Elf_Internal_Verdef *verdef; 1078 1079 /* Symbol version references to external objects. */ 1080 Elf_Internal_Verneed *verref; 1081 1082 /* Linker sections that we are interested in. */ 1083 struct elf_linker_section *linker_section[ (int)LINKER_SECTION_MAX ]; 1084 1085 /* The Irix 5 support uses two virtual sections, which represent 1086 text/data symbols defined in dynamic objects. */ 1087 asymbol *elf_data_symbol; 1088 asymbol *elf_text_symbol; 1089 asection *elf_data_section; 1090 asection *elf_text_section; 1091}; 1092 1093#define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data) 1094#define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header) 1095#define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr) 1096#define elf_numsections(bfd) (elf_tdata(bfd) -> num_elf_sections) 1097#define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr) 1098#define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section) 1099#define elf_symtab_shndx(bfd) (elf_tdata(bfd) -> symtab_shndx_section) 1100#define elf_dynsymtab(bfd) (elf_tdata(bfd) -> dynsymtab_section) 1101#define elf_dynversym(bfd) (elf_tdata(bfd) -> dynversym_section) 1102#define elf_dynverdef(bfd) (elf_tdata(bfd) -> dynverdef_section) 1103#define elf_dynverref(bfd) (elf_tdata(bfd) -> dynverref_section) 1104#define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals) 1105#define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals) 1106#define elf_section_syms(bfd) (elf_tdata(bfd) -> section_syms) 1107#define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms) 1108#define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo) 1109#define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus) 1110#define elf_gp(bfd) (elf_tdata(bfd) -> gp) 1111#define elf_gp_size(bfd) (elf_tdata(bfd) -> gp_size) 1112#define elf_sym_hashes(bfd) (elf_tdata(bfd) -> sym_hashes) 1113#define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts) 1114#define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets) 1115#define elf_local_ptr_offsets(bfd) (elf_tdata(bfd) -> linker_section_pointers) 1116#define elf_dt_name(bfd) (elf_tdata(bfd) -> dt_name) 1117#define elf_dt_soname(bfd) (elf_tdata(bfd) -> dt_soname) 1118#define elf_bad_symtab(bfd) (elf_tdata(bfd) -> bad_symtab) 1119#define elf_flags_init(bfd) (elf_tdata(bfd) -> flags_init) 1120#define elf_linker_section(bfd,n) (elf_tdata(bfd) -> linker_section[(int)n]) 1121 1122extern void _bfd_elf_swap_verdef_in 1123 PARAMS ((bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *)); 1124extern void _bfd_elf_swap_verdef_out 1125 PARAMS ((bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *)); 1126extern void _bfd_elf_swap_verdaux_in 1127 PARAMS ((bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *)); 1128extern void _bfd_elf_swap_verdaux_out 1129 PARAMS ((bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *)); 1130extern void _bfd_elf_swap_verneed_in 1131 PARAMS ((bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *)); 1132extern void _bfd_elf_swap_verneed_out 1133 PARAMS ((bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *)); 1134extern void _bfd_elf_swap_vernaux_in 1135 PARAMS ((bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *)); 1136extern void _bfd_elf_swap_vernaux_out 1137 PARAMS ((bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *)); 1138extern void _bfd_elf_swap_versym_in 1139 PARAMS ((bfd *, const Elf_External_Versym *, Elf_Internal_Versym *)); 1140extern void _bfd_elf_swap_versym_out 1141 PARAMS ((bfd *, const Elf_Internal_Versym *, Elf_External_Versym *)); 1142 1143extern int _bfd_elf_section_from_bfd_section 1144 PARAMS ((bfd *, asection *)); 1145extern char *bfd_elf_string_from_elf_section 1146 PARAMS ((bfd *, unsigned, unsigned)); 1147extern char *bfd_elf_get_str_section 1148 PARAMS ((bfd *, unsigned)); 1149 1150extern boolean _bfd_elf_copy_private_bfd_data 1151 PARAMS ((bfd *, bfd *)); 1152extern boolean _bfd_elf_print_private_bfd_data 1153 PARAMS ((bfd *, PTR)); 1154extern void bfd_elf_print_symbol 1155 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type)); 1156 1157#define elf_string_from_elf_strtab(abfd, strindex) \ 1158 bfd_elf_string_from_elf_section(abfd, elf_elfheader(abfd)->e_shstrndx, \ 1159 strindex) 1160 1161#define bfd_elf32_print_symbol bfd_elf_print_symbol 1162#define bfd_elf64_print_symbol bfd_elf_print_symbol 1163 1164extern void _bfd_elf_sprintf_vma 1165 PARAMS ((bfd *, char *, bfd_vma)); 1166extern void _bfd_elf_fprintf_vma 1167 PARAMS ((bfd *, PTR, bfd_vma)); 1168 1169extern enum elf_reloc_type_class _bfd_elf_reloc_type_class 1170 PARAMS ((const Elf_Internal_Rela *)); 1171extern bfd_vma _bfd_elf_rela_local_sym 1172 PARAMS ((bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *)); 1173extern bfd_vma _bfd_elf_rel_local_sym 1174 PARAMS ((bfd *, Elf_Internal_Sym *, asection **, bfd_vma)); 1175extern bfd_vma _bfd_elf_section_offset 1176 PARAMS ((bfd *, struct bfd_link_info *, asection *, bfd_vma)); 1177 1178extern unsigned long bfd_elf_hash 1179 PARAMS ((const char *)); 1180 1181extern bfd_reloc_status_type bfd_elf_generic_reloc 1182 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1183extern boolean bfd_elf_mkobject 1184 PARAMS ((bfd *)); 1185extern boolean bfd_elf_mkcorefile 1186 PARAMS ((bfd *)); 1187extern Elf_Internal_Shdr *bfd_elf_find_section 1188 PARAMS ((bfd *, char *)); 1189extern boolean _bfd_elf_make_section_from_shdr 1190 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *)); 1191extern boolean _bfd_elf_make_section_from_phdr 1192 PARAMS ((bfd *, Elf_Internal_Phdr *, int, const char *)); 1193extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc 1194 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 1195extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create 1196 PARAMS ((bfd *)); 1197extern void _bfd_elf_link_hash_copy_indirect 1198 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *)); 1199extern void _bfd_elf_link_hash_hide_symbol 1200 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean)); 1201extern boolean _bfd_elf_link_hash_table_init 1202 PARAMS ((struct elf_link_hash_table *, bfd *, 1203 struct bfd_hash_entry *(*) (struct bfd_hash_entry *, 1204 struct bfd_hash_table *, 1205 const char *))); 1206extern boolean _bfd_elf_slurp_version_tables 1207 PARAMS ((bfd *)); 1208 1209extern boolean _bfd_elf_merge_sections 1210 PARAMS ((bfd *, struct bfd_link_info *)); 1211 1212extern boolean _bfd_elf_copy_private_symbol_data 1213 PARAMS ((bfd *, asymbol *, bfd *, asymbol *)); 1214extern boolean _bfd_elf_copy_private_section_data 1215 PARAMS ((bfd *, asection *, bfd *, asection *)); 1216extern boolean _bfd_elf_write_object_contents 1217 PARAMS ((bfd *)); 1218extern boolean _bfd_elf_write_corefile_contents 1219 PARAMS ((bfd *)); 1220extern boolean _bfd_elf_set_section_contents 1221 PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); 1222extern long _bfd_elf_get_symtab_upper_bound 1223 PARAMS ((bfd *)); 1224extern long _bfd_elf_get_symtab 1225 PARAMS ((bfd *, asymbol **)); 1226extern long _bfd_elf_get_dynamic_symtab_upper_bound 1227 PARAMS ((bfd *)); 1228extern long _bfd_elf_canonicalize_dynamic_symtab 1229 PARAMS ((bfd *, asymbol **)); 1230extern long _bfd_elf_get_reloc_upper_bound 1231 PARAMS ((bfd *, sec_ptr)); 1232extern long _bfd_elf_canonicalize_reloc 1233 PARAMS ((bfd *, sec_ptr, arelent **, asymbol **)); 1234extern long _bfd_elf_get_dynamic_reloc_upper_bound 1235 PARAMS ((bfd *)); 1236extern long _bfd_elf_canonicalize_dynamic_reloc 1237 PARAMS ((bfd *, arelent **, asymbol **)); 1238extern asymbol *_bfd_elf_make_empty_symbol 1239 PARAMS ((bfd *)); 1240extern void _bfd_elf_get_symbol_info 1241 PARAMS ((bfd *, asymbol *, symbol_info *)); 1242extern boolean _bfd_elf_is_local_label_name 1243 PARAMS ((bfd *, const char *)); 1244extern alent *_bfd_elf_get_lineno 1245 PARAMS ((bfd *, asymbol *)); 1246extern boolean _bfd_elf_set_arch_mach 1247 PARAMS ((bfd *, enum bfd_architecture, unsigned long)); 1248extern boolean _bfd_elf_find_nearest_line 1249 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **, 1250 const char **, unsigned int *)); 1251#define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols 1252#define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 1253extern int _bfd_elf_sizeof_headers 1254 PARAMS ((bfd *, boolean)); 1255extern boolean _bfd_elf_new_section_hook 1256 PARAMS ((bfd *, asection *)); 1257extern boolean _bfd_elf_init_reloc_shdr 1258 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *, boolean)); 1259 1260/* If the target doesn't have reloc handling written yet: */ 1261extern void _bfd_elf_no_info_to_howto 1262 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 1263 1264extern boolean bfd_section_from_shdr 1265 PARAMS ((bfd *, unsigned int shindex)); 1266extern boolean bfd_section_from_phdr 1267 PARAMS ((bfd *, Elf_Internal_Phdr *, int)); 1268 1269extern int _bfd_elf_symbol_from_bfd_symbol 1270 PARAMS ((bfd *, asymbol **)); 1271 1272extern asection *bfd_section_from_r_symndx 1273 PARAMS ((bfd *, struct sym_sec_cache *, asection *, unsigned long)); 1274extern asection *bfd_section_from_elf_index 1275 PARAMS ((bfd *, unsigned int)); 1276extern boolean _bfd_elf_create_dynamic_sections 1277 PARAMS ((bfd *, struct bfd_link_info *)); 1278extern struct bfd_strtab_hash *_bfd_elf_stringtab_init 1279 PARAMS ((void)); 1280 1281extern struct elf_strtab_hash * _bfd_elf_strtab_init 1282 PARAMS ((void)); 1283extern void _bfd_elf_strtab_free 1284 PARAMS ((struct elf_strtab_hash *)); 1285extern bfd_size_type _bfd_elf_strtab_add 1286 PARAMS ((struct elf_strtab_hash *, const char *, boolean)); 1287extern void _bfd_elf_strtab_addref 1288 PARAMS ((struct elf_strtab_hash *, bfd_size_type)); 1289extern void _bfd_elf_strtab_delref 1290 PARAMS ((struct elf_strtab_hash *, bfd_size_type)); 1291extern void _bfd_elf_strtab_clear_all_refs 1292 PARAMS ((struct elf_strtab_hash *)); 1293extern bfd_size_type _bfd_elf_strtab_size 1294 PARAMS ((struct elf_strtab_hash *)); 1295extern bfd_size_type _bfd_elf_strtab_offset 1296 PARAMS ((struct elf_strtab_hash *, bfd_size_type)); 1297extern boolean _bfd_elf_strtab_emit 1298 PARAMS ((bfd *, struct elf_strtab_hash *)); 1299extern void _bfd_elf_strtab_finalize 1300 PARAMS ((struct elf_strtab_hash *)); 1301 1302extern boolean _bfd_elf_discard_section_eh_frame 1303 PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *, 1304 boolean (*) (bfd_vma, PTR), struct elf_reloc_cookie *)); 1305extern boolean _bfd_elf_discard_section_eh_frame_hdr 1306 PARAMS ((bfd *, struct bfd_link_info *, asection *)); 1307extern bfd_vma _bfd_elf_eh_frame_section_offset 1308 PARAMS ((bfd *, asection *, bfd_vma)); 1309extern boolean _bfd_elf_write_section_eh_frame 1310 PARAMS ((bfd *, asection *, asection *, bfd_byte *)); 1311extern boolean _bfd_elf_write_section_eh_frame_hdr 1312 PARAMS ((bfd *, asection *)); 1313extern boolean _bfd_elf_maybe_strip_eh_frame_hdr 1314 PARAMS ((struct bfd_link_info *)); 1315 1316extern boolean _bfd_elf_link_record_dynamic_symbol 1317 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 1318extern long _bfd_elf_link_lookup_local_dynindx 1319 PARAMS ((struct bfd_link_info *, bfd *, long)); 1320extern boolean _bfd_elf_compute_section_file_positions 1321 PARAMS ((bfd *, struct bfd_link_info *)); 1322extern void _bfd_elf_assign_file_positions_for_relocs 1323 PARAMS ((bfd *)); 1324extern file_ptr _bfd_elf_assign_file_position_for_section 1325 PARAMS ((Elf_Internal_Shdr *, file_ptr, boolean)); 1326 1327extern boolean _bfd_elf_validate_reloc 1328 PARAMS ((bfd *, arelent *)); 1329 1330extern boolean _bfd_elf_create_dynamic_sections 1331 PARAMS ((bfd *, struct bfd_link_info *)); 1332extern boolean _bfd_elf_create_got_section 1333 PARAMS ((bfd *, struct bfd_link_info *)); 1334extern unsigned long _bfd_elf_link_renumber_dynsyms 1335 PARAMS ((bfd *, struct bfd_link_info *)); 1336 1337extern boolean _bfd_elfcore_make_pseudosection 1338 PARAMS ((bfd *, char *, size_t, ufile_ptr)); 1339extern char *_bfd_elfcore_strndup 1340 PARAMS ((bfd *, char *, size_t)); 1341 1342extern elf_linker_section_t *_bfd_elf_create_linker_section 1343 PARAMS ((bfd *, struct bfd_link_info *, enum elf_linker_section_enum, 1344 elf_linker_section_t *)); 1345 1346extern elf_linker_section_pointers_t *_bfd_elf_find_pointer_linker_section 1347 PARAMS ((elf_linker_section_pointers_t *, bfd_vma, 1348 elf_linker_section_enum_t)); 1349 1350extern boolean bfd_elf32_create_pointer_linker_section 1351 PARAMS ((bfd *, struct bfd_link_info *, elf_linker_section_t *, 1352 struct elf_link_hash_entry *, const Elf32_Internal_Rela *)); 1353 1354extern bfd_vma bfd_elf32_finish_pointer_linker_section 1355 PARAMS ((bfd *, bfd *, struct bfd_link_info *, elf_linker_section_t *, 1356 struct elf_link_hash_entry *, bfd_vma, 1357 const Elf32_Internal_Rela *, int)); 1358 1359extern boolean bfd_elf64_create_pointer_linker_section 1360 PARAMS ((bfd *, struct bfd_link_info *, elf_linker_section_t *, 1361 struct elf_link_hash_entry *, const Elf64_Internal_Rela *)); 1362 1363extern bfd_vma bfd_elf64_finish_pointer_linker_section 1364 PARAMS ((bfd *, bfd *, struct bfd_link_info *, elf_linker_section_t *, 1365 struct elf_link_hash_entry *, bfd_vma, 1366 const Elf64_Internal_Rela *, int)); 1367 1368extern boolean _bfd_elf_make_linker_section_rela 1369 PARAMS ((bfd *, elf_linker_section_t *, int)); 1370 1371extern const bfd_target *bfd_elf32_object_p 1372 PARAMS ((bfd *)); 1373extern const bfd_target *bfd_elf32_core_file_p 1374 PARAMS ((bfd *)); 1375extern char *bfd_elf32_core_file_failing_command 1376 PARAMS ((bfd *)); 1377extern int bfd_elf32_core_file_failing_signal 1378 PARAMS ((bfd *)); 1379extern boolean bfd_elf32_core_file_matches_executable_p 1380 PARAMS ((bfd *, bfd *)); 1381 1382extern boolean bfd_elf32_bfd_link_add_symbols 1383 PARAMS ((bfd *, struct bfd_link_info *)); 1384extern boolean bfd_elf32_bfd_final_link 1385 PARAMS ((bfd *, struct bfd_link_info *)); 1386 1387extern void bfd_elf32_swap_symbol_in 1388 PARAMS ((bfd *, const Elf32_External_Sym *, const Elf_External_Sym_Shndx *, 1389 Elf_Internal_Sym *)); 1390extern void bfd_elf32_swap_symbol_out 1391 PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR)); 1392extern void bfd_elf32_swap_reloc_in 1393 PARAMS ((bfd *, const Elf32_External_Rel *, Elf_Internal_Rel *)); 1394extern void bfd_elf32_swap_reloc_out 1395 PARAMS ((bfd *, const Elf_Internal_Rel *, Elf32_External_Rel *)); 1396extern void bfd_elf32_swap_reloca_in 1397 PARAMS ((bfd *, const Elf32_External_Rela *, Elf_Internal_Rela *)); 1398extern void bfd_elf32_swap_reloca_out 1399 PARAMS ((bfd *, const Elf_Internal_Rela *, Elf32_External_Rela *)); 1400extern void bfd_elf32_swap_phdr_in 1401 PARAMS ((bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *)); 1402extern void bfd_elf32_swap_phdr_out 1403 PARAMS ((bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *)); 1404extern void bfd_elf32_swap_dyn_in 1405 PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *)); 1406extern void bfd_elf32_swap_dyn_out 1407 PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR)); 1408extern long bfd_elf32_slurp_symbol_table 1409 PARAMS ((bfd *, asymbol **, boolean)); 1410extern boolean bfd_elf32_write_shdrs_and_ehdr 1411 PARAMS ((bfd *)); 1412extern int bfd_elf32_write_out_phdrs 1413 PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int)); 1414extern void bfd_elf32_write_relocs 1415 PARAMS ((bfd *, asection *, PTR)); 1416extern boolean bfd_elf32_slurp_reloc_table 1417 PARAMS ((bfd *, asection *, asymbol **, boolean)); 1418extern boolean bfd_elf32_add_dynamic_entry 1419 PARAMS ((struct bfd_link_info *, bfd_vma, bfd_vma)); 1420extern boolean bfd_elf32_link_create_dynamic_sections 1421 PARAMS ((bfd *, struct bfd_link_info *)); 1422extern Elf_Internal_Rela *_bfd_elf32_link_read_relocs 1423 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean)); 1424 1425extern const bfd_target *bfd_elf64_object_p 1426 PARAMS ((bfd *)); 1427extern const bfd_target *bfd_elf64_core_file_p 1428 PARAMS ((bfd *)); 1429extern char *bfd_elf64_core_file_failing_command 1430 PARAMS ((bfd *)); 1431extern int bfd_elf64_core_file_failing_signal 1432 PARAMS ((bfd *)); 1433extern boolean bfd_elf64_core_file_matches_executable_p 1434 PARAMS ((bfd *, bfd *)); 1435extern boolean bfd_elf64_bfd_link_add_symbols 1436 PARAMS ((bfd *, struct bfd_link_info *)); 1437extern boolean bfd_elf64_bfd_final_link 1438 PARAMS ((bfd *, struct bfd_link_info *)); 1439 1440extern void bfd_elf64_swap_symbol_in 1441 PARAMS ((bfd *, const Elf64_External_Sym *, const Elf_External_Sym_Shndx *, 1442 Elf_Internal_Sym *)); 1443extern void bfd_elf64_swap_symbol_out 1444 PARAMS ((bfd *, const Elf_Internal_Sym *, PTR, PTR)); 1445extern void bfd_elf64_swap_reloc_in 1446 PARAMS ((bfd *, const Elf64_External_Rel *, Elf_Internal_Rel *)); 1447extern void bfd_elf64_swap_reloc_out 1448 PARAMS ((bfd *, const Elf_Internal_Rel *, Elf64_External_Rel *)); 1449extern void bfd_elf64_swap_reloca_in 1450 PARAMS ((bfd *, const Elf64_External_Rela *, Elf_Internal_Rela *)); 1451extern void bfd_elf64_swap_reloca_out 1452 PARAMS ((bfd *, const Elf_Internal_Rela *, Elf64_External_Rela *)); 1453extern void bfd_elf64_swap_phdr_in 1454 PARAMS ((bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *)); 1455extern void bfd_elf64_swap_phdr_out 1456 PARAMS ((bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *)); 1457extern void bfd_elf64_swap_dyn_in 1458 PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *)); 1459extern void bfd_elf64_swap_dyn_out 1460 PARAMS ((bfd *, const Elf_Internal_Dyn *, PTR)); 1461extern long bfd_elf64_slurp_symbol_table 1462 PARAMS ((bfd *, asymbol **, boolean)); 1463extern boolean bfd_elf64_write_shdrs_and_ehdr 1464 PARAMS ((bfd *)); 1465extern int bfd_elf64_write_out_phdrs 1466 PARAMS ((bfd *, const Elf_Internal_Phdr *, unsigned int)); 1467extern void bfd_elf64_write_relocs 1468 PARAMS ((bfd *, asection *, PTR)); 1469extern boolean bfd_elf64_slurp_reloc_table 1470 PARAMS ((bfd *, asection *, asymbol **, boolean)); 1471extern boolean bfd_elf64_add_dynamic_entry 1472 PARAMS ((struct bfd_link_info *, bfd_vma, bfd_vma)); 1473extern boolean bfd_elf64_link_create_dynamic_sections 1474 PARAMS ((bfd *, struct bfd_link_info *)); 1475extern Elf_Internal_Rela *_bfd_elf64_link_read_relocs 1476 PARAMS ((bfd *, asection *, PTR, Elf_Internal_Rela *, boolean)); 1477 1478#define bfd_elf32_link_record_dynamic_symbol \ 1479 _bfd_elf_link_record_dynamic_symbol 1480#define bfd_elf64_link_record_dynamic_symbol \ 1481 _bfd_elf_link_record_dynamic_symbol 1482 1483extern boolean _bfd_elf32_link_record_local_dynamic_symbol 1484 PARAMS ((struct bfd_link_info *, bfd *, long)); 1485extern boolean _bfd_elf64_link_record_local_dynamic_symbol 1486 PARAMS ((struct bfd_link_info *, bfd *, long)); 1487 1488extern boolean _bfd_elf_close_and_cleanup 1489 PARAMS ((bfd *)); 1490extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn 1491 PARAMS ((bfd *, arelent *, struct symbol_cache_entry *, PTR, 1492 asection *, bfd *, char **)); 1493 1494extern boolean _bfd_elf32_gc_sections 1495 PARAMS ((bfd *, struct bfd_link_info *)); 1496extern boolean _bfd_elf32_gc_common_finalize_got_offsets 1497 PARAMS ((bfd *, struct bfd_link_info *)); 1498extern boolean _bfd_elf32_gc_common_final_link 1499 PARAMS ((bfd *, struct bfd_link_info *)); 1500extern boolean _bfd_elf32_gc_record_vtinherit 1501 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1502extern boolean _bfd_elf32_gc_record_vtentry 1503 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1504 1505extern boolean _bfd_elf64_gc_sections 1506 PARAMS ((bfd *, struct bfd_link_info *)); 1507extern boolean _bfd_elf64_gc_common_finalize_got_offsets 1508 PARAMS ((bfd *, struct bfd_link_info *)); 1509extern boolean _bfd_elf64_gc_common_final_link 1510 PARAMS ((bfd *, struct bfd_link_info *)); 1511extern boolean _bfd_elf64_gc_record_vtinherit 1512 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1513extern boolean _bfd_elf64_gc_record_vtentry 1514 PARAMS ((bfd *, asection *, struct elf_link_hash_entry *, bfd_vma)); 1515 1516extern boolean _bfd_elf32_reloc_symbol_deleted_p 1517 PARAMS ((bfd_vma, PTR)); 1518extern boolean _bfd_elf64_reloc_symbol_deleted_p 1519 PARAMS ((bfd_vma, PTR)); 1520 1521/* Exported interface for writing elf corefile notes. */ 1522extern char *elfcore_write_note 1523 PARAMS ((bfd *, char *, int *, char *, int, void *, int)); 1524extern char *elfcore_write_prpsinfo 1525 PARAMS ((bfd *, char *, int *, char *, char *)); 1526extern char *elfcore_write_prstatus 1527 PARAMS ((bfd *, char *, int *, long, int, void *)); 1528extern char * elfcore_write_pstatus 1529 PARAMS ((bfd *, char *, int *, long, int, void *)); 1530extern char *elfcore_write_prfpreg 1531 PARAMS ((bfd *, char *, int *, void *, int)); 1532extern char *elfcore_write_prxfpreg 1533 PARAMS ((bfd *, char *, int *, void *, int)); 1534 1535/* MIPS ELF specific routines. */ 1536 1537extern boolean _bfd_mips_elf_object_p 1538 PARAMS ((bfd *)); 1539extern boolean _bfd_mips_elf_section_from_shdr 1540 PARAMS ((bfd *, Elf_Internal_Shdr *, char *)); 1541extern boolean _bfd_mips_elf_fake_sections 1542 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *)); 1543extern boolean _bfd_mips_elf_section_from_bfd_section 1544 PARAMS ((bfd *, asection *, int *)); 1545extern boolean _bfd_mips_elf_section_processing 1546 PARAMS ((bfd *, Elf_Internal_Shdr *)); 1547extern void _bfd_mips_elf_symbol_processing 1548 PARAMS ((bfd *, asymbol *)); 1549extern boolean _bfd_mips_elf_read_ecoff_info 1550 PARAMS ((bfd *, asection *, struct ecoff_debug_info *)); 1551extern void _bfd_mips_elf_final_write_processing 1552 PARAMS ((bfd *, boolean)); 1553extern bfd_reloc_status_type _bfd_mips_elf_hi16_reloc 1554 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1555extern bfd_reloc_status_type _bfd_mips_elf_lo16_reloc 1556 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1557extern bfd_reloc_status_type _bfd_mips_elf_gprel16_reloc 1558 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1559extern bfd_reloc_status_type _bfd_mips_elf_got16_reloc 1560 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1561extern bfd_reloc_status_type _bfd_mips_elf_gprel32_reloc 1562 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 1563extern boolean _bfd_mips_elf_set_private_flags 1564 PARAMS ((bfd *, flagword)); 1565extern boolean _bfd_mips_elf_merge_private_bfd_data 1566 PARAMS ((bfd *, bfd *)); 1567extern boolean _bfd_mips_elf_find_nearest_line 1568 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **, 1569 const char **, unsigned int *)); 1570extern boolean _bfd_mips_elf_set_section_contents 1571 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type)); 1572extern boolean _bfd_mips_elf_create_dynamic_sections 1573 PARAMS ((bfd *, struct bfd_link_info *)); 1574extern boolean _bfd_mips_elf_add_symbol_hook 1575 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, 1576 const char **, flagword *, asection **, bfd_vma *)); 1577extern boolean _bfd_mips_elf_adjust_dynamic_symbol 1578 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 1579extern boolean _bfd_mips_elf_finish_dynamic_symbol 1580 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 1581 Elf_Internal_Sym *)); 1582extern boolean _bfd_mips_elf_finish_dynamic_sections 1583 PARAMS ((bfd *, struct bfd_link_info *)); 1584extern asection * _bfd_mips_elf_gc_mark_hook 1585 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *, 1586 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 1587extern boolean _bfd_mips_elf_gc_sweep_hook 1588 PARAMS ((bfd *, struct bfd_link_info *, asection *, 1589 const Elf_Internal_Rela *)); 1590extern boolean _bfd_mips_elf_always_size_sections 1591 PARAMS ((bfd *, struct bfd_link_info *)); 1592extern boolean _bfd_mips_elf_size_dynamic_sections 1593 PARAMS ((bfd *, struct bfd_link_info *)); 1594extern boolean _bfd_mips_elf_check_relocs 1595 PARAMS ((bfd *, struct bfd_link_info *, asection *, 1596 const Elf_Internal_Rela *)); 1597extern struct bfd_link_hash_table *_bfd_mips_elf_link_hash_table_create 1598 PARAMS ((bfd *)); 1599extern boolean _bfd_mips_elf_print_private_bfd_data 1600 PARAMS ((bfd *, PTR)); 1601extern boolean _bfd_mips_elf_link_output_symbol_hook 1602 PARAMS ((bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *, 1603 asection *)); 1604extern boolean _bfd_mips_elf_final_link 1605 PARAMS ((bfd *, struct bfd_link_info *)); 1606extern int _bfd_mips_elf_additional_program_headers 1607 PARAMS ((bfd *)); 1608extern boolean _bfd_mips_elf_modify_segment_map 1609 PARAMS ((bfd *)); 1610extern boolean _bfd_mips_elf_relocate_section 1611 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 1612 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 1613 1614/* SH ELF specific routine. */ 1615 1616extern boolean _sh_elf_set_mach_from_flags 1617 PARAMS ((bfd *)); 1618 1619#endif /* _LIBELF_H_ */ 1620