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