bfd/bfd-in.h

   1 /* Main header file for the bfd library -- portable access to object files.
   2
   3    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   5    Free Software Foundation, Inc.
   6
   7    Contributed by Cygnus Support.
   8
   9    This file is part of BFD, the Binary File Descriptor library.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  24
  25 #ifndef __BFD_H_SEEN__
  26 #define __BFD_H_SEEN__
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #include "ansidecl.h"
  33 #include "symcat.h"
  34 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
  35 #ifndef SABER
  36 /* This hack is to avoid a problem with some strict ANSI C preprocessors.
  37    The problem is, "32_" is not a valid preprocessing token, and we don't
  38    want extra underscores (e.g., "nlm_32_").  The XCONCAT2 macro will
  39    cause the inner CONCAT2 macros to be evaluated first, producing
  40    still-valid pp-tokens.  Then the final concatenation can be done.  */
  41 #undef CONCAT4
  42 #define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d))
  43 #endif
  44 #endif
  45
  46 /* This is a utility macro to handle the situation where the code
  47    wants to place a constant string into the code, followed by a
  48    comma and then the length of the string.  Doing this by hand
  49    is error prone, so using this macro is safer.  The macro will
  50    also safely handle the case where a NULL is passed as the arg.  */
  51 #define STRING_COMMA_LEN(STR) (STR), ((STR) ? sizeof (STR) - 1 : 0)
  52 /* Unfortunately it is not possible to use the STRING_COMMA_LEN macro
  53    to create the arguments to another macro, since the preprocessor
  54    will mis-count the number of arguments to the outer macro (by not
  55    evaluating STRING_COMMA_LEN and so missing the comma).  This is a
  56    problem for example when trying to use STRING_COMMA_LEN to build
  57    the arguments to the strncmp() macro.  Hence this alternative
  58    definition of strncmp is provided here.
  59
  60    Note - these macros do NOT work if STR2 is not a constant string.  */
  61 #define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
  62 #define CONST_STRNCPY(STR1,STR2) strncpy ((STR1), (STR2), sizeof (STR2) - 1)
  63
  64
  65 /* The word size used by BFD on the host.  This may be 64 with a 32
  66    bit target if the host is 64 bit, or if other 64 bit targets have
  67    been selected with --enable-targets, or if --enable-64-bit-bfd.  */
  68 #define BFD_ARCH_SIZE @wordsize@
  69
  70 /* The word size of the default bfd target.  */
  71 #define BFD_DEFAULT_TARGET_SIZE @bfd_default_target_size@
  72
  73 #define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@
  74 #define BFD_HOST_LONG_LONG @BFD_HOST_LONG_LONG@
  75 #if @BFD_HOST_64_BIT_DEFINED@
  76 #define BFD_HOST_64_BIT @BFD_HOST_64_BIT@
  77 #define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@
  78 typedef BFD_HOST_64_BIT bfd_int64_t;
  79 typedef BFD_HOST_U_64_BIT bfd_uint64_t;
  80 #endif
  81
  82 #if BFD_ARCH_SIZE >= 64
  83 #define BFD64
  84 #endif
  85
  86 #ifndef INLINE
  87 #if __GNUC__ >= 2
  88 #define INLINE __inline__
  89 #else
  90 #define INLINE
  91 #endif
  92 #endif
  93
  94 /* Forward declaration.  */
  95 typedef struct bfd bfd;
  96
  97 /* Boolean type used in bfd.  Too many systems define their own
  98    versions of "boolean" for us to safely typedef a "boolean" of
  99    our own.  Using an enum for "bfd_boolean" has its own set of
 100    problems, with strange looking casts required to avoid warnings
 101    on some older compilers.  Thus we just use an int.
 102
 103    General rule: Functions which are bfd_boolean return TRUE on
 104    success and FALSE on failure (unless they're a predicate).  */
 105
 106 typedef int bfd_boolean;
 107 #undef FALSE
 108 #undef TRUE
 109 #define FALSE 0
 110 #define TRUE 1
 111
 112 #ifdef BFD64
 113
 114 #ifndef BFD_HOST_64_BIT
 115  #error No 64 bit integer type available
 116 #endif /* ! defined (BFD_HOST_64_BIT) */
 117
 118 typedef BFD_HOST_U_64_BIT bfd_vma;
 119 typedef BFD_HOST_64_BIT bfd_signed_vma;
 120 typedef BFD_HOST_U_64_BIT bfd_size_type;
 121 typedef BFD_HOST_U_64_BIT symvalue;
 122
 123 #ifndef fprintf_vma
 124 #if BFD_HOST_64BIT_LONG
 125 #define sprintf_vma(s,x) sprintf (s, "%016lx", x)
 126 #define fprintf_vma(f,x) fprintf (f, "%016lx", x)
 127 #else
 128 #define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
 129 #define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
 130 #define fprintf_vma(s,x) \
 131   fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
 132 #define sprintf_vma(s,x) \
 133   sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
 134 #endif
 135 #endif
 136
 137 #else /* not BFD64  */
 138
 139 /* Represent a target address.  Also used as a generic unsigned type
 140    which is guaranteed to be big enough to hold any arithmetic types
 141    we need to deal with.  */
 142 typedef unsigned long bfd_vma;
 143
 144 /* A generic signed type which is guaranteed to be big enough to hold any
 145    arithmetic types we need to deal with.  Can be assumed to be compatible
 146    with bfd_vma in the same way that signed and unsigned ints are compatible
 147    (as parameters, in assignment, etc).  */
 148 typedef long bfd_signed_vma;
 149
 150 typedef unsigned long symvalue;
 151 typedef unsigned long bfd_size_type;
 152
 153 /* Print a bfd_vma x on stream s.  */
 154 #define fprintf_vma(s,x) fprintf (s, "%08lx", x)
 155 #define sprintf_vma(s,x) sprintf (s, "%08lx", x)
 156
 157 #endif /* not BFD64  */
 158
 159 #define HALF_BFD_SIZE_TYPE \
 160   (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2))
 161
 162 #ifndef BFD_HOST_64_BIT
 163 /* Fall back on a 32 bit type.  The idea is to make these types always
 164    available for function return types, but in the case that
 165    BFD_HOST_64_BIT is undefined such a function should abort or
 166    otherwise signal an error.  */
 167 typedef bfd_signed_vma bfd_int64_t;
 168 typedef bfd_vma bfd_uint64_t;
 169 #endif
 170
 171 /* An offset into a file.  BFD always uses the largest possible offset
 172    based on the build time availability of fseek, fseeko, or fseeko64.  */
 173 typedef @bfd_file_ptr@ file_ptr;
 174 typedef unsigned @bfd_file_ptr@ ufile_ptr;
 175
 176 extern void bfd_sprintf_vma (bfd *, char *, bfd_vma);
 177 extern void bfd_fprintf_vma (bfd *, void *, bfd_vma);
 178
 179 #define printf_vma(x) fprintf_vma(stdout,x)
 180 #define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x)
 181
 182 typedef unsigned int flagword;  /* 32 bits of flags */
 183 typedef unsigned char bfd_byte;
 184 \f
 185 /* File formats.  */
 186
 187 typedef enum bfd_format
 188 {
 189   bfd_unknown = 0,      /* File format is unknown.  */
 190   bfd_object,           /* Linker/assembler/compiler output.  */
 191   bfd_archive,          /* Object archive file.  */
 192   bfd_core,             /* Core dump.  */
 193   bfd_type_end          /* Marks the end; don't use it!  */
 194 }
 195 bfd_format;
 196
 197 /* Values that may appear in the flags field of a BFD.  These also
 198    appear in the object_flags field of the bfd_target structure, where
 199    they indicate the set of flags used by that backend (not all flags
 200    are meaningful for all object file formats) (FIXME: at the moment,
 201    the object_flags values have mostly just been copied from backend
 202    to another, and are not necessarily correct).  */
 203
 204 /* No flags.  */
 205 #define BFD_NO_FLAGS    0x00
 206
 207 /* BFD contains relocation entries.  */
 208 #define HAS_RELOC       0x01
 209
 210 /* BFD is directly executable.  */
 211 #define EXEC_P          0x02
 212
 213 /* BFD has line number information (basically used for F_LNNO in a
 214    COFF header).  */
 215 #define HAS_LINENO      0x04
 216
 217 /* BFD has debugging information.  */
 218 #define HAS_DEBUG       0x08
 219
 220 /* BFD has symbols.  */
 221 #define HAS_SYMS        0x10
 222
 223 /* BFD has local symbols (basically used for F_LSYMS in a COFF
 224    header).  */
 225 #define HAS_LOCALS      0x20
 226
 227 /* BFD is a dynamic object.  */
 228 #define DYNAMIC         0x40
 229
 230 /* Text section is write protected (if D_PAGED is not set, this is
 231    like an a.out NMAGIC file) (the linker sets this by default, but
 232    clears it for -r or -N).  */
 233 #define WP_TEXT         0x80
 234
 235 /* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 236    linker sets this by default, but clears it for -r or -n or -N).  */
 237 #define D_PAGED         0x100
 238
 239 /* BFD is relaxable (this means that bfd_relax_section may be able to
 240    do something) (sometimes bfd_relax_section can do something even if
 241    this is not set).  */
 242 #define BFD_IS_RELAXABLE 0x200
 243
 244 /* This may be set before writing out a BFD to request using a
 245    traditional format.  For example, this is used to request that when
 246    writing out an a.out object the symbols not be hashed to eliminate
 247    duplicates.  */
 248 #define BFD_TRADITIONAL_FORMAT 0x400
 249
 250 /* This flag indicates that the BFD contents are actually cached in
 251    memory.  If this is set, iostream points to a bfd_in_memory struct.  */
 252 #define BFD_IN_MEMORY 0x800
 253
 254 /* The sections in this BFD specify a memory page.  */
 255 #define HAS_LOAD_PAGE 0x1000
 256
 257 /* This BFD has been created by the linker and doesn't correspond
 258    to any input file.  */
 259 #define BFD_LINKER_CREATED 0x2000
 260 \f
 261 /* Symbols and relocation.  */
 262
 263 /* A count of carsyms (canonical archive symbols).  */
 264 typedef unsigned long symindex;
 265
 266 /* How to perform a relocation.  */
 267 typedef const struct reloc_howto_struct reloc_howto_type;
 268
 269 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
 270
 271 /* General purpose part of a symbol X;
 272    target specific parts are in libcoff.h, libaout.h, etc.  */
 273
 274 #define bfd_get_section(x) ((x)->section)
 275 #define bfd_get_output_section(x) ((x)->section->output_section)
 276 #define bfd_set_section(x,y) ((x)->section) = (y)
 277 #define bfd_asymbol_base(x) ((x)->section->vma)
 278 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
 279 #define bfd_asymbol_name(x) ((x)->name)
 280 /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
 281 #define bfd_asymbol_bfd(x) ((x)->the_bfd)
 282 #define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
 283
 284 /* A canonical archive symbol.  */
 285 /* This is a type pun with struct ranlib on purpose!  */
 286 typedef struct carsym
 287 {
 288   char *name;
 289   file_ptr file_offset; /* Look here to find the file.  */
 290 }
 291 carsym;                 /* To make these you call a carsymogen.  */
 292
 293 /* Used in generating armaps (archive tables of contents).
 294    Perhaps just a forward definition would do?  */
 295 struct orl                      /* Output ranlib.  */
 296 {
 297   char **name;          /* Symbol name.  */
 298   union
 299   {
 300     file_ptr pos;
 301     bfd *abfd;
 302   } u;                  /* bfd* or file position.  */
 303   int namidx;           /* Index into string table.  */
 304 };
 305 \f
 306 /* Linenumber stuff.  */
 307 typedef struct lineno_cache_entry
 308 {
 309   unsigned int line_number;     /* Linenumber from start of function.  */
 310   union
 311   {
 312     struct bfd_symbol *sym;     /* Function name.  */
 313     bfd_vma offset;                     /* Offset into section.  */
 314   } u;
 315 }
 316 alent;
 317 \f
 318 /* Object and core file sections.  */
 319
 320 #define align_power(addr, align)        \
 321   (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align)))
 322
 323 typedef struct bfd_section *sec_ptr;
 324
 325 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
 326 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
 327 #define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0)
 328 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
 329 #define bfd_section_name(bfd, ptr) ((ptr)->name)
 330 #define bfd_section_size(bfd, ptr) ((ptr)->size)
 331 #define bfd_get_section_size(ptr) ((ptr)->size)
 332 #define bfd_section_vma(bfd, ptr) ((ptr)->vma)
 333 #define bfd_section_lma(bfd, ptr) ((ptr)->lma)
 334 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
 335 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
 336 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
 337
 338 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 339
 340 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)
 341 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)
 342 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)
 343 /* Find the address one past the end of SEC.  */
 344 #define bfd_get_section_limit(bfd, sec) \
 345   (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \
 346    / bfd_octets_per_byte (bfd))
 347
 348 typedef struct stat stat_type;
 349 \f
 350 typedef enum bfd_print_symbol
 351 {
 352   bfd_print_symbol_name,
 353   bfd_print_symbol_more,
 354   bfd_print_symbol_all
 355 } bfd_print_symbol_type;
 356
 357 /* Information about a symbol that nm needs.  */
 358
 359 typedef struct _symbol_info
 360 {
 361   symvalue value;
 362   char type;
 363   const char *name;            /* Symbol name.  */
 364   unsigned char stab_type;     /* Stab type.  */
 365   char stab_other;             /* Stab other.  */
 366   short stab_desc;             /* Stab desc.  */
 367   const char *stab_name;       /* String for stab type.  */
 368 } symbol_info;
 369
 370 /* Get the name of a stabs type code.  */
 371
 372 extern const char *bfd_get_stab_name (int);
 373 \f
 374 /* Hash table routines.  There is no way to free up a hash table.  */
 375
 376 /* An element in the hash table.  Most uses will actually use a larger
 377    structure, and an instance of this will be the first field.  */
 378
 379 struct bfd_hash_entry
 380 {
 381   /* Next entry for this hash code.  */
 382   struct bfd_hash_entry *next;
 383   /* String being hashed.  */
 384   const char *string;
 385   /* Hash code.  This is the full hash code, not the index into the
 386      table.  */
 387   unsigned long hash;
 388 };
 389
 390 /* A hash table.  */
 391
 392 struct bfd_hash_table
 393 {
 394   /* The hash array.  */
 395   struct bfd_hash_entry **table;
 396   /* The number of slots in the hash table.  */
 397   unsigned int size;
 398   /* The number of entries in the hash table.  */
 399   unsigned int count;
 400   /* The size of elements.  */
 401   unsigned int entsize;
 402   /* A function used to create new elements in the hash table.  The
 403      first entry is itself a pointer to an element.  When this
 404      function is first invoked, this pointer will be NULL.  However,
 405      having the pointer permits a hierarchy of method functions to be
 406      built each of which calls the function in the superclass.  Thus
 407      each function should be written to allocate a new block of memory
 408      only if the argument is NULL.  */
 409   struct bfd_hash_entry *(*newfunc)
 410     (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
 411    /* An objalloc for this hash table.  This is a struct objalloc *,
 412      but we use void * to avoid requiring the inclusion of objalloc.h.  */
 413   void *memory;
 414 };
 415
 416 /* Initialize a hash table.  */
 417 extern bfd_boolean bfd_hash_table_init
 418   (struct bfd_hash_table *,
 419    struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 420                                struct bfd_hash_table *,
 421                                const char *),
 422    unsigned int);
 423
 424 /* Initialize a hash table specifying a size.  */
 425 extern bfd_boolean bfd_hash_table_init_n
 426   (struct bfd_hash_table *,
 427    struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 428                                struct bfd_hash_table *,
 429                                const char *),
 430    unsigned int, unsigned int);
 431
 432 /* Free up a hash table.  */
 433 extern void bfd_hash_table_free
 434   (struct bfd_hash_table *);
 435
 436 /* Look up a string in a hash table.  If CREATE is TRUE, a new entry
 437    will be created for this string if one does not already exist.  The
 438    COPY argument must be TRUE if this routine should copy the string
 439    into newly allocated memory when adding an entry.  */
 440 extern struct bfd_hash_entry *bfd_hash_lookup
 441   (struct bfd_hash_table *, const char *, bfd_boolean create,
 442    bfd_boolean copy);
 443
 444 /* Replace an entry in a hash table.  */
 445 extern void bfd_hash_replace
 446   (struct bfd_hash_table *, struct bfd_hash_entry *old,
 447    struct bfd_hash_entry *nw);
 448
 449 /* Base method for creating a hash table entry.  */
 450 extern struct bfd_hash_entry *bfd_hash_newfunc
 451   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
 452
 453 /* Grab some space for a hash table entry.  */
 454 extern void *bfd_hash_allocate
 455   (struct bfd_hash_table *, unsigned int);
 456
 457 /* Traverse a hash table in a random order, calling a function on each
 458    element.  If the function returns FALSE, the traversal stops.  The
 459    INFO argument is passed to the function.  */
 460 extern void bfd_hash_traverse
 461   (struct bfd_hash_table *,
 462    bfd_boolean (*) (struct bfd_hash_entry *, void *),
 463    void *info);
 464
 465 /* Allows the default size of a hash table to be configured. New hash
 466    tables allocated using bfd_hash_table_init will be created with
 467    this size.  */
 468 extern void bfd_hash_set_default_size (bfd_size_type);
 469
 470 /* This structure is used to keep track of stabs in sections
 471    information while linking.  */
 472
 473 struct stab_info
 474 {
 475   /* A hash table used to hold stabs strings.  */
 476   struct bfd_strtab_hash *strings;
 477   /* The header file hash table.  */
 478   struct bfd_hash_table includes;
 479   /* The first .stabstr section.  */
 480   struct bfd_section *stabstr;
 481 };
 482
 483 #define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table
 484
 485 /* User program access to BFD facilities.  */
 486
 487 /* Direct I/O routines, for programs which know more about the object
 488    file than BFD does.  Use higher level routines if possible.  */
 489
 490 extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *);
 491 extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *);
 492 extern int bfd_seek (bfd *, file_ptr, int);
 493 extern file_ptr bfd_tell (bfd *);
 494 extern int bfd_flush (bfd *);
 495 extern int bfd_stat (bfd *, struct stat *);
 496
 497 /* Deprecated old routines.  */
 498 #if __GNUC__
 499 #define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)                            \
 500   (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__),      \
 501    bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
 502 #define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)                           \
 503   (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__),     \
 504    bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
 505 #else
 506 #define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)                            \
 507   (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \
 508    bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
 509 #define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)                           \
 510   (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\
 511    bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
 512 #endif
 513 extern void warn_deprecated (const char *, const char *, int, const char *);
 514
 515 /* Cast from const char * to char * so that caller can assign to
 516    a char * without a warning.  */
 517 #define bfd_get_filename(abfd) ((char *) (abfd)->filename)
 518 #define bfd_get_cacheable(abfd) ((abfd)->cacheable)
 519 #define bfd_get_format(abfd) ((abfd)->format)
 520 #define bfd_get_target(abfd) ((abfd)->xvec->name)
 521 #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
 522 #define bfd_family_coff(abfd) \
 523   (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \
 524    bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)
 525 #define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
 526 #define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
 527 #define bfd_header_big_endian(abfd) \
 528   ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
 529 #define bfd_header_little_endian(abfd) \
 530   ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
 531 #define bfd_get_file_flags(abfd) ((abfd)->flags)
 532 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
 533 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
 534 #define bfd_my_archive(abfd) ((abfd)->my_archive)
 535 #define bfd_has_map(abfd) ((abfd)->has_armap)
 536
 537 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
 538 #define bfd_usrdata(abfd) ((abfd)->usrdata)
 539
 540 #define bfd_get_start_address(abfd) ((abfd)->start_address)
 541 #define bfd_get_symcount(abfd) ((abfd)->symcount)
 542 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
 543 #define bfd_count_sections(abfd) ((abfd)->section_count)
 544
 545 #define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount)
 546
 547 #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
 548
 549 #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)
 550
 551 extern bfd_boolean bfd_cache_close
 552   (bfd *abfd);
 553 /* NB: This declaration should match the autogenerated one in libbfd.h.  */
 554
 555 extern bfd_boolean bfd_cache_close_all (void);
 556
 557 extern bfd_boolean bfd_record_phdr
 558   (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma,
 559    bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **);
 560
 561 /* Byte swapping routines.  */
 562
 563 bfd_uint64_t bfd_getb64 (const void *);
 564 bfd_uint64_t bfd_getl64 (const void *);
 565 bfd_int64_t bfd_getb_signed_64 (const void *);
 566 bfd_int64_t bfd_getl_signed_64 (const void *);
 567 bfd_vma bfd_getb32 (const void *);
 568 bfd_vma bfd_getl32 (const void *);
 569 bfd_signed_vma bfd_getb_signed_32 (const void *);
 570 bfd_signed_vma bfd_getl_signed_32 (const void *);
 571 bfd_vma bfd_getb16 (const void *);
 572 bfd_vma bfd_getl16 (const void *);
 573 bfd_signed_vma bfd_getb_signed_16 (const void *);
 574 bfd_signed_vma bfd_getl_signed_16 (const void *);
 575 void bfd_putb64 (bfd_uint64_t, void *);
 576 void bfd_putl64 (bfd_uint64_t, void *);
 577 void bfd_putb32 (bfd_vma, void *);
 578 void bfd_putl32 (bfd_vma, void *);
 579 void bfd_putb16 (bfd_vma, void *);
 580 void bfd_putl16 (bfd_vma, void *);
 581
 582 /* Byte swapping routines which take size and endiannes as arguments.  */
 583
 584 bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean);
 585 void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean);
 586
 587 extern bfd_boolean bfd_section_already_linked_table_init (void);
 588 extern void bfd_section_already_linked_table_free (void);
 589 \f
 590 /* Externally visible ECOFF routines.  */
 591
 592 #if defined(__STDC__) || defined(ALMOST_STDC)
 593 struct ecoff_debug_info;
 594 struct ecoff_debug_swap;
 595 struct ecoff_extr;
 596 struct bfd_symbol;
 597 struct bfd_link_info;
 598 struct bfd_link_hash_entry;
 599 struct bfd_elf_version_tree;
 600 #endif
 601 extern bfd_vma bfd_ecoff_get_gp_value
 602   (bfd * abfd);
 603 extern bfd_boolean bfd_ecoff_set_gp_value
 604   (bfd *abfd, bfd_vma gp_value);
 605 extern bfd_boolean bfd_ecoff_set_regmasks
 606   (bfd *abfd, unsigned long gprmask, unsigned long fprmask,
 607    unsigned long *cprmask);
 608 extern void *bfd_ecoff_debug_init
 609   (bfd *output_bfd, struct ecoff_debug_info *output_debug,
 610    const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);
 611 extern void bfd_ecoff_debug_free
 612   (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 613    const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);
 614 extern bfd_boolean bfd_ecoff_debug_accumulate
 615   (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 616    const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
 617    struct ecoff_debug_info *input_debug,
 618    const struct ecoff_debug_swap *input_swap, struct bfd_link_info *);
 619 extern bfd_boolean bfd_ecoff_debug_accumulate_other
 620   (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 621    const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
 622    struct bfd_link_info *);
 623 extern bfd_boolean bfd_ecoff_debug_externals
 624   (bfd *abfd, struct ecoff_debug_info *debug,
 625    const struct ecoff_debug_swap *swap, bfd_boolean relocatable,
 626    bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *),
 627    void (*set_index) (struct bfd_symbol *, bfd_size_type));
 628 extern bfd_boolean bfd_ecoff_debug_one_external
 629   (bfd *abfd, struct ecoff_debug_info *debug,
 630    const struct ecoff_debug_swap *swap, const char *name,
 631    struct ecoff_extr *esym);
 632 extern bfd_size_type bfd_ecoff_debug_size
 633   (bfd *abfd, struct ecoff_debug_info *debug,
 634    const struct ecoff_debug_swap *swap);
 635 extern bfd_boolean bfd_ecoff_write_debug
 636   (bfd *abfd, struct ecoff_debug_info *debug,
 637    const struct ecoff_debug_swap *swap, file_ptr where);
 638 extern bfd_boolean bfd_ecoff_write_accumulated_debug
 639   (void *handle, bfd *abfd, struct ecoff_debug_info *debug,
 640    const struct ecoff_debug_swap *swap,
 641    struct bfd_link_info *info, file_ptr where);
 642
 643 /* Externally visible ELF routines.  */
 644
 645 struct bfd_link_needed_list
 646 {
 647   struct bfd_link_needed_list *next;
 648   bfd *by;
 649   const char *name;
 650 };
 651
 652 enum dynamic_lib_link_class {
 653   DYN_NORMAL = 0,
 654   DYN_AS_NEEDED = 1,
 655   DYN_DT_NEEDED = 2,
 656   DYN_NO_ADD_NEEDED = 4,
 657   DYN_NO_NEEDED = 8
 658 };
 659
 660 enum notice_asneeded_action {
 661   notice_as_needed,
 662   notice_not_needed,
 663   notice_needed
 664 };
 665
 666 extern bfd_boolean bfd_elf_record_link_assignment
 667   (bfd *, struct bfd_link_info *, const char *, bfd_boolean,
 668    bfd_boolean);
 669 extern struct bfd_link_needed_list *bfd_elf_get_needed_list
 670   (bfd *, struct bfd_link_info *);
 671 extern bfd_boolean bfd_elf_get_bfd_needed_list
 672   (bfd *, struct bfd_link_needed_list **);
 673 extern bfd_boolean bfd_elf_size_dynamic_sections
 674   (bfd *, const char *, const char *, const char *, const char * const *,
 675    struct bfd_link_info *, struct bfd_section **,
 676    struct bfd_elf_version_tree *);
 677 extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr
 678   (bfd *, struct bfd_link_info *);
 679 extern void bfd_elf_set_dt_needed_name
 680   (bfd *, const char *);
 681 extern const char *bfd_elf_get_dt_soname
 682   (bfd *);
 683 extern void bfd_elf_set_dyn_lib_class
 684   (bfd *, int);
 685 extern int bfd_elf_get_dyn_lib_class
 686   (bfd *);
 687 extern struct bfd_link_needed_list *bfd_elf_get_runpath_list
 688   (bfd *, struct bfd_link_info *);
 689 extern bfd_boolean bfd_elf_discard_info
 690   (bfd *, struct bfd_link_info *);
 691 extern unsigned int _bfd_elf_default_action_discarded
 692   (struct bfd_section *);
 693
 694 /* Return an upper bound on the number of bytes required to store a
 695    copy of ABFD's program header table entries.  Return -1 if an error
 696    occurs; bfd_get_error will return an appropriate code.  */
 697 extern long bfd_get_elf_phdr_upper_bound
 698   (bfd *abfd);
 699
 700 /* Copy ABFD's program header table entries to *PHDRS.  The entries
 701    will be stored as an array of Elf_Internal_Phdr structures, as
 702    defined in include/elf/internal.h.  To find out how large the
 703    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
 704
 705    Return the number of program header table entries read, or -1 if an
 706    error occurs; bfd_get_error will return an appropriate code.  */
 707 extern int bfd_get_elf_phdrs
 708   (bfd *abfd, void *phdrs);
 709
 710 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
 711    reconstruct an ELF file by reading the segments out of remote memory
 712    based on the ELF file header at EHDR_VMA and the ELF program headers it
 713    points to.  If not null, *LOADBASEP is filled in with the difference
 714    between the VMAs from which the segments were read, and the VMAs the
 715    file headers (and hence BFD's idea of each section's VMA) put them at.
 716
 717    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
 718    remote memory at target address VMA into the local buffer at MYADDR; it
 719    should return zero on success or an `errno' code on failure.  TEMPL must
 720    be a BFD for an ELF target with the word size and byte order found in
 721    the remote memory.  */
 722 extern bfd *bfd_elf_bfd_from_remote_memory
 723   (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
 724    int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len));
 725
 726 /* Return the arch_size field of an elf bfd, or -1 if not elf.  */
 727 extern int bfd_get_arch_size
 728   (bfd *);
 729
 730 /* Return TRUE if address "naturally" sign extends, or -1 if not elf.  */
 731 extern int bfd_get_sign_extend_vma
 732   (bfd *);
 733
 734 extern struct bfd_section *_bfd_elf_tls_setup
 735   (bfd *, struct bfd_link_info *);
 736
 737 extern void _bfd_fix_excluded_sec_syms
 738   (bfd *, struct bfd_link_info *);
 739
 740 extern unsigned bfd_m68k_mach_to_features (int);
 741
 742 extern int bfd_m68k_features_to_mach (unsigned);
 743
 744 extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs
 745   (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,
 746    char **);
 747
 748 extern bfd_boolean bfd_bfin_elf32_create_embedded_relocs
 749   (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,
 750    char **);
 751
 752 /* SunOS shared library support routines for the linker.  */
 753
 754 extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
 755   (bfd *, struct bfd_link_info *);
 756 extern bfd_boolean bfd_sunos_record_link_assignment
 757   (bfd *, struct bfd_link_info *, const char *);
 758 extern bfd_boolean bfd_sunos_size_dynamic_sections
 759   (bfd *, struct bfd_link_info *, struct bfd_section **,
 760    struct bfd_section **, struct bfd_section **);
 761
 762 /* Linux shared library support routines for the linker.  */
 763
 764 extern bfd_boolean bfd_i386linux_size_dynamic_sections
 765   (bfd *, struct bfd_link_info *);
 766 extern bfd_boolean bfd_m68klinux_size_dynamic_sections
 767   (bfd *, struct bfd_link_info *);
 768 extern bfd_boolean bfd_sparclinux_size_dynamic_sections
 769   (bfd *, struct bfd_link_info *);
 770
 771 /* mmap hacks */
 772
 773 struct _bfd_window_internal;
 774 typedef struct _bfd_window_internal bfd_window_internal;
 775
 776 typedef struct _bfd_window
 777 {
 778   /* What the user asked for.  */
 779   void *data;
 780   bfd_size_type size;
 781   /* The actual window used by BFD.  Small user-requested read-only
 782      regions sharing a page may share a single window into the object
 783      file.  Read-write versions shouldn't until I've fixed things to
 784      keep track of which portions have been claimed by the
 785      application; don't want to give the same region back when the
 786      application wants two writable copies!  */
 787   struct _bfd_window_internal *i;
 788 }
 789 bfd_window;
 790
 791 extern void bfd_init_window
 792   (bfd_window *);
 793 extern void bfd_free_window
 794   (bfd_window *);
 795 extern bfd_boolean bfd_get_file_window
 796   (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean);
 797
 798 /* XCOFF support routines for the linker.  */
 799
 800 extern bfd_boolean bfd_xcoff_link_record_set
 801   (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type);
 802 extern bfd_boolean bfd_xcoff_import_symbol
 803   (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma,
 804    const char *, const char *, const char *, unsigned int);
 805 extern bfd_boolean bfd_xcoff_export_symbol
 806   (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *);
 807 extern bfd_boolean bfd_xcoff_link_count_reloc
 808   (bfd *, struct bfd_link_info *, const char *);
 809 extern bfd_boolean bfd_xcoff_record_link_assignment
 810   (bfd *, struct bfd_link_info *, const char *);
 811 extern bfd_boolean bfd_xcoff_size_dynamic_sections
 812   (bfd *, struct bfd_link_info *, const char *, const char *,
 813    unsigned long, unsigned long, unsigned long, bfd_boolean,
 814    int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean);
 815 extern bfd_boolean bfd_xcoff_link_generate_rtinit
 816   (bfd *, const char *, const char *, bfd_boolean);
 817
 818 /* XCOFF support routines for ar.  */
 819 extern bfd_boolean bfd_xcoff_ar_archive_set_magic
 820   (bfd *, char *);
 821
 822 /* Externally visible COFF routines.  */
 823
 824 #if defined(__STDC__) || defined(ALMOST_STDC)
 825 struct internal_syment;
 826 union internal_auxent;
 827 #endif
 828
 829 extern bfd_boolean bfd_coff_get_syment
 830   (bfd *, struct bfd_symbol *, struct internal_syment *);
 831
 832 extern bfd_boolean bfd_coff_get_auxent
 833   (bfd *, struct bfd_symbol *, int, union internal_auxent *);
 834
 835 extern bfd_boolean bfd_coff_set_symbol_class
 836   (bfd *, struct bfd_symbol *, unsigned int);
 837
 838 extern bfd_boolean bfd_m68k_coff_create_embedded_relocs
 839   (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **);
 840
 841 /* ARM Interworking support.  Called from linker.  */
 842 extern bfd_boolean bfd_arm_allocate_interworking_sections
 843   (struct bfd_link_info *);
 844
 845 extern bfd_boolean bfd_arm_process_before_allocation
 846   (bfd *, struct bfd_link_info *, int);
 847
 848 extern bfd_boolean bfd_arm_get_bfd_for_interworking
 849   (bfd *, struct bfd_link_info *);
 850
 851 /* PE ARM Interworking support.  Called from linker.  */
 852 extern bfd_boolean bfd_arm_pe_allocate_interworking_sections
 853   (struct bfd_link_info *);
 854
 855 extern bfd_boolean bfd_arm_pe_process_before_allocation
 856   (bfd *, struct bfd_link_info *, int);
 857
 858 extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking
 859   (bfd *, struct bfd_link_info *);
 860
 861 /* ELF ARM Interworking support.  Called from linker.  */
 862 extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections
 863   (struct bfd_link_info *);
 864
 865 extern bfd_boolean bfd_elf32_arm_process_before_allocation
 866   (bfd *, struct bfd_link_info *, int);
 867
 868 void bfd_elf32_arm_set_target_relocs
 869   (struct bfd_link_info *, int, char *, int, int);
 870
 871 extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
 872   (bfd *, struct bfd_link_info *);
 873
 874 extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd
 875   (bfd *, struct bfd_link_info *);
 876
 877 /* ELF ARM mapping symbol support */
 878 #define BFD_ARM_SPECIAL_SYM_TYPE_MAP    (1 << 0)
 879 #define BFD_ARM_SPECIAL_SYM_TYPE_TAG    (1 << 1)
 880 #define BFD_ARM_SPECIAL_SYM_TYPE_OTHER  (1 << 2)
 881 #define BFD_ARM_SPECIAL_SYM_TYPE_ANY    (~0)
 882 extern bfd_boolean bfd_is_arm_special_symbol_name
 883   (const char * name, int type);
 884
 885 /* ARM Note section processing.  */
 886 extern bfd_boolean bfd_arm_merge_machines
 887   (bfd *, bfd *);
 888
 889 extern bfd_boolean bfd_arm_update_notes
 890   (bfd *, const char *);
 891
 892 extern unsigned int bfd_arm_get_mach_from_notes
 893   (bfd *, const char *);
 894
 895 /* TI COFF load page support.  */
 896 extern void bfd_ticoff_set_section_load_page
 897   (struct bfd_section *, int);
 898
 899 extern int bfd_ticoff_get_section_load_page
 900   (struct bfd_section *);
 901
 902 /* H8/300 functions.  */
 903 extern bfd_vma bfd_h8300_pad_address
 904   (bfd *, bfd_vma);
 905
 906 /* IA64 Itanium code generation.  Called from linker.  */
 907 extern void bfd_elf32_ia64_after_parse
 908   (int);
 909
 910 extern void bfd_elf64_ia64_after_parse
 911   (int);
 912
 913 /* This structure is used for a comdat section, as in PE.  A comdat
 914    section is associated with a particular symbol.  When the linker
 915    sees a comdat section, it keeps only one of the sections with a
 916    given name and associated with a given symbol.  */
 917
 918 struct coff_comdat_info
 919 {
 920   /* The name of the symbol associated with a comdat section.  */
 921   const char *name;
 922
 923   /* The local symbol table index of the symbol associated with a
 924      comdat section.  This is only meaningful to the object file format
 925      specific code; it is not an index into the list returned by
 926      bfd_canonicalize_symtab.  */
 927   long symbol;
 928 };
 929
 930 extern struct coff_comdat_info *bfd_coff_get_comdat_section
 931   (bfd *, struct bfd_section *);
 932