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   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, e.g. ELF's
 976            STT_SECTION symbols.  */
 977 #define BSF_SECTION_SYM 0x400000
 978
 979          /* The symbol used to be a common symbol, but now it is
 980            allocated. */
 981 #define BSF_OLD_COMMON  0x800000
 982
 983          /* The default value for common data. */
 984 #define BFD_FORT_COMM_DEFAULT_VALUE 0
 985
 986          /* In some files the type of a symbol sometimes alters its
 987            location in an output file - ie in coff a <<ISFCN>> symbol
 988            which is also <<C_EXT>> symbol appears where it was
 989            declared and not at the end of a section.  This bit is set
 990            by the target BFD part to convey this information. */
 991
 992 #define BSF_NOT_AT_END    0x40000
 993
 994          /* Signal that the symbol is the label of constructor section. */
 995 #define BSF_CONSTRUCTOR   0x1000000
 996
 997          /* Signal that the symbol is a warning symbol. If the symbol
 998            is a warning symbol, then the value field (I know this is
 999            tacky) will point to the asymbol which when referenced will
1000            cause the warning. */
1001 #define BSF_WARNING       0x2000000
1002
1003          /* Signal that the symbol is indirect. The value of the symbol
1004            is a pointer to an undefined asymbol which contains the
1005            name to use instead. */
1006 #define BSF_INDIRECT      0x4000000
1007
1008          /* BSF_FILE marks symbols that contain a file name.  This is used
1009            for ELF STT_FILE symbols.  */
1010 #define BSF_FILE          0x08000000
1011
1012   flagword flags;
1013
1014          /* A pointer to the section to which this symbol is
1015            relative.  This will always be non NULL, there are special
1016           sections for undefined and absolute symbols */
1017   struct sec *section;
1018
1019          /* Back end special data. This is being phased out in favour
1020            of making this a union. */
1021   PTR udata;
1022
1023 } asymbol;
1024 #define get_symtab_upper_bound(abfd) \
1025      BFD_SEND (abfd, _get_symtab_upper_bound, (abfd))
1026 #define bfd_canonicalize_symtab(abfd, location) \
1027      BFD_SEND (abfd, _bfd_canonicalize_symtab,\
1028                   (abfd, location))
1029 boolean EXFUN(bfd_set_symtab , (bfd *, asymbol **, unsigned int ));
1030 void EXFUN(bfd_print_symbol_vandf, (PTR file, asymbol *symbol));
1031 #define bfd_make_empty_symbol(abfd) \
1032      BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
1033 #define bfd_make_debug_symbol(abfd,ptr,size) \
1034         BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
1035 int EXFUN(bfd_decode_symclass, (asymbol *symbol));
1036 struct _bfd
1037 {
1038      /* The filename the application opened the BFD with.  */
1039     CONST char *filename;
1040
1041      /* A pointer to the target jump table.             */
1042     struct bfd_target *xvec;
1043
1044      /* To avoid dragging too many header files into every file that
1045        includes `<<bfd.h>>', IOSTREAM has been declared as a "char
1046        *", and MTIME as a "long".  Their correct types, to which they
1047        are cast when used, are "FILE *" and "time_t".    The iostream
1048        is the result of an fopen on the filename. */
1049     char *iostream;
1050
1051      /* Is the file being cached */
1052
1053     boolean cacheable;
1054
1055      /* Marks whether there was a default target specified when the
1056        BFD was opened. This is used to select what matching algorithm
1057        to use to chose the back end. */
1058
1059     boolean target_defaulted;
1060
1061      /* The caching routines use these to maintain a
1062        least-recently-used list of BFDs */
1063
1064     struct _bfd *lru_prev, *lru_next;
1065
1066      /* When a file is closed by the caching routines, BFD retains
1067        state information on the file here:
1068      */
1069
1070     file_ptr where;
1071
1072      /* and here:*/
1073
1074     boolean opened_once;
1075
1076      /* Set if we have a locally maintained mtime value, rather than
1077        getting it from the file each time: */
1078
1079     boolean mtime_set;
1080
1081      /* File modified time, if mtime_set is true: */
1082
1083     long mtime;
1084
1085      /* Reserved for an unimplemented file locking extension.*/
1086
1087     int ifd;
1088
1089      /* The format which belongs to the BFD.*/
1090
1091     bfd_format format;
1092
1093      /* The direction the BFD was opened with*/
1094
1095     enum bfd_direction {no_direction = 0,
1096                         read_direction = 1,
1097                         write_direction = 2,
1098                         both_direction = 3} direction;
1099
1100      /* Format_specific flags*/
1101
1102     flagword flags;
1103
1104      /* Currently my_archive is tested before adding origin to
1105        anything. I believe that this can become always an add of
1106        origin, with origin set to 0 for non archive files.   */
1107
1108     file_ptr origin;
1109
1110      /* Remember when output has begun, to stop strange things
1111        happening. */
1112     boolean output_has_begun;
1113
1114      /* Pointer to linked list of sections*/
1115     struct sec  *sections;
1116
1117      /* The number of sections */
1118     unsigned int section_count;
1119
1120      /* Stuff only useful for object files:
1121        The start address. */
1122     bfd_vma start_address;
1123
1124      /* Used for input and output*/
1125     unsigned int symcount;
1126
1127      /* Symbol table for output BFD*/
1128     struct symbol_cache_entry  **outsymbols;
1129
1130      /* Pointer to structure which contains architecture information*/
1131     struct bfd_arch_info *arch_info;
1132
1133      /* Stuff only useful for archives:*/
1134     PTR arelt_data;
1135     struct _bfd *my_archive;
1136     struct _bfd *next;
1137     struct _bfd *archive_head;
1138     boolean has_armap;
1139
1140      /* Used by the back end to hold private data. */
1141
1142     union
1143       {
1144       struct aout_data_struct *aout_data;
1145       struct artdata *aout_ar_data;
1146       struct _oasys_data *oasys_obj_data;
1147       struct _oasys_ar_data *oasys_ar_data;
1148       struct coff_tdata *coff_obj_data;
1149       struct ieee_data_struct *ieee_data;
1150       struct ieee_ar_data_struct *ieee_ar_data;
1151       struct srec_data_struct *srec_data;
1152       struct srec_data_struct *tekhex_data;
1153       struct elf_obj_tdata *elf_obj_data;
1154       struct bout_data_struct *bout_data;
1155       struct sun_core_struct *sun_core_data;
1156       struct trad_core_struct *trad_core_data;
1157       struct hppa_data_struct *hppa_data;
1158       PTR any;
1159       } tdata;
1160
1161      /* Used by the application to hold private data*/
1162     PTR usrdata;
1163
1164      /* Where all the allocated stuff under this BFD goes */
1165     struct obstack memory;
1166
1167      /* Is this really needed in addition to usrdata?  */
1168     asymbol **ld_symbols;
1169 };
1170
1171 unsigned int EXFUN(bfd_get_reloc_upper_bound, (bfd *abfd, asection *sect));
1172 unsigned int EXFUN(bfd_canonicalize_reloc
1173     , (bfd *abfd,
1174     asection *sec,
1175     arelent **loc,
1176     asymbol     **syms));
1177 boolean EXFUN(bfd_set_file_flags, (bfd *abfd, flagword flags));
1178 void EXFUN(bfd_set_reloc
1179     , (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
1180
1181     );
1182 boolean EXFUN(bfd_set_start_address, (bfd *, bfd_vma));
1183 long EXFUN(bfd_get_mtime, (bfd *));
1184 #define bfd_sizeof_headers(abfd, reloc) \
1185      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1186
1187 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1188      BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
1189
1190         /* Do these three do anything useful at all, for any back end?  */
1191 #define bfd_debug_info_start(abfd) \
1192         BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1193
1194 #define bfd_debug_info_end(abfd) \
1195         BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1196
1197 #define bfd_debug_info_accumulate(abfd, section) \
1198         BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1199
1200
1201 #define bfd_stat_arch_elt(abfd, stat) \
1202         BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1203
1204 #define bfd_coff_swap_aux_in(a,e,t,c,i) \
1205         BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i))
1206
1207 #define bfd_coff_swap_sym_in(a,e,i) \
1208         BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i))
1209
1210 #define bfd_coff_swap_lineno_in(a,e,i) \
1211         BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i))
1212
1213 #define bfd_set_arch_mach(abfd, arch, mach)\
1214         BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1215
1216 #define bfd_coff_swap_reloc_out(abfd, i, o) \
1217         BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o))
1218
1219 #define bfd_coff_swap_lineno_out(abfd, i, o) \
1220         BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o))
1221
1222 #define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
1223         BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o))
1224
1225 #define bfd_coff_swap_sym_out(abfd, i,o) \
1226         BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o))
1227
1228 #define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1229         BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o))
1230
1231 #define bfd_coff_swap_filehdr_out(abfd, i,o) \
1232         BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o))
1233
1234 #define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1235         BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o))
1236
1237 #define bfd_get_relocated_section_contents(abfd, seclet, data) \
1238         BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet, data))
1239
1240 #define bfd_relax_section(abfd, section, symbols) \
1241        BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols))
1242 symindex EXFUN(bfd_get_next_mapent, (bfd *, symindex previous, carsym ** sym));
1243 boolean EXFUN(bfd_set_archive_head, (bfd *output, bfd *new_head));
1244 bfd *EXFUN(bfd_get_elt_at_index, (bfd * archive, int index));
1245 bfd* EXFUN(bfd_openr_next_archived_file, (bfd *archive, bfd *previous));
1246 CONST char *EXFUN(bfd_core_file_failing_command, (bfd *));
1247 int EXFUN(bfd_core_file_failing_signal, (bfd *));
1248 boolean EXFUN(core_file_matches_executable_p
1249     , (bfd *core_bfd, bfd *exec_bfd));
1250 #define SDEF(ret, name, arglist) \
1251                 PROTO(ret,(*name),arglist)
1252 #define SDEF_FMT(ret, name, arglist) \
1253                 PROTO(ret,(*name[bfd_type_end]),arglist)
1254 #define BFD_SEND(bfd, message, arglist) \
1255                ((*((bfd)->xvec->message)) arglist)
1256 #define BFD_SEND_FMT(bfd, message, arglist) \
1257             (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
1258 typedef struct bfd_target
1259 {
1260   char *name;
1261   enum target_flavour {
1262     bfd_target_unknown_flavour,
1263     bfd_target_aout_flavour,
1264     bfd_target_coff_flavour,
1265     bfd_target_elf_flavour,
1266     bfd_target_ieee_flavour,
1267     bfd_target_oasys_flavour,
1268     bfd_target_tekhex_flavour,
1269     bfd_target_srec_flavour,
1270     bfd_target_hppa_flavour} flavour;
1271   boolean byteorder_big_p;
1272   boolean header_byteorder_big_p;
1273   flagword object_flags;
1274   flagword section_flags;
1275   char ar_pad_char;
1276  unsigned short ar_max_namelen;
1277   unsigned int align_power_min;
1278   SDEF (bfd_vma,      bfd_getx64, (bfd_byte *));
1279   SDEF (void,         bfd_putx64, (bfd_vma, bfd_byte *));
1280   SDEF (bfd_vma, bfd_getx32, (bfd_byte *));
1281   SDEF (void,         bfd_putx32, (bfd_vma, bfd_byte *));
1282   SDEF (bfd_vma, bfd_getx16, (bfd_byte *));
1283   SDEF (void,         bfd_putx16, (bfd_vma, bfd_byte *));
1284   SDEF (bfd_vma,   bfd_h_getx64, (bfd_byte *));
1285   SDEF (void,          bfd_h_putx64, (bfd_vma, bfd_byte *));
1286   SDEF (bfd_vma,  bfd_h_getx32, (bfd_byte *));
1287   SDEF (void,          bfd_h_putx32, (bfd_vma, bfd_byte *));
1288   SDEF (bfd_vma,  bfd_h_getx16, (bfd_byte *));
1289   SDEF (void,          bfd_h_putx16, (bfd_vma, bfd_byte *));
1290   SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));
1291   SDEF_FMT (boolean,            _bfd_set_format, (bfd *));
1292   SDEF_FMT (boolean,            _bfd_write_contents, (bfd *));
1293   SDEF (char *, _core_file_failing_command, (bfd *));
1294   SDEF (int,    _core_file_failing_signal, (bfd *));
1295   SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *));
1296  SDEF (boolean, _bfd_slurp_armap, (bfd *));
1297  SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *));
1298  SDEF (void,   _bfd_truncate_arname, (bfd *, CONST char *, char *));
1299  SDEF (boolean, write_armap, (bfd *arch,
1300                               unsigned int elength,
1301                               struct orl *map,
1302                               unsigned int orl_count,
1303                               int stridx));
1304   SDEF (boolean, _close_and_cleanup, (bfd *));
1305   SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR,
1306                                             file_ptr, bfd_size_type));
1307   SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR,
1308                                             file_ptr, bfd_size_type));
1309   SDEF (boolean, _new_section_hook, (bfd *, sec_ptr));
1310   SDEF (unsigned int, _get_symtab_upper_bound, (bfd *));
1311   SDEF (unsigned int, _bfd_canonicalize_symtab,
1312            (bfd *, struct symbol_cache_entry **));
1313   SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr));
1314   SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **,
1315                                                struct symbol_cache_entry**));
1316   SDEF (struct symbol_cache_entry  *, _bfd_make_empty_symbol, (bfd *));
1317   SDEF (void,     _bfd_print_symbol, (bfd *, PTR, struct symbol_cache_entry  *,
1318                                       bfd_print_symbol_type));
1319 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
1320   SDEF (alent *,   _get_lineno, (bfd *, struct symbol_cache_entry  *));
1321
1322   SDEF (boolean,   _bfd_set_arch_mach, (bfd *, enum bfd_architecture,
1323                                        unsigned long));
1324
1325   SDEF (bfd *,  openr_next_archived_file, (bfd *arch, bfd *prev));
1326   SDEF (boolean, _bfd_find_nearest_line,
1327         (bfd *abfd, struct sec  *section,
1328          struct symbol_cache_entry  **symbols,bfd_vma offset,
1329         CONST char **file, CONST char **func, unsigned int *line));
1330   SDEF (int,    _bfd_stat_arch_elt, (bfd *, struct stat *));
1331
1332   SDEF (int,    _bfd_sizeof_headers, (bfd *, boolean));
1333
1334   SDEF (void, _bfd_debug_info_start, (bfd *));
1335   SDEF (void, _bfd_debug_info_end, (bfd *));
1336   SDEF (void, _bfd_debug_info_accumulate, (bfd *, struct sec  *));
1337   SDEF (bfd_byte *, _bfd_get_relocated_section_contents, (bfd*,struct bfd_seclet_struct *, bfd_byte *data));
1338   SDEF (boolean,_bfd_relax_section,(bfd *, struct sec *, struct symbol_cache_entry **));
1339   SDEF(void, _bfd_coff_swap_aux_in,(
1340        bfd            *abfd ,
1341        PTR             ext,
1342        int             type,
1343        int             class ,
1344        PTR             in));
1345
1346   SDEF(void, _bfd_coff_swap_sym_in,(
1347        bfd            *abfd ,
1348        PTR             ext,
1349        PTR             in));
1350
1351   SDEF(void, _bfd_coff_swap_lineno_in,  (
1352        bfd            *abfd,
1353        PTR            ext,
1354        PTR             in));
1355
1356  SDEF(unsigned int, _bfd_coff_swap_aux_out,(
1357        bfd      *abfd,
1358        PTR      in,
1359        int      type,
1360        int      class,
1361        PTR      ext));
1362
1363  SDEF(unsigned int, _bfd_coff_swap_sym_out,(
1364       bfd      *abfd,
1365       PTR       in,
1366       PTR       ext));
1367
1368  SDEF(unsigned int, _bfd_coff_swap_lineno_out,(
1369         bfd     *abfd,
1370         PTR     in,
1371         PTR     ext));
1372
1373  SDEF(unsigned int, _bfd_coff_swap_reloc_out,(
1374         bfd     *abfd,
1375         PTR     src,
1376         PTR     dst));
1377
1378  SDEF(unsigned int, _bfd_coff_swap_filehdr_out,(
1379         bfd     *abfd,
1380         PTR     in,
1381         PTR     out));
1382
1383  SDEF(unsigned int, _bfd_coff_swap_aouthdr_out,(
1384         bfd     *abfd,
1385         PTR     in,
1386         PTR     out));
1387
1388  SDEF(unsigned int, _bfd_coff_swap_scnhdr_out,(
1389         bfd     *abfd,
1390         PTR     in,
1391         PTR     out));
1392
1393   /* See documentation on reloc types.  */
1394  SDEF (CONST struct reloc_howto_struct *,
1395        reloc_type_lookup,
1396        (bfd *abfd, bfd_reloc_code_real_type code));
1397
1398   /* Complete and utter crock, currently used for the assembler
1399     when creating COFF files.  */
1400  SDEF (asymbol *, _bfd_make_debug_symbol, (
1401        bfd *abfd,
1402        void *ptr,
1403        unsigned long size));
1404  PTR backend_data;
1405 } bfd_target;
1406 bfd_target *EXFUN(bfd_find_target, (CONST char *, bfd *));
1407 CONST char **EXFUN(bfd_target_list, (void));
1408 boolean EXFUN(bfd_check_format, (bfd *abfd, bfd_format format));
1409 boolean EXFUN(bfd_set_format, (bfd *, bfd_format));
1410 CONST char *EXFUN(bfd_format_string, (bfd_format));
1411 #endif