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, 1996, 1997, 1998, 1999,
   3    2000, 2001
   4    Free Software Foundation, Inc.
   5    Contributed by Cygnus Support.
   6
   7 ** NOTE: bfd.h and bfd-in2.h are GENERATED files.  Don't change them;
   8 ** instead, change bfd-in.h or the other BFD source files processed to
   9 ** generate these files.
  10
  11 This file is part of BFD, the Binary File Descriptor library.
  12
  13 This program is free software; you can redistribute it and/or modify
  14 it under the terms of the GNU General Public License as published by
  15 the Free Software Foundation; either version 2 of the License, or
  16 (at your option) any later version.
  17
  18 This program is distributed in the hope that it will be useful,
  19 but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 GNU General Public License for more details.
  22
  23 You should have received a copy of the GNU General Public License
  24 along with this program; if not, write to the Free Software
  25 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  26
  27 /* bfd.h -- The only header file required by users of the bfd library
  28
  29 The bfd.h file is generated from bfd-in.h and various .c files; if you
  30 change it, your changes will probably be lost.
  31
  32 All the prototypes and definitions following the comment "THE FOLLOWING
  33 IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
  34 BFD.  If you change it, someone oneday will extract it from the source
  35 again, and your changes will be lost.  To save yourself from this bind,
  36 change the definitions in the source in the bfd directory.  Type "make
  37 docs" and then "make headers" in that directory, and magically this file
  38 will change to reflect your changes.
  39
  40 If you don't have the tools to perform the extraction, then you are
  41 safe from someone on your system trampling over your header files.
  42 You should still maintain the equivalence between the source and this
  43 file though; every change you make to the .c file should be reflected
  44 here.  */
  45
  46 #ifndef __BFD_H_SEEN__
  47 #define __BFD_H_SEEN__
  48
  49 #ifdef __cplusplus
  50 extern "C" {
  51 #endif
  52
  53 #include "ansidecl.h"
  54
  55 /* These two lines get substitutions done by commands in Makefile.in.  */
  56 #define BFD_VERSION  "@VERSION@"
  57 #define BFD_ARCH_SIZE @wordsize@
  58 #define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@
  59 #if @BFD_HOST_64_BIT_DEFINED@
  60 #define BFD_HOST_64_BIT @BFD_HOST_64_BIT@
  61 #define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@
  62 #endif
  63
  64 #if BFD_ARCH_SIZE >= 64
  65 #define BFD64
  66 #endif
  67
  68 #ifndef INLINE
  69 #if __GNUC__ >= 2
  70 #define INLINE __inline__
  71 #else
  72 #define INLINE
  73 #endif
  74 #endif
  75
  76 /* forward declaration */
  77 typedef struct _bfd bfd;
  78
  79 /* To squelch erroneous compiler warnings ("illegal pointer
  80    combination") from the SVR3 compiler, we would like to typedef
  81    boolean to int (it doesn't like functions which return boolean.
  82    Making sure they are never implicitly declared to return int
  83    doesn't seem to help).  But this file is not configured based on
  84    the host.  */
  85 /* General rules: functions which are boolean return true on success
  86    and false on failure (unless they're a predicate).   -- bfd.doc */
  87 /* I'm sure this is going to break something and someone is going to
  88    force me to change it.  */
  89 /* typedef enum boolean {false, true} boolean; */
  90 /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h>  -fnf */
  91 /* It gets worse if the host also defines a true/false enum... -sts */
  92 /* And even worse if your compiler has built-in boolean types... -law */
  93 #if defined (__GNUG__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 6))
  94 #define TRUE_FALSE_ALREADY_DEFINED
  95 #endif
  96 #ifdef MPW
  97 /* Pre-emptive strike - get the file with the enum.  */
  98 #include <Types.h>
  99 #define TRUE_FALSE_ALREADY_DEFINED
 100 #endif /* MPW */
 101 #ifndef TRUE_FALSE_ALREADY_DEFINED
 102 typedef enum bfd_boolean {false, true} boolean;
 103 #define BFD_TRUE_FALSE
 104 #else
 105 /* Use enum names that will appear nowhere else.  */
 106 typedef enum bfd_boolean {bfd_fffalse, bfd_tttrue} boolean;
 107 #endif
 108
 109 /* A pointer to a position in a file.  */
 110 /* FIXME:  This should be using off_t from <sys/types.h>.
 111    For now, try to avoid breaking stuff by not including <sys/types.h> here.
 112    This will break on systems with 64-bit file offsets (e.g. 4.4BSD).
 113    Probably the best long-term answer is to avoid using file_ptr AND off_t
 114    in this header file, and to handle this in the BFD implementation
 115    rather than in its interface.  */
 116 /* typedef off_t        file_ptr; */
 117 typedef long int file_ptr;
 118
 119 /* Support for different sizes of target format ints and addresses.
 120    If the type `long' is at least 64 bits, BFD_HOST_64BIT_LONG will be
 121    set to 1 above.  Otherwise, if gcc is being used, this code will
 122    use gcc's "long long" type.  Otherwise, BFD_HOST_64_BIT must be
 123    defined above.  */
 124
 125 #ifndef BFD_HOST_64_BIT
 126 # if BFD_HOST_64BIT_LONG
 127 #  define BFD_HOST_64_BIT long
 128 #  define BFD_HOST_U_64_BIT unsigned long
 129 # else
 130 #  ifdef __GNUC__
 131 #   if __GNUC__ >= 2
 132 #    define BFD_HOST_64_BIT long long
 133 #    define BFD_HOST_U_64_BIT unsigned long long
 134 #   endif /* __GNUC__ >= 2 */
 135 #  endif /* ! defined (__GNUC__) */
 136 # endif /* ! BFD_HOST_64BIT_LONG */
 137 #endif /* ! defined (BFD_HOST_64_BIT) */
 138
 139 #ifdef BFD64
 140
 141 #ifndef BFD_HOST_64_BIT
 142  #error No 64 bit integer type available
 143 #endif /* ! defined (BFD_HOST_64_BIT) */
 144
 145 typedef BFD_HOST_U_64_BIT bfd_vma;
 146 typedef BFD_HOST_64_BIT bfd_signed_vma;
 147 typedef BFD_HOST_U_64_BIT bfd_size_type;
 148 typedef BFD_HOST_U_64_BIT symvalue;
 149
 150 #ifndef fprintf_vma
 151 #if BFD_HOST_64BIT_LONG
 152 #define sprintf_vma(s,x) sprintf (s, "%016lx", x)
 153 #define fprintf_vma(f,x) fprintf (f, "%016lx", x)
 154 #else
 155 #define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
 156 #define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
 157 #define fprintf_vma(s,x) \
 158   fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
 159 #define sprintf_vma(s,x) \
 160   sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
 161 #endif
 162 #endif
 163
 164 #else /* not BFD64  */
 165
 166 /* Represent a target address.  Also used as a generic unsigned type
 167    which is guaranteed to be big enough to hold any arithmetic types
 168    we need to deal with.  */
 169 typedef unsigned long bfd_vma;
 170
 171 /* A generic signed type which is guaranteed to be big enough to hold any
 172    arithmetic types we need to deal with.  Can be assumed to be compatible
 173    with bfd_vma in the same way that signed and unsigned ints are compatible
 174    (as parameters, in assignment, etc).  */
 175 typedef long bfd_signed_vma;
 176
 177 typedef unsigned long symvalue;
 178 typedef unsigned long bfd_size_type;
 179
 180 /* Print a bfd_vma x on stream s.  */
 181 #define fprintf_vma(s,x) fprintf (s, "%08lx", x)
 182 #define sprintf_vma(s,x) sprintf (s, "%08lx", x)
 183
 184 #endif /* not BFD64  */
 185
 186 extern void bfd_sprintf_vma PARAMS ((bfd *, char *, bfd_vma));
 187 extern void bfd_fprintf_vma PARAMS ((bfd *, PTR, bfd_vma));
 188
 189 #define printf_vma(x) fprintf_vma(stdout,x)
 190 #define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x)
 191
 192 typedef unsigned int flagword;  /* 32 bits of flags */
 193 typedef unsigned char bfd_byte;
 194 \f
 195 /** File formats */
 196
 197 typedef enum bfd_format {
 198               bfd_unknown = 0,  /* file format is unknown */
 199               bfd_object,       /* linker/assember/compiler output */
 200               bfd_archive,      /* object archive file */
 201               bfd_core,         /* core dump */
 202               bfd_type_end}     /* marks the end; don't use it! */
 203          bfd_format;
 204
 205 /* Values that may appear in the flags field of a BFD.  These also
 206    appear in the object_flags field of the bfd_target structure, where
 207    they indicate the set of flags used by that backend (not all flags
 208    are meaningful for all object file formats) (FIXME: at the moment,
 209    the object_flags values have mostly just been copied from backend
 210    to another, and are not necessarily correct).  */
 211
 212 /* No flags.  */
 213 #define BFD_NO_FLAGS    0x00
 214
 215 /* BFD contains relocation entries.  */
 216 #define HAS_RELOC       0x01
 217
 218 /* BFD is directly executable.  */
 219 #define EXEC_P          0x02
 220
 221 /* BFD has line number information (basically used for F_LNNO in a
 222    COFF header).  */
 223 #define HAS_LINENO      0x04
 224
 225 /* BFD has debugging information.  */
 226 #define HAS_DEBUG       0x08
 227
 228 /* BFD has symbols.  */
 229 #define HAS_SYMS        0x10
 230
 231 /* BFD has local symbols (basically used for F_LSYMS in a COFF
 232    header).  */
 233 #define HAS_LOCALS      0x20
 234
 235 /* BFD is a dynamic object.  */
 236 #define DYNAMIC         0x40
 237
 238 /* Text section is write protected (if D_PAGED is not set, this is
 239    like an a.out NMAGIC file) (the linker sets this by default, but
 240    clears it for -r or -N).  */
 241 #define WP_TEXT         0x80
 242
 243 /* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 244    linker sets this by default, but clears it for -r or -n or -N).  */
 245 #define D_PAGED         0x100
 246
 247 /* BFD is relaxable (this means that bfd_relax_section may be able to
 248    do something) (sometimes bfd_relax_section can do something even if
 249    this is not set).  */
 250 #define BFD_IS_RELAXABLE 0x200
 251
 252 /* This may be set before writing out a BFD to request using a
 253    traditional format.  For example, this is used to request that when
 254    writing out an a.out object the symbols not be hashed to eliminate
 255    duplicates.  */
 256 #define BFD_TRADITIONAL_FORMAT 0x400
 257
 258 /* This flag indicates that the BFD contents are actually cached in
 259    memory.  If this is set, iostream points to a bfd_in_memory struct.  */
 260 #define BFD_IN_MEMORY 0x800
 261 \f
 262 /* symbols and relocation */
 263
 264 /* A count of carsyms (canonical archive symbols).  */
 265 typedef unsigned long symindex;
 266
 267 /* How to perform a relocation.  */
 268 typedef const struct reloc_howto_struct reloc_howto_type;
 269
 270 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
 271
 272 /* General purpose part of a symbol X;
 273    target specific parts are in libcoff.h, libaout.h, etc.  */
 274
 275 #define bfd_get_section(x) ((x)->section)
 276 #define bfd_get_output_section(x) ((x)->section->output_section)
 277 #define bfd_set_section(x,y) ((x)->section) = (y)
 278 #define bfd_asymbol_base(x) ((x)->section->vma)
 279 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
 280 #define bfd_asymbol_name(x) ((x)->name)
 281 /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
 282 #define bfd_asymbol_bfd(x) ((x)->the_bfd)
 283 #define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
 284
 285 /* A canonical archive symbol.  */
 286 /* This is a type pun with struct ranlib on purpose! */
 287 typedef struct carsym {
 288   char *name;
 289   file_ptr file_offset;         /* look here to find the file */
 290 } carsym;                       /* to make these you call a carsymogen */
 291
 292 /* Used in generating armaps (archive tables of contents).
 293    Perhaps just a forward definition would do? */
 294 struct orl {                    /* output ranlib */
 295   char **name;                  /* symbol name */
 296   file_ptr pos;                 /* bfd* or file position */
 297   int namidx;                   /* index into string table */
 298 };
 299 \f
 300 /* Linenumber stuff */
 301 typedef struct lineno_cache_entry {
 302   unsigned int line_number;     /* Linenumber from start of function*/
 303   union {
 304     struct symbol_cache_entry *sym; /* Function name */
 305     bfd_vma offset;         /* Offset into section */
 306   } u;
 307 } alent;
 308 \f
 309 /* object and core file sections */
 310
 311 #define align_power(addr, align)        \
 312         ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
 313
 314 typedef struct sec *sec_ptr;
 315
 316 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
 317 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
 318 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
 319 #define bfd_section_name(bfd, ptr) ((ptr)->name)
 320 #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
 321 #define bfd_section_vma(bfd, ptr) ((ptr)->vma)
 322 #define bfd_section_lma(bfd, ptr) ((ptr)->lma)
 323 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
 324 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
 325 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
 326
 327 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 328
 329 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = (boolean)true), true)
 330 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
 331 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
 332
 333 typedef struct stat stat_type;
 334 \f
 335 typedef enum bfd_print_symbol
 336 {
 337   bfd_print_symbol_name,
 338   bfd_print_symbol_more,
 339   bfd_print_symbol_all
 340 } bfd_print_symbol_type;
 341
 342 /* Information about a symbol that nm needs.  */
 343
 344 typedef struct _symbol_info
 345 {
 346   symvalue value;
 347   char type;
 348   CONST char *name;            /* Symbol name.  */
 349   unsigned char stab_type;     /* Stab type.  */
 350   char stab_other;             /* Stab other.  */
 351   short stab_desc;             /* Stab desc.  */
 352   CONST char *stab_name;       /* String for stab type.  */
 353 } symbol_info;
 354
 355 /* Get the name of a stabs type code.  */
 356
 357 extern const char *bfd_get_stab_name PARAMS ((int));
 358 \f
 359 /* Hash table routines.  There is no way to free up a hash table.  */
 360
 361 /* An element in the hash table.  Most uses will actually use a larger
 362    structure, and an instance of this will be the first field.  */
 363
 364 struct bfd_hash_entry
 365 {
 366   /* Next entry for this hash code.  */
 367   struct bfd_hash_entry *next;
 368   /* String being hashed.  */
 369   const char *string;
 370   /* Hash code.  This is the full hash code, not the index into the
 371      table.  */
 372   unsigned long hash;
 373 };
 374
 375 /* A hash table.  */
 376
 377 struct bfd_hash_table
 378 {
 379   /* The hash array.  */
 380   struct bfd_hash_entry **table;
 381   /* The number of slots in the hash table.  */
 382   unsigned int size;
 383   /* A function used to create new elements in the hash table.  The
 384      first entry is itself a pointer to an element.  When this
 385      function is first invoked, this pointer will be NULL.  However,
 386      having the pointer permits a hierarchy of method functions to be
 387      built each of which calls the function in the superclass.  Thus
 388      each function should be written to allocate a new block of memory
 389      only if the argument is NULL.  */
 390   struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 391                                              struct bfd_hash_table *,
 392                                              const char *));
 393    /* An objalloc for this hash table.  This is a struct objalloc *,
 394      but we use PTR to avoid requiring the inclusion of objalloc.h.  */
 395   PTR memory;
 396 };
 397
 398 /* Initialize a hash table.  */
 399 extern boolean bfd_hash_table_init
 400   PARAMS ((struct bfd_hash_table *,
 401            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 402                                        struct bfd_hash_table *,
 403                                        const char *)));
 404
 405 /* Initialize a hash table specifying a size.  */
 406 extern boolean bfd_hash_table_init_n
 407   PARAMS ((struct bfd_hash_table *,
 408            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 409                                        struct bfd_hash_table *,
 410                                        const char *),
 411            unsigned int size));
 412
 413 /* Free up a hash table.  */
 414 extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *));
 415
 416 /* Look up a string in a hash table.  If CREATE is true, a new entry
 417    will be created for this string if one does not already exist.  The
 418    COPY argument must be true if this routine should copy the string
 419    into newly allocated memory when adding an entry.  */
 420 extern struct bfd_hash_entry *bfd_hash_lookup
 421   PARAMS ((struct bfd_hash_table *, const char *, boolean create,
 422            boolean copy));
 423
 424 /* Replace an entry in a hash table.  */
 425 extern void bfd_hash_replace
 426   PARAMS ((struct bfd_hash_table *, struct bfd_hash_entry *old,
 427            struct bfd_hash_entry *nw));
 428
 429 /* Base method for creating a hash table entry.  */
 430 extern struct bfd_hash_entry *bfd_hash_newfunc
 431   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
 432            const char *));
 433
 434 /* Grab some space for a hash table entry.  */
 435 extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *,
 436                                       unsigned int));
 437
 438 /* Traverse a hash table in a random order, calling a function on each
 439    element.  If the function returns false, the traversal stops.  The
 440    INFO argument is passed to the function.  */
 441 extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *,
 442                                        boolean (*) (struct bfd_hash_entry *,
 443                                                     PTR),
 444                                        PTR info));
 445 \f
 446 /* Semi-portable string concatenation in cpp.
 447    The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors.
 448    The problem is, "32_" is not a valid preprocessing token, and we don't
 449    want extra underscores (e.g., "nlm_32_").  The XCAT2 macro will cause the
 450    inner CAT macros to be evaluated first, producing still-valid pp-tokens.
 451    Then the final concatenation can be done.  (Sigh.)  */
 452 #ifndef CAT
 453 #ifdef SABER
 454 #define CAT(a,b)        a##b
 455 #define CAT3(a,b,c)     a##b##c
 456 #define CAT4(a,b,c,d)   a##b##c##d
 457 #else
 458 #if defined(__STDC__) || defined(ALMOST_STDC)
 459 #define CAT(a,b) a##b
 460 #define CAT3(a,b,c) a##b##c
 461 #define XCAT2(a,b)      CAT(a,b)
 462 #define CAT4(a,b,c,d)   XCAT2(CAT(a,b),CAT(c,d))
 463 #else
 464 #define CAT(a,b) a/**/b
 465 #define CAT3(a,b,c) a/**/b/**/c
 466 #define CAT4(a,b,c,d)   a/**/b/**/c/**/d
 467 #endif
 468 #endif
 469 #endif
 470
 471 #define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table
 472 \f
 473 /* User program access to BFD facilities */
 474
 475 /* Direct I/O routines, for programs which know more about the object
 476    file than BFD does.  Use higher level routines if possible.  */
 477
 478 extern bfd_size_type bfd_read
 479   PARAMS ((PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
 480 extern bfd_size_type bfd_write
 481   PARAMS ((const PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
 482 extern int bfd_seek PARAMS ((bfd *abfd, file_ptr fp, int direction));
 483 extern long bfd_tell PARAMS ((bfd *abfd));
 484 extern int bfd_flush PARAMS ((bfd *abfd));
 485 extern int bfd_stat PARAMS ((bfd *abfd, struct stat *));
 486
 487 /* Cast from const char * to char * so that caller can assign to
 488    a char * without a warning.  */
 489 #define bfd_get_filename(abfd) ((char *) (abfd)->filename)
 490 #define bfd_get_cacheable(abfd) ((abfd)->cacheable)
 491 #define bfd_get_format(abfd) ((abfd)->format)
 492 #define bfd_get_target(abfd) ((abfd)->xvec->name)
 493 #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
 494 #define bfd_family_coff(abfd) \
 495   (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \
 496    bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)
 497 #define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
 498 #define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
 499 #define bfd_header_big_endian(abfd) \
 500   ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
 501 #define bfd_header_little_endian(abfd) \
 502   ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
 503 #define bfd_get_file_flags(abfd) ((abfd)->flags)
 504 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
 505 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
 506 #define bfd_my_archive(abfd) ((abfd)->my_archive)
 507 #define bfd_has_map(abfd) ((abfd)->has_armap)
 508
 509 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
 510 #define bfd_usrdata(abfd) ((abfd)->usrdata)
 511
 512 #define bfd_get_start_address(abfd) ((abfd)->start_address)
 513 #define bfd_get_symcount(abfd) ((abfd)->symcount)
 514 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
 515 #define bfd_count_sections(abfd) ((abfd)->section_count)
 516
 517 #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
 518
 519 #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (boolean) (bool)), true)
 520
 521 extern boolean bfd_cache_close PARAMS ((bfd *abfd));
 522 /* NB: This declaration should match the autogenerated one in libbfd.h.  */
 523
 524 extern boolean bfd_record_phdr
 525   PARAMS ((bfd *, unsigned long, boolean, flagword, boolean, bfd_vma,
 526            boolean, boolean, unsigned int, struct sec **));
 527
 528 /* Byte swapping routines.  */
 529
 530 bfd_vma         bfd_getb64         PARAMS ((const unsigned char *));
 531 bfd_vma         bfd_getl64         PARAMS ((const unsigned char *));
 532 bfd_signed_vma  bfd_getb_signed_64 PARAMS ((const unsigned char *));
 533 bfd_signed_vma  bfd_getl_signed_64 PARAMS ((const unsigned char *));
 534 bfd_vma         bfd_getb32         PARAMS ((const unsigned char *));
 535 bfd_vma         bfd_getl32         PARAMS ((const unsigned char *));
 536 bfd_signed_vma  bfd_getb_signed_32 PARAMS ((const unsigned char *));
 537 bfd_signed_vma  bfd_getl_signed_32 PARAMS ((const unsigned char *));
 538 bfd_vma         bfd_getb16         PARAMS ((const unsigned char *));
 539 bfd_vma         bfd_getl16         PARAMS ((const unsigned char *));
 540 bfd_signed_vma  bfd_getb_signed_16 PARAMS ((const unsigned char *));
 541 bfd_signed_vma  bfd_getl_signed_16 PARAMS ((const unsigned char *));
 542 void            bfd_putb64         PARAMS ((bfd_vma, unsigned char *));
 543 void            bfd_putl64         PARAMS ((bfd_vma, unsigned char *));
 544 void            bfd_putb32         PARAMS ((bfd_vma, unsigned char *));
 545 void            bfd_putl32         PARAMS ((bfd_vma, unsigned char *));
 546 void            bfd_putb16         PARAMS ((bfd_vma, unsigned char *));
 547 void            bfd_putl16         PARAMS ((bfd_vma, unsigned char *));
 548
 549 /* Byte swapping routines which take size and endiannes as arguments.  */
 550
 551 bfd_vma         bfd_get_bits       PARAMS ((bfd_byte *, int, boolean));
 552 void            bfd_put_bits       PARAMS ((bfd_vma, bfd_byte *, int, boolean));
 553 \f
 554 /* Externally visible ECOFF routines.  */
 555
 556 #if defined(__STDC__) || defined(ALMOST_STDC)
 557 struct ecoff_debug_info;
 558 struct ecoff_debug_swap;
 559 struct ecoff_extr;
 560 struct symbol_cache_entry;
 561 struct bfd_link_info;
 562 struct bfd_link_hash_entry;
 563 struct bfd_elf_version_tree;
 564 #endif
 565 extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd));
 566 extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value));
 567 extern boolean bfd_ecoff_set_regmasks
 568   PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask,
 569            unsigned long *cprmask));
 570 extern PTR bfd_ecoff_debug_init
 571   PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug,
 572            const struct ecoff_debug_swap *output_swap,
 573            struct bfd_link_info *));
 574 extern void bfd_ecoff_debug_free
 575   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 576            const struct ecoff_debug_swap *output_swap,
 577            struct bfd_link_info *));
 578 extern boolean bfd_ecoff_debug_accumulate
 579   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 580            const struct ecoff_debug_swap *output_swap,
 581            bfd *input_bfd, struct ecoff_debug_info *input_debug,
 582            const struct ecoff_debug_swap *input_swap,
 583            struct bfd_link_info *));
 584 extern boolean bfd_ecoff_debug_accumulate_other
 585   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 586            const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
 587            struct bfd_link_info *));
 588 extern boolean bfd_ecoff_debug_externals
 589   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 590            const struct ecoff_debug_swap *swap,
 591            boolean relocateable,
 592            boolean (*get_extr) (struct symbol_cache_entry *,
 593                                 struct ecoff_extr *),
 594            void (*set_index) (struct symbol_cache_entry *,
 595                               bfd_size_type)));
 596 extern boolean bfd_ecoff_debug_one_external
 597   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 598            const struct ecoff_debug_swap *swap,
 599            const char *name, struct ecoff_extr *esym));
 600 extern bfd_size_type bfd_ecoff_debug_size
 601   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 602            const struct ecoff_debug_swap *swap));
 603 extern boolean bfd_ecoff_write_debug
 604   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 605            const struct ecoff_debug_swap *swap, file_ptr where));
 606 extern boolean bfd_ecoff_write_accumulated_debug
 607   PARAMS ((PTR handle, bfd *abfd, struct ecoff_debug_info *debug,
 608            const struct ecoff_debug_swap *swap,
 609            struct bfd_link_info *info, file_ptr where));
 610 extern boolean bfd_mips_ecoff_create_embedded_relocs
 611   PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *,
 612            char **));
 613
 614 /* Externally visible ELF routines.  */
 615
 616 struct bfd_link_needed_list
 617 {
 618   struct bfd_link_needed_list *next;
 619   bfd *by;
 620   const char *name;
 621 };
 622
 623 extern boolean bfd_elf32_record_link_assignment
 624   PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean));
 625 extern boolean bfd_elf64_record_link_assignment
 626   PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean));
 627 extern struct bfd_link_needed_list *bfd_elf_get_needed_list
 628   PARAMS ((bfd *, struct bfd_link_info *));
 629 extern boolean bfd_elf_get_bfd_needed_list
 630   PARAMS ((bfd *, struct bfd_link_needed_list **));
 631 extern boolean bfd_elf32_size_dynamic_sections
 632   PARAMS ((bfd *, const char *, const char *, const char *,
 633            const char * const *, struct bfd_link_info *, struct sec **,
 634            struct bfd_elf_version_tree *));
 635 extern boolean bfd_elf64_size_dynamic_sections
 636   PARAMS ((bfd *, const char *, const char *, const char *,
 637            const char * const *, struct bfd_link_info *, struct sec **,
 638            struct bfd_elf_version_tree *));
 639 extern void bfd_elf_set_dt_needed_name PARAMS ((bfd *, const char *));
 640 extern void bfd_elf_set_dt_needed_soname PARAMS ((bfd *, const char *));
 641 extern const char *bfd_elf_get_dt_soname PARAMS ((bfd *));
 642 extern struct bfd_link_needed_list *bfd_elf_get_runpath_list
 643   PARAMS ((bfd *, struct bfd_link_info *));
 644
 645 /* Return an upper bound on the number of bytes required to store a
 646    copy of ABFD's program header table entries.  Return -1 if an error
 647    occurs; bfd_get_error will return an appropriate code.  */
 648 extern long bfd_get_elf_phdr_upper_bound PARAMS ((bfd *abfd));
 649
 650 /* Copy ABFD's program header table entries to *PHDRS.  The entries
 651    will be stored as an array of Elf_Internal_Phdr structures, as
 652    defined in include/elf/internal.h.  To find out how large the
 653    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
 654
 655    Return the number of program header table entries read, or -1 if an
 656    error occurs; bfd_get_error will return an appropriate code.  */
 657 extern int bfd_get_elf_phdrs PARAMS ((bfd *abfd, void *phdrs));
 658
 659 /* Return the arch_size field of an elf bfd, or -1 if not elf.  */
 660 extern int bfd_get_arch_size PARAMS ((bfd *));
 661
 662 /* Return true if address "naturally" sign extends, or -1 if not elf.  */
 663 extern int bfd_get_sign_extend_vma PARAMS ((bfd *));
 664
 665 extern boolean bfd_m68k_elf32_create_embedded_relocs
 666   PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *,
 667            char **));
 668
 669 /* SunOS shared library support routines for the linker.  */
 670
 671 extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
 672   PARAMS ((bfd *, struct bfd_link_info *));
 673 extern boolean bfd_sunos_record_link_assignment
 674   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 675 extern boolean bfd_sunos_size_dynamic_sections
 676   PARAMS ((bfd *, struct bfd_link_info *, struct sec **, struct sec **,
 677            struct sec **));
 678
 679 /* Linux shared library support routines for the linker.  */
 680
 681 extern boolean bfd_i386linux_size_dynamic_sections
 682   PARAMS ((bfd *, struct bfd_link_info *));
 683 extern boolean bfd_m68klinux_size_dynamic_sections
 684   PARAMS ((bfd *, struct bfd_link_info *));
 685 extern boolean bfd_sparclinux_size_dynamic_sections
 686   PARAMS ((bfd *, struct bfd_link_info *));
 687
 688 /* mmap hacks */
 689
 690 struct _bfd_window_internal;
 691 typedef struct _bfd_window_internal bfd_window_internal;
 692
 693 typedef struct _bfd_window {
 694   /* What the user asked for.  */
 695   PTR data;
 696   bfd_size_type size;
 697   /* The actual window used by BFD.  Small user-requested read-only
 698      regions sharing a page may share a single window into the object
 699      file.  Read-write versions shouldn't until I've fixed things to
 700      keep track of which portions have been claimed by the
 701      application; don't want to give the same region back when the
 702      application wants two writable copies!  */
 703   struct _bfd_window_internal *i;
 704 } bfd_window;
 705
 706 extern void bfd_init_window PARAMS ((bfd_window *));
 707 extern void bfd_free_window PARAMS ((bfd_window *));
 708 extern boolean bfd_get_file_window
 709   PARAMS ((bfd *, file_ptr, bfd_size_type, bfd_window *, boolean));
 710
 711 /* XCOFF support routines for the linker.  */
 712
 713 extern boolean bfd_xcoff_link_record_set
 714   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
 715            bfd_size_type));
 716 extern boolean bfd_xcoff_import_symbol
 717   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
 718            bfd_vma, const char *, const char *, const char *));
 719 extern boolean bfd_xcoff_export_symbol
 720   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
 721            boolean));
 722 extern boolean bfd_xcoff_link_count_reloc
 723   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 724 extern boolean bfd_xcoff_record_link_assignment
 725   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 726 extern boolean bfd_xcoff_size_dynamic_sections
 727   PARAMS ((bfd *, struct bfd_link_info *, const char *, const char *,
 728            unsigned long, unsigned long, unsigned long, boolean,
 729            int, boolean, boolean, struct sec **));
 730
 731 /* Externally visible COFF routines.  */
 732
 733 #if defined(__STDC__) || defined(ALMOST_STDC)
 734 struct internal_syment;
 735 union internal_auxent;
 736 #endif
 737
 738 extern boolean bfd_coff_get_syment
 739   PARAMS ((bfd *, struct symbol_cache_entry *, struct internal_syment *));
 740
 741 extern boolean bfd_coff_get_auxent
 742   PARAMS ((bfd *, struct symbol_cache_entry *, int, union internal_auxent *));
 743
 744 extern boolean bfd_coff_set_symbol_class
 745   PARAMS ((bfd *, struct symbol_cache_entry *, unsigned int));
 746
 747 extern boolean bfd_m68k_coff_create_embedded_relocs
 748   PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *,
 749            char **));
 750
 751 /* ARM Interworking support.  Called from linker.  */
 752 extern boolean bfd_arm_allocate_interworking_sections
 753   PARAMS ((struct bfd_link_info *));
 754
 755 extern boolean bfd_arm_process_before_allocation
 756   PARAMS ((bfd *, struct bfd_link_info *, int));
 757
 758 extern boolean bfd_arm_get_bfd_for_interworking
 759   PARAMS ((bfd *, struct bfd_link_info *));
 760
 761 /* PE ARM Interworking support.  Called from linker.  */
 762 extern boolean bfd_arm_pe_allocate_interworking_sections
 763   PARAMS ((struct bfd_link_info *));
 764
 765 extern boolean bfd_arm_pe_process_before_allocation
 766   PARAMS ((bfd *, struct bfd_link_info *, int));
 767
 768 extern boolean bfd_arm_pe_get_bfd_for_interworking
 769   PARAMS ((bfd *, struct bfd_link_info *));
 770
 771 /* ELF ARM Interworking support.  Called from linker.  */
 772 extern boolean bfd_elf32_arm_allocate_interworking_sections
 773   PARAMS ((struct bfd_link_info *));
 774
 775 extern boolean bfd_elf32_arm_process_before_allocation
 776   PARAMS ((bfd *, struct bfd_link_info *, int));
 777
 778 extern boolean bfd_elf32_arm_get_bfd_for_interworking
 779   PARAMS ((bfd *, struct bfd_link_info *));
 780
 781 /* TI COFF load page support.  */
 782 extern void bfd_ticoff_set_section_load_page
 783   PARAMS ((struct sec *, int));
 784
 785 extern int bfd_ticoff_get_section_load_page
 786   PARAMS ((struct sec *));
 787
 788 /* And more from the source.  */
 789 void
 790 bfd_init PARAMS ((void));
 791
 792 bfd *
 793 bfd_openr PARAMS ((CONST char *filename, CONST char *target));
 794
 795 bfd *
 796 bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd));
 797
 798 bfd *
 799 bfd_openstreamr PARAMS ((const char *, const char *, PTR));
 800
 801 bfd *
 802 bfd_openw PARAMS ((CONST char *filename, CONST char *target));
 803
 804 boolean
 805 bfd_close PARAMS ((bfd *abfd));
 806
 807 boolean
 808 bfd_close_all_done PARAMS ((bfd *));
 809
 810 bfd *
 811 bfd_create PARAMS ((CONST char *filename, bfd *templ));
 812
 813 boolean
 814 bfd_make_writable PARAMS ((bfd *abfd));
 815
 816 boolean
 817 bfd_make_readable PARAMS ((bfd *abfd));
 818
 819
 820 /* Byte swapping macros for user section data.  */
 821
 822 #define bfd_put_8(abfd, val, ptr) \
 823                 ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val)))
 824 #define bfd_put_signed_8 \
 825                bfd_put_8
 826 #define bfd_get_8(abfd, ptr) \
 827                 (*(unsigned char *) (ptr))
 828 #define bfd_get_signed_8(abfd, ptr) \
 829                ((*(unsigned char *) (ptr) ^ 0x80) - 0x80)
 830
 831 #define bfd_put_16(abfd, val, ptr) \
 832                 BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
 833 #define bfd_put_signed_16 \
 834                 bfd_put_16
 835 #define bfd_get_16(abfd, ptr) \
 836                 BFD_SEND(abfd, bfd_getx16, (ptr))
 837 #define bfd_get_signed_16(abfd, ptr) \
 838                 BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
 839
 840 #define bfd_put_32(abfd, val, ptr) \
 841                 BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
 842 #define bfd_put_signed_32 \
 843                 bfd_put_32
 844 #define bfd_get_32(abfd, ptr) \
 845                 BFD_SEND(abfd, bfd_getx32, (ptr))
 846 #define bfd_get_signed_32(abfd, ptr) \
 847                 BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
 848
 849 #define bfd_put_64(abfd, val, ptr) \
 850                 BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
 851 #define bfd_put_signed_64 \
 852                 bfd_put_64
 853 #define bfd_get_64(abfd, ptr) \
 854                 BFD_SEND(abfd, bfd_getx64, (ptr))
 855 #define bfd_get_signed_64(abfd, ptr) \
 856                 BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
 857
 858 #define bfd_get(bits, abfd, ptr)                               \
 859                 ((bits) == 8 ? bfd_get_8 (abfd, ptr)           \
 860                 : (bits) == 16 ? bfd_get_16 (abfd, ptr)        \
 861                 : (bits) == 32 ? bfd_get_32 (abfd, ptr)        \
 862                 : (bits) == 64 ? bfd_get_64 (abfd, ptr)        \
 863                 : (abort (), (bfd_vma) - 1))
 864
 865 #define bfd_put(bits, abfd, val, ptr)                          \
 866                 ((bits) == 8 ? bfd_put_8 (abfd, val, ptr)      \
 867                 : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)   \
 868                 : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)   \
 869                 : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)   \
 870                 : (abort (), (void) 0))
 871
 872
 873 /* Byte swapping macros for file header data.  */
 874
 875 #define bfd_h_put_8(abfd, val, ptr) \
 876                bfd_put_8 (abfd, val, ptr)
 877 #define bfd_h_put_signed_8(abfd, val, ptr) \
 878                bfd_put_8 (abfd, val, ptr)
 879 #define bfd_h_get_8(abfd, ptr) \
 880                bfd_get_8 (abfd, ptr)
 881 #define bfd_h_get_signed_8(abfd, ptr) \
 882                bfd_get_signed_8 (abfd, ptr)
 883
 884 #define bfd_h_put_16(abfd, val, ptr) \
 885                 BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
 886 #define bfd_h_put_signed_16 \
 887                 bfd_h_put_16
 888 #define bfd_h_get_16(abfd, ptr) \
 889                 BFD_SEND(abfd, bfd_h_getx16,(ptr))
 890 #define bfd_h_get_signed_16(abfd, ptr) \
 891                 BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
 892
 893 #define bfd_h_put_32(abfd, val, ptr) \
 894                 BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
 895 #define bfd_h_put_signed_32 \
 896                 bfd_h_put_32
 897 #define bfd_h_get_32(abfd, ptr) \
 898                 BFD_SEND(abfd, bfd_h_getx32,(ptr))
 899 #define bfd_h_get_signed_32(abfd, ptr) \
 900                 BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
 901
 902 #define bfd_h_put_64(abfd, val, ptr) \
 903                 BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
 904 #define bfd_h_put_signed_64 \
 905                 bfd_h_put_64
 906 #define bfd_h_get_64(abfd, ptr) \
 907                 BFD_SEND(abfd, bfd_h_getx64,(ptr))
 908 #define bfd_h_get_signed_64(abfd, ptr) \
 909                 BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
 910
 911 /* This structure is used for a comdat section, as in PE.  A comdat
 912    section is associated with a particular symbol.  When the linker
 913    sees a comdat section, it keeps only one of the sections with a
 914    given name and associated with a given symbol.  */
 915
 916 struct bfd_comdat_info
 917 {
 918   /* The name of the symbol associated with a comdat section.  */
 919   const char *name;
 920
 921   /* The local symbol table index of the symbol associated with a
 922      comdat section.  This is only meaningful to the object file format
 923      specific code; it is not an index into the list returned by
 924      bfd_canonicalize_symtab.  */
 925   long symbol;
 926 };
 927
 928 typedef struct sec
 929 {
 930   /* The name of the section; the name isn't a copy, the pointer is
 931      the same as that passed to bfd_make_section.  */
 932
 933   const char *name;
 934
 935   /* A unique sequence number.  */
 936
 937   int id;
 938
 939   /* Which section is it; 0..nth.  */
 940
 941   int index;
 942
 943   /* The next section in the list belonging to the BFD, or NULL.  */
 944
 945   struct sec *next;
 946
 947   /* The field flags contains attributes of the section. Some
 948      flags are read in from the object file, and some are
 949      synthesized from other information.  */
 950
 951   flagword flags;
 952
 953 #define SEC_NO_FLAGS   0x000
 954
 955   /* Tells the OS to allocate space for this section when loading.
 956      This is clear for a section containing debug information only.  */
 957 #define SEC_ALLOC      0x001
 958
 959   /* Tells the OS to load the section from the file when loading.
 960      This is clear for a .bss section.  */
 961 #define SEC_LOAD       0x002
 962
 963   /* The section contains data still to be relocated, so there is
 964      some relocation information too.  */
 965 #define SEC_RELOC      0x004
 966
 967 #if 0   /* Obsolete ? */
 968 #define SEC_BALIGN     0x008
 969 #endif
 970
 971   /* A signal to the OS that the section contains read only data.  */
 972 #define SEC_READONLY   0x010
 973
 974   /* The section contains code only.  */
 975 #define SEC_CODE       0x020
 976
 977   /* The section contains data only.  */
 978 #define SEC_DATA       0x040
 979
 980   /* The section will reside in ROM.  */
 981 #define SEC_ROM        0x080
 982
 983   /* The section contains constructor information. This section
 984      type is used by the linker to create lists of constructors and
 985      destructors used by <<g++>>. When a back end sees a symbol
 986      which should be used in a constructor list, it creates a new
 987      section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
 988      the symbol to it, and builds a relocation. To build the lists
 989      of constructors, all the linker has to do is catenate all the
 990      sections called <<__CTOR_LIST__>> and relocate the data
 991      contained within - exactly the operations it would peform on
 992      standard data.  */
 993 #define SEC_CONSTRUCTOR 0x100
 994
 995   /* The section is a constructor, and should be placed at the
 996      end of the text, data, or bss section(?).  */
 997 #define SEC_CONSTRUCTOR_TEXT 0x1100
 998 #define SEC_CONSTRUCTOR_DATA 0x2100
 999 #define SEC_CONSTRUCTOR_BSS  0x3100
1000
1001   /* The section has contents - a data section could be
1002      <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
1003      <<SEC_HAS_CONTENTS>>  */
1004 #define SEC_HAS_CONTENTS 0x200
1005
1006   /* An instruction to the linker to not output the section
1007      even if it has information which would normally be written.  */
1008 #define SEC_NEVER_LOAD 0x400
1009
1010   /* The section is a COFF shared library section.  This flag is
1011      only for the linker.  If this type of section appears in
1012      the input file, the linker must copy it to the output file
1013      without changing the vma or size.  FIXME: Although this
1014      was originally intended to be general, it really is COFF
1015      specific (and the flag was renamed to indicate this).  It
1016      might be cleaner to have some more general mechanism to
1017      allow the back end to control what the linker does with
1018      sections.  */
1019 #define SEC_COFF_SHARED_LIBRARY 0x800
1020
1021   /* The section has GOT references.  This flag is only for the
1022      linker, and is currently only used by the elf32-hppa back end.
1023      It will be set if global offset table references were detected
1024      in this section, which indicate to the linker that the section
1025      contains PIC code, and must be handled specially when doing a
1026      static link.  */
1027 #define SEC_HAS_GOT_REF 0x4000
1028
1029   /* The section contains common symbols (symbols may be defined
1030      multiple times, the value of a symbol is the amount of
1031      space it requires, and the largest symbol value is the one
1032      used).  Most targets have exactly one of these (which we
1033      translate to bfd_com_section_ptr), but ECOFF has two.  */
1034 #define SEC_IS_COMMON 0x8000
1035
1036   /* The section contains only debugging information.  For
1037      example, this is set for ELF .debug and .stab sections.
1038      strip tests this flag to see if a section can be
1039      discarded.  */
1040 #define SEC_DEBUGGING 0x10000
1041
1042   /* The contents of this section are held in memory pointed to
1043      by the contents field.  This is checked by bfd_get_section_contents,
1044      and the data is retrieved from memory if appropriate.  */
1045 #define SEC_IN_MEMORY 0x20000
1046
1047   /* The contents of this section are to be excluded by the
1048      linker for executable and shared objects unless those
1049      objects are to be further relocated.  */
1050 #define SEC_EXCLUDE 0x40000
1051
1052   /* The contents of this section are to be sorted by the
1053      based on the address specified in the associated symbol
1054      table.  */
1055 #define SEC_SORT_ENTRIES 0x80000
1056
1057   /* When linking, duplicate sections of the same name should be
1058      discarded, rather than being combined into a single section as
1059      is usually done.  This is similar to how common symbols are
1060      handled.  See SEC_LINK_DUPLICATES below.  */
1061 #define SEC_LINK_ONCE 0x100000
1062
1063   /* If SEC_LINK_ONCE is set, this bitfield describes how the linker
1064      should handle duplicate sections.  */
1065 #define SEC_LINK_DUPLICATES 0x600000
1066
1067   /* This value for SEC_LINK_DUPLICATES means that duplicate
1068      sections with the same name should simply be discarded.  */
1069 #define SEC_LINK_DUPLICATES_DISCARD 0x0
1070
1071   /* This value for SEC_LINK_DUPLICATES means that the linker
1072      should warn if there are any duplicate sections, although
1073      it should still only link one copy.  */
1074 #define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000
1075
1076   /* This value for SEC_LINK_DUPLICATES means that the linker
1077      should warn if any duplicate sections are a different size.  */
1078 #define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000
1079
1080   /* This value for SEC_LINK_DUPLICATES means that the linker
1081      should warn if any duplicate sections contain different
1082      contents.  */
1083 #define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000
1084
1085   /* This section was created by the linker as part of dynamic
1086      relocation or other arcane processing.  It is skipped when
1087      going through the first-pass output, trusting that someone
1088      else up the line will take care of it later.  */
1089 #define SEC_LINKER_CREATED 0x800000
1090
1091   /* This section should not be subject to garbage collection.  */
1092 #define SEC_KEEP 0x1000000
1093
1094   /* This section contains "short" data, and should be placed
1095      "near" the GP.  */
1096 #define SEC_SMALL_DATA 0x2000000
1097
1098   /* This section contains data which may be shared with other
1099      executables or shared objects.  */
1100 #define SEC_SHARED 0x4000000
1101
1102   /* When a section with this flag is being linked, then if the size of
1103      the input section is less than a page, it should not cross a page
1104      boundary.  If the size of the input section is one page or more, it
1105      should be aligned on a page boundary.  */
1106 #define SEC_BLOCK 0x8000000
1107
1108   /* Conditionally link this section; do not link if there are no
1109      references found to any symbol in the section.  */
1110 #define SEC_CLINK 0x10000000
1111
1112   /* Attempt to merge identical entities in the section.
1113      Entity size is given in the entsize field.  */
1114 #define SEC_MERGE 0x20000000
1115
1116   /* If given with SEC_MERGE, entities to merge are zero terminated
1117      strings where entsize specifies character size instead of fixed
1118      size entries.  */
1119 #define SEC_STRINGS 0x40000000
1120
1121   /*  End of section flags.  */
1122
1123   /* Some internal packed boolean fields.  */
1124
1125   /* See the vma field.  */
1126   unsigned int user_set_vma : 1;
1127
1128   /* Whether relocations have been processed.  */
1129   unsigned int reloc_done : 1;
1130
1131   /* A mark flag used by some of the linker backends.  */
1132   unsigned int linker_mark : 1;
1133
1134   /* Another mark flag used by some of the linker backends.  Set for
1135      output sections that have a input section.  */
1136   unsigned int linker_has_input : 1;
1137
1138   /* A mark flag used by some linker backends for garbage collection.  */
1139   unsigned int gc_mark : 1;
1140
1141   /* Used by the ELF code to mark sections which have been allocated to segments.  */
1142   unsigned int segment_mark : 1;
1143
1144   /* End of internal packed boolean fields.  */
1145
1146   /*  The virtual memory address of the section - where it will be
1147       at run time.  The symbols are relocated against this.  The
1148       user_set_vma flag is maintained by bfd; if it's not set, the
1149       backend can assign addresses (for example, in <<a.out>>, where
1150       the default address for <<.data>> is dependent on the specific
1151       target and various flags).  */
1152
1153   bfd_vma vma;
1154
1155   /*  The load address of the section - where it would be in a
1156       rom image; really only used for writing section header
1157       information. */
1158
1159   bfd_vma lma;
1160
1161   /* The size of the section in octets, as it will be output.
1162      Contains a value even if the section has no contents (e.g., the
1163      size of <<.bss>>).  This will be filled in after relocation.  */
1164
1165   bfd_size_type _cooked_size;
1166
1167   /* The original size on disk of the section, in octets.  Normally this
1168      value is the same as the size, but if some relaxing has
1169      been done, then this value will be bigger.  */
1170
1171   bfd_size_type _raw_size;
1172
1173   /* If this section is going to be output, then this value is the
1174      offset in *bytes* into the output section of the first byte in the
1175      input section (byte ==> smallest addressable unit on the
1176      target).  In most cases, if this was going to start at the
1177      100th octet (8-bit quantity) in the output section, this value
1178      would be 100.  However, if the target byte size is 16 bits
1179      (bfd_octets_per_byte is "2"), this value would be 50.  */
1180
1181   bfd_vma output_offset;
1182
1183   /* The output section through which to map on output.  */
1184
1185   struct sec *output_section;
1186
1187   /* The alignment requirement of the section, as an exponent of 2 -
1188      e.g., 3 aligns to 2^3 (or 8).  */
1189
1190   unsigned int alignment_power;
1191
1192   /* If an input section, a pointer to a vector of relocation
1193      records for the data in this section.  */
1194
1195   struct reloc_cache_entry *relocation;
1196
1197   /* If an output section, a pointer to a vector of pointers to
1198      relocation records for the data in this section.  */
1199
1200   struct reloc_cache_entry **orelocation;
1201
1202   /* The number of relocation records in one of the above  */
1203
1204   unsigned reloc_count;
1205
1206   /* Information below is back end specific - and not always used
1207      or updated.  */
1208
1209   /* File position of section data.  */
1210
1211   file_ptr filepos;
1212
1213   /* File position of relocation info.  */
1214
1215   file_ptr rel_filepos;
1216
1217   /* File position of line data.  */
1218
1219   file_ptr line_filepos;
1220
1221   /* Pointer to data for applications.  */
1222
1223   PTR userdata;
1224
1225   /* If the SEC_IN_MEMORY flag is set, this points to the actual
1226      contents.  */
1227   unsigned char *contents;
1228
1229   /* Attached line number information.  */
1230
1231   alent *lineno;
1232
1233   /* Number of line number records.  */
1234
1235   unsigned int lineno_count;
1236
1237   /* Entity size for merging purposes.  */
1238
1239   unsigned int entsize;
1240
1241   /* Optional information about a COMDAT entry; NULL if not COMDAT.  */
1242
1243   struct bfd_comdat_info *comdat;
1244
1245   /* Points to the kept section if this section is a link-once section,
1246      and is discarded.  */
1247   struct sec *kept_section;
1248
1249   /* When a section is being output, this value changes as more
1250      linenumbers are written out.  */
1251
1252   file_ptr moving_line_filepos;
1253
1254   /* What the section number is in the target world.  */
1255
1256   int target_index;
1257
1258   PTR used_by_bfd;
1259
1260   /* If this is a constructor section then here is a list of the
1261      relocations created to relocate items within it.  */
1262
1263   struct relent_chain *constructor_chain;
1264
1265   /* The BFD which owns the section.  */
1266
1267   bfd *owner;
1268
1269   /* A symbol which points at this section only */
1270   struct symbol_cache_entry *symbol;
1271   struct symbol_cache_entry **symbol_ptr_ptr;
1272
1273   struct bfd_link_order *link_order_head;
1274   struct bfd_link_order *link_order_tail;
1275 } asection ;
1276
1277 /* These sections are global, and are managed by BFD.  The application
1278    and target back end are not permitted to change the values in
1279    these sections.  New code should use the section_ptr macros rather
1280    than referring directly to the const sections.  The const sections
1281    may eventually vanish.  */
1282 #define BFD_ABS_SECTION_NAME "*ABS*"
1283 #define BFD_UND_SECTION_NAME "*UND*"
1284 #define BFD_COM_SECTION_NAME "*COM*"
1285 #define BFD_IND_SECTION_NAME "*IND*"
1286
1287 /* the absolute section */
1288 extern const asection bfd_abs_section;
1289 #define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
1290 #define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
1291 /* Pointer to the undefined section */
1292 extern const asection bfd_und_section;
1293 #define bfd_und_section_ptr ((asection *) &bfd_und_section)
1294 #define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
1295 /* Pointer to the common section */
1296 extern const asection bfd_com_section;
1297 #define bfd_com_section_ptr ((asection *) &bfd_com_section)
1298 /* Pointer to the indirect section */
1299 extern const asection bfd_ind_section;
1300 #define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
1301 #define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
1302
1303 extern const struct symbol_cache_entry * const bfd_abs_symbol;
1304 extern const struct symbol_cache_entry * const bfd_com_symbol;
1305 extern const struct symbol_cache_entry * const bfd_und_symbol;
1306 extern const struct symbol_cache_entry * const bfd_ind_symbol;
1307 #define bfd_get_section_size_before_reloc(section) \
1308      ((section)->reloc_done ? (abort (), (bfd_size_type) 1) \
1309                             : (section)->_raw_size)
1310 #define bfd_get_section_size_after_reloc(section) \
1311      ((section)->reloc_done ? (section)->_cooked_size \
1312                             : (abort (), (bfd_size_type) 1))
1313 asection *
1314 bfd_get_section_by_name PARAMS ((bfd *abfd, const char *name));
1315
1316 char *
1317 bfd_get_unique_section_name PARAMS ((bfd *abfd,
1318     const char *templat,
1319     int *count));
1320
1321 asection *
1322 bfd_make_section_old_way PARAMS ((bfd *abfd, const char *name));
1323
1324 asection *
1325 bfd_make_section_anyway PARAMS ((bfd *abfd, const char *name));
1326
1327 asection *
1328 bfd_make_section PARAMS ((bfd *, const char *name));
1329
1330 boolean
1331 bfd_set_section_flags PARAMS ((bfd *abfd, asection *sec, flagword flags));
1332
1333 void
1334 bfd_map_over_sections PARAMS ((bfd *abfd,
1335     void (*func) (bfd *abfd,
1336     asection *sect,
1337     PTR obj),
1338     PTR obj));
1339
1340 boolean
1341 bfd_set_section_size PARAMS ((bfd *abfd, asection *sec, bfd_size_type val));
1342
1343 boolean
1344 bfd_set_section_contents PARAMS ((bfd *abfd,
1345     asection *section,
1346     PTR data,
1347     file_ptr offset,
1348     bfd_size_type count));
1349
1350 boolean
1351 bfd_get_section_contents PARAMS ((bfd *abfd, asection *section, PTR location,
1352     file_ptr offset, bfd_size_type count));
1353
1354 boolean
1355 bfd_copy_private_section_data PARAMS ((bfd *ibfd, asection *isec, bfd *obfd, asection *osec));
1356
1357 #define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
1358      BFD_SEND (obfd, _bfd_copy_private_section_data, \
1359                (ibfd, isection, obfd, osection))
1360 void
1361 _bfd_strip_section_from_output PARAMS ((struct bfd_link_info *info, asection *section));
1362
1363 enum bfd_architecture
1364 {
1365   bfd_arch_unknown,   /* File arch not known */
1366   bfd_arch_obscure,   /* Arch known, not one of these */
1367   bfd_arch_m68k,      /* Motorola 68xxx */
1368 #define bfd_mach_m68000 1
1369 #define bfd_mach_m68008 2
1370 #define bfd_mach_m68010 3
1371 #define bfd_mach_m68020 4
1372 #define bfd_mach_m68030 5
1373 #define bfd_mach_m68040 6
1374 #define bfd_mach_m68060 7
1375 #define bfd_mach_cpu32  8
1376 #define bfd_mach_mcf5200  9
1377 #define bfd_mach_mcf5206e 10
1378 #define bfd_mach_mcf5307  11
1379 #define bfd_mach_mcf5407  12
1380   bfd_arch_vax,       /* DEC Vax */
1381   bfd_arch_i960,      /* Intel 960 */
1382     /* The order of the following is important.
1383        lower number indicates a machine type that
1384        only accepts a subset of the instructions
1385        available to machines with higher numbers.
1386        The exception is the "ca", which is
1387        incompatible with all other machines except
1388        "core". */
1389
1390 #define bfd_mach_i960_core      1
1391 #define bfd_mach_i960_ka_sa     2
1392 #define bfd_mach_i960_kb_sb     3
1393 #define bfd_mach_i960_mc        4
1394 #define bfd_mach_i960_xa        5
1395 #define bfd_mach_i960_ca        6
1396 #define bfd_mach_i960_jx        7
1397 #define bfd_mach_i960_hx        8
1398
1399   bfd_arch_a29k,      /* AMD 29000 */
1400   bfd_arch_sparc,     /* SPARC */
1401 #define bfd_mach_sparc                 1
1402 /* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */
1403 #define bfd_mach_sparc_sparclet        2
1404 #define bfd_mach_sparc_sparclite       3
1405 #define bfd_mach_sparc_v8plus          4
1406 #define bfd_mach_sparc_v8plusa         5 /* with ultrasparc add'ns */
1407 #define bfd_mach_sparc_sparclite_le    6
1408 #define bfd_mach_sparc_v9              7
1409 #define bfd_mach_sparc_v9a             8 /* with ultrasparc add'ns */
1410 #define bfd_mach_sparc_v8plusb         9 /* with cheetah add'ns */
1411 #define bfd_mach_sparc_v9b             10 /* with cheetah add'ns */
1412 /* Nonzero if MACH has the v9 instruction set.  */
1413 #define bfd_mach_sparc_v9_p(mach) \
1414   ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \
1415    && (mach) != bfd_mach_sparc_sparclite_le)
1416   bfd_arch_mips,      /* MIPS Rxxxx */
1417 #define bfd_mach_mips3000              3000
1418 #define bfd_mach_mips3900              3900
1419 #define bfd_mach_mips4000              4000
1420 #define bfd_mach_mips4010              4010
1421 #define bfd_mach_mips4100              4100
1422 #define bfd_mach_mips4111              4111
1423 #define bfd_mach_mips4300              4300
1424 #define bfd_mach_mips4400              4400
1425 #define bfd_mach_mips4600              4600
1426 #define bfd_mach_mips4650              4650
1427 #define bfd_mach_mips5000              5000
1428 #define bfd_mach_mips6000              6000
1429 #define bfd_mach_mips8000              8000
1430 #define bfd_mach_mips10000             10000
1431 #define bfd_mach_mips12000             12000
1432 #define bfd_mach_mips16                16
1433 #define bfd_mach_mips32                32
1434 #define bfd_mach_mips32_4k             3204113 /* 32, 04, octal 'K' */
1435 #define bfd_mach_mips5                 5
1436 #define bfd_mach_mips64                64
1437 #define bfd_mach_mips_sb1              12310201 /* octal 'SB', 01 */
1438   bfd_arch_i386,      /* Intel 386 */
1439 #define bfd_mach_i386_i386 0
1440 #define bfd_mach_i386_i8086 1
1441 #define bfd_mach_i386_i386_intel_syntax 2
1442 #define bfd_mach_x86_64 3
1443 #define bfd_mach_x86_64_intel_syntax 4
1444   bfd_arch_we32k,     /* AT&T WE32xxx */
1445   bfd_arch_tahoe,     /* CCI/Harris Tahoe */
1446   bfd_arch_i860,      /* Intel 860 */
1447   bfd_arch_i370,      /* IBM 360/370 Mainframes */
1448   bfd_arch_romp,      /* IBM ROMP PC/RT */
1449   bfd_arch_alliant,   /* Alliant */
1450   bfd_arch_convex,    /* Convex */
1451   bfd_arch_m88k,      /* Motorola 88xxx */
1452   bfd_arch_pyramid,   /* Pyramid Technology */
1453   bfd_arch_h8300,     /* Hitachi H8/300 */
1454 #define bfd_mach_h8300   1
1455 #define bfd_mach_h8300h  2
1456 #define bfd_mach_h8300s  3
1457   bfd_arch_pdp11,     /* DEC PDP-11 */
1458   bfd_arch_powerpc,   /* PowerPC */
1459 #define bfd_mach_ppc           0
1460 #define bfd_mach_ppc_403       403
1461 #define bfd_mach_ppc_403gc     4030
1462 #define bfd_mach_ppc_505       505
1463 #define bfd_mach_ppc_601       601
1464 #define bfd_mach_ppc_602       602
1465 #define bfd_mach_ppc_603       603
1466 #define bfd_mach_ppc_ec603e    6031
1467 #define bfd_mach_ppc_604       604
1468 #define bfd_mach_ppc_620       620
1469 #define bfd_mach_ppc_630       630
1470 #define bfd_mach_ppc_750       750
1471 #define bfd_mach_ppc_860       860
1472 #define bfd_mach_ppc_a35       35
1473 #define bfd_mach_ppc_rs64ii    642
1474 #define bfd_mach_ppc_rs64iii   643
1475 #define bfd_mach_ppc_7400      7400
1476   bfd_arch_rs6000,    /* IBM RS/6000 */
1477 #define bfd_mach_rs6k          0
1478 #define bfd_mach_rs6k_rs1      6001
1479 #define bfd_mach_rs6k_rsc      6003
1480 #define bfd_mach_rs6k_rs2      6002
1481   bfd_arch_hppa,      /* HP PA RISC */
1482   bfd_arch_d10v,      /* Mitsubishi D10V */
1483 #define bfd_mach_d10v          0
1484 #define bfd_mach_d10v_ts2      2
1485 #define bfd_mach_d10v_ts3      3
1486   bfd_arch_d30v,      /* Mitsubishi D30V */
1487   bfd_arch_m68hc11,   /* Motorola 68HC11 */
1488   bfd_arch_m68hc12,   /* Motorola 68HC12 */
1489   bfd_arch_z8k,       /* Zilog Z8000 */
1490 #define bfd_mach_z8001         1
1491 #define bfd_mach_z8002         2
1492   bfd_arch_h8500,     /* Hitachi H8/500 */
1493   bfd_arch_sh,        /* Hitachi SH */
1494 #define bfd_mach_sh            0
1495 #define bfd_mach_sh2        0x20
1496 #define bfd_mach_sh_dsp     0x2d
1497 #define bfd_mach_sh3        0x30
1498 #define bfd_mach_sh3_dsp    0x3d
1499 #define bfd_mach_sh3e       0x3e
1500 #define bfd_mach_sh4        0x40
1501   bfd_arch_alpha,     /* Dec Alpha */
1502 #define bfd_mach_alpha_ev4  0x10
1503 #define bfd_mach_alpha_ev5  0x20
1504 #define bfd_mach_alpha_ev6  0x30
1505   bfd_arch_arm,       /* Advanced Risc Machines ARM */
1506 #define bfd_mach_arm_2         1
1507 #define bfd_mach_arm_2a        2
1508 #define bfd_mach_arm_3         3
1509 #define bfd_mach_arm_3M        4
1510 #define bfd_mach_arm_4         5
1511 #define bfd_mach_arm_4T        6
1512 #define bfd_mach_arm_5         7
1513 #define bfd_mach_arm_5T        8
1514 #define bfd_mach_arm_5TE       9
1515 #define bfd_mach_arm_XScale    10
1516   bfd_arch_ns32k,     /* National Semiconductors ns32000 */
1517   bfd_arch_w65,       /* WDC 65816 */
1518   bfd_arch_tic30,     /* Texas Instruments TMS320C30 */
1519   bfd_arch_tic54x,    /* Texas Instruments TMS320C54X */
1520   bfd_arch_tic80,     /* TI TMS320c80 (MVP) */
1521   bfd_arch_v850,      /* NEC V850 */
1522 #define bfd_mach_v850          0
1523 #define bfd_mach_v850e         'E'
1524 #define bfd_mach_v850ea        'A'
1525   bfd_arch_arc,       /* ARC Cores */
1526 #define bfd_mach_arc_5         0
1527 #define bfd_mach_arc_6         1
1528 #define bfd_mach_arc_7         2
1529 #define bfd_mach_arc_8         3
1530   bfd_arch_m32r,      /* Mitsubishi M32R/D */
1531 #define bfd_mach_m32r          0 /* backwards compatibility */
1532 #define bfd_mach_m32rx         'x'
1533   bfd_arch_mn10200,   /* Matsushita MN10200 */
1534   bfd_arch_mn10300,   /* Matsushita MN10300 */
1535 #define bfd_mach_mn10300               300
1536 #define bfd_mach_am33          330
1537   bfd_arch_fr30,
1538 #define bfd_mach_fr30          0x46523330
1539   bfd_arch_mcore,
1540   bfd_arch_ia64,      /* HP/Intel ia64 */
1541 #define bfd_mach_ia64_elf64    0
1542 #define bfd_mach_ia64_elf32    1
1543   bfd_arch_pj,
1544   bfd_arch_avr,       /* Atmel AVR microcontrollers */
1545 #define bfd_mach_avr1          1
1546 #define bfd_mach_avr2          2
1547 #define bfd_mach_avr3          3
1548 #define bfd_mach_avr4          4
1549 #define bfd_mach_avr5          5
1550   bfd_arch_cris,      /* Axis CRIS */
1551   bfd_arch_s390,      /* IBM s390 */
1552 #define bfd_mach_s390_esa      0
1553 #define bfd_mach_s390_esame    1
1554   bfd_arch_openrisc,  /* OpenRISC */
1555   bfd_arch_last
1556   };
1557
1558 typedef struct bfd_arch_info
1559 {
1560   int bits_per_word;
1561   int bits_per_address;
1562   int bits_per_byte;
1563   enum bfd_architecture arch;
1564   unsigned long mach;
1565   const char *arch_name;
1566   const char *printable_name;
1567   unsigned int section_align_power;
1568   /* True if this is the default machine for the architecture.  */
1569   boolean the_default;
1570   const struct bfd_arch_info * (*compatible)
1571        PARAMS ((const struct bfd_arch_info *a,
1572                 const struct bfd_arch_info *b));
1573
1574   boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
1575
1576   const struct bfd_arch_info *next;
1577 } bfd_arch_info_type;
1578 const char *
1579 bfd_printable_name PARAMS ((bfd *abfd));
1580
1581 const bfd_arch_info_type *
1582 bfd_scan_arch PARAMS ((const char *string));
1583
1584 const char **
1585 bfd_arch_list PARAMS ((void));
1586
1587 const bfd_arch_info_type *
1588 bfd_arch_get_compatible PARAMS ((
1589     const bfd *abfd,
1590     const bfd *bbfd));
1591
1592 void
1593 bfd_set_arch_info PARAMS ((bfd *abfd, const bfd_arch_info_type *arg));
1594
1595 enum bfd_architecture
1596 bfd_get_arch PARAMS ((bfd *abfd));
1597
1598 unsigned long
1599 bfd_get_mach PARAMS ((bfd *abfd));
1600
1601 unsigned int
1602 bfd_arch_bits_per_byte PARAMS ((bfd *abfd));
1603
1604 unsigned int
1605 bfd_arch_bits_per_address PARAMS ((bfd *abfd));
1606
1607 const bfd_arch_info_type *
1608 bfd_get_arch_info PARAMS ((bfd *abfd));
1609
1610 const bfd_arch_info_type *
1611 bfd_lookup_arch PARAMS ((enum bfd_architecture
1612     arch,
1613     unsigned long machine));
1614
1615 const char *
1616 bfd_printable_arch_mach PARAMS ((enum bfd_architecture arch, unsigned long machine));
1617
1618 unsigned int
1619 bfd_octets_per_byte PARAMS ((bfd *abfd));
1620
1621 unsigned int
1622 bfd_arch_mach_octets_per_byte PARAMS ((enum bfd_architecture arch,
1623     unsigned long machine));
1624
1625 typedef enum bfd_reloc_status
1626 {
1627        /* No errors detected */
1628   bfd_reloc_ok,
1629
1630        /* The relocation was performed, but there was an overflow. */
1631   bfd_reloc_overflow,
1632
1633        /* The address to relocate was not within the section supplied. */
1634   bfd_reloc_outofrange,
1635
1636        /* Used by special functions */
1637   bfd_reloc_continue,
1638
1639        /* Unsupported relocation size requested. */
1640   bfd_reloc_notsupported,
1641
1642        /* Unused */
1643   bfd_reloc_other,
1644
1645        /* The symbol to relocate against was undefined. */
1646   bfd_reloc_undefined,
1647
1648        /* The relocation was performed, but may not be ok - presently
1649           generated only when linking i960 coff files with i960 b.out
1650           symbols.  If this type is returned, the error_message argument
1651           to bfd_perform_relocation will be set.  */
1652   bfd_reloc_dangerous
1653  }
1654  bfd_reloc_status_type;
1655
1656
1657 typedef struct reloc_cache_entry
1658 {
1659        /* A pointer into the canonical table of pointers  */
1660   struct symbol_cache_entry **sym_ptr_ptr;
1661
1662        /* offset in section */
1663   bfd_size_type address;
1664
1665        /* addend for relocation value */
1666   bfd_vma addend;
1667
1668        /* Pointer to how to perform the required relocation */
1669   reloc_howto_type *howto;
1670
1671 } arelent;
1672 enum complain_overflow
1673 {
1674        /* Do not complain on overflow. */
1675   complain_overflow_dont,
1676
1677        /* Complain if the bitfield overflows, whether it is considered
1678           as signed or unsigned. */
1679   complain_overflow_bitfield,
1680
1681        /* Complain if the value overflows when considered as signed
1682           number. */
1683   complain_overflow_signed,
1684
1685        /* Complain if the value overflows when considered as an
1686           unsigned number. */
1687   complain_overflow_unsigned
1688 };
1689
1690 struct reloc_howto_struct
1691 {
1692        /*  The type field has mainly a documentary use - the back end can
1693            do what it wants with it, though normally the back end's
1694            external idea of what a reloc number is stored
1695            in this field. For example, a PC relative word relocation
1696            in a coff environment has the type 023 - because that's
1697            what the outside world calls a R_PCRWORD reloc. */
1698   unsigned int type;
1699
1700        /*  The value the final relocation is shifted right by. This drops
1701            unwanted data from the relocation.  */
1702   unsigned int rightshift;
1703
1704        /*  The size of the item to be relocated.  This is *not* a
1705            power-of-two measure.  To get the number of bytes operated
1706            on by a type of relocation, use bfd_get_reloc_size.  */
1707   int size;
1708
1709        /*  The number of bits in the item to be relocated.  This is used
1710            when doing overflow checking.  */
1711   unsigned int bitsize;
1712
1713        /*  Notes that the relocation is relative to the location in the
1714            data section of the addend. The relocation function will
1715            subtract from the relocation value the address of the location
1716            being relocated. */
1717   boolean pc_relative;
1718
1719        /*  The bit position of the reloc value in the destination.
1720            The relocated value is left shifted by this amount. */
1721   unsigned int bitpos;
1722
1723        /* What type of overflow error should be checked for when
1724           relocating. */
1725   enum complain_overflow complain_on_overflow;
1726
1727        /* If this field is non null, then the supplied function is
1728           called rather than the normal function. This allows really
1729           strange relocation methods to be accomodated (e.g., i960 callj
1730           instructions). */
1731   bfd_reloc_status_type (*special_function)
1732                                    PARAMS ((bfd *abfd,
1733                                             arelent *reloc_entry,
1734                                             struct symbol_cache_entry *symbol,
1735                                             PTR data,
1736                                             asection *input_section,
1737                                             bfd *output_bfd,
1738                                             char **error_message));
1739
1740        /* The textual name of the relocation type. */
1741   char *name;
1742
1743        /* Some formats record a relocation addend in the section contents
1744           rather than with the relocation.  For ELF formats this is the
1745           distinction between USE_REL and USE_RELA (though the code checks
1746           for USE_REL == 1/0).  The value of this field is TRUE if the
1747           addend is recorded with the section contents; when performing a
1748           partial link (ld -r) the section contents (the data) will be
1749           modified.  The value of this field is FALSE if addends are
1750           recorded with the relocation (in arelent.addend); when performing
1751           a partial link the relocation will be modified.
1752           All relocations for all ELF USE_RELA targets should set this field
1753           to FALSE (values of TRUE should be looked on with suspicion).
1754           However, the converse is not true: not all relocations of all ELF
1755           USE_REL targets set this field to TRUE.  Why this is so is peculiar
1756           to each particular target.  For relocs that aren't used in partial
1757           links (e.g. GOT stuff) it doesn't matter what this is set to.  */
1758   boolean partial_inplace;
1759
1760        /* The src_mask selects which parts of the read in data
1761           are to be used in the relocation sum.  E.g., if this was an 8 bit
1762           byte of data which we read and relocated, this would be
1763           0x000000ff. When we have relocs which have an addend, such as
1764           sun4 extended relocs, the value in the offset part of a
1765           relocating field is garbage so we never use it. In this case
1766           the mask would be 0x00000000. */
1767   bfd_vma src_mask;
1768
1769        /* The dst_mask selects which parts of the instruction are replaced
1770           into the instruction. In most cases src_mask == dst_mask,
1771           except in the above special case, where dst_mask would be
1772           0x000000ff, and src_mask would be 0x00000000.   */
1773   bfd_vma dst_mask;
1774
1775        /* When some formats create PC relative instructions, they leave
1776           the value of the pc of the place being relocated in the offset
1777           slot of the instruction, so that a PC relative relocation can
1778           be made just by adding in an ordinary offset (e.g., sun3 a.out).
1779           Some formats leave the displacement part of an instruction
1780           empty (e.g., m88k bcs); this flag signals the fact.*/
1781   boolean pcrel_offset;
1782
1783 };
1784 #define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
1785   {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
1786 #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
1787
1788 #define EMPTY_HOWTO(C) \
1789   HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false)
1790
1791 #define HOWTO_PREPARE(relocation, symbol)      \
1792   {                                            \
1793   if (symbol != (asymbol *)NULL) {             \
1794     if (bfd_is_com_section (symbol->section)) { \
1795       relocation = 0;                          \
1796     }                                          \
1797     else {                                     \
1798       relocation = symbol->value;              \
1799     }                                          \
1800   }                                            \
1801 }
1802 unsigned int
1803 bfd_get_reloc_size PARAMS ((reloc_howto_type *));
1804
1805 typedef struct relent_chain {
1806   arelent relent;
1807   struct   relent_chain *next;
1808 } arelent_chain;
1809 bfd_reloc_status_type
1810 bfd_check_overflow PARAMS ((enum complain_overflow how,
1811     unsigned int bitsize,
1812     unsigned int rightshift,
1813     unsigned int addrsize,
1814     bfd_vma relocation));
1815
1816 bfd_reloc_status_type
1817 bfd_perform_relocation PARAMS ((bfd *abfd,
1818     arelent *reloc_entry,
1819     PTR data,
1820     asection *input_section,
1821     bfd *output_bfd,
1822     char **error_message));
1823
1824 bfd_reloc_status_type
1825 bfd_install_relocation PARAMS ((bfd *abfd,
1826     arelent *reloc_entry,
1827     PTR data, bfd_vma data_start,
1828     asection *input_section,
1829     char **error_message));
1830
1831 enum bfd_reloc_code_real {
1832   _dummy_first_bfd_reloc_code_real,
1833
1834
1835 /* Basic absolute relocations of N bits. */
1836   BFD_RELOC_64,
1837   BFD_RELOC_32,
1838   BFD_RELOC_26,
1839   BFD_RELOC_24,
1840   BFD_RELOC_16,
1841   BFD_RELOC_14,
1842   BFD_RELOC_8,
1843
1844 /* PC-relative relocations.  Sometimes these are relative to the address
1845 of the relocation itself; sometimes they are relative to the start of
1846 the section containing the relocation.  It depends on the specific target.
1847
1848 The 24-bit relocation is used in some Intel 960 configurations. */
1849   BFD_RELOC_64_PCREL,
1850   BFD_RELOC_32_PCREL,
1851   BFD_RELOC_24_PCREL,
1852   BFD_RELOC_16_PCREL,
1853   BFD_RELOC_12_PCREL,
1854   BFD_RELOC_8_PCREL,
1855
1856 /* For ELF. */
1857   BFD_RELOC_32_GOT_PCREL,
1858   BFD_RELOC_16_GOT_PCREL,
1859   BFD_RELOC_8_GOT_PCREL,
1860   BFD_RELOC_32_GOTOFF,
1861   BFD_RELOC_16_GOTOFF,
1862   BFD_RELOC_LO16_GOTOFF,
1863   BFD_RELOC_HI16_GOTOFF,
1864   BFD_RELOC_HI16_S_GOTOFF,
1865   BFD_RELOC_8_GOTOFF,
1866   BFD_RELOC_32_PLT_PCREL,
1867   BFD_RELOC_24_PLT_PCREL,
1868   BFD_RELOC_16_PLT_PCREL,
1869   BFD_RELOC_8_PLT_PCREL,
1870   BFD_RELOC_32_PLTOFF,
1871   BFD_RELOC_16_PLTOFF,
1872   BFD_RELOC_LO16_PLTOFF,
1873   BFD_RELOC_HI16_PLTOFF,
1874   BFD_RELOC_HI16_S_PLTOFF,
1875   BFD_RELOC_8_PLTOFF,
1876
1877 /* Relocations used by 68K ELF. */
1878   BFD_RELOC_68K_GLOB_DAT,
1879   BFD_RELOC_68K_JMP_SLOT,
1880   BFD_RELOC_68K_RELATIVE,
1881
1882 /* Linkage-table relative. */
1883   BFD_RELOC_32_BASEREL,
1884   BFD_RELOC_16_BASEREL,
1885   BFD_RELOC_LO16_BASEREL,
1886   BFD_RELOC_HI16_BASEREL,
1887   BFD_RELOC_HI16_S_BASEREL,
1888   BFD_RELOC_8_BASEREL,
1889   BFD_RELOC_RVA,
1890
1891 /* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */
1892   BFD_RELOC_8_FFnn,
1893
1894 /* These PC-relative relocations are stored as word displacements --
1895 i.e., byte displacements shifted right two bits.  The 30-bit word
1896 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1897 SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1898 signed 16-bit displacement is used on the MIPS, and the 23-bit
1899 displacement is used on the Alpha. */
1900   BFD_RELOC_32_PCREL_S2,
1901   BFD_RELOC_16_PCREL_S2,
1902   BFD_RELOC_23_PCREL_S2,
1903
1904 /* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1905 the target word.  These are used on the SPARC. */
1906   BFD_RELOC_HI22,
1907   BFD_RELOC_LO10,
1908
1909 /* For systems that allocate a Global Pointer register, these are
1910 displacements off that register.  These relocation types are
1911 handled specially, because the value the register will have is
1912 decided relatively late. */
1913   BFD_RELOC_GPREL16,
1914   BFD_RELOC_GPREL32,
1915
1916 /* Reloc types used for i960/b.out. */
1917   BFD_RELOC_I960_CALLJ,
1918
1919 /* SPARC ELF relocations.  There is probably some overlap with other
1920 relocation types already defined. */
1921   BFD_RELOC_NONE,
1922   BFD_RELOC_SPARC_WDISP22,
1923   BFD_RELOC_SPARC22,
1924   BFD_RELOC_SPARC13,
1925   BFD_RELOC_SPARC_GOT10,
1926   BFD_RELOC_SPARC_GOT13,
1927   BFD_RELOC_SPARC_GOT22,
1928   BFD_RELOC_SPARC_PC10,
1929   BFD_RELOC_SPARC_PC22,
1930   BFD_RELOC_SPARC_WPLT30,
1931   BFD_RELOC_SPARC_COPY,
1932   BFD_RELOC_SPARC_GLOB_DAT,
1933   BFD_RELOC_SPARC_JMP_SLOT,
1934   BFD_RELOC_SPARC_RELATIVE,
1935   BFD_RELOC_SPARC_UA16,
1936   BFD_RELOC_SPARC_UA32,
1937   BFD_RELOC_SPARC_UA64,
1938
1939 /* I think these are specific to SPARC a.out (e.g., Sun 4). */
1940   BFD_RELOC_SPARC_BASE13,
1941   BFD_RELOC_SPARC_BASE22,
1942
1943 /* SPARC64 relocations */
1944 #define BFD_RELOC_SPARC_64 BFD_RELOC_64
1945   BFD_RELOC_SPARC_10,
1946   BFD_RELOC_SPARC_11,
1947   BFD_RELOC_SPARC_OLO10,
1948   BFD_RELOC_SPARC_HH22,
1949   BFD_RELOC_SPARC_HM10,
1950   BFD_RELOC_SPARC_LM22,
1951   BFD_RELOC_SPARC_PC_HH22,
1952   BFD_RELOC_SPARC_PC_HM10,
1953   BFD_RELOC_SPARC_PC_LM22,
1954   BFD_RELOC_SPARC_WDISP16,
1955   BFD_RELOC_SPARC_WDISP19,
1956   BFD_RELOC_SPARC_7,
1957   BFD_RELOC_SPARC_6,
1958   BFD_RELOC_SPARC_5,
1959 #define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL
1960   BFD_RELOC_SPARC_PLT64,
1961   BFD_RELOC_SPARC_HIX22,
1962   BFD_RELOC_SPARC_LOX10,
1963   BFD_RELOC_SPARC_H44,
1964   BFD_RELOC_SPARC_M44,
1965   BFD_RELOC_SPARC_L44,
1966   BFD_RELOC_SPARC_REGISTER,
1967
1968 /* SPARC little endian relocation */
1969   BFD_RELOC_SPARC_REV32,
1970
1971 /* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
1972 "addend" in some special way.
1973 For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1974 writing; when reading, it will be the absolute section symbol.  The
1975 addend is the displacement in bytes of the "lda" instruction from
1976 the "ldah" instruction (which is at the address of this reloc). */
1977   BFD_RELOC_ALPHA_GPDISP_HI16,
1978
1979 /* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1980 with GPDISP_HI16 relocs.  The addend is ignored when writing the
1981 relocations out, and is filled in with the file's GP value on
1982 reading, for convenience. */
1983   BFD_RELOC_ALPHA_GPDISP_LO16,
1984
1985 /* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1986 relocation except that there is no accompanying GPDISP_LO16
1987 relocation. */
1988   BFD_RELOC_ALPHA_GPDISP,
1989
1990 /* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1991 the assembler turns it into a LDQ instruction to load the address of
1992 the symbol, and then fills in a register in the real instruction.
1993
1994 The LITERAL reloc, at the LDQ instruction, refers to the .lita
1995 section symbol.  The addend is ignored when writing, but is filled
1996 in with the file's GP value on reading, for convenience, as with the
1997 GPDISP_LO16 reloc.
1998
1999 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
2000 It should refer to the symbol to be referenced, as with 16_GOTOFF,
2001 but it generates output not based on the position within the .got
2002 section, but relative to the GP value chosen for the file during the
2003 final link stage.
2004
2005 The LITUSE reloc, on the instruction using the loaded address, gives
2006 information to the linker that it might be able to use to optimize
2007 away some literal section references.  The symbol is ignored (read
2008 as the absolute section symbol), and the "addend" indicates the type
2009 of instruction using the register:
2010 1 - "memory" fmt insn
2011 2 - byte-manipulation (byte offset reg)
2012 3 - jsr (target of branch)
2013
2014 The GNU linker currently doesn't do any of this optimizing. */
2015   BFD_RELOC_ALPHA_LITERAL,
2016   BFD_RELOC_ALPHA_ELF_LITERAL,
2017   BFD_RELOC_ALPHA_LITUSE,
2018
2019 /* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to
2020 process the explicit !<reloc>!sequence relocations, and are mapped
2021 into the normal relocations at the end of processing. */
2022   BFD_RELOC_ALPHA_USER_LITERAL,
2023   BFD_RELOC_ALPHA_USER_LITUSE_BASE,
2024   BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF,
2025   BFD_RELOC_ALPHA_USER_LITUSE_JSR,
2026   BFD_RELOC_ALPHA_USER_GPDISP,
2027   BFD_RELOC_ALPHA_USER_GPRELHIGH,
2028   BFD_RELOC_ALPHA_USER_GPRELLOW,
2029
2030 /* The HINT relocation indicates a value that should be filled into the
2031 "hint" field of a jmp/jsr/ret instruction, for possible branch-
2032 prediction logic which may be provided on some processors. */
2033   BFD_RELOC_ALPHA_HINT,
2034
2035 /* The LINKAGE relocation outputs a linkage pair in the object file,
2036 which is filled by the linker. */
2037   BFD_RELOC_ALPHA_LINKAGE,
2038
2039 /* The CODEADDR relocation outputs a STO_CA in the object file,
2040 which is filled by the linker. */
2041   BFD_RELOC_ALPHA_CODEADDR,
2042
2043 /* Bits 27..2 of the relocation address shifted right 2 bits;
2044 simple reloc otherwise. */
2045   BFD_RELOC_MIPS_JMP,
2046
2047 /* The MIPS16 jump instruction. */
2048   BFD_RELOC_MIPS16_JMP,
2049
2050 /* MIPS16 GP relative reloc. */
2051   BFD_RELOC_MIPS16_GPREL,
2052
2053 /* High 16 bits of 32-bit value; simple reloc. */
2054   BFD_RELOC_HI16,
2055
2056 /* High 16 bits of 32-bit value but the low 16 bits will be sign
2057 extended and added to form the final result.  If the low 16
2058 bits form a negative number, we need to add one to the high value
2059 to compensate for the borrow when the low bits are added. */
2060   BFD_RELOC_HI16_S,
2061
2062 /* Low 16 bits. */
2063   BFD_RELOC_LO16,
2064
2065 /* Like BFD_RELOC_HI16_S, but PC relative. */
2066   BFD_RELOC_PCREL_HI16_S,
2067
2068 /* Like BFD_RELOC_LO16, but PC relative. */
2069   BFD_RELOC_PCREL_LO16,
2070
2071 /* Relocation relative to the global pointer. */
2072 #define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
2073
2074 /* Relocation against a MIPS literal section. */
2075   BFD_RELOC_MIPS_LITERAL,
2076
2077 /* MIPS ELF relocations. */
2078   BFD_RELOC_MIPS_GOT16,
2079   BFD_RELOC_MIPS_CALL16,
2080 #define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
2081   BFD_RELOC_MIPS_GOT_HI16,
2082   BFD_RELOC_MIPS_GOT_LO16,
2083   BFD_RELOC_MIPS_CALL_HI16,
2084   BFD_RELOC_MIPS_CALL_LO16,
2085   BFD_RELOC_MIPS_SUB,
2086   BFD_RELOC_MIPS_GOT_PAGE,
2087   BFD_RELOC_MIPS_GOT_OFST,
2088   BFD_RELOC_MIPS_GOT_DISP,
2089   BFD_RELOC_MIPS_SHIFT5,
2090   BFD_RELOC_MIPS_SHIFT6,
2091   BFD_RELOC_MIPS_INSERT_A,
2092   BFD_RELOC_MIPS_INSERT_B,
2093   BFD_RELOC_MIPS_DELETE,
2094   BFD_RELOC_MIPS_HIGHEST,
2095   BFD_RELOC_MIPS_HIGHER,
2096   BFD_RELOC_MIPS_SCN_DISP,
2097   BFD_RELOC_MIPS_REL16,
2098   BFD_RELOC_MIPS_RELGOT,
2099   BFD_RELOC_MIPS_JALR,
2100
2101
2102 /* i386/elf relocations */
2103   BFD_RELOC_386_GOT32,
2104   BFD_RELOC_386_PLT32,
2105   BFD_RELOC_386_COPY,
2106   BFD_RELOC_386_GLOB_DAT,
2107   BFD_RELOC_386_JUMP_SLOT,
2108   BFD_RELOC_386_RELATIVE,
2109   BFD_RELOC_386_GOTOFF,
2110   BFD_RELOC_386_GOTPC,
2111
2112 /* x86-64/elf relocations */
2113   BFD_RELOC_X86_64_GOT32,
2114   BFD_RELOC_X86_64_PLT32,
2115   BFD_RELOC_X86_64_COPY,
2116   BFD_RELOC_X86_64_GLOB_DAT,
2117   BFD_RELOC_X86_64_JUMP_SLOT,
2118   BFD_RELOC_X86_64_RELATIVE,
2119   BFD_RELOC_X86_64_GOTPCREL,
2120   BFD_RELOC_X86_64_32S,
2121
2122 /* ns32k relocations */
2123   BFD_RELOC_NS32K_IMM_8,
2124   BFD_RELOC_NS32K_IMM_16,
2125   BFD_RELOC_NS32K_IMM_32,
2126   BFD_RELOC_NS32K_IMM_8_PCREL,
2127   BFD_RELOC_NS32K_IMM_16_PCREL,
2128   BFD_RELOC_NS32K_IMM_32_PCREL,
2129   BFD_RELOC_NS32K_DISP_8,
2130   BFD_RELOC_NS32K_DISP_16,
2131   BFD_RELOC_NS32K_DISP_32,
2132   BFD_RELOC_NS32K_DISP_8_PCREL,
2133   BFD_RELOC_NS32K_DISP_16_PCREL,
2134   BFD_RELOC_NS32K_DISP_32_PCREL,
2135
2136 /* PDP11 relocations */
2137   BFD_RELOC_PDP11_DISP_8_PCREL,
2138   BFD_RELOC_PDP11_DISP_6_PCREL,
2139
2140 /* Picojava relocs.  Not all of these appear in object files. */
2141   BFD_RELOC_PJ_CODE_HI16,
2142   BFD_RELOC_PJ_CODE_LO16,
2143   BFD_RELOC_PJ_CODE_DIR16,
2144   BFD_RELOC_PJ_CODE_DIR32,
2145   BFD_RELOC_PJ_CODE_REL16,
2146   BFD_RELOC_PJ_CODE_REL32,
2147
2148 /* Power(rs6000) and PowerPC relocations. */
2149   BFD_RELOC_PPC_B26,
2150   BFD_RELOC_PPC_BA26,
2151   BFD_RELOC_PPC_TOC16,
2152   BFD_RELOC_PPC_B16,
2153   BFD_RELOC_PPC_B16_BRTAKEN,
2154   BFD_RELOC_PPC_B16_BRNTAKEN,
2155   BFD_RELOC_PPC_BA16,
2156   BFD_RELOC_PPC_BA16_BRTAKEN,
2157   BFD_RELOC_PPC_BA16_BRNTAKEN,
2158   BFD_RELOC_PPC_COPY,
2159   BFD_RELOC_PPC_GLOB_DAT,
2160   BFD_RELOC_PPC_JMP_SLOT,
2161   BFD_RELOC_PPC_RELATIVE,
2162   BFD_RELOC_PPC_LOCAL24PC,
2163   BFD_RELOC_PPC_EMB_NADDR32,
2164   BFD_RELOC_PPC_EMB_NADDR16,
2165   BFD_RELOC_PPC_EMB_NADDR16_LO,
2166   BFD_RELOC_PPC_EMB_NADDR16_HI,
2167   BFD_RELOC_PPC_EMB_NADDR16_HA,
2168   BFD_RELOC_PPC_EMB_SDAI16,
2169   BFD_RELOC_PPC_EMB_SDA2I16,
2170   BFD_RELOC_PPC_EMB_SDA2REL,
2171   BFD_RELOC_PPC_EMB_SDA21,
2172   BFD_RELOC_PPC_EMB_MRKREF,
2173   BFD_RELOC_PPC_EMB_RELSEC16,
2174   BFD_RELOC_PPC_EMB_RELST_LO,
2175   BFD_RELOC_PPC_EMB_RELST_HI,
2176   BFD_RELOC_PPC_EMB_RELST_HA,
2177   BFD_RELOC_PPC_EMB_BIT_FLD,
2178   BFD_RELOC_PPC_EMB_RELSDA,
2179
2180 /* IBM 370/390 relocations */
2181   BFD_RELOC_I370_D12,
2182
2183 /* The type of reloc used to build a contructor table - at the moment
2184 probably a 32 bit wide absolute relocation, but the target can choose.
2185 It generally does map to one of the other relocation types. */
2186   BFD_RELOC_CTOR,
2187
2188 /* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2189 not stored in the instruction. */
2190   BFD_RELOC_ARM_PCREL_BRANCH,
2191
2192 /* ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
2193 not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2194 field in the instruction. */
2195   BFD_RELOC_ARM_PCREL_BLX,
2196
2197 /* Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
2198 not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2199 field in the instruction. */
2200   BFD_RELOC_THUMB_PCREL_BLX,
2201
2202 /* These relocs are only used within the ARM assembler.  They are not
2203 (at present) written to any object files. */
2204   BFD_RELOC_ARM_IMMEDIATE,
2205   BFD_RELOC_ARM_ADRL_IMMEDIATE,
2206   BFD_RELOC_ARM_OFFSET_IMM,
2207   BFD_RELOC_ARM_SHIFT_IMM,
2208   BFD_RELOC_ARM_SWI,
2209   BFD_RELOC_ARM_MULTI,
2210   BFD_RELOC_ARM_CP_OFF_IMM,
2211   BFD_RELOC_ARM_ADR_IMM,
2212   BFD_RELOC_ARM_LDR_IMM,
2213   BFD_RELOC_ARM_LITERAL,
2214   BFD_RELOC_ARM_IN_POOL,
2215   BFD_RELOC_ARM_OFFSET_IMM8,
2216   BFD_RELOC_ARM_HWLITERAL,
2217   BFD_RELOC_ARM_THUMB_ADD,
2218   BFD_RELOC_ARM_THUMB_IMM,
2219   BFD_RELOC_ARM_THUMB_SHIFT,
2220   BFD_RELOC_ARM_THUMB_OFFSET,
2221   BFD_RELOC_ARM_GOT12,
2222   BFD_RELOC_ARM_GOT32,
2223   BFD_RELOC_ARM_JUMP_SLOT,
2224   BFD_RELOC_ARM_COPY,
2225   BFD_RELOC_ARM_GLOB_DAT,
2226   BFD_RELOC_ARM_PLT32,
2227   BFD_RELOC_ARM_RELATIVE,
2228   BFD_RELOC_ARM_GOTOFF,
2229   BFD_RELOC_ARM_GOTPC,
2230
2231 /* Hitachi SH relocs.  Not all of these appear in object files. */
2232   BFD_RELOC_SH_PCDISP8BY2,
2233   BFD_RELOC_SH_PCDISP12BY2,
2234   BFD_RELOC_SH_IMM4,
2235   BFD_RELOC_SH_IMM4BY2,
2236   BFD_RELOC_SH_IMM4BY4,
2237   BFD_RELOC_SH_IMM8,
2238   BFD_RELOC_SH_IMM8BY2,
2239   BFD_RELOC_SH_IMM8BY4,
2240   BFD_RELOC_SH_PCRELIMM8BY2,
2241   BFD_RELOC_SH_PCRELIMM8BY4,
2242   BFD_RELOC_SH_SWITCH16,
2243   BFD_RELOC_SH_SWITCH32,
2244   BFD_RELOC_SH_USES,
2245   BFD_RELOC_SH_COUNT,
2246   BFD_RELOC_SH_ALIGN,
2247   BFD_RELOC_SH_CODE,
2248   BFD_RELOC_SH_DATA,
2249   BFD_RELOC_SH_LABEL,
2250   BFD_RELOC_SH_LOOP_START,
2251   BFD_RELOC_SH_LOOP_END,
2252   BFD_RELOC_SH_COPY,
2253   BFD_RELOC_SH_GLOB_DAT,
2254   BFD_RELOC_SH_JMP_SLOT,
2255   BFD_RELOC_SH_RELATIVE,
2256   BFD_RELOC_SH_GOTPC,
2257
2258 /* Thumb 23-, 12- and 9-bit pc-relative branches.  The lowest bit must
2259 be zero and is not stored in the instruction. */
2260   BFD_RELOC_THUMB_PCREL_BRANCH9,
2261   BFD_RELOC_THUMB_PCREL_BRANCH12,
2262   BFD_RELOC_THUMB_PCREL_BRANCH23,
2263
2264 /* ARC Cores relocs.
2265 ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2266 not stored in the instruction.  The high 20 bits are installed in bits 26
2267 through 7 of the instruction. */
2268   BFD_RELOC_ARC_B22_PCREL,
2269
2270 /* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2271 stored in the instruction.  The high 24 bits are installed in bits 23
2272 through 0. */
2273   BFD_RELOC_ARC_B26,
2274
2275 /* Mitsubishi D10V relocs.
2276 This is a 10-bit reloc with the right 2 bits
2277 assumed to be 0. */
2278   BFD_RELOC_D10V_10_PCREL_R,
2279
2280 /* Mitsubishi D10V relocs.
2281 This is a 10-bit reloc with the right 2 bits
2282 assumed to be 0.  This is the same as the previous reloc
2283 except it is in the left container, i.e.,
2284 shifted left 15 bits. */
2285   BFD_RELOC_D10V_10_PCREL_L,
2286
2287 /* This is an 18-bit reloc with the right 2 bits
2288 assumed to be 0. */
2289   BFD_RELOC_D10V_18,
2290
2291 /* This is an 18-bit reloc with the right 2 bits
2292 assumed to be 0. */
2293   BFD_RELOC_D10V_18_PCREL,
2294
2295 /* Mitsubishi D30V relocs.
2296 This is a 6-bit absolute reloc. */
2297   BFD_RELOC_D30V_6,
2298
2299 /* This is a 6-bit pc-relative reloc with
2300 the right 3 bits assumed to be 0. */
2301   BFD_RELOC_D30V_9_PCREL,
2302
2303 /* This is a 6-bit pc-relative reloc with
2304 the right 3 bits assumed to be 0. Same
2305 as the previous reloc but on the right side
2306 of the container. */
2307   BFD_RELOC_D30V_9_PCREL_R,
2308
2309 /* This is a 12-bit absolute reloc with the
2310 right 3 bitsassumed to be 0. */
2311   BFD_RELOC_D30V_15,
2312
2313 /* This is a 12-bit pc-relative reloc with
2314 the right 3 bits assumed to be 0. */
2315   BFD_RELOC_D30V_15_PCREL,
2316
2317 /* This is a 12-bit pc-relative reloc with
2318 the right 3 bits assumed to be 0. Same
2319 as the previous reloc but on the right side
2320 of the container. */
2321   BFD_RELOC_D30V_15_PCREL_R,
2322
2323 /* This is an 18-bit absolute reloc with
2324 the right 3 bits assumed to be 0. */
2325   BFD_RELOC_D30V_21,
2326
2327 /* This is an 18-bit pc-relative reloc with
2328 the right 3 bits assumed to be 0. */
2329   BFD_RELOC_D30V_21_PCREL,
2330
2331 /* This is an 18-bit pc-relative reloc with
2332 the right 3 bits assumed to be 0. Same
2333 as the previous reloc but on the right side
2334 of the container. */
2335   BFD_RELOC_D30V_21_PCREL_R,
2336
2337 /* This is a 32-bit absolute reloc. */
2338   BFD_RELOC_D30V_32,
2339
2340 /* This is a 32-bit pc-relative reloc. */
2341   BFD_RELOC_D30V_32_PCREL,
2342
2343 /* Mitsubishi M32R relocs.
2344 This is a 24 bit absolute address. */
2345   BFD_RELOC_M32R_24,
2346
2347 /* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */
2348   BFD_RELOC_M32R_10_PCREL,
2349
2350 /* This is an 18-bit reloc with the right 2 bits assumed to be 0. */
2351   BFD_RELOC_M32R_18_PCREL,
2352
2353 /* This is a 26-bit reloc with the right 2 bits assumed to be 0. */
2354   BFD_RELOC_M32R_26_PCREL,
2355
2356 /* This is a 16-bit reloc containing the high 16 bits of an address
2357 used when the lower 16 bits are treated as unsigned. */
2358   BFD_RELOC_M32R_HI16_ULO,
2359
2360 /* This is a 16-bit reloc containing the high 16 bits of an address
2361 used when the lower 16 bits are treated as signed. */
2362   BFD_RELOC_M32R_HI16_SLO,
2363
2364 /* This is a 16-bit reloc containing the lower 16 bits of an address. */
2365   BFD_RELOC_M32R_LO16,
2366
2367 /* This is a 16-bit reloc containing the small data area offset for use in
2368 add3, load, and store instructions. */
2369   BFD_RELOC_M32R_SDA16,
2370
2371 /* This is a 9-bit reloc */
2372   BFD_RELOC_V850_9_PCREL,
2373
2374 /* This is a 22-bit reloc */
2375   BFD_RELOC_V850_22_PCREL,
2376
2377 /* This is a 16 bit offset from the short data area pointer. */
2378   BFD_RELOC_V850_SDA_16_16_OFFSET,
2379
2380 /* This is a 16 bit offset (of which only 15 bits are used) from the
2381 short data area pointer. */
2382   BFD_RELOC_V850_SDA_15_16_OFFSET,
2383
2384 /* This is a 16 bit offset from the zero data area pointer. */
2385   BFD_RELOC_V850_ZDA_16_16_OFFSET,
2386
2387 /* This is a 16 bit offset (of which only 15 bits are used) from the
2388 zero data area pointer. */
2389   BFD_RELOC_V850_ZDA_15_16_OFFSET,
2390
2391 /* This is an 8 bit offset (of which only 6 bits are used) from the
2392 tiny data area pointer. */
2393   BFD_RELOC_V850_TDA_6_8_OFFSET,
2394
2395 /* This is an 8bit offset (of which only 7 bits are used) from the tiny
2396 data area pointer. */
2397   BFD_RELOC_V850_TDA_7_8_OFFSET,
2398
2399 /* This is a 7 bit offset from the tiny data area pointer. */
2400   BFD_RELOC_V850_TDA_7_7_OFFSET,
2401
2402 /* This is a 16 bit offset from the tiny data area pointer. */
2403   BFD_RELOC_V850_TDA_16_16_OFFSET,
2404
2405 /* This is a 5 bit offset (of which only 4 bits are used) from the tiny
2406 data area pointer. */
2407   BFD_RELOC_V850_TDA_4_5_OFFSET,
2408
2409 /* This is a 4 bit offset from the tiny data area pointer. */
2410   BFD_RELOC_V850_TDA_4_4_OFFSET,
2411
2412 /* This is a 16 bit offset from the short data area pointer, with the
2413 bits placed non-contigously in the instruction. */
2414   BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,
2415
2416 /* This is a 16 bit offset from the zero data area pointer, with the
2417 bits placed non-contigously in the instruction. */
2418   BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,
2419
2420 /* This is a 6 bit offset from the call table base pointer. */
2421   BFD_RELOC_V850_CALLT_6_7_OFFSET,
2422
2423 /* This is a 16 bit offset from the call table base pointer. */
2424   BFD_RELOC_V850_CALLT_16_16_OFFSET,
2425
2426
2427 /* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2428 instruction. */
2429   BFD_RELOC_MN10300_32_PCREL,
2430
2431 /* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2432 instruction. */
2433   BFD_RELOC_MN10300_16_PCREL,
2434
2435 /* This is a 8bit DP reloc for the tms320c30, where the most
2436 significant 8 bits of a 24 bit word are placed into the least
2437 significant 8 bits of the opcode. */
2438   BFD_RELOC_TIC30_LDP,
2439
2440 /* This is a 7bit reloc for the tms320c54x, where the least
2441 significant 7 bits of a 16 bit word are placed into the least
2442 significant 7 bits of the opcode. */
2443   BFD_RELOC_TIC54X_PARTLS7,
2444
2445 /* This is a 9bit DP reloc for the tms320c54x, where the most
2446 significant 9 bits of a 16 bit word are placed into the least
2447 significant 9 bits of the opcode. */
2448   BFD_RELOC_TIC54X_PARTMS9,
2449
2450 /* This is an extended address 23-bit reloc for the tms320c54x. */
2451   BFD_RELOC_TIC54X_23,
2452
2453 /* This is a 16-bit reloc for the tms320c54x, where the least
2454 significant 16 bits of a 23-bit extended address are placed into
2455 the opcode. */
2456   BFD_RELOC_TIC54X_16_OF_23,
2457
2458 /* This is a reloc for the tms320c54x, where the most
2459 significant 7 bits of a 23-bit extended address are placed into
2460 the opcode. */
2461   BFD_RELOC_TIC54X_MS7_OF_23,
2462
2463 /* This is a 48 bit reloc for the FR30 that stores 32 bits. */
2464   BFD_RELOC_FR30_48,
2465
2466 /* This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2467 two sections. */
2468   BFD_RELOC_FR30_20,
2469
2470 /* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2471 4 bits. */
2472   BFD_RELOC_FR30_6_IN_4,
2473
2474 /* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2475 into 8 bits. */
2476   BFD_RELOC_FR30_8_IN_8,
2477
2478 /* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2479 into 8 bits. */
2480   BFD_RELOC_FR30_9_IN_8,
2481
2482 /* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2483 into 8 bits. */
2484   BFD_RELOC_FR30_10_IN_8,
2485
2486 /* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2487 short offset into 8 bits. */
2488   BFD_RELOC_FR30_9_PCREL,
2489
2490 /* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2491 short offset into 11 bits. */
2492   BFD_RELOC_FR30_12_PCREL,
2493
2494 /* Motorola Mcore relocations. */
2495   BFD_RELOC_MCORE_PCREL_IMM8BY4,
2496   BFD_RELOC_MCORE_PCREL_IMM11BY2,
2497   BFD_RELOC_MCORE_PCREL_IMM4BY2,
2498   BFD_RELOC_MCORE_PCREL_32,
2499   BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,
2500   BFD_RELOC_MCORE_RVA,
2501
2502 /* This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2503 short offset into 7 bits. */
2504   BFD_RELOC_AVR_7_PCREL,
2505
2506 /* This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2507 short offset into 12 bits. */
2508   BFD_RELOC_AVR_13_PCREL,
2509
2510 /* This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2511 program memory address) into 16 bits. */
2512   BFD_RELOC_AVR_16_PM,
2513
2514 /* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2515 data memory address) into 8 bit immediate value of LDI insn. */
2516   BFD_RELOC_AVR_LO8_LDI,
2517
2518 /* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2519 of data memory address) into 8 bit immediate value of LDI insn. */
2520   BFD_RELOC_AVR_HI8_LDI,
2521
2522 /* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2523 of program memory address) into 8 bit immediate value of LDI insn. */
2524   BFD_RELOC_AVR_HH8_LDI,
2525
2526 /* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2527 (usually data memory address) into 8 bit immediate value of SUBI insn. */
2528   BFD_RELOC_AVR_LO8_LDI_NEG,
2529
2530 /* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2531 (high 8 bit of data memory address) into 8 bit immediate value of
2532 SUBI insn. */
2533   BFD_RELOC_AVR_HI8_LDI_NEG,
2534
2535 /* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2536 (most high 8 bit of program memory address) into 8 bit immediate value
2537 of LDI or SUBI insn. */
2538   BFD_RELOC_AVR_HH8_LDI_NEG,
2539
2540 /* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2541 command address) into 8 bit immediate value of LDI insn. */
2542   BFD_RELOC_AVR_LO8_LDI_PM,
2543
2544 /* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2545 of command address) into 8 bit immediate value of LDI insn. */
2546   BFD_RELOC_AVR_HI8_LDI_PM,
2547
2548 /* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2549 of command address) into 8 bit immediate value of LDI insn. */
2550   BFD_RELOC_AVR_HH8_LDI_PM,
2551
2552 /* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2553 (usually command address) into 8 bit immediate value of SUBI insn. */
2554   BFD_RELOC_AVR_LO8_LDI_PM_NEG,
2555
2556 /* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2557 (high 8 bit of 16 bit command address) into 8 bit immediate value
2558 of SUBI insn. */
2559   BFD_RELOC_AVR_HI8_LDI_PM_NEG,
2560
2561 /* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2562 (high 6 bit of 22 bit command address) into 8 bit immediate
2563 value of SUBI insn. */
2564   BFD_RELOC_AVR_HH8_LDI_PM_NEG,
2565
2566 /* This is a 32 bit reloc for the AVR that stores 23 bit value
2567 into 22 bits. */
2568   BFD_RELOC_AVR_CALL,
2569
2570 /* Direct 12 bit. */
2571   BFD_RELOC_390_12,
2572
2573 /* 12 bit GOT offset. */
2574   BFD_RELOC_390_GOT12,
2575
2576 /* 32 bit PC relative PLT address. */
2577   BFD_RELOC_390_PLT32,
2578
2579 /* Copy symbol at runtime. */
2580   BFD_RELOC_390_COPY,
2581
2582 /* Create GOT entry. */
2583   BFD_RELOC_390_GLOB_DAT,
2584
2585 /* Create PLT entry. */
2586   BFD_RELOC_390_JMP_SLOT,
2587
2588 /* Adjust by program base. */
2589   BFD_RELOC_390_RELATIVE,
2590
2591 /* 32 bit PC relative offset to GOT. */
2592   BFD_RELOC_390_GOTPC,
2593
2594 /* 16 bit GOT offset. */
2595   BFD_RELOC_390_GOT16,
2596
2597 /* PC relative 16 bit shifted by 1. */
2598   BFD_RELOC_390_PC16DBL,
2599
2600 /* 16 bit PC rel. PLT shifted by 1. */
2601   BFD_RELOC_390_PLT16DBL,
2602
2603 /* PC relative 32 bit shifted by 1. */
2604   BFD_RELOC_390_PC32DBL,
2605
2606 /* 32 bit PC rel. PLT shifted by 1. */
2607   BFD_RELOC_390_PLT32DBL,
2608
2609 /* 32 bit PC rel. GOT shifted by 1. */
2610   BFD_RELOC_390_GOTPCDBL,
2611
2612 /* 64 bit GOT offset. */
2613   BFD_RELOC_390_GOT64,
2614
2615 /* 64 bit PC relative PLT address. */
2616   BFD_RELOC_390_PLT64,
2617
2618 /* 32 bit rel. offset to GOT entry. */
2619   BFD_RELOC_390_GOTENT,
2620
2621 /* These two relocations are used by the linker to determine which of
2622 the entries in a C++ virtual function table are actually used.  When
2623 the --gc-sections option is given, the linker will zero out the entries
2624 that are not used, so that the code for those functions need not be
2625 included in the output.
2626
2627 VTABLE_INHERIT is a zero-space relocation used to describe to the
2628 linker the inheritence tree of a C++ virtual function table.  The
2629 relocation's symbol should be the parent class' vtable, and the
2630 relocation should be located at the child vtable.
2631
2632 VTABLE_ENTRY is a zero-space relocation that describes the use of a
2633 virtual function table entry.  The reloc's symbol should refer to the
2634 table of the class mentioned in the code.  Off of that base, an offset
2635 describes the entry that is being used.  For Rela hosts, this offset
2636 is stored in the reloc's addend.  For Rel hosts, we are forced to put
2637 this offset in the reloc's section offset. */
2638   BFD_RELOC_VTABLE_INHERIT,
2639   BFD_RELOC_VTABLE_ENTRY,
2640
2641 /* Intel IA64 Relocations. */
2642   BFD_RELOC_IA64_IMM14,
2643   BFD_RELOC_IA64_IMM22,
2644   BFD_RELOC_IA64_IMM64,
2645   BFD_RELOC_IA64_DIR32MSB,
2646   BFD_RELOC_IA64_DIR32LSB,
2647   BFD_RELOC_IA64_DIR64MSB,
2648   BFD_RELOC_IA64_DIR64LSB,
2649   BFD_RELOC_IA64_GPREL22,
2650   BFD_RELOC_IA64_GPREL64I,
2651   BFD_RELOC_IA64_GPREL32MSB,
2652   BFD_RELOC_IA64_GPREL32LSB,
2653   BFD_RELOC_IA64_GPREL64MSB,
2654   BFD_RELOC_IA64_GPREL64LSB,
2655   BFD_RELOC_IA64_LTOFF22,
2656   BFD_RELOC_IA64_LTOFF64I,
2657   BFD_RELOC_IA64_PLTOFF22,
2658   BFD_RELOC_IA64_PLTOFF64I,
2659   BFD_RELOC_IA64_PLTOFF64MSB,
2660   BFD_RELOC_IA64_PLTOFF64LSB,
2661   BFD_RELOC_IA64_FPTR64I,
2662   BFD_RELOC_IA64_FPTR32MSB,
2663   BFD_RELOC_IA64_FPTR32LSB,
2664   BFD_RELOC_IA64_FPTR64MSB,
2665   BFD_RELOC_IA64_FPTR64LSB,
2666   BFD_RELOC_IA64_PCREL21B,
2667   BFD_RELOC_IA64_PCREL21BI,
2668   BFD_RELOC_IA64_PCREL21M,
2669   BFD_RELOC_IA64_PCREL21F,
2670   BFD_RELOC_IA64_PCREL22,
2671   BFD_RELOC_IA64_PCREL60B,
2672   BFD_RELOC_IA64_PCREL64I,
2673   BFD_RELOC_IA64_PCREL32MSB,
2674   BFD_RELOC_IA64_PCREL32LSB,
2675   BFD_RELOC_IA64_PCREL64MSB,
2676   BFD_RELOC_IA64_PCREL64LSB,
2677   BFD_RELOC_IA64_LTOFF_FPTR22,
2678   BFD_RELOC_IA64_LTOFF_FPTR64I,
2679   BFD_RELOC_IA64_LTOFF_FPTR32MSB,
2680   BFD_RELOC_IA64_LTOFF_FPTR32LSB,
2681   BFD_RELOC_IA64_LTOFF_FPTR64MSB,
2682   BFD_RELOC_IA64_LTOFF_FPTR64LSB,
2683   BFD_RELOC_IA64_SEGREL32MSB,
2684   BFD_RELOC_IA64_SEGREL32LSB,
2685   BFD_RELOC_IA64_SEGREL64MSB,
2686   BFD_RELOC_IA64_SEGREL64LSB,
2687   BFD_RELOC_IA64_SECREL32MSB,
2688   BFD_RELOC_IA64_SECREL32LSB,
2689   BFD_RELOC_IA64_SECREL64MSB,
2690   BFD_RELOC_IA64_SECREL64LSB,
2691   BFD_RELOC_IA64_REL32MSB,
2692   BFD_RELOC_IA64_REL32LSB,
2693   BFD_RELOC_IA64_REL64MSB,
2694   BFD_RELOC_IA64_REL64LSB,
2695   BFD_RELOC_IA64_LTV32MSB,
2696   BFD_RELOC_IA64_LTV32LSB,
2697   BFD_RELOC_IA64_LTV64MSB,
2698   BFD_RELOC_IA64_LTV64LSB,
2699   BFD_RELOC_IA64_IPLTMSB,
2700   BFD_RELOC_IA64_IPLTLSB,
2701   BFD_RELOC_IA64_COPY,
2702   BFD_RELOC_IA64_TPREL22,
2703   BFD_RELOC_IA64_TPREL64MSB,
2704   BFD_RELOC_IA64_TPREL64LSB,
2705   BFD_RELOC_IA64_LTOFF_TP22,
2706   BFD_RELOC_IA64_LTOFF22X,
2707   BFD_RELOC_IA64_LDXMOV,
2708
2709 /* Motorola 68HC11 reloc.
2710 This is the 8 bits high part of an absolute address. */
2711   BFD_RELOC_M68HC11_HI8,
2712
2713 /* Motorola 68HC11 reloc.
2714 This is the 8 bits low part of an absolute address. */
2715   BFD_RELOC_M68HC11_LO8,
2716
2717 /* Motorola 68HC11 reloc.
2718 This is the 3 bits of a value. */
2719   BFD_RELOC_M68HC11_3B,
2720
2721 /* These relocs are only used within the CRIS assembler.  They are not
2722 (at present) written to any object files. */
2723   BFD_RELOC_CRIS_BDISP8,
2724   BFD_RELOC_CRIS_UNSIGNED_5,
2725   BFD_RELOC_CRIS_SIGNED_6,
2726   BFD_RELOC_CRIS_UNSIGNED_6,
2727   BFD_RELOC_CRIS_UNSIGNED_4,
2728
2729 /* Relocs used in ELF shared libraries for CRIS. */
2730   BFD_RELOC_CRIS_COPY,
2731   BFD_RELOC_CRIS_GLOB_DAT,
2732   BFD_RELOC_CRIS_JUMP_SLOT,
2733   BFD_RELOC_CRIS_RELATIVE,
2734
2735 /* 32-bit offset to symbol-entry within GOT. */
2736   BFD_RELOC_CRIS_32_GOT,
2737
2738 /* 16-bit offset to symbol-entry within GOT. */
2739   BFD_RELOC_CRIS_16_GOT,
2740
2741 /* 32-bit offset to symbol-entry within GOT, with PLT handling. */
2742   BFD_RELOC_CRIS_32_GOTPLT,
2743
2744 /* 16-bit offset to symbol-entry within GOT, with PLT handling. */
2745   BFD_RELOC_CRIS_16_GOTPLT,
2746
2747 /* 32-bit offset to symbol, relative to GOT. */
2748   BFD_RELOC_CRIS_32_GOTREL,
2749
2750 /* 32-bit offset to symbol with PLT entry, relative to GOT. */
2751   BFD_RELOC_CRIS_32_PLT_GOTREL,
2752
2753 /* 32-bit offset to symbol with PLT entry, relative to this relocation. */
2754   BFD_RELOC_CRIS_32_PLT_PCREL,
2755
2756 /* Intel i860 Relocations. */
2757   BFD_RELOC_860_COPY,
2758   BFD_RELOC_860_GLOB_DAT,
2759   BFD_RELOC_860_JUMP_SLOT,
2760   BFD_RELOC_860_RELATIVE,
2761   BFD_RELOC_860_PC26,
2762   BFD_RELOC_860_PLT26,
2763   BFD_RELOC_860_PC16,
2764   BFD_RELOC_860_LOW0,
2765   BFD_RELOC_860_SPLIT0,
2766   BFD_RELOC_860_LOW1,
2767   BFD_RELOC_860_SPLIT1,
2768   BFD_RELOC_860_LOW2,
2769   BFD_RELOC_860_SPLIT2,
2770   BFD_RELOC_860_LOW3,
2771   BFD_RELOC_860_LOGOT0,
2772   BFD_RELOC_860_SPGOT0,
2773   BFD_RELOC_860_LOGOT1,
2774   BFD_RELOC_860_SPGOT1,
2775   BFD_RELOC_860_LOGOTOFF0,
2776   BFD_RELOC_860_SPGOTOFF0,
2777   BFD_RELOC_860_LOGOTOFF1,
2778   BFD_RELOC_860_SPGOTOFF1,
2779   BFD_RELOC_860_LOGOTOFF2,
2780   BFD_RELOC_860_LOGOTOFF3,
2781   BFD_RELOC_860_LOPC,
2782   BFD_RELOC_860_HIGHADJ,
2783   BFD_RELOC_860_HAGOT,
2784   BFD_RELOC_860_HAGOTOFF,
2785   BFD_RELOC_860_HAPC,
2786   BFD_RELOC_860_HIGH,
2787   BFD_RELOC_860_HIGOT,
2788   BFD_RELOC_860_HIGOTOFF,
2789
2790 /* OpenRISC Relocations. */
2791   BFD_RELOC_OPENRISC_ABS_26,
2792   BFD_RELOC_OPENRISC_REL_26,
2793   BFD_RELOC_UNUSED };
2794 typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2795 reloc_howto_type *
2796 bfd_reloc_type_lookup PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
2797
2798 const char *
2799 bfd_get_reloc_code_name PARAMS ((bfd_reloc_code_real_type code));
2800
2801
2802 typedef struct symbol_cache_entry
2803 {
2804        /* A pointer to the BFD which owns the symbol. This information
2805           is necessary so that a back end can work out what additional
2806           information (invisible to the application writer) is carried
2807           with the symbol.
2808
2809           This field is *almost* redundant, since you can use section->owner
2810           instead, except that some symbols point to the global sections
2811           bfd_{abs,com,und}_section.  This could be fixed by making
2812           these globals be per-bfd (or per-target-flavor).  FIXME. */
2813
2814   struct _bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */
2815
2816        /* The text of the symbol. The name is left alone, and not copied; the
2817           application may not alter it. */
2818   CONST char *name;
2819
2820        /* The value of the symbol.  This really should be a union of a
2821           numeric value with a pointer, since some flags indicate that
2822           a pointer to another symbol is stored here.  */
2823   symvalue value;
2824
2825        /* Attributes of a symbol: */
2826
2827 #define BSF_NO_FLAGS    0x00
2828
2829        /* The symbol has local scope; <<static>> in <<C>>. The value
2830           is the offset into the section of the data. */
2831 #define BSF_LOCAL      0x01
2832
2833        /* The symbol has global scope; initialized data in <<C>>. The
2834           value is the offset into the section of the data. */
2835 #define BSF_GLOBAL     0x02
2836
2837        /* The symbol has global scope and is exported. The value is
2838           the offset into the section of the data. */
2839 #define BSF_EXPORT     BSF_GLOBAL /* no real difference */
2840
2841        /* A normal C symbol would be one of:
2842           <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
2843           <<BSF_GLOBAL>> */
2844
2845        /* The symbol is a debugging record. The value has an arbitary
2846           meaning, unless BSF_DEBUGGING_RELOC is also set.  */
2847 #define BSF_DEBUGGING  0x08
2848
2849        /* The symbol denotes a function entry point.  Used in ELF,
2850           perhaps others someday.  */
2851 #define BSF_FUNCTION    0x10
2852
2853        /* Used by the linker. */
2854 #define BSF_KEEP        0x20
2855 #define BSF_KEEP_G      0x40
2856
2857        /* A weak global symbol, overridable without warnings by
2858           a regular global symbol of the same name.  */
2859 #define BSF_WEAK        0x80
2860
2861        /* This symbol was created to point to a section, e.g. ELF's
2862           STT_SECTION symbols.  */
2863 #define BSF_SECTION_SYM 0x100
2864
2865        /* The symbol used to be a common symbol, but now it is
2866           allocated. */
2867 #define BSF_OLD_COMMON  0x200
2868
2869        /* The default value for common data. */
2870 #define BFD_FORT_COMM_DEFAULT_VALUE 0
2871
2872        /* In some files the type of a symbol sometimes alters its
2873           location in an output file - ie in coff a <<ISFCN>> symbol
2874           which is also <<C_EXT>> symbol appears where it was
2875           declared and not at the end of a section.  This bit is set
2876           by the target BFD part to convey this information. */
2877
2878 #define BSF_NOT_AT_END    0x400
2879
2880        /* Signal that the symbol is the label of constructor section. */
2881 #define BSF_CONSTRUCTOR   0x800
2882
2883        /* Signal that the symbol is a warning symbol.  The name is a
2884           warning.  The name of the next symbol is the one to warn about;
2885           if a reference is made to a symbol with the same name as the next
2886           symbol, a warning is issued by the linker. */
2887 #define BSF_WARNING       0x1000
2888
2889        /* Signal that the symbol is indirect.  This symbol is an indirect
2890           pointer to the symbol with the same name as the next symbol. */
2891 #define BSF_INDIRECT      0x2000
2892
2893        /* BSF_FILE marks symbols that contain a file name.  This is used
2894           for ELF STT_FILE symbols.  */
2895 #define BSF_FILE          0x4000
2896
2897        /* Symbol is from dynamic linking information.  */
2898 #define BSF_DYNAMIC       0x8000
2899
2900        /* The symbol denotes a data object.  Used in ELF, and perhaps
2901           others someday.  */
2902 #define BSF_OBJECT        0x10000
2903
2904        /* This symbol is a debugging symbol.  The value is the offset
2905           into the section of the data.  BSF_DEBUGGING should be set
2906           as well.  */
2907 #define BSF_DEBUGGING_RELOC 0x20000
2908
2909   flagword flags;
2910
2911        /* A pointer to the section to which this symbol is
2912           relative.  This will always be non NULL, there are special
2913           sections for undefined and absolute symbols.  */
2914   struct sec *section;
2915
2916        /* Back end special data.  */
2917   union
2918     {
2919       PTR p;
2920       bfd_vma i;
2921     } udata;
2922
2923 } asymbol;
2924 #define bfd_get_symtab_upper_bound(abfd) \
2925      BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
2926 boolean
2927 bfd_is_local_label PARAMS ((bfd *abfd, asymbol *sym));
2928
2929 boolean
2930 bfd_is_local_label_name PARAMS ((bfd *abfd, const char *name));
2931
2932 #define bfd_is_local_label_name(abfd, name) \
2933      BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
2934 #define bfd_canonicalize_symtab(abfd, location) \
2935      BFD_SEND (abfd, _bfd_canonicalize_symtab,\
2936                   (abfd, location))
2937 boolean
2938 bfd_set_symtab PARAMS ((bfd *abfd, asymbol **location, unsigned int count));
2939
2940 void
2941 bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol));
2942
2943 #define bfd_make_empty_symbol(abfd) \
2944      BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
2945 #define bfd_make_debug_symbol(abfd,ptr,size) \
2946         BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
2947 int
2948 bfd_decode_symclass PARAMS ((asymbol *symbol));
2949
2950 boolean
2951 bfd_is_undefined_symclass PARAMS ((int symclass));
2952
2953 void
2954 bfd_symbol_info PARAMS ((asymbol *symbol, symbol_info *ret));
2955
2956 boolean
2957 bfd_copy_private_symbol_data PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym));
2958
2959 #define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
2960      BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
2961                (ibfd, isymbol, obfd, osymbol))
2962 struct _bfd
2963 {
2964     /* The filename the application opened the BFD with.  */
2965     const char *filename;
2966
2967     /* A pointer to the target jump table.             */
2968     const struct bfd_target *xvec;
2969
2970     /* To avoid dragging too many header files into every file that
2971        includes `<<bfd.h>>', IOSTREAM has been declared as a "char
2972        *", and MTIME as a "long".  Their correct types, to which they
2973        are cast when used, are "FILE *" and "time_t".    The iostream
2974        is the result of an fopen on the filename.  However, if the
2975        BFD_IN_MEMORY flag is set, then iostream is actually a pointer
2976        to a bfd_in_memory struct.  */
2977     PTR iostream;
2978
2979     /* Is the file descriptor being cached?  That is, can it be closed as
2980        needed, and re-opened when accessed later?  */
2981
2982     boolean cacheable;
2983
2984     /* Marks whether there was a default target specified when the
2985        BFD was opened. This is used to select which matching algorithm
2986        to use to choose the back end. */
2987
2988     boolean target_defaulted;
2989
2990     /* The caching routines use these to maintain a
2991        least-recently-used list of BFDs */
2992
2993     struct _bfd *lru_prev, *lru_next;
2994
2995     /* When a file is closed by the caching routines, BFD retains
2996        state information on the file here: */
2997
2998     file_ptr where;
2999
3000     /* and here: (``once'' means at least once) */
3001
3002     boolean opened_once;
3003
3004     /* Set if we have a locally maintained mtime value, rather than
3005        getting it from the file each time: */
3006
3007     boolean mtime_set;
3008
3009     /* File modified time, if mtime_set is true: */
3010
3011     long mtime;
3012
3013     /* Reserved for an unimplemented file locking extension.*/
3014
3015     int ifd;
3016
3017     /* The format which belongs to the BFD. (object, core, etc.) */
3018
3019     bfd_format format;
3020
3021     /* The direction the BFD was opened with*/
3022
3023     enum bfd_direction {no_direction = 0,
3024                         read_direction = 1,
3025                         write_direction = 2,
3026                         both_direction = 3} direction;
3027
3028     /* Format_specific flags*/
3029
3030     flagword flags;
3031
3032     /* Currently my_archive is tested before adding origin to
3033        anything. I believe that this can become always an add of
3034        origin, with origin set to 0 for non archive files.   */
3035
3036     file_ptr origin;
3037
3038     /* Remember when output has begun, to stop strange things
3039        from happening. */
3040     boolean output_has_begun;
3041
3042     /* Pointer to linked list of sections*/
3043     struct sec  *sections;
3044
3045     /* The number of sections */
3046     unsigned int section_count;
3047
3048     /* Stuff only useful for object files:
3049        The start address. */
3050     bfd_vma start_address;
3051
3052     /* Used for input and output*/
3053     unsigned int symcount;
3054
3055     /* Symbol table for output BFD (with symcount entries) */
3056     struct symbol_cache_entry  **outsymbols;
3057
3058     /* Pointer to structure which contains architecture information*/
3059     const struct bfd_arch_info *arch_info;
3060
3061     /* Stuff only useful for archives:*/
3062     PTR arelt_data;
3063     struct _bfd *my_archive;     /* The containing archive BFD.  */
3064     struct _bfd *next;           /* The next BFD in the archive.  */
3065     struct _bfd *archive_head;   /* The first BFD in the archive.  */
3066     boolean has_armap;
3067
3068     /* A chain of BFD structures involved in a link.  */
3069     struct _bfd *link_next;
3070
3071     /* A field used by _bfd_generic_link_add_archive_symbols.  This will
3072        be used only for archive elements.  */
3073     int archive_pass;
3074
3075     /* Used by the back end to hold private data. */
3076
3077     union
3078       {
3079       struct aout_data_struct *aout_data;
3080       struct artdata *aout_ar_data;
3081       struct _oasys_data *oasys_obj_data;
3082       struct _oasys_ar_data *oasys_ar_data;
3083       struct coff_tdata *coff_obj_data;
3084       struct pe_tdata *pe_obj_data;
3085       struct xcoff_tdata *xcoff_obj_data;
3086       struct ecoff_tdata *ecoff_obj_data;
3087       struct ieee_data_struct *ieee_data;
3088       struct ieee_ar_data_struct *ieee_ar_data;
3089       struct srec_data_struct *srec_data;
3090       struct ihex_data_struct *ihex_data;
3091       struct tekhex_data_struct *tekhex_data;
3092       struct elf_obj_tdata *elf_obj_data;
3093       struct nlm_obj_tdata *nlm_obj_data;
3094       struct bout_data_struct *bout_data;
3095       struct sun_core_struct *sun_core_data;
3096       struct sco5_core_struct *sco5_core_data;
3097       struct trad_core_struct *trad_core_data;
3098       struct som_data_struct *som_data;
3099       struct hpux_core_struct *hpux_core_data;
3100       struct hppabsd_core_struct *hppabsd_core_data;
3101       struct sgi_core_struct *sgi_core_data;
3102       struct lynx_core_struct *lynx_core_data;
3103       struct osf_core_struct *osf_core_data;
3104       struct cisco_core_struct *cisco_core_data;
3105       struct versados_data_struct *versados_data;
3106       struct netbsd_core_struct *netbsd_core_data;
3107       PTR any;
3108       } tdata;
3109
3110     /* Used by the application to hold private data*/
3111     PTR usrdata;
3112
3113   /* Where all the allocated stuff under this BFD goes.  This is a
3114      struct objalloc *, but we use PTR to avoid requiring the inclusion of
3115      objalloc.h.  */
3116     PTR memory;
3117 };
3118
3119 typedef enum bfd_error
3120 {
3121   bfd_error_no_error = 0,
3122   bfd_error_system_call,
3123   bfd_error_invalid_target,
3124   bfd_error_wrong_format,
3125   bfd_error_invalid_operation,
3126   bfd_error_no_memory,
3127   bfd_error_no_symbols,
3128   bfd_error_no_armap,
3129   bfd_error_no_more_archived_files,
3130   bfd_error_malformed_archive,
3131   bfd_error_file_not_recognized,
3132   bfd_error_file_ambiguously_recognized,
3133   bfd_error_no_contents,
3134   bfd_error_nonrepresentable_section,
3135   bfd_error_no_debug_section,
3136   bfd_error_bad_value,
3137   bfd_error_file_truncated,
3138   bfd_error_file_too_big,
3139   bfd_error_invalid_error_code
3140 } bfd_error_type;
3141
3142 bfd_error_type
3143 bfd_get_error PARAMS ((void));
3144
3145 void
3146 bfd_set_error PARAMS ((bfd_error_type error_tag));
3147
3148 const char *
3149 bfd_errmsg PARAMS ((bfd_error_type error_tag));
3150
3151 void
3152 bfd_perror PARAMS ((const char *message));
3153
3154 typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...));
3155
3156 bfd_error_handler_type
3157 bfd_set_error_handler PARAMS ((bfd_error_handler_type));
3158
3159 void
3160 bfd_set_error_program_name PARAMS ((const char *));
3161
3162 bfd_error_handler_type
3163 bfd_get_error_handler PARAMS ((void));
3164
3165 long
3166 bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
3167
3168 long
3169 bfd_canonicalize_reloc PARAMS ((bfd *abfd,
3170     asection *sec,
3171     arelent **loc,
3172     asymbol **syms));
3173
3174 void
3175 bfd_set_reloc PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count)
3176
3177     );
3178
3179 boolean
3180 bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags));
3181
3182 int
3183 bfd_get_arch_size PARAMS ((bfd *abfd));
3184
3185 int
3186 bfd_get_sign_extend_vma PARAMS ((bfd *abfd));
3187
3188 boolean
3189 bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma));
3190
3191 long
3192 bfd_get_mtime PARAMS ((bfd *abfd));
3193
3194 long
3195 bfd_get_size PARAMS ((bfd *abfd));
3196
3197 int
3198 bfd_get_gp_size PARAMS ((bfd *abfd));
3199
3200 void
3201 bfd_set_gp_size PARAMS ((bfd *abfd, int i));
3202
3203 bfd_vma
3204 bfd_scan_vma PARAMS ((const char *string, const char **end, int base));
3205
3206 boolean
3207 bfd_copy_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
3208
3209 #define bfd_copy_private_bfd_data(ibfd, obfd) \
3210      BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
3211                (ibfd, obfd))
3212 boolean
3213 bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
3214
3215 #define bfd_merge_private_bfd_data(ibfd, obfd) \
3216      BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
3217                (ibfd, obfd))
3218 boolean
3219 bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
3220
3221 #define bfd_set_private_flags(abfd, flags) \
3222      BFD_SEND (abfd, _bfd_set_private_flags, \
3223                (abfd, flags))
3224 #define bfd_sizeof_headers(abfd, reloc) \
3225      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
3226
3227 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
3228      BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
3229
3230        /* Do these three do anything useful at all, for any back end?  */
3231 #define bfd_debug_info_start(abfd) \
3232         BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
3233
3234 #define bfd_debug_info_end(abfd) \
3235         BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
3236
3237 #define bfd_debug_info_accumulate(abfd, section) \
3238         BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
3239
3240
3241 #define bfd_stat_arch_elt(abfd, stat) \
3242         BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
3243
3244 #define bfd_update_armap_timestamp(abfd) \
3245         BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
3246
3247 #define bfd_set_arch_mach(abfd, arch, mach)\
3248         BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
3249
3250 #define bfd_relax_section(abfd, section, link_info, again) \
3251        BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
3252
3253 #define bfd_gc_sections(abfd, link_info) \
3254        BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
3255
3256 #define bfd_merge_sections(abfd, link_info) \
3257        BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
3258
3259 #define bfd_link_hash_table_create(abfd) \
3260        BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
3261
3262 #define bfd_link_add_symbols(abfd, info) \
3263        BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
3264
3265 #define bfd_final_link(abfd, info) \
3266        BFD_SEND (abfd, _bfd_final_link, (abfd, info))
3267
3268 #define bfd_free_cached_info(abfd) \
3269        BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
3270
3271 #define bfd_get_dynamic_symtab_upper_bound(abfd) \
3272        BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
3273
3274 #define bfd_print_private_bfd_data(abfd, file)\
3275        BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
3276
3277 #define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
3278        BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
3279
3280 #define bfd_get_dynamic_reloc_upper_bound(abfd) \
3281        BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
3282
3283 #define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
3284        BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
3285
3286 extern bfd_byte *bfd_get_relocated_section_contents
3287        PARAMS ((bfd *, struct bfd_link_info *,
3288                  struct bfd_link_order *, bfd_byte *,
3289                  boolean, asymbol **));
3290
3291 symindex
3292 bfd_get_next_mapent PARAMS ((bfd *abfd, symindex previous, carsym **sym));
3293
3294 boolean
3295 bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head));
3296
3297 bfd *
3298 bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous));
3299
3300 CONST char *
3301 bfd_core_file_failing_command PARAMS ((bfd *abfd));
3302
3303 int
3304 bfd_core_file_failing_signal PARAMS ((bfd *abfd));
3305
3306 boolean
3307 core_file_matches_executable_p PARAMS ((bfd *core_bfd, bfd *exec_bfd));
3308
3309 #define BFD_SEND(bfd, message, arglist) \
3310                ((*((bfd)->xvec->message)) arglist)
3311
3312 #ifdef DEBUG_BFD_SEND
3313 #undef BFD_SEND
3314 #define BFD_SEND(bfd, message, arglist) \
3315   (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
3316     ((*((bfd)->xvec->message)) arglist) : \
3317     (bfd_assert (__FILE__,__LINE__), NULL))
3318 #endif
3319 #define BFD_SEND_FMT(bfd, message, arglist) \
3320             (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)
3321
3322 #ifdef DEBUG_BFD_SEND
3323 #undef BFD_SEND_FMT
3324 #define BFD_SEND_FMT(bfd, message, arglist) \
3325   (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
3326    (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \
3327    (bfd_assert (__FILE__,__LINE__), NULL))
3328 #endif
3329 enum bfd_flavour {
3330   bfd_target_unknown_flavour,
3331   bfd_target_aout_flavour,
3332   bfd_target_coff_flavour,
3333   bfd_target_ecoff_flavour,
3334   bfd_target_xcoff_flavour,
3335   bfd_target_elf_flavour,
3336   bfd_target_ieee_flavour,
3337   bfd_target_nlm_flavour,
3338   bfd_target_oasys_flavour,
3339   bfd_target_tekhex_flavour,
3340   bfd_target_srec_flavour,
3341   bfd_target_ihex_flavour,
3342   bfd_target_som_flavour,
3343   bfd_target_os9k_flavour,
3344   bfd_target_versados_flavour,
3345   bfd_target_msdos_flavour,
3346   bfd_target_ovax_flavour,
3347   bfd_target_evax_flavour
3348 };
3349
3350 enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
3351
3352 /* Forward declaration.  */
3353 typedef struct bfd_link_info _bfd_link_info;
3354
3355 typedef struct bfd_target
3356 {
3357   char *name;
3358   enum bfd_flavour flavour;
3359   enum bfd_endian byteorder;
3360   enum bfd_endian header_byteorder;
3361   flagword object_flags;
3362   flagword section_flags;
3363   char symbol_leading_char;
3364   char ar_pad_char;
3365   unsigned short ar_max_namelen;
3366   bfd_vma      (*bfd_getx64) PARAMS ((const bfd_byte *));
3367   bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *));
3368   void         (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *));
3369   bfd_vma      (*bfd_getx32) PARAMS ((const bfd_byte *));
3370   bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *));
3371   void         (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *));
3372   bfd_vma      (*bfd_getx16) PARAMS ((const bfd_byte *));
3373   bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *));
3374   void         (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *));
3375   bfd_vma      (*bfd_h_getx64) PARAMS ((const bfd_byte *));
3376   bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *));
3377   void         (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *));
3378   bfd_vma      (*bfd_h_getx32) PARAMS ((const bfd_byte *));
3379   bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *));
3380   void         (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *));
3381   bfd_vma      (*bfd_h_getx16) PARAMS ((const bfd_byte *));
3382   bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *));
3383   void         (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *));
3384   const struct bfd_target *(*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
3385   boolean             (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *));
3386   boolean             (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *));
3387
3388   /* Generic entry points.  */
3389 #define BFD_JUMP_TABLE_GENERIC(NAME)\
3390 CAT(NAME,_close_and_cleanup),\
3391 CAT(NAME,_bfd_free_cached_info),\
3392 CAT(NAME,_new_section_hook),\
3393 CAT(NAME,_get_section_contents),\
3394 CAT(NAME,_get_section_contents_in_window)
3395
3396   /* Called when the BFD is being closed to do any necessary cleanup.  */
3397   boolean       (*_close_and_cleanup) PARAMS ((bfd *));
3398   /* Ask the BFD to free all cached information.  */
3399   boolean (*_bfd_free_cached_info) PARAMS ((bfd *));
3400   /* Called when a new section is created.  */
3401   boolean       (*_new_section_hook) PARAMS ((bfd *, sec_ptr));
3402   /* Read the contents of a section.  */
3403   boolean       (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
3404                                             file_ptr, bfd_size_type));
3405   boolean       (*_bfd_get_section_contents_in_window)
3406                           PARAMS ((bfd *, sec_ptr, bfd_window *,
3407                                    file_ptr, bfd_size_type));
3408
3409   /* Entry points to copy private data.  */
3410 #define BFD_JUMP_TABLE_COPY(NAME)\
3411 CAT(NAME,_bfd_copy_private_bfd_data),\
3412 CAT(NAME,_bfd_merge_private_bfd_data),\
3413 CAT(NAME,_bfd_copy_private_section_data),\
3414 CAT(NAME,_bfd_copy_private_symbol_data),\
3415 CAT(NAME,_bfd_set_private_flags),\
3416 CAT(NAME,_bfd_print_private_bfd_data)\
3417   /* Called to copy BFD general private data from one object file
3418      to another.  */
3419   boolean       (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *));
3420   /* Called to merge BFD general private data from one object file
3421      to a common output file when linking.  */
3422   boolean       (*_bfd_merge_private_bfd_data) PARAMS ((bfd *, bfd *));
3423   /* Called to copy BFD private section data from one object file
3424      to another.  */
3425   boolean       (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr,
3426                                                        bfd *, sec_ptr));
3427   /* Called to copy BFD private symbol data from one symbol
3428      to another.  */
3429   boolean       (*_bfd_copy_private_symbol_data) PARAMS ((bfd *, asymbol *,
3430                                                           bfd *, asymbol *));
3431   /* Called to set private backend flags */
3432   boolean       (*_bfd_set_private_flags) PARAMS ((bfd *, flagword));
3433
3434   /* Called to print private BFD data */
3435   boolean       (*_bfd_print_private_bfd_data) PARAMS ((bfd *, PTR));
3436
3437   /* Core file entry points.  */
3438 #define BFD_JUMP_TABLE_CORE(NAME)\
3439 CAT(NAME,_core_file_failing_command),\
3440 CAT(NAME,_core_file_failing_signal),\
3441 CAT(NAME,_core_file_matches_executable_p)
3442   char *   (*_core_file_failing_command) PARAMS ((bfd *));
3443   int      (*_core_file_failing_signal) PARAMS ((bfd *));
3444   boolean  (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *));
3445
3446   /* Archive entry points.  */
3447 #define BFD_JUMP_TABLE_ARCHIVE(NAME)\
3448 CAT(NAME,_slurp_armap),\
3449 CAT(NAME,_slurp_extended_name_table),\
3450 CAT(NAME,_construct_extended_name_table),\
3451 CAT(NAME,_truncate_arname),\
3452 CAT(NAME,_write_armap),\
3453 CAT(NAME,_read_ar_hdr),\
3454 CAT(NAME,_openr_next_archived_file),\
3455 CAT(NAME,_get_elt_at_index),\
3456 CAT(NAME,_generic_stat_arch_elt),\
3457 CAT(NAME,_update_armap_timestamp)
3458   boolean  (*_bfd_slurp_armap) PARAMS ((bfd *));
3459   boolean  (*_bfd_slurp_extended_name_table) PARAMS ((bfd *));
3460   boolean  (*_bfd_construct_extended_name_table)
3461              PARAMS ((bfd *, char **, bfd_size_type *, const char **));
3462   void     (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *));
3463   boolean  (*write_armap) PARAMS ((bfd *arch,
3464                               unsigned int elength,
3465                               struct orl *map,
3466                               unsigned int orl_count,
3467                               int stridx));
3468   PTR (*_bfd_read_ar_hdr_fn) PARAMS ((bfd *));
3469   bfd *    (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev));
3470 #define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i))
3471   bfd *    (*_bfd_get_elt_at_index) PARAMS ((bfd *, symindex));
3472   int      (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *));
3473   boolean  (*_bfd_update_armap_timestamp) PARAMS ((bfd *));
3474
3475   /* Entry points used for symbols.  */
3476 #define BFD_JUMP_TABLE_SYMBOLS(NAME)\
3477 CAT(NAME,_get_symtab_upper_bound),\
3478 CAT(NAME,_get_symtab),\
3479 CAT(NAME,_make_empty_symbol),\
3480 CAT(NAME,_print_symbol),\
3481 CAT(NAME,_get_symbol_info),\
3482 CAT(NAME,_bfd_is_local_label_name),\
3483 CAT(NAME,_get_lineno),\
3484 CAT(NAME,_find_nearest_line),\
3485 CAT(NAME,_bfd_make_debug_symbol),\
3486 CAT(NAME,_read_minisymbols),\
3487 CAT(NAME,_minisymbol_to_symbol)
3488   long  (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *));
3489   long  (*_bfd_canonicalize_symtab) PARAMS ((bfd *,
3490                                              struct symbol_cache_entry **));
3491   struct symbol_cache_entry  *
3492                 (*_bfd_make_empty_symbol) PARAMS ((bfd *));
3493   void          (*_bfd_print_symbol) PARAMS ((bfd *, PTR,
3494                                       struct symbol_cache_entry *,
3495                                       bfd_print_symbol_type));
3496 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
3497   void          (*_bfd_get_symbol_info) PARAMS ((bfd *,
3498                                       struct symbol_cache_entry *,
3499                                       symbol_info *));
3500 #define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e))
3501   boolean       (*_bfd_is_local_label_name) PARAMS ((bfd *, const char *));
3502
3503   alent *    (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *));
3504   boolean    (*_bfd_find_nearest_line) PARAMS ((bfd *abfd,
3505                     struct sec *section, struct symbol_cache_entry **symbols,
3506                     bfd_vma offset, CONST char **file, CONST char **func,
3507                     unsigned int *line));
3508  /* Back-door to allow format-aware applications to create debug symbols
3509     while using BFD for everything else.  Currently used by the assembler
3510     when creating COFF files.  */
3511   asymbol *  (*_bfd_make_debug_symbol) PARAMS ((
3512        bfd *abfd,
3513        void *ptr,
3514        unsigned long size));
3515 #define bfd_read_minisymbols(b, d, m, s) \
3516   BFD_SEND (b, _read_minisymbols, (b, d, m, s))
3517   long  (*_read_minisymbols) PARAMS ((bfd *, boolean, PTR *,
3518                                       unsigned int *));
3519 #define bfd_minisymbol_to_symbol(b, d, m, f) \
3520   BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
3521   asymbol *(*_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR,
3522                                              asymbol *));
3523
3524   /* Routines for relocs.  */
3525 #define BFD_JUMP_TABLE_RELOCS(NAME)\
3526 CAT(NAME,_get_reloc_upper_bound),\
3527 CAT(NAME,_canonicalize_reloc),\
3528 CAT(NAME,_bfd_reloc_type_lookup)
3529   long  (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr));
3530   long  (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **,
3531                                             struct symbol_cache_entry **));
3532   /* See documentation on reloc types.  */
3533   reloc_howto_type *
3534        (*reloc_type_lookup) PARAMS ((bfd *abfd,
3535                                      bfd_reloc_code_real_type code));
3536
3537   /* Routines used when writing an object file.  */
3538 #define BFD_JUMP_TABLE_WRITE(NAME)\
3539 CAT(NAME,_set_arch_mach),\
3540 CAT(NAME,_set_section_contents)
3541   boolean    (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture,
3542                     unsigned long));
3543   boolean       (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR,
3544                                             file_ptr, bfd_size_type));
3545
3546   /* Routines used by the linker.  */
3547 #define BFD_JUMP_TABLE_LINK(NAME)\
3548 CAT(NAME,_sizeof_headers),\
3549 CAT(NAME,_bfd_get_relocated_section_contents),\
3550 CAT(NAME,_bfd_relax_section),\
3551 CAT(NAME,_bfd_link_hash_table_create),\
3552 CAT(NAME,_bfd_link_add_symbols),\
3553 CAT(NAME,_bfd_final_link),\
3554 CAT(NAME,_bfd_link_split_section),\
3555 CAT(NAME,_bfd_gc_sections),\
3556 CAT(NAME,_bfd_merge_sections)
3557   int        (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean));
3558   bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *,
3559                     struct bfd_link_info *, struct bfd_link_order *,
3560                     bfd_byte *data, boolean relocateable,
3561                     struct symbol_cache_entry **));
3562
3563   boolean    (*_bfd_relax_section) PARAMS ((bfd *, struct sec *,
3564                     struct bfd_link_info *, boolean *again));
3565
3566   /* Create a hash table for the linker.  Different backends store
3567      different information in this table.  */
3568   struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *));
3569
3570   /* Add symbols from this object file into the hash table.  */
3571   boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *));
3572
3573   /* Do a link based on the link_order structures attached to each
3574      section of the BFD.  */
3575   boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *));
3576
3577   /* Should this section be split up into smaller pieces during linking.  */
3578   boolean (*_bfd_link_split_section) PARAMS ((bfd *, struct sec *));
3579
3580   /* Remove sections that are not referenced from the output.  */
3581   boolean (*_bfd_gc_sections) PARAMS ((bfd *, struct bfd_link_info *));
3582
3583   /* Attempt to merge SEC_MERGE sections.  */
3584   boolean (*_bfd_merge_sections) PARAMS ((bfd *, struct bfd_link_info *));
3585
3586   /* Routines to handle dynamic symbols and relocs.  */
3587 #define BFD_JUMP_TABLE_DYNAMIC(NAME)\
3588 CAT(NAME,_get_dynamic_symtab_upper_bound),\
3589 CAT(NAME,_canonicalize_dynamic_symtab),\
3590 CAT(NAME,_get_dynamic_reloc_upper_bound),\
3591 CAT(NAME,_canonicalize_dynamic_reloc)
3592   /* Get the amount of memory required to hold the dynamic symbols. */
3593   long  (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *));
3594   /* Read in the dynamic symbols.  */
3595   long  (*_bfd_canonicalize_dynamic_symtab)
3596     PARAMS ((bfd *, struct symbol_cache_entry **));
3597   /* Get the amount of memory required to hold the dynamic relocs.  */
3598   long  (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *));
3599   /* Read in the dynamic relocs.  */
3600   long  (*_bfd_canonicalize_dynamic_reloc)
3601     PARAMS ((bfd *, arelent **, struct symbol_cache_entry **));
3602
3603  /* Opposite endian version of this target.  */
3604  const struct bfd_target * alternative_target;
3605
3606  PTR backend_data;
3607
3608 } bfd_target;
3609 boolean
3610 bfd_set_default_target PARAMS ((const char *name));
3611
3612 const bfd_target *
3613 bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd));
3614
3615 const char **
3616 bfd_target_list PARAMS ((void));
3617
3618 const bfd_target *
3619 bfd_search_for_target PARAMS ((int (* search_func) (const bfd_target *, void *), void *));
3620
3621 boolean
3622 bfd_check_format PARAMS ((bfd *abfd, bfd_format format));
3623
3624 boolean
3625 bfd_check_format_matches PARAMS ((bfd *abfd, bfd_format format, char ***matching));
3626
3627 boolean
3628 bfd_set_format PARAMS ((bfd *abfd, bfd_format format));
3629
3630 CONST char *
3631 bfd_format_string PARAMS ((bfd_format format));
3632
3633 #ifdef __cplusplus
3634 }
3635 #endif
3636 #endif