/* A -*- C -*- header file for the bfd library */ /*** bfd.h -- The only header file required by users of the bfd library */ /* Copyright (C) 1990, 1991 Free Software Foundation, Inc. This file is part of BFD, the Binary File Diddler. BFD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. BFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with BFD; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ */ /* executable_object_p is gone -- you can check the bfd flags and call access() yourself */ #ifndef __BFD_H_SEEN__ #define __BFD_H_SEEN__ #include "ansidecl.h" #include "obstack.h" /* Make it easier to declare prototypes (puts conditional here) */ #ifndef PROTO # if __STDC__ # define PROTO(type, name, arglist) type name arglist # else # define PROTO(type, name, arglist) type name () # endif #endif #define BFD_VERSION "1.9" /* forward declaration */ typedef struct _bfd_struct bfd; /* I'm sure this is going to break something and someone is going to force me to change it. */ typedef enum boolean {false, true} boolean; /* FIXME-SOON: I hate it when types are invented for things that already have types. In this case, zero and non-zero are so common that true vs false makes me stop and read code each time I want to know if they mean true there was an error or true the function did something. I can't fix this particularly quickly, so I'll just skirt the issue for now. This WILL change soon. */ #define BFD_SUCCESS (true) #define BFD_FAILURE (false) /* Try to avoid breaking stuff */ typedef long int file_ptr; /* This is used to refer to locations inside a section's rawdata */ typedef unsigned long int rawdata_offset; typedef unsigned long bfd_vma; typedef unsigned long bfd_offset; typedef unsigned int flagword; /* 32 bits of flags */ /** File formats */ typedef enum bfd_format { bfd_unknown = 0, /* file format is unknown */ bfd_object, /* linker/assember/compiler output */ bfd_archive, /* object archive file */ bfd_core, /* core dump */ bfd_type_end} /* marks the end; don't use it! */ bfd_format; /* Object file flag values */ #define NO_FLAGS 0 #define HAS_RELOC 001 #define EXEC_P 002 #define HAS_LINENO 004 #define HAS_DEBUG 010 #define HAS_SYMS 020 #define HAS_LOCALS 040 #define DYNAMIC 0100 #define WP_TEXT 0200 #define D_PAGED 0400 /* This enum gives the object file's CPU architecture, in a global sense. E.g. what processor family does it belong to? There is another field, which indicates what processor within the family is in use. */ enum bfd_architecture { bfd_arch_unknown, /* File arch not known */ bfd_arch_obscure, /* File arch known, not one of these */ bfd_arch_m68k, /* Motorola 68xxx */ bfd_arch_vax, /* DEC Vax */ bfd_arch_i960, /* Intel 960 */ #define bfd_mach_i960_core 0 #define bfd_mach_i960_kb_sb 1 #define bfd_mach_i960_mc 2 #define bfd_mach_i960_xa 3 #define bfd_mach_i960_ca 4 #define bfd_mach_i960_ka_sa 5 bfd_arch_a29k, /* AMD 29000 */ bfd_arch_sparc, /* Sun (SPARC International) SPARC */ bfd_arch_mips, /* MIPS Rxxxx */ bfd_arch_i386, /* Intel 386 */ bfd_arch_ns32k, /* National Semiconductor 32xxx */ bfd_arch_tahoe, /* CCI/Harris Tahoe */ bfd_arch_i860, /* Intel 860 */ bfd_arch_romp, /* IBM ROMP RS/6000 */ bfd_arch_alliant, /* Alliant */ bfd_arch_convex, /* Convex */ bfd_arch_m88k, /* Motorola 88xxx */ bfd_arch_pyramid, /* Pyramid Technology */ bfd_arch_h8_300, /* Hitachi H8/300 */ bfd_arch_last, }; /* symbols and relocation */ typedef unsigned long symindex; #define BFD_NO_MORE_SYMBOLS ((symindex) ~0) typedef enum {bfd_symclass_unknown = 0, bfd_symclass_fcommon, /* fortran common symbols */ bfd_symclass_global, /* global symbol, what a surprise */ bfd_symclass_debugger, /* some debugger symbol */ bfd_symclass_undefined /* none known */ } symclass; typedef unsigned long symvalue; /* someday they may be 64-bit qtys */ typedef int symtype; /* Who knows, yet? */ typedef int bfd_size_type; /* Symbol cache classifications: (Bfd-Symbol-Flag_FOOBAR) */ #define BSF_NO_FLAGS 0x00 #define BSF_LOCAL 0x01 /* bfd_symclass_unknown */ #define BSF_GLOBAL 0x02 /* bfd_symclass_global */ #define BSF_IMPORT 0x04 #define BSF_EXPORT 0x08 #define BSF_UNDEFINED 0x10 /* bfd_symclass_undefined */ #define BSF_FORT_COMM 0x20 /* bfd_symclass_fcommon */ #define BSF_DEBUGGING 0x40 /* bfd_symclass_debugger */ #define BSF_ABSOLUTE 0x80 #define BSF_KEEP 0x10000 #define BSF_WARNING 0x20000 #define BSF_KEEP_G 0x80000 #define BSF_WEAK 0x100000 #define BSF_CTOR 0x200000 /* Symbol is a con/destructor */ #define BSF_FAKE 0x400000 /* SYmbol doesn't really exist */ #define BSF_OLD_COMMON 0x800000 /* Symbol used to be common, but now is allocated */ /* If symbol is fort_comm, then value is size, and this is the */ /* contents */ #define BFD_FORT_COMM_DEFAULT_VALUE 0 /* in some files the type of a symbol sometimes alters its location * in an output file - ie in coff a ISFCN symbol which is also C_EXT * symbol appears where it was declared and not at the end of a section. * This bit is set by the target bfd part to convey this information. */ #define BSF_NOT_AT_END 0x40000 /* general purpose part of a symbol * target specific parts will be found in libcoff.h, liba.out.h etc */ typedef struct symbol_cache_entry { struct _bfd_struct *the_bfd; /* Just a way to find out host type */ CONST char *name; symvalue value; flagword flags; struct sec_struct *section; PTR udata; /* Target-specific stuff */ } asymbol; #define bfd_get_section(x) ((x)->section) #define bfd_get_output_section(x) ((x)->section->output_section) #define bfd_set_section(x,y) ((x)->section) = (y) #define bfd_asymbol_base(x) ((x)->section?((x)->section->vma):0) #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + x->value) #define bfd_asymbol_name(x) ((x)->name) /* This is a type pun with struct ranlib on purpose! */ typedef struct { char *name; file_ptr file_offset; /* look here to find the file */ } carsym; /* to make these you call a carsymogen */ /* Relocation stuff */ /* Either: sym will point to a symbol and isextern will be 0, *OR* sym will be NULL and isextern will be a symbol type (eg N_TEXT) which means the location should be relocated relative to the segment origin. This is because we won't necessarily have a symbol which is guaranteed to point to the segment origin. */ typedef enum { bfd_reloc_ok, bfd_reloc_overflow, bfd_reloc_outofrange, bfd_reloc_continue, bfd_reloc_notsupported, bfd_reloc_other, bfd_reloc_undefined, bfd_reloc_dangerous} bfd_reloc_status_enum_type; typedef CONST struct rint_struct { unsigned int type; unsigned int rightshift; unsigned int size; unsigned int bitsize; boolean pc_relative; unsigned int bitpos; boolean absolute; boolean complain_on_overflow; bfd_reloc_status_enum_type (*special_function)(); char *name; boolean partial_inplace; /* Two mask fields, the src_mask is used to select what parts of the read in data are to be used in the relocation sum. Eg, if this was an 8 bit bit of data which we read and relocated, this would be 0x000000ff. When we have relocs which have an addend, such as sun4 extended relocs, the value in the offset part of a relocating field is garbage so we never use it. In this case the mask would be 0x00000000. The dst_mask is what parts of the instruction are replaced into the instruction. In most cases src_mask == dst_mask, except in the above special case, where dst_mask would be 0x000000ff, and src_mask would be 0x00000000. */ unsigned int src_mask; /* What things to take from the source */ unsigned int dst_mask; /* What things to put into the dest */ /* Does a pc rel offset already have the offset of the jump from the beginnining of the module in place - eg on the sun3, a pcrel instruction always has a negative number in place, containing the displacement from the beginning of the module. 88k bcs has a zero in there, so you have to work out the offset yourself. */ boolean pcrel_offset; } reloc_howto_type; #define HOWTO(CODE, RT,SIZE,BITSIZE, PCREL, BITPOS, ABS, OVERFLOW, SF, NAME, INPLACE, MASKSRC, MASKDST, PCRELDONE) \ {(unsigned)CODE,RT,SIZE,BITSIZE, PCREL, BITPOS,ABS,OVERFLOW,SF,NAME,INPLACE,MASKSRC,MASKDST,PCRELDONE} typedef unsigned char bfd_byte; typedef struct reloc_cache_entry { /* A pointer into the canonicalized table for the symbol */ asymbol **sym_ptr_ptr; rawdata_offset address; /* offset in section */ bfd_vma addend; /* addend for relocation value */ struct sec_struct *section; /* if sym is null this is the section */ reloc_howto_type *howto; } arelent; typedef struct relent_chain_struct { arelent relent; struct relent_chain_struct *next; } arelent_chain; /* Used in generating armaps. Perhaps just a forward definition would do? */ struct orl { /* output ranlib */ char **name; /* symbol name */ file_ptr pos; /* element number or file position */ int namidx; /* index into string table */ }; /* Linenumber stuff */ typedef struct lineno_cache_entry { unsigned int line_number; /* Linenumber from start of function*/ union { asymbol *sym; /* Function name */ unsigned long offset; /* Offset into section */ } u; } alent; /* object and core file sections */ /* Section flag definitions */ #define SEC_NO_FLAGS 000 #define SEC_ALLOC 001 #define SEC_LOAD 002 #define SEC_RELOC 004 #define SEC_BALIGN 010 #define SEC_READONLY 020 #define SEC_CODE 040 #define SEC_DATA 0100 #define SEC_ROM 0200 #define SEC_CONSTRUCTOR 0400 #define SEC_HAS_CONTENTS (0x200) typedef struct sec_struct { CONST char *name; struct sec_struct *next; flagword flags; bfd_vma vma; bfd_size_type size; /* The output_offset is the indent into the output section of this section. If this is the first section to go into an output section, this value will be 0... */ bfd_vma output_offset; struct sec_struct *output_section; unsigned int alignment_power; /* eg 4 aligns to 2^4*/ arelent *relocation; /* for input files */ arelent **orelocation; /* for output files */ unsigned reloc_count; file_ptr filepos; /* File position of section data */ file_ptr rel_filepos; /* File position of relocation info */ file_ptr line_filepos; struct user_section_struct *userdata; struct lang_output_section_struct *otheruserdata; int index; /* Which section is it 0..nth */ alent *lineno; unsigned int lineno_count; /* When a section is being output, this value changes as more * linenumbers are written out */ file_ptr moving_line_filepos; /* what the section number is in the target world */ unsigned int target_index; PTR used_by_bfd; /* If this is a constructor section then here is a list of relents */ arelent_chain *constructor_chain; } asection; #define align_power(addr, align) \ ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) typedef struct sec_struct *sec_ptr; #define bfd_section_name(bfd, ptr) ((ptr)->name) #define bfd_section_size(bfd, ptr) ((ptr)->size) #define bfd_section_vma(bfd, ptr) ((ptr)->vma) #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags) #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (val)), true) #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true) #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true) struct stat; /** Error handling */ typedef enum {no_error = 0, system_call_error, invalid_target, wrong_format, invalid_operation, no_memory, no_symbols, no_relocation_info, no_more_archived_files, malformed_archive, symbol_not_found, file_not_recognized, file_ambiguously_recognized, no_contents, bfd_error_nonrepresentable_section, invalid_error_code} bfd_ec; extern bfd_ec bfd_error; typedef struct { PROTO(void,(* nonrepresentable_section ),(CONST bfd *CONST abfd, CONST char *CONST name)); } bfd_error_vector_type; PROTO (char *, bfd_errmsg, ()); PROTO (void, bfd_perror, (CONST char *message)); typedef enum { bfd_print_symbol_name_enum, bfd_print_symbol_type_enum, bfd_print_symbol_all_enum, } bfd_print_symbol_enum_type; /* The BFD target structure. This structure is how to find out everything BFD knows about a target. It includes things like its byte order, name, what routines to call to do various operations, etc. Every BFD points to a target structure with its "xvec" member. */ /* Shortcut for declaring fields which are prototyped function pointers, while avoiding anguish on compilers that don't support protos. */ #define SDEF(ret, name, arglist) PROTO(ret,(*name),arglist) #define SDEF_FMT(ret, name, arglist) PROTO(ret,(*name[bfd_type_end]),arglist) /* These macros are used to dispatch to functions through the bfd_target vector. They are used in a number of macros further down in bfd.h, and are also used when calling various routines by hand inside the bfd implementation. The "arglist" argument must be parenthesized; it contains all the arguments to the called function. */ #define BFD_SEND(bfd, message, arglist) ((*((bfd)->xvec->message)) arglist) /* For operations which index on the bfd format */ #define BFD_SEND_FMT(bfd, message, arglist) \ (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) /* FIXME, these names should be rationalised with the names of the entry points which call them. Too bad we can't have one macro to define them both! */ typedef struct bfd_target { /* identifies the kind of target, eg SunOS4, Ultrix, etc */ char *name; /* This is bogus. Anything that can be told from the "flavour" by some user program should be an independent attribute that can be queried instead. FIXME. -- gnu@cygnus.com */ enum target_flavour_enum { bfd_target_aout_flavour_enum, bfd_target_coff_flavour_enum, bfd_target_ieee_flavour_enum, bfd_target_oasys_flavour_enum, bfd_target_srec_flavour_enum} flavour; boolean byteorder_big_p; /* Order of bytes in data sections */ boolean header_byteorder_big_p; /* Order of bytes in header */ flagword object_flags; /* these are the ones that may be set */ flagword section_flags; /* ditto */ char ar_pad_char; /* filenames in archives padded w/this char */ unsigned short ar_max_namelen; /* this could be a char too! */ /* Byte swapping for data */ /* Note that these don't take bfd as first arg. Certain other handlers could do the same. */ SDEF (long, bfd_getxlong, (bfd_byte *)); SDEF (void, bfd_putxlong, (unsigned long, bfd_byte *)); SDEF (short, bfd_getxshort, (bfd_byte *)); SDEF (void, bfd_putxshort, (int, bfd_byte *)); /* Byte swapping for headers */ SDEF (long, bfd_h_getxlong, (bfd_byte *)); SDEF (void, bfd_h_putxlong, (unsigned long, bfd_byte *)); SDEF (short, bfd_h_getxshort, (bfd_byte *)); SDEF (void, bfd_h_putxshort, (int, bfd_byte *)); /* Format-dependent */ SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));/* file fmt or 0 */ SDEF_FMT (boolean, _bfd_set_format, (bfd *)); /* make it an object file. */ /* All these are defined in JUMP_TABLE */ /* Core files */ SDEF (char *, _core_file_failing_command, (bfd *)); SDEF (int, _core_file_failing_signal, (bfd *)); SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *)); /* Archives */ SDEF (boolean, _bfd_slurp_armap, (bfd *)); SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *)); SDEF (void, _bfd_truncate_arname, (bfd *, CONST char *, char *)); SDEF (boolean, write_armap, (bfd *arch, unsigned int elength, struct orl *map, int orl_count, int stridx)); /* All the standard stuff */ SDEF (boolean, _close_and_cleanup, (bfd *)); /* free any allocated data */ SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR, file_ptr, int)); SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR, file_ptr, int)); SDEF (boolean, _new_section_hook, (bfd *, sec_ptr)); /* Symbols and relocation */ SDEF (unsigned int, _get_symtab_upper_bound, (bfd *)); SDEF (unsigned int, _bfd_canonicalize_symtab, (bfd *, asymbol **)); SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr)); SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **, asymbol**)); /* FIXME: For steve -- clean up later */ SDEF (asymbol *, _bfd_make_empty_symbol, (bfd *)); SDEF (void, _bfd_print_symbol, (bfd *, PTR, asymbol *, bfd_print_symbol_enum_type)); SDEF(alent *, _get_lineno, (bfd *, asymbol *)); /* This should perhaps be format-dependent, I don't know yet. -gnu */ SDEF (boolean, _bfd_set_arch_mach, (bfd *, enum bfd_architecture, unsigned long)); SDEF (bfd *, openr_next_archived_file, (bfd *arch, bfd *prev)); SDEF (boolean, _bfd_find_nearest_line, (bfd *abfd, asection *section, asymbol **symbols,bfd_vma offset, CONST char **file, CONST char **func, unsigned int *line)); SDEF (int, _bfd_stat_arch_elt, (bfd *, struct stat *)); SDEF (int, _bfd_sizeof_headers, (bfd *, boolean)); } bfd_target; /* The code that implements targets can initialize a jump table with this macro. It must name all its routines the same way (a prefix plus the standard routine suffix), or it must #define the routines that are not so named, before calling JUMP_TABLE in the initializer. */ /* Semi-portable string concatenation in cpp */ #ifndef CAT #ifdef __STDC__ #define CAT(a,b) a##b #else #define CAT(a,b) a/**/b #endif #endif #define JUMP_TABLE(NAME)\ CAT(NAME,_core_file_failing_command),\ CAT(NAME,_core_file_failing_signal),\ CAT(NAME,_core_file_matches_executable_p),\ CAT(NAME,_slurp_armap),\ CAT(NAME,_slurp_extended_name_table),\ CAT(NAME,_truncate_arname),\ CAT(NAME,_write_armap),\ CAT(NAME,_close_and_cleanup), \ CAT(NAME,_set_section_contents),\ CAT(NAME,_get_section_contents),\ CAT(NAME,_new_section_hook),\ CAT(NAME,_get_symtab_upper_bound),\ CAT(NAME,_get_symtab),\ CAT(NAME,_get_reloc_upper_bound),\ CAT(NAME,_canonicalize_reloc),\ CAT(NAME,_make_empty_symbol),\ CAT(NAME,_print_symbol),\ CAT(NAME,_get_lineno),\ CAT(NAME,_set_arch_mach),\ CAT(NAME,_openr_next_archived_file),\ CAT(NAME,_find_nearest_line),\ CAT(NAME,_generic_stat_arch_elt),\ CAT(NAME,_sizeof_headers) /* User program access to BFD facilities */ extern CONST short _bfd_host_big_endian; #define HOST_BYTE_ORDER_BIG_P (*(char *)&_bfd_host_big_endian) /* The bfd itself */ #define bfd_get_filename(abfd) ((abfd)->filename) #define bfd_get_format(abfd) ((abfd)->format) #define bfd_get_target(abfd) ((abfd)->xvec->name) #define bfd_get_file_flags(abfd) ((abfd)->flags) #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) #define bfd_my_archive(abfd) ((abfd)->my_archive); #define bfd_has_map(abfd) ((abfd)->has_armap) #define bfd_header_twiddle_required(abfd) \ ((((abfd)->xvec->header_byteorder_big_p) \ != (boolean)HOST_BYTE_ORDER_BIG_P) ? true:false) #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) #define bfd_usrdata(abfd) ((abfd)->usrdata) #define bfd_get_start_address(abfd) ((abfd)->start_address) #define bfd_get_symcount(abfd) ((abfd)->symcount) #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) #define bfd_count_sections(abfd) ((abfd)->section_count) #define bfd_get_architecture(abfd) ((abfd)->obj_arch) #define bfd_get_machine(abfd) ((abfd)->obj_machine) /* Finally! The BFD struct itself. This contains the major data about the file, and contains pointers to the rest of the data. To avoid dragging too many header files into every file that includes bfd.h, IOSTREAM has been declared as a "char *", and MTIME as a "long". Their correct types, to which they are cast when used, are "FILE *" and "time_t". If these had been declared as structs rather than typedefs, we wouldn't have this problem. */ struct _bfd_struct { CONST char *filename; /* could be null; filename user opened with */ bfd_target *xvec; /* operation jump table */ char *iostream; /* stdio FILE *, unless an archive element */ boolean cacheable; /* iostream can be closed if desired */ struct _bfd_struct *lru_prev; /* Used for file caching */ struct _bfd_struct *lru_next; /* Used for file caching */ file_ptr where; /* Where the file was when closed */ boolean opened_once; boolean mtime_set; /* Flag indicating mtime is available */ long mtime; /* File modified time */ int ifd; /* for output files, channel we locked. */ bfd_format format; enum bfd_direction {no_direction = 0, read_direction = 1, write_direction = 2, both_direction = 3} direction; flagword flags; /* format_specific */ /* Currently my_archive is tested before adding origin to anything. I believe that this can become always an add of origin, with origin set to 0 for non archive files */ file_ptr origin; /* for archive contents */ boolean output_has_begun; /* cf bfd_set_section_size */ asection *sections; /* Pointer to linked list of sections */ unsigned int section_count; /* The number of sections */ /* Some object file stuff */ bfd_vma start_address; /* for object files only, of course */ unsigned int symcount; /* used for input and output */ asymbol **outsymbols; /* symtab for output bfd */ enum bfd_architecture obj_arch; /* Architecture of object machine, eg m68k */ unsigned long obj_machine; /* Particular machine within arch, e.g. 68010 */ /* Archive stuff. strictly speaking we don't need all three bfd* vars, but doing so would allow recursive archives! */ PTR arelt_data; /* needed if this came from an archive */ struct _bfd_struct *my_archive; /* if this is an archive element */ struct _bfd_struct *next; /* output chain pointer */ struct _bfd_struct *archive_head; /* for output archive */ boolean has_armap; /* if an arch; has it an armap? */ PTR tdata; /* target-specific storage */ PTR usrdata; /* application-specific storage */ /* Should probably be enabled here always, so that library may be changed to switch this on and off, while user code may remain unchanged */ #ifdef BFD_LOCKS struct flock *lock; char *actual_name; /* for output files, name given to open() */ #endif /* Where all the allocated stuff under this BFD goes */ struct obstack memory; }; PROTO(PTR, bfd_alloc, (bfd *abfd, size_t size)); PROTO(PTR, bfd_zalloc,(bfd *abfd, size_t size)); PROTO(PTR, bfd_realloc,(bfd *abfd, PTR orig, size_t new)); PROTO(size_t, bfd_alloc_size,(bfd *abfd)); /* FIXME, these are broken! bfd_free references "Y" which is not a parameter. bfd_release frees the mentioned object AND EVERYTHING AFTER IT IN THE OBSTACK! -- gnu@cygnus.com */ #define bfd_free(x) (obstack_free(&(x->memory),y)) #define bfd_release(x,y) (obstack_free(&(x->memory),y)) PROTO (char *, bfd_printable_arch_mach,(enum bfd_architecture, unsigned long)); PROTO (char *, bfd_format_string, (bfd_format format)); PROTO (char**, bfd_target_list, ()); PROTO (bfd *, bfd_openr, (CONST char *filename, CONST char *target)); PROTO (bfd *, bfd_fdopenr, (CONST char *filename, CONST char *target, int fd)); PROTO (bfd *, bfd_openw, (CONST char *filename, CONST char *target)); PROTO (bfd *, bfd_create, (CONST char *filename, CONST bfd *abfd)); PROTO (boolean, bfd_close, (bfd *abfd)); PROTO (long, bfd_get_mtime, (bfd *abfd)); PROTO (bfd *, bfd_openr_next_archived_file, (bfd *obfd, bfd *last_file)); PROTO (boolean, bfd_set_archive_head, (bfd *output_archive, bfd *new_head)); PROTO (boolean, bfd_check_format, (bfd *abfd, bfd_format format)); PROTO (boolean, bfd_set_format, (bfd *abfd, bfd_format format)); PROTO (char *, bfd_core_file_failing_command, (bfd *abfd)); PROTO (int, bfd_core_file_failing_signal, (bfd *abfd)); PROTO (boolean, core_file_matches_executable_p, (bfd *core_bfd, bfd *exec_bfd)); PROTO (sec_ptr, bfd_get_section_by_name, (bfd *abfd, CONST char *name)); PROTO (void, bfd_map_over_sections, (bfd *abfd, void (*operation)(), PTR user_storage)); PROTO (sec_ptr, bfd_make_section, (bfd *abfd, CONST char *CONST name)); PROTO (boolean, bfd_set_section_flags, (bfd *abfd, sec_ptr section, flagword flags)); PROTO (boolean, bfd_set_file_flags, (bfd *abfd, flagword flags)); PROTO (boolean, bfd_arch_compatible, (bfd *abfd, bfd *bbfd, enum bfd_architecture *res_arch, unsigned long *res_machine)); PROTO (boolean, bfd_set_section_size, (bfd *abfd, sec_ptr ptr, unsigned long val)); PROTO (boolean, bfd_get_section_contents, (bfd *abfd, sec_ptr section, PTR location, file_ptr offset, int count)); PROTO (boolean, bfd_set_section_contents, (bfd *abfd, sec_ptr section, PTR location, file_ptr offset, int count)); PROTO (unsigned long, bfd_get_next_mapent, (bfd *abfd, symindex prev, carsym **entry)); PROTO (bfd *, bfd_get_elt_at_index, (bfd *abfd, int index)); PROTO (boolean, bfd_set_symtab, (bfd *abfd, asymbol **location, unsigned int symcount)); PROTO (unsigned int, get_reloc_upper_bound, (bfd *abfd, sec_ptr asect)); PROTO (unsigned int, bfd_canonicalize_reloc, (bfd *abfd, sec_ptr asect, arelent **location, asymbol **canon)); PROTO (void, bfd_set_reloc, (bfd *abfd, sec_ptr asect, arelent **location, unsigned int count)); PROTO (boolean, bfd_set_start_address, (bfd *,bfd_vma)); PROTO (void, bfd_print_symbol_vandf, (PTR, asymbol *)); PROTO (bfd_reloc_status_enum_type, bfd_perform_relocation, (bfd *, arelent*, PTR, asection *, bfd*)); PROTO (bfd_vma, bfd_log2, (bfd_vma)); #define bfd_symbol_same_target(abfd, symbol) \ ( ( ((symbol)->the_bfd->xvec) == (abfd)->xvec) ? true:false) PROTO(boolean, bfd_scan_arch_mach,(CONST char *, enum bfd_architecture *, unsigned long *)); /* For speed we turn calls to these interface routines directly into jumps through the transfer vector. This makes error-checking somewhat confusing; the user basically has to read the documentation since there are no longer prototypes, only declarations in the xfer vector (which should be enough for some compilers). To bad the preprocessor is too dumb to allow us to clean this up with a macro. */ #define bfd_set_arch_mach(abfd, arch, mach) \ BFD_SEND (abfd, _bfd_set_arch_mach, (abfd, arch, mach)) #define bfd_sizeof_headers(abfd, reloc) \ BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) #define bfd_symbol_value(abfd, idx) \ BFD_SEND (abfd, _bfd_symbol_value, (abfd, idx)) #define bfd_symbol_name(abfd, idx) \ BFD_SEND (abfd, _bfd_symbol_name, (abfd, idx)) #define bfd_get_first_symbol(abfd) \ BFD_SEND (abfd, _bfd_get_first_symbol, (abfd)) #define bfd_get_next_symbol(abfd, oidx) \ BFD_SEND (abfd, _bfd_get_next_symbol, (abfd, oidx)) #define bfd_classify_symbol(abfd, idx) \ BFD_SEND (abfd, _bfd_classify_symbol, (abfd, idx)) #define bfd_symbol_hasclass(abfd, idx, class) \ BFD_SEND (abfd, _bfd_symbol_hasclass, (abfd, idx, class)) #define get_symtab_upper_bound(abfd) \ BFD_SEND (abfd, _get_symtab_upper_bound, (abfd)) #define bfd_canonicalize_symtab(abfd, location) \ BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) #define bfd_make_empty_symbol(abfd) \ BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) #define bfd_print_symbol(abfd, file, symbol, how) \ BFD_SEND (abfd, _bfd_print_symbol, (abfd, file, symbol, how)) #define bfd_get_lineno(abfd, symbol) \ BFD_SEND (abfd, _get_lineno, (abfd, symbol)) #define bfd_stat_arch_elt(abfd, buf) \ BFD_SEND(abfd, _bfd_stat_arch_elt, (abfd, buf)) #define bfd_find_nearest_line(abfd, section, symbols, offset,filename_ptr, func, line_ptr) \ BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, section,symbols, offset, filename_ptr, func, line_ptr)) /* Some byte-swapping i/o operations */ #define LONG_SIZE 4 #define SHORT_SIZE 2 #define BYTE_SIZE 1 #define bfd_putchar(abfd, val, ptr) (*((char *)ptr) = (char)val) #define bfd_getchar(abfd, ptr) (*((char *)ptr)) #define bfd_putlong(abfd, val, ptr) BFD_SEND(abfd, bfd_putxlong, (val,ptr)) #define bfd_getlong(abfd, ptr) BFD_SEND(abfd, bfd_getxlong, (ptr)) #define bfd_putshort(abfd, val, ptr) BFD_SEND(abfd, bfd_putxshort, (val,ptr)) #define bfd_getshort(abfd, ptr) BFD_SEND(abfd, bfd_getxshort, (ptr)) #define bfd_h_putchar(abfd, val, ptr) bfd_putchar (abfd, val, ptr) #define bfd_h_getchar(abfd, ptr) bfd_getchar (abfd, ptr) #define bfd_h_putlong(abfd, val, ptr) BFD_SEND(abfd, bfd_h_putxlong, (val, (bfd_byte *) ptr)) #define bfd_h_getlong(abfd, ptr) BFD_SEND(abfd, bfd_h_getxlong, ((bfd_byte *) ptr)) #define bfd_h_putshort(abfd, val, ptr) BFD_SEND(abfd, bfd_h_putxshort,(val,ptr)) #define bfd_h_getshort(abfd, ptr) BFD_SEND(abfd, bfd_h_getxshort,(ptr)) /* General purpose one fits all. The do { } while (0) makes a single statement out of it, for use in things like nested if-statements. USE OF THESE MACROS IS DISCOURAGED. THEY ASSUME THAT THE HOST AND TARGET FIELD ALIGNMENT AND SIZES ARE THE SAME. TARGET STRUCTS SHOULD BE MODELED AS BYTE ARRAYS INSTEAD, TO AVOID THESE ASSUMPTIONS. */ #define bfd_h_put_x(abfd, val, ptr) \ do { \ if (sizeof(*(ptr)) == LONG_SIZE) \ bfd_h_putlong (abfd, val, (bfd_byte*)(ptr));\ else if (sizeof(*(ptr)) == SHORT_SIZE) \ bfd_h_putshort (abfd, val, (bfd_byte *)(ptr));\ else if (sizeof(*(ptr)) == BYTE_SIZE) \ bfd_h_putchar (abfd, val, (bfd_byte *)(ptr));\ else abort(); } while (0) #define bfd_h_get_x(abfd, ptr) \ ((sizeof(*(ptr))==LONG_SIZE) ? bfd_h_getlong (abfd, (bfd_byte *)(ptr)):\ (sizeof(*(ptr))==SHORT_SIZE) ? bfd_h_getshort(abfd, (bfd_byte *)(ptr)):\ (sizeof(*(ptr))==BYTE_SIZE) ? bfd_h_getchar (abfd, (bfd_byte *)(ptr)):\ (abort(),1) ) #ifdef GNU960 #define BFD_COFF_FORMAT bfd_target_coff_flavour_enum #define BFD_BOUT_FORMAT bfd_target_aout_flavour_enum /* * Return nonzero iff specified bfd is for big-endian target */ #define BFD_BIG_ENDIAN_FILE_P(abfd) \ ((abfd)->xvec->header_byteorder_big_p == true) /* * Return nonzero iff specified bfd is for coff target */ #define BFD_COFF_FILE_P(abfd) ((abfd)->xvec->flavour == BFD_COFF_FORMAT) /* * The names of the only targets the GNU/960 release cares about */ #define BFD_BIG_COFF_TARG "coff-Intel-big" #define BFD_LITTLE_COFF_TARG "coff-Intel-little" #define BFD_BIG_BOUT_TARG "b.out.big" #define BFD_LITTLE_BOUT_TARG "b.out.little" extern PROTO (char *, bfd_make_targ_name,( enum target_flavour_enum format, int bigendian)); #endif /* GNU960 */ #endif /* __BFD_H_SEEN__ */