bfd/bfd-in2.h

   1 /* Main header file for the bfd library -- portable access to object files.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 ** NOTE: bfd.h and bfd-in2.h are GENERATED files.  Don't change them;
   6 ** instead, change bfd-in.h or the other BFD source files processed to
   7 ** generate these files.
   8
   9 This file is part of BFD, the Binary File Descriptor library.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  24
  25 /* bfd.h -- The only header file required by users of the bfd library
  26
  27 The bfd.h file is generated from bfd-in.h and various .c files; if you
  28 change it, your changes will probably be lost.
  29
  30 All the prototypes and definitions following the comment "THE FOLLOWING
  31 IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
  32 BFD.  If you change it, someone oneday will extract it from the source
  33 again, and your changes will be lost.  To save yourself from this bind,
  34 change the definitions in the source in the bfd directory.  Type "make
  35 docs" and then "make headers" in that directory, and magically this file
  36 will change to reflect your changes.
  37
  38 If you don't have the tools to perform the extraction, then you are
  39 safe from someone on your system trampling over your header files.
  40 You should still maintain the equivalence between the source and this
  41 file though; every change you make to the .c file should be reflected
  42 here.  */
  43
  44 #ifndef __BFD_H_SEEN__
  45 #define __BFD_H_SEEN__
  46
  47 #ifdef __cplusplus
  48 extern "C" {
  49 #endif
  50
  51 #include "ansidecl.h"
  52 #include "obstack.h"
  53
  54 /* These two lines get substitutions done by commands in Makefile.in.  */
  55 #define BFD_VERSION  "@VERSION@"
  56 #define BFD_ARCH_SIZE @wordsize@
  57 #define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@
  58 #if @BFD_HOST_64_BIT_DEFINED@
  59 #define BFD_HOST_64_BIT @BFD_HOST_64_BIT@
  60 #define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@
  61 #endif
  62
  63 #if BFD_ARCH_SIZE >= 64
  64 #define BFD64
  65 #endif
  66
  67 #ifndef INLINE
  68 #if __GNUC__ >= 2
  69 #define INLINE __inline__
  70 #else
  71 #define INLINE
  72 #endif
  73 #endif
  74
  75 /* forward declaration */
  76 typedef struct _bfd bfd;
  77
  78 /* To squelch erroneous compiler warnings ("illegal pointer
  79    combination") from the SVR3 compiler, we would like to typedef
  80    boolean to int (it doesn't like functions which return boolean.
  81    Making sure they are never implicitly declared to return int
  82    doesn't seem to help).  But this file is not configured based on
  83    the host.  */
  84 /* General rules: functions which are boolean return true on success
  85    and false on failure (unless they're a predicate).   -- bfd.doc */
  86 /* I'm sure this is going to break something and someone is going to
  87    force me to change it. */
  88 /* typedef enum boolean {false, true} boolean; */
  89 /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h>  -fnf */
  90 /* It gets worse if the host also defines a true/false enum... -sts */
  91 /* And even worse if your compiler has built-in boolean types... -law */
  92 #if defined (__GNUG__) && (__GNUC_MINOR__ > 5)
  93 #define TRUE_FALSE_ALREADY_DEFINED
  94 #endif
  95 #ifdef MPW
  96 /* Pre-emptive strike - get the file with the enum. */
  97 #include <Types.h>
  98 #define TRUE_FALSE_ALREADY_DEFINED
  99 #endif /* MPW */
 100 #ifndef TRUE_FALSE_ALREADY_DEFINED
 101 typedef enum bfd_boolean {false, true} boolean;
 102 #define BFD_TRUE_FALSE
 103 #else
 104 /* Use enum names that will appear nowhere else.  */
 105 typedef enum bfd_boolean {bfd_fffalse, bfd_tttrue} boolean;
 106 #endif
 107
 108 /* A pointer to a position in a file.  */
 109 /* FIXME:  This should be using off_t from <sys/types.h>.
 110    For now, try to avoid breaking stuff by not including <sys/types.h> here.
 111    This will break on systems with 64-bit file offsets (e.g. 4.4BSD).
 112    Probably the best long-term answer is to avoid using file_ptr AND off_t
 113    in this header file, and to handle this in the BFD implementation
 114    rather than in its interface.  */
 115 /* typedef off_t        file_ptr; */
 116 typedef long int file_ptr;
 117
 118 /* Support for different sizes of target format ints and addresses.
 119    If the type `long' is at least 64 bits, BFD_HOST_64BIT_LONG will be
 120    set to 1 above.  Otherwise, if gcc is being used, this code will
 121    use gcc's "long long" type.  Otherwise, BFD_HOST_64_BIT must be
 122    defined above.  */
 123
 124 #ifdef BFD64
 125
 126 #ifndef BFD_HOST_64_BIT
 127 #if BFD_HOST_64BIT_LONG
 128 #define BFD_HOST_64_BIT long
 129 #define BFD_HOST_U_64_BIT unsigned long
 130 #else
 131 #ifdef __GNUC__
 132 #define BFD_HOST_64_BIT long long
 133 #define BFD_HOST_U_64_BIT unsigned long long
 134 #else /* ! defined (__GNUC__) */
 135  #error No 64 bit integer type available
 136 #endif /* ! defined (__GNUC__) */
 137 #endif /* ! BFD_HOST_64BIT_LONG */
 138 #endif /* ! defined (BFD_HOST_64_BIT) */
 139
 140 typedef BFD_HOST_U_64_BIT bfd_vma;
 141 typedef BFD_HOST_64_BIT bfd_signed_vma;
 142 typedef BFD_HOST_U_64_BIT bfd_size_type;
 143 typedef BFD_HOST_U_64_BIT symvalue;
 144
 145 #ifndef fprintf_vma
 146 #if BFD_HOST_64BIT_LONG
 147 #define sprintf_vma(s,x) sprintf (s, "%016lx", x)
 148 #define fprintf_vma(f,x) fprintf (f, "%016lx", x)
 149 #else
 150 #define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
 151 #define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
 152 #define fprintf_vma(s,x) \
 153   fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
 154 #define sprintf_vma(s,x) \
 155   sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
 156 #endif
 157 #endif
 158
 159 #else /* not BFD64  */
 160
 161 /* Represent a target address.  Also used as a generic unsigned type
 162    which is guaranteed to be big enough to hold any arithmetic types
 163    we need to deal with.  */
 164 typedef unsigned long bfd_vma;
 165
 166 /* A generic signed type which is guaranteed to be big enough to hold any
 167    arithmetic types we need to deal with.  Can be assumed to be compatible
 168    with bfd_vma in the same way that signed and unsigned ints are compatible
 169    (as parameters, in assignment, etc).  */
 170 typedef long bfd_signed_vma;
 171
 172 typedef unsigned long symvalue;
 173 typedef unsigned long bfd_size_type;
 174
 175 /* Print a bfd_vma x on stream s.  */
 176 #define fprintf_vma(s,x) fprintf(s, "%08lx", x)
 177 #define sprintf_vma(s,x) sprintf(s, "%08lx", x)
 178 #endif /* not BFD64  */
 179 #define printf_vma(x) fprintf_vma(stdout,x)
 180
 181 typedef unsigned int flagword;  /* 32 bits of flags */
 182 typedef unsigned char bfd_byte;
 183 \f
 184 /** File formats */
 185
 186 typedef enum bfd_format {
 187               bfd_unknown = 0,  /* file format is unknown */
 188               bfd_object,       /* linker/assember/compiler output */
 189               bfd_archive,      /* object archive file */
 190               bfd_core,         /* core dump */
 191               bfd_type_end}     /* marks the end; don't use it! */
 192          bfd_format;
 193
 194 /* Values that may appear in the flags field of a BFD.  These also
 195    appear in the object_flags field of the bfd_target structure, where
 196    they indicate the set of flags used by that backend (not all flags
 197    are meaningful for all object file formats) (FIXME: at the moment,
 198    the object_flags values have mostly just been copied from backend
 199    to another, and are not necessarily correct).  */
 200
 201 /* No flags.  */
 202 #define BFD_NO_FLAGS    0x00
 203
 204 /* BFD contains relocation entries.  */
 205 #define HAS_RELOC       0x01
 206
 207 /* BFD is directly executable.  */
 208 #define EXEC_P          0x02
 209
 210 /* BFD has line number information (basically used for F_LNNO in a
 211    COFF header).  */
 212 #define HAS_LINENO      0x04
 213
 214 /* BFD has debugging information.  */
 215 #define HAS_DEBUG       0x08
 216
 217 /* BFD has symbols.  */
 218 #define HAS_SYMS        0x10
 219
 220 /* BFD has local symbols (basically used for F_LSYMS in a COFF
 221    header).  */
 222 #define HAS_LOCALS      0x20
 223
 224 /* BFD is a dynamic object.  */
 225 #define DYNAMIC         0x40
 226
 227 /* Text section is write protected (if D_PAGED is not set, this is
 228    like an a.out NMAGIC file) (the linker sets this by default, but
 229    clears it for -r or -N).  */
 230 #define WP_TEXT         0x80
 231
 232 /* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 233    linker sets this by default, but clears it for -r or -n or -N).  */
 234 #define D_PAGED         0x100
 235
 236 /* BFD is relaxable (this means that bfd_relax_section may be able to
 237    do something) (sometimes bfd_relax_section can do something even if
 238    this is not set).  */
 239 #define BFD_IS_RELAXABLE 0x200
 240
 241 /* This may be set before writing out a BFD to request using a
 242    traditional format.  For example, this is used to request that when
 243    writing out an a.out object the symbols not be hashed to eliminate
 244    duplicates.  */
 245 #define BFD_TRADITIONAL_FORMAT 0x400
 246
 247 /* This flag indicates that the BFD contents are actually cached in
 248    memory.  If this is set, iostream points to a bfd_in_memory struct.  */
 249 #define BFD_IN_MEMORY 0x800
 250 \f
 251 /* symbols and relocation */
 252
 253 /* A count of carsyms (canonical archive symbols).  */
 254 typedef unsigned long symindex;
 255
 256 /* How to perform a relocation.  */
 257 typedef const struct reloc_howto_struct reloc_howto_type;
 258
 259 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
 260
 261 /* General purpose part of a symbol X;
 262    target specific parts are in libcoff.h, libaout.h, etc.  */
 263
 264 #define bfd_get_section(x) ((x)->section)
 265 #define bfd_get_output_section(x) ((x)->section->output_section)
 266 #define bfd_set_section(x,y) ((x)->section) = (y)
 267 #define bfd_asymbol_base(x) ((x)->section->vma)
 268 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
 269 #define bfd_asymbol_name(x) ((x)->name)
 270 /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
 271 #define bfd_asymbol_bfd(x) ((x)->the_bfd)
 272 #define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
 273
 274 /* A canonical archive symbol.  */
 275 /* This is a type pun with struct ranlib on purpose! */
 276 typedef struct carsym {
 277   char *name;
 278   file_ptr file_offset;         /* look here to find the file */
 279 } carsym;                       /* to make these you call a carsymogen */
 280
 281
 282 /* Used in generating armaps (archive tables of contents).
 283    Perhaps just a forward definition would do? */
 284 struct orl {                    /* output ranlib */
 285   char **name;                  /* symbol name */
 286   file_ptr pos;                 /* bfd* or file position */
 287   int namidx;                   /* index into string table */
 288 };
 289 \f
 290
 291 /* Linenumber stuff */
 292 typedef struct lineno_cache_entry {
 293   unsigned int line_number;     /* Linenumber from start of function*/
 294   union {
 295     struct symbol_cache_entry *sym; /* Function name */
 296     unsigned long offset;       /* Offset into section */
 297   } u;
 298 } alent;
 299 \f
 300 /* object and core file sections */
 301
 302 #define align_power(addr, align)        \
 303         ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
 304
 305 typedef struct sec *sec_ptr;
 306
 307 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
 308 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
 309 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
 310 #define bfd_section_name(bfd, ptr) ((ptr)->name)
 311 #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
 312 #define bfd_section_vma(bfd, ptr) ((ptr)->vma)
 313 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
 314 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
 315 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
 316
 317 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 318
 319 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = (boolean)true), true)
 320 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
 321 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
 322
 323 typedef struct stat stat_type;
 324 \f
 325 typedef enum bfd_print_symbol
 326 {
 327   bfd_print_symbol_name,
 328   bfd_print_symbol_more,
 329   bfd_print_symbol_all
 330 } bfd_print_symbol_type;
 331
 332 /* Information about a symbol that nm needs.  */
 333
 334 typedef struct _symbol_info
 335 {
 336   symvalue value;
 337   char type;
 338   CONST char *name;            /* Symbol name.  */
 339   unsigned char stab_type;     /* Stab type.  */
 340   char stab_other;             /* Stab other. */
 341   short stab_desc;             /* Stab desc.  */
 342   CONST char *stab_name;       /* String for stab type.  */
 343 } symbol_info;
 344
 345 /* Get the name of a stabs type code.  */
 346
 347 extern const char *bfd_get_stab_name PARAMS ((int));
 348 \f
 349 /* Hash table routines.  There is no way to free up a hash table.  */
 350
 351 /* An element in the hash table.  Most uses will actually use a larger
 352    structure, and an instance of this will be the first field.  */
 353
 354 struct bfd_hash_entry
 355 {
 356   /* Next entry for this hash code.  */
 357   struct bfd_hash_entry *next;
 358   /* String being hashed.  */
 359   const char *string;
 360   /* Hash code.  This is the full hash code, not the index into the
 361      table.  */
 362   unsigned long hash;
 363 };
 364
 365 /* A hash table.  */
 366
 367 struct bfd_hash_table
 368 {
 369   /* The hash array.  */
 370   struct bfd_hash_entry **table;
 371   /* The number of slots in the hash table.  */
 372   unsigned int size;
 373   /* A function used to create new elements in the hash table.  The
 374      first entry is itself a pointer to an element.  When this
 375      function is first invoked, this pointer will be NULL.  However,
 376      having the pointer permits a hierarchy of method functions to be
 377      built each of which calls the function in the superclass.  Thus
 378      each function should be written to allocate a new block of memory
 379      only if the argument is NULL.  */
 380   struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 381                                              struct bfd_hash_table *,
 382                                              const char *));
 383   /* An obstack for this hash table.  */
 384   struct obstack memory;
 385 };
 386
 387 /* Initialize a hash table.  */
 388 extern boolean bfd_hash_table_init
 389   PARAMS ((struct bfd_hash_table *,
 390            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 391                                        struct bfd_hash_table *,
 392                                        const char *)));
 393
 394 /* Initialize a hash table specifying a size.  */
 395 extern boolean bfd_hash_table_init_n
 396   PARAMS ((struct bfd_hash_table *,
 397            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 398                                        struct bfd_hash_table *,
 399                                        const char *),
 400            unsigned int size));
 401
 402 /* Free up a hash table.  */
 403 extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *));
 404
 405 /* Look up a string in a hash table.  If CREATE is true, a new entry
 406    will be created for this string if one does not already exist.  The
 407    COPY argument must be true if this routine should copy the string
 408    into newly allocated memory when adding an entry.  */
 409 extern struct bfd_hash_entry *bfd_hash_lookup
 410   PARAMS ((struct bfd_hash_table *, const char *, boolean create,
 411            boolean copy));
 412
 413 /* Replace an entry in a hash table.  */
 414 extern void bfd_hash_replace
 415   PARAMS ((struct bfd_hash_table *, struct bfd_hash_entry *old,
 416            struct bfd_hash_entry *nw));
 417
 418 /* Base method for creating a hash table entry.  */
 419 extern struct bfd_hash_entry *bfd_hash_newfunc
 420   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
 421            const char *));
 422
 423 /* Grab some space for a hash table entry.  */
 424 extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *,
 425                                       unsigned int));
 426
 427 /* Traverse a hash table in a random order, calling a function on each
 428    element.  If the function returns false, the traversal stops.  The
 429    INFO argument is passed to the function.  */
 430 extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *,
 431                                        boolean (*) (struct bfd_hash_entry *,
 432                                                     PTR),
 433                                        PTR info));
 434 \f
 435 /* Semi-portable string concatenation in cpp.
 436    The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors.
 437    The problem is, "32_" is not a valid preprocessing token, and we don't
 438    want extra underscores (e.g., "nlm_32_").  The XCAT2 macro will cause the
 439    inner CAT macros to be evaluated first, producing still-valid pp-tokens.
 440    Then the final concatenation can be done.  (Sigh.)  */
 441 #ifndef CAT
 442 #ifdef SABER
 443 #define CAT(a,b)        a##b
 444 #define CAT3(a,b,c)     a##b##c
 445 #define CAT4(a,b,c,d)   a##b##c##d
 446 #else
 447 #if defined(__STDC__) || defined(ALMOST_STDC)
 448 #define CAT(a,b) a##b
 449 #define CAT3(a,b,c) a##b##c
 450 #define XCAT2(a,b)      CAT(a,b)
 451 #define CAT4(a,b,c,d)   XCAT2(CAT(a,b),CAT(c,d))
 452 #else
 453 #define CAT(a,b) a/**/b
 454 #define CAT3(a,b,c) a/**/b/**/c
 455 #define CAT4(a,b,c,d)   a/**/b/**/c/**/d
 456 #endif
 457 #endif
 458 #endif
 459
 460 #define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table
 461 \f
 462 /* User program access to BFD facilities */
 463
 464 /* Direct I/O routines, for programs which know more about the object
 465    file than BFD does.  Use higher level routines if possible.  */
 466
 467 extern bfd_size_type bfd_read
 468   PARAMS ((PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
 469 extern bfd_size_type bfd_write
 470   PARAMS ((const PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
 471 extern int bfd_seek PARAMS ((bfd *abfd, file_ptr fp, int direction));
 472 extern long bfd_tell PARAMS ((bfd *abfd));
 473 extern int bfd_flush PARAMS ((bfd *abfd));
 474 extern int bfd_stat PARAMS ((bfd *abfd, struct stat *));
 475
 476
 477 /* Cast from const char * to char * so that caller can assign to
 478    a char * without a warning.  */
 479 #define bfd_get_filename(abfd) ((char *) (abfd)->filename)
 480 #define bfd_get_cacheable(abfd) ((abfd)->cacheable)
 481 #define bfd_get_format(abfd) ((abfd)->format)
 482 #define bfd_get_target(abfd) ((abfd)->xvec->name)
 483 #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
 484 #define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
 485 #define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
 486 #define bfd_header_big_endian(abfd) \
 487   ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
 488 #define bfd_header_little_endian(abfd) \
 489   ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
 490 #define bfd_get_file_flags(abfd) ((abfd)->flags)
 491 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
 492 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
 493 #define bfd_my_archive(abfd) ((abfd)->my_archive)
 494 #define bfd_has_map(abfd) ((abfd)->has_armap)
 495
 496 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
 497 #define bfd_usrdata(abfd) ((abfd)->usrdata)
 498
 499 #define bfd_get_start_address(abfd) ((abfd)->start_address)
 500 #define bfd_get_symcount(abfd) ((abfd)->symcount)
 501 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
 502 #define bfd_count_sections(abfd) ((abfd)->section_count)
 503
 504 #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
 505
 506 #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (boolean)(bool)), true)
 507
 508 extern boolean bfd_record_phdr
 509   PARAMS ((bfd *, unsigned long, boolean, flagword, boolean, bfd_vma,
 510            boolean, boolean, unsigned int, struct sec **));
 511
 512 /* Byte swapping routines.  */
 513
 514 bfd_vma         bfd_getb64         PARAMS ((const unsigned char *));
 515 bfd_vma         bfd_getl64         PARAMS ((const unsigned char *));
 516 bfd_signed_vma  bfd_getb_signed_64 PARAMS ((const unsigned char *));
 517 bfd_signed_vma  bfd_getl_signed_64 PARAMS ((const unsigned char *));
 518 bfd_vma         bfd_getb32         PARAMS ((const unsigned char *));
 519 bfd_vma         bfd_getl32         PARAMS ((const unsigned char *));
 520 bfd_signed_vma  bfd_getb_signed_32 PARAMS ((const unsigned char *));
 521 bfd_signed_vma  bfd_getl_signed_32 PARAMS ((const unsigned char *));
 522 bfd_vma         bfd_getb16         PARAMS ((const unsigned char *));
 523 bfd_vma         bfd_getl16         PARAMS ((const unsigned char *));
 524 bfd_signed_vma  bfd_getb_signed_16 PARAMS ((const unsigned char *));
 525 bfd_signed_vma  bfd_getl_signed_16 PARAMS ((const unsigned char *));
 526 void            bfd_putb64         PARAMS ((bfd_vma, unsigned char *));
 527 void            bfd_putl64         PARAMS ((bfd_vma, unsigned char *));
 528 void            bfd_putb32         PARAMS ((bfd_vma, unsigned char *));
 529 void            bfd_putl32         PARAMS ((bfd_vma, unsigned char *));
 530 void            bfd_putb16         PARAMS ((bfd_vma, unsigned char *));
 531 void            bfd_putl16         PARAMS ((bfd_vma, unsigned char *));
 532 \f
 533 /* Externally visible ECOFF routines.  */
 534
 535 #if defined(__STDC__) || defined(ALMOST_STDC)
 536 struct ecoff_debug_info;
 537 struct ecoff_debug_swap;
 538 struct ecoff_extr;
 539 struct symbol_cache_entry;
 540 struct bfd_link_info;
 541 struct bfd_link_hash_entry;
 542 #endif
 543 extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd));
 544 extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value));
 545 extern boolean bfd_ecoff_set_regmasks
 546   PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask,
 547            unsigned long *cprmask));
 548 extern PTR bfd_ecoff_debug_init
 549   PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug,
 550            const struct ecoff_debug_swap *output_swap,
 551            struct bfd_link_info *));
 552 extern void bfd_ecoff_debug_free
 553   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 554            const struct ecoff_debug_swap *output_swap,
 555            struct bfd_link_info *));
 556 extern boolean bfd_ecoff_debug_accumulate
 557   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 558            const struct ecoff_debug_swap *output_swap,
 559            bfd *input_bfd, struct ecoff_debug_info *input_debug,
 560            const struct ecoff_debug_swap *input_swap,
 561            struct bfd_link_info *));
 562 extern boolean bfd_ecoff_debug_accumulate_other
 563   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 564            const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
 565            struct bfd_link_info *));
 566 extern boolean bfd_ecoff_debug_externals
 567   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 568            const struct ecoff_debug_swap *swap,
 569            boolean relocateable,
 570            boolean (*get_extr) (struct symbol_cache_entry *,
 571                                 struct ecoff_extr *),
 572            void (*set_index) (struct symbol_cache_entry *,
 573                               bfd_size_type)));
 574 extern boolean bfd_ecoff_debug_one_external
 575   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 576            const struct ecoff_debug_swap *swap,
 577            const char *name, struct ecoff_extr *esym));
 578 extern bfd_size_type bfd_ecoff_debug_size
 579   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 580            const struct ecoff_debug_swap *swap));
 581 extern boolean bfd_ecoff_write_debug
 582   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 583            const struct ecoff_debug_swap *swap, file_ptr where));
 584 extern boolean bfd_ecoff_write_accumulated_debug
 585   PARAMS ((PTR handle, bfd *abfd, struct ecoff_debug_info *debug,
 586            const struct ecoff_debug_swap *swap,
 587            struct bfd_link_info *info, file_ptr where));
 588 extern boolean bfd_mips_ecoff_create_embedded_relocs
 589   PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *,
 590            char **));
 591
 592 /* Externally visible ELF routines.  */
 593
 594 struct bfd_link_needed_list
 595 {
 596   struct bfd_link_needed_list *next;
 597   bfd *by;
 598   const char *name;
 599 };
 600
 601 extern boolean bfd_elf32_record_link_assignment
 602   PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean));
 603 extern boolean bfd_elf64_record_link_assignment
 604   PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean));
 605 extern struct bfd_link_needed_list *bfd_elf_get_needed_list
 606   PARAMS ((bfd *, struct bfd_link_info *));
 607 extern boolean bfd_elf32_size_dynamic_sections
 608   PARAMS ((bfd *, const char *, const char *, boolean, const char *,
 609            const char * const *, struct bfd_link_info *, struct sec **));
 610 extern boolean bfd_elf64_size_dynamic_sections
 611   PARAMS ((bfd *, const char *, const char *, boolean, const char *,
 612            const char * const *, struct bfd_link_info *, struct sec **));
 613 extern void bfd_elf_set_dt_needed_name PARAMS ((bfd *, const char *));
 614 extern const char *bfd_elf_get_dt_soname PARAMS ((bfd *));
 615
 616 /* SunOS shared library support routines for the linker.  */
 617
 618 extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
 619   PARAMS ((bfd *, struct bfd_link_info *));
 620 extern boolean bfd_sunos_record_link_assignment
 621   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 622 extern boolean bfd_sunos_size_dynamic_sections
 623   PARAMS ((bfd *, struct bfd_link_info *, struct sec **, struct sec **,
 624            struct sec **));
 625
 626 /* Linux shared library support routines for the linker.  */
 627
 628 extern boolean bfd_i386linux_size_dynamic_sections
 629   PARAMS ((bfd *, struct bfd_link_info *));
 630 extern boolean bfd_m68klinux_size_dynamic_sections
 631   PARAMS ((bfd *, struct bfd_link_info *));
 632
 633 /* mmap hacks */
 634
 635 struct _bfd_window_internal;
 636 typedef struct _bfd_window_internal bfd_window_internal;
 637
 638 typedef struct _bfd_window {
 639   /* What the user asked for.  */
 640   PTR data;
 641   bfd_size_type size;
 642   /* The actual window used by BFD.  Small user-requested read-only
 643      regions sharing a page may share a single window into the object
 644      file.  Read-write versions shouldn't until I've fixed things to
 645      keep track of which portions have been claimed by the
 646      application; don't want to give the same region back when the
 647      application wants two writable copies!  */
 648   struct _bfd_window_internal *i;
 649 } bfd_window;
 650
 651 extern void bfd_init_window PARAMS ((bfd_window *));
 652 extern void bfd_free_window PARAMS ((bfd_window *));
 653 extern boolean bfd_get_file_window
 654   PARAMS ((bfd *, file_ptr, bfd_size_type, bfd_window *, boolean));
 655
 656 /* XCOFF support routines for the linker.  */
 657
 658 extern boolean bfd_xcoff_link_record_set
 659   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
 660            bfd_size_type));
 661 extern boolean bfd_xcoff_import_symbol
 662   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
 663            bfd_vma, const char *, const char *, const char *));
 664 extern boolean bfd_xcoff_export_symbol
 665   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
 666            boolean));
 667 extern boolean bfd_xcoff_link_count_reloc
 668   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 669 extern boolean bfd_xcoff_record_link_assignment
 670   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 671 extern boolean bfd_xcoff_size_dynamic_sections
 672   PARAMS ((bfd *, struct bfd_link_info *, const char *, const char *,
 673            unsigned long, unsigned long, unsigned long, boolean,
 674            int, boolean, boolean, struct sec **));
 675
 676 /* Externally visible COFF routines.  */
 677
 678 #if defined(__STDC__) || defined(ALMOST_STDC)
 679 struct internal_syment;
 680 union internal_auxent;
 681 #endif
 682
 683 extern boolean bfd_coff_get_syment
 684   PARAMS ((bfd *, struct symbol_cache_entry *, struct internal_syment *));
 685 extern boolean bfd_coff_get_auxent
 686   PARAMS ((bfd *, struct symbol_cache_entry *, int, union internal_auxent *));
 687
 688 /* And more from the source.  */
 689 void
 690 bfd_init PARAMS ((void));
 691
 692 bfd *
 693 bfd_openr PARAMS ((CONST char *filename, CONST char *target));
 694
 695 bfd *
 696 bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd));
 697
 698 bfd *
 699 bfd_openstreamr PARAMS (());
 700
 701 bfd *
 702 bfd_openw PARAMS ((CONST char *filename, CONST char *target));
 703
 704 boolean
 705 bfd_close PARAMS ((bfd *abfd));
 706
 707 boolean
 708 bfd_close_all_done PARAMS ((bfd *));
 709
 710 bfd_size_type
 711 bfd_alloc_size PARAMS ((bfd *abfd));
 712
 713 bfd *
 714 bfd_create PARAMS ((CONST char *filename, bfd *templ));
 715
 716
 717  /* Byte swapping macros for user section data.  */
 718
 719 #define bfd_put_8(abfd, val, ptr) \
 720                 (*((unsigned char *)(ptr)) = (unsigned char)(val))
 721 #define bfd_put_signed_8 \
 722                 bfd_put_8
 723 #define bfd_get_8(abfd, ptr) \
 724                 (*(unsigned char *)(ptr))
 725 #define bfd_get_signed_8(abfd, ptr) \
 726                 ((*(unsigned char *)(ptr) ^ 0x80) - 0x80)
 727
 728 #define bfd_put_16(abfd, val, ptr) \
 729                 BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
 730 #define bfd_put_signed_16 \
 731                  bfd_put_16
 732 #define bfd_get_16(abfd, ptr) \
 733                 BFD_SEND(abfd, bfd_getx16, (ptr))
 734 #define bfd_get_signed_16(abfd, ptr) \
 735                  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 736
 737 #define bfd_put_32(abfd, val, ptr) \
 738                 BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
 739 #define bfd_put_signed_32 \
 740                  bfd_put_32
 741 #define bfd_get_32(abfd, ptr) \
 742                 BFD_SEND(abfd, bfd_getx32, (ptr))
 743 #define bfd_get_signed_32(abfd, ptr) \
 744                  BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
 745
 746 #define bfd_put_64(abfd, val, ptr) \
 747                 BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
 748 #define bfd_put_signed_64 \
 749                  bfd_put_64
 750 #define bfd_get_64(abfd, ptr) \
 751                 BFD_SEND(abfd, bfd_getx64, (ptr))
 752 #define bfd_get_signed_64(abfd, ptr) \
 753                  BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
 754
 755
 756  /* Byte swapping macros for file header data.  */
 757
 758 #define bfd_h_put_8(abfd, val, ptr) \
 759                 bfd_put_8 (abfd, val, ptr)
 760 #define bfd_h_put_signed_8(abfd, val, ptr) \
 761                 bfd_put_8 (abfd, val, ptr)
 762 #define bfd_h_get_8(abfd, ptr) \
 763                 bfd_get_8 (abfd, ptr)
 764 #define bfd_h_get_signed_8(abfd, ptr) \
 765                 bfd_get_signed_8 (abfd, ptr)
 766
 767 #define bfd_h_put_16(abfd, val, ptr) \
 768                 BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
 769 #define bfd_h_put_signed_16 \
 770                  bfd_h_put_16
 771 #define bfd_h_get_16(abfd, ptr) \
 772                 BFD_SEND(abfd, bfd_h_getx16,(ptr))
 773 #define bfd_h_get_signed_16(abfd, ptr) \
 774                  BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
 775
 776 #define bfd_h_put_32(abfd, val, ptr) \
 777                 BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
 778 #define bfd_h_put_signed_32 \
 779                  bfd_h_put_32
 780 #define bfd_h_get_32(abfd, ptr) \
 781                 BFD_SEND(abfd, bfd_h_getx32,(ptr))
 782 #define bfd_h_get_signed_32(abfd, ptr) \
 783                  BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
 784
 785 #define bfd_h_put_64(abfd, val, ptr) \
 786                 BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
 787 #define bfd_h_put_signed_64 \
 788                  bfd_h_put_64
 789 #define bfd_h_get_64(abfd, ptr) \
 790                 BFD_SEND(abfd, bfd_h_getx64,(ptr))
 791 #define bfd_h_get_signed_64(abfd, ptr) \
 792                  BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
 793
 794 typedef struct sec
 795 {
 796          /* The name of the section; the name isn't a copy, the pointer is
 797         the same as that passed to bfd_make_section. */
 798
 799     CONST char *name;
 800
 801          /* Which section is it; 0..nth.      */
 802
 803    int index;
 804
 805          /* The next section in the list belonging to the BFD, or NULL. */
 806
 807     struct sec *next;
 808
 809          /* The field flags contains attributes of the section. Some
 810            flags are read in from the object file, and some are
 811            synthesized from other information.  */
 812
 813     flagword flags;
 814
 815 #define SEC_NO_FLAGS   0x000
 816
 817          /* Tells the OS to allocate space for this section when loading.
 818            This is clear for a section containing debug information
 819            only. */
 820 #define SEC_ALLOC      0x001
 821
 822          /* Tells the OS to load the section from the file when loading.
 823            This is clear for a .bss section. */
 824 #define SEC_LOAD       0x002
 825
 826          /* The section contains data still to be relocated, so there is
 827            some relocation information too. */
 828 #define SEC_RELOC      0x004
 829
 830 #if 0    /* Obsolete ? */
 831 #define SEC_BALIGN     0x008
 832 #endif
 833
 834          /* A signal to the OS that the section contains read only
 835           data. */
 836 #define SEC_READONLY   0x010
 837
 838          /* The section contains code only. */
 839 #define SEC_CODE       0x020
 840
 841          /* The section contains data only. */
 842 #define SEC_DATA       0x040
 843
 844          /* The section will reside in ROM. */
 845 #define SEC_ROM        0x080
 846
 847          /* The section contains constructor information. This section
 848            type is used by the linker to create lists of constructors and
 849            destructors used by <<g++>>. When a back end sees a symbol
 850            which should be used in a constructor list, it creates a new
 851            section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
 852            the symbol to it, and builds a relocation. To build the lists
 853            of constructors, all the linker has to do is catenate all the
 854            sections called <<__CTOR_LIST__>> and relocate the data
 855            contained within - exactly the operations it would peform on
 856            standard data. */
 857 #define SEC_CONSTRUCTOR 0x100
 858
 859          /* The section is a constuctor, and should be placed at the
 860           end of the text, data, or bss section(?). */
 861 #define SEC_CONSTRUCTOR_TEXT 0x1100
 862 #define SEC_CONSTRUCTOR_DATA 0x2100
 863 #define SEC_CONSTRUCTOR_BSS  0x3100
 864
 865          /* The section has contents - a data section could be
 866            <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
 867            <<SEC_HAS_CONTENTS>> */
 868 #define SEC_HAS_CONTENTS 0x200
 869
 870          /* An instruction to the linker to not output the section
 871            even if it has information which would normally be written. */
 872 #define SEC_NEVER_LOAD 0x400
 873
 874          /* The section is a COFF shared library section.  This flag is
 875            only for the linker.  If this type of section appears in
 876            the input file, the linker must copy it to the output file
 877            without changing the vma or size.  FIXME: Although this
 878            was originally intended to be general, it really is COFF
 879            specific (and the flag was renamed to indicate this).  It
 880            might be cleaner to have some more general mechanism to
 881            allow the back end to control what the linker does with
 882            sections. */
 883 #define SEC_COFF_SHARED_LIBRARY 0x800
 884
 885          /* The section contains common symbols (symbols may be defined
 886            multiple times, the value of a symbol is the amount of
 887            space it requires, and the largest symbol value is the one
 888            used).  Most targets have exactly one of these (which we
 889             translate to bfd_com_section_ptr), but ECOFF has two. */
 890 #define SEC_IS_COMMON 0x8000
 891
 892          /* The section contains only debugging information.  For
 893            example, this is set for ELF .debug and .stab sections.
 894            strip tests this flag to see if a section can be
 895            discarded. */
 896 #define SEC_DEBUGGING 0x10000
 897
 898          /* The contents of this section are held in memory pointed to
 899            by the contents field.  This is checked by
 900            bfd_get_section_contents, and the data is retrieved from
 901            memory if appropriate.  */
 902 #define SEC_IN_MEMORY 0x20000
 903
 904          /* The contents of this section are to be excluded by the
 905             linker for executable and shared objects unless those
 906             objects are to be further relocated.  */
 907 #define SEC_EXCLUDE 0x40000
 908
 909          /* The contents of this section are to be sorted by the
 910            based on the address specified in the associated symbol
 911            table.  */
 912 #define SEC_SORT_ENTRIES 0x80000
 913
 914          /* When linking, duplicate sections of the same name should be
 915            discarded, rather than being combined into a single section as
 916            is usually done.  This is similar to how common symbols are
 917            handled.  See SEC_LINK_DUPLICATES below.  */
 918 #define SEC_LINK_ONCE 0x100000
 919
 920          /* If SEC_LINK_ONCE is set, this bitfield describes how the linker
 921            should handle duplicate sections.  */
 922 #define SEC_LINK_DUPLICATES 0x600000
 923
 924          /* This value for SEC_LINK_DUPLICATES means that duplicate
 925            sections with the same name should simply be discarded. */
 926 #define SEC_LINK_DUPLICATES_DISCARD 0x0
 927
 928          /* This value for SEC_LINK_DUPLICATES means that the linker
 929            should warn if there are any duplicate sections, although
 930            it should still only link one copy.  */
 931 #define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000
 932
 933          /* This value for SEC_LINK_DUPLICATES means that the linker
 934            should warn if any duplicate sections are a different size.  */
 935 #define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000
 936
 937          /* This value for SEC_LINK_DUPLICATES means that the linker
 938            should warn if any duplicate sections contain different
 939            contents.  */
 940 #define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000
 941
 942          /* This section was created by the linker as part of dynamic
 943            relocation or other arcane processing.  It is skipped when
 944            going through the first-pass output, trusting that someone
 945            else up the line will take care of it later.  */
 946 #define SEC_LINKER_CREATED 0x800000
 947
 948          /*  End of section flags.  */
 949
 950          /* Some internal packed boolean fields.  */
 951
 952          /* See the vma field.  */
 953         unsigned int user_set_vma : 1;
 954
 955          /* Whether relocations have been processed.  */
 956         unsigned int reloc_done : 1;
 957
 958          /* A mark flag used by some of the linker backends.  */
 959         unsigned int linker_mark : 1;
 960
 961          /* End of internal packed boolean fields.  */
 962
 963         /*  The virtual memory address of the section - where it will be
 964            at run time.  The symbols are relocated against this.  The
 965             user_set_vma flag is maintained by bfd; if it's not set, the
 966             backend can assign addresses (for example, in <<a.out>>, where
 967             the default address for <<.data>> is dependent on the specific
 968             target and various flags).  */
 969
 970    bfd_vma vma;
 971
 972         /*  The load address of the section - where it would be in a
 973            rom image; really only used for writing section header
 974             information. */
 975
 976    bfd_vma lma;
 977
 978          /* The size of the section in bytes, as it will be output.
 979            contains a value even if the section has no contents (e.g., the
 980            size of <<.bss>>). This will be filled in after relocation */
 981
 982    bfd_size_type _cooked_size;
 983
 984          /* The original size on disk of the section, in bytes.  Normally this
 985             value is the same as the size, but if some relaxing has
 986             been done, then this value will be bigger.  */
 987
 988    bfd_size_type _raw_size;
 989
 990          /* If this section is going to be output, then this value is the
 991            offset into the output section of the first byte in the input
 992            section. E.g., if this was going to start at the 100th byte in
 993            the output section, this value would be 100. */
 994
 995    bfd_vma output_offset;
 996
 997          /* The output section through which to map on output. */
 998
 999    struct sec *output_section;
1000
1001          /* The alignment requirement of the section, as an exponent of 2 -
1002            e.g., 3 aligns to 2^3 (or 8). */
1003
1004    unsigned int alignment_power;
1005
1006          /* If an input section, a pointer to a vector of relocation
1007            records for the data in this section. */
1008
1009    struct reloc_cache_entry *relocation;
1010
1011          /* If an output section, a pointer to a vector of pointers to
1012            relocation records for the data in this section. */
1013
1014    struct reloc_cache_entry **orelocation;
1015
1016          /* The number of relocation records in one of the above  */
1017
1018    unsigned reloc_count;
1019
1020          /* Information below is back end specific - and not always used
1021            or updated.  */
1022
1023          /* File position of section data    */
1024
1025    file_ptr filepos;
1026
1027          /* File position of relocation info */
1028
1029    file_ptr rel_filepos;
1030
1031          /* File position of line data       */
1032
1033    file_ptr line_filepos;
1034
1035          /* Pointer to data for applications */
1036
1037    PTR userdata;
1038
1039          /* If the SEC_IN_MEMORY flag is set, this points to the actual
1040            contents.  */
1041    unsigned char *contents;
1042
1043          /* Attached line number information */
1044
1045    alent *lineno;
1046
1047          /* Number of line number records   */
1048
1049    unsigned int lineno_count;
1050
1051          /* When a section is being output, this value changes as more
1052            linenumbers are written out */
1053
1054    file_ptr moving_line_filepos;
1055
1056          /* What the section number is in the target world  */
1057
1058    int target_index;
1059
1060    PTR used_by_bfd;
1061
1062          /* If this is a constructor section then here is a list of the
1063            relocations created to relocate items within it. */
1064
1065    struct relent_chain *constructor_chain;
1066
1067          /* The BFD which owns the section. */
1068
1069    bfd *owner;
1070
1071           /* A symbol which points at this section only */
1072    struct symbol_cache_entry *symbol;
1073    struct symbol_cache_entry **symbol_ptr_ptr;
1074
1075    struct bfd_link_order *link_order_head;
1076    struct bfd_link_order *link_order_tail;
1077 } asection ;
1078
1079      /* These sections are global, and are managed by BFD.  The application
1080        and target back end are not permitted to change the values in
1081         these sections.  New code should use the section_ptr macros rather
1082        than referring directly to the const sections.  The const sections
1083        may eventually vanish.  */
1084 #define BFD_ABS_SECTION_NAME "*ABS*"
1085 #define BFD_UND_SECTION_NAME "*UND*"
1086 #define BFD_COM_SECTION_NAME "*COM*"
1087 #define BFD_IND_SECTION_NAME "*IND*"
1088
1089      /* the absolute section */
1090 extern const asection bfd_abs_section;
1091 #define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
1092 #define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
1093      /* Pointer to the undefined section */
1094 extern const asection bfd_und_section;
1095 #define bfd_und_section_ptr ((asection *) &bfd_und_section)
1096 #define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
1097      /* Pointer to the common section */
1098 extern const asection bfd_com_section;
1099 #define bfd_com_section_ptr ((asection *) &bfd_com_section)
1100      /* Pointer to the indirect section */
1101 extern const asection bfd_ind_section;
1102 #define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
1103 #define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
1104
1105 extern const struct symbol_cache_entry * const bfd_abs_symbol;
1106 extern const struct symbol_cache_entry * const bfd_com_symbol;
1107 extern const struct symbol_cache_entry * const bfd_und_symbol;
1108 extern const struct symbol_cache_entry * const bfd_ind_symbol;
1109 #define bfd_get_section_size_before_reloc(section) \
1110      (section->reloc_done ? (abort(),1): (section)->_raw_size)
1111 #define bfd_get_section_size_after_reloc(section) \
1112      ((section->reloc_done) ? (section)->_cooked_size: (abort(),1))
1113 asection *
1114 bfd_get_section_by_name PARAMS ((bfd *abfd, CONST char *name));
1115
1116 asection *
1117 bfd_make_section_old_way PARAMS ((bfd *abfd, CONST char *name));
1118
1119 asection *
1120 bfd_make_section_anyway PARAMS ((bfd *abfd, CONST char *name));
1121
1122 asection *
1123 bfd_make_section PARAMS ((bfd *, CONST char *name));
1124
1125 boolean
1126 bfd_set_section_flags PARAMS ((bfd *abfd, asection *sec, flagword flags));
1127
1128 void
1129 bfd_map_over_sections PARAMS ((bfd *abfd,
1130     void (*func)(bfd *abfd,
1131     asection *sect,
1132     PTR obj),
1133     PTR obj));
1134
1135 boolean
1136 bfd_set_section_size PARAMS ((bfd *abfd, asection *sec, bfd_size_type val));
1137
1138 boolean
1139 bfd_set_section_contents
1140  PARAMS ((bfd *abfd,
1141     asection *section,
1142     PTR data,
1143     file_ptr offset,
1144     bfd_size_type count));
1145
1146 boolean
1147 bfd_get_section_contents
1148  PARAMS ((bfd *abfd, asection *section, PTR location,
1149     file_ptr offset, bfd_size_type count));
1150
1151 boolean
1152 bfd_copy_private_section_data PARAMS ((bfd *ibfd, asection *isec, bfd *obfd, asection *osec));
1153
1154 #define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
1155      BFD_SEND (obfd, _bfd_copy_private_section_data, \
1156                 (ibfd, isection, obfd, osection))
1157 enum bfd_architecture
1158 {
1159   bfd_arch_unknown,    /* File arch not known */
1160   bfd_arch_obscure,    /* Arch known, not one of these */
1161   bfd_arch_m68k,       /* Motorola 68xxx */
1162   bfd_arch_vax,        /* DEC Vax */
1163   bfd_arch_i960,       /* Intel 960 */
1164      /* The order of the following is important.
1165        lower number indicates a machine type that
1166        only accepts a subset of the instructions
1167        available to machines with higher numbers.
1168        The exception is the "ca", which is
1169        incompatible with all other machines except
1170        "core". */
1171
1172 #define bfd_mach_i960_core      1
1173 #define bfd_mach_i960_ka_sa     2
1174 #define bfd_mach_i960_kb_sb     3
1175 #define bfd_mach_i960_mc        4
1176 #define bfd_mach_i960_xa        5
1177 #define bfd_mach_i960_ca        6
1178 #define bfd_mach_i960_jx         7
1179 #define bfd_mach_i960_hx        8
1180
1181   bfd_arch_a29k,       /* AMD 29000 */
1182   bfd_arch_sparc,      /* SPARC */
1183 #define bfd_mach_sparc                  1
1184  /* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */
1185 #define bfd_mach_sparc_sparclet 2
1186 #define bfd_mach_sparc_sparclite        3
1187 #define bfd_mach_sparc_v8plus           4
1188 #define bfd_mach_sparc_v8plusa          5  /* with ultrasparc add'ns */
1189 #define bfd_mach_sparc_v9               6
1190 #define bfd_mach_sparc_v9a              7  /* with ultrasparc add'ns */
1191  /* Nonzero if MACH has the v9 instruction set.  */
1192 #define bfd_mach_sparc_v9_p(mach) \
1193   ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a)
1194   bfd_arch_mips,       /* MIPS Rxxxx */
1195   bfd_arch_i386,       /* Intel 386 */
1196 #define bfd_mach_i386_i386 0
1197 #define bfd_mach_i386_i8086 1
1198   bfd_arch_we32k,      /* AT&T WE32xxx */
1199   bfd_arch_tahoe,      /* CCI/Harris Tahoe */
1200   bfd_arch_i860,       /* Intel 860 */
1201   bfd_arch_romp,       /* IBM ROMP PC/RT */
1202   bfd_arch_alliant,    /* Alliant */
1203   bfd_arch_convex,     /* Convex */
1204   bfd_arch_m88k,       /* Motorola 88xxx */
1205   bfd_arch_pyramid,    /* Pyramid Technology */
1206   bfd_arch_h8300,      /* Hitachi H8/300 */
1207 #define bfd_mach_h8300   1
1208 #define bfd_mach_h8300h  2
1209 #define bfd_mach_h8300s  3
1210   bfd_arch_powerpc,    /* PowerPC */
1211   bfd_arch_rs6000,     /* IBM RS/6000 */
1212   bfd_arch_hppa,       /* HP PA RISC */
1213   /* start-sanitize-d10v */
1214   bfd_arch_d10v,       /* Mitsubishi D10V */
1215   /* end-sanitize-d10v */
1216   /* start-sanitize-d30v */
1217   bfd_arch_d30v,       /* Mitsubishi D30V */
1218   /* end-sanitize-d30v */
1219   bfd_arch_z8k,        /* Zilog Z8000 */
1220 #define bfd_mach_z8001          1
1221 #define bfd_mach_z8002          2
1222   bfd_arch_h8500,      /* Hitachi H8/500 */
1223   bfd_arch_sh,         /* Hitachi SH */
1224   bfd_arch_alpha,      /* Dec Alpha */
1225   bfd_arch_arm,        /* Advanced Risc Machines ARM */
1226   bfd_arch_ns32k,      /* National Semiconductors ns32000 */
1227   bfd_arch_w65,        /* WDC 65816 */
1228   /* start-sanitize-tic80 */
1229   bfd_arch_tic80,      /* TI TMS320c80 (MVP) */
1230   /* end-sanitize-tic80 */
1231   /* start-sanitize-v850 */
1232   bfd_arch_v850,       /* NEC V850 */
1233   /* end-sanitize-v850 */
1234   /* start-sanitize-arc */
1235   bfd_arch_arc,        /* Argonaut RISC Core */
1236 #define bfd_mach_arc_base 0
1237 #define bfd_mach_arc_host 1
1238 #define bfd_mach_arc_graphics 2
1239 #define bfd_mach_arc_audio 3
1240   /* end-sanitize-arc */
1241   /* start-sanitize-m32r */
1242   bfd_arch_m32r,       /* Mitsubishi M32R */
1243   /* end-sanitize-m32r */
1244   bfd_arch_mn10200,    /* Matsushita MN10200 */
1245   bfd_arch_mn10300,    /* Matsushita MN10300 */
1246   bfd_arch_last
1247   };
1248
1249 typedef struct bfd_arch_info
1250 {
1251   int bits_per_word;
1252   int bits_per_address;
1253   int bits_per_byte;
1254   enum bfd_architecture arch;
1255   unsigned long mach;
1256   const char *arch_name;
1257   const char *printable_name;
1258   unsigned int section_align_power;
1259   /* true if this is the default machine for the architecture */
1260   boolean the_default;
1261   const struct bfd_arch_info * (*compatible)
1262         PARAMS ((const struct bfd_arch_info *a,
1263                  const struct bfd_arch_info *b));
1264
1265   boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
1266
1267   const struct bfd_arch_info *next;
1268 } bfd_arch_info_type;
1269 const char *
1270 bfd_printable_name PARAMS ((bfd *abfd));
1271
1272 const bfd_arch_info_type *
1273 bfd_scan_arch PARAMS ((const char *string));
1274
1275 const bfd_arch_info_type *
1276 bfd_arch_get_compatible PARAMS ((
1277     const bfd *abfd,
1278     const bfd *bbfd));
1279
1280 void
1281 bfd_set_arch_info PARAMS ((bfd *abfd, const bfd_arch_info_type *arg));
1282
1283 enum bfd_architecture
1284 bfd_get_arch PARAMS ((bfd *abfd));
1285
1286 unsigned long
1287 bfd_get_mach PARAMS ((bfd *abfd));
1288
1289 unsigned int
1290 bfd_arch_bits_per_byte PARAMS ((bfd *abfd));
1291
1292 unsigned int
1293 bfd_arch_bits_per_address PARAMS ((bfd *abfd));
1294
1295 const bfd_arch_info_type *
1296 bfd_get_arch_info PARAMS ((bfd *abfd));
1297
1298 const bfd_arch_info_type *
1299 bfd_lookup_arch
1300  PARAMS ((enum bfd_architecture
1301     arch,
1302     unsigned long machine));
1303
1304 const char *
1305 bfd_printable_arch_mach
1306  PARAMS ((enum bfd_architecture arch, unsigned long machine));
1307
1308 typedef enum bfd_reloc_status
1309 {
1310         /* No errors detected */
1311   bfd_reloc_ok,
1312
1313         /* The relocation was performed, but there was an overflow. */
1314   bfd_reloc_overflow,
1315
1316         /* The address to relocate was not within the section supplied. */
1317   bfd_reloc_outofrange,
1318
1319         /* Used by special functions */
1320   bfd_reloc_continue,
1321
1322         /* Unsupported relocation size requested. */
1323   bfd_reloc_notsupported,
1324
1325         /* Unused */
1326   bfd_reloc_other,
1327
1328         /* The symbol to relocate against was undefined. */
1329   bfd_reloc_undefined,
1330
1331         /* The relocation was performed, but may not be ok - presently
1332           generated only when linking i960 coff files with i960 b.out
1333           symbols.  If this type is returned, the error_message argument
1334           to bfd_perform_relocation will be set.  */
1335   bfd_reloc_dangerous
1336  }
1337  bfd_reloc_status_type;
1338
1339
1340 typedef struct reloc_cache_entry
1341 {
1342         /* A pointer into the canonical table of pointers  */
1343   struct symbol_cache_entry **sym_ptr_ptr;
1344
1345         /* offset in section */
1346   bfd_size_type address;
1347
1348         /* addend for relocation value */
1349   bfd_vma addend;
1350
1351         /* Pointer to how to perform the required relocation */
1352   reloc_howto_type *howto;
1353
1354 } arelent;
1355 enum complain_overflow
1356 {
1357          /* Do not complain on overflow. */
1358   complain_overflow_dont,
1359
1360          /* Complain if the bitfield overflows, whether it is considered
1361            as signed or unsigned. */
1362   complain_overflow_bitfield,
1363
1364          /* Complain if the value overflows when considered as signed
1365            number. */
1366   complain_overflow_signed,
1367
1368          /* Complain if the value overflows when considered as an
1369            unsigned number. */
1370   complain_overflow_unsigned
1371 };
1372
1373 struct reloc_howto_struct
1374 {
1375         /*  The type field has mainly a documentary use - the back end can
1376            do what it wants with it, though normally the back end's
1377            external idea of what a reloc number is stored
1378            in this field. For example, a PC relative word relocation
1379            in a coff environment has the type 023 - because that's
1380            what the outside world calls a R_PCRWORD reloc. */
1381   unsigned int type;
1382
1383         /*  The value the final relocation is shifted right by. This drops
1384            unwanted data from the relocation.  */
1385   unsigned int rightshift;
1386
1387          /*  The size of the item to be relocated.  This is *not* a
1388             power-of-two measure.  To get the number of bytes operated
1389             on by a type of relocation, use bfd_get_reloc_size.  */
1390   int size;
1391
1392         /*  The number of bits in the item to be relocated.  This is used
1393             when doing overflow checking.  */
1394   unsigned int bitsize;
1395
1396         /*  Notes that the relocation is relative to the location in the
1397            data section of the addend. The relocation function will
1398            subtract from the relocation value the address of the location
1399            being relocated. */
1400   boolean pc_relative;
1401
1402          /*  The bit position of the reloc value in the destination.
1403             The relocated value is left shifted by this amount. */
1404   unsigned int bitpos;
1405
1406          /* What type of overflow error should be checked for when
1407            relocating. */
1408   enum complain_overflow complain_on_overflow;
1409
1410         /* If this field is non null, then the supplied function is
1411           called rather than the normal function. This allows really
1412           strange relocation methods to be accomodated (e.g., i960 callj
1413           instructions). */
1414   bfd_reloc_status_type (*special_function)
1415                                     PARAMS ((bfd *abfd,
1416                                              arelent *reloc_entry,
1417                                             struct symbol_cache_entry *symbol,
1418                                             PTR data,
1419                                             asection *input_section,
1420                                             bfd *output_bfd,
1421                                             char **error_message));
1422
1423         /* The textual name of the relocation type. */
1424   char *name;
1425
1426         /* When performing a partial link, some formats must modify the
1427           relocations rather than the data - this flag signals this.*/
1428   boolean partial_inplace;
1429
1430         /* The src_mask selects which parts of the read in data
1431           are to be used in the relocation sum.  E.g., if this was an 8 bit
1432           bit of data which we read and relocated, this would be
1433           0x000000ff. When we have relocs which have an addend, such as
1434           sun4 extended relocs, the value in the offset part of a
1435           relocating field is garbage so we never use it. In this case
1436           the mask would be 0x00000000. */
1437   bfd_vma src_mask;
1438
1439         /* The dst_mask selects which parts of the instruction are replaced
1440           into the instruction. In most cases src_mask == dst_mask,
1441           except in the above special case, where dst_mask would be
1442           0x000000ff, and src_mask would be 0x00000000.   */
1443   bfd_vma dst_mask;
1444
1445         /* When some formats create PC relative instructions, they leave
1446           the value of the pc of the place being relocated in the offset
1447           slot of the instruction, so that a PC relative relocation can
1448           be made just by adding in an ordinary offset (e.g., sun3 a.out).
1449           Some formats leave the displacement part of an instruction
1450           empty (e.g., m88k bcs); this flag signals the fact.*/
1451   boolean pcrel_offset;
1452
1453 };
1454 #define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
1455   {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
1456 #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
1457
1458 #define HOWTO_PREPARE(relocation, symbol)      \
1459   {                                            \
1460   if (symbol != (asymbol *)NULL) {             \
1461     if (bfd_is_com_section (symbol->section)) { \
1462       relocation = 0;                          \
1463     }                                          \
1464     else {                                     \
1465       relocation = symbol->value;              \
1466     }                                          \
1467   }                                            \
1468 }
1469 int
1470 bfd_get_reloc_size  PARAMS ((reloc_howto_type *));
1471
1472 typedef struct relent_chain {
1473   arelent relent;
1474   struct   relent_chain *next;
1475 } arelent_chain;
1476 bfd_reloc_status_type
1477
1478 bfd_perform_relocation
1479  PARAMS ((bfd *abfd,
1480     arelent *reloc_entry,
1481     PTR data,
1482     asection *input_section,
1483     bfd *output_bfd,
1484     char **error_message));
1485
1486 bfd_reloc_status_type
1487
1488 bfd_install_relocation
1489  PARAMS ((bfd *abfd,
1490     arelent *reloc_entry,
1491     PTR data, bfd_vma data_start,
1492     asection *input_section,
1493     char **error_message));
1494
1495 enum bfd_reloc_code_real {
1496   _dummy_first_bfd_reloc_code_real,
1497
1498
1499 /* Basic absolute relocations of N bits. */
1500   BFD_RELOC_64,
1501   BFD_RELOC_32,
1502   BFD_RELOC_26,
1503   BFD_RELOC_24,
1504   BFD_RELOC_16,
1505   BFD_RELOC_14,
1506   BFD_RELOC_8,
1507
1508 /* PC-relative relocations.  Sometimes these are relative to the address
1509 of the relocation itself; sometimes they are relative to the start of
1510 the section containing the relocation.  It depends on the specific target.
1511
1512 The 24-bit relocation is used in some Intel 960 configurations. */
1513   BFD_RELOC_64_PCREL,
1514   BFD_RELOC_32_PCREL,
1515   BFD_RELOC_24_PCREL,
1516   BFD_RELOC_16_PCREL,
1517   BFD_RELOC_12_PCREL,
1518   BFD_RELOC_8_PCREL,
1519
1520 /* For ELF. */
1521   BFD_RELOC_32_GOT_PCREL,
1522   BFD_RELOC_16_GOT_PCREL,
1523   BFD_RELOC_8_GOT_PCREL,
1524   BFD_RELOC_32_GOTOFF,
1525   BFD_RELOC_16_GOTOFF,
1526   BFD_RELOC_LO16_GOTOFF,
1527   BFD_RELOC_HI16_GOTOFF,
1528   BFD_RELOC_HI16_S_GOTOFF,
1529   BFD_RELOC_8_GOTOFF,
1530   BFD_RELOC_32_PLT_PCREL,
1531   BFD_RELOC_24_PLT_PCREL,
1532   BFD_RELOC_16_PLT_PCREL,
1533   BFD_RELOC_8_PLT_PCREL,
1534   BFD_RELOC_32_PLTOFF,
1535   BFD_RELOC_16_PLTOFF,
1536   BFD_RELOC_LO16_PLTOFF,
1537   BFD_RELOC_HI16_PLTOFF,
1538   BFD_RELOC_HI16_S_PLTOFF,
1539   BFD_RELOC_8_PLTOFF,
1540
1541 /* Relocations used by 68K ELF. */
1542   BFD_RELOC_68K_GLOB_DAT,
1543   BFD_RELOC_68K_JMP_SLOT,
1544   BFD_RELOC_68K_RELATIVE,
1545
1546 /* Linkage-table relative. */
1547   BFD_RELOC_32_BASEREL,
1548   BFD_RELOC_16_BASEREL,
1549   BFD_RELOC_LO16_BASEREL,
1550   BFD_RELOC_HI16_BASEREL,
1551   BFD_RELOC_HI16_S_BASEREL,
1552   BFD_RELOC_8_BASEREL,
1553   BFD_RELOC_RVA,
1554
1555 /* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */
1556   BFD_RELOC_8_FFnn,
1557
1558 /* These PC-relative relocations are stored as word displacements --
1559 i.e., byte displacements shifted right two bits.  The 30-bit word
1560 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1561 SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1562 signed 16-bit displacement is used on the MIPS, and the 23-bit
1563 displacement is used on the Alpha. */
1564   BFD_RELOC_32_PCREL_S2,
1565   BFD_RELOC_16_PCREL_S2,
1566   BFD_RELOC_23_PCREL_S2,
1567
1568 /* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1569 the target word.  These are used on the SPARC. */
1570   BFD_RELOC_HI22,
1571   BFD_RELOC_LO10,
1572
1573 /* For systems that allocate a Global Pointer register, these are
1574 displacements off that register.  These relocation types are
1575 handled specially, because the value the register will have is
1576 decided relatively late. */
1577   BFD_RELOC_GPREL16,
1578   BFD_RELOC_GPREL32,
1579
1580 /* Reloc types used for i960/b.out. */
1581   BFD_RELOC_I960_CALLJ,
1582
1583 /* SPARC ELF relocations.  There is probably some overlap with other
1584 relocation types already defined. */
1585   BFD_RELOC_NONE,
1586   BFD_RELOC_SPARC_WDISP22,
1587   BFD_RELOC_SPARC22,
1588   BFD_RELOC_SPARC13,
1589   BFD_RELOC_SPARC_GOT10,
1590   BFD_RELOC_SPARC_GOT13,
1591   BFD_RELOC_SPARC_GOT22,
1592   BFD_RELOC_SPARC_PC10,
1593   BFD_RELOC_SPARC_PC22,
1594   BFD_RELOC_SPARC_WPLT30,
1595   BFD_RELOC_SPARC_COPY,
1596   BFD_RELOC_SPARC_GLOB_DAT,
1597   BFD_RELOC_SPARC_JMP_SLOT,
1598   BFD_RELOC_SPARC_RELATIVE,
1599   BFD_RELOC_SPARC_UA32,
1600
1601 /* I think these are specific to SPARC a.out (e.g., Sun 4). */
1602   BFD_RELOC_SPARC_BASE13,
1603   BFD_RELOC_SPARC_BASE22,
1604
1605 /* Some relocations we're using for SPARC V9 -- subject to change. */
1606 #define BFD_RELOC_SPARC_64 BFD_RELOC_64
1607   BFD_RELOC_SPARC_10,
1608   BFD_RELOC_SPARC_11,
1609   BFD_RELOC_SPARC_OLO10,
1610   BFD_RELOC_SPARC_HH22,
1611   BFD_RELOC_SPARC_HM10,
1612   BFD_RELOC_SPARC_LM22,
1613   BFD_RELOC_SPARC_PC_HH22,
1614   BFD_RELOC_SPARC_PC_HM10,
1615   BFD_RELOC_SPARC_PC_LM22,
1616   BFD_RELOC_SPARC_WDISP16,
1617   BFD_RELOC_SPARC_WDISP19,
1618   BFD_RELOC_SPARC_GLOB_JMP,
1619   BFD_RELOC_SPARC_7,
1620   BFD_RELOC_SPARC_6,
1621   BFD_RELOC_SPARC_5,
1622
1623 /* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
1624 "addend" in some special way.
1625 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1626 writing; when reading, it will be the absolute section symbol.  The
1627 addend is the displacement in bytes of the "lda" instruction from
1628 the "ldah" instruction (which is at the address of this reloc). */
1629   BFD_RELOC_ALPHA_GPDISP_HI16,
1630
1631 /* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1632 with GPDISP_HI16 relocs.  The addend is ignored when writing the
1633 relocations out, and is filled in with the file's GP value on
1634 reading, for convenience. */
1635   BFD_RELOC_ALPHA_GPDISP_LO16,
1636
1637 /* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1638 relocation except that there is no accompanying GPDISP_LO16
1639 relocation. */
1640   BFD_RELOC_ALPHA_GPDISP,
1641
1642 /* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1643 the assembler turns it into a LDQ instruction to load the address of
1644 the symbol, and then fills in a register in the real instruction.
1645
1646 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1647 section symbol.  The addend is ignored when writing, but is filled
1648 in with the file's GP value on reading, for convenience, as with the
1649 GPDISP_LO16 reloc.
1650
1651 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1652 It should refer to the symbol to be referenced, as with 16_GOTOFF,
1653 but it generates output not based on the position within the .got
1654 section, but relative to the GP value chosen for the file during the
1655 final link stage.
1656
1657 The LITUSE reloc, on the instruction using the loaded address, gives
1658 information to the linker that it might be able to use to optimize
1659 away some literal section references.  The symbol is ignored (read
1660 as the absolute section symbol), and the "addend" indicates the type
1661 of instruction using the register:
1662 1 - "memory" fmt insn
1663 2 - byte-manipulation (byte offset reg)
1664 3 - jsr (target of branch)
1665
1666 The GNU linker currently doesn't do any of this optimizing. */
1667   BFD_RELOC_ALPHA_LITERAL,
1668   BFD_RELOC_ALPHA_ELF_LITERAL,
1669   BFD_RELOC_ALPHA_LITUSE,
1670
1671 /* The HINT relocation indicates a value that should be filled into the
1672 "hint" field of a jmp/jsr/ret instruction, for possible branch-
1673 prediction logic which may be provided on some processors. */
1674   BFD_RELOC_ALPHA_HINT,
1675
1676 /* The LINKAGE relocation outputs a linkage pair in the object file,
1677 which is filled by the linker. */
1678   BFD_RELOC_ALPHA_LINKAGE,
1679
1680 /* The CODEADDR relocation outputs a STO_CA in the object file,
1681 which is filled by the linker. */
1682   BFD_RELOC_ALPHA_CODEADDR,
1683
1684 /* Bits 27..2 of the relocation address shifted right 2 bits;
1685 simple reloc otherwise. */
1686   BFD_RELOC_MIPS_JMP,
1687
1688 /* The MIPS16 jump instruction. */
1689   BFD_RELOC_MIPS16_JMP,
1690
1691 /* MIPS16 GP relative reloc. */
1692   BFD_RELOC_MIPS16_GPREL,
1693
1694 /* High 16 bits of 32-bit value; simple reloc. */
1695   BFD_RELOC_HI16,
1696
1697 /* High 16 bits of 32-bit value but the low 16 bits will be sign
1698 extended and added to form the final result.  If the low 16
1699 bits form a negative number, we need to add one to the high value
1700 to compensate for the borrow when the low bits are added. */
1701   BFD_RELOC_HI16_S,
1702
1703 /* Low 16 bits. */
1704   BFD_RELOC_LO16,
1705
1706 /* Like BFD_RELOC_HI16_S, but PC relative. */
1707   BFD_RELOC_PCREL_HI16_S,
1708
1709 /* Like BFD_RELOC_LO16, but PC relative. */
1710   BFD_RELOC_PCREL_LO16,
1711
1712 /* Relocation relative to the global pointer. */
1713 #define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
1714
1715 /* Relocation against a MIPS literal section. */
1716   BFD_RELOC_MIPS_LITERAL,
1717
1718 /* MIPS ELF relocations. */
1719   BFD_RELOC_MIPS_GOT16,
1720   BFD_RELOC_MIPS_CALL16,
1721 #define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
1722   BFD_RELOC_MIPS_GOT_HI16,
1723   BFD_RELOC_MIPS_GOT_LO16,
1724   BFD_RELOC_MIPS_CALL_HI16,
1725   BFD_RELOC_MIPS_CALL_LO16,
1726
1727 /* i386/elf relocations */
1728   BFD_RELOC_386_GOT32,
1729   BFD_RELOC_386_PLT32,
1730   BFD_RELOC_386_COPY,
1731   BFD_RELOC_386_GLOB_DAT,
1732   BFD_RELOC_386_JUMP_SLOT,
1733   BFD_RELOC_386_RELATIVE,
1734   BFD_RELOC_386_GOTOFF,
1735   BFD_RELOC_386_GOTPC,
1736
1737 /* ns32k relocations */
1738   BFD_RELOC_NS32K_IMM_8,
1739   BFD_RELOC_NS32K_IMM_16,
1740   BFD_RELOC_NS32K_IMM_32,
1741   BFD_RELOC_NS32K_IMM_8_PCREL,
1742   BFD_RELOC_NS32K_IMM_16_PCREL,
1743   BFD_RELOC_NS32K_IMM_32_PCREL,
1744   BFD_RELOC_NS32K_DISP_8,
1745   BFD_RELOC_NS32K_DISP_16,
1746   BFD_RELOC_NS32K_DISP_32,
1747   BFD_RELOC_NS32K_DISP_8_PCREL,
1748   BFD_RELOC_NS32K_DISP_16_PCREL,
1749   BFD_RELOC_NS32K_DISP_32_PCREL,
1750
1751 /* Power(rs6000) and PowerPC relocations. */
1752   BFD_RELOC_PPC_B26,
1753   BFD_RELOC_PPC_BA26,
1754   BFD_RELOC_PPC_TOC16,
1755   BFD_RELOC_PPC_B16,
1756   BFD_RELOC_PPC_B16_BRTAKEN,
1757   BFD_RELOC_PPC_B16_BRNTAKEN,
1758   BFD_RELOC_PPC_BA16,
1759   BFD_RELOC_PPC_BA16_BRTAKEN,
1760   BFD_RELOC_PPC_BA16_BRNTAKEN,
1761   BFD_RELOC_PPC_COPY,
1762   BFD_RELOC_PPC_GLOB_DAT,
1763   BFD_RELOC_PPC_JMP_SLOT,
1764   BFD_RELOC_PPC_RELATIVE,
1765   BFD_RELOC_PPC_LOCAL24PC,
1766   BFD_RELOC_PPC_EMB_NADDR32,
1767   BFD_RELOC_PPC_EMB_NADDR16,
1768   BFD_RELOC_PPC_EMB_NADDR16_LO,
1769   BFD_RELOC_PPC_EMB_NADDR16_HI,
1770   BFD_RELOC_PPC_EMB_NADDR16_HA,
1771   BFD_RELOC_PPC_EMB_SDAI16,
1772   BFD_RELOC_PPC_EMB_SDA2I16,
1773   BFD_RELOC_PPC_EMB_SDA2REL,
1774   BFD_RELOC_PPC_EMB_SDA21,
1775   BFD_RELOC_PPC_EMB_MRKREF,
1776   BFD_RELOC_PPC_EMB_RELSEC16,
1777   BFD_RELOC_PPC_EMB_RELST_LO,
1778   BFD_RELOC_PPC_EMB_RELST_HI,
1779   BFD_RELOC_PPC_EMB_RELST_HA,
1780   BFD_RELOC_PPC_EMB_BIT_FLD,
1781   BFD_RELOC_PPC_EMB_RELSDA,
1782
1783 /* The type of reloc used to build a contructor table - at the moment
1784 probably a 32 bit wide absolute relocation, but the target can choose.
1785 It generally does map to one of the other relocation types. */
1786   BFD_RELOC_CTOR,
1787
1788 /* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
1789 not stored in the instruction. */
1790   BFD_RELOC_ARM_PCREL_BRANCH,
1791
1792 /* These relocs are only used within the ARM assembler.  They are not
1793 (at present) written to any object files. */
1794   BFD_RELOC_ARM_IMMEDIATE,
1795   BFD_RELOC_ARM_OFFSET_IMM,
1796   BFD_RELOC_ARM_SHIFT_IMM,
1797   BFD_RELOC_ARM_SWI,
1798   BFD_RELOC_ARM_MULTI,
1799   BFD_RELOC_ARM_CP_OFF_IMM,
1800   BFD_RELOC_ARM_ADR_IMM,
1801   BFD_RELOC_ARM_LDR_IMM,
1802   BFD_RELOC_ARM_LITERAL,
1803   BFD_RELOC_ARM_IN_POOL,
1804   BFD_RELOC_ARM_OFFSET_IMM8,
1805   BFD_RELOC_ARM_HWLITERAL,
1806   BFD_RELOC_ARM_THUMB_ADD,
1807   BFD_RELOC_ARM_THUMB_IMM,
1808   BFD_RELOC_ARM_THUMB_SHIFT,
1809   BFD_RELOC_ARM_THUMB_OFFSET,
1810
1811 /* Hitachi SH relocs.  Not all of these appear in object files. */
1812   BFD_RELOC_SH_PCDISP8BY2,
1813   BFD_RELOC_SH_PCDISP12BY2,
1814   BFD_RELOC_SH_IMM4,
1815   BFD_RELOC_SH_IMM4BY2,
1816   BFD_RELOC_SH_IMM4BY4,
1817   BFD_RELOC_SH_IMM8,
1818   BFD_RELOC_SH_IMM8BY2,
1819   BFD_RELOC_SH_IMM8BY4,
1820   BFD_RELOC_SH_PCRELIMM8BY2,
1821   BFD_RELOC_SH_PCRELIMM8BY4,
1822   BFD_RELOC_SH_SWITCH16,
1823   BFD_RELOC_SH_SWITCH32,
1824   BFD_RELOC_SH_USES,
1825   BFD_RELOC_SH_COUNT,
1826   BFD_RELOC_SH_ALIGN,
1827   BFD_RELOC_SH_CODE,
1828   BFD_RELOC_SH_DATA,
1829   BFD_RELOC_SH_LABEL,
1830 /* start-sanitize-arc */
1831
1832 /* Argonaut RISC Core (ARC) relocs.
1833 ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
1834 not stored in the instruction.  The high 20 bits are installed in bits 26
1835 through 7 of the instruction. */
1836   BFD_RELOC_ARC_B22_PCREL,
1837
1838 /* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
1839 stored in the instruction.  The high 24 bits are installed in bits 23
1840 through 0. */
1841   BFD_RELOC_ARC_B26,
1842 /* end-sanitize-arc */
1843
1844 /* start-sanitize-d10v */
1845
1846 /* Mitsubishi D10V relocs.
1847 This is a 10-bit reloc with the right 2 bits
1848 assumed to be 0. */
1849   BFD_RELOC_D10V_10_PCREL_R,
1850
1851 /* Mitsubishi D10V relocs.
1852 This is a 10-bit reloc with the right 2 bits
1853 assumed to be 0.  This is the same as the previous reloc
1854 except it is in the left container, i.e.,
1855 shifted left 15 bits. */
1856   BFD_RELOC_D10V_10_PCREL_L,
1857
1858 /* This is an 18-bit reloc with the right 2 bits
1859 assumed to be 0. */
1860   BFD_RELOC_D10V_18,
1861
1862 /* This is an 18-bit reloc with the right 2 bits
1863 assumed to be 0. */
1864   BFD_RELOC_D10V_18_PCREL,
1865 /* end-sanitize-d10v */
1866
1867 /* start-sanitize-d30v */
1868
1869 /* Mitsubishi D30V relocs.
1870 This is a 6-bit absolute reloc. */
1871   BFD_RELOC_D30V_6,
1872
1873 /* Mitsubishi D30V relocs.
1874 This is a 12-bit absolute reloc with the
1875 right 3 bitsassumed to be 0. */
1876   BFD_RELOC_D30V_15,
1877
1878 /* Mitsubishi D30V relocs.
1879 This is a 12-bit pc-relative reloc with
1880 the right 3 bits assumed to be 0. */
1881   BFD_RELOC_D30V_15_PCREL,
1882
1883 /* This is an 18-bit absolute reloc with
1884 the right 3 bits assumed to be 0. */
1885   BFD_RELOC_D30V_21,
1886
1887 /* This is an 18-bit pc-relative reloc with
1888 the right 3 bits assumed to be 0. */
1889   BFD_RELOC_D30V_21_PCREL,
1890
1891 /* This is a 32-bit absolute reloc. */
1892   BFD_RELOC_D30V_32,
1893
1894 /* This is a 32-bit pc-relative reloc. */
1895   BFD_RELOC_D30V_32_PCREL,
1896 /* end-sanitize-d30v */
1897
1898 /* start-sanitize-m32r */
1899
1900 /* Mitsubishi M32R relocs.
1901 This is a 24 bit absolute address. */
1902   BFD_RELOC_M32R_24,
1903
1904 /* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */
1905   BFD_RELOC_M32R_10_PCREL,
1906
1907 /* This is an 18-bit reloc with the right 2 bits assumed to be 0. */
1908   BFD_RELOC_M32R_18_PCREL,
1909
1910 /* This is a 26-bit reloc with the right 2 bits assumed to be 0. */
1911   BFD_RELOC_M32R_26_PCREL,
1912
1913 /* This is a 16-bit reloc containing the high 16 bits of an address
1914 used when the lower 16 bits are treated as unsigned. */
1915   BFD_RELOC_M32R_HI16_ULO,
1916
1917 /* This is a 16-bit reloc containing the high 16 bits of an address
1918 used when the lower 16 bits are treated as signed. */
1919   BFD_RELOC_M32R_HI16_SLO,
1920
1921 /* This is a 16-bit reloc containing the lower 16 bits of an address. */
1922   BFD_RELOC_M32R_LO16,
1923 /* end-sanitize-m32r */
1924
1925 /* start-sanitize-v850 */
1926
1927 /* This is a 9-bit reloc */
1928   BFD_RELOC_V850_9_PCREL,
1929
1930 /* This is a 22-bit reloc */
1931   BFD_RELOC_V850_22_PCREL,
1932
1933 /* This is an offset from the short data area pointer.. */
1934   BFD_RELOC_V850_SDA_OFFSET,
1935
1936 /* This is an offset from the zero data area pointer.. */
1937   BFD_RELOC_V850_ZDA_OFFSET,
1938
1939 /* This is an offset from the tiny data area pointer.. */
1940   BFD_RELOC_V850_TDA_OFFSET,
1941 /* end-sanitize-v850 */
1942
1943
1944 /* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
1945 instruction. */
1946   BFD_RELOC_MN10300_32_PCREL,
1947
1948 /* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
1949 instruction. */
1950   BFD_RELOC_MN10300_16_PCREL,
1951   BFD_RELOC_UNUSED };
1952 typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
1953 reloc_howto_type *
1954
1955 bfd_reloc_type_lookup  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
1956
1957 const char *
1958 bfd_get_reloc_code_name  PARAMS ((bfd_reloc_code_real_type code));
1959
1960
1961 typedef struct symbol_cache_entry
1962 {
1963          /* A pointer to the BFD which owns the symbol. This information
1964            is necessary so that a back end can work out what additional
1965            information (invisible to the application writer) is carried
1966            with the symbol.
1967
1968            This field is *almost* redundant, since you can use section->owner
1969            instead, except that some symbols point to the global sections
1970            bfd_{abs,com,und}_section.  This could be fixed by making
1971            these globals be per-bfd (or per-target-flavor).  FIXME. */
1972
1973   struct _bfd *the_bfd;  /* Use bfd_asymbol_bfd(sym) to access this field. */
1974
1975          /* The text of the symbol. The name is left alone, and not copied; the
1976            application may not alter it. */
1977   CONST char *name;
1978
1979          /* The value of the symbol.  This really should be a union of a
1980           numeric value with a pointer, since some flags indicate that
1981           a pointer to another symbol is stored here.  */
1982   symvalue value;
1983
1984          /* Attributes of a symbol: */
1985
1986 #define BSF_NO_FLAGS    0x00
1987
1988          /* The symbol has local scope; <<static>> in <<C>>. The value
1989            is the offset into the section of the data. */
1990 #define BSF_LOCAL       0x01
1991
1992          /* The symbol has global scope; initialized data in <<C>>. The
1993            value is the offset into the section of the data. */
1994 #define BSF_GLOBAL      0x02
1995
1996          /* The symbol has global scope and is exported. The value is
1997            the offset into the section of the data. */
1998 #define BSF_EXPORT      BSF_GLOBAL  /* no real difference */
1999
2000          /* A normal C symbol would be one of:
2001            <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
2002            <<BSF_GLOBAL>> */
2003
2004          /* The symbol is a debugging record. The value has an arbitary
2005            meaning. */
2006 #define BSF_DEBUGGING   0x08
2007
2008          /* The symbol denotes a function entry point.  Used in ELF,
2009            perhaps others someday.  */
2010 #define BSF_FUNCTION    0x10
2011
2012          /* Used by the linker. */
2013 #define BSF_KEEP        0x20
2014 #define BSF_KEEP_G      0x40
2015
2016          /* A weak global symbol, overridable without warnings by
2017            a regular global symbol of the same name.  */
2018 #define BSF_WEAK        0x80
2019
2020         /* This symbol was created to point to a section, e.g. ELF's
2021            STT_SECTION symbols.  */
2022 #define BSF_SECTION_SYM 0x100
2023
2024          /* The symbol used to be a common symbol, but now it is
2025            allocated. */
2026 #define BSF_OLD_COMMON  0x200
2027
2028          /* The default value for common data. */
2029 #define BFD_FORT_COMM_DEFAULT_VALUE 0
2030
2031          /* In some files the type of a symbol sometimes alters its
2032            location in an output file - ie in coff a <<ISFCN>> symbol
2033            which is also <<C_EXT>> symbol appears where it was
2034            declared and not at the end of a section.  This bit is set
2035            by the target BFD part to convey this information. */
2036
2037 #define BSF_NOT_AT_END    0x400
2038
2039          /* Signal that the symbol is the label of constructor section. */
2040 #define BSF_CONSTRUCTOR   0x800
2041
2042          /* Signal that the symbol is a warning symbol.  The name is a
2043            warning.  The name of the next symbol is the one to warn about;
2044            if a reference is made to a symbol with the same name as the next
2045            symbol, a warning is issued by the linker. */
2046 #define BSF_WARNING       0x1000
2047
2048          /* Signal that the symbol is indirect.  This symbol is an indirect
2049            pointer to the symbol with the same name as the next symbol. */
2050 #define BSF_INDIRECT      0x2000
2051
2052          /* BSF_FILE marks symbols that contain a file name.  This is used
2053            for ELF STT_FILE symbols.  */
2054 #define BSF_FILE          0x4000
2055
2056          /* Symbol is from dynamic linking information.  */
2057 #define BSF_DYNAMIC        0x8000
2058
2059         /* The symbol denotes a data object.  Used in ELF, and perhaps
2060           others someday.  */
2061 #define BSF_OBJECT         0x10000
2062
2063   flagword flags;
2064
2065          /* A pointer to the section to which this symbol is
2066            relative.  This will always be non NULL, there are special
2067           sections for undefined and absolute symbols.  */
2068   struct sec *section;
2069
2070          /* Back end special data.  */
2071   union
2072     {
2073       PTR p;
2074       bfd_vma i;
2075     } udata;
2076
2077 } asymbol;
2078 #define bfd_get_symtab_upper_bound(abfd) \
2079      BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
2080 boolean
2081 bfd_is_local_label PARAMS ((bfd *abfd, asymbol *sym));
2082
2083 #define bfd_is_local_label(abfd, sym) \
2084      BFD_SEND (abfd, _bfd_is_local_label,(abfd, sym))
2085 #define bfd_canonicalize_symtab(abfd, location) \
2086      BFD_SEND (abfd, _bfd_canonicalize_symtab,\
2087                   (abfd, location))
2088 boolean
2089 bfd_set_symtab  PARAMS ((bfd *abfd, asymbol **location, unsigned int count));
2090
2091 void
2092 bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol));
2093
2094 #define bfd_make_empty_symbol(abfd) \
2095      BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
2096 #define bfd_make_debug_symbol(abfd,ptr,size) \
2097         BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
2098 int
2099 bfd_decode_symclass PARAMS ((asymbol *symbol));
2100
2101 void
2102 bfd_symbol_info PARAMS ((asymbol *symbol, symbol_info *ret));
2103
2104 boolean
2105 bfd_copy_private_symbol_data PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym));
2106
2107 #define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
2108      BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
2109                 (ibfd, isymbol, obfd, osymbol))
2110 struct _bfd
2111 {
2112      /* The filename the application opened the BFD with.  */
2113     CONST char *filename;
2114
2115      /* A pointer to the target jump table.             */
2116     const struct bfd_target *xvec;
2117
2118      /* To avoid dragging too many header files into every file that
2119        includes `<<bfd.h>>', IOSTREAM has been declared as a "char
2120        *", and MTIME as a "long".  Their correct types, to which they
2121        are cast when used, are "FILE *" and "time_t".    The iostream
2122        is the result of an fopen on the filename.  However, if the
2123        BFD_IN_MEMORY flag is set, then iostream is actually a pointer
2124        to a bfd_in_memory struct.  */
2125     PTR iostream;
2126
2127      /* Is the file descriptor being cached?  That is, can it be closed as
2128        needed, and re-opened when accessed later?  */
2129
2130     boolean cacheable;
2131
2132      /* Marks whether there was a default target specified when the
2133        BFD was opened. This is used to select which matching algorithm
2134        to use to choose the back end. */
2135
2136     boolean target_defaulted;
2137
2138      /* The caching routines use these to maintain a
2139        least-recently-used list of BFDs */
2140
2141     struct _bfd *lru_prev, *lru_next;
2142
2143      /* When a file is closed by the caching routines, BFD retains
2144        state information on the file here: */
2145
2146     file_ptr where;
2147
2148      /* and here: (``once'' means at least once) */
2149
2150     boolean opened_once;
2151
2152      /* Set if we have a locally maintained mtime value, rather than
2153        getting it from the file each time: */
2154
2155     boolean mtime_set;
2156
2157      /* File modified time, if mtime_set is true: */
2158
2159     long mtime;
2160
2161      /* Reserved for an unimplemented file locking extension.*/
2162
2163     int ifd;
2164
2165      /* The format which belongs to the BFD. (object, core, etc.) */
2166
2167     bfd_format format;
2168
2169      /* The direction the BFD was opened with*/
2170
2171     enum bfd_direction {no_direction = 0,
2172                         read_direction = 1,
2173                         write_direction = 2,
2174                         both_direction = 3} direction;
2175
2176      /* Format_specific flags*/
2177
2178     flagword flags;
2179
2180      /* Currently my_archive is tested before adding origin to
2181        anything. I believe that this can become always an add of
2182        origin, with origin set to 0 for non archive files.   */
2183
2184     file_ptr origin;
2185
2186      /* Remember when output has begun, to stop strange things
2187        from happening. */
2188     boolean output_has_begun;
2189
2190      /* Pointer to linked list of sections*/
2191     struct sec  *sections;
2192
2193      /* The number of sections */
2194     unsigned int section_count;
2195
2196      /* Stuff only useful for object files:
2197        The start address. */
2198     bfd_vma start_address;
2199
2200      /* Used for input and output*/
2201     unsigned int symcount;
2202
2203      /* Symbol table for output BFD (with symcount entries) */
2204     struct symbol_cache_entry  **outsymbols;
2205
2206      /* Pointer to structure which contains architecture information*/
2207     const struct bfd_arch_info *arch_info;
2208
2209      /* Stuff only useful for archives:*/
2210     PTR arelt_data;
2211     struct _bfd *my_archive;      /* The containing archive BFD.  */
2212     struct _bfd *next;            /* The next BFD in the archive.  */
2213     struct _bfd *archive_head;    /* The first BFD in the archive.  */
2214     boolean has_armap;
2215
2216      /* A chain of BFD structures involved in a link.  */
2217     struct _bfd *link_next;
2218
2219      /* A field used by _bfd_generic_link_add_archive_symbols.  This will
2220        be used only for archive elements.  */
2221     int archive_pass;
2222
2223      /* Used by the back end to hold private data. */
2224
2225     union
2226       {
2227       struct aout_data_struct *aout_data;
2228       struct artdata *aout_ar_data;
2229       struct _oasys_data *oasys_obj_data;
2230       struct _oasys_ar_data *oasys_ar_data;
2231       struct coff_tdata *coff_obj_data;
2232       struct pe_tdata *pe_obj_data;
2233       struct xcoff_tdata *xcoff_obj_data;
2234       struct ecoff_tdata *ecoff_obj_data;
2235       struct ieee_data_struct *ieee_data;
2236       struct ieee_ar_data_struct *ieee_ar_data;
2237       struct srec_data_struct *srec_data;
2238       struct ihex_data_struct *ihex_data;
2239       struct tekhex_data_struct *tekhex_data;
2240       struct elf_obj_tdata *elf_obj_data;
2241       struct nlm_obj_tdata *nlm_obj_data;
2242       struct bout_data_struct *bout_data;
2243       struct sun_core_struct *sun_core_data;
2244       struct trad_core_struct *trad_core_data;
2245       struct som_data_struct *som_data;
2246       struct hpux_core_struct *hpux_core_data;
2247       struct hppabsd_core_struct *hppabsd_core_data;
2248       struct sgi_core_struct *sgi_core_data;
2249       struct lynx_core_struct *lynx_core_data;
2250       struct osf_core_struct *osf_core_data;
2251       struct cisco_core_struct *cisco_core_data;
2252       struct versados_data_struct *versados_data;
2253       struct netbsd_core_struct *netbsd_core_data;
2254       PTR any;
2255       } tdata;
2256
2257      /* Used by the application to hold private data*/
2258     PTR usrdata;
2259
2260      /* Where all the allocated stuff under this BFD goes */
2261     struct obstack memory;
2262 };
2263
2264 typedef enum bfd_error
2265 {
2266   bfd_error_no_error = 0,
2267   bfd_error_system_call,
2268   bfd_error_invalid_target,
2269   bfd_error_wrong_format,
2270   bfd_error_invalid_operation,
2271   bfd_error_no_memory,
2272   bfd_error_no_symbols,
2273   bfd_error_no_armap,
2274   bfd_error_no_more_archived_files,
2275   bfd_error_malformed_archive,
2276   bfd_error_file_not_recognized,
2277   bfd_error_file_ambiguously_recognized,
2278   bfd_error_no_contents,
2279   bfd_error_nonrepresentable_section,
2280   bfd_error_no_debug_section,
2281   bfd_error_bad_value,
2282   bfd_error_file_truncated,
2283   bfd_error_file_too_big,
2284   bfd_error_invalid_error_code
2285 } bfd_error_type;
2286
2287 bfd_error_type
2288 bfd_get_error  PARAMS ((void));
2289
2290 void
2291 bfd_set_error  PARAMS ((bfd_error_type error_tag));
2292
2293 CONST char *
2294 bfd_errmsg  PARAMS ((bfd_error_type error_tag));
2295
2296 void
2297 bfd_perror  PARAMS ((CONST char *message));
2298
2299 typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...));
2300
2301 bfd_error_handler_type
2302 bfd_set_error_handler  PARAMS ((bfd_error_handler_type));
2303
2304 void
2305 bfd_set_error_program_name  PARAMS ((const char *));
2306
2307 long
2308 bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
2309
2310 long
2311 bfd_canonicalize_reloc
2312  PARAMS ((bfd *abfd,
2313     asection *sec,
2314     arelent **loc,
2315     asymbol     **syms));
2316
2317 void
2318 bfd_set_reloc
2319  PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count)
2320
2321     );
2322
2323 boolean
2324 bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags));
2325
2326 boolean
2327 bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma));
2328
2329 long
2330 bfd_get_mtime PARAMS ((bfd *abfd));
2331
2332 long
2333 bfd_get_size PARAMS ((bfd *abfd));
2334
2335 int
2336 bfd_get_gp_size PARAMS ((bfd *abfd));
2337
2338 void
2339 bfd_set_gp_size PARAMS ((bfd *abfd, int i));
2340
2341 bfd_vma
2342 bfd_scan_vma PARAMS ((CONST char *string, CONST char **end, int base));
2343
2344 boolean
2345 bfd_copy_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
2346
2347 #define bfd_copy_private_bfd_data(ibfd, obfd) \
2348      BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
2349                 (ibfd, obfd))
2350 boolean
2351 bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
2352
2353 #define bfd_merge_private_bfd_data(ibfd, obfd) \
2354      BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
2355                 (ibfd, obfd))
2356 boolean
2357 bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
2358
2359 #define bfd_set_private_flags(abfd, flags) \
2360      BFD_SEND (abfd, _bfd_set_private_flags, \
2361                 (abfd, flags))
2362 #define bfd_sizeof_headers(abfd, reloc) \
2363      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
2364
2365 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
2366      BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
2367
2368         /* Do these three do anything useful at all, for any back end?  */
2369 #define bfd_debug_info_start(abfd) \
2370         BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
2371
2372 #define bfd_debug_info_end(abfd) \
2373         BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
2374
2375 #define bfd_debug_info_accumulate(abfd, section) \
2376         BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
2377
2378
2379 #define bfd_stat_arch_elt(abfd, stat) \
2380         BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
2381
2382 #define bfd_update_armap_timestamp(abfd) \
2383         BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
2384
2385 #define bfd_set_arch_mach(abfd, arch, mach)\
2386         BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
2387
2388 #define bfd_relax_section(abfd, section, link_info, again) \
2389        BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
2390
2391 #define bfd_link_hash_table_create(abfd) \
2392         BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
2393
2394 #define bfd_link_add_symbols(abfd, info) \
2395         BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
2396
2397 #define bfd_final_link(abfd, info) \
2398         BFD_SEND (abfd, _bfd_final_link, (abfd, info))
2399
2400 #define bfd_free_cached_info(abfd) \
2401        BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
2402
2403 #define bfd_get_dynamic_symtab_upper_bound(abfd) \
2404         BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
2405
2406 #define bfd_print_private_bfd_data(abfd, file)\
2407         BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
2408
2409 #define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
2410         BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
2411
2412 #define bfd_get_dynamic_reloc_upper_bound(abfd) \
2413         BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
2414
2415 #define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
2416         BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
2417
2418 extern bfd_byte *bfd_get_relocated_section_contents
2419         PARAMS ((bfd *, struct bfd_link_info *,
2420                   struct bfd_link_order *, bfd_byte *,
2421                   boolean, asymbol **));
2422
2423 symindex
2424 bfd_get_next_mapent PARAMS ((bfd *abfd, symindex previous, carsym **sym));
2425
2426 boolean
2427 bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head));
2428
2429 bfd *
2430 bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous));
2431
2432 CONST char *
2433 bfd_core_file_failing_command PARAMS ((bfd *abfd));
2434
2435 int
2436 bfd_core_file_failing_signal PARAMS ((bfd *abfd));
2437
2438 boolean
2439 core_file_matches_executable_p
2440  PARAMS ((bfd *core_bfd, bfd *exec_bfd));
2441
2442 #define BFD_SEND(bfd, message, arglist) \
2443                ((*((bfd)->xvec->message)) arglist)
2444
2445 #ifdef DEBUG_BFD_SEND
2446 #undef BFD_SEND
2447 #define BFD_SEND(bfd, message, arglist) \
2448   (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
2449     ((*((bfd)->xvec->message)) arglist) : \
2450     (bfd_assert (__FILE__,__LINE__), NULL))
2451 #endif
2452 #define BFD_SEND_FMT(bfd, message, arglist) \
2453             (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
2454
2455 #ifdef DEBUG_BFD_SEND
2456 #undef BFD_SEND_FMT
2457 #define BFD_SEND_FMT(bfd, message, arglist) \
2458   (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
2459    (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) : \
2460    (bfd_assert (__FILE__,__LINE__), NULL))
2461 #endif
2462 enum bfd_flavour {
2463   bfd_target_unknown_flavour,
2464   bfd_target_aout_flavour,
2465   bfd_target_coff_flavour,
2466   bfd_target_ecoff_flavour,
2467   bfd_target_elf_flavour,
2468   bfd_target_ieee_flavour,
2469   bfd_target_nlm_flavour,
2470   bfd_target_oasys_flavour,
2471   bfd_target_tekhex_flavour,
2472   bfd_target_srec_flavour,
2473   bfd_target_ihex_flavour,
2474   bfd_target_som_flavour,
2475   bfd_target_os9k_flavour,
2476   bfd_target_versados_flavour,
2477   bfd_target_msdos_flavour,
2478   bfd_target_evax_flavour
2479 };
2480
2481 enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
2482
2483  /* Forward declaration.  */
2484 typedef struct bfd_link_info _bfd_link_info;
2485
2486 typedef struct bfd_target
2487 {
2488   char *name;
2489   enum bfd_flavour flavour;
2490   enum bfd_endian byteorder;
2491   enum bfd_endian header_byteorder;
2492   flagword object_flags;
2493   flagword section_flags;
2494   char symbol_leading_char;
2495   char ar_pad_char;
2496   unsigned short ar_max_namelen;
2497   bfd_vma      (*bfd_getx64) PARAMS ((const bfd_byte *));
2498   bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *));
2499   void         (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *));
2500   bfd_vma      (*bfd_getx32) PARAMS ((const bfd_byte *));
2501   bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *));
2502   void         (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *));
2503   bfd_vma      (*bfd_getx16) PARAMS ((const bfd_byte *));
2504   bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *));
2505   void         (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *));
2506   bfd_vma      (*bfd_h_getx64) PARAMS ((const bfd_byte *));
2507   bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *));
2508   void         (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *));
2509   bfd_vma      (*bfd_h_getx32) PARAMS ((const bfd_byte *));
2510   bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *));
2511   void         (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *));
2512   bfd_vma      (*bfd_h_getx16) PARAMS ((const bfd_byte *));
2513   bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *));
2514   void         (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *));
2515   const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
2516   boolean             (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *));
2517   boolean             (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *));
2518
2519    /* Generic entry points.  */
2520 #define BFD_JUMP_TABLE_GENERIC(NAME)\
2521 CAT(NAME,_close_and_cleanup),\
2522 CAT(NAME,_bfd_free_cached_info),\
2523 CAT(NAME,_new_section_hook),\
2524 CAT(NAME,_get_section_contents),\
2525 CAT(NAME,_get_section_contents_in_window)
2526
2527    /* Called when the BFD is being closed to do any necessary cleanup.  */
2528   boolean       (*_close_and_cleanup) PARAMS ((bfd *));
2529    /* Ask the BFD to free all cached information.  */
2530   boolean (*_bfd_free_cached_info) PARAMS ((bfd *));
2531    /* Called when a new section is created.  */
2532   boolean       (*_new_section_hook) PARAMS ((bfd *, sec_ptr));
2533    /* Read the contents of a section.  */
2534   boolean       (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
2535                                             file_ptr, bfd_size_type));
2536   boolean       (*_bfd_get_section_contents_in_window)
2537                           PARAMS ((bfd *, sec_ptr, bfd_window *,
2538                                    file_ptr, bfd_size_type));
2539
2540    /* Entry points to copy private data.  */
2541 #define BFD_JUMP_TABLE_COPY(NAME)\
2542 CAT(NAME,_bfd_copy_private_bfd_data),\
2543 CAT(NAME,_bfd_merge_private_bfd_data),\
2544 CAT(NAME,_bfd_copy_private_section_data),\
2545 CAT(NAME,_bfd_copy_private_symbol_data),\
2546 CAT(NAME,_bfd_set_private_flags),\
2547 CAT(NAME,_bfd_print_private_bfd_data)\
2548    /* Called to copy BFD general private data from one object file
2549      to another.  */
2550   boolean        (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *));
2551    /* Called to merge BFD general private data from one object file
2552      to a common output file when linking.  */
2553   boolean        (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *));
2554    /* Called to copy BFD private section data from one object file
2555      to another.  */
2556   boolean       (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr,
2557                                                        bfd *, sec_ptr));
2558    /* Called to copy BFD private symbol data from one symbol
2559      to another.  */
2560   boolean       (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *,
2561                                                            bfd *, asymbol *));
2562    /* Called to set private backend flags */
2563   boolean        (*_bfd_set_private_flags) PARAMS ((bfd *, flagword));
2564
2565    /* Called to print private BFD data */
2566   boolean       (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR));
2567
2568    /* Core file entry points.  */
2569 #define BFD_JUMP_TABLE_CORE(NAME)\
2570 CAT(NAME,_core_file_failing_command),\
2571 CAT(NAME,_core_file_failing_signal),\
2572 CAT(NAME,_core_file_matches_executable_p)
2573   char *   (*_core_file_failing_command) PARAMS ((bfd *));
2574   int      (*_core_file_failing_signal) PARAMS ((bfd *));
2575   boolean  (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *));
2576
2577    /* Archive entry points.  */
2578 #define BFD_JUMP_TABLE_ARCHIVE(NAME)\
2579 CAT(NAME,_slurp_armap),\
2580 CAT(NAME,_slurp_extended_name_table),\
2581 CAT(NAME,_construct_extended_name_table),\
2582 CAT(NAME,_truncate_arname),\
2583 CAT(NAME,_write_armap),\
2584 CAT(NAME,_read_ar_hdr),\
2585 CAT(NAME,_openr_next_archived_file),\
2586 CAT(NAME,_get_elt_at_index),\
2587 CAT(NAME,_generic_stat_arch_elt),\
2588 CAT(NAME,_update_armap_timestamp)
2589   boolean  (*_bfd_slurp_armap) PARAMS ((bfd *));
2590   boolean  (*_bfd_slurp_extended_name_table) PARAMS ((bfd *));
2591   boolean  (*_bfd_construct_extended_name_table)
2592              PARAMS ((bfd *, char **, bfd_size_type *, const char **));
2593   void     (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *));
2594   boolean  (*write_armap) PARAMS ((bfd *arch,
2595                               unsigned int elength,
2596                               struct orl *map,
2597                               unsigned int orl_count,
2598                               int stridx));
2599   PTR (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *));
2600   bfd *    (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev));
2601 #define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i))
2602   bfd *    (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex));
2603   int      (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *));
2604   boolean  (*_bfd_update_armap_timestamp) PARAMS ((bfd *));
2605
2606    /* Entry points used for symbols.  */
2607 #define BFD_JUMP_TABLE_SYMBOLS(NAME)\
2608 CAT(NAME,_get_symtab_upper_bound),\
2609 CAT(NAME,_get_symtab),\
2610 CAT(NAME,_make_empty_symbol),\
2611 CAT(NAME,_print_symbol),\
2612 CAT(NAME,_get_symbol_info),\
2613 CAT(NAME,_bfd_is_local_label),\
2614 CAT(NAME,_get_lineno),\
2615 CAT(NAME,_find_nearest_line),\
2616 CAT(NAME,_bfd_make_debug_symbol),\
2617 CAT(NAME,_read_minisymbols),\
2618 CAT(NAME,_minisymbol_to_symbol)
2619   long  (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *));
2620   long  (*_bfd_canonicalize_symtab) PARAMS ((bfd *,
2621                                              struct symbol_cache_entry **));
2622   struct symbol_cache_entry  *
2623                 (*_bfd_make_empty_symbol) PARAMS ((bfd *));
2624   void          (*_bfd_print_symbol) PARAMS ((bfd *, PTR,
2625                                       struct symbol_cache_entry *,
2626                                       bfd_print_symbol_type));
2627 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
2628   void          (*_bfd_get_symbol_info) PARAMS ((bfd *,
2629                                       struct symbol_cache_entry *,
2630                                       symbol_info *));
2631 #define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e))
2632   boolean        (*_bfd_is_local_label) PARAMS ((bfd *, asymbol *));
2633
2634   alent *    (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *));
2635   boolean    (*_bfd_find_nearest_line) PARAMS ((bfd *abfd,
2636                     struct sec *section, struct symbol_cache_entry **symbols,
2637                     bfd_vma offset, CONST char **file, CONST char **func,
2638                     unsigned int *line));
2639   /* Back-door to allow format-aware applications to create debug symbols
2640     while using BFD for everything else.  Currently used by the assembler
2641     when creating COFF files.  */
2642   asymbol *  (*_bfd_make_debug_symbol) PARAMS ((
2643        bfd *abfd,
2644        void *ptr,
2645        unsigned long size));
2646 #define bfd_read_minisymbols(b, d, m, s) \
2647   BFD_SEND (b, _read_minisymbols, (b, d, m, s))
2648   long  (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *,
2649                                       unsigned int *));
2650 #define bfd_minisymbol_to_symbol(b, d, m, f) \
2651   BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
2652   asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR,
2653                                              asymbol *));
2654
2655    /* Routines for relocs.  */
2656 #define BFD_JUMP_TABLE_RELOCS(NAME)\
2657 CAT(NAME,_get_reloc_upper_bound),\
2658 CAT(NAME,_canonicalize_reloc),\
2659 CAT(NAME,_bfd_reloc_type_lookup)
2660   long  (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr));
2661   long  (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **,
2662                                             struct symbol_cache_entry **));
2663    /* See documentation on reloc types.  */
2664   reloc_howto_type *
2665        (*reloc_type_lookup) PARAMS ((bfd *abfd,
2666                                      bfd_reloc_code_real_type code));
2667
2668    /* Routines used when writing an object file.  */
2669 #define BFD_JUMP_TABLE_WRITE(NAME)\
2670 CAT(NAME,_set_arch_mach),\
2671 CAT(NAME,_set_section_contents)
2672   boolean    (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture,
2673                     unsigned long));
2674   boolean       (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
2675                                             file_ptr, bfd_size_type));
2676
2677    /* Routines used by the linker.  */
2678 #define BFD_JUMP_TABLE_LINK(NAME)\
2679 CAT(NAME,_sizeof_headers),\
2680 CAT(NAME,_bfd_get_relocated_section_contents),\
2681 CAT(NAME,_bfd_relax_section),\
2682 CAT(NAME,_bfd_link_hash_table_create),\
2683 CAT(NAME,_bfd_link_add_symbols),\
2684 CAT(NAME,_bfd_final_link),\
2685 CAT(NAME,_bfd_link_split_section)
2686   int        (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean));
2687   bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *,
2688                     struct bfd_link_info *, struct bfd_link_order *,
2689                     bfd_byte *data, boolean relocateable,
2690                     struct symbol_cache_entry **));
2691
2692   boolean    (*_bfd_relax_section) PARAMS ((bfd *, struct sec *,
2693                     struct bfd_link_info *, boolean *again));
2694
2695    /* Create a hash table for the linker.  Different backends store
2696      different information in this table.  */
2697   struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *));
2698
2699    /* Add symbols from this object file into the hash table.  */
2700   boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *));
2701
2702    /* Do a link based on the link_order structures attached to each
2703      section of the BFD.  */
2704   boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *));
2705
2706    /* Should this section be split up into smaller pieces during linking.  */
2707   boolean (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *));
2708
2709   /* Routines to handle dynamic symbols and relocs.  */
2710 #define BFD_JUMP_TABLE_DYNAMIC(NAME)\
2711 CAT(NAME,_get_dynamic_symtab_upper_bound),\
2712 CAT(NAME,_canonicalize_dynamic_symtab),\
2713 CAT(NAME,_get_dynamic_reloc_upper_bound),\
2714 CAT(NAME,_canonicalize_dynamic_reloc)
2715    /* Get the amount of memory required to hold the dynamic symbols. */
2716   long  (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *));
2717    /* Read in the dynamic symbols.  */
2718   long  (*_bfd_canonicalize_dynamic_symtab)
2719     PARAMS ((bfd *, struct symbol_cache_entry **));
2720    /* Get the amount of memory required to hold the dynamic relocs.  */
2721   long  (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *));
2722    /* Read in the dynamic relocs.  */
2723   long  (*_bfd_canonicalize_dynamic_reloc)
2724     PARAMS ((bfd *, arelent **, struct symbol_cache_entry **));
2725
2726  PTR backend_data;
2727 } bfd_target;
2728 const bfd_target *
2729 bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd));
2730
2731 const char **
2732 bfd_target_list PARAMS ((void));
2733
2734 boolean
2735 bfd_check_format PARAMS ((bfd *abfd, bfd_format format));
2736
2737 boolean
2738 bfd_check_format_matches PARAMS ((bfd *abfd, bfd_format format, char ***matching));
2739
2740 boolean
2741 bfd_set_format PARAMS ((bfd *abfd, bfd_format format));
2742
2743 CONST char *
2744 bfd_format_string PARAMS ((bfd_format format));
2745
2746 #ifdef __cplusplus
2747 }
2748 #endif
2749 #endif