bfd/bfd-in.h

   1 /* Main header file for the bfd library -- portable access to object files.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 ** NOTE: bfd.h and bfd-in2.h are GENERATED files.  Don't change them;
   6 ** instead, change bfd-in.h or the other BFD source files processed to
   7 ** generate these files.
   8
   9 This file is part of BFD, the Binary File Descriptor library.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24
  25 /* bfd.h -- The only header file required by users of the bfd library
  26
  27 The bfd.h file is generated from bfd-in.h and various .c files; if you
  28 change it, your changes will probably be lost.
  29
  30 All the prototypes and definitions following the comment "THE FOLLOWING
  31 IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
  32 BFD.  If you change it, someone oneday will extract it from the source
  33 again, and your changes will be lost.  To save yourself from this bind,
  34 change the definitions in the source in the bfd directory.  Type "make
  35 docs" and then "make headers" in that directory, and magically this file
  36 will change to reflect your changes.
  37
  38 If you don't have the tools to perform the extraction, then you are
  39 safe from someone on your system trampling over your header files.
  40 You should still maintain the equivalence between the source and this
  41 file though; every change you make to the .c file should be reflected
  42 here.  */
  43
  44 #ifndef __BFD_H_SEEN__
  45 #define __BFD_H_SEEN__
  46
  47 #include "ansidecl.h"
  48 #include "obstack.h"
  49
  50 /* These two lines get substitutions done by commands in Makefile.in.  */
  51 #define BFD_VERSION   "@VERSION@"
  52 #define BFD_ARCH_SIZE @WORDSIZE@
  53
  54 #if BFD_ARCH_SIZE >= 64
  55 #define BFD64
  56 #endif
  57
  58 #ifndef INLINE
  59 #if __GNUC__ >= 2
  60 #define INLINE __inline__
  61 #else
  62 #define INLINE
  63 #endif
  64 #endif
  65
  66 /* 64-bit type definition (if any) from bfd's sysdep.h goes here */
  67
  68
  69 /* forward declaration */
  70 typedef struct _bfd bfd;
  71
  72 /* To squelch erroneous compiler warnings ("illegal pointer
  73    combination") from the SVR3 compiler, we would like to typedef
  74    boolean to int (it doesn't like functions which return boolean.
  75    Making sure they are never implicitly declared to return int
  76    doesn't seem to help).  But this file is not configured based on
  77    the host.  */
  78 /* General rules: functions which are boolean return true on success
  79    and false on failure (unless they're a predicate).   -- bfd.doc */
  80 /* I'm sure this is going to break something and someone is going to
  81    force me to change it. */
  82 /* typedef enum boolean {false, true} boolean; */
  83 /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h>  -fnf */
  84 /* It gets worse if the host also defines a true/false enum... -sts */
  85 /* And even worse if your compiler has built-in boolean types... -law */
  86 #if defined (__GNUG__) && (__GNUC_MINOR__ > 5)
  87 #define TRUE_FALSE_ALREADY_DEFINED
  88 #endif
  89 #ifndef TRUE_FALSE_ALREADY_DEFINED
  90 typedef enum bfd_boolean {false, true} boolean;
  91 #define BFD_TRUE_FALSE
  92 #else
  93 typedef enum bfd_boolean {bfd_false, bfd_true} boolean;
  94 #endif
  95
  96 /* A pointer to a position in a file.  */
  97 /* FIXME:  This should be using off_t from <sys/types.h>.
  98    For now, try to avoid breaking stuff by not including <sys/types.h> here.
  99    This will break on systems with 64-bit file offsets (e.g. 4.4BSD).
 100    Probably the best long-term answer is to avoid using file_ptr AND off_t
 101    in this header file, and to handle this in the BFD implementation
 102    rather than in its interface.  */
 103 /* typedef off_t        file_ptr; */
 104 typedef long int file_ptr;
 105
 106 /* Support for different sizes of target format ints and addresses.
 107    If the host implements 64-bit values, it defines BFD_HOST_64_BIT to
 108    be the appropriate type.  Otherwise, this code will fall back on
 109    gcc's "long long" type if gcc is being used.  BFD_HOST_64_BIT must
 110    be defined in such a way as to be a valid type name by itself or
 111    with "unsigned" prefixed.  It should be a signed type by itself.
 112
 113    If neither is the case, then compilation will fail if 64-bit
 114    targets are requested.  If you don't request any 64-bit targets,
 115    you should be safe. */
 116
 117 #ifdef  BFD64
 118
 119 #if defined (__GNUC__) && !defined (BFD_HOST_64_BIT)
 120 #define BFD_HOST_64_BIT long long
 121 typedef BFD_HOST_64_BIT int64_type;
 122 typedef unsigned BFD_HOST_64_BIT uint64_type;
 123 #endif
 124
 125 #if !defined (uint64_type) && defined (__GNUC__)
 126 #define uint64_type unsigned long long
 127 #define int64_type long long
 128 #endif
 129 #ifndef uint64_typeLOW
 130 #define uint64_typeLOW(x) ((unsigned long)(((x) & 0xffffffff)))
 131 #define uint64_typeHIGH(x) ((unsigned long)(((x) >> 32) & 0xffffffff))
 132 #endif
 133
 134 typedef unsigned BFD_HOST_64_BIT bfd_vma;
 135 typedef BFD_HOST_64_BIT bfd_signed_vma;
 136 typedef unsigned BFD_HOST_64_BIT bfd_size_type;
 137 typedef unsigned BFD_HOST_64_BIT symvalue;
 138 #ifndef fprintf_vma
 139 #define fprintf_vma(s,x) \
 140                 fprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x))
 141 #define sprintf_vma(s,x) \
 142                 sprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x))
 143 #endif
 144 #else /* not BFD64  */
 145
 146 /* Represent a target address.  Also used as a generic unsigned type
 147    which is guaranteed to be big enough to hold any arithmetic types
 148    we need to deal with.  */
 149 typedef unsigned long bfd_vma;
 150
 151 /* A generic signed type which is guaranteed to be big enough to hold any
 152    arithmetic types we need to deal with.  Can be assumed to be compatible
 153    with bfd_vma in the same way that signed and unsigned ints are compatible
 154    (as parameters, in assignment, etc).  */
 155 typedef long bfd_signed_vma;
 156
 157 typedef unsigned long symvalue;
 158 typedef unsigned long bfd_size_type;
 159
 160 /* Print a bfd_vma x on stream s.  */
 161 #define fprintf_vma(s,x) fprintf(s, "%08lx", x)
 162 #define sprintf_vma(s,x) sprintf(s, "%08lx", x)
 163 #endif /* not BFD64  */
 164 #define printf_vma(x) fprintf_vma(stdout,x)
 165
 166 typedef unsigned int flagword;  /* 32 bits of flags */
 167 typedef unsigned char bfd_byte;
 168 \f
 169 /** File formats */
 170
 171 typedef enum bfd_format {
 172               bfd_unknown = 0,  /* file format is unknown */
 173               bfd_object,       /* linker/assember/compiler output */
 174               bfd_archive,      /* object archive file */
 175               bfd_core,         /* core dump */
 176               bfd_type_end}     /* marks the end; don't use it! */
 177          bfd_format;
 178
 179 /* Values that may appear in the flags field of a BFD.  These also
 180    appear in the object_flags field of the bfd_target structure, where
 181    they indicate the set of flags used by that backend (not all flags
 182    are meaningful for all object file formats) (FIXME: at the moment,
 183    the object_flags values have mostly just been copied from backend
 184    to another, and are not necessarily correct).  */
 185
 186 /* No flags.  */
 187 #define NO_FLAGS        0x00
 188
 189 /* BFD contains relocation entries.  */
 190 #define HAS_RELOC       0x01
 191
 192 /* BFD is directly executable.  */
 193 #define EXEC_P          0x02
 194
 195 /* BFD has line number information (basically used for F_LNNO in a
 196    COFF header).  */
 197 #define HAS_LINENO      0x04
 198
 199 /* BFD has debugging information.  */
 200 #define HAS_DEBUG       0x08
 201
 202 /* BFD has symbols.  */
 203 #define HAS_SYMS        0x10
 204
 205 /* BFD has local symbols (basically used for F_LSYMS in a COFF
 206    header).  */
 207 #define HAS_LOCALS      0x20
 208
 209 /* BFD is a dynamic object.  */
 210 #define DYNAMIC         0x40
 211
 212 /* Text section is write protected (if D_PAGED is not set, this is
 213    like an a.out NMAGIC file) (the linker sets this by default, but
 214    clears it for -r or -N).  */
 215 #define WP_TEXT         0x80
 216
 217 /* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 218    linker sets this by default, but clears it for -r or -n or -N).  */
 219 #define D_PAGED         0x100
 220
 221 /* BFD is relaxable (this means that bfd_relax_section may be able to
 222    do something) (sometimes bfd_relax_section can do something even if
 223    this is not set).  */
 224 #define BFD_IS_RELAXABLE 0x200
 225
 226 /* This may be set before writing out a BFD to request using a
 227    traditional format.  For example, this is used to request that when
 228    writing out an a.out object the symbols not be hashed to eliminate
 229    duplicates.  */
 230 #define BFD_TRADITIONAL_FORMAT 0x400
 231 \f
 232 /* symbols and relocation */
 233
 234 /* A count of carsyms (canonical archive symbols).  */
 235 typedef unsigned long symindex;
 236
 237 /* How to perform a relocation.  */
 238 typedef const struct reloc_howto_struct reloc_howto_type;
 239
 240 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
 241
 242 /* General purpose part of a symbol X;
 243    target specific parts are in libcoff.h, libaout.h, etc.  */
 244
 245 #define bfd_get_section(x) ((x)->section)
 246 #define bfd_get_output_section(x) ((x)->section->output_section)
 247 #define bfd_set_section(x,y) ((x)->section) = (y)
 248 #define bfd_asymbol_base(x) ((x)->section->vma)
 249 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
 250 #define bfd_asymbol_name(x) ((x)->name)
 251 /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
 252 #define bfd_asymbol_bfd(x) ((x)->the_bfd)
 253 #define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
 254
 255 /* A canonical archive symbol.  */
 256 /* This is a type pun with struct ranlib on purpose! */
 257 typedef struct carsym {
 258   char *name;
 259   file_ptr file_offset;         /* look here to find the file */
 260 } carsym;                       /* to make these you call a carsymogen */
 261
 262
 263 /* Used in generating armaps (archive tables of contents).
 264    Perhaps just a forward definition would do? */
 265 struct orl {                    /* output ranlib */
 266   char **name;                  /* symbol name */
 267   file_ptr pos;                 /* bfd* or file position */
 268   int namidx;                   /* index into string table */
 269 };
 270 \f
 271
 272 /* Linenumber stuff */
 273 typedef struct lineno_cache_entry {
 274   unsigned int line_number;     /* Linenumber from start of function*/
 275   union {
 276     struct symbol_cache_entry *sym; /* Function name */
 277     unsigned long offset;       /* Offset into section */
 278   } u;
 279 } alent;
 280 \f
 281 /* object and core file sections */
 282
 283 #define align_power(addr, align)        \
 284         ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
 285
 286 typedef struct sec *sec_ptr;
 287
 288 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
 289 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
 290 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
 291 #define bfd_section_name(bfd, ptr) ((ptr)->name)
 292 #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
 293 #define bfd_section_vma(bfd, ptr) ((ptr)->vma)
 294 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
 295 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
 296 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
 297
 298 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
 299
 300 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = true), true)
 301 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
 302 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
 303
 304 typedef struct stat stat_type;
 305 \f
 306 typedef enum bfd_print_symbol
 307 {
 308   bfd_print_symbol_name,
 309   bfd_print_symbol_more,
 310   bfd_print_symbol_all
 311 } bfd_print_symbol_type;
 312
 313 /* Information about a symbol that nm needs.  */
 314
 315 typedef struct _symbol_info
 316 {
 317   symvalue value;
 318   char type;
 319   CONST char *name;            /* Symbol name.  */
 320   char stab_other;             /* Unused. */
 321   short stab_desc;             /* Info for N_TYPE.  */
 322   CONST char *stab_name;
 323 } symbol_info;
 324 \f
 325 /* Hash table routines.  There is no way to free up a hash table.  */
 326
 327 /* An element in the hash table.  Most uses will actually use a larger
 328    structure, and an instance of this will be the first field.  */
 329
 330 struct bfd_hash_entry
 331 {
 332   /* Next entry for this hash code.  */
 333   struct bfd_hash_entry *next;
 334   /* String being hashed.  */
 335   const char *string;
 336   /* Hash code.  This is the full hash code, not the index into the
 337      table.  */
 338   unsigned long hash;
 339 };
 340
 341 /* A hash table.  */
 342
 343 struct bfd_hash_table
 344 {
 345   /* The hash array.  */
 346   struct bfd_hash_entry **table;
 347   /* The number of slots in the hash table.  */
 348   unsigned int size;
 349   /* A function used to create new elements in the hash table.  The
 350      first entry is itself a pointer to an element.  When this
 351      function is first invoked, this pointer will be NULL.  However,
 352      having the pointer permits a hierarchy of method functions to be
 353      built each of which calls the function in the superclass.  Thus
 354      each function should be written to allocate a new block of memory
 355      only if the argument is NULL.  */
 356   struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 357                                              struct bfd_hash_table *,
 358                                              const char *));
 359   /* An obstack for this hash table.  */
 360   struct obstack memory;
 361 };
 362
 363 /* Initialize a hash table.  */
 364 extern boolean bfd_hash_table_init
 365   PARAMS ((struct bfd_hash_table *,
 366            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 367                                        struct bfd_hash_table *,
 368                                        const char *)));
 369
 370 /* Initialize a hash table specifying a size.  */
 371 extern boolean bfd_hash_table_init_n
 372   PARAMS ((struct bfd_hash_table *,
 373            struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 374                                        struct bfd_hash_table *,
 375                                        const char *),
 376            unsigned int size));
 377
 378 /* Free up a hash table.  */
 379 extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *));
 380
 381 /* Look up a string in a hash table.  If CREATE is true, a new entry
 382    will be created for this string if one does not already exist.  The
 383    COPY argument must be true if this routine should copy the string
 384    into newly allocated memory when adding an entry.  */
 385 extern struct bfd_hash_entry *bfd_hash_lookup
 386   PARAMS ((struct bfd_hash_table *, const char *, boolean create,
 387            boolean copy));
 388
 389 /* Base method for creating a hash table entry.  */
 390 extern struct bfd_hash_entry *bfd_hash_newfunc
 391   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
 392            const char *));
 393
 394 /* Grab some space for a hash table entry.  */
 395 extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *,
 396                                       unsigned int));
 397
 398 /* Traverse a hash table in a random order, calling a function on each
 399    element.  If the function returns false, the traversal stops.  The
 400    INFO argument is passed to the function.  */
 401 extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *,
 402                                        boolean (*) (struct bfd_hash_entry *,
 403                                                     PTR),
 404                                        PTR info));
 405 \f
 406 /* Semi-portable string concatenation in cpp.
 407    The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors.
 408    The problem is, "32_" is not a valid preprocessing token, and we don't
 409    want extra underscores (e.g., "nlm_32_").  The XCAT2 macro will cause the
 410    inner CAT macros to be evaluated first, producing still-valid pp-tokens.
 411    Then the final concatenation can be done.  (Sigh.)  */
 412 #ifndef CAT
 413 #ifdef SABER
 414 #define CAT(a,b)        a##b
 415 #define CAT3(a,b,c)     a##b##c
 416 #define CAT4(a,b,c,d)   a##b##c##d
 417 #else
 418 #if defined(__STDC__) || defined(ALMOST_STDC)
 419 #define CAT(a,b) a##b
 420 #define CAT3(a,b,c) a##b##c
 421 #define XCAT2(a,b)      CAT(a,b)
 422 #define CAT4(a,b,c,d)   XCAT2(CAT(a,b),CAT(c,d))
 423 #else
 424 #define CAT(a,b) a/**/b
 425 #define CAT3(a,b,c) a/**/b/**/c
 426 #define CAT4(a,b,c,d)   a/**/b/**/c/**/d
 427 #endif
 428 #endif
 429 #endif
 430
 431 #define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table
 432 \f
 433 /* User program access to BFD facilities */
 434
 435 /* Direct I/O routines, for programs which know more about the object
 436    file than BFD does.  Use higher level routines if possible.  */
 437
 438 extern bfd_size_type bfd_read
 439   PARAMS ((PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
 440 extern bfd_size_type bfd_write
 441   PARAMS ((const PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
 442 extern int bfd_seek PARAMS ((bfd *abfd, file_ptr fp, int direction));
 443 extern long bfd_tell PARAMS ((bfd *abfd));
 444 extern int bfd_flush PARAMS ((bfd *abfd));
 445 extern int bfd_stat PARAMS ((bfd *abfd, struct stat *));
 446
 447 /* PE STUFF */
 448 /* Also define some types which are used within bfdlink.h for the
 449    bfd_link_info struct.  These are not defined in bfdlink.h for a reason.
 450    When the link_info data is passed to bfd from ld, it is copied into
 451    extern variables defined in internal.h.  The type class for these must
 452    be available to any thing that includes internal.h.  When internal.h is
 453    included, it is always preceeded by an include on this file.  If I leave the
 454    type definitions in bfdlink.h, then I must include that file when ever
 455    I include internal.h, and this is not always a good thing */
 456
 457 /* These are the different types of subsystems to be used when linking for
 458    Windows NT.  This information is passed in as an input parameter (default
 459    is console) and ultimately ends up in the optional header data */
 460 enum bfd_link_subsystem
 461 {
 462   native,    /* image doesn't require a subsystem */
 463   windows,   /* image runs in the Windows GUI subsystem */
 464   console,   /* image runs in the Windows CUI (character) subsystem */
 465   os2,       /* image runs in the OS/2 character subsystem */
 466   posix      /* image runs in the posix character subsystem */
 467 };
 468 /* The NT optional header file allows input of the stack and heap reserve
 469    and commit size.  This data may be input on the command line and will
 470    end up in the optional header.  Default sizes are provided. */
 471 struct _bfd_link_stack_heap
 472 {
 473   boolean stack_defined;
 474   boolean heap_defined;
 475   bfd_vma stack_reserve;
 476   bfd_vma stack_commit;
 477   bfd_vma heap_reserve;
 478   bfd_vma heap_commit;
 479 };
 480 typedef struct _bfd_link_stack_heap bfd_link_stack_heap;
 481
 482 /* END OF PE STUFF */
 483
 484 /* Cast from const char * to char * so that caller can assign to
 485    a char * without a warning.  */
 486 #define bfd_get_filename(abfd) ((char *) (abfd)->filename)
 487 #define bfd_get_cacheable(abfd) ((abfd)->cacheable)
 488 #define bfd_get_format(abfd) ((abfd)->format)
 489 #define bfd_get_target(abfd) ((abfd)->xvec->name)
 490 #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
 491 #define bfd_get_file_flags(abfd) ((abfd)->flags)
 492 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
 493 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
 494 #define bfd_my_archive(abfd) ((abfd)->my_archive)
 495 #define bfd_has_map(abfd) ((abfd)->has_armap)
 496
 497 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
 498 #define bfd_usrdata(abfd) ((abfd)->usrdata)
 499
 500 #define bfd_get_start_address(abfd) ((abfd)->start_address)
 501 #define bfd_get_symcount(abfd) ((abfd)->symcount)
 502 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
 503 #define bfd_count_sections(abfd) ((abfd)->section_count)
 504
 505 #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
 506
 507 #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (bool)), true)
 508
 509 /* Byte swapping routines.  */
 510
 511 bfd_vma         bfd_getb64         PARAMS ((const unsigned char *));
 512 bfd_vma         bfd_getl64         PARAMS ((const unsigned char *));
 513 bfd_signed_vma  bfd_getb_signed_64 PARAMS ((const unsigned char *));
 514 bfd_signed_vma  bfd_getl_signed_64 PARAMS ((const unsigned char *));
 515 bfd_vma         bfd_getb32         PARAMS ((const unsigned char *));
 516 bfd_vma         bfd_getl32         PARAMS ((const unsigned char *));
 517 bfd_signed_vma  bfd_getb_signed_32 PARAMS ((const unsigned char *));
 518 bfd_signed_vma  bfd_getl_signed_32 PARAMS ((const unsigned char *));
 519 bfd_vma         bfd_getb16         PARAMS ((const unsigned char *));
 520 bfd_vma         bfd_getl16         PARAMS ((const unsigned char *));
 521 bfd_signed_vma  bfd_getb_signed_16 PARAMS ((const unsigned char *));
 522 bfd_signed_vma  bfd_getl_signed_16 PARAMS ((const unsigned char *));
 523 void            bfd_putb64         PARAMS ((bfd_vma, unsigned char *));
 524 void            bfd_putl64         PARAMS ((bfd_vma, unsigned char *));
 525 void            bfd_putb32         PARAMS ((bfd_vma, unsigned char *));
 526 void            bfd_putl32         PARAMS ((bfd_vma, unsigned char *));
 527 void            bfd_putb16         PARAMS ((bfd_vma, unsigned char *));
 528 void            bfd_putl16         PARAMS ((bfd_vma, unsigned char *));
 529 \f
 530 /* Externally visible ECOFF routines.  */
 531
 532 #if defined(__STDC__) || defined(ALMOST_STDC)
 533 struct ecoff_debug_info;
 534 struct ecoff_debug_swap;
 535 struct ecoff_extr;
 536 struct symbol_cache_entry;
 537 struct bfd_link_info;
 538 #endif
 539 extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd));
 540 extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value));
 541 extern boolean bfd_ecoff_set_regmasks
 542   PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask,
 543            unsigned long *cprmask));
 544 extern PTR bfd_ecoff_debug_init
 545   PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug,
 546            const struct ecoff_debug_swap *output_swap,
 547            struct bfd_link_info *));
 548 extern void bfd_ecoff_debug_free
 549   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 550            const struct ecoff_debug_swap *output_swap,
 551            struct bfd_link_info *));
 552 extern boolean bfd_ecoff_debug_accumulate
 553   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 554            const struct ecoff_debug_swap *output_swap,
 555            bfd *input_bfd, struct ecoff_debug_info *input_debug,
 556            const struct ecoff_debug_swap *input_swap,
 557            struct bfd_link_info *));
 558 extern boolean bfd_ecoff_debug_accumulate_other
 559   PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
 560            const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
 561            struct bfd_link_info *));
 562 extern boolean bfd_ecoff_debug_externals
 563   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 564            const struct ecoff_debug_swap *swap,
 565            boolean relocateable,
 566            boolean (*get_extr) (struct symbol_cache_entry *,
 567                                 struct ecoff_extr *),
 568            void (*set_index) (struct symbol_cache_entry *,
 569                               bfd_size_type)));
 570 extern boolean bfd_ecoff_debug_one_external
 571   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 572            const struct ecoff_debug_swap *swap,
 573            const char *name, struct ecoff_extr *esym));
 574 extern bfd_size_type bfd_ecoff_debug_size
 575   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 576            const struct ecoff_debug_swap *swap));
 577 extern boolean bfd_ecoff_write_debug
 578   PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
 579            const struct ecoff_debug_swap *swap, file_ptr where));
 580 extern boolean bfd_ecoff_write_accumulated_debug
 581   PARAMS ((PTR handle, bfd *abfd, struct ecoff_debug_info *debug,
 582            const struct ecoff_debug_swap *swap,
 583            struct bfd_link_info *info, file_ptr where));
 584 extern boolean bfd_mips_ecoff_create_embedded_relocs
 585   PARAMS ((bfd *, struct bfd_link_info *, struct sec *, struct sec *,
 586            char **));
 587
 588 /* Externally visible ELF routines.  */
 589
 590 extern boolean bfd_elf32_record_link_assignment
 591   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 592 extern boolean bfd_elf64_record_link_assignment
 593   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 594 extern boolean bfd_elf32_size_dynamic_sections
 595   PARAMS ((bfd *, const char *, const char *, boolean,
 596            struct bfd_link_info *, struct sec **));
 597 extern boolean bfd_elf64_size_dynamic_sections
 598   PARAMS ((bfd *, const char *, const char *, boolean,
 599            struct bfd_link_info *, struct sec **));
 600 extern void bfd_elf_set_dt_needed_name PARAMS ((bfd *, const char *));
 601
 602 /* SunOS shared library support routines for the linker.  */
 603
 604 extern boolean bfd_sunos_record_link_assignment
 605   PARAMS ((bfd *, struct bfd_link_info *, const char *));
 606 extern boolean bfd_sunos_size_dynamic_sections
 607   PARAMS ((bfd *, struct bfd_link_info *, struct sec **, struct sec **,
 608            struct sec **));
 609
 610 /* Linux shared library support routines for the linker.  */
 611
 612 extern boolean bfd_linux_size_dynamic_sections
 613   PARAMS ((bfd *, struct bfd_link_info *));
 614
 615 /* And more from the source.  */
 616
 617 /* provide storage for subsystem, stack and heap data which may have been
 618    passed in on the command line.  Ld puts this data into a bfd_link_info
 619    struct which ultimately gets passed in to the bfd.  When it arrives, copy
 620    it to the following struct so that the data will be available in coffcode.h
 621    where it is needed.  The typedef's used are defined in bfd.h */
 622 enum   bfd_link_subsystem  NT_subsystem;
 623 bfd_link_stack_heap NT_stack_heap;