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        0x00
 110 #define HAS_RELOC       0x01
 111 #define EXEC_P          0x02
 112 #define HAS_LINENO      0x04
 113 #define HAS_DEBUG       0x08
 114 #define HAS_SYMS        0x10
 115 #define HAS_LOCALS      0x20
 116 #define DYNAMIC         0x40
 117 #define WP_TEXT         0x80
 118 #define D_PAGED         0x100
 119 #define BFD_IS_RELAXABLE 0x200
 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   struct bfd_arch_info *next;
 675 } bfd_arch_info_type;
 676 CONST char *EXFUN(bfd_printable_name, (bfd *abfd));
 677 bfd_arch_info_type *EXFUN(bfd_scan_arch, (CONST char *));
 678 CONST bfd_arch_info_type *EXFUN(bfd_arch_get_compatible, (
 679     CONST bfd *abfd,
 680     CONST bfd *bbfd));
 681 void EXFUN(bfd_set_arch_info, (bfd *, bfd_arch_info_type *));
 682 enum bfd_architecture EXFUN(bfd_get_arch, (bfd *abfd));
 683 unsigned long EXFUN(bfd_get_mach, (bfd *abfd));
 684 unsigned int EXFUN(bfd_arch_bits_per_byte, (bfd *abfd));
 685 unsigned int EXFUN(bfd_arch_bits_per_address, (bfd *abfd));
 686 bfd_arch_info_type * EXFUN(bfd_get_arch_info, (bfd *));
 687 bfd_arch_info_type *EXFUN(bfd_lookup_arch
 688     , (enum bfd_architecture
 689     arch,
 690     long machine));
 691 CONST char * EXFUN(bfd_printable_arch_mach
 692     , (enum bfd_architecture arch, unsigned long machine));
 693 typedef enum bfd_reloc_status
 694 {
 695         /* No errors detected */
 696   bfd_reloc_ok,
 697
 698         /* The relocation was performed, but there was an overflow. */
 699   bfd_reloc_overflow,
 700
 701         /* The address to relocate was not within the section supplied*/
 702   bfd_reloc_outofrange,
 703
 704         /* Used by special functions */
 705   bfd_reloc_continue,
 706
 707         /* Unused */
 708   bfd_reloc_notsupported,
 709
 710         /* Unsupported relocation size requested.  */
 711   bfd_reloc_other,
 712
 713         /* The symbol to relocate against was undefined.*/
 714   bfd_reloc_undefined,
 715
 716         /* The relocation was performed, but may not be ok - presently
 717           generated only when linking i960 coff files with i960 b.out
 718           symbols. */
 719   bfd_reloc_dangerous
 720  }
 721  bfd_reloc_status_type;
 722
 723
 724 typedef struct reloc_cache_entry
 725 {
 726         /* A pointer into the canonical table of pointers  */
 727   struct symbol_cache_entry **sym_ptr_ptr;
 728
 729         /* offset in section */
 730   rawdata_offset address;
 731
 732         /* addend for relocation value */
 733   bfd_vma addend;
 734
 735         /* Pointer to how to perform the required relocation */
 736   CONST struct reloc_howto_struct *howto;
 737
 738 } arelent;
 739
 740 typedef CONST struct reloc_howto_struct
 741 {
 742         /*  The type field has mainly a documetary use - the back end can
 743            to what it wants with it, though the normally the back end's
 744            external idea of what a reloc number would be would be stored
 745            in this field. For example, the a PC relative word relocation
 746            in a coff environment would have the type 023 - because that's
 747            what the outside world calls a R_PCRWORD reloc. */
 748   unsigned int type;
 749
 750         /*  The value the final relocation is shifted right by. This drops
 751            unwanted data from the relocation.  */
 752   unsigned int rightshift;
 753
 754         /*  The size of the item to be relocated - 0, is one byte, 1 is 2
 755            bytes, 3 is four bytes.  A -ve value indicates that the
 756             result is to be subtracted from the data*/
 757   unsigned int size;
 758
 759         /*  Now obsolete */
 760   unsigned int bitsize;
 761
 762         /*  Notes that the relocation is relative to the location in the
 763            data section of the addend. The relocation function will
 764            subtract from the relocation value the address of the location
 765            being relocated. */
 766   boolean pc_relative;
 767
 768         /*  Now obsolete */
 769   unsigned int bitpos;
 770
 771         /*  Now obsolete */
 772   boolean absolute;
 773
 774         /* Causes the relocation routine to return an error if overflow
 775           is detected when relocating. */
 776   boolean complain_on_overflow;
 777
 778         /* If this field is non null, then the supplied function is
 779           called rather than the normal function. This allows really
 780           strange relocation methods to be accomodated (eg, i960 callj
 781           instructions). */
 782   bfd_reloc_status_type EXFUN ((*special_function),
 783                                             (bfd *abfd,
 784                                              arelent *reloc_entry,
 785                                             struct symbol_cache_entry *symbol,
 786                                             PTR data,
 787                                             asection *input_section,
 788                                             bfd *output_bfd     ));
 789
 790         /* The textual name of the relocation type. */
 791   char *name;
 792
 793         /* When performing a partial link, some formats must modify the
 794           relocations rather than the data - this flag signals this.*/
 795   boolean partial_inplace;
 796
 797         /* The src_mask is used to select what parts of the read in data
 798           are to be used in the relocation sum. Eg, if this was an 8 bit
 799           bit of data which we read and relocated, this would be
 800           0x000000ff. When we have relocs which have an addend, such as
 801           sun4 extended relocs, the value in the offset part of a
 802           relocating field is garbage so we never use it. In this case
 803           the mask would be 0x00000000. */
 804   bfd_word src_mask;
 805
 806         /* The dst_mask is what parts of the instruction are replaced
 807           into the instruction. In most cases src_mask == dst_mask,
 808           except in the above special case, where dst_mask would be
 809           0x000000ff, and src_mask would be 0x00000000.   */
 810   bfd_word dst_mask;
 811
 812         /* When some formats create PC relative instructions, they leave
 813           the value of the pc of the place being relocated in the offset
 814           slot of the instruction, so that a PC relative relocation can
 815           be made just by adding in an ordinary offset (eg sun3 a.out).
 816           Some formats leave the displacement part of an instruction
 817           empty (eg m88k bcs), this flag signals the fact.*/
 818   boolean pcrel_offset;
 819
 820 } reloc_howto_type;
 821 #define HOWTO(C, R,S,B, P, BI, ABS, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 822   {(unsigned)C,R,S,B, P, BI, ABS,O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
 823 #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,false,false,FUNCTION, NAME,false,0,0,IN)
 824
 825 #define HOWTO_PREPARE(relocation, symbol)      \
 826   {                                            \
 827   if (symbol != (asymbol *)NULL) {             \
 828     if (symbol->section == &bfd_com_section) { \
 829       relocation = 0;                          \
 830     }                                          \
 831     else {                                     \
 832       relocation = symbol->value;              \
 833     }                                          \
 834   }                                            \
 835 }
 836 typedef unsigned char bfd_byte;
 837
 838 typedef struct relent_chain {
 839   arelent relent;
 840   struct   relent_chain *next;
 841 } arelent_chain;
 842 bfd_reloc_status_type
 843 EXFUN(bfd_perform_relocation
 844     , (bfd * abfd,
 845     arelent *reloc_entry,
 846     PTR data,
 847     asection *input_section,
 848     bfd *output_bfd));
 849 typedef enum bfd_reloc_code_real
 850 {
 851         /* 16 bits wide, simple reloc */
 852   BFD_RELOC_16,
 853
 854         /* 8 bits wide, but used to form an address like 0xffnn */
 855   BFD_RELOC_8_FFnn,
 856
 857         /* 8 bits wide, simple */
 858   BFD_RELOC_8,
 859
 860         /* 8 bits wide, pc relative */
 861   BFD_RELOC_8_PCREL,
 862
 863         /* The type of reloc used to build a contructor table - at the
 864           moment probably a 32 bit wide abs address, but the cpu can
 865           choose. */
 866
 867   BFD_RELOC_CTOR,
 868
 869         /* 32 bits wide, simple reloc */
 870   BFD_RELOC_32,
 871          /* 32 bits, PC-relative */
 872   BFD_RELOC_32_PCREL,
 873
 874          /* High 22 bits of 32-bit value; simple reloc.  */
 875   BFD_RELOC_HI22,
 876          /* Low 10 bits.  */
 877   BFD_RELOC_LO10,
 878
 879          /* Reloc types used for i960/b.out.  */
 880   BFD_RELOC_24_PCREL,
 881   BFD_RELOC_I960_CALLJ,
 882
 883   BFD_RELOC_16_PCREL,
 884          /* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
 885            word displacement, e.g. for SPARC) */
 886   BFD_RELOC_32_PCREL_S2,
 887
 888    /* now for the sparc/elf codes */
 889   BFD_RELOC_NONE,                /* actually used */
 890   BFD_RELOC_SPARC_WDISP22,
 891   BFD_RELOC_SPARC22,
 892   BFD_RELOC_SPARC13,
 893   BFD_RELOC_SPARC_BASE13,
 894   BFD_RELOC_SPARC_GOT10,
 895   BFD_RELOC_SPARC_GOT13,
 896   BFD_RELOC_SPARC_GOT22,
 897   BFD_RELOC_SPARC_PC10,
 898   BFD_RELOC_SPARC_PC22,
 899   BFD_RELOC_SPARC_WPLT30,
 900   BFD_RELOC_SPARC_COPY,
 901   BFD_RELOC_SPARC_GLOB_DAT,
 902   BFD_RELOC_SPARC_JMP_SLOT,
 903   BFD_RELOC_SPARC_RELATIVE,
 904   BFD_RELOC_SPARC_UA32,
 905
 906    /* this one is a.out specific? */
 907   BFD_RELOC_SPARC_BASE22,
 908
 909    /* this must be the highest numeric value */
 910   BFD_RELOC_UNUSED
 911  } bfd_reloc_code_real_type;
 912 CONST struct reloc_howto_struct *
 913 EXFUN(bfd_reloc_type_lookup , (bfd *abfd, bfd_reloc_code_real_type code));
 914 typedef struct symbol_cache_entry
 915 {
 916          /* A pointer to the BFD which owns the symbol. This information
 917            is necessary so that a back end can work out what additional
 918            (invisible to the application writer) information is carried
 919            with the symbol.  */
 920
 921   struct _bfd *the_bfd;
 922
 923          /* The text of the symbol. The name is left alone, and not copied - the
 924            application may not alter it. */
 925   CONST char *name;
 926
 927          /* The value of the symbol.*/
 928   symvalue value;
 929
 930          /* Attributes of a symbol: */
 931
 932 #define BSF_NO_FLAGS    0x00
 933
 934          /* The symbol has local scope; <<static>> in <<C>>. The value
 935            is the offset into the section of the data. */
 936 #define BSF_LOCAL       0x01
 937
 938          /* The symbol has global scope; initialized data in <<C>>. The
 939            value is the offset into the section of the data. */
 940 #define BSF_GLOBAL      0x02
 941
 942          /* Obsolete */
 943 #define BSF_IMPORT      0x04
 944
 945          /* The symbol has global scope, and is exported. The value is
 946            the offset into the section of the data. */
 947 #define BSF_EXPORT      0x08
 948
 949          /* The symbol is undefined. <<extern>> in <<C>>. The value has
 950            no meaning. */
 951 #define BSF_UNDEFINED_OBS 0x10
 952
 953          /* The symbol is common, initialized to zero; default in
 954            <<C>>. The value is the size of the object in bytes. */
 955 #define BSF_FORT_COMM_OBS       0x20
 956
 957          /* A normal C symbol would be one of:
 958            <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
 959            <<BSF_EXPORT|BSD_GLOBAL>> */
 960
 961          /* The symbol is a debugging record. The value has an arbitary
 962            meaning. */
 963 #define BSF_DEBUGGING   0x40
 964
 965          /* Used by the linker */
 966 #define BSF_KEEP        0x10000
 967 #define BSF_KEEP_G      0x80000
 968
 969          /* Unused */
 970 #define BSF_WEAK        0x100000
 971 #define BSF_CTOR        0x200000
 972
 973         /* This symbol was created to point to a section, e.g. ELF's
 974            STT_SECTION symbols.  */
 975 #define BSF_SECTION_SYM 0x400000
 976
 977          /* The symbol used to be a common symbol, but now it is
 978            allocated. */
 979 #define BSF_OLD_COMMON  0x800000
 980
 981          /* The default value for common data. */
 982 #define BFD_FORT_COMM_DEFAULT_VALUE 0
 983
 984          /* In some files the type of a symbol sometimes alters its
 985            location in an output file - ie in coff a <<ISFCN>> symbol
 986            which is also <<C_EXT>> symbol appears where it was
 987            declared and not at the end of a section.  This bit is set
 988            by the target BFD part to convey this information. */
 989
 990 #define BSF_NOT_AT_END    0x40000
 991
 992          /* Signal that the symbol is the label of constructor section. */
 993 #define BSF_CONSTRUCTOR   0x1000000
 994
 995          /* Signal that the symbol is a warning symbol. If the symbol
 996            is a warning symbol, then the value field (I know this is
 997            tacky) will point to the asymbol which when referenced will
 998            cause the warning. */
 999 #define BSF_WARNING       0x2000000
1000
1001          /* Signal that the symbol is indirect. The value of the symbol
1002            is a pointer to an undefined asymbol which contains the
1003            name to use instead. */
1004 #define BSF_INDIRECT      0x4000000
1005
1006          /* BSF_FILE marks symbols that contain a file name.  This is used
1007            for ELF STT_FILE symbols.  */
1008 #define BSF_FILE          0x08000000
1009
1010   flagword flags;
1011
1012          /* A pointer to the section to which this symbol is
1013            relative.  This will always be non NULL, there are special
1014           sections for undefined and absolute symbols */
1015   struct sec *section;
1016
1017          /* Back end special data. This is being phased out in favour
1018            of making this a union. */
1019   PTR udata;
1020
1021 } asymbol;
1022 #define get_symtab_upper_bound(abfd) \
1023      BFD_SEND (abfd, _get_symtab_upper_bound, (abfd))
1024 #define bfd_canonicalize_symtab(abfd, location) \
1025      BFD_SEND (abfd, _bfd_canonicalize_symtab,\
1026                   (abfd, location))
1027 boolean EXFUN(bfd_set_symtab , (bfd *, asymbol **, unsigned int ));
1028 void EXFUN(bfd_print_symbol_vandf, (PTR file, asymbol *symbol));
1029 #define bfd_make_empty_symbol(abfd) \
1030      BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
1031 #define bfd_make_debug_symbol(abfd,ptr,size) \
1032         BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
1033 int EXFUN(bfd_decode_symclass, (asymbol *symbol));
1034 struct _bfd
1035 {
1036      /* The filename the application opened the BFD with.  */
1037     CONST char *filename;
1038
1039      /* A pointer to the target jump table.             */
1040     struct bfd_target *xvec;
1041
1042      /* To avoid dragging too many header files into every file that
1043        includes `<<bfd.h>>', IOSTREAM has been declared as a "char
1044        *", and MTIME as a "long".  Their correct types, to which they
1045        are cast when used, are "FILE *" and "time_t".    The iostream
1046        is the result of an fopen on the filename. */
1047     char *iostream;
1048
1049      /* Is the file being cached */
1050
1051     boolean cacheable;
1052
1053      /* Marks whether there was a default target specified when the
1054        BFD was opened. This is used to select what matching algorithm
1055        to use to chose the back end. */
1056
1057     boolean target_defaulted;
1058
1059      /* The caching routines use these to maintain a
1060        least-recently-used list of BFDs */
1061
1062     struct _bfd *lru_prev, *lru_next;
1063
1064      /* When a file is closed by the caching routines, BFD retains
1065        state information on the file here:
1066      */
1067
1068     file_ptr where;
1069
1070      /* and here:*/
1071
1072     boolean opened_once;
1073
1074      /* Set if we have a locally maintained mtime value, rather than
1075        getting it from the file each time: */
1076
1077     boolean mtime_set;
1078
1079      /* File modified time, if mtime_set is true: */
1080
1081     long mtime;
1082
1083      /* Reserved for an unimplemented file locking extension.*/
1084
1085     int ifd;
1086
1087      /* The format which belongs to the BFD.*/
1088
1089     bfd_format format;
1090
1091      /* The direction the BFD was opened with*/
1092
1093     enum bfd_direction {no_direction = 0,
1094                         read_direction = 1,
1095                         write_direction = 2,
1096                         both_direction = 3} direction;
1097
1098      /* Format_specific flags*/
1099
1100     flagword flags;
1101
1102      /* Currently my_archive is tested before adding origin to
1103        anything. I believe that this can become always an add of
1104        origin, with origin set to 0 for non archive files.   */
1105
1106     file_ptr origin;
1107
1108      /* Remember when output has begun, to stop strange things
1109        happening. */
1110     boolean output_has_begun;
1111
1112      /* Pointer to linked list of sections*/
1113     struct sec  *sections;
1114
1115      /* The number of sections */
1116     unsigned int section_count;
1117
1118      /* Stuff only useful for object files:
1119        The start address. */
1120     bfd_vma start_address;
1121
1122      /* Used for input and output*/
1123     unsigned int symcount;
1124
1125      /* Symbol table for output BFD*/
1126     struct symbol_cache_entry  **outsymbols;
1127
1128      /* Pointer to structure which contains architecture information*/
1129     struct bfd_arch_info *arch_info;
1130
1131      /* Stuff only useful for archives:*/
1132     PTR arelt_data;
1133     struct _bfd *my_archive;
1134     struct _bfd *next;
1135     struct _bfd *archive_head;
1136     boolean has_armap;
1137
1138      /* Used by the back end to hold private data. */
1139
1140     union
1141       {
1142       struct aout_data_struct *aout_data;
1143       struct artdata *aout_ar_data;
1144       struct _oasys_data *oasys_obj_data;
1145       struct _oasys_ar_data *oasys_ar_data;
1146       struct coff_tdata *coff_obj_data;
1147       struct ieee_data_struct *ieee_data;
1148       struct ieee_ar_data_struct *ieee_ar_data;
1149       struct srec_data_struct *srec_data;
1150       struct srec_data_struct *tekhex_data;
1151       struct elf_obj_tdata *elf_obj_data;
1152       struct bout_data_struct *bout_data;
1153       struct sun_core_struct *sun_core_data;
1154       struct trad_core_struct *trad_core_data;
1155       struct hppa_data_struct *hppa_data;
1156       PTR any;
1157       } tdata;
1158
1159      /* Used by the application to hold private data*/
1160     PTR usrdata;
1161
1162      /* Where all the allocated stuff under this BFD goes */
1163     struct obstack memory;
1164
1165      /* Is this really needed in addition to usrdata?  */
1166     asymbol **ld_symbols;
1167 };
1168
1169 unsigned int EXFUN(bfd_get_reloc_upper_bound, (bfd *abfd, asection *sect));
1170 unsigned int EXFUN(bfd_canonicalize_reloc
1171     , (bfd *abfd,
1172     asection *sec,
1173     arelent **loc,
1174     asymbol     **syms));
1175 boolean EXFUN(bfd_set_file_flags, (bfd *abfd, flagword flags));
1176 void EXFUN(bfd_set_reloc
1177     , (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
1178
1179     );
1180 boolean EXFUN(bfd_set_start_address, (bfd *, bfd_vma));
1181 long EXFUN(bfd_get_mtime, (bfd *));
1182 #define bfd_sizeof_headers(abfd, reloc) \
1183      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1184
1185 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1186      BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
1187
1188         /* Do these three do anything useful at all, for any back end?  */
1189 #define bfd_debug_info_start(abfd) \
1190         BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1191
1192 #define bfd_debug_info_end(abfd) \
1193         BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1194
1195 #define bfd_debug_info_accumulate(abfd, section) \
1196         BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1197
1198
1199 #define bfd_stat_arch_elt(abfd, stat) \
1200         BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1201
1202 #define bfd_coff_swap_aux_in(a,e,t,c,i) \
1203         BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i))
1204
1205 #define bfd_coff_swap_sym_in(a,e,i) \
1206         BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i))
1207
1208 #define bfd_coff_swap_lineno_in(a,e,i) \
1209         BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i))
1210
1211 #define bfd_set_arch_mach(abfd, arch, mach)\
1212         BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1213
1214 #define bfd_coff_swap_reloc_out(abfd, i, o) \
1215         BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o))
1216
1217 #define bfd_coff_swap_lineno_out(abfd, i, o) \
1218         BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o))
1219
1220 #define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
1221         BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o))
1222
1223 #define bfd_coff_swap_sym_out(abfd, i,o) \
1224         BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o))
1225
1226 #define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1227         BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o))
1228
1229 #define bfd_coff_swap_filehdr_out(abfd, i,o) \
1230         BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o))
1231
1232 #define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1233         BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o))
1234
1235 #define bfd_get_relocated_section_contents(abfd, seclet, data) \
1236         BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet, data))
1237
1238 #define bfd_relax_section(abfd, section, symbols) \
1239        BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols))
1240 symindex EXFUN(bfd_get_next_mapent, (bfd *, symindex previous, carsym ** sym));
1241 boolean EXFUN(bfd_set_archive_head, (bfd *output, bfd *new_head));
1242 bfd *EXFUN(bfd_get_elt_at_index, (bfd * archive, int index));
1243 bfd* EXFUN(bfd_openr_next_archived_file, (bfd *archive, bfd *previous));
1244 CONST char *EXFUN(bfd_core_file_failing_command, (bfd *));
1245 int EXFUN(bfd_core_file_failing_signal, (bfd *));
1246 boolean EXFUN(core_file_matches_executable_p
1247     , (bfd *core_bfd, bfd *exec_bfd));
1248 #define SDEF(ret, name, arglist) \
1249                 PROTO(ret,(*name),arglist)
1250 #define SDEF_FMT(ret, name, arglist) \
1251                 PROTO(ret,(*name[bfd_type_end]),arglist)
1252 #define BFD_SEND(bfd, message, arglist) \
1253                ((*((bfd)->xvec->message)) arglist)
1254 #define BFD_SEND_FMT(bfd, message, arglist) \
1255             (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
1256 typedef struct bfd_target
1257 {
1258   char *name;
1259   enum target_flavour {
1260     bfd_target_unknown_flavour,
1261     bfd_target_aout_flavour,
1262     bfd_target_coff_flavour,
1263     bfd_target_elf_flavour,
1264     bfd_target_ieee_flavour,
1265     bfd_target_oasys_flavour,
1266     bfd_target_tekhex_flavour,
1267     bfd_target_srec_flavour,
1268     bfd_target_hppa_flavour} flavour;
1269   boolean byteorder_big_p;
1270   boolean header_byteorder_big_p;
1271   flagword object_flags;
1272   flagword section_flags;
1273   char ar_pad_char;
1274  unsigned short ar_max_namelen;
1275   unsigned int align_power_min;
1276   SDEF (bfd_vma,      bfd_getx64, (bfd_byte *));
1277   SDEF (void,         bfd_putx64, (bfd_vma, bfd_byte *));
1278   SDEF (bfd_vma, bfd_getx32, (bfd_byte *));
1279   SDEF (void,         bfd_putx32, (bfd_vma, bfd_byte *));
1280   SDEF (bfd_vma, bfd_getx16, (bfd_byte *));
1281   SDEF (void,         bfd_putx16, (bfd_vma, bfd_byte *));
1282   SDEF (bfd_vma,   bfd_h_getx64, (bfd_byte *));
1283   SDEF (void,          bfd_h_putx64, (bfd_vma, bfd_byte *));
1284   SDEF (bfd_vma,  bfd_h_getx32, (bfd_byte *));
1285   SDEF (void,          bfd_h_putx32, (bfd_vma, bfd_byte *));
1286   SDEF (bfd_vma,  bfd_h_getx16, (bfd_byte *));
1287   SDEF (void,          bfd_h_putx16, (bfd_vma, bfd_byte *));
1288   SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));
1289   SDEF_FMT (boolean,            _bfd_set_format, (bfd *));
1290   SDEF_FMT (boolean,            _bfd_write_contents, (bfd *));
1291   SDEF (char *, _core_file_failing_command, (bfd *));
1292   SDEF (int,    _core_file_failing_signal, (bfd *));
1293   SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *));
1294  SDEF (boolean, _bfd_slurp_armap, (bfd *));
1295  SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *));
1296  SDEF (void,   _bfd_truncate_arname, (bfd *, CONST char *, char *));
1297  SDEF (boolean, write_armap, (bfd *arch,
1298                               unsigned int elength,
1299                               struct orl *map,
1300                               unsigned int orl_count,
1301                               int stridx));
1302   SDEF (boolean, _close_and_cleanup, (bfd *));
1303   SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR,
1304                                             file_ptr, bfd_size_type));
1305   SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR,
1306                                             file_ptr, bfd_size_type));
1307   SDEF (boolean, _new_section_hook, (bfd *, sec_ptr));
1308   SDEF (unsigned int, _get_symtab_upper_bound, (bfd *));
1309   SDEF (unsigned int, _bfd_canonicalize_symtab,
1310            (bfd *, struct symbol_cache_entry **));
1311   SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr));
1312   SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **,
1313                                                struct symbol_cache_entry**));
1314   SDEF (struct symbol_cache_entry  *, _bfd_make_empty_symbol, (bfd *));
1315   SDEF (void,     _bfd_print_symbol, (bfd *, PTR, struct symbol_cache_entry  *,
1316                                       bfd_print_symbol_type));
1317 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
1318   SDEF (alent *,   _get_lineno, (bfd *, struct symbol_cache_entry  *));
1319
1320   SDEF (boolean,   _bfd_set_arch_mach, (bfd *, enum bfd_architecture,
1321                                        unsigned long));
1322
1323   SDEF (bfd *,  openr_next_archived_file, (bfd *arch, bfd *prev));
1324   SDEF (boolean, _bfd_find_nearest_line,
1325         (bfd *abfd, struct sec  *section,
1326          struct symbol_cache_entry  **symbols,bfd_vma offset,
1327         CONST char **file, CONST char **func, unsigned int *line));
1328   SDEF (int,    _bfd_stat_arch_elt, (bfd *, struct stat *));
1329
1330   SDEF (int,    _bfd_sizeof_headers, (bfd *, boolean));
1331
1332   SDEF (void, _bfd_debug_info_start, (bfd *));
1333   SDEF (void, _bfd_debug_info_end, (bfd *));
1334   SDEF (void, _bfd_debug_info_accumulate, (bfd *, struct sec  *));
1335   SDEF (bfd_byte *, _bfd_get_relocated_section_contents, (bfd*,struct bfd_seclet_struct *, bfd_byte *data));
1336   SDEF (boolean,_bfd_relax_section,(bfd *, struct sec *, struct symbol_cache_entry **));
1337   SDEF(void, _bfd_coff_swap_aux_in,(
1338        bfd            *abfd ,
1339        PTR             ext,
1340        int             type,
1341        int             class ,
1342        PTR             in));
1343
1344   SDEF(void, _bfd_coff_swap_sym_in,(
1345        bfd            *abfd ,
1346        PTR             ext,
1347        PTR             in));
1348
1349   SDEF(void, _bfd_coff_swap_lineno_in,  (
1350        bfd            *abfd,
1351        PTR            ext,
1352        PTR             in));
1353
1354  SDEF(unsigned int, _bfd_coff_swap_aux_out,(
1355        bfd      *abfd,
1356        PTR      in,
1357        int      type,
1358        int      class,
1359        PTR      ext));
1360
1361  SDEF(unsigned int, _bfd_coff_swap_sym_out,(
1362       bfd      *abfd,
1363       PTR       in,
1364       PTR       ext));
1365
1366  SDEF(unsigned int, _bfd_coff_swap_lineno_out,(
1367         bfd     *abfd,
1368         PTR     in,
1369         PTR     ext));
1370
1371  SDEF(unsigned int, _bfd_coff_swap_reloc_out,(
1372         bfd     *abfd,
1373         PTR     src,
1374         PTR     dst));
1375
1376  SDEF(unsigned int, _bfd_coff_swap_filehdr_out,(
1377         bfd     *abfd,
1378         PTR     in,
1379         PTR     out));
1380
1381  SDEF(unsigned int, _bfd_coff_swap_aouthdr_out,(
1382         bfd     *abfd,
1383         PTR     in,
1384         PTR     out));
1385
1386  SDEF(unsigned int, _bfd_coff_swap_scnhdr_out,(
1387         bfd     *abfd,
1388         PTR     in,
1389         PTR     out));
1390
1391   /* See documentation on reloc types.  */
1392  SDEF (CONST struct reloc_howto_struct *,
1393        reloc_type_lookup,
1394        (bfd *abfd, bfd_reloc_code_real_type code));
1395
1396   /* Complete and utter crock, currently used for the assembler
1397     when creating COFF files.  */
1398  SDEF (asymbol *, _bfd_make_debug_symbol, (
1399        bfd *abfd,
1400        void *ptr,
1401        unsigned long size));
1402  PTR backend_data;
1403 } bfd_target;
1404 bfd_target *EXFUN(bfd_find_target, (CONST char *, bfd *));
1405 CONST char **EXFUN(bfd_target_list, (void));
1406 boolean EXFUN(bfd_check_format, (bfd *abfd, bfd_format format));
1407 boolean EXFUN(bfd_set_format, (bfd *, bfd_format));
1408 CONST char *EXFUN(bfd_format_string, (bfd_format));
1409 #endif