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