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, 2004, 2005, 2006, 2007 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #ifndef _LIBELF_H_
  24 #define _LIBELF_H_ 1
  25
  26 #include "elf/common.h"
  27 #include "elf/internal.h"
  28 #include "elf/external.h"
  29 #include "bfdlink.h"
  30
  31 /* The number of entries in a section is its size divided by the size
  32    of a single entry.  This is normally only applicable to reloc and
  33    symbol table sections.  */
  34 #define NUM_SHDR_ENTRIES(shdr) ((shdr)->sh_size / (shdr)->sh_entsize)
  35
  36 /* If size isn't specified as 64 or 32, NAME macro should fail.  */
  37 #ifndef NAME
  38 #if ARCH_SIZE == 64
  39 #define NAME(x, y) x ## 64 ## _ ## y
  40 #endif
  41 #if ARCH_SIZE == 32
  42 #define NAME(x, y) x ## 32 ## _ ## y
  43 #endif
  44 #endif
  45
  46 #ifndef NAME
  47 #define NAME(x, y) x ## NOSIZE ## _ ## y
  48 #endif
  49
  50 #define ElfNAME(X)      NAME(Elf,X)
  51 #define elfNAME(X)      NAME(elf,X)
  52
  53 /* Information held for an ELF symbol.  The first field is the
  54    corresponding asymbol.  Every symbol is an ELF file is actually a
  55    pointer to this structure, although it is often handled as a
  56    pointer to an asymbol.  */
  57
  58 typedef struct
  59 {
  60   /* The BFD symbol.  */
  61   asymbol symbol;
  62   /* ELF symbol information.  */
  63   Elf_Internal_Sym internal_elf_sym;
  64   /* Backend specific information.  */
  65   union
  66     {
  67       unsigned int hppa_arg_reloc;
  68       void *mips_extr;
  69       void *any;
  70     }
  71   tc_data;
  72
  73   /* Version information.  This is from an Elf_Internal_Versym
  74      structure in a SHT_GNU_versym section.  It is zero if there is no
  75      version information.  */
  76   unsigned short version;
  77
  78 } elf_symbol_type;
  79 \f
  80 struct elf_strtab_hash;
  81 struct got_entry;
  82 struct plt_entry;
  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   /* If this symbol requires an entry in the global offset table, the
 109      processor specific backend uses this field to track usage and
 110      final offset.  Two schemes are supported:  The first assumes that
 111      a symbol may only have one GOT entry, and uses REFCOUNT until
 112      size_dynamic_sections, at which point the contents of the .got is
 113      fixed.  Afterward, if OFFSET is -1, then the symbol does not
 114      require a global offset table entry.  The second scheme allows
 115      multiple GOT entries per symbol, managed via a linked list
 116      pointed to by GLIST.  */
 117   union gotplt_union
 118     {
 119       bfd_signed_vma refcount;
 120       bfd_vma offset;
 121       struct got_entry *glist;
 122       struct plt_entry *plist;
 123     } got;
 124
 125   /* Same, but tracks a procedure linkage table entry.  */
 126   union gotplt_union plt;
 127
 128   /* Symbol size.  */
 129   bfd_size_type size;
 130
 131   /* Symbol type (STT_NOTYPE, STT_OBJECT, etc.).  */
 132   unsigned int type : 8;
 133
 134   /* Symbol st_other value, symbol visibility.  */
 135   unsigned int other : 8;
 136
 137   /* Symbol is referenced by a non-shared object.  */
 138   unsigned int ref_regular : 1;
 139   /* Symbol is defined by a non-shared object.  */
 140   unsigned int def_regular : 1;
 141   /* Symbol is referenced by a shared object.  */
 142   unsigned int ref_dynamic : 1;
 143   /* Symbol is defined by a shared object.  */
 144   unsigned int def_dynamic : 1;
 145   /* Symbol has a non-weak reference from a non-shared object.  */
 146   unsigned int ref_regular_nonweak : 1;
 147   /* Dynamic symbol has been adjustd.  */
 148   unsigned int dynamic_adjusted : 1;
 149   /* Symbol needs a copy reloc.  */
 150   unsigned int needs_copy : 1;
 151   /* Symbol needs a procedure linkage table entry.  */
 152   unsigned int needs_plt : 1;
 153   /* Symbol appears in a non-ELF input file.  */
 154   unsigned int non_elf : 1;
 155   /* Symbol should be marked as hidden in the version information.  */
 156   unsigned int hidden : 1;
 157   /* Symbol was forced to local scope due to a version script file.  */
 158   unsigned int forced_local : 1;
 159   /* Symbol was forced to be dynamic due to a version script file.  */
 160   unsigned int dynamic : 1;
 161   /* Symbol was marked during garbage collection.  */
 162   unsigned int mark : 1;
 163   /* Symbol is referenced by a non-GOT/non-PLT relocation.  This is
 164      not currently set by all the backends.  */
 165   unsigned int non_got_ref : 1;
 166   /* Symbol has a definition in a shared object.
 167      FIXME: There is no real need for this field if def_dynamic is never
 168      cleared and all places that test def_dynamic also test def_regular.  */
 169   unsigned int dynamic_def : 1;
 170   /* Symbol is weak in all shared objects.  */
 171   unsigned int dynamic_weak : 1;
 172   /* Symbol is referenced with a relocation where C/C++ pointer equality
 173      matters.  */
 174   unsigned int pointer_equality_needed : 1;
 175
 176   /* String table index in .dynstr if this is a dynamic symbol.  */
 177   unsigned long dynstr_index;
 178
 179   union
 180   {
 181     /* If this is a weak defined symbol from a dynamic object, this
 182        field points to a defined symbol with the same value, if there is
 183        one.  Otherwise it is NULL.  */
 184     struct elf_link_hash_entry *weakdef;
 185
 186     /* Hash value of the name computed using the ELF hash function.
 187        Used part way through size_dynamic_sections, after we've finished
 188        with weakdefs.  */
 189     unsigned long elf_hash_value;
 190   } u;
 191
 192   /* Version information.  */
 193   union
 194   {
 195     /* This field is used for a symbol which is not defined in a
 196        regular object.  It points to the version information read in
 197        from the dynamic object.  */
 198     Elf_Internal_Verdef *verdef;
 199     /* This field is used for a symbol which is defined in a regular
 200        object.  It is set up in size_dynamic_sections.  It points to
 201        the version information we should write out for this symbol.  */
 202     struct bfd_elf_version_tree *vertree;
 203   } verinfo;
 204
 205   struct
 206   {
 207     /* Virtual table entry use information.  This array is nominally of size
 208        size/sizeof(target_void_pointer), though we have to be able to assume
 209        and track a size while the symbol is still undefined.  It is indexed
 210        via offset/sizeof(target_void_pointer).  */
 211     size_t size;
 212     bfd_boolean *used;
 213
 214     /* Virtual table derivation info.  */
 215     struct elf_link_hash_entry *parent;
 216   } *vtable;
 217 };
 218
 219 /* Will references to this symbol always reference the symbol
 220    in this object?  STV_PROTECTED is excluded from the visibility test
 221    here so that function pointer comparisons work properly.  Since
 222    function symbols not defined in an app are set to their .plt entry,
 223    it's necessary for shared libs to also reference the .plt even
 224    though the symbol is really local to the shared lib.  */
 225 #define SYMBOL_REFERENCES_LOCAL(INFO, H) \
 226   _bfd_elf_symbol_refs_local_p (H, INFO, 0)
 227
 228 /* Will _calls_ to this symbol always call the version in this object?  */
 229 #define SYMBOL_CALLS_LOCAL(INFO, H) \
 230   _bfd_elf_symbol_refs_local_p (H, INFO, 1)
 231
 232 /* Common symbols that are turned into definitions don't have the
 233    DEF_REGULAR flag set, so they might appear to be undefined.  */
 234 #define ELF_COMMON_DEF_P(H) \
 235   (!(H)->def_regular                                                    \
 236    && !(H)->def_dynamic                                                 \
 237    && (H)->root.type == bfd_link_hash_defined)
 238
 239 /* Records local symbols to be emitted in the dynamic symbol table.  */
 240
 241 struct elf_link_local_dynamic_entry
 242 {
 243   struct elf_link_local_dynamic_entry *next;
 244
 245   /* The input bfd this symbol came from.  */
 246   bfd *input_bfd;
 247
 248   /* The index of the local symbol being copied.  */
 249   long input_indx;
 250
 251   /* The index in the outgoing dynamic symbol table.  */
 252   long dynindx;
 253
 254   /* A copy of the input symbol.  */
 255   Elf_Internal_Sym isym;
 256 };
 257
 258 struct elf_link_loaded_list
 259 {
 260   struct elf_link_loaded_list *next;
 261   bfd *abfd;
 262 };
 263
 264 /* Structures used by the eh_frame optimization code.  */
 265 struct eh_cie_fde
 266 {
 267   union {
 268     struct {
 269       /* If REMOVED == 1, this is the CIE that the FDE originally used.
 270          The CIE belongs to the same .eh_frame input section as the FDE.
 271
 272          If REMOVED == 0, this is the CIE that we have chosen to use for
 273          the output FDE.  The CIE's REMOVED field is also 0, but the CIE
 274          might belong to a different .eh_frame input section from the FDE.  */
 275       struct eh_cie_fde *cie_inf;
 276       struct eh_cie_fde *next_for_section;
 277     } fde;
 278     struct {
 279       /* In general, equivalent CIEs are grouped together, with one CIE
 280          representing all the others in a group.  If REMOVED == 0,
 281          this CIE is the group representative.  If REMOVED == 1,
 282          following this pointer brings us "closer" to the CIE's group
 283          representative, and reapplying always gives the representative.  */
 284       struct eh_cie_fde *merged;
 285
 286       /* True if we have marked relocations associated with this CIE.  */
 287       unsigned int gc_mark : 1;
 288
 289       /* True if we have decided to turn an absolute LSDA encoding into
 290          a PC-relative one.  It is the group representative's setting
 291          that matters.  */
 292       unsigned int make_lsda_relative : 1;
 293
 294       /* True if the CIE contains personality data and if that data
 295          uses a PC-relative encoding.  */
 296       unsigned int per_encoding_relative : 1;
 297
 298       /* True if we need to add an 'R' (FDE encoding) entry to the
 299          CIE's augmentation data.  */
 300       unsigned int add_fde_encoding : 1;
 301     } cie;
 302   } u;
 303   unsigned int reloc_index;
 304   unsigned int size;
 305   unsigned int offset;
 306   unsigned int new_offset;
 307   unsigned int fde_encoding : 8;
 308   unsigned int lsda_encoding : 8;
 309   unsigned int lsda_offset : 8;
 310
 311   /* True if this entry represents a CIE, false if it represents an FDE.  */
 312   unsigned int cie : 1;
 313
 314   /* True if this entry is currently marked for removal.  */
 315   unsigned int removed : 1;
 316
 317   /* True if we need to add a 'z' (augmentation size) entry to the CIE's
 318      augmentation data, and an associated byte to each of the CIE's FDEs.  */
 319   unsigned int add_augmentation_size : 1;
 320
 321   /* True if we have decided to convert absolute FDE relocations into
 322      relative ones.  This applies to the first relocation in the FDE,
 323      which is against the code that the FDE describes.  */
 324   unsigned int make_relative : 1;
 325
 326   /* Unused bits.  */
 327   unsigned int pad1 : 4;
 328
 329   unsigned int *set_loc;
 330 };
 331
 332 struct eh_frame_sec_info
 333 {
 334   unsigned int count;
 335   struct eh_cie_fde entry[1];
 336 };
 337
 338 struct eh_frame_array_ent
 339 {
 340   bfd_vma initial_loc;
 341   bfd_vma fde;
 342 };
 343
 344 struct htab;
 345
 346 struct eh_frame_hdr_info
 347 {
 348   struct htab *cies;
 349   asection *hdr_sec;
 350   unsigned int fde_count, array_count;
 351   struct eh_frame_array_ent *array;
 352   /* TRUE if all .eh_frames have been parsd.  */
 353   bfd_boolean parsed_eh_frames;
 354   /* TRUE if .eh_frame_hdr should contain the sorted search table.
 355      We build it if we successfully read all .eh_frame input sections
 356      and recognize them.  */
 357   bfd_boolean table;
 358   bfd_boolean offsets_adjusted;
 359 };
 360
 361 /* ELF linker hash table.  */
 362
 363 struct elf_link_hash_table
 364 {
 365   struct bfd_link_hash_table root;
 366
 367   /* Whether we have created the special dynamic sections required
 368      when linking against or generating a shared object.  */
 369   bfd_boolean dynamic_sections_created;
 370
 371   /* True if this target has relocatable executables, so needs dynamic
 372      section symbols.  */
 373   bfd_boolean is_relocatable_executable;
 374
 375   /* The BFD used to hold special sections created by the linker.
 376      This will be the first BFD found which requires these sections to
 377      be created.  */
 378   bfd *dynobj;
 379
 380   /* The value to use when initialising got.refcount/offset and
 381      plt.refcount/offset in an elf_link_hash_entry.  Set to zero when
 382      the values are refcounts.  Set to init_got_offset/init_plt_offset
 383      in size_dynamic_sections when the values may be offsets.  */
 384   union gotplt_union init_got_refcount;
 385   union gotplt_union init_plt_refcount;
 386
 387   /* The value to use for got.refcount/offset and plt.refcount/offset
 388      when the values may be offsets.  Normally (bfd_vma) -1.  */
 389   union gotplt_union init_got_offset;
 390   union gotplt_union init_plt_offset;
 391
 392   /* The number of symbols found in the link which must be put into
 393      the .dynsym section.  */
 394   bfd_size_type dynsymcount;
 395
 396   /* The string table of dynamic symbols, which becomes the .dynstr
 397      section.  */
 398   struct elf_strtab_hash *dynstr;
 399
 400   /* The number of buckets in the hash table in the .hash section.
 401      This is based on the number of dynamic symbols.  */
 402   bfd_size_type bucketcount;
 403
 404   /* A linked list of DT_NEEDED names found in dynamic objects
 405      included in the link.  */
 406   struct bfd_link_needed_list *needed;
 407
 408   /* Sections in the output bfd that provides a section symbol
 409      to be used by relocations emitted against local symbols.
 410      Most targets will not use data_index_section.  */
 411   asection *text_index_section;
 412   asection *data_index_section;
 413
 414   /* The _GLOBAL_OFFSET_TABLE_ symbol.  */
 415   struct elf_link_hash_entry *hgot;
 416
 417   /* The _PROCEDURE_LINKAGE_TABLE_ symbol.  */
 418   struct elf_link_hash_entry *hplt;
 419
 420   /* A pointer to information used to merge SEC_MERGE sections.  */
 421   void *merge_info;
 422
 423   /* Used to link stabs in sections.  */
 424   struct stab_info stab_info;
 425
 426   /* Used by eh_frame code when editing .eh_frame.  */
 427   struct eh_frame_hdr_info eh_info;
 428
 429   /* A linked list of local symbols to be added to .dynsym.  */
 430   struct elf_link_local_dynamic_entry *dynlocal;
 431
 432   /* A linked list of DT_RPATH/DT_RUNPATH names found in dynamic
 433      objects included in the link.  */
 434   struct bfd_link_needed_list *runpath;
 435
 436   /* Cached first output tls section and size of PT_TLS segment.  */
 437   asection *tls_sec;
 438   bfd_size_type tls_size;
 439
 440   /* A linked list of BFD's loaded in the link.  */
 441   struct elf_link_loaded_list *loaded;
 442 };
 443
 444 /* Look up an entry in an ELF linker hash table.  */
 445
 446 #define elf_link_hash_lookup(table, string, create, copy, follow)       \
 447   ((struct elf_link_hash_entry *)                                       \
 448    bfd_link_hash_lookup (&(table)->root, (string), (create),            \
 449                          (copy), (follow)))
 450
 451 /* Traverse an ELF linker hash table.  */
 452
 453 #define elf_link_hash_traverse(table, func, info)                       \
 454   (bfd_link_hash_traverse                                               \
 455    (&(table)->root,                                                     \
 456     (bfd_boolean (*) (struct bfd_link_hash_entry *, void *)) (func),    \
 457     (info)))
 458
 459 /* Get the ELF linker hash table from a link_info structure.  */
 460
 461 #define elf_hash_table(p) ((struct elf_link_hash_table *) ((p)->hash))
 462
 463 /* Returns TRUE if the hash table is a struct elf_link_hash_table.  */
 464 #define is_elf_hash_table(htab)                                         \
 465   (((struct bfd_link_hash_table *) (htab))->type == bfd_link_elf_hash_table)
 466
 467 /* Used by bfd_section_from_r_symndx to cache a small number of local
 468    symbol to section mappings.  */
 469 #define LOCAL_SYM_CACHE_SIZE 32
 470 struct sym_sec_cache
 471 {
 472   bfd *abfd;
 473   unsigned long indx[LOCAL_SYM_CACHE_SIZE];
 474   unsigned int shndx[LOCAL_SYM_CACHE_SIZE];
 475 };
 476 \f
 477 /* Constant information held for an ELF backend.  */
 478
 479 struct elf_size_info {
 480   unsigned char sizeof_ehdr, sizeof_phdr, sizeof_shdr;
 481   unsigned char sizeof_rel, sizeof_rela, sizeof_sym, sizeof_dyn, sizeof_note;
 482
 483   /* The size of entries in the .hash section.  */
 484   unsigned char sizeof_hash_entry;
 485
 486   /* The number of internal relocations to allocate per external
 487      relocation entry.  */
 488   unsigned char int_rels_per_ext_rel;
 489   /* We use some fixed size arrays.  This should be large enough to
 490      handle all back-ends.  */
 491 #define MAX_INT_RELS_PER_EXT_REL 3
 492
 493   unsigned char arch_size, log_file_align;
 494   unsigned char elfclass, ev_current;
 495   int (*write_out_phdrs)
 496     (bfd *, const Elf_Internal_Phdr *, unsigned int);
 497   bfd_boolean
 498     (*write_shdrs_and_ehdr) (bfd *);
 499   bfd_boolean (*checksum_contents)
 500     (bfd * , void (*) (const void *, size_t, void *), void *);
 501   void (*write_relocs)
 502     (bfd *, asection *, void *);
 503   bfd_boolean (*swap_symbol_in)
 504     (bfd *, const void *, const void *, Elf_Internal_Sym *);
 505   void (*swap_symbol_out)
 506     (bfd *, const Elf_Internal_Sym *, void *, void *);
 507   bfd_boolean (*slurp_reloc_table)
 508     (bfd *, asection *, asymbol **, bfd_boolean);
 509   long (*slurp_symbol_table)
 510     (bfd *, asymbol **, bfd_boolean);
 511   void (*swap_dyn_in)
 512     (bfd *, const void *, Elf_Internal_Dyn *);
 513   void (*swap_dyn_out)
 514     (bfd *, const Elf_Internal_Dyn *, void *);
 515
 516   /* This function is called to swap in a REL relocation.  If an
 517      external relocation corresponds to more than one internal
 518      relocation, then all relocations are swapped in at once.  */
 519   void (*swap_reloc_in)
 520     (bfd *, const bfd_byte *, Elf_Internal_Rela *);
 521
 522   /* This function is called to swap out a REL relocation.  */
 523   void (*swap_reloc_out)
 524     (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 525
 526   /* This function is called to swap in a RELA relocation.  If an
 527      external relocation corresponds to more than one internal
 528      relocation, then all relocations are swapped in at once.  */
 529   void (*swap_reloca_in)
 530     (bfd *, const bfd_byte *, Elf_Internal_Rela *);
 531
 532   /* This function is called to swap out a RELA relocation.  */
 533   void (*swap_reloca_out)
 534     (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 535 };
 536
 537 #define elf_symbol_from(ABFD,S) \
 538         (((S)->the_bfd->xvec->flavour == bfd_target_elf_flavour \
 539           && (S)->the_bfd->tdata.elf_obj_data != 0) \
 540          ? (elf_symbol_type *) (S) \
 541          : 0)
 542
 543 enum elf_reloc_type_class {
 544   reloc_class_normal,
 545   reloc_class_relative,
 546   reloc_class_plt,
 547   reloc_class_copy
 548 };
 549
 550 struct elf_reloc_cookie
 551 {
 552   Elf_Internal_Rela *rels, *rel, *relend;
 553   Elf_Internal_Sym *locsyms;
 554   bfd *abfd;
 555   size_t locsymcount;
 556   size_t extsymoff;
 557   struct elf_link_hash_entry **sym_hashes;
 558   int r_sym_shift;
 559   bfd_boolean bad_symtab;
 560 };
 561
 562 /* The level of IRIX compatibility we're striving for.  */
 563
 564 typedef enum {
 565   ict_none,
 566   ict_irix5,
 567   ict_irix6
 568 } irix_compat_t;
 569
 570 /* Mapping of ELF section names and types.  */
 571 struct bfd_elf_special_section
 572 {
 573   const char *prefix;
 574   int prefix_length;
 575   /* 0 means name must match PREFIX exactly.
 576      -1 means name must start with PREFIX followed by an arbitrary string.
 577      -2 means name must match PREFIX exactly or consist of PREFIX followed
 578      by a dot then anything.
 579      > 0 means name must start with the first PREFIX_LENGTH chars of
 580      PREFIX and finish with the last SUFFIX_LENGTH chars of PREFIX.  */
 581   int suffix_length;
 582   int type;
 583   int attr;
 584 };
 585
 586 enum action_discarded
 587   {
 588     COMPLAIN = 1,
 589     PRETEND = 2
 590   };
 591
 592 typedef asection * (*elf_gc_mark_hook_fn)
 593   (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
 594    struct elf_link_hash_entry *, Elf_Internal_Sym *);
 595
 596 struct elf_backend_data
 597 {
 598   /* The architecture for this backend.  */
 599   enum bfd_architecture arch;
 600
 601   /* The ELF machine code (EM_xxxx) for this backend.  */
 602   int elf_machine_code;
 603
 604   /* EI_OSABI. */
 605   int elf_osabi;
 606
 607   /* The maximum page size for this backend.  */
 608   bfd_vma maxpagesize;
 609
 610   /* The minimum page size for this backend.  An input object will not be
 611      considered page aligned unless its sections are correctly aligned for
 612      pages at least this large.  May be smaller than maxpagesize.  */
 613   bfd_vma minpagesize;
 614
 615   /* The common page size for this backend.  */
 616   bfd_vma commonpagesize;
 617
 618   /* The BFD flags applied to sections created for dynamic linking.  */
 619   flagword dynamic_sec_flags;
 620
 621   /* A function to translate an ELF RELA relocation to a BFD arelent
 622      structure.  */
 623   void (*elf_info_to_howto)
 624     (bfd *, arelent *, Elf_Internal_Rela *);
 625
 626   /* A function to translate an ELF REL relocation to a BFD arelent
 627      structure.  */
 628   void (*elf_info_to_howto_rel)
 629     (bfd *, arelent *, Elf_Internal_Rela *);
 630
 631   /* A function to determine whether a symbol is global when
 632      partitioning the symbol table into local and global symbols.
 633      This should be NULL for most targets, in which case the correct
 634      thing will be done.  MIPS ELF, at least on the Irix 5, has
 635      special requirements.  */
 636   bfd_boolean (*elf_backend_sym_is_global)
 637     (bfd *, asymbol *);
 638
 639   /* The remaining functions are hooks which are called only if they
 640      are not NULL.  */
 641
 642   /* A function to permit a backend specific check on whether a
 643      particular BFD format is relevant for an object file, and to
 644      permit the backend to set any global information it wishes.  When
 645      this is called elf_elfheader is set, but anything else should be
 646      used with caution.  If this returns FALSE, the check_format
 647      routine will return a bfd_error_wrong_format error.  */
 648   bfd_boolean (*elf_backend_object_p)
 649     (bfd *);
 650
 651   /* A function to do additional symbol processing when reading the
 652      ELF symbol table.  This is where any processor-specific special
 653      section indices are handled.  */
 654   void (*elf_backend_symbol_processing)
 655     (bfd *, asymbol *);
 656
 657   /* A function to do additional symbol processing after reading the
 658      entire ELF symbol table.  */
 659   bfd_boolean (*elf_backend_symbol_table_processing)
 660     (bfd *, elf_symbol_type *, unsigned int);
 661
 662   /* A function to set the type of the info field.  Processor-specific
 663      types should be handled here.  */
 664   int (*elf_backend_get_symbol_type)
 665     (Elf_Internal_Sym *, int);
 666
 667   /* A function to return the linker hash table entry of a symbol that
 668      might be satisfied by an archive symbol.  */
 669   struct elf_link_hash_entry * (*elf_backend_archive_symbol_lookup)
 670     (bfd *, struct bfd_link_info *, const char *);
 671
 672   /* Return true if local section symbols should have a non-null st_name.
 673      NULL implies false.  */
 674   bfd_boolean (*elf_backend_name_local_section_symbols)
 675     (bfd *);
 676
 677   /* A function to do additional processing on the ELF section header
 678      just before writing it out.  This is used to set the flags and
 679      type fields for some sections, or to actually write out data for
 680      unusual sections.  */
 681   bfd_boolean (*elf_backend_section_processing)
 682     (bfd *, Elf_Internal_Shdr *);
 683
 684   /* A function to handle unusual section types when creating BFD
 685      sections from ELF sections.  */
 686   bfd_boolean (*elf_backend_section_from_shdr)
 687     (bfd *, Elf_Internal_Shdr *, const char *, int);
 688
 689   /* A function to convert machine dependent ELF section header flags to
 690      BFD internal section header flags.  */
 691   bfd_boolean (*elf_backend_section_flags)
 692     (flagword *, const Elf_Internal_Shdr *);
 693
 694   /* A function that returns a struct containing ELF section flags and
 695      type for the given BFD section.   */
 696   const struct bfd_elf_special_section * (*get_sec_type_attr)
 697     (bfd *, asection *);
 698
 699   /* A function to handle unusual program segment types when creating BFD
 700      sections from ELF program segments.  */
 701   bfd_boolean (*elf_backend_section_from_phdr)
 702     (bfd *, Elf_Internal_Phdr *, int, const char *);
 703
 704   /* A function to set up the ELF section header for a BFD section in
 705      preparation for writing it out.  This is where the flags and type
 706      fields are set for unusual sections.  */
 707   bfd_boolean (*elf_backend_fake_sections)
 708     (bfd *, Elf_Internal_Shdr *, asection *);
 709
 710   /* A function to get the ELF section index for a BFD section.  If
 711      this returns TRUE, the section was found.  If it is a normal ELF
 712      section, *RETVAL should be left unchanged.  If it is not a normal
 713      ELF section *RETVAL should be set to the SHN_xxxx index.  */
 714   bfd_boolean (*elf_backend_section_from_bfd_section)
 715     (bfd *, asection *, int *retval);
 716
 717   /* If this field is not NULL, it is called by the add_symbols phase
 718      of a link just before adding a symbol to the global linker hash
 719      table.  It may modify any of the fields as it wishes.  If *NAME
 720      is set to NULL, the symbol will be skipped rather than being
 721      added to the hash table.  This function is responsible for
 722      handling all processor dependent symbol bindings and section
 723      indices, and must set at least *FLAGS and *SEC for each processor
 724      dependent case; failure to do so will cause a link error.  */
 725   bfd_boolean (*elf_add_symbol_hook)
 726     (bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *,
 727      const char **name, flagword *flags, asection **sec, bfd_vma *value);
 728
 729   /* If this field is not NULL, it is called by the elf_link_output_sym
 730      phase of a link for each symbol which will appear in the object file.  */
 731   bfd_boolean (*elf_backend_link_output_symbol_hook)
 732     (struct bfd_link_info *info, const char *, Elf_Internal_Sym *,
 733      asection *, struct elf_link_hash_entry *);
 734
 735   /* The CREATE_DYNAMIC_SECTIONS function is called by the ELF backend
 736      linker the first time it encounters a dynamic object in the link.
 737      This function must create any sections required for dynamic
 738      linking.  The ABFD argument is a dynamic object.  The .interp,
 739      .dynamic, .dynsym, .dynstr, and .hash functions have already been
 740      created, and this function may modify the section flags if
 741      desired.  This function will normally create the .got and .plt
 742      sections, but different backends have different requirements.  */
 743   bfd_boolean (*elf_backend_create_dynamic_sections)
 744     (bfd *abfd, struct bfd_link_info *info);
 745
 746   /* When creating a shared library, determine whether to omit the
 747      dynamic symbol for the section.  */
 748   bfd_boolean (*elf_backend_omit_section_dynsym)
 749     (bfd *output_bfd, struct bfd_link_info *info, asection *osec);
 750
 751   /* Return TRUE if relocations of targets are compatible to the extent
 752      that CHECK_RELOCS will properly process them.  PR 4424.  */
 753   bfd_boolean (*relocs_compatible) (const bfd_target *, const bfd_target *);
 754
 755   /* The CHECK_RELOCS function is called by the add_symbols phase of
 756      the ELF backend linker.  It is called once for each section with
 757      relocs of an object file, just after the symbols for the object
 758      file have been added to the global linker hash table.  The
 759      function must look through the relocs and do any special handling
 760      required.  This generally means allocating space in the global
 761      offset table, and perhaps allocating space for a reloc.  The
 762      relocs are always passed as Rela structures; if the section
 763      actually uses Rel structures, the r_addend field will always be
 764      zero.  */
 765   bfd_boolean (*check_relocs)
 766     (bfd *abfd, struct bfd_link_info *info, asection *o,
 767      const Elf_Internal_Rela *relocs);
 768
 769   /* The CHECK_DIRECTIVES function is called once per input file by
 770      the add_symbols phase of the ELF backend linker.  The function
 771      must inspect the bfd and create any additional symbols according
 772      to any custom directives in the bfd.  */
 773   bfd_boolean (*check_directives)
 774     (bfd *abfd, struct bfd_link_info *info);
 775
 776   /* The AS_NEEDED_CLEANUP function is called once per --as-needed
 777      input file that was not needed by the add_symbols phase of the
 778      ELF backend linker.  The function must undo any target specific
 779      changes in the symbol hash table.  */
 780   bfd_boolean (*as_needed_cleanup)
 781     (bfd *abfd, struct bfd_link_info *info);
 782
 783   /* The ADJUST_DYNAMIC_SYMBOL function is called by the ELF backend
 784      linker for every symbol which is defined by a dynamic object and
 785      referenced by a regular object.  This is called after all the
 786      input files have been seen, but before the SIZE_DYNAMIC_SECTIONS
 787      function has been called.  The hash table entry should be
 788      bfd_link_hash_defined ore bfd_link_hash_defweak, and it should be
 789      defined in a section from a dynamic object.  Dynamic object
 790      sections are not included in the final link, and this function is
 791      responsible for changing the value to something which the rest of
 792      the link can deal with.  This will normally involve adding an
 793      entry to the .plt or .got or some such section, and setting the
 794      symbol to point to that.  */
 795   bfd_boolean (*elf_backend_adjust_dynamic_symbol)
 796     (struct bfd_link_info *info, struct elf_link_hash_entry *h);
 797
 798   /* The ALWAYS_SIZE_SECTIONS function is called by the backend linker
 799      after all the linker input files have been seen but before the
 800      section sizes have been set.  This is called after
 801      ADJUST_DYNAMIC_SYMBOL, but before SIZE_DYNAMIC_SECTIONS.  */
 802   bfd_boolean (*elf_backend_always_size_sections)
 803     (bfd *output_bfd, struct bfd_link_info *info);
 804
 805   /* The SIZE_DYNAMIC_SECTIONS function is called by the ELF backend
 806      linker after all the linker input files have been seen but before
 807      the sections sizes have been set.  This is called after
 808      ADJUST_DYNAMIC_SYMBOL has been called on all appropriate symbols.
 809      It is only called when linking against a dynamic object.  It must
 810      set the sizes of the dynamic sections, and may fill in their
 811      contents as well.  The generic ELF linker can handle the .dynsym,
 812      .dynstr and .hash sections.  This function must handle the
 813      .interp section and any sections created by the
 814      CREATE_DYNAMIC_SECTIONS entry point.  */
 815   bfd_boolean (*elf_backend_size_dynamic_sections)
 816     (bfd *output_bfd, struct bfd_link_info *info);
 817
 818   /* Set TEXT_INDEX_SECTION and DATA_INDEX_SECTION, the output sections
 819      we keep to use as a base for relocs and symbols.  */
 820   void (*elf_backend_init_index_section)
 821     (bfd *output_bfd, struct bfd_link_info *info);
 822
 823   /* The RELOCATE_SECTION function is called by the ELF backend linker
 824      to handle the relocations for a section.
 825
 826      The relocs are always passed as Rela structures; if the section
 827      actually uses Rel structures, the r_addend field will always be
 828      zero.
 829
 830      This function is responsible for adjust the section contents as
 831      necessary, and (if using Rela relocs and generating a
 832      relocatable output file) adjusting the reloc addend as
 833      necessary.
 834
 835      This function does not have to worry about setting the reloc
 836      address or the reloc symbol index.
 837
 838      LOCAL_SYMS is a pointer to the swapped in local symbols.
 839
 840      LOCAL_SECTIONS is an array giving the section in the input file
 841      corresponding to the st_shndx field of each local symbol.
 842
 843      The global hash table entry for the global symbols can be found
 844      via elf_sym_hashes (input_bfd).
 845
 846      When generating relocatable output, this function must handle
 847      STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 848      going to be the section symbol corresponding to the output
 849      section, which means that the addend must be adjusted
 850      accordingly.
 851
 852      Returns FALSE on error, TRUE on success, 2 if successful and
 853      relocations should be written for this section.  */
 854   int (*elf_backend_relocate_section)
 855     (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
 856      asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs,
 857      Elf_Internal_Sym *local_syms, asection **local_sections);
 858
 859   /* The FINISH_DYNAMIC_SYMBOL function is called by the ELF backend
 860      linker just before it writes a symbol out to the .dynsym section.
 861      The processor backend may make any required adjustment to the
 862      symbol.  It may also take the opportunity to set contents of the
 863      dynamic sections.  Note that FINISH_DYNAMIC_SYMBOL is called on
 864      all .dynsym symbols, while ADJUST_DYNAMIC_SYMBOL is only called
 865      on those symbols which are defined by a dynamic object.  */
 866   bfd_boolean (*elf_backend_finish_dynamic_symbol)
 867     (bfd *output_bfd, struct bfd_link_info *info,
 868      struct elf_link_hash_entry *h, Elf_Internal_Sym *sym);
 869
 870   /* The FINISH_DYNAMIC_SECTIONS function is called by the ELF backend
 871      linker just before it writes all the dynamic sections out to the
 872      output file.  The FINISH_DYNAMIC_SYMBOL will have been called on
 873      all dynamic symbols.  */
 874   bfd_boolean (*elf_backend_finish_dynamic_sections)
 875     (bfd *output_bfd, struct bfd_link_info *info);
 876
 877   /* A function to do any beginning processing needed for the ELF file
 878      before building the ELF headers and computing file positions.  */
 879   void (*elf_backend_begin_write_processing)
 880     (bfd *, struct bfd_link_info *);
 881
 882   /* A function to do any final processing needed for the ELF file
 883      before writing it out.  The LINKER argument is TRUE if this BFD
 884      was created by the ELF backend linker.  */
 885   void (*elf_backend_final_write_processing)
 886     (bfd *, bfd_boolean linker);
 887
 888   /* This function is called by get_program_header_size.  It should
 889      return the number of additional program segments which this BFD
 890      will need.  It should return -1 on error.  */
 891   int (*elf_backend_additional_program_headers)
 892     (bfd *, struct bfd_link_info *);
 893
 894   /* This function is called to modify an existing segment map in a
 895      backend specific fashion.  */
 896   bfd_boolean (*elf_backend_modify_segment_map)
 897     (bfd *, struct bfd_link_info *);
 898
 899   /* This function is called to modify program headers just before
 900      they are written.  */
 901   bfd_boolean (*elf_backend_modify_program_headers)
 902     (bfd *, struct bfd_link_info *);
 903
 904   /* This function is called during section garbage collection to
 905      mark sections that define global symbols.  */
 906   bfd_boolean (*gc_mark_dynamic_ref)
 907     (struct elf_link_hash_entry *h, void *inf);
 908
 909   /* This function is called during section gc to discover the section a
 910      particular relocation refers to.  */
 911   elf_gc_mark_hook_fn gc_mark_hook;
 912
 913   /* This function, if defined, is called after the first gc marking pass
 914      to allow the backend to mark additional sections.  */
 915   bfd_boolean (*gc_mark_extra_sections)
 916     (struct bfd_link_info *info, elf_gc_mark_hook_fn gc_mark_hook);
 917
 918   /* This function, if defined, is called during the sweep phase of gc
 919      in order that a backend might update any data structures it might
 920      be maintaining.  */
 921   bfd_boolean (*gc_sweep_hook)
 922     (bfd *abfd, struct bfd_link_info *info, asection *o,
 923      const Elf_Internal_Rela *relocs);
 924
 925   /* This function, if defined, is called after the ELF headers have
 926      been created.  This allows for things like the OS and ABI versions
 927      to be changed.  */
 928   void (*elf_backend_post_process_headers)
 929     (bfd *, struct bfd_link_info *);
 930
 931   /* This function, if defined, prints a symbol to file and returns the
 932      name of the symbol to be printed.  It should return NULL to fall
 933      back to default symbol printing.  */
 934   const char *(*elf_backend_print_symbol_all)
 935     (bfd *, void *, asymbol *);
 936
 937   /* This function, if defined, is called after all local symbols and
 938      global symbols converted to locals are emitted into the symtab
 939      section.  It allows the backend to emit special local symbols
 940      not handled in the hash table.  */
 941   bfd_boolean (*elf_backend_output_arch_local_syms)
 942     (bfd *, struct bfd_link_info *, void *,
 943      bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *,
 944                       struct elf_link_hash_entry *));
 945
 946   /* This function, if defined, is called after all symbols are emitted
 947      into the symtab section.  It allows the backend to emit special
 948      global symbols not handled in the hash table.  */
 949   bfd_boolean (*elf_backend_output_arch_syms)
 950     (bfd *, struct bfd_link_info *, void *,
 951      bfd_boolean (*) (void *, const char *, Elf_Internal_Sym *, asection *,
 952                       struct elf_link_hash_entry *));
 953
 954   /* Copy any information related to dynamic linking from a pre-existing
 955      symbol to a newly created symbol.  Also called to copy flags and
 956      other back-end info to a weakdef, in which case the symbol is not
 957      newly created and plt/got refcounts and dynamic indices should not
 958      be copied.  */
 959   void (*elf_backend_copy_indirect_symbol)
 960     (struct bfd_link_info *, struct elf_link_hash_entry *,
 961      struct elf_link_hash_entry *);
 962
 963   /* Modify any information related to dynamic linking such that the
 964      symbol is not exported.  */
 965   void (*elf_backend_hide_symbol)
 966     (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
 967
 968   /* A function to do additional symbol fixup, called by
 969      _bfd_elf_fix_symbol_flags.  */
 970   bfd_boolean (*elf_backend_fixup_symbol)
 971     (struct bfd_link_info *, struct elf_link_hash_entry *);
 972
 973   /* Merge the backend specific symbol attribute.  */
 974   void (*elf_backend_merge_symbol_attribute)
 975     (struct elf_link_hash_entry *, const Elf_Internal_Sym *, bfd_boolean,
 976      bfd_boolean);
 977
 978   /* Decide whether an undefined symbol is special and can be ignored.
 979      This is the case for OPTIONAL symbols on IRIX.  */
 980   bfd_boolean (*elf_backend_ignore_undef_symbol)
 981     (struct elf_link_hash_entry *);
 982
 983   /* Emit relocations.  Overrides default routine for emitting relocs,
 984      except during a relocatable link, or if all relocs are being emitted.  */
 985   bfd_boolean (*elf_backend_emit_relocs)
 986     (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *,
 987      struct elf_link_hash_entry **);
 988
 989   /* Count relocations.  Not called for relocatable links
 990      or if all relocs are being preserved in the output.  */
 991   unsigned int (*elf_backend_count_relocs)
 992     (asection *, Elf_Internal_Rela *);
 993
 994   /* This function, if defined, is called when an NT_PRSTATUS note is found
 995      in a core file.  */
 996   bfd_boolean (*elf_backend_grok_prstatus)
 997     (bfd *, Elf_Internal_Note *);
 998
 999   /* This function, if defined, is called when an NT_PSINFO or NT_PRPSINFO
1000      note is found in a core file.  */
1001   bfd_boolean (*elf_backend_grok_psinfo)
1002     (bfd *, Elf_Internal_Note *);
1003
1004   /* This function, if defined, is called to write a note to a corefile.  */
1005   char *(*elf_backend_write_core_note)
1006     (bfd *abfd, char *buf, int *bufsiz, int note_type, ...);
1007
1008   /* This function returns class of a reloc type.  */
1009   enum elf_reloc_type_class (*elf_backend_reloc_type_class)
1010     (const Elf_Internal_Rela *);
1011
1012   /* This function, if defined, removes information about discarded functions
1013      from other sections which mention them.  */
1014   bfd_boolean (*elf_backend_discard_info)
1015     (bfd *, struct elf_reloc_cookie *, struct bfd_link_info *);
1016
1017   /* This function, if defined, signals that the function above has removed
1018      the discarded relocations for this section.  */
1019   bfd_boolean (*elf_backend_ignore_discarded_relocs)
1020     (asection *);
1021
1022   /* What to do when ld finds relocations against symbols defined in
1023      discarded sections.  */
1024   unsigned int (*action_discarded)
1025     (asection *);
1026
1027   /* This function returns the width of FDE pointers in bytes, or 0 if
1028      that can't be determined for some reason.  The default definition
1029      goes by the bfd's EI_CLASS.  */
1030   unsigned int (*elf_backend_eh_frame_address_size)
1031     (bfd *, asection *);
1032
1033   /* These functions tell elf-eh-frame whether to attempt to turn
1034      absolute or lsda encodings into pc-relative ones.  The default
1035      definition enables these transformations.  */
1036   bfd_boolean (*elf_backend_can_make_relative_eh_frame)
1037      (bfd *, struct bfd_link_info *, asection *);
1038   bfd_boolean (*elf_backend_can_make_lsda_relative_eh_frame)
1039      (bfd *, struct bfd_link_info *, asection *);
1040
1041   /* This function returns an encoding after computing the encoded
1042      value (and storing it in ENCODED) for the given OFFSET into OSEC,
1043      to be stored in at LOC_OFFSET into the LOC_SEC input section.
1044      The default definition chooses a 32-bit PC-relative encoding.  */
1045   bfd_byte (*elf_backend_encode_eh_address)
1046      (bfd *abfd, struct bfd_link_info *info,
1047       asection *osec, bfd_vma offset,
1048       asection *loc_sec, bfd_vma loc_offset,
1049       bfd_vma *encoded);
1050
1051   /* This function, if defined, may write out the given section.
1052      Returns TRUE if it did so and FALSE if the caller should.  */
1053   bfd_boolean (*elf_backend_write_section)
1054     (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1055
1056   /* The level of IRIX compatibility we're striving for.
1057      MIPS ELF specific function.  */
1058   irix_compat_t (*elf_backend_mips_irix_compat)
1059     (bfd *);
1060
1061   reloc_howto_type *(*elf_backend_mips_rtype_to_howto)
1062     (unsigned int, bfd_boolean);
1063
1064   /* The swapping table to use when dealing with ECOFF information.
1065      Used for the MIPS ELF .mdebug section.  */
1066   const struct ecoff_debug_swap *elf_backend_ecoff_debug_swap;
1067
1068   /* This function implements `bfd_elf_bfd_from_remote_memory';
1069      see elf.c, elfcode.h.  */
1070   bfd *(*elf_backend_bfd_from_remote_memory)
1071      (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
1072       int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len));
1073
1074   /* This function is used by `_bfd_elf_get_synthetic_symtab';
1075      see elf.c.  */
1076   bfd_vma (*plt_sym_val) (bfd_vma, const asection *, const arelent *);
1077
1078   /* Is symbol defined in common section?  */
1079   bfd_boolean (*common_definition) (Elf_Internal_Sym *);
1080
1081   /* Return a common section index for section.  */
1082   unsigned int (*common_section_index) (asection *);
1083
1084   /* Return a common section for section.  */
1085   asection *(*common_section) (asection *);
1086
1087   /* Return TRUE if we can merge 2 definitions.  */
1088   bfd_boolean (*merge_symbol) (struct bfd_link_info *,
1089                                struct elf_link_hash_entry **,
1090                                struct elf_link_hash_entry *,
1091                                Elf_Internal_Sym *, asection **,
1092                                bfd_vma *, unsigned int *,
1093                                bfd_boolean *, bfd_boolean *,
1094                                bfd_boolean *, bfd_boolean *,
1095                                bfd_boolean *, bfd_boolean *,
1096                                bfd_boolean *, bfd_boolean *,
1097                                bfd *, asection **,
1098                                bfd_boolean *, bfd_boolean *,
1099                                bfd_boolean *, bfd_boolean *,
1100                                bfd *, asection **);
1101
1102   /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
1103   bfd_boolean (*elf_hash_symbol) (struct elf_link_hash_entry *);
1104
1105   /* Return TRUE if type is a function symbol type.  */
1106   bfd_boolean (*is_function_type) (unsigned int type);
1107
1108   /* Used to handle bad SHF_LINK_ORDER input.  */
1109   bfd_error_handler_type link_order_error_handler;
1110
1111   /* Name of the PLT relocation section.  */
1112   const char *relplt_name;
1113
1114   /* Alternate EM_xxxx machine codes for this backend.  */
1115   int elf_machine_alt1;
1116   int elf_machine_alt2;
1117
1118   const struct elf_size_info *s;
1119
1120   /* An array of target specific special sections.  */
1121   const struct bfd_elf_special_section *special_sections;
1122
1123   /* The size in bytes of the header for the GOT.  This includes the
1124      so-called reserved entries on some systems.  */
1125   bfd_vma got_header_size;
1126
1127   /* The vendor name to use for a processor-standard attributes section.  */
1128   const char *obj_attrs_vendor;
1129
1130   /* The section name to use for a processor-standard attributes section.  */
1131   const char *obj_attrs_section;
1132
1133   /* Return 1, 2 or 3 to indicate what type of arguments a
1134      processor-specific tag takes.  */
1135   int (*obj_attrs_arg_type) (int);
1136
1137   /* The section type to use for an attributes section.  */
1138   unsigned int obj_attrs_section_type;
1139
1140   /* This is TRUE if the linker should act like collect and gather
1141      global constructors and destructors by name.  This is TRUE for
1142      MIPS ELF because the Irix 5 tools can not handle the .init
1143      section.  */
1144   unsigned collect : 1;
1145
1146   /* This is TRUE if the linker should ignore changes to the type of a
1147      symbol.  This is TRUE for MIPS ELF because some Irix 5 objects
1148      record undefined functions as STT_OBJECT although the definitions
1149      are STT_FUNC.  */
1150   unsigned type_change_ok : 1;
1151
1152   /* Whether the backend may use REL relocations.  (Some backends use
1153      both REL and RELA relocations, and this flag is set for those
1154      backends.)  */
1155   unsigned may_use_rel_p : 1;
1156
1157   /* Whether the backend may use RELA relocations.  (Some backends use
1158      both REL and RELA relocations, and this flag is set for those
1159      backends.)  */
1160   unsigned may_use_rela_p : 1;
1161
1162   /* Whether the default relocation type is RELA.  If a backend with
1163      this flag set wants REL relocations for a particular section,
1164      it must note that explicitly.  Similarly, if this flag is clear,
1165      and the backend wants RELA relocations for a particular
1166      section.  */
1167   unsigned default_use_rela_p : 1;
1168
1169   /* Set if RELA relocations for a relocatable link can be handled by
1170      generic code.  Backends that set this flag need do nothing in the
1171      backend relocate_section routine for relocatable linking.  */
1172   unsigned rela_normal : 1;
1173
1174   /* TRUE if addresses "naturally" sign extend.  This is used when
1175      swapping in from Elf32 when BFD64.  */
1176   unsigned sign_extend_vma : 1;
1177
1178   unsigned want_got_plt : 1;
1179   unsigned plt_readonly : 1;
1180   unsigned want_plt_sym : 1;
1181   unsigned plt_not_loaded : 1;
1182   unsigned plt_alignment : 4;
1183   unsigned can_gc_sections : 1;
1184   unsigned can_refcount : 1;
1185   unsigned want_got_sym : 1;
1186   unsigned want_dynbss : 1;
1187
1188   /* Targets which do not support physical addressing often require
1189      that the p_paddr field in the section header to be set to zero.
1190      This field indicates whether this behavior is required.  */
1191   unsigned want_p_paddr_set_to_zero : 1;
1192
1193   /* True if an object file lacking a .note.GNU-stack section
1194      should be assumed to be requesting exec stack.  At least one
1195      other file in the link needs to have a .note.GNU-stack section
1196      for a PT_GNU_STACK segment to be created.  */
1197   unsigned default_execstack : 1;
1198 };
1199
1200 /* Information stored for each BFD section in an ELF file.  This
1201    structure is allocated by elf_new_section_hook.  */
1202
1203 struct bfd_elf_section_data
1204 {
1205   /* The ELF header for this section.  */
1206   Elf_Internal_Shdr this_hdr;
1207
1208   /* The ELF header for the reloc section associated with this
1209      section, if any.  */
1210   Elf_Internal_Shdr rel_hdr;
1211
1212   /* If there is a second reloc section associated with this section,
1213      as can happen on Irix 6, this field points to the header.  */
1214   Elf_Internal_Shdr *rel_hdr2;
1215
1216   /* The number of relocations currently assigned to REL_HDR.  */
1217   unsigned int rel_count;
1218
1219   /* The number of relocations currently assigned to REL_HDR2.  */
1220   unsigned int rel_count2;
1221
1222   /* The ELF section number of this section.  */
1223   int this_idx;
1224
1225   /* The ELF section number of the reloc section indicated by
1226      REL_HDR if any.  Only used for an output file.  */
1227   int rel_idx;
1228
1229   /* The ELF section number of the reloc section indicated by
1230      REL_HDR2 if any.  Only used for an output file.  */
1231   int rel_idx2;
1232
1233   /* Used by the backend linker when generating a shared library to
1234      record the dynamic symbol index for a section symbol
1235      corresponding to this section.  A value of 0 means that there is
1236      no dynamic symbol for this section.  */
1237   int dynindx;
1238
1239   /* A pointer to the linked-to section for SHF_LINK_ORDER.  */
1240   asection *linked_to;
1241
1242   /* Used by the backend linker to store the symbol hash table entries
1243      associated with relocs against global symbols.  */
1244   struct elf_link_hash_entry **rel_hashes;
1245
1246   /* A pointer to the swapped relocs.  If the section uses REL relocs,
1247      rather than RELA, all the r_addend fields will be zero.  This
1248      pointer may be NULL.  It is used by the backend linker.  */
1249   Elf_Internal_Rela *relocs;
1250
1251   /* A pointer to a linked list tracking dynamic relocs copied for
1252      local symbols.  */
1253   void *local_dynrel;
1254
1255   /* A pointer to the bfd section used for dynamic relocs.  */
1256   asection *sreloc;
1257
1258   union {
1259     /* Group name, if this section is a member of a group.  */
1260     const char *name;
1261
1262     /* Group signature sym, if this is the SHT_GROUP section.  */
1263     struct bfd_symbol *id;
1264   } group;
1265
1266   /* For a member of a group, points to the SHT_GROUP section.
1267      NULL for the SHT_GROUP section itself and non-group sections.  */
1268   asection *sec_group;
1269
1270   /* A linked list of member sections in the group.  Circular when used by
1271      the linker.  For the SHT_GROUP section, points at first member.  */
1272   asection *next_in_group;
1273
1274   /* The FDEs associated with this section.  The u.fde.next_in_section
1275      field acts as a chain pointer.  */
1276   struct eh_cie_fde *fde_list;
1277
1278   /* A pointer used for various section optimizations.  */
1279   void *sec_info;
1280 };
1281
1282 #define elf_section_data(sec)  ((struct bfd_elf_section_data*)(sec)->used_by_bfd)
1283 #define elf_linked_to_section(sec) (elf_section_data(sec)->linked_to)
1284 #define elf_section_type(sec)  (elf_section_data(sec)->this_hdr.sh_type)
1285 #define elf_section_flags(sec) (elf_section_data(sec)->this_hdr.sh_flags)
1286 #define elf_group_name(sec)    (elf_section_data(sec)->group.name)
1287 #define elf_group_id(sec)      (elf_section_data(sec)->group.id)
1288 #define elf_next_in_group(sec) (elf_section_data(sec)->next_in_group)
1289 #define elf_fde_list(sec)      (elf_section_data(sec)->fde_list)
1290 #define elf_sec_group(sec)      (elf_section_data(sec)->sec_group)
1291
1292 #define xvec_get_elf_backend_data(xvec) \
1293   ((const struct elf_backend_data *) (xvec)->backend_data)
1294
1295 #define get_elf_backend_data(abfd) \
1296    xvec_get_elf_backend_data ((abfd)->xvec)
1297
1298 /* This struct is used to pass information to routines called via
1299    elf_link_hash_traverse which must return failure.  */
1300
1301 struct elf_info_failed
1302 {
1303   bfd_boolean failed;
1304   struct bfd_link_info *info;
1305   struct bfd_elf_version_tree *verdefs;
1306 };
1307
1308 /* This structure is used to pass information to
1309    _bfd_elf_link_assign_sym_version.  */
1310
1311 struct elf_assign_sym_version_info
1312 {
1313   /* Output BFD.  */
1314   bfd *output_bfd;
1315   /* General link information.  */
1316   struct bfd_link_info *info;
1317   /* Version tree.  */
1318   struct bfd_elf_version_tree *verdefs;
1319   /* Whether we had a failure.  */
1320   bfd_boolean failed;
1321 };
1322
1323 /* This structure is used to pass information to
1324    _bfd_elf_link_find_version_dependencies.  */
1325
1326 struct elf_find_verdep_info
1327 {
1328   /* Output BFD.  */
1329   bfd *output_bfd;
1330   /* General link information.  */
1331   struct bfd_link_info *info;
1332   /* The number of dependencies.  */
1333   unsigned int vers;
1334   /* Whether we had a failure.  */
1335   bfd_boolean failed;
1336 };
1337
1338 /* The maximum number of known object attributes for any target.  */
1339 #define NUM_KNOWN_OBJ_ATTRIBUTES 32
1340
1341 /* The value of an object attribute.  type & 1 indicates whether there
1342    is an integer value; type & 2 indicates whether there is a string
1343    value.  */
1344
1345 typedef struct obj_attribute
1346 {
1347   int type;
1348   unsigned int i;
1349   char *s;
1350 } obj_attribute;
1351
1352 typedef struct obj_attribute_list
1353 {
1354   struct obj_attribute_list *next;
1355   int tag;
1356   obj_attribute attr;
1357 } obj_attribute_list;
1358
1359 /* Object attributes may either be defined by the processor ABI, index
1360    OBJ_ATTR_PROC in the *_obj_attributes arrays, or be GNU-specific
1361    (and possibly also processor-specific), index OBJ_ATTR_GNU.  */
1362 #define OBJ_ATTR_PROC 0
1363 #define OBJ_ATTR_GNU 1
1364 #define OBJ_ATTR_FIRST OBJ_ATTR_PROC
1365 #define OBJ_ATTR_LAST OBJ_ATTR_GNU
1366
1367 /* The following object attribute tags are taken as generic, for all
1368    targets and for "gnu" where there is no target standard.  */
1369 enum
1370 {
1371   Tag_NULL = 0,
1372   Tag_File = 1,
1373   Tag_Section = 2,
1374   Tag_Symbol = 3,
1375   Tag_compatibility = 32
1376 };
1377
1378 /* Some private data is stashed away for future use using the tdata pointer
1379    in the bfd structure.  */
1380
1381 struct elf_obj_tdata
1382 {
1383   Elf_Internal_Ehdr elf_header[1];      /* Actual data, but ref like ptr */
1384   Elf_Internal_Shdr **elf_sect_ptr;
1385   Elf_Internal_Phdr *phdr;
1386   struct elf_segment_map *segment_map;
1387   struct elf_strtab_hash *strtab_ptr;
1388   int num_locals;
1389   int num_globals;
1390   unsigned int num_elf_sections;        /* elf_sect_ptr size */
1391   int num_section_syms;
1392   asymbol **section_syms;               /* STT_SECTION symbols for each section */
1393   Elf_Internal_Shdr symtab_hdr;
1394   Elf_Internal_Shdr shstrtab_hdr;
1395   Elf_Internal_Shdr strtab_hdr;
1396   Elf_Internal_Shdr dynsymtab_hdr;
1397   Elf_Internal_Shdr dynstrtab_hdr;
1398   Elf_Internal_Shdr dynversym_hdr;
1399   Elf_Internal_Shdr dynverref_hdr;
1400   Elf_Internal_Shdr dynverdef_hdr;
1401   Elf_Internal_Shdr symtab_shndx_hdr;
1402   unsigned int symtab_section, shstrtab_section;
1403   unsigned int strtab_section, dynsymtab_section;
1404   unsigned int symtab_shndx_section;
1405   unsigned int dynversym_section, dynverdef_section, dynverref_section;
1406   file_ptr next_file_pos;
1407   bfd_vma gp;                           /* The gp value */
1408   unsigned int gp_size;                 /* The gp size */
1409
1410   /* Information grabbed from an elf core file.  */
1411   int core_signal;
1412   int core_pid;
1413   int core_lwpid;
1414   char* core_program;
1415   char* core_command;
1416
1417   /* A mapping from external symbols to entries in the linker hash
1418      table, used when linking.  This is indexed by the symbol index
1419      minus the sh_info field of the symbol table header.  */
1420   struct elf_link_hash_entry **sym_hashes;
1421
1422   /* Track usage and final offsets of GOT entries for local symbols.
1423      This array is indexed by symbol index.  Elements are used
1424      identically to "got" in struct elf_link_hash_entry.  */
1425   union
1426     {
1427       bfd_signed_vma *refcounts;
1428       bfd_vma *offsets;
1429       struct got_entry **ents;
1430     } local_got;
1431
1432   /* The linker ELF emulation code needs to let the backend ELF linker
1433      know what filename should be used for a dynamic object if the
1434      dynamic object is found using a search.  The emulation code then
1435      sometimes needs to know what name was actually used.  Until the
1436      file has been added to the linker symbol table, this field holds
1437      the name the linker wants.  After it has been added, it holds the
1438      name actually used, which will be the DT_SONAME entry if there is
1439      one.  */
1440   const char *dt_name;
1441
1442   /* Records the result of `get_program_header_size'.  */
1443   bfd_size_type program_header_size;
1444
1445   /* Used by find_nearest_line entry point.  */
1446   void *line_info;
1447
1448   /* Used by MIPS ELF find_nearest_line entry point.  The structure
1449      could be included directly in this one, but there's no point to
1450      wasting the memory just for the infrequently called
1451      find_nearest_line.  */
1452   struct mips_elf_find_line *find_line_info;
1453
1454   /* A place to stash dwarf1 info for this bfd.  */
1455   struct dwarf1_debug *dwarf1_find_line_info;
1456
1457   /* A place to stash dwarf2 info for this bfd.  */
1458   void *dwarf2_find_line_info;
1459
1460   /* An array of stub sections indexed by symbol number, used by the
1461      MIPS ELF linker.  FIXME: We should figure out some way to only
1462      include this field for a MIPS ELF target.  */
1463   asection **local_stubs;
1464   asection **local_call_stubs;
1465
1466   /* Used to determine if PT_GNU_EH_FRAME segment header should be
1467      created.  */
1468   asection *eh_frame_hdr;
1469
1470   Elf_Internal_Shdr **group_sect_ptr;
1471   int num_group;
1472
1473   /* Number of symbol version definitions we are about to emit.  */
1474   unsigned int cverdefs;
1475
1476   /* Number of symbol version references we are about to emit.  */
1477   unsigned int cverrefs;
1478
1479   /* Segment flags for the PT_GNU_STACK segment.  */
1480   unsigned int stack_flags;
1481
1482   /* Symbol version definitions in external objects.  */
1483   Elf_Internal_Verdef *verdef;
1484
1485   /* Symbol version references to external objects.  */
1486   Elf_Internal_Verneed *verref;
1487
1488   /* The Irix 5 support uses two virtual sections, which represent
1489      text/data symbols defined in dynamic objects.  */
1490   asymbol *elf_data_symbol;
1491   asymbol *elf_text_symbol;
1492   asection *elf_data_section;
1493   asection *elf_text_section;
1494
1495   /* A pointer to the .eh_frame section.  */
1496   asection *eh_frame_section;
1497
1498   /* Whether a dyanmic object was specified normally on the linker
1499      command line, or was specified when --as-needed was in effect,
1500      or was found via a DT_NEEDED entry.  */
1501   enum dynamic_lib_link_class dyn_lib_class;
1502
1503   /* This is set to TRUE if the object was created by the backend
1504      linker.  */
1505   bfd_boolean linker;
1506
1507   /* Irix 5 often screws up the symbol table, sorting local symbols
1508      after global symbols.  This flag is set if the symbol table in
1509      this BFD appears to be screwed up.  If it is, we ignore the
1510      sh_info field in the symbol table header, and always read all the
1511      symbols.  */
1512   bfd_boolean bad_symtab;
1513
1514   /* Used to determine if the e_flags field has been initialized */
1515   bfd_boolean flags_init;
1516
1517   /* Symbol buffer.  */
1518   void *symbuf;
1519
1520   obj_attribute known_obj_attributes[2][NUM_KNOWN_OBJ_ATTRIBUTES];
1521   obj_attribute_list *other_obj_attributes[2];
1522
1523   /* Called at the end of _bfd_elf_write_object_contents if not NULL.  */
1524   bfd_boolean (*after_write_object_contents) (bfd *);
1525   void *after_write_object_contents_info;
1526
1527   /* NT_GNU_BUILD_ID note type.  */
1528   bfd_size_type build_id_size;
1529   bfd_byte *build_id;
1530 };
1531
1532 #define elf_tdata(bfd)          ((bfd) -> tdata.elf_obj_data)
1533 #define elf_elfheader(bfd)      (elf_tdata(bfd) -> elf_header)
1534 #define elf_elfsections(bfd)    (elf_tdata(bfd) -> elf_sect_ptr)
1535 #define elf_numsections(bfd)    (elf_tdata(bfd) -> num_elf_sections)
1536 #define elf_shstrtab(bfd)       (elf_tdata(bfd) -> strtab_ptr)
1537 #define elf_onesymtab(bfd)      (elf_tdata(bfd) -> symtab_section)
1538 #define elf_symtab_shndx(bfd)   (elf_tdata(bfd) -> symtab_shndx_section)
1539 #define elf_dynsymtab(bfd)      (elf_tdata(bfd) -> dynsymtab_section)
1540 #define elf_dynversym(bfd)      (elf_tdata(bfd) -> dynversym_section)
1541 #define elf_dynverdef(bfd)      (elf_tdata(bfd) -> dynverdef_section)
1542 #define elf_dynverref(bfd)      (elf_tdata(bfd) -> dynverref_section)
1543 #define elf_eh_frame_section(bfd) \
1544                                 (elf_tdata(bfd) -> eh_frame_section)
1545 #define elf_num_locals(bfd)     (elf_tdata(bfd) -> num_locals)
1546 #define elf_num_globals(bfd)    (elf_tdata(bfd) -> num_globals)
1547 #define elf_section_syms(bfd)   (elf_tdata(bfd) -> section_syms)
1548 #define elf_num_section_syms(bfd) (elf_tdata(bfd) -> num_section_syms)
1549 #define core_prpsinfo(bfd)      (elf_tdata(bfd) -> prpsinfo)
1550 #define core_prstatus(bfd)      (elf_tdata(bfd) -> prstatus)
1551 #define elf_gp(bfd)             (elf_tdata(bfd) -> gp)
1552 #define elf_gp_size(bfd)        (elf_tdata(bfd) -> gp_size)
1553 #define elf_sym_hashes(bfd)     (elf_tdata(bfd) -> sym_hashes)
1554 #define elf_local_got_refcounts(bfd) (elf_tdata(bfd) -> local_got.refcounts)
1555 #define elf_local_got_offsets(bfd) (elf_tdata(bfd) -> local_got.offsets)
1556 #define elf_local_got_ents(bfd) (elf_tdata(bfd) -> local_got.ents)
1557 #define elf_dt_name(bfd)        (elf_tdata(bfd) -> dt_name)
1558 #define elf_dyn_lib_class(bfd)  (elf_tdata(bfd) -> dyn_lib_class)
1559 #define elf_bad_symtab(bfd)     (elf_tdata(bfd) -> bad_symtab)
1560 #define elf_flags_init(bfd)     (elf_tdata(bfd) -> flags_init)
1561 #define elf_known_obj_attributes(bfd) (elf_tdata (bfd) -> known_obj_attributes)
1562 #define elf_other_obj_attributes(bfd) (elf_tdata (bfd) -> other_obj_attributes)
1563 #define elf_known_obj_attributes_proc(bfd) \
1564   (elf_known_obj_attributes (bfd) [OBJ_ATTR_PROC])
1565 #define elf_other_obj_attributes_proc(bfd) \
1566   (elf_other_obj_attributes (bfd) [OBJ_ATTR_PROC])
1567 \f
1568 extern void _bfd_elf_swap_verdef_in
1569   (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *);
1570 extern void _bfd_elf_swap_verdef_out
1571   (bfd *, const Elf_Internal_Verdef *, Elf_External_Verdef *);
1572 extern void _bfd_elf_swap_verdaux_in
1573   (bfd *, const Elf_External_Verdaux *, Elf_Internal_Verdaux *);
1574 extern void _bfd_elf_swap_verdaux_out
1575   (bfd *, const Elf_Internal_Verdaux *, Elf_External_Verdaux *);
1576 extern void _bfd_elf_swap_verneed_in
1577   (bfd *, const Elf_External_Verneed *, Elf_Internal_Verneed *);
1578 extern void _bfd_elf_swap_verneed_out
1579   (bfd *, const Elf_Internal_Verneed *, Elf_External_Verneed *);
1580 extern void _bfd_elf_swap_vernaux_in
1581   (bfd *, const Elf_External_Vernaux *, Elf_Internal_Vernaux *);
1582 extern void _bfd_elf_swap_vernaux_out
1583   (bfd *, const Elf_Internal_Vernaux *, Elf_External_Vernaux *);
1584 extern void _bfd_elf_swap_versym_in
1585   (bfd *, const Elf_External_Versym *, Elf_Internal_Versym *);
1586 extern void _bfd_elf_swap_versym_out
1587   (bfd *, const Elf_Internal_Versym *, Elf_External_Versym *);
1588
1589 extern int _bfd_elf_section_from_bfd_section
1590   (bfd *, asection *);
1591 extern char *bfd_elf_string_from_elf_section
1592   (bfd *, unsigned, unsigned);
1593 extern char *bfd_elf_get_str_section
1594   (bfd *, unsigned);
1595 extern Elf_Internal_Sym *bfd_elf_get_elf_syms
1596   (bfd *, Elf_Internal_Shdr *, size_t, size_t, Elf_Internal_Sym *, void *,
1597    Elf_External_Sym_Shndx *);
1598 extern const char *bfd_elf_sym_name
1599   (bfd *, Elf_Internal_Shdr *, Elf_Internal_Sym *, asection *);
1600
1601 extern bfd_boolean _bfd_elf_copy_private_bfd_data
1602   (bfd *, bfd *);
1603 extern bfd_boolean _bfd_elf_print_private_bfd_data
1604   (bfd *, void *);
1605 extern void bfd_elf_print_symbol
1606   (bfd *, void *, asymbol *, bfd_print_symbol_type);
1607
1608 extern unsigned int _bfd_elf_eh_frame_address_size
1609   (bfd *, asection *);
1610 extern bfd_byte _bfd_elf_encode_eh_address
1611   (bfd *abfd, struct bfd_link_info *info, asection *osec, bfd_vma offset,
1612    asection *loc_sec, bfd_vma loc_offset, bfd_vma *encoded);
1613 extern bfd_boolean _bfd_elf_can_make_relative
1614   (bfd *input_bfd, struct bfd_link_info *info, asection *eh_frame_section);
1615
1616 extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
1617   (const Elf_Internal_Rela *);
1618 extern bfd_vma _bfd_elf_rela_local_sym
1619   (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *);
1620 extern bfd_vma _bfd_elf_rel_local_sym
1621   (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
1622 extern bfd_vma _bfd_elf_section_offset
1623   (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1624
1625 extern unsigned long bfd_elf_hash
1626   (const char *);
1627 extern unsigned long bfd_elf_gnu_hash
1628   (const char *);
1629
1630 extern bfd_reloc_status_type bfd_elf_generic_reloc
1631   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
1632 extern bfd_boolean bfd_elf_mkobject
1633   (bfd *);
1634 extern bfd_boolean bfd_elf_mkcorefile
1635   (bfd *);
1636 extern Elf_Internal_Shdr *bfd_elf_find_section
1637   (bfd *, char *);
1638 extern bfd_boolean _bfd_elf_make_section_from_shdr
1639   (bfd *, Elf_Internal_Shdr *, const char *, int);
1640 extern bfd_boolean _bfd_elf_make_section_from_phdr
1641   (bfd *, Elf_Internal_Phdr *, int, const char *);
1642 extern struct bfd_hash_entry *_bfd_elf_link_hash_newfunc
1643   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
1644 extern struct bfd_link_hash_table *_bfd_elf_link_hash_table_create
1645   (bfd *);
1646 extern void _bfd_elf_link_hash_copy_indirect
1647   (struct bfd_link_info *, struct elf_link_hash_entry *,
1648    struct elf_link_hash_entry *);
1649 extern void _bfd_elf_link_hash_hide_symbol
1650   (struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean);
1651 extern bfd_boolean _bfd_elf_link_hash_fixup_symbol
1652   (struct bfd_link_info *, struct elf_link_hash_entry *);
1653 extern bfd_boolean _bfd_elf_link_hash_table_init
1654   (struct elf_link_hash_table *, bfd *,
1655    struct bfd_hash_entry *(*)
1656      (struct bfd_hash_entry *, struct bfd_hash_table *, const char *),
1657    unsigned int);
1658 extern bfd_boolean _bfd_elf_slurp_version_tables
1659   (bfd *, bfd_boolean);
1660 extern bfd_boolean _bfd_elf_merge_sections
1661   (bfd *, struct bfd_link_info *);
1662 extern bfd_boolean _bfd_elf_match_sections_by_type
1663   (bfd *, const asection *, bfd *, const asection *);
1664 extern bfd_boolean bfd_elf_is_group_section
1665   (bfd *, const struct bfd_section *);
1666 extern void _bfd_elf_section_already_linked
1667   (bfd *, struct bfd_section *, struct bfd_link_info *);
1668 extern void bfd_elf_set_group_contents
1669   (bfd *, asection *, void *);
1670 extern asection *_bfd_elf_check_kept_section
1671   (asection *, struct bfd_link_info *);
1672 extern void _bfd_elf_link_just_syms
1673   (asection *, struct bfd_link_info *);
1674 extern bfd_boolean _bfd_elf_copy_private_header_data
1675   (bfd *, bfd *);
1676 extern bfd_boolean _bfd_elf_copy_private_symbol_data
1677   (bfd *, asymbol *, bfd *, asymbol *);
1678 #define _bfd_generic_init_private_section_data \
1679   _bfd_elf_init_private_section_data
1680 extern bfd_boolean _bfd_elf_init_private_section_data
1681   (bfd *, asection *, bfd *, asection *, struct bfd_link_info *);
1682 extern bfd_boolean _bfd_elf_copy_private_section_data
1683   (bfd *, asection *, bfd *, asection *);
1684 extern bfd_boolean _bfd_elf_write_object_contents
1685   (bfd *);
1686 extern bfd_boolean _bfd_elf_write_corefile_contents
1687   (bfd *);
1688 extern bfd_boolean _bfd_elf_set_section_contents
1689   (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);
1690 extern long _bfd_elf_get_symtab_upper_bound
1691   (bfd *);
1692 extern long _bfd_elf_canonicalize_symtab
1693   (bfd *, asymbol **);
1694 extern long _bfd_elf_get_dynamic_symtab_upper_bound
1695   (bfd *);
1696 extern long _bfd_elf_canonicalize_dynamic_symtab
1697   (bfd *, asymbol **);
1698 extern long _bfd_elf_get_synthetic_symtab
1699   (bfd *, long, asymbol **, long, asymbol **, asymbol **);
1700 extern long _bfd_elf_get_reloc_upper_bound
1701   (bfd *, sec_ptr);
1702 extern long _bfd_elf_canonicalize_reloc
1703   (bfd *, sec_ptr, arelent **, asymbol **);
1704 extern long _bfd_elf_get_dynamic_reloc_upper_bound
1705   (bfd *);
1706 extern long _bfd_elf_canonicalize_dynamic_reloc
1707   (bfd *, arelent **, asymbol **);
1708 extern asymbol *_bfd_elf_make_empty_symbol
1709   (bfd *);
1710 extern void _bfd_elf_get_symbol_info
1711   (bfd *, asymbol *, symbol_info *);
1712 extern bfd_boolean _bfd_elf_is_local_label_name
1713   (bfd *, const char *);
1714 extern alent *_bfd_elf_get_lineno
1715   (bfd *, asymbol *);
1716 extern bfd_boolean _bfd_elf_set_arch_mach
1717   (bfd *, enum bfd_architecture, unsigned long);
1718 extern bfd_boolean _bfd_elf_find_nearest_line
1719   (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **,
1720    unsigned int *);
1721 extern bfd_boolean _bfd_elf_find_line
1722   (bfd *, asymbol **, asymbol *, const char **, unsigned int *);
1723 #define _bfd_generic_find_line _bfd_elf_find_line
1724 extern bfd_boolean _bfd_elf_find_inliner_info
1725   (bfd *, const char **, const char **, unsigned int *);
1726 #define _bfd_elf_read_minisymbols _bfd_generic_read_minisymbols
1727 #define _bfd_elf_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
1728 extern int _bfd_elf_sizeof_headers
1729   (bfd *, struct bfd_link_info *);
1730 extern bfd_boolean _bfd_elf_new_section_hook
1731   (bfd *, asection *);
1732 extern bfd_boolean _bfd_elf_init_reloc_shdr
1733   (bfd *, Elf_Internal_Shdr *, asection *, bfd_boolean);
1734 extern const struct bfd_elf_special_section *_bfd_elf_get_special_section
1735   (const char *, const struct bfd_elf_special_section *, unsigned int);
1736 extern const struct bfd_elf_special_section *_bfd_elf_get_sec_type_attr
1737   (bfd *, asection *);
1738
1739 /* If the target doesn't have reloc handling written yet:  */
1740 extern void _bfd_elf_no_info_to_howto
1741   (bfd *, arelent *, Elf_Internal_Rela *);
1742
1743 extern bfd_boolean bfd_section_from_shdr
1744   (bfd *, unsigned int shindex);
1745 extern bfd_boolean bfd_section_from_phdr
1746   (bfd *, Elf_Internal_Phdr *, int);
1747
1748 extern int _bfd_elf_symbol_from_bfd_symbol
1749   (bfd *, asymbol **);
1750
1751 extern asection *bfd_section_from_r_symndx
1752   (bfd *, struct sym_sec_cache *, asection *, unsigned long);
1753 extern asection *bfd_section_from_elf_index
1754   (bfd *, unsigned int);
1755 extern struct bfd_strtab_hash *_bfd_elf_stringtab_init
1756   (void);
1757
1758 extern struct elf_strtab_hash * _bfd_elf_strtab_init
1759   (void);
1760 extern void _bfd_elf_strtab_free
1761   (struct elf_strtab_hash *);
1762 extern bfd_size_type _bfd_elf_strtab_add
1763   (struct elf_strtab_hash *, const char *, bfd_boolean);
1764 extern void _bfd_elf_strtab_addref
1765   (struct elf_strtab_hash *, bfd_size_type);
1766 extern void _bfd_elf_strtab_delref
1767   (struct elf_strtab_hash *, bfd_size_type);
1768 extern void _bfd_elf_strtab_clear_all_refs
1769   (struct elf_strtab_hash *);
1770 extern bfd_size_type _bfd_elf_strtab_size
1771   (struct elf_strtab_hash *);
1772 extern bfd_size_type _bfd_elf_strtab_offset
1773   (struct elf_strtab_hash *, bfd_size_type);
1774 extern bfd_boolean _bfd_elf_strtab_emit
1775   (bfd *, struct elf_strtab_hash *);
1776 extern void _bfd_elf_strtab_finalize
1777   (struct elf_strtab_hash *);
1778
1779 extern void _bfd_elf_begin_eh_frame_parsing
1780   (struct bfd_link_info *info);
1781 extern void _bfd_elf_parse_eh_frame
1782   (bfd *, struct bfd_link_info *, asection *, struct elf_reloc_cookie *);
1783 extern void _bfd_elf_end_eh_frame_parsing
1784   (struct bfd_link_info *info);
1785
1786 extern bfd_boolean _bfd_elf_discard_section_eh_frame
1787   (bfd *, struct bfd_link_info *, asection *,
1788    bfd_boolean (*) (bfd_vma, void *), struct elf_reloc_cookie *);
1789 extern bfd_boolean _bfd_elf_discard_section_eh_frame_hdr
1790   (bfd *, struct bfd_link_info *);
1791 extern bfd_vma _bfd_elf_eh_frame_section_offset
1792   (bfd *, struct bfd_link_info *, asection *, bfd_vma);
1793 extern bfd_boolean _bfd_elf_write_section_eh_frame
1794   (bfd *, struct bfd_link_info *, asection *, bfd_byte *);
1795 extern bfd_boolean _bfd_elf_write_section_eh_frame_hdr
1796   (bfd *, struct bfd_link_info *);
1797 extern bfd_boolean _bfd_elf_maybe_strip_eh_frame_hdr
1798   (struct bfd_link_info *);
1799
1800 extern bfd_boolean _bfd_elf_merge_symbol
1801   (bfd *, struct bfd_link_info *, const char *, Elf_Internal_Sym *,
1802    asection **, bfd_vma *, unsigned int *,
1803    struct elf_link_hash_entry **, bfd_boolean *,
1804    bfd_boolean *, bfd_boolean *, bfd_boolean *);
1805
1806 extern bfd_boolean _bfd_elf_hash_symbol (struct elf_link_hash_entry *);
1807
1808 extern bfd_boolean _bfd_elf_add_default_symbol
1809   (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
1810    const char *, Elf_Internal_Sym *, asection **, bfd_vma *,
1811    bfd_boolean *, bfd_boolean);
1812
1813 extern bfd_boolean _bfd_elf_export_symbol
1814   (struct elf_link_hash_entry *, void *);
1815
1816 extern bfd_boolean _bfd_elf_link_find_version_dependencies
1817   (struct elf_link_hash_entry *, void *);
1818
1819 extern bfd_boolean _bfd_elf_link_assign_sym_version
1820   (struct elf_link_hash_entry *, void *);
1821
1822 extern long _bfd_elf_link_lookup_local_dynindx
1823   (struct bfd_link_info *, bfd *, long);
1824 extern bfd_boolean _bfd_elf_compute_section_file_positions
1825   (bfd *, struct bfd_link_info *);
1826 extern void _bfd_elf_assign_file_positions_for_relocs
1827   (bfd *);
1828 extern file_ptr _bfd_elf_assign_file_position_for_section
1829   (Elf_Internal_Shdr *, file_ptr, bfd_boolean);
1830
1831 extern bfd_boolean _bfd_elf_validate_reloc
1832   (bfd *, arelent *);
1833
1834 extern bfd_boolean _bfd_elf_link_create_dynamic_sections
1835   (bfd *, struct bfd_link_info *);
1836 extern bfd_boolean _bfd_elf_link_omit_section_dynsym
1837   (bfd *, struct bfd_link_info *, asection *);
1838 extern bfd_boolean _bfd_elf_create_dynamic_sections
1839   (bfd *, struct bfd_link_info *);
1840 extern bfd_boolean _bfd_elf_create_got_section
1841   (bfd *, struct bfd_link_info *);
1842 extern struct elf_link_hash_entry *_bfd_elf_define_linkage_sym
1843   (bfd *, struct bfd_link_info *, asection *, const char *);
1844 extern void _bfd_elf_init_1_index_section
1845   (bfd *, struct bfd_link_info *);
1846 extern void _bfd_elf_init_2_index_sections
1847   (bfd *, struct bfd_link_info *);
1848
1849 extern bfd_boolean _bfd_elfcore_make_pseudosection
1850   (bfd *, char *, size_t, ufile_ptr);
1851 extern char *_bfd_elfcore_strndup
1852   (bfd *, char *, size_t);
1853
1854 extern Elf_Internal_Rela *_bfd_elf_link_read_relocs
1855   (bfd *, asection *, void *, Elf_Internal_Rela *, bfd_boolean);
1856
1857 extern bfd_boolean _bfd_elf_link_size_reloc_section
1858   (bfd *, Elf_Internal_Shdr *, asection *);
1859
1860 extern bfd_boolean _bfd_elf_link_output_relocs
1861   (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *,
1862    struct elf_link_hash_entry **);
1863
1864 extern bfd_boolean _bfd_elf_fix_symbol_flags
1865   (struct elf_link_hash_entry *, struct elf_info_failed *);
1866
1867 extern bfd_boolean _bfd_elf_adjust_dynamic_symbol
1868   (struct elf_link_hash_entry *, void *);
1869
1870 extern bfd_boolean _bfd_elf_adjust_dynamic_copy
1871   (struct elf_link_hash_entry *, asection *);
1872
1873 extern bfd_boolean _bfd_elf_link_sec_merge_syms
1874   (struct elf_link_hash_entry *, void *);
1875
1876 extern bfd_boolean _bfd_elf_dynamic_symbol_p
1877   (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1878
1879 extern bfd_boolean _bfd_elf_symbol_refs_local_p
1880   (struct elf_link_hash_entry *, struct bfd_link_info *, bfd_boolean);
1881
1882 extern bfd_reloc_status_type bfd_elf_perform_complex_relocation
1883   (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma);
1884
1885 extern bfd_boolean _bfd_elf_setup_sections
1886   (bfd *);
1887
1888 extern void _bfd_elf_set_osabi (bfd * , struct bfd_link_info *);
1889
1890 extern const bfd_target *bfd_elf32_object_p
1891   (bfd *);
1892 extern const bfd_target *bfd_elf32_core_file_p
1893   (bfd *);
1894 extern char *bfd_elf32_core_file_failing_command
1895   (bfd *);
1896 extern int bfd_elf32_core_file_failing_signal
1897   (bfd *);
1898 extern bfd_boolean bfd_elf32_core_file_matches_executable_p
1899   (bfd *, bfd *);
1900
1901 extern bfd_boolean bfd_elf32_swap_symbol_in
1902   (bfd *, const void *, const void *, Elf_Internal_Sym *);
1903 extern void bfd_elf32_swap_symbol_out
1904   (bfd *, const Elf_Internal_Sym *, void *, void *);
1905 extern void bfd_elf32_swap_reloc_in
1906   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1907 extern void bfd_elf32_swap_reloc_out
1908   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1909 extern void bfd_elf32_swap_reloca_in
1910   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1911 extern void bfd_elf32_swap_reloca_out
1912   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1913 extern void bfd_elf32_swap_phdr_in
1914   (bfd *, const Elf32_External_Phdr *, Elf_Internal_Phdr *);
1915 extern void bfd_elf32_swap_phdr_out
1916   (bfd *, const Elf_Internal_Phdr *, Elf32_External_Phdr *);
1917 extern void bfd_elf32_swap_dyn_in
1918   (bfd *, const void *, Elf_Internal_Dyn *);
1919 extern void bfd_elf32_swap_dyn_out
1920   (bfd *, const Elf_Internal_Dyn *, void *);
1921 extern long bfd_elf32_slurp_symbol_table
1922   (bfd *, asymbol **, bfd_boolean);
1923 extern bfd_boolean bfd_elf32_write_shdrs_and_ehdr
1924   (bfd *);
1925 extern int bfd_elf32_write_out_phdrs
1926   (bfd *, const Elf_Internal_Phdr *, unsigned int);
1927 extern bfd_boolean bfd_elf32_checksum_contents
1928   (bfd * , void (*) (const void *, size_t, void *), void *);
1929 extern void bfd_elf32_write_relocs
1930   (bfd *, asection *, void *);
1931 extern bfd_boolean bfd_elf32_slurp_reloc_table
1932   (bfd *, asection *, asymbol **, bfd_boolean);
1933
1934 extern const bfd_target *bfd_elf64_object_p
1935   (bfd *);
1936 extern const bfd_target *bfd_elf64_core_file_p
1937   (bfd *);
1938 extern char *bfd_elf64_core_file_failing_command
1939   (bfd *);
1940 extern int bfd_elf64_core_file_failing_signal
1941   (bfd *);
1942 extern bfd_boolean bfd_elf64_core_file_matches_executable_p
1943   (bfd *, bfd *);
1944
1945 extern bfd_boolean bfd_elf64_swap_symbol_in
1946   (bfd *, const void *, const void *, Elf_Internal_Sym *);
1947 extern void bfd_elf64_swap_symbol_out
1948   (bfd *, const Elf_Internal_Sym *, void *, void *);
1949 extern void bfd_elf64_swap_reloc_in
1950   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1951 extern void bfd_elf64_swap_reloc_out
1952   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1953 extern void bfd_elf64_swap_reloca_in
1954   (bfd *, const bfd_byte *, Elf_Internal_Rela *);
1955 extern void bfd_elf64_swap_reloca_out
1956   (bfd *, const Elf_Internal_Rela *, bfd_byte *);
1957 extern void bfd_elf64_swap_phdr_in
1958   (bfd *, const Elf64_External_Phdr *, Elf_Internal_Phdr *);
1959 extern void bfd_elf64_swap_phdr_out
1960   (bfd *, const Elf_Internal_Phdr *, Elf64_External_Phdr *);
1961 extern void bfd_elf64_swap_dyn_in
1962   (bfd *, const void *, Elf_Internal_Dyn *);
1963 extern void bfd_elf64_swap_dyn_out
1964   (bfd *, const Elf_Internal_Dyn *, void *);
1965 extern long bfd_elf64_slurp_symbol_table
1966   (bfd *, asymbol **, bfd_boolean);
1967 extern bfd_boolean bfd_elf64_write_shdrs_and_ehdr
1968   (bfd *);
1969 extern int bfd_elf64_write_out_phdrs
1970   (bfd *, const Elf_Internal_Phdr *, unsigned int);
1971 extern bfd_boolean bfd_elf64_checksum_contents
1972   (bfd * , void (*) (const void *, size_t, void *), void *);
1973 extern void bfd_elf64_write_relocs
1974   (bfd *, asection *, void *);
1975 extern bfd_boolean bfd_elf64_slurp_reloc_table
1976   (bfd *, asection *, asymbol **, bfd_boolean);
1977
1978 extern bfd_boolean _bfd_elf_default_relocs_compatible
1979   (const bfd_target *, const bfd_target *);
1980
1981 extern bfd_boolean _bfd_elf_relocs_compatible
1982   (const bfd_target *, const bfd_target *);
1983
1984 extern struct elf_link_hash_entry *_bfd_elf_archive_symbol_lookup
1985   (bfd *, struct bfd_link_info *, const char *);
1986 extern bfd_boolean bfd_elf_link_add_symbols
1987   (bfd *, struct bfd_link_info *);
1988 extern bfd_boolean _bfd_elf_add_dynamic_entry
1989   (struct bfd_link_info *, bfd_vma, bfd_vma);
1990
1991 extern bfd_boolean bfd_elf_link_record_dynamic_symbol
1992   (struct bfd_link_info *, struct elf_link_hash_entry *);
1993
1994 extern int bfd_elf_link_record_local_dynamic_symbol
1995   (struct bfd_link_info *, bfd *, long);
1996
1997 extern void bfd_elf_link_mark_dynamic_symbol
1998   (struct bfd_link_info *, struct elf_link_hash_entry *,
1999    Elf_Internal_Sym *);
2000
2001 extern bfd_boolean _bfd_elf_close_and_cleanup
2002   (bfd *);
2003
2004 extern bfd_boolean _bfd_elf_common_definition
2005   (Elf_Internal_Sym *);
2006
2007 extern unsigned int _bfd_elf_common_section_index
2008   (asection *);
2009
2010 extern asection *_bfd_elf_common_section
2011   (asection *);
2012
2013 extern void _bfd_dwarf2_cleanup_debug_info
2014   (bfd *);
2015
2016 extern bfd_reloc_status_type _bfd_elf_rel_vtable_reloc_fn
2017   (bfd *, arelent *, struct bfd_symbol *, void *,
2018    asection *, bfd *, char **);
2019
2020 extern bfd_boolean bfd_elf_final_link
2021   (bfd *, struct bfd_link_info *);
2022
2023 extern bfd_boolean bfd_elf_gc_mark_dynamic_ref_symbol
2024   (struct elf_link_hash_entry *h, void *inf);
2025
2026 extern bfd_boolean bfd_elf_gc_sections
2027   (bfd *, struct bfd_link_info *);
2028
2029 extern bfd_boolean bfd_elf_gc_record_vtinherit
2030   (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
2031
2032 extern bfd_boolean bfd_elf_gc_record_vtentry
2033   (bfd *, asection *, struct elf_link_hash_entry *, bfd_vma);
2034
2035 extern asection *_bfd_elf_gc_mark_hook
2036   (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
2037    struct elf_link_hash_entry *, Elf_Internal_Sym *);
2038
2039 extern asection *_bfd_elf_gc_mark_rsec
2040   (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn,
2041    struct elf_reloc_cookie *);
2042
2043 extern bfd_boolean _bfd_elf_gc_mark_reloc
2044   (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn,
2045    struct elf_reloc_cookie *);
2046
2047 extern bfd_boolean _bfd_elf_gc_mark_fdes
2048   (struct bfd_link_info *, asection *, asection *, elf_gc_mark_hook_fn,
2049    struct elf_reloc_cookie *);
2050
2051 extern bfd_boolean _bfd_elf_gc_mark
2052   (struct bfd_link_info *, asection *, elf_gc_mark_hook_fn);
2053
2054 extern bfd_boolean bfd_elf_gc_common_finalize_got_offsets
2055   (bfd *, struct bfd_link_info *);
2056
2057 extern bfd_boolean bfd_elf_gc_common_final_link
2058   (bfd *, struct bfd_link_info *);
2059
2060 extern bfd_boolean bfd_elf_reloc_symbol_deleted_p
2061   (bfd_vma, void *);
2062
2063 extern struct elf_segment_map * _bfd_elf_make_dynamic_segment
2064   (bfd *, asection *);
2065
2066 extern bfd_boolean _bfd_elf_map_sections_to_segments
2067   (bfd *, struct bfd_link_info *);
2068
2069 extern bfd_boolean _bfd_elf_is_function_type (unsigned int);
2070
2071 /* Exported interface for writing elf corefile notes. */
2072 extern char *elfcore_write_note
2073   (bfd *, char *, int *, const char *, int, const void *, int);
2074 extern char *elfcore_write_prpsinfo
2075   (bfd *, char *, int *, const char *, const char *);
2076 extern char *elfcore_write_prstatus
2077   (bfd *, char *, int *, long, int, const void *);
2078 extern char * elfcore_write_pstatus
2079   (bfd *, char *, int *, long, int, const void *);
2080 extern char *elfcore_write_prfpreg
2081   (bfd *, char *, int *, const void *, int);
2082 extern char *elfcore_write_prxfpreg
2083   (bfd *, char *, int *, const void *, int);
2084 extern char *elfcore_write_ppc_vmx
2085   (bfd *, char *, int *, const void *, int);
2086 extern char *elfcore_write_lwpstatus
2087   (bfd *, char *, int *, long, int, const void *);
2088
2089 extern bfd *_bfd_elf32_bfd_from_remote_memory
2090   (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
2091    int (*target_read_memory) (bfd_vma, bfd_byte *, int));
2092 extern bfd *_bfd_elf64_bfd_from_remote_memory
2093   (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
2094    int (*target_read_memory) (bfd_vma, bfd_byte *, int));
2095
2096 extern bfd_vma bfd_elf_obj_attr_size (bfd *);
2097 extern void bfd_elf_set_obj_attr_contents (bfd *, bfd_byte *, bfd_vma);
2098 extern int bfd_elf_get_obj_attr_int (bfd *, int, int);
2099 extern void bfd_elf_add_obj_attr_int (bfd *, int, int, unsigned int);
2100 #define bfd_elf_add_proc_attr_int(BFD, TAG, VALUE) \
2101   bfd_elf_add_obj_attr_int ((BFD), OBJ_ATTR_PROC, (TAG), (VALUE))
2102 extern void bfd_elf_add_obj_attr_string (bfd *, int, int, const char *);
2103 #define bfd_elf_add_proc_attr_string(BFD, TAG, VALUE) \
2104   bfd_elf_add_obj_attr_string ((BFD), OBJ_ATTR_PROC, (TAG), (VALUE))
2105 extern void bfd_elf_add_obj_attr_compat (bfd *, int, unsigned int,
2106                                          const char *);
2107 #define bfd_elf_add_proc_attr_compat(BFD, INTVAL, STRVAL) \
2108   bfd_elf_add_obj_attr_compat ((BFD), OBJ_ATTR_PROC, (INTVAL), (STRVAL))
2109
2110 extern char *_bfd_elf_attr_strdup (bfd *, const char *);
2111 extern void _bfd_elf_copy_obj_attributes (bfd *, bfd *);
2112 extern int _bfd_elf_obj_attrs_arg_type (bfd *, int, int);
2113 extern void _bfd_elf_parse_attributes (bfd *, Elf_Internal_Shdr *);
2114 extern bfd_boolean _bfd_elf_merge_object_attributes (bfd *, bfd *);
2115
2116 /* Large common section.  */
2117 extern asection _bfd_elf_large_com_section;
2118
2119 /* SH ELF specific routine.  */
2120
2121 extern bfd_boolean _sh_elf_set_mach_from_flags
2122   (bfd *);
2123
2124 /* This is the condition under which finish_dynamic_symbol will be called.
2125    If our finish_dynamic_symbol isn't called, we'll need to do something
2126    about initializing any .plt and .got entries in relocate_section.  */
2127 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
2128   ((DYN)                                                                \
2129    && ((SHARED) || !(H)->forced_local)                                  \
2130    && ((H)->dynindx != -1 || (H)->forced_local))
2131
2132 /* This macro is to avoid lots of duplicated code in the body
2133    of xxx_relocate_section() in the various elfxx-xxxx.c files.  */
2134 #define RELOC_FOR_GLOBAL_SYMBOL(info, input_bfd, input_section, rel,    \
2135                                 r_symndx, symtab_hdr, sym_hashes,       \
2136                                 h, sec, relocation,                     \
2137                                 unresolved_reloc, warned)               \
2138   do                                                                    \
2139     {                                                                   \
2140       /* It seems this can happen with erroneous or unsupported         \
2141          input (mixing a.out and elf in an archive, for example.)  */   \
2142       if (sym_hashes == NULL)                                           \
2143         return FALSE;                                                   \
2144                                                                         \
2145       h = sym_hashes[r_symndx - symtab_hdr->sh_info];                   \
2146                                                                         \
2147       while (h->root.type == bfd_link_hash_indirect                     \
2148              || h->root.type == bfd_link_hash_warning)                  \
2149         h = (struct elf_link_hash_entry *) h->root.u.i.link;            \
2150                                                                         \
2151       warned = FALSE;                                                   \
2152       unresolved_reloc = FALSE;                                         \
2153       relocation = 0;                                                   \
2154       if (h->root.type == bfd_link_hash_defined                         \
2155           || h->root.type == bfd_link_hash_defweak)                     \
2156         {                                                               \
2157           sec = h->root.u.def.section;                                  \
2158           if (sec == NULL                                               \
2159               || sec->output_section == NULL)                           \
2160             /* Set a flag that will be cleared later if we find a       \
2161                relocation value for this symbol.  output_section        \
2162                is typically NULL for symbols satisfied by a shared      \
2163                library.  */                                             \
2164             unresolved_reloc = TRUE;                                    \
2165           else                                                          \
2166             relocation = (h->root.u.def.value                           \
2167                           + sec->output_section->vma                    \
2168                           + sec->output_offset);                        \
2169         }                                                               \
2170       else if (h->root.type == bfd_link_hash_undefweak)                 \
2171         ;                                                               \
2172       else if (info->unresolved_syms_in_objects == RM_IGNORE            \
2173                && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)          \
2174         ;                                                               \
2175       else if (!info->relocatable)                                      \
2176         {                                                               \
2177           bfd_boolean err;                                              \
2178           err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR  \
2179                  || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);       \
2180           if (!info->callbacks->undefined_symbol (info,                 \
2181                                                   h->root.root.string,  \
2182                                                   input_bfd,            \
2183                                                   input_section,        \
2184                                                   rel->r_offset, err))  \
2185             return FALSE;                                               \
2186           warned = TRUE;                                                \
2187         }                                                               \
2188     }                                                                   \
2189   while (0)
2190
2191 /* Will a symbol be bound to the the definition within the shared
2192    library, if any.  */
2193 #define SYMBOLIC_BIND(INFO, H) \
2194     ((INFO)->symbolic || ((INFO)->dynamic && !(H)->dynamic))
2195
2196 #endif /* _LIBELF_H_ */