X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=include%2Fbfd.h;h=dd3ede9edfbf088b0e3e10865c2168acc0151ae2;hb=808566e89a9fa306dc0a4c73061eb4e89f3ff6b0;hp=132e3599794548e4f4afaad121e8ef47b9633991;hpb=c3089ec904b4a3a7d99449a067aaec6119eea4a2;p=deliverable%2Fbinutils-gdb.git diff --git a/include/bfd.h b/include/bfd.h index 132e359979..dd3ede9edf 100644 --- a/include/bfd.h +++ b/include/bfd.h @@ -1,5 +1,7 @@ -/* A -*- C -*- header file for the bfd library - Copyright 1990, 1991 Free Software Foundation, Inc. +/* Main header file for the bfd library -- portable access to object files. + ==> The bfd.h file is generated from bfd-in.h and various .c files; if you + ==> change it, your changes will probably be lost. + Copyright 1990, 1991, 1992 Free Software Foundation, Inc. Contributed by Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -20,8 +22,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* bfd.h -- The only header file required by users of the bfd library -This file is generated from various .c files, if you change it, your -bits may be lost. +The bfd.h file is generated from bfd-in.h and various .c files; if you +change it, your changes will probably be lost. All the prototypes and definitions following the comment "THE FOLLOWING IS EXTRACTED FROM THE SOURCE" are extracted from the source files for @@ -43,16 +45,7 @@ here. */ #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 "0.18" +#define BFD_VERSION "2.0" /* forward declaration */ typedef struct _bfd bfd; @@ -65,8 +58,15 @@ typedef struct _bfd bfd; /* Yup, SVR4 has a "typedef enum boolean" in -fnf */ typedef enum bfd_boolean {false, true} boolean; -/* Try to avoid breaking stuff */ -typedef long int file_ptr; +/* A pointer to a position in a file. */ +/* FIXME: This should be using off_t from . + For now, try to avoid breaking stuff by not including here. + This will break on systems with 64-bit file offsets (e.g. 4.4BSD). + Probably the best long-term answer is to avoid using file_ptr AND off_t + in this header file, and to handle this in the BFD implementation + rather than in its interface. */ +/* typedef off_t file_ptr; */ +typedef long int file_ptr; /* Support for different sizes of target format ints and addresses */ @@ -106,17 +106,17 @@ typedef enum bfd_format { 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 - +#define NO_FLAGS 0x00 +#define HAS_RELOC 0x01 +#define EXEC_P 0x02 +#define HAS_LINENO 0x04 +#define HAS_DEBUG 0x08 +#define HAS_SYMS 0x10 +#define HAS_LOCALS 0x20 +#define DYNAMIC 0x40 +#define WP_TEXT 0x80 +#define D_PAGED 0x100 +#define BFD_IS_RELAXABLE 0x200 /* symbols and relocation */ @@ -180,14 +180,17 @@ typedef struct lineno_cache_entry { typedef struct sec *sec_ptr; +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0) +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0) +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0) #define bfd_section_name(bfd, ptr) ((ptr)->name) #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr)) #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_flags(bfd, ptr) ((ptr)->flags + 0) #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_vma(bfd, ptr, val) (((ptr)->vma = (val)), ((ptr)->user_set_vma = true), 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) @@ -203,31 +206,30 @@ typedef enum bfd_error { symbol_not_found, file_not_recognized, file_ambiguously_recognized, no_contents, bfd_error_nonrepresentable_section, - no_debug_section, + no_debug_section, bad_value, invalid_error_code} bfd_ec; extern bfd_ec bfd_error; struct reloc_cache_entry; -struct bfd_seclet_struct ; +struct bfd_seclet; typedef struct bfd_error_vector { - PROTO(void,(* nonrepresentable_section ),(CONST bfd *CONST abfd, - CONST char *CONST name)); - PROTO(void,(* undefined_symbol),(CONST struct reloc_cache_entry *rel, - CONST struct bfd_seclet_struct *sec - )); - PROTO(void, (* reloc_value_truncated),(CONST struct + void (* nonrepresentable_section ) PARAMS ((CONST bfd *CONST abfd, + CONST char *CONST name)); + void (* undefined_symbol) PARAMS ((CONST struct reloc_cache_entry *rel, + CONST struct bfd_seclet *sec)); + void (* reloc_value_truncated) PARAMS ((CONST struct reloc_cache_entry *rel, - struct bfd_seclet_struct *sec)); + struct bfd_seclet *sec)); - PROTO(void, (* reloc_dangerous),(CONST struct reloc_cache_entry *rel, - CONST struct bfd_seclet_struct *sec)); + void (* reloc_dangerous) PARAMS ((CONST struct reloc_cache_entry *rel, + CONST struct bfd_seclet *sec)); } bfd_error_vector_type; -PROTO (char *, bfd_errmsg, (bfd_ec error_tag)); -PROTO (void, bfd_perror, (CONST char *message)); +CONST char *bfd_errmsg PARAMS ((bfd_ec error_tag)); +void bfd_perror PARAMS ((CONST char *message)); typedef enum bfd_print_symbol @@ -284,13 +286,7 @@ CAT(NAME,_bfd_debug_info_accumulate),\ CAT(NAME,_bfd_get_relocated_section_contents),\ CAT(NAME,_bfd_relax_section) -#define COFF_SWAP_TABLE \ - coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in, \ - coff_swap_aux_out, coff_swap_sym_out, \ - coff_swap_lineno_out, coff_swap_reloc_out, \ - coff_swap_filehdr_out, coff_swap_aouthdr_out, \ - coff_swap_scnhdr_out - +#define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table /* User program access to BFD facilities */ @@ -324,32 +320,37 @@ extern CONST short _bfd_host_big_endian; #define bfd_get_architecture(abfd) ((abfd)->obj_arch) #define bfd_get_machine(abfd) ((abfd)->obj_machine) - +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) #define BYTE_SIZE 1 #define SHORT_SIZE 2 #define LONG_SIZE 4 +/* And more from the source. */ +void +bfd_init PARAMS ((void)); +bfd * +bfd_openr PARAMS ((CONST char *filename, CONST char*target)); -/* ANd more from the source */ +bfd * +bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd)); +bfd * +bfd_openw PARAMS ((CONST char *filename, CONST char *target)); +boolean +bfd_close PARAMS ((bfd *)); +boolean +bfd_close_all_done PARAMS ((bfd *)); +bfd_size_type +bfd_alloc_size PARAMS ((bfd *abfd)); +bfd * +bfd_create PARAMS ((CONST char *filename, bfd *template)); - - - -void EXFUN(bfd_init, (void)); -bfd *EXFUN(bfd_openr, (CONST char *filename, CONST char*target)); -bfd *EXFUN(bfd_fdopenr, (CONST char *filename, CONST char *target, int fd)); -bfd *EXFUN(bfd_openw, (CONST char *filename, CONST char *target)); -boolean EXFUN(bfd_close, (bfd *)); -boolean EXFUN(bfd_close_all_done, (bfd *)); -bfd_size_type EXFUN(bfd_alloc_size, (bfd *abfd)); -bfd *EXFUN(bfd_create, (CONST char *filename, bfd *template)); #define bfd_put_8(abfd, val, ptr) \ (*((char *)ptr) = (char)val) #define bfd_get_8(abfd, ptr) \ @@ -477,9 +478,15 @@ typedef struct sec #define SEC_NEVER_LOAD 0x400 + /* The section is a shared library section. The linker must leave + these completely alone, as the vma and size are used when + the executable is loaded. */ + +#define SEC_SHARED_LIBRARY 0x800 bfd_vma vma; + boolean user_set_vma; /* The size of the section in bytes, as it will be output. contains a value even if the section has no contents (eg, the @@ -576,8 +583,8 @@ typedef struct sec /* A symbol which points at this section only */ struct symbol_cache_entry *symbol; struct symbol_cache_entry **symbol_ptr_ptr; - struct bfd_seclet_struct *seclets_head; - struct bfd_seclet_struct *seclets_tail; + struct bfd_seclet *seclets_head; + struct bfd_seclet *seclets_tail; } asection ; @@ -599,25 +606,41 @@ typedef struct sec (section->reloc_done ? (abort(),1): (section)->_raw_size) #define bfd_get_section_size_after_reloc(section) \ ((section->reloc_done) ? (section)->_cooked_size: (abort(),1)) -asection *EXFUN(bfd_get_section_by_name, (bfd *abfd, CONST char *name)); -asection *EXFUN(bfd_make_section_old_way, (bfd *, CONST char *name)); -asection * EXFUN(bfd_make_section, (bfd *, CONST char *name)); -boolean EXFUN(bfd_set_section_flags, (bfd *, asection *, flagword)); -void EXFUN(bfd_map_over_sections, (bfd *abfd, +asection * +bfd_get_section_by_name PARAMS ((bfd *abfd, CONST char *name)); + +asection * +bfd_make_section_old_way PARAMS ((bfd *, CONST char *name)); + +asection * +bfd_make_section PARAMS ((bfd *, CONST char *name)); + +boolean +bfd_set_section_flags PARAMS ((bfd *, asection *, flagword)); + +void +bfd_map_over_sections PARAMS ((bfd *abfd, void (*func)(bfd *abfd, asection *sect, PTR obj), PTR obj)); -boolean EXFUN(bfd_set_section_size, (bfd *, asection *, bfd_size_type val)); -boolean EXFUN(bfd_set_section_contents - , (bfd *abfd, + +boolean +bfd_set_section_size PARAMS ((bfd *, asection *, bfd_size_type val)); + +boolean +bfd_set_section_contents + PARAMS ((bfd *abfd, asection *section, PTR data, file_ptr offset, bfd_size_type count)); -boolean EXFUN(bfd_get_section_contents - , (bfd *abfd, asection *section, PTR location, + +boolean +bfd_get_section_contents + PARAMS ((bfd *abfd, asection *section, PTR location, file_ptr offset, bfd_size_type count)); + enum bfd_architecture { bfd_arch_unknown, /* File arch not known */ @@ -644,7 +667,7 @@ enum bfd_architecture bfd_arch_sparc, /* SPARC */ bfd_arch_mips, /* MIPS Rxxxx */ bfd_arch_i386, /* Intel 386 */ - bfd_arch_ns32k, /* National Semiconductor 32xxx */ + bfd_arch_we32k, /* AT&T WE32xxx */ bfd_arch_tahoe, /* CCI/Harris Tahoe */ bfd_arch_i860, /* Intel 860 */ bfd_arch_romp, /* IBM ROMP PC/RT */ @@ -654,9 +677,12 @@ enum bfd_architecture bfd_arch_pyramid, /* Pyramid Technology */ bfd_arch_h8300, /* Hitachi H8/300 */ bfd_arch_rs6000, /* IBM RS/6000 */ + bfd_arch_hppa, /* HP PA RISC */ + bfd_arch_z8k, /* Zilog Z8000 */ +#define bfd_mach_z8001 1 +#define bfd_mach_z8002 2 bfd_arch_last }; -typedef int bfd_reloc_code_type; typedef struct bfd_arch_info { @@ -667,40 +693,63 @@ typedef struct bfd_arch_info long mach; char *arch_name; CONST char *printable_name; + unsigned int section_align_power; /* true if this is the default machine for the architecture */ - unsigned int section_align_power; boolean the_default; - CONST struct bfd_arch_info * EXFUN((*compatible), - (CONST struct bfd_arch_info *a, - CONST struct bfd_arch_info *b)); - - boolean EXFUN((*scan),(CONST struct bfd_arch_info *,CONST char *)); - unsigned int EXFUN((*disassemble),(bfd_vma addr, CONST char *data, - PTR stream)); - CONST struct reloc_howto_struct *EXFUN((*reloc_type_lookup), - (CONST struct bfd_arch_info *, - bfd_reloc_code_type code)); + CONST struct bfd_arch_info * (*compatible) + PARAMS ((CONST struct bfd_arch_info *a, + CONST struct bfd_arch_info *b)); + + boolean (*scan) PARAMS ((CONST struct bfd_arch_info *, CONST char *)); + /* How to disassemble an instruction, producing a printable + representation on a specified stdio stream. This isn't + defined for most processors at present, because of the size + of the additional tables it would drag in, and because gdb + wants to use a different interface. */ + unsigned int (*disassemble) PARAMS ((bfd_vma addr, CONST char *data, + PTR stream)); struct bfd_arch_info *next; - } bfd_arch_info_type; -CONST char *EXFUN(bfd_printable_name, (bfd *abfd)); -bfd_arch_info_type *EXFUN(bfd_scan_arch, (CONST char *)); -CONST bfd_arch_info_type *EXFUN(bfd_arch_get_compatible, ( +CONST char * +bfd_printable_name PARAMS ((bfd *abfd)); + +bfd_arch_info_type * +bfd_scan_arch PARAMS ((CONST char *)); + +CONST bfd_arch_info_type * +bfd_arch_get_compatible PARAMS (( CONST bfd *abfd, CONST bfd *bbfd)); -void EXFUN(bfd_set_arch_info, (bfd *, bfd_arch_info_type *)); -enum bfd_architecture EXFUN(bfd_get_arch, (bfd *abfd)); -unsigned long EXFUN(bfd_get_mach, (bfd *abfd)); -unsigned int EXFUN(bfd_arch_bits_per_byte, (bfd *abfd)); -unsigned int EXFUN(bfd_arch_bits_per_address, (bfd *abfd)); -bfd_arch_info_type * EXFUN(bfd_get_arch_info, (bfd *)); -bfd_arch_info_type *EXFUN(bfd_lookup_arch - , (enum bfd_architecture + +void +bfd_set_arch_info PARAMS ((bfd *, bfd_arch_info_type *)); + +enum bfd_architecture +bfd_get_arch PARAMS ((bfd *abfd)); + +unsigned long +bfd_get_mach PARAMS ((bfd *abfd)); + +unsigned int +bfd_arch_bits_per_byte PARAMS ((bfd *abfd)); + +unsigned int +bfd_arch_bits_per_address PARAMS ((bfd *abfd)); + +bfd_arch_info_type * +bfd_get_arch_info PARAMS ((bfd *)); + +bfd_arch_info_type * +bfd_lookup_arch + PARAMS ((enum bfd_architecture arch, long machine)); -CONST char * EXFUN(bfd_printable_arch_mach - , (enum bfd_architecture arch, unsigned long machine)); + +CONST char * +bfd_printable_arch_mach + PARAMS ((enum bfd_architecture arch, unsigned long machine)); + typedef enum bfd_reloc_status { /* No errors detected */ @@ -763,10 +812,11 @@ typedef CONST struct reloc_howto_struct unsigned int rightshift; /* The size of the item to be relocated - 0, is one byte, 1 is 2 - bytes, 3 is four bytes. */ - unsigned int size; + bytes, 3 is four bytes. A -ve value indicates that the + result is to be subtracted from the data*/ + int size; - /* Now obsolete */ + /* Now obsolete. But m68k-coff still uses it. */ unsigned int bitsize; /* Notes that the relocation is relative to the location in the @@ -775,11 +825,12 @@ typedef CONST struct reloc_howto_struct being relocated. */ boolean pc_relative; - /* Now obsolete */ unsigned int bitpos; +#if 1 /* Now obsolete */ boolean absolute; +#endif /* Causes the relocation routine to return an error if overflow is detected when relocating. */ @@ -789,12 +840,13 @@ typedef CONST struct reloc_howto_struct called rather than the normal function. This allows really strange relocation methods to be accomodated (eg, i960 callj instructions). */ - bfd_reloc_status_type EXFUN ((*special_function), - (bfd *abfd, + bfd_reloc_status_type (*special_function) + PARAMS ((bfd *abfd, arelent *reloc_entry, struct symbol_cache_entry *symbol, PTR data, - asection *input_section)); + asection *input_section, + bfd *output_bfd)); /* The textual name of the relocation type. */ char *name; @@ -849,13 +901,16 @@ typedef struct relent_chain { struct relent_chain *next; } arelent_chain; bfd_reloc_status_type -EXFUN(bfd_perform_relocation - , (bfd * abfd, + +bfd_perform_relocation + PARAMS ((bfd * abfd, arelent *reloc_entry, PTR data, asection *input_section, bfd *output_bfd)); + typedef enum bfd_reloc_code_real + { /* 16 bits wide, simple reloc */ BFD_RELOC_16, @@ -873,16 +928,60 @@ typedef enum bfd_reloc_code_real moment probably a 32 bit wide abs address, but the cpu can choose. */ - BFD_RELOC_CTOR + BFD_RELOC_CTOR, + + /* 32 bits wide, simple reloc */ + BFD_RELOC_32, + /* 32 bits, PC-relative */ + BFD_RELOC_32_PCREL, + + /* High 22 bits of 32-bit value; simple reloc. */ + BFD_RELOC_HI22, + /* Low 10 bits. */ + BFD_RELOC_LO10, + + /* Reloc types used for i960/b.out. */ + BFD_RELOC_24_PCREL, + BFD_RELOC_I960_CALLJ, + + BFD_RELOC_16_PCREL, + /* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit + word displacement, e.g. for SPARC) */ + BFD_RELOC_32_PCREL_S2, + + /* now for the sparc/elf codes */ + BFD_RELOC_NONE, /* actually used */ + BFD_RELOC_SPARC_WDISP22, + BFD_RELOC_SPARC22, + BFD_RELOC_SPARC13, + BFD_RELOC_SPARC_BASE13, + BFD_RELOC_SPARC_GOT10, + BFD_RELOC_SPARC_GOT13, + BFD_RELOC_SPARC_GOT22, + BFD_RELOC_SPARC_PC10, + BFD_RELOC_SPARC_PC22, + BFD_RELOC_SPARC_WPLT30, + BFD_RELOC_SPARC_COPY, + BFD_RELOC_SPARC_GLOB_DAT, + BFD_RELOC_SPARC_JMP_SLOT, + BFD_RELOC_SPARC_RELATIVE, + BFD_RELOC_SPARC_UA32, + + /* this one is a.out specific? */ + BFD_RELOC_SPARC_BASE22, + + /* this must be the highest numeric value */ + BFD_RELOC_UNUSED } bfd_reloc_code_real_type; CONST struct reloc_howto_struct * -EXFUN(bfd_reloc_type_lookup - , (CONST bfd_arch_info_type *arch, bfd_reloc_code_type code)); + +bfd_reloc_type_lookup PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); + typedef struct symbol_cache_entry { /* A pointer to the BFD which owns the symbol. This information is necessary so that a back end can work out what additional - (invisible to the application writer) information is carried + information (invisible to the application writer) is carried with the symbol. */ struct _bfd *the_bfd; @@ -906,7 +1005,7 @@ typedef struct symbol_cache_entry value is the offset into the section of the data. */ #define BSF_GLOBAL 0x02 - /* Obsolete */ + /* Obsolete; should be deleted? */ #define BSF_IMPORT 0x04 /* The symbol has global scope, and is exported. The value is @@ -914,7 +1013,7 @@ typedef struct symbol_cache_entry #define BSF_EXPORT 0x08 /* The symbol is undefined. <> in <>. The value has - no meaning. */ + no meaning. Obsolete; should be deleted? */ #define BSF_UNDEFINED_OBS 0x10 /* The symbol is common, initialized to zero; default in @@ -929,15 +1028,16 @@ typedef struct symbol_cache_entry meaning. */ #define BSF_DEBUGGING 0x40 - /* Used by the linker */ + /* Used by the linker. Should be part of app_data now. */ #define BSF_KEEP 0x10000 #define BSF_KEEP_G 0x80000 - /* Unused */ + /* Unused; should be deleted? */ #define BSF_WEAK 0x100000 #define BSF_CTOR 0x200000 - /* This symbol was created to point to a section */ + /* This symbol was created to point to a section, e.g. ELF's + STT_SECTION symbols. */ #define BSF_SECTION_SYM 0x400000 /* The symbol used to be a common symbol, but now it is @@ -967,7 +1067,11 @@ typedef struct symbol_cache_entry /* Signal that the symbol is indirect. The value of the symbol is a pointer to an undefined asymbol which contains the name to use instead. */ -#define BSF_INDIRECT 0x4000000 +#define BSF_INDIRECT 0x4000000 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ +#define BSF_FILE 0x08000000 flagword flags; @@ -978,7 +1082,10 @@ typedef struct symbol_cache_entry /* Back end special data. This is being phased out in favour of making this a union. */ - PTR udata; + PTR udata; + + /* Application data. */ + union { unsigned long aflags; PTR aptr; } app_data; } asymbol; #define get_symtab_upper_bound(abfd) \ @@ -986,11 +1093,19 @@ typedef struct symbol_cache_entry #define bfd_canonicalize_symtab(abfd, location) \ BFD_SEND (abfd, _bfd_canonicalize_symtab,\ (abfd, location)) -boolean EXFUN(bfd_set_symtab , (bfd *, asymbol **, unsigned int )); -void EXFUN(bfd_print_symbol_vandf, (PTR file, asymbol *symbol)); +boolean +bfd_set_symtab PARAMS ((bfd *, asymbol **, unsigned int )); + +void +bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol)); + #define bfd_make_empty_symbol(abfd) \ BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) -int EXFUN(bfd_decode_symclass, (asymbol *symbol)); +#define bfd_make_debug_symbol(abfd,ptr,size) \ + BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) +int +bfd_decode_symclass PARAMS ((asymbol *symbol)); + struct _bfd { /* The filename the application opened the BFD with. */ @@ -1108,11 +1223,12 @@ struct _bfd struct ieee_ar_data_struct *ieee_ar_data; struct srec_data_struct *srec_data; struct tekhex_data_struct *tekhex_data; - struct elf_obj_tdata_struct *elf_obj_data; - struct elf_core_tdata_struct *elf_core_data; + struct elf_obj_tdata *elf_obj_data; struct bout_data_struct *bout_data; struct sun_core_struct *sun_core_data; struct trad_core_struct *trad_core_data; + struct hppa_data_struct *hppa_data; + struct hppa_core_struct *hppa_core_data; PTR any; } tdata; @@ -1122,28 +1238,42 @@ struct _bfd /* Where all the allocated stuff under this BFD goes */ struct obstack memory; + /* Is this really needed in addition to usrdata? */ asymbol **ld_symbols; }; -unsigned int EXFUN(bfd_get_reloc_upper_bound, (bfd *abfd, asection *sect)); -unsigned int EXFUN(bfd_canonicalize_reloc - , (bfd *abfd, +unsigned int +bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect)); + +unsigned int +bfd_canonicalize_reloc + PARAMS ((bfd *abfd, asection *sec, arelent **loc, asymbol **syms)); -boolean EXFUN(bfd_set_file_flags, (bfd *abfd, flagword flags)); -void EXFUN(bfd_set_reloc - , (bfd *abfd, asection *sec, arelent **rel, unsigned int count) + +boolean +bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags)); + +void +bfd_set_reloc + PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count) ); -boolean EXFUN(bfd_set_start_address, (bfd *, bfd_vma)); -long EXFUN(bfd_get_mtime, (bfd *)); + +boolean +bfd_set_start_address PARAMS ((bfd *, bfd_vma)); + +long +bfd_get_mtime PARAMS ((bfd *)); + #define bfd_sizeof_headers(abfd, reloc) \ BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line)) + /* Do these three do anything useful at all, for any back end? */ #define bfd_debug_info_start(abfd) \ BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) @@ -1153,59 +1283,40 @@ long EXFUN(bfd_get_mtime, (bfd *)); #define bfd_debug_info_accumulate(abfd, section) \ BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) + #define bfd_stat_arch_elt(abfd, stat) \ BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) -#define bfd_coff_swap_aux_in(a,e,t,c,i) \ - BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i)) - -#define bfd_coff_swap_sym_in(a,e,i) \ - BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i)) - -#define bfd_coff_swap_lineno_in(a,e,i) \ - BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i)) - #define bfd_set_arch_mach(abfd, arch, mach)\ BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) -#define bfd_coff_swap_reloc_out(abfd, i, o) \ - BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o)) - -#define bfd_coff_swap_lineno_out(abfd, i, o) \ - BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o)) +#define bfd_get_relocated_section_contents(abfd, seclet, data) \ + BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet, data)) + +#define bfd_relax_section(abfd, section, symbols) \ + BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols)) +symindex +bfd_get_next_mapent PARAMS ((bfd *, symindex previous, carsym ** sym)); -#define bfd_coff_swap_aux_out(abfd, i, t,c,o) \ - BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o)) +boolean +bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head)); -#define bfd_coff_swap_sym_out(abfd, i,o) \ - BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o)) +bfd * +bfd_get_elt_at_index PARAMS ((bfd * archive, int index)); -#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ - BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o)) +bfd* +bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous)); -#define bfd_coff_swap_filehdr_out(abfd, i,o) \ - BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o)) +CONST char * +bfd_core_file_failing_command PARAMS ((bfd *)); -#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ - BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o)) +int +bfd_core_file_failing_signal PARAMS ((bfd *)); -#define bfd_get_relocated_section_contents(abfd, seclet) \ - BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet)) +boolean +core_file_matches_executable_p + PARAMS ((bfd *core_bfd, bfd *exec_bfd)); -#define bfd_relax_section(abfd, section, symbols) \ - BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols)) -symindex EXFUN(bfd_get_next_mapent, (bfd *, symindex previous, carsym ** sym)); -boolean EXFUN(bfd_set_archive_head, (bfd *output, bfd *new_head)); -bfd *EXFUN(bfd_get_elt_at_index, (bfd * archive, int index)); -bfd* EXFUN(bfd_openr_next_archived_file, (bfd *archive, bfd *previous)); -CONST char *EXFUN(bfd_core_file_failing_command, (bfd *)); -int EXFUN(bfd_core_file_failing_signal, (bfd *)); -boolean EXFUN(core_file_matches_executable_p - , (bfd *core_bfd, bfd *exec_bfd)); -#define SDEF(ret, name, arglist) \ - PROTO(ret,(*name),arglist) -#define SDEF_FMT(ret, name, arglist) \ - PROTO(ret,(*name[bfd_type_end]),arglist) #define BFD_SEND(bfd, message, arglist) \ ((*((bfd)->xvec->message)) arglist) #define BFD_SEND_FMT(bfd, message, arglist) \ @@ -1221,133 +1332,112 @@ typedef struct bfd_target bfd_target_ieee_flavour, bfd_target_oasys_flavour, bfd_target_tekhex_flavour, - bfd_target_srec_flavour} flavour; + bfd_target_srec_flavour, + bfd_target_hppa_flavour} flavour; boolean byteorder_big_p; boolean header_byteorder_big_p; flagword object_flags; flagword section_flags; + char symbol_leading_char; char ar_pad_char; - unsigned short ar_max_namelen; + unsigned short ar_max_namelen; unsigned int align_power_min; - SDEF (bfd_vma, bfd_getx64, (bfd_byte *)); - SDEF (void, bfd_putx64, (bfd_vma, bfd_byte *)); - SDEF (bfd_vma, bfd_getx32, (bfd_byte *)); - SDEF (void, bfd_putx32, (bfd_vma, bfd_byte *)); - SDEF (bfd_vma, bfd_getx16, (bfd_byte *)); - SDEF (void, bfd_putx16, (bfd_vma, bfd_byte *)); - SDEF (bfd_vma, bfd_h_getx64, (bfd_byte *)); - SDEF (void, bfd_h_putx64, (bfd_vma, bfd_byte *)); - SDEF (bfd_vma, bfd_h_getx32, (bfd_byte *)); - SDEF (void, bfd_h_putx32, (bfd_vma, bfd_byte *)); - SDEF (bfd_vma, bfd_h_getx16, (bfd_byte *)); - SDEF (void, bfd_h_putx16, (bfd_vma, bfd_byte *)); - SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *)); - SDEF_FMT (boolean, _bfd_set_format, (bfd *)); - SDEF_FMT (boolean, _bfd_write_contents, (bfd *)); - SDEF (char *, _core_file_failing_command, (bfd *)); - SDEF (int, _core_file_failing_signal, (bfd *)); - SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *)); - 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, + bfd_vma (*bfd_getx64) PARAMS ((bfd_byte *)); + void (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_getx32) PARAMS ((bfd_byte *)); + void (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_getx16) PARAMS ((bfd_byte *)); + void (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx64) PARAMS ((bfd_byte *)); + void (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx32) PARAMS ((bfd_byte *)); + void (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *)); + bfd_vma (*bfd_h_getx16) PARAMS ((bfd_byte *)); + void (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *)); + struct bfd_target * (*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *)); + boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *)); + boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *)); + char * (*_core_file_failing_command) PARAMS ((bfd *)); + int (*_core_file_failing_signal) PARAMS ((bfd *)); + boolean (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *)); + boolean (*_bfd_slurp_armap) PARAMS ((bfd *)); + boolean (*_bfd_slurp_extended_name_table) PARAMS ((bfd *)); + void (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *)); + boolean (*write_armap) PARAMS ((bfd *arch, unsigned int elength, struct orl *map, unsigned int orl_count, int stridx)); - SDEF (boolean, _close_and_cleanup, (bfd *)); - SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR, + boolean (*_close_and_cleanup) PARAMS ((bfd *)); + boolean (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); - SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR, + boolean (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); - SDEF (boolean, _new_section_hook, (bfd *, sec_ptr)); - SDEF (unsigned int, _get_symtab_upper_bound, (bfd *)); - SDEF (unsigned int, _bfd_canonicalize_symtab, - (bfd *, struct symbol_cache_entry **)); - SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr)); - SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **, - struct symbol_cache_entry**)); - SDEF (struct symbol_cache_entry *, _bfd_make_empty_symbol, (bfd *)); - SDEF (void, _bfd_print_symbol, (bfd *, PTR, struct symbol_cache_entry *, + boolean (*_new_section_hook) PARAMS ((bfd *, sec_ptr)); + unsigned int (*_get_symtab_upper_bound) PARAMS ((bfd *)); + unsigned int (*_bfd_canonicalize_symtab) PARAMS ((bfd *, + struct symbol_cache_entry **)); + unsigned int (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr)); + unsigned int (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **, + struct symbol_cache_entry **)); + struct symbol_cache_entry * + (*_bfd_make_empty_symbol) PARAMS ((bfd *)); + void (*_bfd_print_symbol) PARAMS ((bfd *, PTR, + struct symbol_cache_entry *, bfd_print_symbol_type)); #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e)) - SDEF (alent *, _get_lineno, (bfd *, struct symbol_cache_entry *)); - - 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, struct sec *section, - struct symbol_cache_entry **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)); - - SDEF (void, _bfd_debug_info_start, (bfd *)); - SDEF (void, _bfd_debug_info_end, (bfd *)); - SDEF (void, _bfd_debug_info_accumulate, (bfd *, struct sec *)); - SDEF (bfd_byte *, _bfd_get_relocated_section_contents, (bfd*,struct bfd_seclet_struct *)); - SDEF (boolean,_bfd_relax_section,(bfd *, struct sec *, struct symbol_cache_entry **)); - SDEF(void, _bfd_coff_swap_aux_in,( - bfd *abfd , - PTR ext, - int type, - int class , - PTR in)); - - SDEF(void, _bfd_coff_swap_sym_in,( - bfd *abfd , - PTR ext, - PTR in)); - - SDEF(void, _bfd_coff_swap_lineno_in, ( - bfd *abfd, - PTR ext, - PTR in)); - - SDEF(unsigned int, _bfd_coff_swap_aux_out,( - bfd *abfd, - PTR in, - int type, - int class, - PTR ext)); - - SDEF(unsigned int, _bfd_coff_swap_sym_out,( - bfd *abfd, - PTR in, - PTR ext)); - - SDEF(unsigned int, _bfd_coff_swap_lineno_out,( - bfd *abfd, - PTR in, - PTR ext)); - - SDEF(unsigned int, _bfd_coff_swap_reloc_out,( - bfd *abfd, - PTR src, - PTR dst)); - - SDEF(unsigned int, _bfd_coff_swap_filehdr_out,( - bfd *abfd, - PTR in, - PTR out)); - - SDEF(unsigned int, _bfd_coff_swap_aouthdr_out,( - bfd *abfd, - PTR in, - PTR out)); - - SDEF(unsigned int, _bfd_coff_swap_scnhdr_out,( - bfd *abfd, - PTR in, - PTR out)); + alent * (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *)); + boolean (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture, + unsigned long)); + + bfd * (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev)); + + boolean (*_bfd_find_nearest_line) PARAMS ((bfd *abfd, + struct sec *section, struct symbol_cache_entry **symbols, + bfd_vma offset, CONST char **file, CONST char **func, + unsigned int *line)); + + int (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *)); + + int (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean)); + + void (*_bfd_debug_info_start) PARAMS ((bfd *)); + void (*_bfd_debug_info_end) PARAMS ((bfd *)); + void (*_bfd_debug_info_accumulate) PARAMS ((bfd *, struct sec *)); + + bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *, + struct bfd_seclet *, bfd_byte *data)); + + boolean (*_bfd_relax_section) PARAMS ((bfd *, struct sec *, + struct symbol_cache_entry **)); + /* See documentation on reloc types. */ + CONST struct reloc_howto_struct * + (*reloc_type_lookup) PARAMS ((bfd *abfd, + bfd_reloc_code_real_type code)); + + /* Back-door to allow format-aware applications to create debug symbols + while using BFD for everything else. Currently used by the assembler + when creating COFF files. */ + asymbol * (*_bfd_make_debug_symbol) PARAMS (( + bfd *abfd, + void *ptr, + unsigned long size)); + PTR backend_data; } bfd_target; -bfd_target *EXFUN(bfd_find_target, (CONST char *, bfd *)); -CONST char **EXFUN(bfd_target_list, (void)); -boolean EXFUN(bfd_check_format, (bfd *abfd, bfd_format format)); -boolean EXFUN(bfd_set_format, (bfd *, bfd_format)); -CONST char *EXFUN(bfd_format_string, (bfd_format)); +bfd_target * +bfd_find_target PARAMS ((CONST char *, bfd *)); + +CONST char ** +bfd_target_list PARAMS ((void)); + +boolean +bfd_check_format PARAMS ((bfd *abfd, bfd_format format)); + +boolean +bfd_set_format PARAMS ((bfd *, bfd_format)); + +CONST char * +bfd_format_string PARAMS ((bfd_format)); + #endif