bfd/elf-bfd.h

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