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