include/bfd.h

   1 /* A -*- C -*- header file for the bfd library
   2    Copyright 1990, 1991 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* bfd.h -- The only header file required by users of the bfd library
  22
  23 This file is generated from various .c files, if you change it, your
  24 bits may be lost.
  25
  26 All the prototypes and definitions following the comment "THE FOLLOWING
  27 IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
  28 BFD.  If you change it, someone oneday will extract it from the source
  29 again, and your changes will be lost.  To save yourself from this bind,
  30 change the definitions in the source in the bfd directory.  Type "make
  31 docs" and then "make headers" in that directory, and magically this file
  32 will change to reflect your changes.
  33
  34 If you don't have the tools to perform the extraction, then you are
  35 safe from someone on your system trampling over your header files.
  36 You should still maintain the equivalence between the source and this
  37 file though; every change you make to the .c file should be reflected
  38 here.  */
  39
  40 #ifndef __BFD_H_SEEN__
  41 #define __BFD_H_SEEN__
  42
  43 #include "ansidecl.h"
  44 #include "obstack.h"
  45
  46 /* Make it easier to declare prototypes (puts conditional here) */
  47 #ifndef PROTO
  48 #       if __STDC__
  49 #               define PROTO(type, name, arglist) type name arglist
  50 #       else
  51 #               define PROTO(type, name, arglist) type name ()
  52 #       endif
  53 #endif
  54
  55 #define BFD_VERSION "1.97"
  56
  57 /* forward declaration */
  58 typedef struct _bfd bfd;
  59
  60 /* General rules: functions which are boolean return true on success
  61    and false on failure (unless they're a predicate).   -- bfd.doc */
  62 /* I'm sure this is going to break something and someone is going to
  63    force me to change it. */
  64 /* typedef enum boolean {false, true} boolean; */
  65 /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h>  -fnf */
  66 typedef enum bfd_boolean {false, true} boolean;
  67
  68 /* Try to avoid breaking stuff */
  69 typedef  long int file_ptr;
  70
  71 /* Support for different sizes of target format ints and addresses */
  72
  73 #ifdef  HOST_64_BIT
  74 typedef HOST_64_BIT rawdata_offset;
  75 typedef HOST_64_BIT bfd_vma;
  76 typedef HOST_64_BIT bfd_word;
  77 typedef HOST_64_BIT bfd_offset;
  78 typedef HOST_64_BIT bfd_size_type;
  79 typedef HOST_64_BIT symvalue;
  80 typedef HOST_64_BIT bfd_64_type;
  81 #define fprintf_vma(s,x) \
  82                 fprintf(s,"%08x%08x", uint64_typeHIGH(x), uint64_typeLOW(x))
  83 #else
  84 typedef struct {int a,b;} bfd_64_type;
  85 typedef unsigned long rawdata_offset;
  86 typedef unsigned long bfd_vma;
  87 typedef unsigned long bfd_offset;
  88 typedef unsigned long bfd_word;
  89 typedef unsigned long bfd_size;
  90 typedef unsigned long symvalue;
  91 typedef unsigned long bfd_size_type;
  92 #define fprintf_vma(s,x) fprintf(s, "%08lx", x)
  93 #endif
  94 #define printf_vma(x) fprintf_vma(stdout,x)
  95
  96 typedef unsigned int flagword;  /* 32 bits of flags */
  97 \f
  98 /** File formats */
  99
 100 typedef enum bfd_format {
 101               bfd_unknown = 0,  /* file format is unknown */
 102               bfd_object,       /* linker/assember/compiler output */
 103               bfd_archive,      /* object archive file */
 104               bfd_core,         /* core dump */
 105               bfd_type_end}     /* marks the end; don't use it! */
 106          bfd_format;
 107
 108 /* Object file flag values */
 109 #define NO_FLAGS    0
 110 #define HAS_RELOC   001
 111 #define EXEC_P      002
 112 #define HAS_LINENO  004
 113 #define HAS_DEBUG   010
 114 #define HAS_SYMS    020
 115 #define HAS_LOCALS  040
 116 #define DYNAMIC     0100
 117 #define WP_TEXT     0200
 118 #define D_PAGED     0400
 119
 120 \f
 121 /* symbols and relocation */
 122
 123 typedef unsigned long symindex;
 124
 125 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
 126
 127 typedef enum bfd_symclass {
 128               bfd_symclass_unknown = 0,
 129               bfd_symclass_fcommon, /* fortran common symbols */
 130               bfd_symclass_global, /* global symbol, what a surprise */
 131               bfd_symclass_debugger, /* some debugger symbol */
 132               bfd_symclass_undefined /* none known */
 133             } symclass;
 134
 135
 136 typedef int symtype;            /* Who knows, yet? */
 137
 138
 139 /* general purpose part of a symbol;
 140    target specific parts will be found in libcoff.h, liba.out.h etc */
 141
 142
 143 #define bfd_get_section(x) ((x)->section)
 144 #define bfd_get_output_section(x) ((x)->section->output_section)
 145 #define bfd_set_section(x,y) ((x)->section) = (y)
 146 #define bfd_asymbol_base(x) ((x)->section?((x)->section->vma):0)
 147 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + x->value)
 148 #define bfd_asymbol_name(x) ((x)->name)
 149
 150 /* This is a type pun with struct ranlib on purpose! */
 151 typedef struct carsym {
 152   char *name;
 153   file_ptr file_offset;         /* look here to find the file */
 154 } carsym;                       /* to make these you call a carsymogen */
 155
 156
 157 /* Used in generating armaps.  Perhaps just a forward definition would do? */
 158 struct orl {                    /* output ranlib */
 159   char **name;                  /* symbol name */
 160   file_ptr pos;                 /* bfd* or file position */
 161   int namidx;                   /* index into string table */
 162 };
 163
 164 \f
 165
 166 /* Linenumber stuff */
 167 typedef struct lineno_cache_entry {
 168   unsigned int line_number;     /* Linenumber from start of function*/
 169   union {
 170  struct symbol_cache_entry *sym;                /* Function name */
 171     unsigned long offset;       /* Offset into section */
 172   } u;
 173 } alent;
 174 \f
 175 /* object and core file sections */
 176
 177
 178 #define align_power(addr, align)        \
 179         ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
 180
 181 typedef struct sec *sec_ptr;
 182
 183 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
 184 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
 185 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
 186 #define bfd_section_name(bfd, ptr) ((ptr)->name)
 187 #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
 188 #define bfd_section_vma(bfd, ptr) ((ptr)->vma)
 189 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
 190 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
 191 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
 192
 193 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (val)), ((ptr)->user_set_vma = true), true)
 194 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
 195 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
 196
 197 typedef struct stat stat_type;
 198 \f
 199 /** Error handling */
 200
 201 typedef enum bfd_error {
 202               no_error = 0, system_call_error, invalid_target,
 203               wrong_format, invalid_operation, no_memory,
 204               no_symbols, no_relocation_info,
 205               no_more_archived_files, malformed_archive,
 206               symbol_not_found, file_not_recognized,
 207               file_ambiguously_recognized, no_contents,
 208               bfd_error_nonrepresentable_section,
 209               no_debug_section, bad_value,
 210               invalid_error_code} bfd_ec;
 211
 212 extern bfd_ec bfd_error;
 213 struct reloc_cache_entry;
 214 struct bfd_seclet_struct ;
 215
 216
 217 typedef struct bfd_error_vector {
 218   PROTO(void,(* nonrepresentable_section ),(CONST bfd  *CONST abfd,
 219                                             CONST char *CONST name));
 220   PROTO(void,(* undefined_symbol),(CONST struct reloc_cache_entry *rel,
 221                                    CONST struct bfd_seclet_struct *sec
 222                                    ));
 223   PROTO(void, (* reloc_value_truncated),(CONST struct
 224                                           reloc_cache_entry *rel,
 225                                           struct bfd_seclet_struct *sec));
 226
 227   PROTO(void, (* reloc_dangerous),(CONST struct reloc_cache_entry *rel,
 228                                    CONST struct bfd_seclet_struct *sec));
 229
 230 } bfd_error_vector_type;
 231
 232 PROTO (CONST char *, bfd_errmsg, (bfd_ec error_tag));
 233 PROTO (void, bfd_perror, (CONST char *message));
 234 \f
 235
 236 typedef enum bfd_print_symbol
 237 {
 238   bfd_print_symbol_name,
 239   bfd_print_symbol_more,
 240   bfd_print_symbol_all,
 241   bfd_print_symbol_nm   /* Pretty format suitable for nm program. */
 242 } bfd_print_symbol_type;
 243
 244 \f
 245 \f
 246 /* The code that implements targets can initialize a jump table with this
 247    macro.  It must name all its routines the same way (a prefix plus
 248    the standard routine suffix), or it must #define the routines that
 249    are not so named, before calling JUMP_TABLE in the initializer.  */
 250
 251 /* Semi-portable string concatenation in cpp */
 252 #ifndef CAT
 253 #ifdef __STDC__
 254 #define CAT(a,b) a##b
 255 #else
 256 #define CAT(a,b) a/**/b
 257 #endif
 258 #endif
 259
 260 #define JUMP_TABLE(NAME)\
 261 CAT(NAME,_core_file_failing_command),\
 262 CAT(NAME,_core_file_failing_signal),\
 263 CAT(NAME,_core_file_matches_executable_p),\
 264 CAT(NAME,_slurp_armap),\
 265 CAT(NAME,_slurp_extended_name_table),\
 266 CAT(NAME,_truncate_arname),\
 267 CAT(NAME,_write_armap),\
 268 CAT(NAME,_close_and_cleanup),   \
 269 CAT(NAME,_set_section_contents),\
 270 CAT(NAME,_get_section_contents),\
 271 CAT(NAME,_new_section_hook),\
 272 CAT(NAME,_get_symtab_upper_bound),\
 273 CAT(NAME,_get_symtab),\
 274 CAT(NAME,_get_reloc_upper_bound),\
 275 CAT(NAME,_canonicalize_reloc),\
 276 CAT(NAME,_make_empty_symbol),\
 277 CAT(NAME,_print_symbol),\
 278 CAT(NAME,_get_lineno),\
 279 CAT(NAME,_set_arch_mach),\
 280 CAT(NAME,_openr_next_archived_file),\
 281 CAT(NAME,_find_nearest_line),\
 282 CAT(NAME,_generic_stat_arch_elt),\
 283 CAT(NAME,_sizeof_headers),\
 284 CAT(NAME,_bfd_debug_info_start),\
 285 CAT(NAME,_bfd_debug_info_end),\
 286 CAT(NAME,_bfd_debug_info_accumulate),\
 287 CAT(NAME,_bfd_get_relocated_section_contents),\
 288 CAT(NAME,_bfd_relax_section)
 289
 290 #define COFF_SWAP_TABLE \
 291  coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in, \
 292  coff_swap_aux_out, coff_swap_sym_out, \
 293  coff_swap_lineno_out, coff_swap_reloc_out, \
 294  coff_swap_filehdr_out, coff_swap_aouthdr_out, \
 295  coff_swap_scnhdr_out
 296
 297
 298 \f
 299 /* User program access to BFD facilities */
 300
 301 extern CONST short _bfd_host_big_endian;
 302 #define HOST_BYTE_ORDER_BIG_P   (*(char *)&_bfd_host_big_endian)
 303
 304 /* The bfd itself */
 305
 306 /* Cast from const char * to char * so that caller can assign to
 307    a char * without a warning.  */
 308 #define bfd_get_filename(abfd) ((char *) (abfd)->filename)
 309 #define bfd_get_format(abfd) ((abfd)->format)
 310 #define bfd_get_target(abfd) ((abfd)->xvec->name)
 311 #define bfd_get_file_flags(abfd) ((abfd)->flags)
 312 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
 313 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
 314 #define bfd_my_archive(abfd) ((abfd)->my_archive)
 315 #define bfd_has_map(abfd) ((abfd)->has_armap)
 316 #define bfd_header_twiddle_required(abfd) \
 317         ((((abfd)->xvec->header_byteorder_big_p)                \
 318           != (boolean)HOST_BYTE_ORDER_BIG_P) ? true:false)
 319
 320 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
 321 #define bfd_usrdata(abfd) ((abfd)->usrdata)
 322
 323 #define bfd_get_start_address(abfd) ((abfd)->start_address)
 324 #define bfd_get_symcount(abfd) ((abfd)->symcount)
 325 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
 326 #define bfd_count_sections(abfd) ((abfd)->section_count)
 327 #define bfd_get_architecture(abfd) ((abfd)->obj_arch)
 328 #define bfd_get_machine(abfd) ((abfd)->obj_machine)
 329
 330
 331
 332 #define BYTE_SIZE 1
 333 #define SHORT_SIZE 2
 334 #define LONG_SIZE 4
 335
 336 /* And more from the source.  */
 337 void EXFUN(bfd_init, (void));
 338 bfd *EXFUN(bfd_openr, (CONST char *filename, CONST char*target));
 339 bfd *EXFUN(bfd_fdopenr, (CONST char *filename, CONST char *target, int fd));
 340 bfd *EXFUN(bfd_openw, (CONST char *filename, CONST char *target));
 341 boolean EXFUN(bfd_close, (bfd *));
 342 boolean EXFUN(bfd_close_all_done, (bfd *));
 343 bfd_size_type EXFUN(bfd_alloc_size, (bfd *abfd));
 344 bfd *EXFUN(bfd_create, (CONST char *filename, bfd *template));
 345 #define bfd_put_8(abfd, val, ptr) \
 346                 (*((char *)ptr) = (char)val)
 347 #define bfd_get_8(abfd, ptr) \
 348                 (*((char *)ptr))
 349 #define bfd_put_16(abfd, val, ptr) \
 350                 BFD_SEND(abfd, bfd_putx16, (val,ptr))
 351 #define bfd_get_16(abfd, ptr) \
 352                 BFD_SEND(abfd, bfd_getx16, (ptr))
 353 #define bfd_put_32(abfd, val, ptr) \
 354                 BFD_SEND(abfd, bfd_putx32, (val,ptr))
 355 #define bfd_get_32(abfd, ptr) \
 356                 BFD_SEND(abfd, bfd_getx32, (ptr))
 357 #define bfd_put_64(abfd, val, ptr) \
 358                 BFD_SEND(abfd, bfd_putx64, (val, ptr))
 359 #define bfd_get_64(abfd, ptr) \
 360                 BFD_SEND(abfd, bfd_getx64, (ptr))
 361 #define bfd_h_put_8(abfd, val, ptr) \
 362                 (*((char *)ptr) = (char)val)
 363 #define bfd_h_get_8(abfd, ptr) \
 364                 (*((char *)ptr))
 365 #define bfd_h_put_16(abfd, val, ptr) \
 366                 BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
 367 #define bfd_h_get_16(abfd, ptr) \
 368                 BFD_SEND(abfd, bfd_h_getx16,(ptr))
 369 #define bfd_h_put_32(abfd, val, ptr) \
 370                 BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
 371 #define bfd_h_get_32(abfd, ptr) \
 372                 BFD_SEND(abfd, bfd_h_getx32,(ptr))
 373 #define bfd_h_put_64(abfd, val, ptr) \
 374                 BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
 375 #define bfd_h_get_64(abfd, ptr) \
 376                 BFD_SEND(abfd, bfd_h_getx64,(ptr))
 377 typedef struct sec
 378 {
 379          /* The name of the section, the name isn't a copy, the pointer is
 380         the same as that passed to bfd_make_section. */
 381
 382     CONST char *name;
 383
 384
 385          /* Which section is it 0.nth      */
 386
 387    int index;
 388
 389          /* The next section in the list belonging to the BFD, or NULL. */
 390
 391     struct sec *next;
 392
 393          /* The field flags contains attributes of the section. Some of
 394            flags are read in from the object file, and some are
 395            synthesized from other information.  */
 396
 397     flagword flags;
 398
 399 #define SEC_NO_FLAGS   0x000
 400
 401          /* Tells the OS to allocate space for this section when loaded.
 402            This would clear for a section containing debug information
 403            only. */
 404
 405
 406 #define SEC_ALLOC      0x001
 407          /* Tells the OS to load the section from the file when loading.
 408            This would be clear for a .bss section */
 409
 410 #define SEC_LOAD       0x002
 411          /* The section contains data still to be relocated, so there will
 412            be some relocation information too. */
 413
 414 #define SEC_RELOC      0x004
 415
 416          /* Obsolete ? */
 417
 418 #define SEC_BALIGN     0x008
 419
 420          /* A signal to the OS that the section contains read only
 421           data. */
 422 #define SEC_READONLY   0x010
 423
 424          /* The section contains code only. */
 425
 426 #define SEC_CODE       0x020
 427
 428          /* The section contains data only. */
 429
 430 #define SEC_DATA        0x040
 431
 432          /* The section will reside in ROM. */
 433
 434 #define SEC_ROM        0x080
 435
 436          /* The section contains constructor information. This section
 437            type is used by the linker to create lists of constructors and
 438            destructors used by <<g++>>. When a back end sees a symbol
 439            which should be used in a constructor list, it creates a new
 440            section for the type of name (eg <<__CTOR_LIST__>>), attaches
 441            the symbol to it and builds a relocation. To build the lists
 442            of constructors, all the linker has to to is catenate all the
 443            sections called <<__CTOR_LIST__>> and relocte the data
 444            contained within - exactly the operations it would peform on
 445            standard data. */
 446
 447 #define SEC_CONSTRUCTOR 0x100
 448
 449          /* The section is a constuctor, and should be placed at the
 450           end of the . */
 451
 452
 453 #define SEC_CONSTRUCTOR_TEXT 0x1100
 454
 455 #define SEC_CONSTRUCTOR_DATA 0x2100
 456
 457 #define SEC_CONSTRUCTOR_BSS  0x3100
 458
 459
 460          /* The section has contents - a bss section could be
 461            <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>, a debug section could be
 462            <<SEC_HAS_CONTENTS>> */
 463
 464 #define SEC_HAS_CONTENTS 0x200
 465
 466          /* An instruction to the linker not to output sections
 467           containing this flag even if they have information which
 468           would normally be written. */
 469
 470 #define SEC_NEVER_LOAD 0x400
 471
 472
 473
 474    bfd_vma vma;
 475    boolean user_set_vma;
 476
 477          /* The size of the section in bytes, as it will be output.
 478            contains a value even if the section has no contents (eg, the
 479            size of <<.bss>>). This will be filled in after relocation */
 480
 481    bfd_size_type _cooked_size;
 482
 483          /* The size on disk of the section in bytes originally.  Normally this
 484             value is the same as the size, but if some relaxing has
 485             been done, then this value will be bigger.  */
 486
 487    bfd_size_type _raw_size;
 488
 489          /* If this section is going to be output, then this value is the
 490            offset into the output section of the first byte in the input
 491            section. Eg, if this was going to start at the 100th byte in
 492            the output section, this value would be 100. */
 493
 494    bfd_vma output_offset;
 495
 496          /* The output section through which to map on output. */
 497
 498    struct sec *output_section;
 499
 500          /* The alignment requirement of the section, as an exponent - eg
 501            3 aligns to 2^3 (or 8) */
 502
 503    unsigned int alignment_power;
 504
 505          /* If an input section, a pointer to a vector of relocation
 506            records for the data in this section. */
 507
 508    struct reloc_cache_entry *relocation;
 509
 510          /* If an output section, a pointer to a vector of pointers to
 511            relocation records for the data in this section. */
 512
 513    struct reloc_cache_entry **orelocation;
 514
 515          /* The number of relocation records in one of the above  */
 516
 517    unsigned reloc_count;
 518
 519          /* Information below is back end specific - and not always used
 520            or updated
 521
 522            File position of section data    */
 523
 524    file_ptr filepos;
 525
 526          /* File position of relocation info */
 527
 528    file_ptr rel_filepos;
 529
 530          /* File position of line data       */
 531
 532    file_ptr line_filepos;
 533
 534          /* Pointer to data for applications */
 535
 536    PTR userdata;
 537
 538    struct lang_output_section *otheruserdata;
 539
 540          /* Attached line number information */
 541
 542    alent *lineno;
 543
 544          /* Number of line number records   */
 545
 546    unsigned int lineno_count;
 547
 548          /* When a section is being output, this value changes as more
 549            linenumbers are written out */
 550
 551    file_ptr moving_line_filepos;
 552
 553          /* what the section number is in the target world  */
 554
 555    int target_index;
 556
 557    PTR used_by_bfd;
 558
 559          /* If this is a constructor section then here is a list of the
 560            relocations created to relocate items within it. */
 561
 562    struct relent_chain *constructor_chain;
 563
 564          /* The BFD which owns the section. */
 565
 566    bfd *owner;
 567
 568    boolean reloc_done;
 569           /* A symbol which points at this section only */
 570    struct symbol_cache_entry *symbol;
 571    struct symbol_cache_entry **symbol_ptr_ptr;
 572    struct bfd_seclet_struct *seclets_head;
 573    struct bfd_seclet_struct *seclets_tail;
 574 } asection ;
 575
 576
 577 #define BFD_ABS_SECTION_NAME "*ABS*"
 578 #define BFD_UND_SECTION_NAME "*UND*"
 579 #define BFD_COM_SECTION_NAME "*COM*"
 580
 581      /* the absolute section */
 582  extern   asection bfd_abs_section;
 583      /* Pointer to the undefined section */
 584  extern   asection bfd_und_section;
 585      /* Pointer to the common section */
 586  extern asection bfd_com_section;
 587
 588  extern struct symbol_cache_entry *bfd_abs_symbol;
 589  extern struct symbol_cache_entry *bfd_com_symbol;
 590  extern struct symbol_cache_entry *bfd_und_symbol;
 591 #define bfd_get_section_size_before_reloc(section) \
 592      (section->reloc_done ? (abort(),1): (section)->_raw_size)
 593 #define bfd_get_section_size_after_reloc(section) \
 594      ((section->reloc_done) ? (section)->_cooked_size: (abort(),1))
 595 asection *EXFUN(bfd_get_section_by_name, (bfd *abfd, CONST char *name));
 596 asection *EXFUN(bfd_make_section_old_way, (bfd *, CONST char *name));
 597 asection * EXFUN(bfd_make_section, (bfd *, CONST char *name));
 598 boolean EXFUN(bfd_set_section_flags, (bfd *, asection *, flagword));
 599 void EXFUN(bfd_map_over_sections, (bfd *abfd,
 600     void (*func)(bfd *abfd,
 601     asection *sect,
 602     PTR obj),
 603     PTR obj));
 604 boolean EXFUN(bfd_set_section_size, (bfd *, asection *, bfd_size_type val));
 605 boolean EXFUN(bfd_set_section_contents
 606     , (bfd *abfd,
 607     asection *section,
 608     PTR data,
 609     file_ptr offset,
 610     bfd_size_type count));
 611 boolean EXFUN(bfd_get_section_contents
 612     , (bfd *abfd, asection *section, PTR location,
 613     file_ptr offset, bfd_size_type count));
 614 enum bfd_architecture
 615 {
 616   bfd_arch_unknown,    /* File arch not known */
 617   bfd_arch_obscure,    /* Arch known, not one of these */
 618   bfd_arch_m68k,       /* Motorola 68xxx */
 619   bfd_arch_vax,        /* DEC Vax */
 620   bfd_arch_i960,       /* Intel 960 */
 621      /* The order of the following is important.
 622        lower number indicates a machine type that
 623        only accepts a subset of the instructions
 624        available to machines with higher numbers.
 625        The exception is the "ca", which is
 626        incompatible with all other machines except
 627        "core". */
 628
 629 #define bfd_mach_i960_core      1
 630 #define bfd_mach_i960_ka_sa     2
 631 #define bfd_mach_i960_kb_sb     3
 632 #define bfd_mach_i960_mc        4
 633 #define bfd_mach_i960_xa        5
 634 #define bfd_mach_i960_ca        6
 635
 636   bfd_arch_a29k,       /* AMD 29000 */
 637   bfd_arch_sparc,      /* SPARC */
 638   bfd_arch_mips,       /* MIPS Rxxxx */
 639   bfd_arch_i386,       /* Intel 386 */
 640   bfd_arch_ns32k,      /* National Semiconductor 32xxx */
 641   bfd_arch_tahoe,      /* CCI/Harris Tahoe */
 642   bfd_arch_i860,       /* Intel 860 */
 643   bfd_arch_romp,       /* IBM ROMP PC/RT */
 644   bfd_arch_alliant,    /* Alliant */
 645   bfd_arch_convex,     /* Convex */
 646   bfd_arch_m88k,       /* Motorola 88xxx */
 647   bfd_arch_pyramid,    /* Pyramid Technology */
 648   bfd_arch_h8300,      /* Hitachi H8/300 */
 649   bfd_arch_rs6000,     /* IBM RS/6000 */
 650   bfd_arch_hppa,       /* HP PA RISC */
 651   bfd_arch_last
 652   };
 653
 654 typedef struct bfd_arch_info
 655 {
 656   int bits_per_word;
 657   int bits_per_address;
 658   int bits_per_byte;
 659   enum bfd_architecture arch;
 660   long mach;
 661   char *arch_name;
 662   CONST  char *printable_name;
 663   unsigned int section_align_power;
 664   /* true if this is the default machine for the architecture */
 665   boolean the_default;
 666   CONST struct bfd_arch_info * EXFUN((*compatible),
 667         (CONST struct bfd_arch_info *a,
 668          CONST struct bfd_arch_info *b));
 669
 670   boolean EXFUN((*scan),(CONST struct bfd_arch_info *,CONST char *));
 671   unsigned int EXFUN((*disassemble),(bfd_vma addr, CONST char *data,
 672                                      PTR stream));
 673
 674   unsigned int segment_size;
 675   unsigned int page_size;
 676
 677   struct bfd_arch_info *next;
 678 } bfd_arch_info_type;
 679 CONST char *EXFUN(bfd_printable_name, (bfd *abfd));
 680 bfd_arch_info_type *EXFUN(bfd_scan_arch, (CONST char *));
 681 CONST bfd_arch_info_type *EXFUN(bfd_arch_get_compatible, (
 682     CONST bfd *abfd,
 683     CONST bfd *bbfd));
 684 void EXFUN(bfd_set_arch_info, (bfd *, bfd_arch_info_type *));
 685 enum bfd_architecture EXFUN(bfd_get_arch, (bfd *abfd));
 686 unsigned long EXFUN(bfd_get_mach, (bfd *abfd));
 687 unsigned int EXFUN(bfd_arch_bits_per_byte, (bfd *abfd));
 688 unsigned int EXFUN(bfd_arch_bits_per_address, (bfd *abfd));
 689 bfd_arch_info_type * EXFUN(bfd_get_arch_info, (bfd *));
 690 bfd_arch_info_type *EXFUN(bfd_lookup_arch
 691     , (enum bfd_architecture
 692     arch,
 693     long machine));
 694 CONST char * EXFUN(bfd_printable_arch_mach
 695     , (enum bfd_architecture arch, unsigned long machine));
 696 typedef enum bfd_reloc_status
 697 {
 698         /* No errors detected */
 699   bfd_reloc_ok,
 700
 701         /* The relocation was performed, but there was an overflow. */
 702   bfd_reloc_overflow,
 703
 704         /* The address to relocate was not within the section supplied*/
 705   bfd_reloc_outofrange,
 706
 707         /* Used by special functions */
 708   bfd_reloc_continue,
 709
 710         /* Unused */
 711   bfd_reloc_notsupported,
 712
 713         /* Unsupported relocation size requested.  */
 714   bfd_reloc_other,
 715
 716         /* The symbol to relocate against was undefined.*/
 717   bfd_reloc_undefined,
 718
 719         /* The relocation was performed, but may not be ok - presently
 720           generated only when linking i960 coff files with i960 b.out
 721           symbols. */
 722   bfd_reloc_dangerous
 723  }
 724  bfd_reloc_status_type;
 725
 726
 727 typedef struct reloc_cache_entry
 728 {
 729         /* A pointer into the canonical table of pointers  */
 730   struct symbol_cache_entry **sym_ptr_ptr;
 731
 732         /* offset in section */
 733   rawdata_offset address;
 734
 735         /* addend for relocation value */
 736   bfd_vma addend;
 737
 738         /* Pointer to how to perform the required relocation */
 739   CONST struct reloc_howto_struct *howto;
 740
 741 } arelent;
 742
 743 typedef CONST struct reloc_howto_struct
 744 {
 745         /*  The type field has mainly a documetary use - the back end can
 746            to what it wants with it, though the normally the back end's
 747            external idea of what a reloc number would be would be stored
 748            in this field. For example, the a PC relative word relocation
 749            in a coff environment would have the type 023 - because that's
 750            what the outside world calls a R_PCRWORD reloc. */
 751   unsigned int type;
 752
 753         /*  The value the final relocation is shifted right by. This drops
 754            unwanted data from the relocation.  */
 755   unsigned int rightshift;
 756
 757         /*  The size of the item to be relocated - 0, is one byte, 1 is 2
 758            bytes, 3 is four bytes. */
 759   unsigned int size;
 760
 761         /*  Now obsolete */
 762   unsigned int bitsize;
 763
 764         /*  Notes that the relocation is relative to the location in the
 765            data section of the addend. The relocation function will
 766            subtract from the relocation value the address of the location
 767            being relocated. */
 768   boolean pc_relative;
 769
 770         /*  Now obsolete */
 771   unsigned int bitpos;
 772
 773         /*  Now obsolete */
 774   boolean absolute;
 775
 776         /* Causes the relocation routine to return an error if overflow
 777           is detected when relocating. */
 778   boolean complain_on_overflow;
 779
 780         /* If this field is non null, then the supplied function is
 781           called rather than the normal function. This allows really
 782           strange relocation methods to be accomodated (eg, i960 callj
 783           instructions). */
 784   bfd_reloc_status_type EXFUN ((*special_function),
 785                                             (bfd *abfd,
 786                                              arelent *reloc_entry,
 787                                             struct symbol_cache_entry *symbol,
 788                                             PTR data,
 789                                             asection *input_section,
 790                                             bfd *output_bfd     ));
 791
 792         /* The textual name of the relocation type. */
 793   char *name;
 794
 795         /* When performing a partial link, some formats must modify the
 796           relocations rather than the data - this flag signals this.*/
 797   boolean partial_inplace;
 798
 799         /* The src_mask is used to select what parts of the read in data
 800           are to be used in the relocation sum. Eg, if this was an 8 bit
 801           bit of data which we read and relocated, this would be
 802           0x000000ff. When we have relocs which have an addend, such as
 803           sun4 extended relocs, the value in the offset part of a
 804           relocating field is garbage so we never use it. In this case
 805           the mask would be 0x00000000. */
 806   bfd_word src_mask;
 807
 808         /* The dst_mask is what parts of the instruction are replaced
 809           into the instruction. In most cases src_mask == dst_mask,
 810           except in the above special case, where dst_mask would be
 811           0x000000ff, and src_mask would be 0x00000000.   */
 812   bfd_word dst_mask;
 813
 814         /* When some formats create PC relative instructions, they leave
 815           the value of the pc of the place being relocated in the offset
 816           slot of the instruction, so that a PC relative relocation can
 817           be made just by adding in an ordinary offset (eg sun3 a.out).
 818           Some formats leave the displacement part of an instruction
 819           empty (eg m88k bcs), this flag signals the fact.*/
 820   boolean pcrel_offset;
 821
 822 } reloc_howto_type;
 823 #define HOWTO(C, R,S,B, P, BI, ABS, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 824   {(unsigned)C,R,S,B, P, BI, ABS,O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
 825 #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,false,false,FUNCTION, NAME,false,0,0,IN)
 826
 827 #define HOWTO_PREPARE(relocation, symbol)      \
 828   {                                            \
 829   if (symbol != (asymbol *)NULL) {             \
 830     if (symbol->section == &bfd_com_section) { \
 831       relocation = 0;                          \
 832     }                                          \
 833     else {                                     \
 834       relocation = symbol->value;              \
 835     }                                          \
 836   }                                            \
 837 }
 838 typedef unsigned char bfd_byte;
 839
 840 typedef struct relent_chain {
 841   arelent relent;
 842   struct   relent_chain *next;
 843 } arelent_chain;
 844 bfd_reloc_status_type
 845 EXFUN(bfd_perform_relocation
 846     , (bfd * abfd,
 847     arelent *reloc_entry,
 848     PTR data,
 849     asection *input_section,
 850     bfd *output_bfd));
 851 typedef enum bfd_reloc_code_real
 852 {
 853         /* 16 bits wide, simple reloc */
 854   BFD_RELOC_16,
 855
 856         /* 8 bits wide, but used to form an address like 0xffnn */
 857   BFD_RELOC_8_FFnn,
 858
 859         /* 8 bits wide, simple */
 860   BFD_RELOC_8,
 861
 862         /* 8 bits wide, pc relative */
 863   BFD_RELOC_8_PCREL,
 864
 865         /* The type of reloc used to build a contructor table - at the
 866           moment probably a 32 bit wide abs address, but the cpu can
 867           choose. */
 868
 869   BFD_RELOC_CTOR,
 870
 871         /* 32 bits wide, simple reloc */
 872   BFD_RELOC_32,
 873          /* 32 bits, PC-relative */
 874   BFD_RELOC_32_PCREL,
 875
 876          /* High 22 bits of 32-bit value; simple reloc.  */
 877   BFD_RELOC_HI22,
 878          /* Low 10 bits.  */
 879   BFD_RELOC_LO10,
 880
 881          /* Reloc types used for i960/b.out.  */
 882   BFD_RELOC_24_PCREL,
 883   BFD_RELOC_I960_CALLJ,
 884
 885   BFD_RELOC_16_PCREL,
 886          /* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
 887            word displacement, e.g. for SPARC) */
 888   BFD_RELOC_32_PCREL_S2,
 889
 890    /* now for the sparc/elf codes */
 891   BFD_RELOC_NONE,                /* actually used */
 892   BFD_RELOC_SPARC_WDISP22,
 893   BFD_RELOC_SPARC22,
 894   BFD_RELOC_SPARC13,
 895   BFD_RELOC_SPARC_BASE13,
 896   BFD_RELOC_SPARC_GOT10,
 897   BFD_RELOC_SPARC_GOT13,
 898   BFD_RELOC_SPARC_GOT22,
 899   BFD_RELOC_SPARC_PC10,
 900   BFD_RELOC_SPARC_PC22,
 901   BFD_RELOC_SPARC_WPLT30,
 902   BFD_RELOC_SPARC_COPY,
 903   BFD_RELOC_SPARC_GLOB_DAT,
 904   BFD_RELOC_SPARC_JMP_SLOT,
 905   BFD_RELOC_SPARC_RELATIVE,
 906   BFD_RELOC_SPARC_UA32,
 907
 908    /* this one is a.out specific? */
 909   BFD_RELOC_SPARC_BASE22,
 910
 911    /* this must be the highest numeric value */
 912   BFD_RELOC_UNUSED
 913  } bfd_reloc_code_real_type;
 914 CONST struct reloc_howto_struct *
 915 EXFUN(bfd_reloc_type_lookup , (bfd *abfd, bfd_reloc_code_real_type code));
 916 typedef struct symbol_cache_entry
 917 {
 918          /* A pointer to the BFD which owns the symbol. This information
 919            is necessary so that a back end can work out what additional
 920            (invisible to the application writer) information is carried
 921            with the symbol.  */
 922
 923   struct _bfd *the_bfd;
 924
 925          /* The text of the symbol. The name is left alone, and not copied - the
 926            application may not alter it. */
 927   CONST char *name;
 928
 929          /* The value of the symbol.*/
 930   symvalue value;
 931
 932          /* Attributes of a symbol: */
 933
 934 #define BSF_NO_FLAGS    0x00
 935
 936          /* The symbol has local scope; <<static>> in <<C>>. The value
 937            is the offset into the section of the data. */
 938 #define BSF_LOCAL       0x01
 939
 940          /* The symbol has global scope; initialized data in <<C>>. The
 941            value is the offset into the section of the data. */
 942 #define BSF_GLOBAL      0x02
 943
 944          /* Obsolete */
 945 #define BSF_IMPORT      0x04
 946
 947          /* The symbol has global scope, and is exported. The value is
 948            the offset into the section of the data. */
 949 #define BSF_EXPORT      0x08
 950
 951          /* The symbol is undefined. <<extern>> in <<C>>. The value has
 952            no meaning. */
 953 #define BSF_UNDEFINED_OBS 0x10
 954
 955          /* The symbol is common, initialized to zero; default in
 956            <<C>>. The value is the size of the object in bytes. */
 957 #define BSF_FORT_COMM_OBS       0x20
 958
 959          /* A normal C symbol would be one of:
 960            <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
 961            <<BSF_EXPORT|BSD_GLOBAL>> */
 962
 963          /* The symbol is a debugging record. The value has an arbitary
 964            meaning. */
 965 #define BSF_DEBUGGING   0x40
 966
 967          /* Used by the linker */
 968 #define BSF_KEEP        0x10000
 969 #define BSF_KEEP_G      0x80000
 970
 971          /* Unused */
 972 #define BSF_WEAK        0x100000
 973 #define BSF_CTOR        0x200000
 974
 975         /* This symbol was created to point to a section */
 976 #define BSF_SECTION_SYM 0x400000
 977
 978          /* The symbol used to be a common symbol, but now it is
 979            allocated. */
 980 #define BSF_OLD_COMMON  0x800000
 981
 982          /* The default value for common data. */
 983 #define BFD_FORT_COMM_DEFAULT_VALUE 0
 984
 985          /* In some files the type of a symbol sometimes alters its
 986            location in an output file - ie in coff a <<ISFCN>> symbol
 987            which is also <<C_EXT>> symbol appears where it was
 988            declared and not at the end of a section.  This bit is set
 989            by the target BFD part to convey this information. */
 990
 991 #define BSF_NOT_AT_END    0x40000
 992
 993          /* Signal that the symbol is the label of constructor section. */
 994 #define BSF_CONSTRUCTOR   0x1000000
 995
 996          /* Signal that the symbol is a warning symbol. If the symbol
 997            is a warning symbol, then the value field (I know this is
 998            tacky) will point to the asymbol which when referenced will
 999            cause the warning. */
1000 #define BSF_WARNING       0x2000000
1001
1002          /* Signal that the symbol is indirect. The value of the symbol
1003            is a pointer to an undefined asymbol which contains the
1004            name to use instead. */
1005 #define BSF_INDIRECT     0x4000000
1006
1007   flagword flags;
1008
1009          /* A pointer to the section to which this symbol is
1010            relative.  This will always be non NULL, there are special
1011           sections for undefined and absolute symbols */
1012   struct sec *section;
1013
1014          /* Back end special data. This is being phased out in favour
1015            of making this a union. */
1016   PTR udata;
1017
1018 } asymbol;
1019 #define get_symtab_upper_bound(abfd) \
1020      BFD_SEND (abfd, _get_symtab_upper_bound, (abfd))
1021 #define bfd_canonicalize_symtab(abfd, location) \
1022      BFD_SEND (abfd, _bfd_canonicalize_symtab,\
1023                   (abfd, location))
1024 boolean EXFUN(bfd_set_symtab , (bfd *, asymbol **, unsigned int ));
1025 void EXFUN(bfd_print_symbol_vandf, (PTR file, asymbol *symbol));
1026 #define bfd_make_empty_symbol(abfd) \
1027      BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
1028 #define bfd_make_debug_symbol(abfd,ptr,size) \
1029         BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
1030 int EXFUN(bfd_decode_symclass, (asymbol *symbol));
1031 struct _bfd
1032 {
1033      /* The filename the application opened the BFD with.  */
1034     CONST char *filename;
1035
1036      /* A pointer to the target jump table.             */
1037     struct bfd_target *xvec;
1038
1039      /* To avoid dragging too many header files into every file that
1040        includes `<<bfd.h>>', IOSTREAM has been declared as a "char
1041        *", and MTIME as a "long".  Their correct types, to which they
1042        are cast when used, are "FILE *" and "time_t".    The iostream
1043        is the result of an fopen on the filename. */
1044     char *iostream;
1045
1046      /* Is the file being cached */
1047
1048     boolean cacheable;
1049
1050      /* Marks whether there was a default target specified when the
1051        BFD was opened. This is used to select what matching algorithm
1052        to use to chose the back end. */
1053
1054     boolean target_defaulted;
1055
1056      /* The caching routines use these to maintain a
1057        least-recently-used list of BFDs */
1058
1059     struct _bfd *lru_prev, *lru_next;
1060
1061      /* When a file is closed by the caching routines, BFD retains
1062        state information on the file here:
1063      */
1064
1065     file_ptr where;
1066
1067      /* and here:*/
1068
1069     boolean opened_once;
1070
1071      /* Set if we have a locally maintained mtime value, rather than
1072        getting it from the file each time: */
1073
1074     boolean mtime_set;
1075
1076      /* File modified time, if mtime_set is true: */
1077
1078     long mtime;
1079
1080      /* Reserved for an unimplemented file locking extension.*/
1081
1082     int ifd;
1083
1084      /* The format which belongs to the BFD.*/
1085
1086     bfd_format format;
1087
1088      /* The direction the BFD was opened with*/
1089
1090     enum bfd_direction {no_direction = 0,
1091                         read_direction = 1,
1092                         write_direction = 2,
1093                         both_direction = 3} direction;
1094
1095      /* Format_specific flags*/
1096
1097     flagword flags;
1098
1099      /* Currently my_archive is tested before adding origin to
1100        anything. I believe that this can become always an add of
1101        origin, with origin set to 0 for non archive files.   */
1102
1103     file_ptr origin;
1104
1105      /* Remember when output has begun, to stop strange things
1106        happening. */
1107     boolean output_has_begun;
1108
1109      /* Pointer to linked list of sections*/
1110     struct sec  *sections;
1111
1112      /* The number of sections */
1113     unsigned int section_count;
1114
1115      /* Stuff only useful for object files:
1116        The start address. */
1117     bfd_vma start_address;
1118
1119      /* Used for input and output*/
1120     unsigned int symcount;
1121
1122      /* Symbol table for output BFD*/
1123     struct symbol_cache_entry  **outsymbols;
1124
1125      /* Pointer to structure which contains architecture information*/
1126     struct bfd_arch_info *arch_info;
1127
1128      /* Stuff only useful for archives:*/
1129     PTR arelt_data;
1130     struct _bfd *my_archive;
1131     struct _bfd *next;
1132     struct _bfd *archive_head;
1133     boolean has_armap;
1134
1135      /* Used by the back end to hold private data. */
1136
1137     union
1138       {
1139       struct aout_data_struct *aout_data;
1140       struct artdata *aout_ar_data;
1141       struct _oasys_data *oasys_obj_data;
1142       struct _oasys_ar_data *oasys_ar_data;
1143       struct coff_tdata *coff_obj_data;
1144       struct ieee_data_struct *ieee_data;
1145       struct ieee_ar_data_struct *ieee_ar_data;
1146       struct srec_data_struct *srec_data;
1147       struct srec_data_struct *tekhex_data;
1148       struct elf_obj_tdata *elf_obj_data;
1149       struct bout_data_struct *bout_data;
1150       struct sun_core_struct *sun_core_data;
1151       struct trad_core_struct *trad_core_data;
1152       PTR any;
1153       } tdata;
1154
1155      /* Used by the application to hold private data*/
1156     PTR usrdata;
1157
1158      /* Where all the allocated stuff under this BFD goes */
1159     struct obstack memory;
1160
1161      /* Is this really needed in addition to usrdata?  */
1162     asymbol **ld_symbols;
1163 };
1164
1165 unsigned int EXFUN(bfd_get_reloc_upper_bound, (bfd *abfd, asection *sect));
1166 unsigned int EXFUN(bfd_canonicalize_reloc
1167     , (bfd *abfd,
1168     asection *sec,
1169     arelent **loc,
1170     asymbol     **syms));
1171 boolean EXFUN(bfd_set_file_flags, (bfd *abfd, flagword flags));
1172 void EXFUN(bfd_set_reloc
1173     , (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
1174
1175     );
1176 boolean EXFUN(bfd_set_start_address, (bfd *, bfd_vma));
1177 long EXFUN(bfd_get_mtime, (bfd *));
1178 #define bfd_sizeof_headers(abfd, reloc) \
1179      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1180
1181 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1182      BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
1183
1184         /* Do these three do anything useful at all, for any back end?  */
1185 #define bfd_debug_info_start(abfd) \
1186         BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1187
1188 #define bfd_debug_info_end(abfd) \
1189         BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1190
1191 #define bfd_debug_info_accumulate(abfd, section) \
1192         BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1193
1194
1195 #define bfd_stat_arch_elt(abfd, stat) \
1196         BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1197
1198 #define bfd_coff_swap_aux_in(a,e,t,c,i) \
1199         BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i))
1200
1201 #define bfd_coff_swap_sym_in(a,e,i) \
1202         BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i))
1203
1204 #define bfd_coff_swap_lineno_in(a,e,i) \
1205         BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i))
1206
1207 #define bfd_set_arch_mach(abfd, arch, mach)\
1208         BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1209
1210 #define bfd_coff_swap_reloc_out(abfd, i, o) \
1211         BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o))
1212
1213 #define bfd_coff_swap_lineno_out(abfd, i, o) \
1214         BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o))
1215
1216 #define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
1217         BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o))
1218
1219 #define bfd_coff_swap_sym_out(abfd, i,o) \
1220         BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o))
1221
1222 #define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1223         BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o))
1224
1225 #define bfd_coff_swap_filehdr_out(abfd, i,o) \
1226         BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o))
1227
1228 #define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1229         BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o))
1230
1231 #define bfd_get_relocated_section_contents(abfd, seclet, data) \
1232         BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet, data))
1233
1234 #define bfd_relax_section(abfd, section, symbols) \
1235        BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols))
1236 symindex EXFUN(bfd_get_next_mapent, (bfd *, symindex previous, carsym ** sym));
1237 boolean EXFUN(bfd_set_archive_head, (bfd *output, bfd *new_head));
1238 bfd *EXFUN(bfd_get_elt_at_index, (bfd * archive, int index));
1239 bfd* EXFUN(bfd_openr_next_archived_file, (bfd *archive, bfd *previous));
1240 CONST char *EXFUN(bfd_core_file_failing_command, (bfd *));
1241 int EXFUN(bfd_core_file_failing_signal, (bfd *));
1242 boolean EXFUN(core_file_matches_executable_p
1243     , (bfd *core_bfd, bfd *exec_bfd));
1244 #define SDEF(ret, name, arglist) \
1245                 PROTO(ret,(*name),arglist)
1246 #define SDEF_FMT(ret, name, arglist) \
1247                 PROTO(ret,(*name[bfd_type_end]),arglist)
1248 #define BFD_SEND(bfd, message, arglist) \
1249                ((*((bfd)->xvec->message)) arglist)
1250 #define BFD_SEND_FMT(bfd, message, arglist) \
1251             (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
1252 typedef struct bfd_target
1253 {
1254   char *name;
1255   enum target_flavour {
1256     bfd_target_unknown_flavour,
1257     bfd_target_aout_flavour,
1258     bfd_target_coff_flavour,
1259     bfd_target_elf_flavour,
1260     bfd_target_ieee_flavour,
1261     bfd_target_oasys_flavour,
1262     bfd_target_tekhex_flavour,
1263     bfd_target_srec_flavour,
1264     bfd_target_hppa_flavour} flavour;
1265   boolean byteorder_big_p;
1266   boolean header_byteorder_big_p;
1267   flagword object_flags;
1268   flagword section_flags;
1269   char ar_pad_char;
1270  unsigned short ar_max_namelen;
1271   unsigned int align_power_min;
1272   SDEF (bfd_vma,      bfd_getx64, (bfd_byte *));
1273   SDEF (void,         bfd_putx64, (bfd_vma, bfd_byte *));
1274   SDEF (bfd_vma, bfd_getx32, (bfd_byte *));
1275   SDEF (void,         bfd_putx32, (bfd_vma, bfd_byte *));
1276   SDEF (bfd_vma, bfd_getx16, (bfd_byte *));
1277   SDEF (void,         bfd_putx16, (bfd_vma, bfd_byte *));
1278   SDEF (bfd_vma,   bfd_h_getx64, (bfd_byte *));
1279   SDEF (void,          bfd_h_putx64, (bfd_vma, bfd_byte *));
1280   SDEF (bfd_vma,  bfd_h_getx32, (bfd_byte *));
1281   SDEF (void,          bfd_h_putx32, (bfd_vma, bfd_byte *));
1282   SDEF (bfd_vma,  bfd_h_getx16, (bfd_byte *));
1283   SDEF (void,          bfd_h_putx16, (bfd_vma, bfd_byte *));
1284   SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));
1285   SDEF_FMT (boolean,            _bfd_set_format, (bfd *));
1286   SDEF_FMT (boolean,            _bfd_write_contents, (bfd *));
1287   SDEF (char *, _core_file_failing_command, (bfd *));
1288   SDEF (int,    _core_file_failing_signal, (bfd *));
1289   SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *));
1290  SDEF (boolean, _bfd_slurp_armap, (bfd *));
1291  SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *));
1292  SDEF (void,   _bfd_truncate_arname, (bfd *, CONST char *, char *));
1293  SDEF (boolean, write_armap, (bfd *arch,
1294                               unsigned int elength,
1295                               struct orl *map,
1296                               unsigned int orl_count,
1297                               int stridx));
1298   SDEF (boolean, _close_and_cleanup, (bfd *));
1299   SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR,
1300                                             file_ptr, bfd_size_type));
1301   SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR,
1302                                             file_ptr, bfd_size_type));
1303   SDEF (boolean, _new_section_hook, (bfd *, sec_ptr));
1304   SDEF (unsigned int, _get_symtab_upper_bound, (bfd *));
1305   SDEF (unsigned int, _bfd_canonicalize_symtab,
1306            (bfd *, struct symbol_cache_entry **));
1307   SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr));
1308   SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **,
1309                                                struct symbol_cache_entry**));
1310   SDEF (struct symbol_cache_entry  *, _bfd_make_empty_symbol, (bfd *));
1311   SDEF (void,     _bfd_print_symbol, (bfd *, PTR, struct symbol_cache_entry  *,
1312                                       bfd_print_symbol_type));
1313 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
1314   SDEF (alent *,   _get_lineno, (bfd *, struct symbol_cache_entry  *));
1315
1316   SDEF (boolean,   _bfd_set_arch_mach, (bfd *, enum bfd_architecture,
1317                                        unsigned long));
1318
1319   SDEF (bfd *,  openr_next_archived_file, (bfd *arch, bfd *prev));
1320   SDEF (boolean, _bfd_find_nearest_line,
1321         (bfd *abfd, struct sec  *section,
1322          struct symbol_cache_entry  **symbols,bfd_vma offset,
1323         CONST char **file, CONST char **func, unsigned int *line));
1324   SDEF (int,    _bfd_stat_arch_elt, (bfd *, struct stat *));
1325
1326   SDEF (int,    _bfd_sizeof_headers, (bfd *, boolean));
1327
1328   SDEF (void, _bfd_debug_info_start, (bfd *));
1329   SDEF (void, _bfd_debug_info_end, (bfd *));
1330   SDEF (void, _bfd_debug_info_accumulate, (bfd *, struct sec  *));
1331   SDEF (bfd_byte *, _bfd_get_relocated_section_contents, (bfd*,struct bfd_seclet_struct *, bfd_byte *data));
1332   SDEF (boolean,_bfd_relax_section,(bfd *, struct sec *, struct symbol_cache_entry **));
1333   SDEF(void, _bfd_coff_swap_aux_in,(
1334        bfd            *abfd ,
1335        PTR             ext,
1336        int             type,
1337        int             class ,
1338        PTR             in));
1339
1340   SDEF(void, _bfd_coff_swap_sym_in,(
1341        bfd            *abfd ,
1342        PTR             ext,
1343        PTR             in));
1344
1345   SDEF(void, _bfd_coff_swap_lineno_in,  (
1346        bfd            *abfd,
1347        PTR            ext,
1348        PTR             in));
1349
1350  SDEF(unsigned int, _bfd_coff_swap_aux_out,(
1351        bfd      *abfd,
1352        PTR      in,
1353        int      type,
1354        int      class,
1355        PTR      ext));
1356
1357  SDEF(unsigned int, _bfd_coff_swap_sym_out,(
1358       bfd      *abfd,
1359       PTR       in,
1360       PTR       ext));
1361
1362  SDEF(unsigned int, _bfd_coff_swap_lineno_out,(
1363         bfd     *abfd,
1364         PTR     in,
1365         PTR     ext));
1366
1367  SDEF(unsigned int, _bfd_coff_swap_reloc_out,(
1368         bfd     *abfd,
1369         PTR     src,
1370         PTR     dst));
1371
1372  SDEF(unsigned int, _bfd_coff_swap_filehdr_out,(
1373         bfd     *abfd,
1374         PTR     in,
1375         PTR     out));
1376
1377  SDEF(unsigned int, _bfd_coff_swap_aouthdr_out,(
1378         bfd     *abfd,
1379         PTR     in,
1380         PTR     out));
1381
1382  SDEF(unsigned int, _bfd_coff_swap_scnhdr_out,(
1383         bfd     *abfd,
1384         PTR     in,
1385         PTR     out));
1386
1387   /* See documentation on reloc types.  */
1388  SDEF (CONST struct reloc_howto_struct *,
1389        reloc_type_lookup,
1390        (bfd *abfd, bfd_reloc_code_real_type code));
1391
1392   /* Complete and utter crock, currently used for the assembler
1393     when creating COFF files.  */
1394  SDEF (asymbol *, _bfd_make_debug_symbol, (
1395        bfd *abfd,
1396        void *ptr,
1397        unsigned long size));
1398  PTR backend_data;
1399 } bfd_target;
1400 bfd_target *EXFUN(bfd_find_target, (CONST char *, bfd *));
1401 CONST char **EXFUN(bfd_target_list, (void));
1402 boolean EXFUN(bfd_check_format, (bfd *abfd, bfd_format format));
1403 boolean EXFUN(bfd_set_format, (bfd *, bfd_format));
1404 CONST char *EXFUN(bfd_format_string, (bfd_format));
1405 #endif