X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fbfd-in.h;h=f0a1d84ebde651356a8780d8482abdb993df1f42;hb=c4aa876b9116069c2578a8db47d08ab38f2e5f57;hp=f4caaab431fd34e4a739952202c0a4c10625b498;hpb=815179af80dc1348b0ebf6499c483b71c080ab84;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/bfd-in.h b/bfd/bfd-in.h index f4caaab431..f0a1d84ebd 100644 --- a/bfd/bfd-in.h +++ b/bfd/bfd-in.h @@ -1,5 +1,6 @@ /* Main header file for the bfd library -- portable access to object files. - Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. + Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 + Free Software Foundation, Inc. Contributed by Cygnus Support. ** NOTE: bfd.h and bfd-in2.h are GENERATED files. Don't change them; @@ -22,7 +23,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/* bfd.h -- The only header file required by users of the bfd library +/* bfd.h -- The only header file required by users of the bfd library The bfd.h file is generated from bfd-in.h and various .c files; if you change it, your changes will probably be lost. @@ -49,11 +50,15 @@ extern "C" { #endif #include "ansidecl.h" -#include "obstack.h" /* These two lines get substitutions done by commands in Makefile.in. */ -#define BFD_VERSION "@VERSION@" -#define BFD_ARCH_SIZE @WORDSIZE@ +#define BFD_VERSION "@VERSION@" +#define BFD_ARCH_SIZE @wordsize@ +#define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@ +#if @BFD_HOST_64_BIT_DEFINED@ +#define BFD_HOST_64_BIT @BFD_HOST_64_BIT@ +#define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@ +#endif #if BFD_ARCH_SIZE >= 64 #define BFD64 @@ -67,9 +72,6 @@ extern "C" { #endif #endif -/* 64-bit type definition (if any) from bfd's sysdep.h goes here */ - - /* forward declaration */ typedef struct _bfd bfd; @@ -87,9 +89,14 @@ typedef struct _bfd bfd; /* Yup, SVR4 has a "typedef enum boolean" in -fnf */ /* It gets worse if the host also defines a true/false enum... -sts */ /* And even worse if your compiler has built-in boolean types... -law */ -#if defined (__GNUG__) && (__GNUC_MINOR__ > 5) +#if defined (__GNUG__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 6)) #define TRUE_FALSE_ALREADY_DEFINED #endif +#ifdef MPW +/* Pre-emptive strike - get the file with the enum. */ +#include +#define TRUE_FALSE_ALREADY_DEFINED +#endif /* MPW */ #ifndef TRUE_FALSE_ALREADY_DEFINED typedef enum bfd_boolean {false, true} boolean; #define BFD_TRUE_FALSE @@ -102,50 +109,57 @@ typedef enum bfd_boolean {bfd_fffalse, bfd_tttrue} boolean; /* 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 + 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. - If the host implements 64-bit values, it defines BFD_HOST_64_BIT to - be the appropriate type. Otherwise, this code will fall back on - gcc's "long long" type if gcc is being used. BFD_HOST_64_BIT must - be defined in such a way as to be a valid type name by itself or - with "unsigned" prefixed. It should be a signed type by itself. - - If neither is the case, then compilation will fail if 64-bit - targets are requested. If you don't request any 64-bit targets, - you should be safe. */ - -#ifdef BFD64 - -#if defined (__GNUC__) && !defined (BFD_HOST_64_BIT) -#define BFD_HOST_64_BIT long long -typedef BFD_HOST_64_BIT int64_type; -typedef unsigned BFD_HOST_64_BIT uint64_type; -#endif - -#if !defined (uint64_type) && defined (__GNUC__) -#define uint64_type unsigned long long -#define int64_type long long -#endif -#ifndef uint64_typeLOW -#define uint64_typeLOW(x) ((unsigned long)(((x) & 0xffffffff))) -#define uint64_typeHIGH(x) ((unsigned long)(((x) >> 32) & 0xffffffff)) -#endif - -typedef unsigned BFD_HOST_64_BIT bfd_vma; + If the type `long' is at least 64 bits, BFD_HOST_64BIT_LONG will be + set to 1 above. Otherwise, if gcc is being used, this code will + use gcc's "long long" type. Otherwise, BFD_HOST_64_BIT must be + defined above. */ + +#ifndef BFD_HOST_64_BIT +# if BFD_HOST_64BIT_LONG +# define BFD_HOST_64_BIT long +# define BFD_HOST_U_64_BIT unsigned long +# else +# ifdef __GNUC__ +# if __GNUC__ >= 2 +# define BFD_HOST_64_BIT long long +# define BFD_HOST_U_64_BIT unsigned long long +# endif /* __GNUC__ >= 2 */ +# endif /* ! defined (__GNUC__) */ +# endif /* ! BFD_HOST_64BIT_LONG */ +#endif /* ! defined (BFD_HOST_64_BIT) */ + +#ifdef BFD64 + +#ifndef BFD_HOST_64_BIT + #error No 64 bit integer type available +#endif /* ! defined (BFD_HOST_64_BIT) */ + +typedef BFD_HOST_U_64_BIT bfd_vma; typedef BFD_HOST_64_BIT bfd_signed_vma; -typedef unsigned BFD_HOST_64_BIT bfd_size_type; -typedef unsigned BFD_HOST_64_BIT symvalue; +typedef BFD_HOST_U_64_BIT bfd_size_type; +typedef BFD_HOST_U_64_BIT symvalue; + #ifndef fprintf_vma +#if BFD_HOST_64BIT_LONG +#define sprintf_vma(s,x) sprintf (s, "%016lx", x) +#define fprintf_vma(f,x) fprintf (f, "%016lx", x) +#else +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff))) +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff)) #define fprintf_vma(s,x) \ - fprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x)) + fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) #define sprintf_vma(s,x) \ - sprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x)) + sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x)) #endif +#endif + #else /* not BFD64 */ /* Represent a target address. Also used as a generic unsigned type @@ -165,7 +179,9 @@ typedef unsigned long bfd_size_type; /* Print a bfd_vma x on stream s. */ #define fprintf_vma(s,x) fprintf(s, "%08lx", x) #define sprintf_vma(s,x) sprintf(s, "%08lx", x) + #endif /* not BFD64 */ + #define printf_vma(x) fprintf_vma(stdout,x) typedef unsigned int flagword; /* 32 bits of flags */ @@ -189,7 +205,7 @@ typedef enum bfd_format { to another, and are not necessarily correct). */ /* No flags. */ -#define NO_FLAGS 0x00 +#define BFD_NO_FLAGS 0x00 /* BFD contains relocation entries. */ #define HAS_RELOC 0x01 @@ -233,6 +249,10 @@ typedef enum bfd_format { writing out an a.out object the symbols not be hashed to eliminate duplicates. */ #define BFD_TRADITIONAL_FORMAT 0x400 + +/* This flag indicates that the BFD contents are actually cached in + memory. If this is set, iostream points to a bfd_in_memory struct. */ +#define BFD_IN_MEMORY 0x800 /* symbols and relocation */ @@ -264,11 +284,11 @@ typedef struct carsym { file_ptr file_offset; /* look here to find the file */ } carsym; /* to make these you call a carsymogen */ - + /* Used in generating armaps (archive tables of contents). Perhaps just a forward definition would do? */ struct orl { /* output ranlib */ - char **name; /* symbol name */ + char **name; /* symbol name */ file_ptr pos; /* bfd* or file position */ int namidx; /* index into string table */ }; @@ -276,7 +296,7 @@ struct orl { /* output ranlib */ /* Linenumber stuff */ typedef struct lineno_cache_entry { - unsigned int line_number; /* Linenumber from start of function*/ + unsigned int line_number; /* Linenumber from start of function*/ union { struct symbol_cache_entry *sym; /* Function name */ unsigned long offset; /* Offset into section */ @@ -296,6 +316,7 @@ typedef struct sec *sec_ptr; #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_lma(bfd, ptr) ((ptr)->lma) #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0) #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) @@ -306,15 +327,15 @@ typedef struct sec *sec_ptr; #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) -typedef struct stat stat_type; +typedef struct stat stat_type; typedef enum bfd_print_symbol -{ +{ bfd_print_symbol_name, bfd_print_symbol_more, bfd_print_symbol_all } bfd_print_symbol_type; - + /* Information about a symbol that nm needs. */ typedef struct _symbol_info @@ -322,10 +343,15 @@ typedef struct _symbol_info symvalue value; char type; CONST char *name; /* Symbol name. */ - char stab_other; /* Unused. */ - short stab_desc; /* Info for N_TYPE. */ - CONST char *stab_name; + unsigned char stab_type; /* Stab type. */ + char stab_other; /* Stab other. */ + short stab_desc; /* Stab desc. */ + CONST char *stab_name; /* String for stab type. */ } symbol_info; + +/* Get the name of a stabs type code. */ + +extern const char *bfd_get_stab_name PARAMS ((int)); /* Hash table routines. There is no way to free up a hash table. */ @@ -361,8 +387,9 @@ struct bfd_hash_table struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); - /* An obstack for this hash table. */ - struct obstack memory; + /* An objalloc for this hash table. This is a struct objalloc *, + but we use PTR to avoid requiring the inclusion of objalloc.h. */ + PTR memory; }; /* Initialize a hash table. */ @@ -391,6 +418,11 @@ extern struct bfd_hash_entry *bfd_hash_lookup PARAMS ((struct bfd_hash_table *, const char *, boolean create, boolean copy)); +/* Replace an entry in a hash table. */ +extern void bfd_hash_replace + PARAMS ((struct bfd_hash_table *, struct bfd_hash_entry *old, + struct bfd_hash_entry *nw)); + /* Base method for creating a hash table entry. */ extern struct bfd_hash_entry *bfd_hash_newfunc PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, @@ -449,58 +481,6 @@ extern long bfd_tell PARAMS ((bfd *abfd)); extern int bfd_flush PARAMS ((bfd *abfd)); extern int bfd_stat PARAMS ((bfd *abfd, struct stat *)); -/* PE STUFF */ -/* Also define some types which are used within bfdlink.h for the - bfd_link_info struct. These are not defined in bfdlink.h for a reason. - When the link_info data is passed to bfd from ld, it is copied into - extern variables defined in internal.h. The type class for these must - be available to any thing that includes internal.h. When internal.h is - included, it is always preceeded by an include on this file. If I leave the - type definitions in bfdlink.h, then I must include that file when ever - I include internal.h, and this is not always a good thing */ - -/* These are the different types of subsystems to be used when linking for - Windows NT. This information is passed in as an input parameter (default - is console) and ultimately ends up in the optional header data */ - -#define BFD_PE_NATIVE 1 /* image doesn't require a subsystem */ -#define BFD_PE_WINDOWS 2 /* image runs in the Windows GUI subsystem */ -#define BFD_PE_CONSOLE 3 /* image runs in the Windows CUI subsystem */ -#define BFD_PE_OS2 5 /* image runs in the OS/2 character subsystem */ -#define BFD_PE_POSIX 7 /* image runs in the posix character subsystem */ - -/* The NT optional header file allows input of the stack and heap reserve - and commit size. This data may be input on the command line and will - end up in the optional header. Default sizes are provided. */ - -typedef struct -{ - boolean defined; - bfd_vma value; -} bfd_link_pe_info_dval ; - -typedef struct _bfd_link_pe_info -{ - bfd_link_pe_info_dval dll; - bfd_link_pe_info_dval file_alignment; - bfd_link_pe_info_dval heap_commit; - bfd_link_pe_info_dval heap_reserve; - bfd_link_pe_info_dval image_base; - bfd_link_pe_info_dval major_image_version; - bfd_link_pe_info_dval major_os_version; - bfd_link_pe_info_dval major_subsystem_version; - bfd_link_pe_info_dval minor_image_version; - bfd_link_pe_info_dval minor_os_version; - bfd_link_pe_info_dval minor_subsystem_version; - bfd_link_pe_info_dval section_alignment; - bfd_link_pe_info_dval stack_commit; - bfd_link_pe_info_dval stack_reserve; - bfd_link_pe_info_dval subsystem; -} bfd_link_pe_info; - -/* END OF PE STUFF */ - - /* Cast from const char * to char * so that caller can assign to a char * without a warning. */ @@ -509,6 +489,15 @@ typedef struct _bfd_link_pe_info #define bfd_get_format(abfd) ((abfd)->format) #define bfd_get_target(abfd) ((abfd)->xvec->name) #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) +#define bfd_family_coff(abfd) \ + (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \ + bfd_get_flavour (abfd) == bfd_target_xcoff_flavour) +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG) +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE) +#define bfd_header_big_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG) +#define bfd_header_little_endian(abfd) \ + ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE) #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) @@ -527,6 +516,10 @@ typedef struct _bfd_link_pe_info #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (boolean)(bool)), true) +extern boolean bfd_record_phdr + PARAMS ((bfd *, unsigned long, boolean, flagword, boolean, bfd_vma, + boolean, boolean, unsigned int, struct sec **)); + /* Byte swapping routines. */ bfd_vma bfd_getb64 PARAMS ((const unsigned char *)); @@ -556,6 +549,8 @@ struct ecoff_debug_swap; struct ecoff_extr; struct symbol_cache_entry; struct bfd_link_info; +struct bfd_link_hash_entry; +struct bfd_elf_version_tree; #endif extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd)); extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value)); @@ -608,28 +603,53 @@ extern boolean bfd_mips_ecoff_create_embedded_relocs /* Externally visible ELF routines. */ -extern boolean bfd_elf32_record_link_assignment - PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean)); -extern boolean bfd_elf64_record_link_assignment - PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean)); -struct bfd_elf_link_needed_list +struct bfd_link_needed_list { - struct bfd_elf_link_needed_list *next; + struct bfd_link_needed_list *next; bfd *by; const char *name; }; -extern struct bfd_elf_link_needed_list *bfd_elf_get_needed_list + +extern boolean bfd_elf32_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean)); +extern boolean bfd_elf64_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean)); +extern struct bfd_link_needed_list *bfd_elf_get_needed_list PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_elf_get_bfd_needed_list + PARAMS ((bfd *, struct bfd_link_needed_list **)); extern boolean bfd_elf32_size_dynamic_sections - PARAMS ((bfd *, const char *, const char *, boolean, - struct bfd_link_info *, struct sec **)); + PARAMS ((bfd *, const char *, const char *, boolean, const char *, + const char * const *, struct bfd_link_info *, struct sec **, + struct bfd_elf_version_tree *)); extern boolean bfd_elf64_size_dynamic_sections - PARAMS ((bfd *, const char *, const char *, boolean, - struct bfd_link_info *, struct sec **)); + PARAMS ((bfd *, const char *, const char *, boolean, const char *, + const char * const *, struct bfd_link_info *, struct sec **, + struct bfd_elf_version_tree *)); extern void bfd_elf_set_dt_needed_name PARAMS ((bfd *, const char *)); +extern const char *bfd_elf_get_dt_soname PARAMS ((bfd *)); + +/* Return an upper bound on the number of bytes required to store a + copy of ABFD's program header table entries. Return -1 if an error + occurs; bfd_get_error will return an appropriate code. */ +extern long bfd_get_elf_phdr_upper_bound PARAMS ((bfd *abfd)); + +/* Copy ABFD's program header table entries to *PHDRS. The entries + will be stored as an array of Elf_Internal_Phdr structures, as + defined in include/elf/internal.h. To find out how large the + buffer needs to be, call bfd_get_elf_phdr_upper_bound. + + Return the number of program header table entries read, or -1 if an + error occurs; bfd_get_error will return an appropriate code. */ +extern int bfd_get_elf_phdrs PARAMS ((bfd *abfd, void *phdrs)); + +/* Return the arch_size field of an elf bfd, or -1 if not elf. */ +extern int bfd_elf_get_arch_size PARAMS ((bfd *)); /* SunOS shared library support routines for the linker. */ +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list + PARAMS ((bfd *, struct bfd_link_info *)); extern boolean bfd_sunos_record_link_assignment PARAMS ((bfd *, struct bfd_link_info *, const char *)); extern boolean bfd_sunos_size_dynamic_sections @@ -638,7 +658,107 @@ extern boolean bfd_sunos_size_dynamic_sections /* Linux shared library support routines for the linker. */ -extern boolean bfd_linux_size_dynamic_sections +extern boolean bfd_i386linux_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_m68klinux_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); +extern boolean bfd_sparclinux_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *)); + +/* mmap hacks */ + +struct _bfd_window_internal; +typedef struct _bfd_window_internal bfd_window_internal; + +typedef struct _bfd_window { + /* What the user asked for. */ + PTR data; + bfd_size_type size; + /* The actual window used by BFD. Small user-requested read-only + regions sharing a page may share a single window into the object + file. Read-write versions shouldn't until I've fixed things to + keep track of which portions have been claimed by the + application; don't want to give the same region back when the + application wants two writable copies! */ + struct _bfd_window_internal *i; +} bfd_window; + +extern void bfd_init_window PARAMS ((bfd_window *)); +extern void bfd_free_window PARAMS ((bfd_window *)); +extern boolean bfd_get_file_window + PARAMS ((bfd *, file_ptr, bfd_size_type, bfd_window *, boolean)); + +/* XCOFF support routines for the linker. */ + +extern boolean bfd_xcoff_link_record_set + PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, + bfd_size_type)); +extern boolean bfd_xcoff_import_symbol + PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, + bfd_vma, const char *, const char *, const char *)); +extern boolean bfd_xcoff_export_symbol + PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, + boolean)); +extern boolean bfd_xcoff_link_count_reloc + PARAMS ((bfd *, struct bfd_link_info *, const char *)); +extern boolean bfd_xcoff_record_link_assignment + PARAMS ((bfd *, struct bfd_link_info *, const char *)); +extern boolean bfd_xcoff_size_dynamic_sections + PARAMS ((bfd *, struct bfd_link_info *, const char *, const char *, + unsigned long, unsigned long, unsigned long, boolean, + int, boolean, boolean, struct sec **)); + +/* Externally visible COFF routines. */ + +#if defined(__STDC__) || defined(ALMOST_STDC) +struct internal_syment; +union internal_auxent; +#endif + +extern boolean bfd_coff_get_syment + PARAMS ((bfd *, struct symbol_cache_entry *, struct internal_syment *)); + +extern boolean bfd_coff_get_auxent + PARAMS ((bfd *, struct symbol_cache_entry *, int, union internal_auxent *)); + +extern boolean bfd_coff_set_symbol_class + PARAMS ((bfd *, struct symbol_cache_entry *, unsigned int)); + +/* ARM Interworking support. Called from linker. */ +extern boolean bfd_arm_allocate_interworking_sections + PARAMS ((struct bfd_link_info *)); + +extern boolean bfd_arm_process_before_allocation + PARAMS ((bfd *, struct bfd_link_info *, int)); + +extern boolean bfd_arm_get_bfd_for_interworking PARAMS ((bfd *, struct bfd_link_info *)); +/* PE ARM Interworking support. Called from linker. */ +extern boolean bfd_arm_pe_allocate_interworking_sections + PARAMS ((struct bfd_link_info *)); + +extern boolean bfd_arm_pe_process_before_allocation + PARAMS ((bfd *, struct bfd_link_info *, int)); + +extern boolean bfd_arm_pe_get_bfd_for_interworking + PARAMS ((bfd *, struct bfd_link_info *)); + +/* ELF ARM Interworking support. Called from linker. */ +extern boolean bfd_elf32_arm_allocate_interworking_sections + PARAMS ((struct bfd_link_info *)); + +extern boolean bfd_elf32_arm_process_before_allocation + PARAMS ((bfd *, struct bfd_link_info *, int)); + +extern boolean bfd_elf32_arm_get_bfd_for_interworking + PARAMS ((bfd *, struct bfd_link_info *)); + +/* TI COFF load page support. */ +extern void bfd_ticoff_set_section_load_page + PARAMS ((struct sec *, int)); + +extern int bfd_ticoff_get_section_load_page + PARAMS ((struct sec *)); + /* And more from the source. */