include/bfd.h

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