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, 2003 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 #ifndef NAME
  37 #if ARCH_SIZE == 64
  38 #define NAME(x, y) x ## 64 ## _ ## y
  39 #endif
  40 #if ARCH_SIZE == 32
  41 #define NAME(x, y) x ## 32 ## _ ## y
  42 #endif
  43 #endif
  44
  45 #ifndef NAME
  46 #define NAME(x, y) x ## NOSIZE ## _ ## y
  47 #endif
  48
  49 #define ElfNAME(X)      NAME(Elf,X)
  50 #define elfNAME(X)      NAME(elf,X)
  51
  52 /* Information held for an ELF symbol.  The first field is the
  53    corresponding asymbol.  Every symbol is an ELF file is actually a
  54    pointer to this structure, although it is often handled as a
  55    pointer to an asymbol.  */
  56
  57 typedef struct
  58 {
  59   /* The BFD symbol.  */
  60   asymbol symbol;
  61   /* ELF symbol information.  */
  62   Elf_Internal_Sym internal_elf_sym;
  63   /* Backend specific information.  */
  64   union
  65     {
  66       unsigned int hppa_arg_reloc;
  67       void *mips_extr;
  68       void *any;
  69     }
  70   tc_data;
  71
  72   /* Version information.  This is from an Elf_Internal_Versym
  73      structure in a SHT_GNU_versym section.  It is zero if there is no
  74      version information.  */
  75   unsigned short version;
  76
  77 } elf_symbol_type;
  78 \f
  79 struct elf_strtab_hash;
  80 struct got_entry;
  81 struct plt_entry;
  82
  83 /* ELF linker hash table entries.  */
  84
  85 struct elf_link_hash_entry
  86 {
  87   struct bfd_link_hash_entry root;
  88
  89   /* Symbol index in output file.  This is initialized to -1.  It is
  90      set to -2 if the symbol is used by a reloc.  */
  91   long indx;
  92
  93   /* Symbol index as a dynamic symbol.  Initialized to -1, and remains
  94      -1 if this is not a dynamic symbol.  */
  95   /* ??? Note that this is consistently used as a synonym for tests
  96      against whether we can perform various simplifying transformations
  97      to the code.  (E.g. changing a pc-relative jump to a PLT entry
  98      into a pc-relative jump to the target function.)  That test, which
  99      is often relatively complex, and someplaces wrong or incomplete,
 100      should really be replaced by a predicate in elflink.c.
 101
 102      End result: this field -1 does not indicate that the symbol is
 103      not in the dynamic symbol table, but rather that the symbol is
 104      not visible outside this DSO.  */
 105   long dynindx;
 106
 107   /* String table index in .dynstr if this is a dynamic symbol.  */
 108   unsigned long dynstr_index;
 109
 110   /* Hash value of the name computed using the ELF hash function.  */
 111   unsigned long elf_hash_value;
 112
 113   /* If this is a weak defined symbol from a dynamic object, this
 114      field points to a defined symbol with the same value, if there is
 115      one.  Otherwise it is NULL.  */
 116   struct elf_link_hash_entry *weakdef;
 117
 118   /* Version information.  */
 119   union
 120   {
 121     /* This field is used for a symbol which is not defined in a
 122        regular object.  It points to the version information read in
 123        from the dynamic object.  */
 124     Elf_Internal_Verdef *verdef;
 125     /* This field is used for a symbol which is defined in a regular
 126        object.  It is set up in size_dynamic_sections.  It points to
 127        the version information we should write out for this symbol.  */
 128     struct bfd_elf_version_tree *vertree;
 129   } verinfo;
 130
 131   /* Virtual table entry use information.  This array is nominally of size
 132      size/sizeof(target_void_pointer), though we have to be able to assume
 133      and track a size while the symbol is still undefined.  It is indexed
 134      via offset/sizeof(target_void_pointer).  */
 135   size_t vtable_entries_size;
 136   bfd_boolean *vtable_entries_used;
 137
 138   /* Virtual table derivation info.  */
 139   struct elf_link_hash_entry *vtable_parent;
 140
 141   /* If this symbol requires an entry in the global offset table, the
 142      processor specific backend uses this field to track usage and
 143      final offset.  Two schemes are supported:  The first assumes that
 144      a symbol may only have one GOT entry, and uses REFCOUNT until
 145      size_dynamic_sections, at which point the contents of the .got is
 146      fixed.  Afterward, if OFFSET is -1, then the symbol does not
 147      require a global offset table entry.  The second scheme allows
 148      multiple GOT entries per symbol, managed via a linked list
 149      pointed to by GLIST.  */
 150   union gotplt_union
 151     {
 152       bfd_signed_vma refcount;
 153       bfd_vma offset;
 154       struct got_entry *glist;
 155       struct plt_entry *plist;
 156     } got;
 157
 158   /* Same, but tracks a procedure linkage table entry.  */
 159   union gotplt_union plt;
 160
 161   /* Symbol size.  */
 162   bfd_size_type size;
 163
 164   /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.).  */
 165   char type;
 166
 167   /* Symbol st_other value, symbol visibility.  */
 168   unsigned char other;
 169
 170   /* Some flags; legal values follow.  */
 171   unsigned short elf_link_hash_flags;
 172   /* Symbol is referenced by a non-shared object.  */
 173 #define ELF_LINK_HASH_REF_REGULAR 01
 174   /* Symbol is defined by a non-shared object.  */
 175 #define ELF_LINK_HASH_DEF_REGULAR 02
 176   /* Symbol is referenced by a shared object.  */
 177 #define ELF_LINK_HASH_REF_DYNAMIC 04
 178   /* Symbol is defined by a shared object.  */
 179 #define ELF_LINK_HASH_DEF_DYNAMIC 010
 180   /* Symbol has a non-weak reference from a non-shared object.  */
 181 #define ELF_LINK_HASH_REF_REGULAR_NONWEAK 020
 182   /* Dynamic symbol has been adjustd.  */
 183 #define ELF_LINK_HASH_DYNAMIC_ADJUSTED 040
 184   /* Symbol needs a copy reloc.  */
 185 #define ELF_LINK_HASH_NEEDS_COPY 0100
 186   /* Symbol needs a procedure linkage table entry.  */
 187 #define ELF_LINK_HASH_NEEDS_PLT 0200
 188   /* Symbol appears in a non-ELF input file.  */
 189 #define ELF_LINK_NON_ELF 0400
 190   /* Symbol should be marked as hidden in the version information.  */
 191 #define ELF_LINK_HIDDEN 01000
 192   /* Symbol was forced to local scope due to a version script file.  */
 193 #define ELF_LINK_FORCED_LOCAL 02000
 194   /* Symbol was marked during garbage collection.  */
 195 #define ELF_LINK_HASH_MARK 04000
 196   /* Symbol is referenced by a non-GOT/non-PLT relocation.  This is
 197      not currently set by all the backends.  */
 198 #define ELF_LINK_NON_GOT_REF 010000
 199   /* Symbol has a definition in a shared object.  */
 200 #define ELF_LINK_DYNAMIC_DEF 020000
 201   /* Symbol is weak in all shared objects.  */
 202 #define ELF_LINK_DYNAMIC_WEAK 040000
 203   /* Symbol is referenced with a relocation where C/C++ pointer equality
 204      matters.  */
 205 #define ELF_LINK_POINTER_EQUALITY_NEEDED 0100000
 206 };
 207
 208 /* Will references to this symbol always reference the symbol
 209    in this object?  STV_PROTECTED is excluded from the visibility test
 210    here so that function pointer comparisons work properly.  Since
 211    function symbols not defined in an app are set to their .plt entry,
 212    it's necessary for shared libs to also reference the .plt even
 213    though the symbol is really local to the shared lib.  */
 214 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
 215   _bfd_elf_symbol_refs_local_p (H, INFO, 0)
 216
 217 /* Will _calls_ to this symbol always call the version in this object?  */
 218 #define SYMBOL_CALLS_LOCAL(INFO, H) \
 219   _bfd_elf_symbol_refs_local_p (H, INFO, 1)
 220
 221 /* Records local symbols to be emitted in the dynamic symbol table.  */
 222
 223 struct elf_link_local_dynamic_entry
 224 {
 225   struct elf_link_local_dynamic_entry *next;
 226
 227   /* The input bfd this symbol came from.  */
 228   bfd *input_bfd;
 229
 230   /* The index of the local symbol being copied.  */
 231   long input_indx;
 232
 233   /* The index in the outgoing dynamic symbol table.  */
 234   long dynindx;
 235
 236   /* A copy of the input symbol.  */
 237   Elf_Internal_Sym isym;
 238 };
 239
 240 struct elf_link_loaded_list
 241 {
 242   struct elf_link_loaded_list *next;
 243   bfd *abfd;
 244 };
 245
 246 /* Structures used by the eh_frame optimization code.  */
 247 struct cie_header
 248 {
 249   unsigned int length;
 250   unsigned int id;
 251 };
 252
 253 struct cie
 254 {
 255   struct cie_header hdr;
 256   unsigned char version;
 257   unsigned char augmentation[20];
 258   unsigned int code_align;
 259   int data_align;
 260   unsigned int ra_column;
 261   unsigned int augmentation_size;
 262   struct elf_link_hash_entry *personality;
 263   unsigned char per_encoding;
 264   unsigned char lsda_encoding;
 265   unsigned char fde_encoding;
 266   unsigned char initial_insn_length;
 267   unsigned char make_relative;
 268   unsigned char make_lsda_relative;
 269   unsigned char initial_instructions[50];
 270 };
 271
 272 struct eh_cie_fde
 273 {
 274   unsigned int offset;
 275   unsigned int size;
 276   asection *sec;
 277   unsigned int new_offset;
 278   unsigned char fde_encoding;
 279   unsigned char lsda_encoding;
 280   unsigned char lsda_offset;
 281   unsigned char cie : 1;
 282   unsigned char removed : 1;
 283   unsigned char make_relative : 1;
 284   unsigned char make_lsda_relative : 1;
 285   unsigned char per_encoding_relative : 1;
 286 };
 287
 288 struct eh_frame_sec_info
 289 {
 290   unsigned int count;
 291   unsigned int alloced;
 292   struct eh_cie_fde entry[1];
 293 };
 294
 295 struct eh_frame_array_ent
 296 {
 297   bfd_vma initial_loc;
 298   bfd_vma fde;
 299 };
 300
 301 struct eh_frame_hdr_info
 302 {
 303   struct cie last_cie;
 304   asection *last_cie_sec;
 305   asection *hdr_sec;
 306   unsigned int last_cie_offset;
 307   unsigned int fde_count, array_count;
 308   struct eh_frame_array_ent *array;
 309   /* TRUE if .eh_frame_hdr should contain the sorted search table.
 310      We build it if we successfully read all .eh_frame input sections
 311      and recognize them.  */
 312   bfd_boolean table;
 313 };
 314
 315 /* ELF linker hash table.  */
 316
 317 struct elf_link_hash_table
 318 {
 319   struct bfd_link_hash_table root;
 320
 321   /* Whether we have created the special dynamic sections required
 322      when linking against or generating a shared object.  */
 323   bfd_boolean dynamic_sections_created;
 324
 325   /* The BFD used to hold special sections created by the linker.
 326      This will be the first BFD found which requires these sections to
 327      be created.  */
 328   bfd *dynobj;
 329
 330   /* The value to use when initialising got.refcount/offset and
 331      plt.refcount/offset in an elf_link_hash_entry.  Set to zero when
 332      the values are refcounts.  Set to init_offset in
 333      size_dynamic_sections when the values may be offsets.  */
 334   union gotplt_union init_refcount;
 335
 336   /* The value to use for got.refcount/offset and plt.refcount/offset
 337      when the values may be offsets.  Normally (bfd_vma) -1.  */
 338   union gotplt_union init_offset;
 339
 340   /* The number of symbols found in the link which must be put into
 341      the .dynsym section.  */
 342   bfd_size_type dynsymcount;
 343
 344   /* The string table of dynamic symbols, which becomes the .dynstr
 345      section.  */
 346   struct elf_strtab_hash *dynstr;
 347
 348   /* The number of buckets in the hash table in the .hash section.
 349      This is based on the number of dynamic symbols.  */
 350   bfd_size_type bucketcount;
 351
 352   /* A linked list of DT_NEEDED names found in dynamic objects
 353      included in the link.  */
 354   struct bfd_link_needed_list *needed;
 355
 356   /* The _GLOBAL_OFFSET_TABLE_ symbol.  */
 357   struct elf_link_hash_entry *hgot;
 358
 359   /* A pointer to information used to link stabs in sections.  */
 360   void *stab_info;
 361
 362   /* A pointer to information used to merge SEC_MERGE sections.  */
 363   void *merge_info;
 364
 365   /* Used by eh_frame code when editing .eh_frame.  */
 366   struct eh_frame_hdr_info eh_info;
 367
 368   /* A linked list of local symbols to be added to .dynsym.  */
 369   struct elf_link_local_dynamic_entry *dynlocal;
 370
 371   /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
 372      objects included in the link.  */
 373   struct bfd_link_needed_list *runpath;
 374
 375   /* Cached first output tls section and size of PT_TLS segment.  */
 376   asection *tls_sec;
 377   bfd_size_type tls_size;
 378
 379   /* A linked list of BFD's loaded in the link.  */
 380   struct elf_link_loaded_list *loaded;
 381 };
 382
 383 /* Look up an entry in an ELF linker hash table.  */
 384
 385 #define elf_link_hash_lookup(table, string, create, copy, follow)       \
 386   ((struct elf_link_hash_entry *)                                       \
 387    bfd_link_hash_lookup (&(table)->root, (string), (create),            \
 388                          (copy), (follow)))
 389
 390 /* Traverse an ELF linker hash table.  */
 391
 392 #define elf_link_hash_traverse(table, func, info)                       \
 393   (bfd_link_hash_traverse                                               \
 394    (&(table)->root,                                                     \
 395     (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func),    \
 396     (info)))
 397
 398 /* Get the ELF linker hash table from a link_info structure.  */
 399
 400 #define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
 401
 402 /* Returns TRUE if the hash table is a struct elf_link_hash_table.  */
 403 #define is_elf_hash_table(htab)                                         \
 404   (((struct bfd_link_hash_table *) (htab))->type == bfd_link_elf_hash_table)
 405
 406 /* Used by bfd_section_from_r_symndx to cache a small number of local
 407    symbol to section mappings.  */
 408 #define LOCAL_SYM_CACHE_SIZE 32
 409 struct sym_sec_cache
 410 {
 411   bfd *abfd;
 412   unsigned long indx[LOCAL_SYM_CACHE_SIZE];
 413   asection *sec[LOCAL_SYM_CACHE_SIZE];
 414 };
 415 \f
 416 /* Constant information held for an ELF backend.  */
 417
 418 struct elf_size_info {
 419   unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
 420   unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
 421
 422   /* The size of entries in the .hash section.  */
 423   unsigned char sizeof_hash_entry;
 424
 425   /* The number of internal relocations to allocate per external
 426      relocation entry.  */
 427   unsigned char int_rels_per_ext_rel;
 428   /* We use some fixed size arrays.  This should be large enough to
 429      handle all back-ends.  */
 430 #define MAX_INT_RELS_PER_EXT_REL 3
 431
 432   unsigned char arch_size, log_file_align;
 433   unsigned char elfclass, ev_current;
 434   int (*write_out_phdrs)
 435     (bfd *, const Elf_Internal_Phdr *, unsigned int);
 436   bfd_boolean
 437     (*write_shdrs_and_ehdr) (bfd *);
 438   void (*write_relocs)
 439     (bfd *, asection *, void *);
 440   void (*swap_symbol_in)
 441     (bfd *, const void *, const void *, Elf_Internal_Sym *);
 442   void (*swap_symbol_out)
 443     (bfd *, const Elf_Internal_Sym *, void *, void *);
 444   bfd_boolean (*slurp_reloc_table)
 445     (bfd *, asection *, asymbol **, bfd_boolean);
 446   long (*slurp_symbol_table)
 447     (bfd *, asymbol **, bfd_boolean);
 448   void (*swap_dyn_in)
 449     (bfd *, const void *, Elf_Internal_Dyn *);
 450   void (*swap_dyn_out)
 451     (bfd *, const Elf_Internal_Dyn *, void *);
 452
 453   /* This function is called to swap in a REL relocation.  If an
 454      external relocation corresponds to more than one internal
 455      relocation, then all relocations are swapped in at once.  */
 456   void (*swap_reloc_in)
 457     (bfd *, const bfd_byte *, Elf_Internal_Rela *);
 458
 459   /* This function is called to swap out a REL relocation.  */
 460   void (*swap_reloc_out)
 461     (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 462
 463   /* This function is called to swap in a RELA relocation.  If an
 464      external relocation corresponds to more than one internal
 465      relocation, then all relocations are swapped in at once.  */
 466   void (*swap_reloca_in)
 467     (bfd *, const bfd_byte *, Elf_Internal_Rela *);
 468
 469   /* This function is called to swap out a RELA relocation.  */
 470   void (*swap_reloca_out)
 471     (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 472 };
 473
 474 #define elf_symbol_from(ABFD,S) \
 475         (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
 476           && (S)->the_bfd->tdata.elf_obj_data != 0) \
 477          ? (elf_symbol_type *) (S) \
 478          : 0)
 479
 480 enum elf_reloc_type_class {
 481   reloc_class_normal,
 482   reloc_class_relative,
 483   reloc_class_plt,
 484   reloc_class_copy
 485 };
 486
 487 struct elf_reloc_cookie
 488 {
 489   Elf_Internal_Rela *rels, *rel, *relend;
 490   Elf_Internal_Sym *locsyms;
 491   bfd *abfd;
 492   size_t locsymcount;
 493   size_t extsymoff;
 494   struct elf_link_hash_entry **sym_hashes;
 495   bfd_boolean bad_symtab;
 496 };
 497
 498 /* The level of IRIX compatibility we're striving for.  */
 499
 500 typedef enum {
 501   ict_none,
 502   ict_irix5,
 503   ict_irix6
 504 } irix_compat_t;
 505
 506 /* Mapping of ELF section names and types.  */
 507 struct bfd_elf_special_section
 508 {
 509   const char *prefix;
 510   int prefix_length;
 511   /* 0 means name must match PREFIX exactly.
 512      -1 means name must start with PREFIX followed by an arbitrary string.
 513      -2 means name must match PREFIX exactly or consist of PREFIX followed
 514      by a dot then anything.
 515      > 0 means name must start with the first PREFIX_LENGTH chars of
 516      PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX.  */
 517   int suffix_length;
 518   int type;
 519   int attr;
 520 };
 521
 522 struct elf_backend_data
 523 {
 524   /* The architecture for this backend.  */
 525   enum bfd_architecture arch;
 526
 527   /* The ELF machine code (EM_xxxx) for this backend.  */
 528   int elf_machine_code;
 529
 530   /* The maximum page size for this backend.  */
 531   bfd_vma maxpagesize;
 532
 533   /* A function to translate an ELF RELA relocation to a BFD arelent
 534      structure.  */
 535   void (*elf_info_to_howto)
 536     (bfd *, arelent *, Elf_Internal_Rela *);
 537
 538   /* A function to translate an ELF REL relocation to a BFD arelent
 539      structure.  */
 540   void (*elf_info_to_howto_rel)
 541     (bfd *, arelent *, Elf_Internal_Rela *);
 542
 543   /* A function to determine whether a symbol is global when
 544      partitioning the symbol table into local and global symbols.
 545      This should be NULL for most targets, in which case the correct
 546      thing will be done.  MIPS ELF, at least on the Irix 5, has
 547      special requirements.  */
 548   bfd_boolean (*elf_backend_sym_is_global)
 549     (bfd *, asymbol *);
 550
 551   /* The remaining functions are hooks which are called only if they
 552      are not NULL.  */
 553
 554   /* A function to permit a backend specific check on whether a
 555      particular BFD format is relevant for an object file, and to
 556      permit the backend to set any global information it wishes.  When
 557      this is called elf_elfheader is set, but anything else should be
 558      used with caution.  If this returns FALSE, the check_format
 559      routine will return a bfd_error_wrong_format error.  */
 560   bfd_boolean (*elf_backend_object_p)
 561     (bfd *);
 562
 563   /* A function to do additional symbol processing when reading the
 564      ELF symbol table.  This is where any processor-specific special
 565      section indices are handled.  */
 566   void (*elf_backend_symbol_processing)
 567     (bfd *, asymbol *);
 568
 569   /* A function to do additional symbol processing after reading the
 570      entire ELF symbol table.  */
 571   bfd_boolean (*elf_backend_symbol_table_processing)
 572     (bfd *, elf_symbol_type *, unsigned int);
 573
 574    /* A function to set the type of the info field.  Processor-specific
 575      types should be handled here.  */
 576   int (*elf_backend_get_symbol_type)
 577     (Elf_Internal_Sym *, int);
 578
 579   /* A function to do additional processing on the ELF section header
 580      just before writing it out.  This is used to set the flags and
 581      type fields for some sections, or to actually write out data for
 582      unusual sections.  */
 583   bfd_boolean (*elf_backend_section_processing)
 584     (bfd *, Elf_Internal_Shdr *);
 585
 586   /* A function to handle unusual section types when creating BFD
 587      sections from ELF sections.  */
 588   bfd_boolean (*elf_backend_section_from_shdr)
 589     (bfd *, Elf_Internal_Shdr *, const char *);
 590
 591   /* A function to convert machine dependent section header flags to
 592      BFD internal section header flags.  */
 593   bfd_boolean (*elf_backend_section_flags)
 594     (flagword *, Elf_Internal_Shdr *);
 595
 596   /* A function to handle unusual program segment types when creating BFD
 597      sections from ELF program segments.  */
 598   bfd_boolean (*elf_backend_section_from_phdr)
 599     (bfd *, Elf_Internal_Phdr *, int);
 600
 601   /* A function to set up the ELF section header for a BFD section in
 602      preparation for writing it out.  This is where the flags and type
 603      fields are set for unusual sections.  */
 604   bfd_boolean (*elf_backend_fake_sections)
 605     (bfd *, Elf_Internal_Shdr *, asection *);
 606
 607   /* A function to get the ELF section index for a BFD section.  If
 608      this returns TRUE, the section was found.  If it is a normal ELF
 609      section, *RETVAL should be left unchanged.  If it is not a normal
 610      ELF section *RETVAL should be set to the SHN_xxxx index.  */
 611   bfd_boolean (*elf_backend_section_from_bfd_section)
 612     (bfd *, asection *, int *retval);
 613
 614   /* If this field is not NULL, it is called by the add_symbols phase
 615      of a link just before adding a symbol to the global linker hash
 616      table.  It may modify any of the fields as it wishes.  If *NAME
 617      is set to NULL, the symbol will be skipped rather than being
 618      added to the hash table.  This function is responsible for
 619      handling all processor dependent symbol bindings and section
 620      indices, and must set at least *FLAGS and *SEC for each processor
 621      dependent case; failure to do so will cause a link error.  */
 622   bfd_boolean (*elf_add_symbol_hook)
 623     (bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *,
 624      const char **name, flagword *flags, asection **sec, bfd_vma *value);
 625
 626   /* If this field is not NULL, it is called by the elf_link_output_sym
 627      phase of a link for each symbol which will appear in the object file.  */
 628   bfd_boolean (*elf_backend_link_output_symbol_hook)
 629     (bfd *, struct bfd_link_info *info, const char *, Elf_Internal_Sym *,
 630      asection *);
 631
 632   /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
 633      linker the first time it encounters a dynamic object in the link.
 634      This function must create any sections required for dynamic
 635      linking.  The ABFD argument is a dynamic object.  The .interp,
 636      .dynamic, .dynsym, .dynstr, and .hash functions have already been
 637      created, and this function may modify the section flags if
 638      desired.  This function will normally create the .got and .plt
 639      sections, but different backends have different requirements.  */
 640   bfd_boolean (*elf_backend_create_dynamic_sections)
 641     (bfd *abfd, struct bfd_link_info *info);
 642
 643   /* The CHECK_RELOCS function is called by the add_symbols phase of
 644      the ELF backend linker.  It is called once for each section with
 645      relocs of an object file, just after the symbols for the object
 646      file have been added to the global linker hash table.  The
 647      function must look through the relocs and do any special handling
 648      required.  This generally means allocating space in the global
 649      offset table, and perhaps allocating space for a reloc.  The
 650      relocs are always passed as Rela structures; if the section
 651      actually uses Rel structures, the r_addend field will always be
 652      zero.  */
 653   bfd_boolean (*check_relocs)
 654     (bfd *abfd, struct bfd_link_info *info, asection *o,
 655      const Elf_Internal_Rela *relocs);
 656
 657   /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
 658      linker for every symbol which is defined by a dynamic object and
 659      referenced by a regular object.  This is called after all the
 660      input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
 661      function has been called.  The hash table entry should be
 662      bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
 663      defined in a section from a dynamic object.  Dynamic object
 664      sections are not included in the final link, and this function is
 665      responsible for changing the value to something which the rest of
 666      the link can deal with.  This will normally involve adding an
 667      entry to the .plt or .got or some such section, and setting the
 668      symbol to point to that.  */
 669   bfd_boolean (*elf_backend_adjust_dynamic_symbol)
 670     (struct bfd_link_info *info, struct elf_link_hash_entry *h);
 671
 672   /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
 673      after all the linker input files have been seen but before the
 674      section sizes have been set.  This is called after
 675      ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS.  */
 676   bfd_boolean (*elf_backend_always_size_sections)
 677     (bfd *output_bfd, struct bfd_link_info *info);
 678
 679   /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
 680      linker after all the linker input files have been seen but before
 681      the sections sizes have been set.  This is called after
 682      ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
 683      It is only called when linking against a dynamic object.  It must
 684      set the sizes of the dynamic sections, and may fill in their
 685      contents as well.  The generic ELF linker can handle the .dynsym,
 686      .dynstr and .hash sections.  This function must handle the
 687      .interp section and any sections created by the
 688      CREATE_DYNAMIC_SECTIONS entry point.  */
 689   bfd_boolean (*elf_backend_size_dynamic_sections)
 690     (bfd *output_bfd, struct bfd_link_info *info);
 691
 692   /* The RELOCATE_SECTION function is called by the ELF backend linker
 693      to handle the relocations for a section.
 694
 695      The relocs are always passed as Rela structures; if the section
 696      actually uses Rel structures, the r_addend field will always be
 697      zero.
 698
 699      This function is responsible for adjust the section contents as
 700      necessary, and (if using Rela relocs and generating a
 701      relocatable output file) adjusting the reloc addend as
 702      necessary.
 703
 704      This function does not have to worry about setting the reloc
 705      address or the reloc symbol index.
 706
 707      LOCAL_SYMS is a pointer to the swapped in local symbols.
 708
 709      LOCAL_SECTIONS is an array giving the section in the input file
 710      corresponding to the st_shndx field of each local symbol.
 711
 712      The global hash table entry for the global symbols can be found
 713      via elf_sym_hashes (input_bfd).
 714
 715      When generating relocatable output, this function must handle
 716      STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 717      going to be the section symbol corresponding to the output
 718      section, which means that the addend must be adjusted
 719      accordingly.  */
 720   bfd_boolean (*elf_backend_relocate_section)
 721     (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
 722      asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs,
 723      Elf_Internal_Sym *local_syms, asection **local_sections);
 724
 725   /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
 726      linker just before it writes a symbol out to the .dynsym section.
 727      The processor backend may make any required adjustment to the
 728      symbol.  It may also take the opportunity to set contents of the
 729      dynamic sections.  Note that FINISH_DYNAMIC_SYMBOL is called on
 730      all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
 731      on those symbols which are defined by a dynamic object.  */
 732   bfd_boolean (*elf_backend_finish_dynamic_symbol)
 733     (bfd *output_bfd, struct bfd_link_info *info,
 734      struct elf_link_hash_entry *h, Elf_Internal_Sym *sym);
 735
 736   /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
 737      linker just before it writes all the dynamic sections out to the
 738      output file.  The FINISH_DYNAMIC_SYMBOL will have been called on
 739      all dynamic symbols.  */
 740   bfd_boolean (*elf_backend_finish_dynamic_sections)
 741     (bfd *output_bfd, struct bfd_link_info *info);
 742
 743   /* A function to do any beginning processing needed for the ELF file
 744      before building the ELF headers and computing file positions.  */
 745   void (*elf_backend_begin_write_processing)
 746     (bfd *, struct bfd_link_info *);
 747
 748   /* A function to do any final processing needed for the ELF file
 749      before writing it out.  The LINKER argument is TRUE if this BFD
 750      was created by the ELF backend linker.  */
 751   void (*elf_backend_final_write_processing)
 752     (bfd *, bfd_boolean linker);
 753
 754   /* This function is called by get_program_header_size.  It should
 755      return the number of additional program segments which this BFD
 756      will need.  It should return -1 on error.  */
 757   int (*elf_backend_additional_program_headers)
 758     (bfd *);
 759
 760   /* This function is called to modify an existing segment map in a
 761      backend specific fashion.  */
 762   bfd_boolean (*elf_backend_modify_segment_map)
 763     (bfd *, struct bfd_link_info *);
 764
 765   /* This function is called during section gc to discover the section a
 766      particular relocation refers to.  */
 767   asection * (*gc_mark_hook)
 768     (asection *sec, struct bfd_link_info *, Elf_Internal_Rela *,
 769      struct elf_link_hash_entry *h, Elf_Internal_Sym *);
 770
 771   /* This function, if defined, is called during the sweep phase of gc
 772      in order that a backend might update any data structures it might
 773      be maintaining.  */
 774   bfd_boolean (*gc_sweep_hook)
 775     (bfd *abfd, struct bfd_link_info *info, asection *o,
 776      const Elf_Internal_Rela *relocs);
 777
 778   /* This function, if defined, is called after the ELF headers have
 779      been created.  This allows for things like the OS and ABI versions
 780      to be changed.  */
 781   void (*elf_backend_post_process_headers)
 782     (bfd *, struct bfd_link_info *);
 783
 784   /* This function, if defined, prints a symbol to file and returns the
 785      name of the symbol to be printed.  It should return NULL to fall
 786      back to default symbol printing.  */
 787   const char *(*elf_backend_print_symbol_all)
 788     (bfd *, void *, asymbol *);
 789
 790   /* This function, if defined, is called after all local symbols and
 791      global symbols converted to locals are emitted into the symtab
 792      section.  It allows the backend to emit special global symbols
 793      not handled in the hash table.  */
 794   bfd_boolean (*elf_backend_output_arch_syms)
 795     (bfd *, struct bfd_link_info *, void *,
 796      bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *));
 797
 798   /* Copy any information related to dynamic linking from a pre-existing
 799      symbol to a newly created symbol.  Also called to copy flags and
 800      other back-end info to a weakdef, in which case the symbol is not
 801      newly created and plt/got refcounts and dynamic indices should not
 802      be copied.  */
 803   void (*elf_backend_copy_indirect_symbol)
 804     (const struct elf_backend_data *, struct elf_link_hash_entry *,
 805      struct elf_link_hash_entry *);
 806
 807   /* Modify any information related to dynamic linking such that the
 808      symbol is not exported.  */
 809   void (*elf_backend_hide_symbol)
 810     (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
 811
 812   /* Merge the backend specific symbol attribute.  */
 813   void (*elf_backend_merge_symbol_attribute)
 814     (struct elf_link_hash_entry *, const Elf_Internal_Sym *, bfd_boolean,
 815      bfd_boolean);
 816
 817   /* Emit relocations.  Overrides default routine for emitting relocs,
 818      except during a relocatable link, or if all relocs are being emitted.  */
 819   bfd_boolean (*elf_backend_emit_relocs)
 820     (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
 821
 822   /* Count relocations.  Not called for relocatable links
 823      or if all relocs are being preserved in the output.  */
 824   unsigned int (*elf_backend_count_relocs)
 825     (asection *, Elf_Internal_Rela *);
 826
 827   /* This function, if defined, is called when an NT_PRSTATUS note is found
 828      in a core file. */
 829   bfd_boolean (*elf_backend_grok_prstatus)
 830     (bfd *, Elf_Internal_Note *);
 831
 832   /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
 833      note is found in a core file. */
 834   bfd_boolean (*elf_backend_grok_psinfo)
 835     (bfd *, Elf_Internal_Note *);
 836
 837   /* Functions to print VMAs.  Special code to handle 64 bit ELF files.  */
 838   void (* elf_backend_sprintf_vma)
 839     (bfd *, char *, bfd_vma);
 840   void (* elf_backend_fprintf_vma)
 841     (bfd *, void *, bfd_vma);
 842
 843   /* This function returns class of a reloc type.  */
 844   enum elf_reloc_type_class (*elf_backend_reloc_type_class)
 845     (const Elf_Internal_Rela *);
 846
 847   /* This function, if defined, removes information about discarded functions
 848      from other sections which mention them.  */
 849   bfd_boolean (*elf_backend_discard_info)
 850     (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *);
 851
 852   /* This function, if defined, signals that the function above has removed
 853      the discarded relocations for this section.  */
 854   bfd_boolean (*elf_backend_ignore_discarded_relocs)
 855     (asection *);
 856
 857   /* This function, if defined, may write out the given section.
 858      Returns TRUE if it did so and FALSE if the caller should.  */
 859   bfd_boolean (*elf_backend_write_section)
 860     (bfd *, asection *, bfd_byte *);
 861
 862   /* The level of IRIX compatibility we're striving for.
 863      MIPS ELF specific function.  */
 864   irix_compat_t (*elf_backend_mips_irix_compat)
 865     (bfd *);
 866
 867   reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
 868     (unsigned int, bfd_boolean);
 869
 870   /* The swapping table to use when dealing with ECOFF information.
 871      Used for the MIPS ELF .mdebug section.  */
 872   const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
 873
 874   /* This function implements `bfd_elf_bfd_from_remote_memory';
 875      see elf.c, elfcode.h.  */
 876   bfd *(*elf_backend_bfd_from_remote_memory)
 877      (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
 878       int (*target_read_memory) (bfd_vma vma, char *myaddr, int len));
 879
 880   /* Alternate EM_xxxx machine codes for this backend.  */
 881   int elf_machine_alt1;
 882   int elf_machine_alt2;
 883
 884   const struct elf_size_info *s;
 885
 886   /* An array of target specific special section map.  */
 887   const struct bfd_elf_special_section *special_sections;
 888
 889   /* offset of the _GLOBAL_OFFSET_TABLE_ symbol from the start of the
 890      .got section */
 891   bfd_vma got_symbol_offset;
 892
 893   /* The size in bytes of the header for the GOT.  This includes the
 894      so-called reserved entries on some systems.  */
 895   bfd_vma got_header_size;
 896
 897   /* This is TRUE if the linker should act like collect and gather
 898      global constructors and destructors by name.  This is TRUE for
 899      MIPS ELF because the Irix 5 tools can not handle the .init
 900      section.  */
 901   unsigned collect : 1;
 902
 903   /* This is TRUE if the linker should ignore changes to the type of a
 904      symbol.  This is TRUE for MIPS ELF because some Irix 5 objects
 905      record undefined functions as STT_OBJECT although the definitions
 906      are STT_FUNC.  */
 907   unsigned type_change_ok : 1;
 908
 909   /* Whether the backend may use REL relocations.  (Some backends use
 910      both REL and RELA relocations, and this flag is set for those
 911      backends.)  */
 912   unsigned may_use_rel_p : 1;
 913
 914   /* Whether the backend may use RELA relocations.  (Some backends use
 915      both REL and RELA relocations, and this flag is set for those
 916      backends.)  */
 917   unsigned may_use_rela_p : 1;
 918
 919   /* Whether the default relocation type is RELA.  If a backend with
 920      this flag set wants REL relocations for a particular section,
 921      it must note that explicitly.  Similarly, if this flag is clear,
 922      and the backend wants RELA relocations for a particular
 923      section.  */
 924   unsigned default_use_rela_p : 1;
 925
 926   /* Set if RELA relocations for a relocatable link can be handled by
 927      generic code.  Backends that set this flag need do nothing in the
 928      backend relocate_section routine for relocatable linking.  */
 929   unsigned rela_normal : 1;
 930
 931   /* TRUE if addresses "naturally" sign extend.  This is used when
 932      swapping in from Elf32 when BFD64.  */
 933   unsigned sign_extend_vma : 1;
 934
 935   unsigned want_got_plt : 1;
 936   unsigned plt_readonly : 1;
 937   unsigned want_plt_sym : 1;
 938   unsigned plt_not_loaded : 1;
 939   unsigned plt_alignment : 4;
 940   unsigned can_gc_sections : 1;
 941   unsigned can_refcount : 1;
 942   unsigned want_got_sym : 1;
 943   unsigned want_dynbss : 1;
 944     /* Targets which do not support physical addressing often require
 945        that the p_paddr field in the section header to be set to zero.
 946        This field indicates whether this behavior is required.  */
 947   unsigned want_p_paddr_set_to_zero : 1;
 948 };
 949
 950 /* Information stored for each BFD section in an ELF file.  This
 951    structure is allocated by elf_new_section_hook.  */
 952
 953 struct bfd_elf_section_data
 954 {
 955   /* The ELF header for this section.  */
 956   Elf_Internal_Shdr this_hdr;
 957
 958   /* The ELF header for the reloc section associated with this
 959      section, if any.  */
 960   Elf_Internal_Shdr rel_hdr;
 961
 962   /* If there is a second reloc section associated with this section,
 963      as can happen on Irix 6, this field points to the header.  */
 964   Elf_Internal_Shdr *rel_hdr2;
 965
 966   /* The number of relocations currently assigned to REL_HDR.  */
 967   unsigned int rel_count;
 968
 969   /* The number of relocations currently assigned to REL_HDR2.  */
 970   unsigned int rel_count2;
 971
 972   /* The ELF section number of this section.  Only used for an output
 973      file.  */
 974   int this_idx;
 975
 976   /* The ELF section number of the reloc section indicated by
 977      REL_HDR if any.  Only used for an output file.  */
 978   int rel_idx;
 979
 980   /* The ELF section number of the reloc section indicated by
 981      REL_HDR2 if any.  Only used for an output file.  */
 982   int rel_idx2;
 983
 984   /* Used by the backend linker when generating a shared library to
 985      record the dynamic symbol index for a section symbol
 986      corresponding to this section.  A value of 0 means that there is
 987      no dynamic symbol for this section.  */
 988   int dynindx;
 989
 990   /* Used by the backend linker to store the symbol hash table entries
 991      associated with relocs against global symbols.  */
 992   struct elf_link_hash_entry **rel_hashes;
 993
 994   /* A pointer to the swapped relocs.  If the section uses REL relocs,
 995      rather than RELA, all the r_addend fields will be zero.  This
 996      pointer may be NULL.  It is used by the backend linker.  */
 997   Elf_Internal_Rela *relocs;
 998
 999   /* A pointer to a linked list tracking dynamic relocs copied for
1000      local symbols.  */
1001   void *local_dynrel;
1002
1003   /* A pointer to the bfd section used for dynamic relocs.  */
1004   asection *sreloc;
1005
1006   union {
1007     /* Group name, if this section is a member of a group.  */
1008     const char *name;
1009
1010     /* Group signature sym, if this is the SHT_GROUP section.  */
1011     struct bfd_symbol *id;
1012   } group;
1013
1014   /* A linked list of sections in the group.  Circular when used by
1015      the linker.  */
1016   asection *next_in_group;
1017
1018   /* A pointer used for various section optimizations.  */
1019   void *sec_info;
1020 };
1021
1022 #define elf_section_data(sec)  ((struct bfd_elf_section_data*)sec->used_by_bfd)
1023 #define elf_section_type(sec)  (elf_section_data(sec)->this_hdr.sh_type)
1024 #define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags)
1025 #define elf_group_name(sec)    (elf_section_data(sec)->group.name)
1026 #define elf_group_id(sec)      (elf_section_data(sec)->group.id)
1027 #define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
1028
1029 /* Return TRUE if section has been discarded.  */
1030 #define elf_discarded_section(sec)                              \
1031   (!bfd_is_abs_section (sec)                                    \
1032    && bfd_is_abs_section ((sec)->output_section)                \
1033    && sec->sec_info_type != ELF_INFO_TYPE_MERGE                 \
1034    && sec->sec_info_type != ELF_INFO_TYPE_JUST_SYMS)
1035
1036 #define get_elf_backend_data(abfd) \
1037   ((const struct elf_backend_data *) (abfd)->xvec->backend_data)
1038
1039 /* This struct is used to pass information to routines called via
1040    elf_link_hash_traverse which must return failure.  */
1041
1042 struct elf_info_failed
1043 {
1044   bfd_boolean failed;
1045   struct bfd_link_info *info;
1046   struct bfd_elf_version_tree *verdefs;
1047 };
1048
1049 /* This structure is used to pass information to
1050    _bfd_elf_link_assign_sym_version.  */
1051
1052 struct elf_assign_sym_version_info
1053 {
1054   /* Output BFD.  */
1055   bfd *output_bfd;
1056   /* General link information.  */
1057   struct bfd_link_info *info;
1058   /* Version tree.  */
1059   struct bfd_elf_version_tree *verdefs;
1060   /* Whether we had a failure.  */
1061   bfd_boolean failed;
1062 };
1063
1064 /* This structure is used to pass information to
1065    _bfd_elf_link_find_version_dependencies.  */
1066
1067 struct elf_find_verdep_info
1068 {
1069   /* Output BFD.  */
1070   bfd *output_bfd;
1071   /* General link information.  */
1072   struct bfd_link_info *info;
1073   /* The number of dependencies.  */
1074   unsigned int vers;
1075   /* Whether we had a failure.  */
1076   bfd_boolean failed;
1077 };
1078
1079 /* Some private data is stashed away for future use using the tdata pointer
1080    in the bfd structure.  */
1081
1082 struct elf_obj_tdata
1083 {
1084   Elf_Internal_Ehdr elf_header[1];      /* Actual data, but ref like ptr */
1085   Elf_Internal_Shdr **elf_sect_ptr;
1086   Elf_Internal_Phdr *phdr;
1087   struct elf_segment_map *segment_map;
1088   struct elf_strtab_hash *strtab_ptr;
1089   int num_locals;
1090   int num_globals;
1091   unsigned int num_elf_sections;        /* elf_sect_ptr size */
1092   int num_section_syms;
1093   asymbol **section_syms;               /* STT_SECTION symbols for each section */
1094   Elf_Internal_Shdr symtab_hdr;
1095   Elf_Internal_Shdr shstrtab_hdr;
1096   Elf_Internal_Shdr strtab_hdr;
1097   Elf_Internal_Shdr dynsymtab_hdr;
1098   Elf_Internal_Shdr dynstrtab_hdr;
1099   Elf_Internal_Shdr dynversym_hdr;
1100   Elf_Internal_Shdr dynverref_hdr;
1101   Elf_Internal_Shdr dynverdef_hdr;
1102   Elf_Internal_Shdr symtab_shndx_hdr;
1103   unsigned int symtab_section, shstrtab_section;
1104   unsigned int strtab_section, dynsymtab_section;
1105   unsigned int symtab_shndx_section;
1106   unsigned int dynversym_section, dynverdef_section, dynverref_section;
1107   file_ptr next_file_pos;
1108   bfd_vma gp;                           /* The gp value */
1109   unsigned int gp_size;                 /* The gp size */
1110
1111   Elf_Internal_Shdr **group_sect_ptr;
1112   int num_group;
1113
1114   /* Information grabbed from an elf core file.  */
1115   int core_signal;
1116   int core_pid;
1117   int core_lwpid;
1118   char* core_program;
1119   char* core_command;
1120
1121   /* This is set to TRUE if the object was created by the backend
1122      linker.  */
1123   bfd_boolean linker;
1124
1125   /* A mapping from external symbols to entries in the linker hash
1126      table, used when linking.  This is indexed by the symbol index
1127      minus the sh_info field of the symbol table header.  */
1128   struct elf_link_hash_entry **sym_hashes;
1129
1130   /* Track usage and final offsets of GOT entries for local symbols.
1131      This array is indexed by symbol index.  Elements are used
1132      identically to "got" in struct elf_link_hash_entry.  */
1133   union
1134     {
1135       bfd_signed_vma *refcounts;
1136       bfd_vma *offsets;
1137       struct got_entry **ents;
1138     } local_got;
1139
1140   /* The linker ELF emulation code needs to let the backend ELF linker
1141      know what filename should be used for a dynamic object if the
1142      dynamic object is found using a search.  The emulation code then
1143      sometimes needs to know what name was actually used.  Until the
1144      file has been added to the linker symbol table, this field holds
1145      the name the linker wants.  After it has been added, it holds the
1146      name actually used, which will be the DT_SONAME entry if there is
1147      one.  */
1148   const char *dt_name;
1149
1150   /* When a reference in a regular object is resolved by a shared
1151      object is loaded into via the DT_NEEDED entries by the linker
1152      ELF emulation code, we need to add the shared object to the
1153      DT_NEEDED list of the resulting binary to indicate the dependency
1154      as if the -l option is passed to the linker. This field holds the
1155      name of the loaded shared object.  */
1156   const char *dt_soname;
1157
1158   /* Irix 5 often screws up the symbol table, sorting local symbols
1159      after global symbols.  This flag is set if the symbol table in
1160      this BFD appears to be screwed up.  If it is, we ignore the
1161      sh_info field in the symbol table header, and always read all the
1162      symbols.  */
1163   bfd_boolean bad_symtab;
1164
1165   /* Records the result of `get_program_header_size'.  */
1166   bfd_size_type program_header_size;
1167
1168   /* Used by find_nearest_line entry point.  */
1169   void *line_info;
1170
1171   /* Used by MIPS ELF find_nearest_line entry point.  The structure
1172      could be included directly in this one, but there's no point to
1173      wasting the memory just for the infrequently called
1174      find_nearest_line.  */
1175   struct mips_elf_find_line *find_line_info;
1176
1177   /* A place to stash dwarf1 info for this bfd.  */
1178   struct dwarf1_debug *dwarf1_find_line_info;
1179
1180   /* A place to stash dwarf2 info for this bfd.  */
1181   void *dwarf2_find_line_info;
1182
1183   /* An array of stub sections indexed by symbol number, used by the
1184      MIPS ELF linker.  FIXME: We should figure out some way to only
1185      include this field for a MIPS ELF target.  */
1186   asection **local_stubs;
1187
1188   /* Used to determine if PT_GNU_EH_FRAME segment header should be
1189      created.  */
1190   asection *eh_frame_hdr;
1191
1192   /* Used to determine if the e_flags field has been initialized */
1193   bfd_boolean flags_init;
1194
1195   /* Number of symbol version definitions we are about to emit.  */
1196   unsigned int cverdefs;
1197
1198   /* Number of symbol version references we are about to emit.  */
1199   unsigned int cverrefs;
1200
1201   /* Segment flags for the PT_GNU_STACK segment.  */
1202   unsigned int stack_flags;
1203
1204   /* Symbol version definitions in external objects.  */
1205   Elf_Internal_Verdef *verdef;
1206
1207   /* Symbol version references to external objects.  */
1208   Elf_Internal_Verneed *verref;
1209
1210   /* The Irix 5 support uses two virtual sections, which represent
1211      text/data symbols defined in dynamic objects.  */
1212   asymbol *elf_data_symbol;
1213   asymbol *elf_text_symbol;
1214   asection *elf_data_section;
1215   asection *elf_text_section;
1216 };
1217
1218 #define elf_tdata(bfd)          ((bfd) -> tdata.elf_obj_data)
1219 #define elf_elfheader(bfd)      (elf_tdata(bfd) -> elf_header)
1220 #define elf_elfsections(bfd)    (elf_tdata(bfd) -> elf_sect_ptr)
1221 #define elf_numsections(bfd)    (elf_tdata(bfd) -> num_elf_sections)
1222 #define elf_shstrtab(bfd)       (elf_tdata(bfd) -> strtab_ptr)
1223 #define elf_onesymtab(bfd)      (elf_tdata(bfd) -> symtab_section)
1224 #define elf_symtab_shndx(bfd)   (elf_tdata(bfd) -> symtab_shndx_section)
1225 #define elf_dynsymtab(bfd)      (elf_tdata(bfd) -> dynsymtab_section)
1226 #define elf_dynversym(bfd)      (elf_tdata(bfd) -> dynversym_section)
1227 #define elf_dynverdef(bfd)      (elf_tdata(bfd) -> dynverdef_section)
1228 #define elf_dynverref(bfd)      (elf_tdata(bfd) -> dynverref_section)
1229 #define elf_num_locals(bfd)     (elf_tdata(bfd) -> num_locals)
1230 #define elf_num_globals(bfd)    (elf_tdata(bfd) -> num_globals)
1231 #define elf_section_syms(bfd)   (elf_tdata(bfd) -> section_syms)
1232 #define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms)
1233 #define core_prpsinfo(bfd)      (elf_tdata(bfd) -> prpsinfo)
1234 #define core_prstatus(bfd)      (elf_tdata(bfd) -> prstatus)
1235 #define elf_gp(bfd)             (elf_tdata(bfd) -> gp)
1236 #define elf_gp_size(bfd)        (elf_tdata(bfd) -> gp_size)
1237 #define elf_sym_hashes(bfd)     (elf_tdata(bfd) -> sym_hashes)
1238 #define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
1239 #define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
1240 #define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
1241 #define elf_dt_name(bfd)        (elf_tdata(bfd) -> dt_name)
1242 #define elf_dt_soname(bfd)      (elf_tdata(bfd) -> dt_soname)
1243 #define elf_bad_symtab(bfd)     (elf_tdata(bfd) -> bad_symtab)
1244 #define elf_flags_init(bfd)     (elf_tdata(bfd) -> flags_init)
1245 \f
1246 extern void _bfd_elf_swap_verdef_in
1247   (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *);
1248 extern void _bfd_elf_swap_verdef_out
1249   (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *);
1250 extern void _bfd_elf_swap_verdaux_in
1251   (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *);
1252 extern void _bfd_elf_swap_verdaux_out
1253   (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *);
1254 extern void _bfd_elf_swap_verneed_in
1255   (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *);
1256 extern void _bfd_elf_swap_verneed_out
1257   (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *);
1258 extern void _bfd_elf_swap_vernaux_in
1259   (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *);
1260 extern void _bfd_elf_swap_vernaux_out
1261   (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *);
1262 extern void _bfd_elf_swap_versym_in
1263   (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *);
1264 extern void _bfd_elf_swap_versym_out
1265   (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *);
1266
1267 extern int _bfd_elf_section_from_bfd_section
1268   (bfd *, asection *);
1269 extern char *bfd_elf_string_from_elf_section
1270   (bfd *, unsigned, unsigned);
1271 extern char *bfd_elf_get_str_section
1272   (bfd *, unsigned);
1273 extern Elf_Internal_Sym *bfd_elf_get_elf_syms
1274   (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *,
1275    Elf_External_Sym_Shndx *);
1276 extern const char *bfd_elf_local_sym_name
1277   (bfd *, Elf_Internal_Sym *);
1278
1279 extern bfd_boolean _bfd_elf_copy_private_bfd_data
1280   (bfd *, bfd *);
1281 extern bfd_boolean _bfd_elf_print_private_bfd_data
1282   (bfd *, void *);
1283 extern void bfd_elf_print_symbol
1284   (bfd *, void *, asymbol *, bfd_print_symbol_type);
1285
1286 #define elf_string_from_elf_strtab(abfd, strindex) \
1287   bfd_elf_string_from_elf_section (abfd, elf_elfheader(abfd)->e_shstrndx, \
1288                                    strindex)
1289
1290 #define bfd_elf32_print_symbol  bfd_elf_print_symbol
1291 #define bfd_elf64_print_symbol  bfd_elf_print_symbol
1292
1293 extern void _bfd_elf_sprintf_vma
1294   (bfd *, char *, bfd_vma);
1295 extern void _bfd_elf_fprintf_vma
1296   (bfd *, void *, bfd_vma);
1297
1298 extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
1299   (const Elf_Internal_Rela *);
1300 extern bfd_vma _bfd_elf_rela_local_sym
1301   (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *);
1302 extern bfd_vma _bfd_elf_rel_local_sym
1303   (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
1304 extern bfd_vma _bfd_elf_section_offset
1305   (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1306
1307 extern unsigned long bfd_elf_hash
1308   (const char *);
1309
1310 extern bfd_reloc_status_type bfd_elf_generic_reloc
1311   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
1312 extern bfd_boolean bfd_elf_mkobject
1313   (bfd *);
1314 extern bfd_boolean bfd_elf_mkcorefile
1315   (bfd *);
1316 extern Elf_Internal_Shdr *bfd_elf_find_section
1317   (bfd *, char *);
1318 extern bfd_boolean _bfd_elf_make_section_from_shdr
1319   (bfd *, Elf_Internal_Shdr *, const char *);
1320 extern bfd_boolean _bfd_elf_make_section_from_phdr
1321   (bfd *, Elf_Internal_Phdr *, int, const char *);
1322 extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
1323   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
1324 extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
1325   (bfd *);
1326 extern void _bfd_elf_link_hash_copy_indirect
1327   (const struct elf_backend_data *, struct elf_link_hash_entry *,
1328    struct elf_link_hash_entry *);
1329 extern void _bfd_elf_link_hash_hide_symbol
1330   (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
1331 extern bfd_boolean _bfd_elf_link_hash_table_init
1332   (struct elf_link_hash_table *, bfd *,
1333    struct bfd_hash_entry *(*)
1334      (struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
1335 extern bfd_boolean _bfd_elf_slurp_version_tables
1336   (bfd *);
1337 extern bfd_boolean _bfd_elf_merge_sections
1338   (bfd *, struct bfd_link_info *);
1339 extern bfd_boolean bfd_elf_discard_group
1340   (bfd *, struct bfd_section *);
1341 extern void bfd_elf_set_group_contents
1342   (bfd *, asection *, void *);
1343 extern void _bfd_elf_link_just_syms
1344   (asection *, struct bfd_link_info *);
1345 extern bfd_boolean _bfd_elf_copy_private_symbol_data
1346   (bfd *, asymbol *, bfd *, asymbol *);
1347 extern bfd_boolean _bfd_elf_copy_private_section_data
1348   (bfd *, asection *, bfd *, asection *);
1349 extern bfd_boolean _bfd_elf_write_object_contents
1350   (bfd *);
1351 extern bfd_boolean _bfd_elf_write_corefile_contents
1352   (bfd *);
1353 extern bfd_boolean _bfd_elf_set_section_contents
1354   (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);
1355 extern long _bfd_elf_get_symtab_upper_bound
1356   (bfd *);
1357 extern long _bfd_elf_canonicalize_symtab
1358   (bfd *, asymbol **);
1359 extern long _bfd_elf_get_dynamic_symtab_upper_bound
1360   (bfd *);
1361 extern long _bfd_elf_canonicalize_dynamic_symtab
1362   (bfd *, asymbol **);
1363 extern long _bfd_elf_get_reloc_upper_bound
1364   (bfd *, sec_ptr);
1365 extern long _bfd_elf_canonicalize_reloc
1366   (bfd *, sec_ptr, arelent **, asymbol **);
1367 extern long _bfd_elf_get_dynamic_reloc_upper_bound
1368   (bfd *);
1369 extern long _bfd_elf_canonicalize_dynamic_reloc
1370   (bfd *, arelent **, asymbol **);
1371 extern asymbol *_bfd_elf_make_empty_symbol
1372   (bfd *);
1373 extern void _bfd_elf_get_symbol_info
1374   (bfd *, asymbol *, symbol_info *);
1375 extern bfd_boolean _bfd_elf_is_local_label_name
1376   (bfd *, const char *);
1377 extern alent *_bfd_elf_get_lineno
1378   (bfd *, asymbol *);
1379 extern bfd_boolean _bfd_elf_set_arch_mach
1380   (bfd *, enum bfd_architecture, unsigned long);
1381 extern bfd_boolean _bfd_elf_find_nearest_line
1382   (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **,
1383    unsigned int *);
1384 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
1385 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1386 extern int _bfd_elf_sizeof_headers
1387   (bfd *, bfd_boolean);
1388 extern bfd_boolean _bfd_elf_new_section_hook
1389   (bfd *, asection *);
1390 extern bfd_boolean _bfd_elf_init_reloc_shdr
1391   (bfd *, Elf_Internal_Shdr *, asection *, bfd_boolean);
1392 extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr
1393   (bfd *, const char *);
1394
1395 /* If the target doesn't have reloc handling written yet:  */
1396 extern void _bfd_elf_no_info_to_howto
1397   (bfd *, arelent *, Elf_Internal_Rela *);
1398
1399 extern bfd_boolean bfd_section_from_shdr
1400   (bfd *, unsigned int shindex);
1401 extern bfd_boolean bfd_section_from_phdr
1402   (bfd *, Elf_Internal_Phdr *, int);
1403
1404 extern int _bfd_elf_symbol_from_bfd_symbol
1405   (bfd *, asymbol **);
1406
1407 extern asection *bfd_section_from_r_symndx
1408   (bfd *, struct sym_sec_cache *, asection *, unsigned long);
1409 extern asection *bfd_section_from_elf_index
1410   (bfd *, unsigned int);
1411 extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
1412   (void);
1413
1414 extern struct elf_strtab_hash * _bfd_elf_strtab_init
1415   (void);
1416 extern void _bfd_elf_strtab_free
1417   (struct elf_strtab_hash *);
1418 extern bfd_size_type _bfd_elf_strtab_add
1419   (struct elf_strtab_hash *, const char *, bfd_boolean);
1420 extern void _bfd_elf_strtab_addref
1421   (struct elf_strtab_hash *, bfd_size_type);
1422 extern void _bfd_elf_strtab_delref
1423   (struct elf_strtab_hash *, bfd_size_type);
1424 extern void _bfd_elf_strtab_clear_all_refs
1425   (struct elf_strtab_hash *);
1426 extern bfd_size_type _bfd_elf_strtab_size
1427   (struct elf_strtab_hash *);
1428 extern bfd_size_type _bfd_elf_strtab_offset
1429   (struct elf_strtab_hash *, bfd_size_type);
1430 extern bfd_boolean _bfd_elf_strtab_emit
1431   (bfd *, struct elf_strtab_hash *);
1432 extern void _bfd_elf_strtab_finalize
1433   (struct elf_strtab_hash *);
1434
1435 extern bfd_boolean _bfd_elf_discard_section_eh_frame
1436   (bfd *, struct bfd_link_info *, asection *,
1437    bfd_boolean (*) (bfd_vma, void *), struct elf_reloc_cookie *);
1438 extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
1439   (bfd *, struct bfd_link_info *);
1440 extern bfd_vma _bfd_elf_eh_frame_section_offset
1441   (bfd *, asection *, bfd_vma);
1442 extern bfd_boolean _bfd_elf_write_section_eh_frame
1443   (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1444 extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
1445   (bfd *, struct bfd_link_info *);
1446 extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
1447   (struct bfd_link_info *);
1448
1449 extern bfd_boolean _bfd_elf_merge_symbol
1450   (bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
1451    asection **, bfd_vma *, struct elf_link_hash_entry **, bfd_boolean *,
1452    bfd_boolean *, bfd_boolean *, bfd_boolean *, bfd_boolean);
1453
1454 extern bfd_boolean _bfd_elf_add_default_symbol
1455   (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
1456    const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
1457    bfd_boolean *, bfd_boolean, bfd_boolean);
1458
1459 extern bfd_boolean _bfd_elf_export_symbol
1460   (struct elf_link_hash_entry *, void *);
1461
1462 extern bfd_boolean _bfd_elf_link_find_version_dependencies
1463   (struct elf_link_hash_entry *, void *);
1464
1465 extern bfd_boolean _bfd_elf_link_assign_sym_version
1466   (struct elf_link_hash_entry *, void *);
1467
1468 extern bfd_boolean _bfd_elf_link_record_dynamic_symbol
1469   (struct bfd_link_info *, struct elf_link_hash_entry *);
1470 extern long _bfd_elf_link_lookup_local_dynindx
1471   (struct bfd_link_info *, bfd *, long);
1472 extern bfd_boolean _bfd_elf_compute_section_file_positions
1473   (bfd *, struct bfd_link_info *);
1474 extern void _bfd_elf_assign_file_positions_for_relocs
1475   (bfd *);
1476 extern file_ptr _bfd_elf_assign_file_position_for_section
1477   (Elf_Internal_Shdr *, file_ptr, bfd_boolean);
1478
1479 extern bfd_boolean _bfd_elf_validate_reloc
1480   (bfd *, arelent *);
1481
1482 extern bfd_boolean _bfd_elf_link_create_dynamic_sections
1483   (bfd *, struct bfd_link_info *);
1484 extern bfd_boolean _bfd_elf_create_dynamic_sections
1485   (bfd *, struct bfd_link_info *);
1486 extern bfd_boolean _bfd_elf_create_got_section
1487   (bfd *, struct bfd_link_info *);
1488 extern unsigned long _bfd_elf_link_renumber_dynsyms
1489   (bfd *, struct bfd_link_info *);
1490
1491 extern bfd_boolean _bfd_elfcore_make_pseudosection
1492   (bfd *, char *, size_t, ufile_ptr);
1493 extern char *_bfd_elfcore_strndup
1494   (bfd *, char *, size_t);
1495
1496 extern Elf_Internal_Rela *_bfd_elf_link_read_relocs
1497   (bfd *, asection *, void *, Elf_Internal_Rela *, bfd_boolean);
1498
1499 extern bfd_boolean _bfd_elf_link_size_reloc_section
1500   (bfd *, Elf_Internal_Shdr *, asection *);
1501
1502 extern bfd_boolean _bfd_elf_link_output_relocs
1503   (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
1504
1505 extern bfd_boolean _bfd_elf_fix_symbol_flags
1506   (struct elf_link_hash_entry *, struct elf_info_failed *);
1507
1508 extern bfd_boolean _bfd_elf_adjust_dynamic_symbol
1509   (struct elf_link_hash_entry *, void *);
1510
1511 extern bfd_boolean _bfd_elf_link_sec_merge_syms
1512   (struct elf_link_hash_entry *, void *);
1513
1514 extern bfd_boolean _bfd_elf_dynamic_symbol_p
1515   (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1516
1517 extern bfd_boolean _bfd_elf_symbol_refs_local_p
1518   (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1519
1520 extern const bfd_target *bfd_elf32_object_p
1521   (bfd *);
1522 extern const bfd_target *bfd_elf32_core_file_p
1523   (bfd *);
1524 extern char *bfd_elf32_core_file_failing_command
1525   (bfd *);
1526 extern int bfd_elf32_core_file_failing_signal
1527   (bfd *);
1528 extern bfd_boolean bfd_elf32_core_file_matches_executable_p
1529   (bfd *, bfd *);
1530
1531 extern bfd_boolean bfd_elf32_bfd_link_add_symbols
1532   (bfd *, struct bfd_link_info *);
1533 extern bfd_boolean bfd_elf32_bfd_final_link
1534   (bfd *, struct bfd_link_info *);
1535
1536 extern void bfd_elf32_swap_symbol_in
1537   (bfd *, const void *, const void *, Elf_Internal_Sym *);
1538 extern void bfd_elf32_swap_symbol_out
1539   (bfd *, const Elf_Internal_Sym *, void *, void *);
1540 extern void bfd_elf32_swap_reloc_in
1541   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1542 extern void bfd_elf32_swap_reloc_out
1543   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1544 extern void bfd_elf32_swap_reloca_in
1545   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1546 extern void bfd_elf32_swap_reloca_out
1547   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1548 extern void bfd_elf32_swap_phdr_in
1549   (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *);
1550 extern void bfd_elf32_swap_phdr_out
1551   (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *);
1552 extern void bfd_elf32_swap_dyn_in
1553   (bfd *, const void *, Elf_Internal_Dyn *);
1554 extern void bfd_elf32_swap_dyn_out
1555   (bfd *, const Elf_Internal_Dyn *, void *);
1556 extern long bfd_elf32_slurp_symbol_table
1557   (bfd *, asymbol **, bfd_boolean);
1558 extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
1559   (bfd *);
1560 extern int bfd_elf32_write_out_phdrs
1561   (bfd *, const Elf_Internal_Phdr *, unsigned int);
1562 extern void bfd_elf32_write_relocs
1563   (bfd *, asection *, void *);
1564 extern bfd_boolean bfd_elf32_slurp_reloc_table
1565   (bfd *, asection *, asymbol **, bfd_boolean);
1566 extern bfd_boolean bfd_elf32_add_dynamic_entry
1567   (struct bfd_link_info *, bfd_vma, bfd_vma);
1568
1569 extern const bfd_target *bfd_elf64_object_p
1570   (bfd *);
1571 extern const bfd_target *bfd_elf64_core_file_p
1572   (bfd *);
1573 extern char *bfd_elf64_core_file_failing_command
1574   (bfd *);
1575 extern int bfd_elf64_core_file_failing_signal
1576   (bfd *);
1577 extern bfd_boolean bfd_elf64_core_file_matches_executable_p
1578   (bfd *, bfd *);
1579 extern bfd_boolean bfd_elf64_bfd_link_add_symbols
1580   (bfd *, struct bfd_link_info *);
1581 extern bfd_boolean bfd_elf64_bfd_final_link
1582   (bfd *, struct bfd_link_info *);
1583
1584 extern void bfd_elf64_swap_symbol_in
1585   (bfd *, const void *, const void *, Elf_Internal_Sym *);
1586 extern void bfd_elf64_swap_symbol_out
1587   (bfd *, const Elf_Internal_Sym *, void *, void *);
1588 extern void bfd_elf64_swap_reloc_in
1589   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1590 extern void bfd_elf64_swap_reloc_out
1591   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1592 extern void bfd_elf64_swap_reloca_in
1593   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1594 extern void bfd_elf64_swap_reloca_out
1595   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1596 extern void bfd_elf64_swap_phdr_in
1597   (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *);
1598 extern void bfd_elf64_swap_phdr_out
1599   (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *);
1600 extern void bfd_elf64_swap_dyn_in
1601   (bfd *, const void *, Elf_Internal_Dyn *);
1602 extern void bfd_elf64_swap_dyn_out
1603   (bfd *, const Elf_Internal_Dyn *, void *);
1604 extern long bfd_elf64_slurp_symbol_table
1605   (bfd *, asymbol **, bfd_boolean);
1606 extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
1607   (bfd *);
1608 extern int bfd_elf64_write_out_phdrs
1609   (bfd *, const Elf_Internal_Phdr *, unsigned int);
1610 extern void bfd_elf64_write_relocs
1611   (bfd *, asection *, void *);
1612 extern bfd_boolean bfd_elf64_slurp_reloc_table
1613   (bfd *, asection *, asymbol **, bfd_boolean);
1614 extern bfd_boolean bfd_elf64_add_dynamic_entry
1615   (struct bfd_link_info *, bfd_vma, bfd_vma);
1616
1617 #define bfd_elf32_link_record_dynamic_symbol \
1618   _bfd_elf_link_record_dynamic_symbol
1619 #define bfd_elf64_link_record_dynamic_symbol \
1620   _bfd_elf_link_record_dynamic_symbol
1621
1622 extern int elf_link_record_local_dynamic_symbol
1623   (struct bfd_link_info *, bfd *, long);
1624 #define _bfd_elf32_link_record_local_dynamic_symbol \
1625   elf_link_record_local_dynamic_symbol
1626 #define _bfd_elf64_link_record_local_dynamic_symbol \
1627   elf_link_record_local_dynamic_symbol
1628
1629 extern bfd_boolean _bfd_elf_close_and_cleanup
1630   (bfd *);
1631 extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
1632   (bfd *, arelent *, struct bfd_symbol *, void *,
1633    asection *, bfd *, char **);
1634
1635 extern bfd_boolean _bfd_elf32_gc_sections
1636   (bfd *, struct bfd_link_info *);
1637 extern bfd_boolean _bfd_elf32_gc_common_finalize_got_offsets
1638   (bfd *, struct bfd_link_info *);
1639 extern bfd_boolean _bfd_elf32_gc_common_final_link
1640   (bfd *, struct bfd_link_info *);
1641 extern bfd_boolean _bfd_elf32_gc_record_vtinherit
1642   (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1643 extern bfd_boolean _bfd_elf32_gc_record_vtentry
1644   (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1645
1646 extern bfd_boolean _bfd_elf64_gc_sections
1647   (bfd *, struct bfd_link_info *);
1648 extern bfd_boolean _bfd_elf64_gc_common_finalize_got_offsets
1649   (bfd *, struct bfd_link_info *);
1650 extern bfd_boolean _bfd_elf64_gc_common_final_link
1651   (bfd *, struct bfd_link_info *);
1652 extern bfd_boolean _bfd_elf64_gc_record_vtinherit
1653   (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1654 extern bfd_boolean _bfd_elf64_gc_record_vtentry
1655   (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
1656
1657 extern bfd_boolean _bfd_elf32_reloc_symbol_deleted_p
1658   (bfd_vma, void *);
1659 extern bfd_boolean _bfd_elf64_reloc_symbol_deleted_p
1660   (bfd_vma, void *);
1661
1662 /* Exported interface for writing elf corefile notes. */
1663 extern char *elfcore_write_note
1664   (bfd *, char *, int *, const char *, int, const void *, int);
1665 extern char *elfcore_write_prpsinfo
1666   (bfd *, char *, int *, const char *, const char *);
1667 extern char *elfcore_write_prstatus
1668   (bfd *, char *, int *, long, int, const void *);
1669 extern char * elfcore_write_pstatus
1670   (bfd *, char *, int *, long, int, const void *);
1671 extern char *elfcore_write_prfpreg
1672   (bfd *, char *, int *, const void *, int);
1673 extern char *elfcore_write_prxfpreg
1674   (bfd *, char *, int *, const void *, int);
1675 extern char *elfcore_write_lwpstatus
1676   (bfd *, char *, int *, long, int, const void *);
1677
1678 extern bfd *_bfd_elf32_bfd_from_remote_memory
1679   (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1680    int (*target_read_memory) (bfd_vma, char *, int));
1681 extern bfd *_bfd_elf64_bfd_from_remote_memory
1682   (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1683    int (*target_read_memory) (bfd_vma, char *, int));
1684
1685 /* SH ELF specific routine.  */
1686
1687 extern bfd_boolean _sh_elf_set_mach_from_flags
1688   (bfd *);
1689
1690 /* This macro is to avoid lots of duplicated code in the body
1691    of xxx_relocate_section() in the various elfxx-xxxx.c files.  */
1692 #define RELOC_FOR_GLOBAL_SYMBOL(h, sym_hashes, r_symndx, symtab_hdr, relocation, sec, unresolved_reloc, info, warned)   \
1693   do                                                                                                                    \
1694     {                                                                                                                   \
1695       /* It seems this can happen with erroneous or unsupported                                                         \
1696          input (mixing a.out and elf in an archive, for example.)  */                                                   \
1697       if (sym_hashes == NULL)                                                                                           \
1698         return FALSE;                                                                                                   \
1699                                                                                                                         \
1700       h = sym_hashes[r_symndx - symtab_hdr->sh_info];                                                                   \
1701                                                                                                                         \
1702       while (h->root.type == bfd_link_hash_indirect                                                                     \
1703              || h->root.type == bfd_link_hash_warning)                                                                  \
1704         h = (struct elf_link_hash_entry *) h->root.u.i.link;                                                            \
1705                                                                                                                         \
1706       warned = FALSE;                                                                                                   \
1707       unresolved_reloc = FALSE;                                                                                         \
1708       relocation = 0;                                                                                                   \
1709       if (h->root.type == bfd_link_hash_defined                                                                         \
1710           || h->root.type == bfd_link_hash_defweak)                                                                     \
1711         {                                                                                                               \
1712           sec = h->root.u.def.section;                                                                                  \
1713           if (sec == NULL                                                                                               \
1714               || sec->output_section == NULL)                                                                           \
1715             /* Set a flag that will be cleared later if we find a                                                       \
1716                relocation value for this symbol.  output_section                                                        \
1717                is typically NULL for symbols satisfied by a shared                                                      \
1718                library.  */                                                                                             \
1719             unresolved_reloc = TRUE;                                                                                    \
1720           else                                                                                                          \
1721             relocation = (h->root.u.def.value                                                                           \
1722                           + sec->output_section->vma                                                                    \
1723                           + sec->output_offset);                                                                        \
1724         }                                                                                                               \
1725       else if (h->root.type == bfd_link_hash_undefweak)                                                                 \
1726         ;                                                                                                               \
1727       else if (!info->executable                                                                                        \
1728                && info->unresolved_syms_in_objects == RM_IGNORE                                                         \
1729                && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)                                                          \
1730         ;                                                                                                               \
1731       else                                                                                                              \
1732         {                                                                                                               \
1733           if (! info->callbacks->undefined_symbol                                                                       \
1734               (info, h->root.root.string, input_bfd,                                                                    \
1735                input_section, rel->r_offset,                                                                            \
1736                ((info->shared && info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)                             \
1737                 || (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR)                             \
1738                 || ELF_ST_VISIBILITY (h->other))                                                                        \
1739                ))                                                                                                       \
1740             return FALSE;                                                                                               \
1741           warned = TRUE;                                                                                                \
1742         }                                                                                                               \
1743     }                                                                                                                   \
1744   while (0)
1745
1746 #endif /* _LIBELF_H_ */