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