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