bfd/elf-bfd.h

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