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