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