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