X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=include%2Fbfd.h;h=dd3ede9edfbf088b0e3e10865c2168acc0151ae2;hb=808566e89a9fa306dc0a4c73061eb4e89f3ff6b0;hp=290a0df3ac1bad4a20c551ec4dfc3605eba3b895;hpb=fb3ee1c0d547326cd22e69b9fd3cf61acce4a4e3;p=deliverable%2Fbinutils-gdb.git diff --git a/include/bfd.h b/include/bfd.h index 290a0df3ac..dd3ede9edf 100644 --- a/include/bfd.h +++ b/include/bfd.h @@ -1,30 +1,43 @@ - /* A -*- C -*- header file for the bfd library */ +/* 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. -/* bfd.h -- The only header file required by users of the bfd library - */ +This file is part of BFD, the Binary File Descriptor library. -/* WARNING: -This file is generated from various .c files, if you change it, your -bits may be lost -*/ - -/* 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 +This program 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. +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. -BFD is distributed in the hope that it will be useful, +This program 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. */ +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* 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. + +All the prototypes and definitions following the comment "THE FOLLOWING +IS EXTRACTED FROM THE SOURCE" are extracted from the source files for +BFD. If you change it, someone oneday will extract it from the source +again, and your changes will be lost. To save yourself from this bind, +change the definitions in the source in the bfd directory. Type "make +docs" and then "make headers" in that directory, and magically this file +will change to reflect your changes. + +If you don't have the tools to perform the extraction, then you are +safe from someone on your system trampling over your header files. +You should still maintain the equivalence between the source and this +file though; every change you make to the .c file should be reflected +here. */ #ifndef __BFD_H_SEEN__ #define __BFD_H_SEEN__ @@ -32,16 +45,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #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.15" +#define BFD_VERSION "2.0" /* forward declaration */ typedef struct _bfd bfd; @@ -50,10 +54,19 @@ typedef struct _bfd bfd; and false on failure (unless they're a predicate). -- bfd.doc */ /* 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; - -/* Try to avoid breaking stuff */ -typedef long int file_ptr; +/* typedef enum boolean {false, true} boolean; */ +/* Yup, SVR4 has a "typedef enum boolean" in -fnf */ +typedef enum bfd_boolean {false, true} boolean; + +/* 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 */ @@ -67,8 +80,6 @@ typedef HOST_64_BIT symvalue; typedef HOST_64_BIT bfd_64_type; #define fprintf_vma(s,x) \ fprintf(s,"%08x%08x", uint64_typeHIGH(x), uint64_typeLOW(x)) -#define printf_vma(x) \ - printf( "%08x%08x", uint64_typeHIGH(x), uint64_typeLOW(x)) #else typedef struct {int a,b;} bfd_64_type; typedef unsigned long rawdata_offset; @@ -78,9 +89,9 @@ typedef unsigned long bfd_word; typedef unsigned long bfd_size; typedef unsigned long symvalue; typedef unsigned long bfd_size_type; -#define printf_vma(x) printf( "%08lx", x) #define fprintf_vma(s,x) fprintf(s, "%08lx", x) #endif +#define printf_vma(x) fprintf_vma(stdout,x) typedef unsigned int flagword; /* 32 bits of flags */ @@ -95,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 */ @@ -169,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) ((ptr)->size) +#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) @@ -191,26 +205,40 @@ typedef enum bfd_error { no_more_archived_files, malformed_archive, symbol_not_found, file_not_recognized, file_ambiguously_recognized, no_contents, - bfd_error_nonrepresentable_section, + bfd_error_nonrepresentable_section, + no_debug_section, bad_value, invalid_error_code} bfd_ec; extern bfd_ec bfd_error; +struct reloc_cache_entry; +struct bfd_seclet; + typedef struct bfd_error_vector { - PROTO(void,(* nonrepresentable_section ),(CONST bfd *CONST abfd, - CONST char *CONST name)); + 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 *sec)); + + void (* reloc_dangerous) PARAMS ((CONST struct reloc_cache_entry *rel, + CONST struct bfd_seclet *sec)); + } bfd_error_vector_type; -PROTO (char *, bfd_errmsg, ()); -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 { - bfd_print_symbol_name_enum, - bfd_print_symbol_type_enum, - bfd_print_symbol_all_enum -} bfd_print_symbol_enum_type; + bfd_print_symbol_name, + bfd_print_symbol_more, + bfd_print_symbol_all, + bfd_print_symbol_nm /* Pretty format suitable for nm program. */ +} bfd_print_symbol_type; @@ -254,9 +282,12 @@ CAT(NAME,_generic_stat_arch_elt),\ CAT(NAME,_sizeof_headers),\ CAT(NAME,_bfd_debug_info_start),\ CAT(NAME,_bfd_debug_info_end),\ -CAT(NAME,_bfd_debug_info_accumulate) +CAT(NAME,_bfd_debug_info_accumulate),\ +CAT(NAME,_bfd_get_relocated_section_contents),\ +CAT(NAME,_bfd_relax_section) + +#define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table -#define COFF_SWAP_TABLE coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in, /* User program access to BFD facilities */ @@ -273,7 +304,7 @@ extern CONST short _bfd_host_big_endian; #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_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) \ @@ -289,140 +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)); -/*THE FOLLOWING IS EXTRACTED FROM THE SOURCE */ - -/* Opens the file supplied (using fopen) with the target supplied, it -returns a pointer to the created bfd. - -If NULL is returned then an error has occured. -Possible errors are no_memory, invalid_target or system_call error. -*/ -PROTO(bfd*, bfd_openr, (CONST char *filename,CONST char*target)); -/* bfd_fdopenr is to bfd_fopenr much like fdopen is to fopen. It opens a bfd on -a file already described by the @var{fd} supplied. - -Possible errors are no_memory, invalid_target and system_call error. -*/ - PROTO(bfd *, bfd_fdopenr, - (CONST char *filename, CONST char *target, int fd)); -/* Creates a bfd, associated with file @var{filename}, using the file -format @var{target}, and returns a pointer to it. - -Possible errors are system_call_error, no_memory, invalid_target. -*/ -PROTO(bfd *, bfd_openw, (CONST char *filename, CONST char *target)); -/* This function closes a bfd. If the bfd was open for writing, then -pending operations are completed and the file written out and closed. -If the created file is executable, then @code{chmod} is called to mark -it as such. - -All memory attatched to the bfd's obstacks is released. - -@code{true} is returned if all is ok, otherwise @code{false}. -*/ -PROTO(boolean, bfd_close,(bfd *)); -/* This routine creates a new bfd in the manner of bfd_openw, but without -opening a file. The new bfd takes the target from the target used by -@var{template}. The format is always set to @code{bfd_object}. - -*/ -PROTO(bfd *, bfd_create, (CONST char *filename, bfd *template)); -/* Return the number of bytes in the obstacks connected to the supplied -bfd. -*/ -PROTO(bfd_size_type,bfd_alloc_size,(bfd *abfd)); -/* 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. The machine gives a number which -distingushes different versions of the architecture, containing for -example 2 and 3 for Intel i960 KA and i960 KB, and 68020 and 68030 for -Motorola 68020 and 68030. - -*/ -enum bfd_architecture -{ - bfd_arch_unknown, /* File arch not known */ - bfd_arch_obscure, /* Arch known, not one of these */ - bfd_arch_m68k, /* Motorola 68xxx */ - bfd_arch_vax, /* DEC Vax */ - bfd_arch_i960, /* Intel 960 */ - /* The order of the following is important. - lower number indicates a machine type that - only accepts a subset of the instructions - available to machines with higher numbers. - The exception is the "ca", which is - incompatible with all other machines except - "core". */ +bfd * +bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd)); -#define bfd_mach_i960_core 1 -#define bfd_mach_i960_ka_sa 2 -#define bfd_mach_i960_kb_sb 3 -#define bfd_mach_i960_mc 4 -#define bfd_mach_i960_xa 5 -#define bfd_mach_i960_ca 6 +bfd * +bfd_openw PARAMS ((CONST char *filename, CONST char *target)); - bfd_arch_a29k, /* AMD 29000 */ - bfd_arch_sparc, /* 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 - }; +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)); -/* stuff -*/ - -/* Return a printable string representing the architecture and machine -type. The result is only good until the next call to -bfd_printable_arch_mach. -*/ -PROTO(CONST char *,bfd_printable_arch_mach, - (enum bfd_architecture arch, unsigned long machine)); -/* Scan a string and attempt to turn it into an archive and machine type combination. -*/ -PROTO(boolean, bfd_scan_arch_mach, - (CONST char *, enum bfd_architecture *, unsigned long *)); -/* This routine is used to determine whether two BFDs' architectures and machine types are -compatible. It calculates the lowest common denominator between the -two architectures and machine types implied by the bfds and sets the -objects pointed at by @var{archp} and @var{machine} if non NULL. - -This routine returns @code{true} if the bfds are of compatible type, -otherwise @code{false}. -*/ -PROTO(boolean, bfd_arch_compatible, - (bfd *abfd, - bfd *bbfd, - enum bfd_architecture *archp, - unsigned long *machinep)); -/* Set atch mach -*/ -#define bfd_set_arch_mach(abfd, arch, mach) \ - BFD_SEND (abfd, _bfd_set_arch_mach,\ - (abfd, arch, mach)) - -/* These macros as used for reading and writing raw data in sections; -each access (except for bytes) is vectored through the target format -of the bfd and mangled accordingly. The mangling performs any -necessary endian translations and removes alignment restrictions. -*/ #define bfd_put_8(abfd, val, ptr) \ (*((char *)ptr) = (char)val) #define bfd_get_8(abfd, ptr) \ @@ -439,13 +367,6 @@ necessary endian translations and removes alignment restrictions. BFD_SEND(abfd, bfd_putx64, (val, ptr)) #define bfd_get_64(abfd, ptr) \ BFD_SEND(abfd, bfd_getx64, (ptr)) - -/* These macros have the same function as their @code{bfd_get_x} -bretherin, except that they are used for removing information for the -header records of object files. Believe it or not, some object files -keep their header records in big endian order, and their data in little -endan order. -*/ #define bfd_h_put_8(abfd, val, ptr) \ (*((char *)ptr) = (char)val) #define bfd_h_get_8(abfd, ptr) \ @@ -462,1080 +383,1061 @@ endan order. BFD_SEND(abfd, bfd_h_putx64,(val, ptr)) #define bfd_h_get_64(abfd, ptr) \ BFD_SEND(abfd, bfd_h_getx64,(ptr)) +typedef struct sec +{ + /* The name of the section, the name isn't a copy, the pointer is + the same as that passed to bfd_make_section. */ -/* The shape of a section struct: + CONST char *name; -*/ -typedef struct sec { - /* The name of the section, the name isn't a copy, the pointer is - the same as that passed to bfd_make_section. - */ - CONST char *name; + /* Which section is it 0.nth */ + + int index; + + /* The next section in the list belonging to the BFD, or NULL. */ - /* The next section in the list belonging to the bfd, or NULL. - */ struct sec *next; - /* The field flags contains attributes of the section. Some of these - flags are read in from the object file, and some are synthesized from - other information. - */ -flagword flags; + /* The field flags contains attributes of the section. Some of + flags are read in from the object file, and some are + synthesized from other information. */ + + flagword flags; + #define SEC_NO_FLAGS 0x000 - /* Tells the OS to allocate space for this section when loaded. - This would clear for a section containing debug information only. - */ + /* Tells the OS to allocate space for this section when loaded. + This would clear for a section containing debug information + only. */ + + #define SEC_ALLOC 0x001 + /* Tells the OS to load the section from the file when loading. + This would be clear for a .bss section */ - /* Tells the OS to load the section from the file when loading. - This would be clear for a .bss section - */ #define SEC_LOAD 0x002 + /* The section contains data still to be relocated, so there will + be some relocation information too. */ - /* The section contains data still to be relocated, so there will be some - relocation information too. - */ #define SEC_RELOC 0x004 - /* Obsolete ? - */ + /* Obsolete ? */ + #define SEC_BALIGN 0x008 - /* A signal to the OS that the section contains read only data. - */ + /* A signal to the OS that the section contains read only + data. */ #define SEC_READONLY 0x010 - /* The section contains code only. - */ + /* The section contains code only. */ + #define SEC_CODE 0x020 - /* The section contains data only. - */ + /* The section contains data only. */ + #define SEC_DATA 0x040 - /* The section will reside in ROM. - */ + /* The section will reside in ROM. */ + #define SEC_ROM 0x080 - /* The section contains constructor information. This section type is - used by the linker to create lists of constructors and destructors - used by @code{g++}. When a back end sees a symbol which should be used - in a constructor list, it creates a new section for the type of name - (eg @code{__CTOR_LIST__}), attatches the symbol to it and builds a - relocation. To build the lists of constructors, all the linker has to - to is catenate all the sections called @code{__CTOR_LIST__} and - relocte the data contained within - exactly the operations it would - peform on standard data. - */ + /* The section contains constructor information. This section + type is used by the linker to create lists of constructors and + destructors used by <>. When a back end sees a symbol + which should be used in a constructor list, it creates a new + section for the type of name (eg <<__CTOR_LIST__>>), attaches + the symbol to it and builds a relocation. To build the lists + of constructors, all the linker has to to is catenate all the + sections called <<__CTOR_LIST__>> and relocte the data + contained within - exactly the operations it would peform on + standard data. */ + #define SEC_CONSTRUCTOR 0x100 - /* The section has contents - a bss section could be - @code{SEC_ALLOC} | @code{SEC_HAS_CONTENTS}, a debug section could be - @code{SEC_HAS_CONTENTS} - */ + /* The section is a constuctor, and should be placed at the + end of the . */ + + +#define SEC_CONSTRUCTOR_TEXT 0x1100 + +#define SEC_CONSTRUCTOR_DATA 0x2100 + +#define SEC_CONSTRUCTOR_BSS 0x3100 + + + /* The section has contents - a bss section could be + <> | <>, a debug section could be + <> */ + #define SEC_HAS_CONTENTS 0x200 - /* An instruction to the linker not to output sections containing - this flag even if they have information which would normally be written. - */ + /* An instruction to the linker not to output sections + containing this flag even if they have information which + would normally be written. */ + #define SEC_NEVER_LOAD 0x400 - /* The base address of the section in the address space of the target. - */ + /* 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 + size of <<.bss>>). This will be filled in after relocation */ + + bfd_size_type _cooked_size; + + /* The size on disk of the section in bytes originally. Normally this + value is the same as the size, but if some relaxing has + been done, then this value will be bigger. */ - /* The size of the section in bytes of the loaded section. This contains - a value even if the section has no contents (eg, the size of @code{.bss}). - */ - bfd_size_type size; + bfd_size_type _raw_size; + + /* If this section is going to be output, then this value is the + offset into the output section of the first byte in the input + section. Eg, if this was going to start at the 100th byte in + the output section, this value would be 100. */ - /* If this section is going to be output, then this value is the - offset into the output section of the first byte in the input - section. Eg, if this was going to start at the 100th byte in the - output section, this value would be 100. - */ bfd_vma output_offset; - /* The output section through which to map on output. - */ + /* The output section through which to map on output. */ + struct sec *output_section; - /* The alignment requirement of the section, as an exponent - eg 3 - aligns to 2^3 (or 8) - */ + /* The alignment requirement of the section, as an exponent - eg + 3 aligns to 2^3 (or 8) */ + unsigned int alignment_power; - /* If an input section, a pointer to a vector of relocation records for - the data in this section. - */ + /* If an input section, a pointer to a vector of relocation + records for the data in this section. */ + struct reloc_cache_entry *relocation; - /* If an output section, a pointer to a vector of pointers to - relocation records for the data in this section. - */ + /* If an output section, a pointer to a vector of pointers to + relocation records for the data in this section. */ + struct reloc_cache_entry **orelocation; - /* The number of relocation records in one of the above - */ + /* The number of relocation records in one of the above */ + unsigned reloc_count; - /* Which section is it 0..nth - */ - int index; + /* Information below is back end specific - and not always used + or updated + + File position of section data */ - /* Information below is back end specific - and not always used or - updated - - File position of section data - */ file_ptr filepos; + + /* File position of relocation info */ - /* File position of relocation info - */ file_ptr rel_filepos; - /* File position of line data - */ + /* File position of line data */ + file_ptr line_filepos; - /* Pointer to data for applications - */ + /* Pointer to data for applications */ + PTR userdata; + struct lang_output_section *otheruserdata; - /* Attached line number information - */ + /* Attached line number information */ + alent *lineno; + + /* Number of line number records */ - /* Number of line number records - */ unsigned int lineno_count; - /* When a section is being output, this value changes as more - linenumbers are written out - */ + /* 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; + /* what the section number is in the target world */ + + int target_index; + PTR used_by_bfd; - /* If this is a constructor section then here is a list of the - relocations created to relocate items within it. - */ + /* If this is a constructor section then here is a list of the + relocations created to relocate items within it. */ + struct relent_chain *constructor_chain; - /* The bfd which owns the section. - */ + /* The BFD which owns the section. */ + bfd *owner; + + boolean reloc_done; + /* A symbol which points at this section only */ + struct symbol_cache_entry *symbol; + struct symbol_cache_entry **symbol_ptr_ptr; + struct bfd_seclet *seclets_head; + struct bfd_seclet *seclets_tail; } asection ; -/* Runs through the provided @var{abfd} and returns the @code{asection} -who's name matches that provided, otherwise NULL. @xref{Sections}, for more information. - -*/ -PROTO(asection *, bfd_get_section_by_name, - (bfd *abfd, CONST char *name)); -/* This function creates a new empty section called @var{name} and attatches it -to the end of the chain of sections for @var{bfd}. An attempt to -create a section with a name which is already in use, returns the old -section by that name instead. - -Possible errors are: -@table @code -@item invalid_operation -If output has already started for this bfd. -@item no_memory -If obstack alloc fails. -@end table - -*/ -PROTO(asection *, bfd_make_section, (bfd *, CONST char *name)); -/* Attempts to set the attributes of the section named in the bfd -supplied to the value. Returns true on success, false on error. -Possible error returns are: -@table @code -@item invalid operation -The section cannot have one or more of the attributes requested. For -example, a .bss section in @code{a.out} may not have the -@code{SEC_HAS_CONTENTS} field set. -@end table - -*/ -PROTO(boolean, bfd_set_section_flags, - (bfd *, asection *, flagword)); -/* Calls the provided function @var{func} for each section attatched to -the bfd @var{abfd}, passing @var{obj} as an argument. The function -will be called as if by - -@example - func(abfd, the_section, obj); -@end example - - -*/ -PROTO(void, bfd_map_over_sections, - (bfd *abfd, void (*func)(), PTR obj)); -/* This is the prefered method for iterating over sections, an -alternative would be to use a loop: - -@example - section *p; - for (p = abfd->sections; p != NULL; p = p->next) - func(abfd, p, ...) -@end example*/ - -/* Sets @var{section} to the size @var{val}. If the operation is ok, then -@code{true} is returned, else @code{false}. - -Possible error returns: -@table @code -@item invalid_operation -Writing has started to the bfd, so setting the size is invalid -@end table - -*/ -PROTO(boolean, bfd_set_section_size, - (bfd *, asection *, bfd_size_type val)); -/* Sets the contents of the section @var{section} in bfd @var{abfd} to -the data starting in memory at @var{data}. The data is written to the -output section starting at offset @var{offset} for @var{count} bytes. - -Normally @code{true} is returned, else @code{false}. Possible error -returns are: -@table @code -@item no_contents -The output section does not have the @code{SEC_HAS_CONTENTS} -attribute, so nothing can be written to it. -@item and some more too -@end table -This routine is front end to the back end function @code{_bfd_set_section_contents}. - -*/ -PROTO(boolean, bfd_set_section_contents, - (bfd *abfd, - asection *section, - PTR data, - file_ptr offset, - bfd_size_type count)); -/* This function reads data from @var{section} in bfd @var{abfd} into -memory starting at @var{location}. The data is read at an offset of -@var{offset} from the start of the input section, and is read for -@var{count} bytes. - -If the contents of a constuctor with the @code{SEC_CONSTUCTOR} flag -set are requested, then the @var{location} is filled with zeroes. - -If no errors occur, @code{true} is returned, else @code{false}. -Possible errors are: - -@table @code -@item unknown yet -@end table - -*/ -PROTO(boolean, bfd_get_section_contents, - (bfd *abfd, asection *section, PTR location, - file_ptr offset, bfd_size_type count)); -/* @subsection typedef asymbol -An @code{asymbol} has the form: - -*/ + +#define BFD_ABS_SECTION_NAME "*ABS*" +#define BFD_UND_SECTION_NAME "*UND*" +#define BFD_COM_SECTION_NAME "*COM*" + + /* the absolute section */ + extern asection bfd_abs_section; + /* Pointer to the undefined section */ + extern asection bfd_und_section; + /* Pointer to the common section */ + extern asection bfd_com_section; + + extern struct symbol_cache_entry *bfd_abs_symbol; + extern struct symbol_cache_entry *bfd_com_symbol; + extern struct symbol_cache_entry *bfd_und_symbol; +#define bfd_get_section_size_before_reloc(section) \ + (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 * +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 +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 +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 */ + bfd_arch_obscure, /* Arch known, not one of these */ + bfd_arch_m68k, /* Motorola 68xxx */ + bfd_arch_vax, /* DEC Vax */ + bfd_arch_i960, /* Intel 960 */ + /* The order of the following is important. + lower number indicates a machine type that + only accepts a subset of the instructions + available to machines with higher numbers. + The exception is the "ca", which is + incompatible with all other machines except + "core". */ + +#define bfd_mach_i960_core 1 +#define bfd_mach_i960_ka_sa 2 +#define bfd_mach_i960_kb_sb 3 +#define bfd_mach_i960_mc 4 +#define bfd_mach_i960_xa 5 +#define bfd_mach_i960_ca 6 + + bfd_arch_a29k, /* AMD 29000 */ + bfd_arch_sparc, /* SPARC */ + bfd_arch_mips, /* MIPS Rxxxx */ + bfd_arch_i386, /* Intel 386 */ + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + bfd_arch_romp, /* IBM ROMP PC/RT */ + bfd_arch_alliant, /* Alliant */ + bfd_arch_convex, /* Convex */ + bfd_arch_m88k, /* Motorola 88xxx */ + 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 struct bfd_arch_info +{ + int bits_per_word; + int bits_per_address; + int bits_per_byte; + enum bfd_architecture arch; + long mach; + char *arch_name; + CONST char *printable_name; + unsigned int section_align_power; + /* true if this is the default machine for the architecture */ + boolean the_default; + 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 * +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 +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 * +bfd_printable_arch_mach + PARAMS ((enum bfd_architecture arch, unsigned long machine)); + +typedef enum bfd_reloc_status +{ + /* No errors detected */ + bfd_reloc_ok, + + /* The relocation was performed, but there was an overflow. */ + bfd_reloc_overflow, + + /* The address to relocate was not within the section supplied*/ + bfd_reloc_outofrange, + + /* Used by special functions */ + bfd_reloc_continue, + + /* Unused */ + bfd_reloc_notsupported, + + /* Unsupported relocation size requested. */ + bfd_reloc_other, + + /* The symbol to relocate against was undefined.*/ + bfd_reloc_undefined, + + /* The relocation was performed, but may not be ok - presently + generated only when linking i960 coff files with i960 b.out + symbols. */ + bfd_reloc_dangerous + } + bfd_reloc_status_type; + + +typedef struct reloc_cache_entry +{ + /* A pointer into the canonical table of pointers */ + struct symbol_cache_entry **sym_ptr_ptr; + + /* offset in section */ + rawdata_offset address; + + /* addend for relocation value */ + bfd_vma addend; + + /* Pointer to how to perform the required relocation */ + CONST struct reloc_howto_struct *howto; + +} arelent; + +typedef CONST struct reloc_howto_struct +{ + /* The type field has mainly a documetary use - the back end can + to what it wants with it, though the normally the back end's + external idea of what a reloc number would be would be stored + in this field. For example, the a PC relative word relocation + in a coff environment would have the type 023 - because that's + what the outside world calls a R_PCRWORD reloc. */ + unsigned int type; + + /* The value the final relocation is shifted right by. This drops + unwanted data from the relocation. */ + unsigned int rightshift; + + /* The size of the item to be relocated - 0, is one byte, 1 is 2 + bytes, 3 is four bytes. A -ve value indicates that the + result is to be subtracted from the data*/ + int size; + + /* Now obsolete. But m68k-coff still uses it. */ + unsigned int bitsize; + + /* Notes that the relocation is relative to the location in the + data section of the addend. The relocation function will + subtract from the relocation value the address of the location + being relocated. */ + boolean pc_relative; + + unsigned int bitpos; + +#if 1 + /* Now obsolete */ + boolean absolute; +#endif + + /* Causes the relocation routine to return an error if overflow + is detected when relocating. */ + boolean complain_on_overflow; + + /* If this field is non null, then the supplied function is + called rather than the normal function. This allows really + strange relocation methods to be accomodated (eg, i960 callj + instructions). */ + bfd_reloc_status_type (*special_function) + PARAMS ((bfd *abfd, + arelent *reloc_entry, + struct symbol_cache_entry *symbol, + PTR data, + asection *input_section, + bfd *output_bfd)); + + /* The textual name of the relocation type. */ + char *name; + + /* When performing a partial link, some formats must modify the + relocations rather than the data - this flag signals this.*/ + boolean partial_inplace; + + /* 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. */ + bfd_word src_mask; + + /* 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. */ + bfd_word dst_mask; + + /* When some formats create PC relative instructions, they leave + the value of the pc of the place being relocated in the offset + slot of the instruction, so that a PC relative relocation can + be made just by adding in an ordinary offset (eg sun3 a.out). + Some formats leave the displacement part of an instruction + empty (eg m88k bcs), this flag signals the fact.*/ + boolean pcrel_offset; + +} reloc_howto_type; +#define HOWTO(C, R,S,B, P, BI, ABS, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ + {(unsigned)C,R,S,B, P, BI, ABS,O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC} +#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,false,false,FUNCTION, NAME,false,0,0,IN) + +#define HOWTO_PREPARE(relocation, symbol) \ + { \ + if (symbol != (asymbol *)NULL) { \ + if (symbol->section == &bfd_com_section) { \ + relocation = 0; \ + } \ + else { \ + relocation = symbol->value; \ + } \ + } \ +} +typedef unsigned char bfd_byte; + +typedef struct relent_chain { + arelent relent; + struct relent_chain *next; +} arelent_chain; +bfd_reloc_status_type + +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, + + /* 8 bits wide, but used to form an address like 0xffnn */ + BFD_RELOC_8_FFnn, + + /* 8 bits wide, simple */ + BFD_RELOC_8, + + /* 8 bits wide, pc relative */ + BFD_RELOC_8_PCREL, + + /* The type of reloc used to build a contructor table - at the + moment probably a 32 bit wide abs address, but the cpu can + choose. */ + + 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 * + +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 + information (invisible to the application writer) is carried + with the symbol. */ - /* 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 with the symbol. - */ struct _bfd *the_bfd; - /* The text of the symbol. The name is left alone, and not copied - the - application may not alter it. - */ - CONST char *name; + /* The text of the symbol. The name is left alone, and not copied - the + application may not alter it. */ + CONST char *name; - /* The value of the symbol. - */ - symvalue value; + /* The value of the symbol.*/ + symvalue value; + + /* Attributes of a symbol: */ - /* Attributes of a symbol: - */ #define BSF_NO_FLAGS 0x00 - /* The symbol has local scope; @code{static} in @code{C}. The value is - the offset into the section of the data. - */ + /* The symbol has local scope; <> in <>. The value + is the offset into the section of the data. */ #define BSF_LOCAL 0x01 - /* The symbol has global scope; initialized data in @code{C}. The value - is the offset into the section of the data. - */ + /* The symbol has global scope; initialized data in <>. The + 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 the offset - into the section of the data. - */ + /* The symbol has global scope, and is exported. The value is + the offset into the section of the data. */ #define BSF_EXPORT 0x08 - /* The symbol is undefined. @code{extern} in @code{C}. The value has no meaning. - */ -#define BSF_UNDEFINED 0x10 + /* The symbol is undefined. <> in <>. The value has + no meaning. Obsolete; should be deleted? */ +#define BSF_UNDEFINED_OBS 0x10 - /* The symbol is common, initialized to zero; default in @code{C}. The - value is the size of the object in bytes. - */ -#define BSF_FORT_COMM 0x20 + /* The symbol is common, initialized to zero; default in + <>. The value is the size of the object in bytes. */ +#define BSF_FORT_COMM_OBS 0x20 - /* A normal @code{C} symbol would be one of: - @code{BSF_LOCAL}, @code{BSF_FORT_COMM}, @code{BSF_UNDEFINED} or @code{BSF_EXPORT|BSD_GLOBAL} - - The symbol is a debugging record. The value has an arbitary meaning. - */ -#define BSF_DEBUGGING 0x40 + /* A normal C symbol would be one of: + <>, <>, <> or + <> */ - /* The symbol has no section attached, any value is the actual value and - is not a relative offset to a section. - */ -#define BSF_ABSOLUTE 0x80 + /* The symbol is a debugging record. The value has an arbitary + 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_WARNING 0x20000 #define BSF_KEEP_G 0x80000 - /* Unused - */ + /* Unused; should be deleted? */ #define BSF_WEAK 0x100000 #define BSF_CTOR 0x200000 -#define BSF_FAKE 0x400000 - /* The symbol used to be a common symbol, but now it is allocated. - */ + /* 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 + allocated. */ #define BSF_OLD_COMMON 0x800000 - /* The default value for common data. - */ + /* The default value for common data. */ #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 @code{ISFCN} symbol which is also @code{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. - */ + /* In some files the type of a symbol sometimes alters its + location in an output file - ie in coff a <> symbol + which is also <> 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 + + /* Signal that the symbol is the label of constructor section. */ +#define BSF_CONSTRUCTOR 0x1000000 + + /* Signal that the symbol is a warning symbol. If the symbol + is a warning symbol, then the value field (I know this is + tacky) will point to the asymbol which when referenced will + cause the warning. */ +#define BSF_WARNING 0x2000000 + + /* 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 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ +#define BSF_FILE 0x08000000 + flagword flags; - /* Aointer to the section to which this symbol is relative, or 0 if the - symbol is absolute or undefined. Note that it is not sufficient to set - this location to 0 to mark a symbol as absolute - the flag - @code{BSF_ABSOLUTE} must be set also. - */ + /* A pointer to the section to which this symbol is + relative. This will always be non NULL, there are special + sections for undefined and absolute symbols */ struct sec *section; - /* Back end special data. This is being phased out in favour of making - this a union. - */ - PTR udata; -} asymbol; + /* Back end special data. This is being phased out in favour + of making this a union. */ + PTR udata; + + /* Application data. */ + union { unsigned long aflags; PTR aptr; } app_data; -/* Returns the number of bytes required in a vector of pointers to -@code{asymbols} for all the symbols in the supplied bfd, including a -terminal NULL pointer. If there are no symbols in the bfd, then 0 is -returned. -*/ +} asymbol; #define get_symtab_upper_bound(abfd) \ BFD_SEND (abfd, _get_symtab_upper_bound, (abfd)) - -/* Supplied a bfd and a pointer to an uninitialized vector of pointers. -This reads in the symbols from the bfd, and fills in the table with -pointers to the symbols, and a trailing NULL. The routine returns the -actual number of symbol pointers not including the NULL. - -*/ #define bfd_canonicalize_symtab(abfd, location) \ BFD_SEND (abfd, _bfd_canonicalize_symtab,\ (abfd, location)) +boolean +bfd_set_symtab PARAMS ((bfd *, asymbol **, unsigned int )); +void +bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol)); -/* Provided a table of pointers to to symbols and a count, writes to the -output bfd the symbols when closed. +#define bfd_make_empty_symbol(abfd) \ + BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) +#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)); -*/ -PROTO(boolean, bfd_set_symtab, (bfd *, asymbol **, unsigned int )); -/* Prints the value and flags of the symbol supplied to the stream file. +struct _bfd +{ + /* The filename the application opened the BFD with. */ + CONST char *filename; -*/ -PROTO(void, bfd_print_symbol_vandf, (PTR file, asymbol *symbol)); -/* This function creates a new @code{asymbol} structure for the bfd, and -returns a pointer to it. + /* A pointer to the target jump table. */ + struct bfd_target *xvec; -This routine is necessary, since each back end has private information -surrounding the @code{asymbol}. Building your own @code{asymbol} and -pointing to it will not create the private information, and will cause -problems later on. -*/ -#define bfd_make_empty_symbol(abfd) \ - BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) + /* To avoid dragging too many header files into every file that + includes `<>', 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". The iostream + is the result of an fopen on the filename. */ + char *iostream; -/* @section typedef bfd + /* Is the file being cached */ -Pointers to bfd structs are the cornerstone of any application using -libbfd. References though the bfd and to data in the bfd give the -entire bfd functionality. + boolean cacheable; -Finally! The BFD struct itself. This contains the major data about -the file, and contains pointers to the rest of the data. + /* Marks whether there was a default target specified when the + BFD was opened. This is used to select what matching algorithm + to use to chose the back end. */ -*/ -struct _bfd -{ + boolean target_defaulted; - /* The filename the application opened the bfd with. - */ - CONST char *filename; + /* The caching routines use these to maintain a + least-recently-used list of BFDs */ - /* A pointer to the target jump table. - */ - struct bfd_target *xvec; + struct _bfd *lru_prev, *lru_next; - /* 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". - - The iostream is the result of an fopen on the filename. - */ - char *iostream; - - /* Is the file being cached @xref{File Caching}. - */ - boolean cacheable; - - /* Marks whether there was a default target specified when the bfd was - opened. This is used to select what matching algorithm to use to chose - the back end. - */ - boolean target_defaulted; - - /* The caching routines use these to maintain an LRU list of bfds. - */ - struct _bfd *lru_prev, *lru_next; - - /* When a file is closed by the caching routines, it retains the state - here: - */ - file_ptr where; - - /* and here: - */ - boolean opened_once; - boolean mtime_set; - - /* File modified time - */ - long mtime; - - /* For output files, channel we locked (is this used?). - */ -int ifd; - - /* The format which belongs to the bfd. - */ - bfd_format format; - - /* The direction the bfd was opened with - */ - enum bfd_direction {no_direction = 0, - read_direction = 1, - write_direction = 2, - both_direction = 3} direction; - - /* Format_specific flags - */ - flagword flags; - - /* 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; - - /* Remember when output has begun, to stop strange things happening. - */ - boolean output_has_begun; - - /* Pointer to linked list of sections - */ - struct sec *sections; - - /* The number of sections - */ - unsigned int section_count; - - /* Stuff only usefull for object files: - The start address. - */ - bfd_vma start_address; - - /* Used for input and output - */ - unsigned int symcount; - - /* Symtab for output bfd - */ - struct symbol_cache_entry **outsymbols; - - /* Architecture of object machine, eg m68k - */ - enum bfd_architecture obj_arch; - - /* Particular machine within arch, e.g. 68010 - */ - unsigned long obj_machine; - - /* Stuff only usefull for archives: - */ - PTR arelt_data; - struct _bfd *my_archive; - struct _bfd *next; - struct _bfd *archive_head; - boolean has_armap; - - /* Used by the back end to hold private data. - */ - PTR tdata; - - /* Used by the application to hold private data - */ - PTR usrdata; - - /* Where all the allocated stuff under this BFD goes - */ - struct obstack memory; -}; + /* When a file is closed by the caching routines, BFD retains + state information on the file here: + */ -/* Marks the entry point of an output bfd. Returns @code{true} on -success, @code{false} otherwise. + file_ptr where; -*/ -PROTO(boolean, bfd_set_start_address,(bfd *, bfd_vma)); -/* Return cached file modification time (e.g. as read from archive header -for archive members, or from file system if we have been called -before); else determine modify time, cache it, and return it. + /* and here:*/ -*/ -PROTO(long, bfd_get_mtime, (bfd *)); -#define bfd_sizeof_headers(abfd, reloc) \ - BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) + boolean opened_once; -#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)) + /* Set if we have a locally maintained mtime value, rather than + getting it from the file each time: */ -#define bfd_debug_info_start(abfd) \ - BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) + boolean mtime_set; -#define bfd_debug_info_end(abfd) \ - BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) + /* File modified time, if mtime_set is true: */ -#define bfd_debug_info_accumulate(abfd, section) \ - BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) + long mtime; -#define bfd_stat_arch_elt(abfd, stat) \ - BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) + /* Reserved for an unimplemented file locking extension.*/ -#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)) - -/* What this does -*/ -PROTO(symindex, bfd_get_next_mapent, (bfd *, symindex, carsym **)); -/* Used whilst processing archives. Sets the head of the chain of bfds -contained in an archive to @var{new_head}. (see chapter on archives) -*/ -PROTO(boolean, bfd_set_archive_head, (bfd *output, bfd *new_head)); -/* *;PROTO(bfd *, bfd_get_elt_at_index, (bfd *, int));*/ - -/* Initially provided a bfd containing an archive and NULL, opens a bfd -on the first contained element and returns that. Subsequent calls to -bfd_openr_next_archived_file should pass the archive and the previous -return value to return a created bfd to the next contained element. -NULL is returned when there are no more. - -*/ -PROTO(bfd*, bfd_openr_next_archived_file, - (bfd *archive, bfd *previous)); -/* Returns a read-only string explaining what program was running when -it failed and produced the core file being read - -*/ -PROTO(CONST char *, bfd_core_file_failing_command, (bfd *)); -/* Returns the signal number which caused the core dump which generated -the file the bfd is attatched to. - -*/ -PROTO(int, bfd_core_file_failing_signal, (bfd *)); -/* Returns @code{true} if the core file attatched to @var{core_bfd} was -generated by a run of the executable file attatched to @var{exec_bfd}, -or else @code{false}. -*/ -PROTO(boolean, core_file_matches_executable_p, - (bfd *core_bfd, bfd *exec_bfd)); -/* The relocation routine returns as a status an enumerated type: - -*/ -typedef enum bfd_reloc_status { - - /* No errors detected - */ - bfd_reloc_ok, + int ifd; - /* The relocation was performed, but there was an overflow. - */ - bfd_reloc_overflow, + /* The format which belongs to the BFD.*/ - /* The address to relocate was not within the section supplied - */ - bfd_reloc_outofrange, + bfd_format format; - /* Used by special functions - */ - bfd_reloc_continue, + /* The direction the BFD was opened with*/ - /* Unused - */ - bfd_reloc_notsupported, + enum bfd_direction {no_direction = 0, + read_direction = 1, + write_direction = 2, + both_direction = 3} direction; - /* Unsupported relocation size requested. - */ - bfd_reloc_other, + /* Format_specific flags*/ - /* The symbol to relocate against was undefined. - */ - bfd_reloc_undefined, + flagword flags; - /* The relocaction was performed, but may not be ok - presently generated - only when linking i960 coff files with i960 b.out symbols. - */ - bfd_reloc_dangerous - } - bfd_reloc_status_enum_type; -typedef struct reloc_cache_entry -{ + /* 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. */ - /* A pointer into the canonical table of pointers - */ - struct symbol_cache_entry **sym_ptr_ptr; + file_ptr origin; - /* offset in section - */ - rawdata_offset address; + /* Remember when output has begun, to stop strange things + happening. */ + boolean output_has_begun; - /* addend for relocation value - */ - bfd_vma addend; + /* Pointer to linked list of sections*/ + struct sec *sections; - /* if sym is null this is the section - */ - struct sec *section; + /* The number of sections */ + unsigned int section_count; - /* Pointer to how to perform the required relocation - */ - CONST struct reloc_howto_struct *howto; -} arelent; + /* Stuff only useful for object files: + The start address. */ + bfd_vma start_address; -/* The @code{reloc_howto_type} is a structure which contains all the -information that bfd needs to know to tie up a back end's data. + /* Used for input and output*/ + unsigned int symcount; -*/ -typedef CONST struct reloc_howto_struct -{ + /* Symbol table for output BFD*/ + struct symbol_cache_entry **outsymbols; - /* The type field has mainly a documetary use - the back end can to what - it wants with it, though the normally the back end's external idea of - what a reloc number would be would be stored in this field. For - example, the a PC relative word relocation in a coff environment would - have the type 023 - because that's what the outside world calls a - R_PCRWORD reloc. - */ - unsigned int type; + /* Pointer to structure which contains architecture information*/ + struct bfd_arch_info *arch_info; - /* The value the final relocation is shifted right by. This drops - unwanted data from the relocation. - */ - unsigned int rightshift; + /* Stuff only useful for archives:*/ + PTR arelt_data; + struct _bfd *my_archive; + struct _bfd *next; + struct _bfd *archive_head; + boolean has_armap; - /* The size of the item to be relocated - 0, is one byte, 1 is 2 bytes, 3 - is four bytes. - */ - unsigned int size; + /* Used by the back end to hold private data. */ - /* Now obsolete - */ - unsigned int bitsize; + union + { + struct aout_data_struct *aout_data; + struct artdata *aout_ar_data; + struct _oasys_data *oasys_obj_data; + struct _oasys_ar_data *oasys_ar_data; + struct coff_tdata *coff_obj_data; + struct ieee_data_struct *ieee_data; + struct ieee_ar_data_struct *ieee_ar_data; + struct srec_data_struct *srec_data; + struct tekhex_data_struct *tekhex_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; + + /* Used by the application to hold private data*/ + PTR usrdata; - /* Notes that the relocation is relative to the location in the data - section of the addend. The relocation function will subtract from the - relocation value the address of the location being relocated. - */ - boolean pc_relative; + /* Where all the allocated stuff under this BFD goes */ + struct obstack memory; - /* Now obsolete - */ - unsigned int bitpos; + /* Is this really needed in addition to usrdata? */ + asymbol **ld_symbols; +}; - /* Now obsolete - */ - boolean absolute; +unsigned int +bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect)); - /* Causes the relocation routine to return an error if overflow is - detected when relocating. - */ - boolean complain_on_overflow; +unsigned int +bfd_canonicalize_reloc + PARAMS ((bfd *abfd, + asection *sec, + arelent **loc, + asymbol **syms)); - /* If this field is non null, then the supplied function is called rather - than the normal function. This allows really strange relocation - methods to be accomodated (eg, i960 callj instructions). - */ - bfd_reloc_status_enum_type (*special_function)(); +boolean +bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags)); - /* The textual name of the relocation type. - */ - char *name; +void +bfd_set_reloc + PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count) + + ); - /* When performing a partial link, some formats must modify the - relocations rather than the data - this flag signals this. - */ - boolean partial_inplace; +boolean +bfd_set_start_address PARAMS ((bfd *, bfd_vma)); - /* 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. - */ - bfd_word src_mask; +long +bfd_get_mtime PARAMS ((bfd *)); - /* 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. - */ - bfd_word dst_mask; +#define bfd_sizeof_headers(abfd, reloc) \ + BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) - /* When some formats create PC relative instructions, they leave the - value of the pc of the place being relocated in the offset slot of the - instruction, so that a PC relative relocation can be made just by - adding in an ordinary offset (eg sun3 a.out). Some formats leave the - displacement part of an instruction empty (eg m88k bcs), this flag - signals the fact. - */ - boolean pcrel_offset; -} reloc_howto_type; +#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)) -/* The HOWTO define is horrible and will go away. -*/ -#define HOWTO(C, R,S,B, P, BI, ABS, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ - {(unsigned)C,R,S,B, P, BI, ABS,O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC} -typedef unsigned char bfd_byte; + /* 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)) -typedef struct relent_chain { - arelent relent; - struct relent_chain *next; -} arelent_chain; +#define bfd_debug_info_end(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) +#define bfd_debug_info_accumulate(abfd, section) \ + BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) -/* If an output_bfd is supplied to this function the generated image -will be relocatable, the relocations are copied to the output file -after they have been changed to reflect the new state of the world. -There are two ways of reflecting the results of partial linkage in an -output file; by modifying the output data in place, and by modifying -the relocation record. Some native formats (eg basic a.out and basic -coff) have no way of specifying an addend in the relocation type, so -the addend has to go in the output data. This is no big deal since in -these formats the output data slot will always be big enough for the -addend. Complex reloc types with addends were invented to solve just -this problem. -*/ -PROTO(bfd_reloc_status_enum_type, - bfd_perform_relocation, - (bfd * abfd, - arelent *reloc_entry, - PTR data, - asection *input_section, - bfd *output_bfd)); -/* @node bfd_target -@subsection bfd_target -This structure contains everything that 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) +#define bfd_stat_arch_elt(abfd, stat) \ + BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) + +#define bfd_set_arch_mach(abfd, arch, mach)\ + BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) -/* This is the struct which defines the type of BFD this is. The -"xvec" member of the struct bfd itself points here. Each module -that implements access to a different target under BFD, defines -one of these. +#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)); -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! +boolean +bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head)); -*/ +bfd * +bfd_get_elt_at_index PARAMS ((bfd * archive, int index)); + +bfd* +bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous)); + +CONST char * +bfd_core_file_failing_command PARAMS ((bfd *)); + +int +bfd_core_file_failing_signal PARAMS ((bfd *)); + +boolean +core_file_matches_executable_p + PARAMS ((bfd *core_bfd, bfd *exec_bfd)); + +#define BFD_SEND(bfd, message, arglist) \ + ((*((bfd)->xvec->message)) arglist) +#define BFD_SEND_FMT(bfd, message, arglist) \ + (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) typedef struct bfd_target { - - /* identifies the kind of target, eg SunOS4, Ultrix, etc - */ char *name; - - /* The "flavour" of a back end is a general indication about the contents - of a file. - */ - 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; - - /* The order of bytes within the data area of a file. - */ + enum target_flavour { + bfd_target_unknown_flavour, + bfd_target_aout_flavour, + bfd_target_coff_flavour, + bfd_target_elf_flavour, + bfd_target_ieee_flavour, + bfd_target_oasys_flavour, + bfd_target_tekhex_flavour, + bfd_target_srec_flavour, + bfd_target_hppa_flavour} flavour; boolean byteorder_big_p; - - /* The order of bytes within the header parts of a file. - */ boolean header_byteorder_big_p; - - /* This is a mask of all the flags which an executable may have set - - from the set @code{NO_FLAGS}, @code{HAS_RELOC}, ...@code{D_PAGED}. - */ flagword object_flags; - - /* This is a mask of all the flags which a section may have set - from - the set @code{SEC_NO_FLAGS}, @code{SEC_ALLOC}, ...@code{SET_NEVER_LOAD}. - */ flagword section_flags; - - /* The pad character for filenames within an archive header. - */ + char symbol_leading_char; char ar_pad_char; - - /* The maximum number of characters in an archive header. - */ - unsigned short ar_max_namelen; - - /* The minimum alignment restriction for any section. - */ + unsigned short ar_max_namelen; unsigned int align_power_min; - - /* Entries for byte swapping for data. These are different to the other - entry points, since they don't take bfd as first arg. Certain other handlers - could do the same. - */ - 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 *)); - - /* Byte swapping for the headers - */ - 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 *)); - - /* Format dependent routines, these turn into vectors of entry points - within the target vector structure; one for each format to check. - - Check the format of a file being read. Return bfd_target * or zero. - */ - SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *)); - - /* Set the format of a file being written. - */ - SDEF_FMT (boolean, _bfd_set_format, (bfd *)); - - /* Write cached information into a file being written, at bfd_close. - */ - SDEF_FMT (boolean, _bfd_write_contents, (bfd *)); - - /* The following functions are defined in @code{JUMP_TABLE}. The idea is - that the back end writer of @code{foo} names all the routines - @code{foo_}@var{entry_point}, @code{JUMP_TABLE} will built the entries - in this structure in the right order. - - Core file entry points - */ - SDEF (char *, _core_file_failing_command, (bfd *)); - SDEF (int, _core_file_failing_signal, (bfd *)); - SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *)); - - /* Archive entry points - */ - 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, - int orl_count, + unsigned int orl_count, int stridx)); - - /* Standard stuff. - */ - 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)); - - /* Symbols and reloctions - */ - 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 *, - bfd_print_symbol_enum_type)); + 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 *)); - - /* Special entry points for gdb to swap in coff symbol table parts - */ - 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)); - + 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 * +bfd_find_target PARAMS ((CONST char *, bfd *)); -/* Returns a pointer to the transfer vector for the object target -named target_name. If target_name is NULL, chooses the one in the -environment variable GNUTARGET; if that is null or not defined then -the first entry in the target list is chosen. Passing in the -string "default" or setting the environment variable to "default" -will cause the first entry in the target list to be returned, -and "target_defaulted" will be set in the bfd. This causes -bfd_check_format to loop over all the targets to find the one -that matches the file being read. -*/ -PROTO(bfd_target *, bfd_find_target,(CONST char *, bfd *)); -/* This function returns a freshly malloced NULL-terminated vector of the -names of all the valid bfd targets. Do not modify the names -*/ -PROTO(CONST char **,bfd_target_list,()); -/* This routine is supplied a bfd and a format. It attempts to verify if -the file attatched to the bfd is indeed compatible with the format -specified (ie, one of @code{bfd_object}, @code{bfd_archive} or -@code{bfd_core}). - -If the bfd has been set to a specific @var{target} before the call, -only the named target and format combination will be checked. If the -target has not been set, or has been set to @code{default} then all -the known target backends will be interrogated to determine a match. - -The function returns @code{true} on success, otherwise @code{false} -with one of the following error codes: -@table @code -@item -invalid_operation -if @code{format} is not one of @code{bfd_object}, @code{bfd_archive} -or @code{bfd_core}. -@item system_call_error -if an error occured during a read - even some file mismatches can -cause system_call_errros -@item file_not_recognised -none of the backends recognised the file format -@item file_ambiguously_recognized -more than one backend recognised the file format. -@end table -*/ -PROTO(boolean, bfd_check_format, (bfd *abfd, bfd_format format)); -/* This function sets the file format of the supplied bfd to the format -requested. If the target set in the bfd does not support the format -requested, the format is illegal or the bfd is not open for writing -than an error occurs. -*/ -PROTO(boolean,bfd_set_format,(bfd *, bfd_format)); -/* This function takes one argument, and enumerated type (bfd_format) and -returns a pointer to a const string "invalid", "object", "archive", -"core" or "unknown" depending upon the value of the enumeration. -*/ -PROTO(CONST char *, bfd_format_string, (bfd_format)); -#endif +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