bfd/bfd-in2.h

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