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