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