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