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