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