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