diff options
| -rw-r--r-- | bfd/.Sanitize | 21 | ||||
| -rw-r--r-- | bfd/Makefile.in | 97 | ||||
| -rw-r--r-- | bfd/aoutf1.h | 87 | ||||
| -rw-r--r-- | bfd/aoutx.h | 157 | ||||
| -rw-r--r-- | bfd/archive.c | 171 | ||||
| -rw-r--r-- | bfd/bfd.c | 947 | ||||
| -rw-r--r-- | bfd/coffcode.h | 2353 | ||||
| -rw-r--r-- | bfd/ieee.c | 1374 | ||||
| -rw-r--r-- | bfd/libbfd.c | 216 | ||||
| -rw-r--r-- | bfd/libbfd.h | 59 | ||||
| -rw-r--r-- | bfd/newsos3.c | 61 | ||||
| -rw-r--r-- | bfd/oasys.c | 636 | ||||
| -rw-r--r-- | bfd/opncls.c | 85 | ||||
| -rw-r--r-- | bfd/srec.c | 33 | ||||
| -rw-r--r-- | bfd/targets.c | 415 |
15 files changed, 4204 insertions, 2508 deletions
diff --git a/bfd/.Sanitize b/bfd/.Sanitize index 7c527af..89a5e3d 100644 --- a/bfd/.Sanitize +++ b/bfd/.Sanitize @@ -28,7 +28,9 @@ echo Sanitizing `pwd`... Things-to-keep: COPYING +bfd.texinfo ChangeLog +Makefile Makefile.in TODO VERSION @@ -40,19 +42,17 @@ archive.c archures.c archures.h bfd.c -bfd.doc bout.c cache.c coffcode.h -coffish.h -coffswap.c -config -configure +config.status +configure* configure.in -cplus-dem.c +core.c demo64.c ecoff.c filemode.c +format.c host-aout.c i386coff.c icoff.c @@ -65,12 +65,14 @@ libieee.h liboasys.h m68kcoff.c m88k-bcs.c -misc.h newsos3.c oasys.c opncls.c +reloc.c +section.c srec.c sunos.c +syms.c targets.c trad-core.c trad-core.h @@ -82,7 +84,10 @@ echo Done in `pwd`. # # # $Log$ -# Revision 1.3 1991/05/31 11:22:12 gnu +# Revision 1.4 1991/07/04 16:52:54 steve +# Now full of documentation. Yum Yum. +# +# Revision 1.3 1991/05/31 11:22:12 gnu # Remove coff-code.h and liba.out.h, add libaout.h. # # Revision 1.2 1991/05/29 02:40:08 gnu diff --git a/bfd/Makefile.in b/bfd/Makefile.in index 9d32e33..a8a74e2 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -1,4 +1,4 @@ -# + # # Copyright (C) 1990, 1991 Free Software Foundation, Inc. # # This file is part of BFD, the Binary File Diddler. @@ -20,6 +20,8 @@ # $Id$ srcdir = . +destdir = /usr/local +libdir = $(destdir)/lib RANLIB = ranlib AR = ar @@ -35,18 +37,21 @@ CFLAGS = -g $(HDEFINES) $(TDEFINES) $(CSEARCH) $(CSWITCHES) # -DINTEL960VERSION BFD_LIBS = libbfd.o opncls.o bfd.o archive.o targets.o cache.o \ - archures.o + archures.o core.o section.o format.o syms.o reloc.o -BFD_BACKENDS = oasys.o ieee.o srec.o aout64.o aout32.o sunos.o icoff.o demo64.o \ - m68kcoff.o i386coff.o m88k-bcs.o coffswap.o ecoff.o newsos3.o # trad-core.o bout.o +BFD_BACKENDS = oasys.o ieee.o srec.o aout64.o aout32.o sunos.o icoff.o \ +demo64.o \ +m68kcoff.o i386coff.o m88k-bcs.o ecoff.o newsos3.o # trad-core.o bout.o BFD_H=$(INCDIR)/bfd.h SYSDEP_H=$(INCDIR)/sysdep.h # C source files that correspond to .o's. CFILES = libbfd.c opncls.c bfd.c archive.c targets.c cache.c archures.c \ - i386coff.c aout64.c aout32.c sunos.c demo64.c icoff.c srec.c oasys.c ieee.c m68kcoff.c \ - m88k-bcs.c coffswap.c ecoff.c trad-core.c newsos3.c #bout.c + i386coff.c aout64.c aout32.c sunos.c demo64.c icoff.c srec.c \ +oasys.c ieee.c m68kcoff.c \ +format.c section.c core.c syms.c reloc.c \ + m88k-bcs.c ecoff.c trad-core.c newsos3.c #bout.c STAGESTUFF = $(TARGETLIB) $(OFILES) @@ -149,6 +154,8 @@ roll: force: install: + install -c libbfd.a $(libdir) + $(RANLIB) $(libdir)/libbfd.a # Target to uncomment host-specific lines in this makefile. Such lines must # have the following string beginning in column 1: #__<hostname>__# @@ -181,3 +188,81 @@ Makefile: $(srcdir)/Makefile.in $(srcdir)/configure dep: $(CFILES) mkdep $(CFLAGS) $? + + +# Stuff to make the documentation for bfd. +# +# make docs +# rebuilds the documentation. Has to be done when the source is +# modified until I work out how to do this properly +# +# make docs headers +# rebuilds the header files from the source +# +# make docs texdoc +# rebuilds the bfd.dvi manual +# +# make docs texinfo +# rebuilts the bfdinfo manual + + +.SUFFIXES: .doc .o .c .h .proto + +.c.doc: + makedoc <$< doc/$*.doc doc/$*.proto doc/$*.protointernal doc/$*.drop + +.h.doc: + makedoc <$< doc/$*.doc doc/$*.proto doc/$*.protointernal doc/$*.drop + +.proto.doc: + makedoc <$< doc/$*.doc doc/$*.proto doc/$*.protointernal doc/$*.drop + + +DSRC=$(CFILES) + +docs: syms.doc bfd.doc cache.doc format.doc section.doc archive.doc \ + core.doc libbfd.doc archures.doc reloc.doc opncls.doc \ + targets.doc aoutx.doc coffcode.doc + + +PROTOS = doc/opncls.proto doc/archures.proto doc/libbfd.proto doc/section.proto doc/syms.proto doc/bfd.proto doc/archive.proto \ + doc/reloc.proto doc/targets.proto doc/format.proto + + +headers : $(PROTOS) + mkdir -f doc + # Rebuild prototypes in bfd.h + sed <$(BFD_H) >bfd.h.new -e '1,/THE FOLLOWING/!d' + cat doc/opncls.proto doc/archures.proto \ + doc/libbfd.proto doc/section.proto doc/syms.proto doc/bfd.proto doc/archive.proto \ + doc/reloc.proto doc/targets.proto doc/format.proto >>bfd.h.new + echo >> bfd.h.new + echo "#endif" >> bfd.h.new + echo >> bfd.h.new + mv bfd.h.new $(BFD_H) + + # and libbfd.h + sed < libbfd.h >libbfd.h.new -e '1,/THE FOLLOWING/!d' + cat doc/libbfd.protointernal doc/cache.protointernal doc/reloc.protointernal >> libbfd.h.new + echo >> libbfd.h.new + mv libbfd.h.new libbfd.h + + # and libcoff.h + sed < $(srcdir)/libcoff.h >libcoff.h.new -e '1,/THE FOLLOWING/!d' + cat doc/coffcode.proto >>libcoff.h.new + mv libcoff.h.new $(srcdir)/libcoff.h + + +texinfo: + makeinfo +no-validate bfd.texinfo + +texdoc: + tex bfd.texinfo + texindex bfd.?? + tex bfd.texinfo + +quickdoc: $(DSRC) docs + tex bfd.texinfo + + + diff --git a/bfd/aoutf1.h b/bfd/aoutf1.h index ad3c12d..a9a9934 100644 --- a/bfd/aoutf1.h +++ b/bfd/aoutf1.h @@ -1,5 +1,3 @@ -/* BFD backend for generic a.out flavour 1 */ - /* Copyright (C) 1990, 1991 Free Software Foundation, Inc. This file is part of BFD, the Binary File Diddler. @@ -18,6 +16,7 @@ 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. */ + #include <ansidecl.h> #include <sysdep.h> struct external_exec; @@ -33,6 +32,33 @@ struct external_exec; #include "ar.h" +/* +inheritd two core files and various implimentation files. +The file @code{aoutf1.h} contains the code for BFD's +a.out back end. Control over the generated back end is given by these +three preprocessor names: +@table @code +@item ARCH +This value should be either 32 or 64, depending upon the size of an +int in the target format. It changes the sizes of the structs which +perform the memory/disk mapping of structures. + +The 64 bit backend may only be used if the host compiler supports 64 +ints (eg with gcc), by defining the name @code{HOST_64_BIT}. With this +name defined, @emph{all} bfd operations are performed with 64bit +arithmetic, not just those to a 64bit target. + +@item TARGETNAME +bit long longsIf bfd is being compiled with gcc, (or any other compiler which gives +64 bit long longs), +@item +It is structured in such a way that @code{#define}ing +the size of the architecture into a @code{#include}ing +it with different @code{#define}s present will alter the definitions +of various structures in include files and generate correct code for +th + +*/ void (*bfd_error_trap)(); @@ -177,7 +203,7 @@ DEFUN(NAME(aout,sunos4_write_object_contents),(abfd), choose_reloc_size(abfd); /* FIXME */ - N_SET_FLAGS (*execp, 0x81); + N_SET_FLAGS (*execp, 0x1); WRITE_HEADERS(abfd, execp); @@ -461,31 +487,42 @@ DEFUN(swapcore,(abfd, core), #define aout_64_core_file_failing_signal sunos4_core_file_failing_signal #define aout_64_core_file_matches_executable_p sunos4_core_file_matches_executable_p +#define aout_64_bfd_debug_info_start bfd_void +#define aout_64_bfd_debug_info_end bfd_void +#define aout_64_bfd_debug_info_accumulate bfd_void + +#define aout_32_bfd_debug_info_start bfd_void +#define aout_32_bfd_debug_info_end bfd_void +#define aout_32_bfd_debug_info_accumulate bfd_void + + + /* We implement these routines ourselves, rather than using the generic a.out versions. */ #define aout_write_object_contents sunos4_write_object_contents bfd_target VECNAME = { -TARGETNAME, - bfd_target_aout_flavour_enum, - true, /* target byte order */ - true, /* target headers byte order */ - (HAS_RELOC | EXEC_P | /* object flags */ - HAS_LINENO | HAS_DEBUG | - HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ - ' ', /* ar_pad_char */ - 16, /* ar_max_namelen */ - _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */ - _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ - - {_bfd_dummy_target, NAME(sunos,object_p), - bfd_generic_archive_p, sunos4_core_file_p}, - {bfd_false, NAME(aout,mkobject), - _bfd_generic_mkarchive, bfd_false}, - {bfd_false, NAME(aout,sunos4_write_object_contents), /* bfd_write_contents */ - _bfd_write_archive_contents, bfd_false}, - - JUMP_TABLE(JNAME(aout)) -}; + TARGETNAME, + bfd_target_aout_flavour_enum, + true, /* target byte order */ + true, /* target headers byte order */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + 3, /* minimum alignment power */ + _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */ + _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ + + {_bfd_dummy_target, NAME(sunos,object_p), + bfd_generic_archive_p, sunos4_core_file_p}, + {bfd_false, NAME(aout,mkobject), + _bfd_generic_mkarchive, bfd_false}, + {bfd_false, NAME(aout,sunos4_write_object_contents), /* bfd_write_contents */ + _bfd_write_archive_contents, bfd_false}, + + JUMP_TABLE(JNAME(aout)) + }; diff --git a/bfd/aoutx.h b/bfd/aoutx.h index 399584c..8d68ccc 100644 --- a/bfd/aoutx.h +++ b/bfd/aoutx.h @@ -20,13 +20,69 @@ along with BFD; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ +/*doc* +@section a.out backends + +BFD supports a number of different flavours of a.out format, though +the major differences are only the sizes of the structures on disk, +and the shape of the relocation information. + +The support is split into a basic support file @code{aoutx.h} and +other files which derive functions from the base. One derivation file +is @code{aoutf1.h} (for a.out flavour 1), and adds to the basic a.out +functions support for sun3, sun4, 386 and 29k a.out files, to create a +target jump vector for a specific target. + +This information is further split out into more specific files for each +machine, including @code{sunos.c} - for sun3 and sun4 and +@code{demo64} for a demonstration of a 64 bit a.out format. + +The base file @code{aoutx.h} defines general mechanisms for reading +and writing records to and from disk, and various other methods which +bfd requires. It is included by @code{aout32.c} and @code{aout64.c} to +form the names aout_32_swap_exec_header_in, +aout_64_swap_exec_header_in, etc. + +As an example, this is what goes on to make the back end for a sun4, from aout32.c + +@example + #define ARCH_SIZE 32 + #include "aoutx.h" +@end example + +Which exports names: +@example + ... + aout_32_canonicalize_reloc + aout_32_find_nearest_line + aout_32_get_lineno + aout_32_get_reloc_upper_bound + ... +@end example + +from sunos.c + +@example + #define ARCH 32 + #define TARGET_NAME "a.out-sunos-big" + #define VECNAME sunos_big_vec + #include "aoutf1.h" +@end example +requires all the names from aout32.c, and produces the jump vector + +@example + sunos_big_vec +@end example + +*/ + #include <sysdep.h> #include <ansidecl.h> #include "bfd.h" struct external_exec; -#include "liba.out.h" +#include "libaout.h" #include "libbfd.h" #include "aout64.h" #include "stab.gnu.h" @@ -34,9 +90,15 @@ struct external_exec; void (*bfd_error_trap)(); -/*SUPPRESS558*/ -/*SUPPRESS529*/ +/*doc* +@subsection relocations +The file @code{aoutx.h} caters for both the @emph{standard} and +@emph{extended} forms of a.out relocation records. +The standard records are characterised by containing only an address, +a symbol index and a type field. The extended records (used on 29ks +and sparcs) also have a full integer for an addend. +*/ #define CTOR_TABLE_RELOC_IDX 2 static reloc_howto_type howto_table_ext[] = { @@ -85,6 +147,24 @@ HOWTO( 7, 0, 3, 64, true, 0, false, true,0,"DISP64", true, 0xfeedfac bfd_error_vector_type bfd_error_vector; + +/*doc* +@subsection Internal Entry Points +@code{aoutx.h} exports several routines for accessing the contents of +an a.out file, which are gathered and exported in turn by various +format specific files (eg sunos.c). +*/ + +/*doc* +*i aout_<size>_swap_exec_header_in +Swaps the information in an executable header taken from a raw byte stream memory image, +into the internal exec_header structure. +*; PROTO(void, aout_<size>_swap_exec_header_in, + (bfd *abfd, + struct external_exec *raw_bytes, + struct internal_exec *execp)); +*/ + void DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp), bfd *abfd AND @@ -104,6 +184,15 @@ DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp), execp->a_drsize = GET_WORD (abfd, bytes->e_drsize); } +/*doc* +*i aout_<size>_swap_exec_header_out +Swaps the information in an internal exec header structure into the +supplied buffer ready for writing to disk. +*; PROTO(void, aout_<size>_swap_exec_header_out, + (bfd *abfd, + struct internal_exec *execp, + struct external_exec *raw_bytes)); +*/ void DEFUN(NAME(aout,swap_exec_header_out),(abfd, execp, raw_bytes), bfd *abfd AND @@ -128,10 +217,19 @@ struct container { struct internal_exec e; }; -/* Some A.OUT variant thinks that the file whose format we're checking - is an a.out file. Do some more checking, and set up for access if - it really is. Call back to the calling environments "finish up" - function just before returning, to handle any last-minute setup. */ + +/*doc* +*i aout_<size>_some_aout_object_p + +Some A.OUT variant thinks that the file whose format we're checking +is an a.out file. Do some more checking, and set up for access if +it really is. Call back to the calling environments "finish up" +function just before returning, to handle any last-minute setup. + +*; PROTO(bfd_target *, aout_<size>_some_aout_object_p, + (bfd *abfd, + bfd_target *(*callback_to_real_object_p)())); +*/ bfd_target * DEFUN(NAME(aout,some_aout_object_p),(abfd, callback_to_real_object_p), @@ -282,6 +380,13 @@ DEFUN(NAME(aout,some_aout_object_p),(abfd, callback_to_real_object_p), return (*callback_to_real_object_p)(abfd); } +/*doc* +*i aout_<size>_mkobject + +This routine initializes a bfd for use with a.out files. + +*; PROTO(boolean, aout_<size>_mkobject, (bfd *)); +*/ boolean DEFUN(NAME(aout,mkobject),(abfd), @@ -314,12 +419,21 @@ DEFUN(NAME(aout,mkobject),(abfd), return true; } -/* Keep track of machine architecture and machine type for a.out's. + +/*doc* +*i aout_<size>_machine_type + +Keep track of machine architecture and machine type for a.out's. Return the machine_type for a particular arch&machine, or M_UNKNOWN if that exact arch&machine can't be represented in a.out format. If the architecture is understood, machine type 0 (default) should -always be understood. */ +always be understood. + +*; PROTO(enum machine_type, aout_<size>_machine_type, + (enum bfd_architecture arch, + unsigned long machine)); +*/ enum machine_type DEFUN(NAME(aout,machine_type),(arch, machine), @@ -360,6 +474,19 @@ DEFUN(NAME(aout,machine_type),(arch, machine), return arch_flags; } +/*doc* +*i aout_<size>_set_arch_mach + +Sets the architecture and the machine of the bfd to those values +supplied. Verifies that the format can support the architecture +required. + +*; PROTO(boolean, aout_<size>_set_arch_mach, + (bfd *, + enum bfd_architecture, + unsigned long machine)); +*/ + boolean DEFUN(NAME(aout,set_arch_mach),(abfd, arch, machine), bfd *abfd AND @@ -373,9 +500,15 @@ DEFUN(NAME(aout,set_arch_mach),(abfd, arch, machine), return false; /* We can't represent this type */ return true; /* We're easy ... */ } - -/* exec and core file sections */ +/*doc* +*i aout_<size>new_section_hook + +Called by the bfd in response to a @code{bfd_make_section} request. +*; PROTO(boolean, aout_<size>_new_section_hook, + (bfd *abfd, + asection *newsect)); +*/ boolean DEFUN(NAME(aout,new_section_hook),(abfd, newsect), bfd *abfd AND @@ -1460,7 +1593,7 @@ DEFUN(NAME(aout,find_nearest_line),(abfd, buffer[sizeof(buffer)-1] = 0; /* Have to remove : stuff */ p = strchr(buffer,':'); - if (p != NULL) {*p = NULL; } + if (p != NULL) { *p = NULL; } *functionname_ptr = buffer; return true; diff --git a/bfd/archive.c b/bfd/archive.c index a4431cc..fd7fc3c 100644 --- a/bfd/archive.c +++ b/bfd/archive.c @@ -1,6 +1,4 @@ -/*** archive.c -- an attempt at combining the machine-independent parts of - archives */ /* Copyright (C) 1990, 1991 Free Software Foundation, Inc. @@ -21,6 +19,21 @@ along with BFD; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ +/*doc* +@setfilename archive-info +@section Archives + +Gumby, you promised to write this bit... + +Archives are supported in bfd in @code{archive.c}. + +An archive is represented internally just like another bfd, with a +pointer to a chain of contained bfds. Archives can be created by +opening bfds, linking them together and attatching them as children to +another bfd and then closing the parent bfd. + +*-*/ + /* Assumes: o - all archive elements start on an even boundary, newline padded; o - all arch headers are char *; @@ -72,6 +85,10 @@ _bfd_generic_mkarchive (abfd) return true; } +/*proto* bfd_get_next_mapent +What this does +*; PROTO(symindex, bfd_get_next_mapent, (bfd *, symindex, carsym **)); +*/ symindex bfd_get_next_mapent (abfd, prev, entry) bfd *abfd; @@ -107,9 +124,16 @@ _bfd_create_empty_archive_element_shell (obfd) return nbfd; } +/*proto* bfd_set_archive_head +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)); +*/ + boolean -bfd_set_archive_head (output_archive, new_head) - bfd *output_archive, *new_head; +DEFUN(bfd_set_archive_head,(output_archive, new_head), + bfd *output_archive AND + bfd *new_head) { output_archive->archive_head = new_head; @@ -229,8 +253,10 @@ snarf_ar_hdr (abfd) return NULL; } - /* extract the filename from the archive */ - if (hdr.ar_name[0] == ' ' && bfd_ardata (abfd)->extended_names != NULL) { + /* extract the filename from the archive - there are two ways to + specify an extendend name table, either the first char of the + name is a space, or it's a slash */ + if ((hdr.ar_name[0] == '/' || hdr.ar_name[0] == ' ') && bfd_ardata (abfd)->extended_names != NULL) { filename = get_extended_arelt_filename (abfd, hdr.ar_name); if (filename == NULL) { bfd_error = malformed_archive; @@ -325,10 +351,22 @@ bfd_get_elt_at_index (abfd, index) return result; } -/* If you've got an archive, call this to read each subfile. */ +/*proto* bfd_openr_next_archived_file +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)); + +*/ + bfd * -bfd_openr_next_archived_file (archive, last_file) - bfd *archive, *last_file; +DEFUN(bfd_openr_next_archived_file,(archive, last_file), + bfd *archive AND + bfd*last_file) { if ((bfd_get_format (archive) != bfd_archive) || @@ -411,7 +449,7 @@ boolean bfd_slurp_bsd_armap (abfd) bfd *abfd; { - int i; + struct areltdata *mapdata; char nextname[17]; unsigned int counter = 0; @@ -451,7 +489,7 @@ bfd_slurp_bsd_armap (abfd) goto byebye; } - ardata->symdef_count = bfd_h_get_32(abfd, raw_armap) / sizeof (struct symdef); + ardata->symdef_count = bfd_h_get_32(abfd, (PTR)raw_armap) / sizeof (struct symdef); ardata->cache = 0; rbase = raw_armap+1; ardata->symdefs = (carsym *) rbase; @@ -459,8 +497,8 @@ bfd_slurp_bsd_armap (abfd) for (;counter < ardata->symdef_count; counter++) { struct symdef *sym = ((struct symdef *) rbase) + counter; - sym->s.name = bfd_h_get_32(abfd, &(sym->s.string_offset)) + stringbase; - sym->file_offset = bfd_h_get_32(abfd, &(sym->file_offset)); + sym->s.name = bfd_h_get_32(abfd, (PTR)(&(sym->s.string_offset))) + stringbase; + sym->file_offset = bfd_h_get_32(abfd, (PTR)( &(sym->file_offset))); } ardata->first_file_filepos = bfd_tell (abfd); @@ -501,13 +539,16 @@ bfd_slurp_coff_armap (abfd) if (mapdata == NULL) return false; raw_armap = (int *) bfd_alloc(abfd,mapdata->parsed_size); - if (raw_armap == NULL) { + + if (raw_armap == NULL) + { bfd_error = no_memory; byebye: bfd_release (abfd, (PTR)mapdata); return false; } + /* read in the raw map */ if (bfd_read ((PTR)raw_armap, 1, mapdata->parsed_size, abfd) != mapdata->parsed_size) { bfd_error = malformed_archive; @@ -552,19 +593,22 @@ bfd_slurp_coff_armap (abfd) ardata->first_file_filepos = bfd_tell (abfd); /* Pad to an even boundary if you have to */ ardata->first_file_filepos += (ardata->first_file_filepos) %2; - bfd_release (abfd, (PTR)raw_armap); - bfd_release (abfd, (PTR)mapdata); + +/* bfd_release (abfd, (PTR)raw_armap); + bfd_release (abfd, (PTR)mapdata);*/ bfd_has_map (abfd) = true; return true; } /** Extended name table. - Normally archives support only 14-character filenames. Intel has extended - the format: longer names are stored in a special element (the first in the - archive, or second if there is an armap); the name in the ar_hdr is replaced - by <space><index into filename element>. Index is the P.R. of an int (radix: - 8). */ + Normally archives support only 14-character filenames. + + Intel has extended the format: longer names are stored in a special + element (the first in the archive, or second if there is an armap); + the name in the ar_hdr is replaced by <space><index into filename + element>. Index is the P.R. of an int (radix: 8). Data General have + extended the format by using the prefix // for the special element */ /* Returns false on error, true otherwise */ boolean @@ -578,49 +622,52 @@ _bfd_slurp_extended_name_table (abfd) we probably don't want to return true. */ if (bfd_read ((PTR)nextname, 1, 16, abfd) == 16) { - bfd_seek (abfd, -16L, SEEK_CUR); + bfd_seek (abfd, -16L, SEEK_CUR); - if (strncmp (nextname, "ARFILENAMES/ ", 16)) { - bfd_ardata (abfd)->extended_names = NULL; - return true; - } + if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 && + strncmp (nextname, "// ", 16) != 0) + { + bfd_ardata (abfd)->extended_names = NULL; + return true; + } - namedata = snarf_ar_hdr (abfd); - if (namedata == NULL) return false; + namedata = snarf_ar_hdr (abfd); + if (namedata == NULL) return false; - bfd_ardata (abfd)->extended_names = bfd_zalloc(abfd,namedata->parsed_size); - if (bfd_ardata (abfd)->extended_names == NULL) { - bfd_error = no_memory; - byebye: - bfd_release (abfd, (PTR)namedata); - return false; - } + bfd_ardata (abfd)->extended_names = bfd_zalloc(abfd,namedata->parsed_size); + if (bfd_ardata (abfd)->extended_names == NULL) { + bfd_error = no_memory; + byebye: + bfd_release (abfd, (PTR)namedata); + return false; + } - if (bfd_read ((PTR)bfd_ardata (abfd)->extended_names, 1, - namedata->parsed_size, abfd) != namedata->parsed_size) { - bfd_error = malformed_archive; - bfd_release (abfd, (PTR)(bfd_ardata (abfd)->extended_names)); - bfd_ardata (abfd)->extended_names = NULL; - goto byebye; - } + if (bfd_read ((PTR)bfd_ardata (abfd)->extended_names, 1, + namedata->parsed_size, abfd) != namedata->parsed_size) { + bfd_error = malformed_archive; + bfd_release (abfd, (PTR)(bfd_ardata (abfd)->extended_names)); + bfd_ardata (abfd)->extended_names = NULL; + goto byebye; + } - /* It appears that the extended names are newline-padded, not null padded. - */ - { - char *temp = bfd_ardata (abfd)->extended_names; - for (; *temp != '\0'; ++temp) - if (*temp == '\n') *temp = '\0'; - } + /* Since the archive is supposed to be printable if it contains + text, the entries in the list are newline-padded, not null + padded. We'll fix that there.. */ + { + char *temp = bfd_ardata (abfd)->extended_names; + for (; *temp != '\0'; ++temp) + if (*temp == '\n') *temp = '\0'; + } - /* Pad to an even boundary if you have to */ - bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd); - bfd_ardata (abfd)->first_file_filepos += - (bfd_ardata (abfd)->first_file_filepos) %2; - - /* FIXME, we can't release namedata here because it was allocated - below extended_names on the obstack... */ - /* bfd_release (abfd, namedata); */ -} + /* Pad to an even boundary if you have to */ + bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd); + bfd_ardata (abfd)->first_file_filepos += + (bfd_ardata (abfd)->first_file_filepos) %2; + + /* FIXME, we can't release namedata here because it was allocated + below extended_names on the obstack... */ + /* bfd_release (abfd, namedata); */ + } return true; } @@ -1127,7 +1174,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx) for (i = 0; i < sizeof (struct ar_hdr); i++) if (((char *)(&hdr))[i] == '\0') (((char *)(&hdr))[i]) = ' '; bfd_write ((char *)&hdr, 1, sizeof (struct ar_hdr), arch); - bfd_h_put_32(arch, ranlibsize, &temp); + bfd_h_put_32(arch, ranlibsize, (PTR)&temp); bfd_write (&temp, 1, sizeof (temp), arch); for (count = 0; count < orl_count; count++) { @@ -1143,13 +1190,13 @@ bsd_write_armap (arch, elength, map, orl_count, stridx) } /* if new archive element */ last_elt = current; - bfd_h_put_32(arch, ((map[count]).namidx), &outs.s.string_offset); - bfd_h_put_32(arch, firstreal, &outs.file_offset); + bfd_h_put_32(arch, ((map[count]).namidx),(PTR) &outs.s.string_offset); + bfd_h_put_32(arch, firstreal,(PTR) &outs.file_offset); bfd_write ((char *)outp, 1, sizeof (outs), arch); } /* now write the strings themselves */ - bfd_h_put_32(arch, stridx, &temp); + bfd_h_put_32(arch, stridx, (PTR)&temp); bfd_write ((PTR)&temp, 1, sizeof (temp), arch); for (count = 0; count < orl_count; count++) bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch); @@ -1,11 +1,3 @@ - /* -*- C -*- */ - -/*** bfd -- binary file diddling routines by Gumby Wallace of Cygnus Support. - Every definition in this file should be exported and declared - in bfd.h. If you don't want it to be user-visible, put it in - libbfd.c! -*/ - /* Copyright (C) 1990, 1991 Free Software Foundation, Inc. This file is part of BFD, the Binary File Diddler. @@ -24,55 +16,198 @@ You should have received a copy of the GNU General Public License along with BFD; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + /* $Id$ */ + +/*proto* +@section typedef bfd + +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. + +Finally! The BFD struct itself. This contains the major data about +the file, and contains pointers to the rest of the data. + +*+++ + +$struct _bfd +${ + The filename the application opened the bfd with. + +$ CONST char *filename; + +A pointer to the target jump table. + +$ struct bfd_target *xvec; + + +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; +$}; + +*--- + +*/ #include <sysdep.h> #include "bfd.h" #include "libbfd.h" + short _bfd_host_big_endian = 0x0100; - /* Accessing the above as (*(char*)&_bfd_host_big_endian), will - return 1 if the host is big-endian, 0 otherwise. - (assuming that a short is two bytes long!!! FIXME) - (See HOST_IS_BIG_ENDIAN_P in bfd.h.) */ + /* Accessing the above as (*(char*)&_bfd_host_big_endian), will + return 1 if the host is big-endian, 0 otherwise. + (assuming that a short is two bytes long!!! FIXME) + (See HOST_IS_BIG_ENDIAN_P in bfd.h.) */ /** Error handling o - Most functions return nonzero on success (check doc for - precise semantics); 0 or NULL on error. + precise semantics); 0 or NULL on error. o - Internal errors are documented by the value of bfd_error. - If that is system_call_error then check errno. + If that is system_call_error then check errno. o - The easiest way to report this to the user is to use bfd_perror. */ bfd_ec bfd_error = no_error; -char *bfd_errmsgs[] = { "No error", - "System call error", - "Invalid target", - "File in wrong format", - "Invalid operation", - "Memory exhausted", - "No symbols", - "No relocation info", - "No more archived files", - "Malformed archive", - "Symbol not found", - "File format not recognized", - "File format is ambiguous", - "Section has no contents", - "Nonrepresentable section on output", - "#<Invalid error code>" - }; +char *bfd_errmsgs[] = { "No error", + "System call error", + "Invalid target", + "File in wrong format", + "Invalid operation", + "Memory exhausted", + "No symbols", + "No relocation info", + "No more archived files", + "Malformed archive", + "Symbol not found", + "File format not recognized", + "File format is ambiguous", + "Section has no contents", + "Nonrepresentable section on output", + "#<Invalid error code>" + }; static void DEFUN(bfd_nonrepresentable_section,(abfd, name), - CONST bfd * CONST abfd AND - CONST char * CONST name) + CONST bfd * CONST abfd AND + CONST char * CONST name) { printf("bfd error writing file %s, format %s can't represent section %s\n", - abfd->filename, - abfd->xvec->name, - name); + abfd->filename, + abfd->xvec->name, + name); exit(1); } @@ -90,7 +225,7 @@ strerror (code) extern char *sys_errlist[]; return (((code < 0) || (code >= sys_nerr)) ? "(unknown error)" : - sys_errlist [code]); + sys_errlist [code]); } #endif /* not ANSI_LIBRARIES */ @@ -127,7 +262,7 @@ DEFUN(bfd_perror,(message), CONST char *message) { if (bfd_error == system_call_error) - perror((char *)message); /* must be system error then... */ + perror((char *)message); /* must be system error then... */ else { if (message == NULL || *message == '\0') fprintf (stderr, "%s\n", bfd_errmsg (bfd_error)); @@ -136,415 +271,11 @@ DEFUN(bfd_perror,(message), } } -/* for error messages */ -char * -bfd_format_string (format) - bfd_format format; -{ - if (((int)format <(int) bfd_unknown) || ((int)format >=(int) bfd_type_end)) return "invalid"; - - switch (format) { - case bfd_object: return "object"; /* linker/assember/compiler output */ - case bfd_archive: return "archive"; /* object archive file */ - case bfd_core: return "core"; /* core dump */ - default: return "unknown"; - } -} - -/** Target configurations */ - -extern bfd_target *target_vector[]; -extern bfd_target *default_vector[]; - -/* 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. */ - -bfd_target * -DEFUN(bfd_find_target,(target_name, abfd), - CONST char *target_name AND - bfd *abfd) -{ - bfd_target **target; - extern char *getenv (); - CONST char *targname = (target_name ? target_name : getenv ("GNUTARGET")); - - /* This is safe; the vector cannot be null */ - if (targname == NULL || !strcmp (targname, "default")) { - abfd->target_defaulted = true; - return abfd->xvec = target_vector[0]; - } - - abfd->target_defaulted = false; - - for (target = &target_vector[0]; *target != NULL; target++) { - if (!strcmp (targname, (*target)->name)) - return abfd->xvec = *target; - } - - bfd_error = invalid_target; - return NULL; -} - - -/* Returns a freshly-consed, NULL-terminated vector of the names of all the - valid bfd targets. Do not modify the names */ - -char ** -bfd_target_list () -{ - int vec_length= 0; - bfd_target **target; - char **name_list, **name_ptr; - - for (target = &target_vector[0]; *target != NULL; target++) - vec_length++; - - name_ptr = name_list = (char **) zalloc ((vec_length + 1) * sizeof (char **)); - - if (name_list == NULL) { - bfd_error = no_memory; - return NULL; - } - - for (target = &target_vector[0]; *target != NULL; target++) - *(name_ptr++) = (*target)->name; - - return name_list; -} - -/* Init a bfd for read of the proper format. If the target was unspecified, - search all the possible targets. */ - -boolean -DEFUN(bfd_check_format,(abfd, format), - bfd *abfd AND - bfd_format format) -{ - bfd_target **target, *save_targ, *right_targ; - int match_count; - - if (!bfd_read_p (abfd) || - ((int)(abfd->format) < (int)bfd_unknown) || - ((int)(abfd->format) >= (int)bfd_type_end)) { - bfd_error = invalid_operation; - return false; - } - - if (abfd->format != bfd_unknown) - return (abfd->format == format)? true: false; - - /* presume the answer is yes */ - abfd->format = format; - - /* If the target type was explicitly specified, just check that target. */ - - if (!abfd->target_defaulted) { - bfd_seek (abfd, (file_ptr)0, SEEK_SET); /* rewind! */ - - right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); - if (right_targ) { - abfd->xvec = right_targ; /* Set the target as returned */ - return true; /* File position has moved, BTW */ - } - return false; /* Specified target is not right */ - } - - /* Since the target type was defaulted, check them - all in the hope that one will be uniquely recognized. */ - - save_targ = abfd->xvec; - match_count = 0; - right_targ = 0; - - for (target = target_vector; *target != NULL; target++) { - bfd_target *temp; - - abfd->xvec = *target; /* Change BFD's target temporarily */ - bfd_seek (abfd, (file_ptr)0, SEEK_SET); - temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd)); - if (temp) { /* This format checks out as ok! */ - right_targ = temp; - match_count++; - /* If this is the default target, accept it, even if other targets - might match. People who want those other targets have to set - the GNUTARGET variable. */ - if (temp == default_vector[0]) - break; -#ifdef GNU960 - /* Big- and little-endian b.out archives look the same, but it doesn't - * matter: there is no difference in their headers, and member file byte - * orders will (I hope) be handled appropriately by bfd. Ditto for big - * and little coff archives. And the 4 coff/b.out object formats are - * unambiguous. So accept the first match we find. - */ - break; -#endif - } - } - - if (match_count == 1) { - abfd->xvec = right_targ; /* Change BFD's target permanently */ - return true; /* File position has moved, BTW */ - } - - abfd->xvec = save_targ; /* Restore original target type */ - abfd->format = bfd_unknown; /* Restore original format */ - bfd_error = ((match_count == 0) ? file_not_recognized : - file_ambiguously_recognized); - return false; -} - -boolean -DEFUN(bfd_set_format,(abfd, format), - bfd *abfd AND - bfd_format format) -{ - - if (bfd_read_p (abfd) || - ((int)abfd->format < (int)bfd_unknown) || - ((int)abfd->format >= (int)bfd_type_end)) { - bfd_error = invalid_operation; - return false; - } - - if (abfd->format != bfd_unknown) return (abfd->format == format) ? true:false; - - /* presume the answer is yes */ - abfd->format = format; - - if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd))) { - abfd->format = bfd_unknown; - return false; - } - - return true; -} - -/* Hack object and core file sections */ - -sec_ptr -DEFUN(bfd_get_section_by_name,(abfd, name), - bfd *abfd AND - CONST char *name) -{ - asection *sect; - - for (sect = abfd->sections; sect != NULL; sect = sect->next) - if (!strcmp (sect->name, name)) return sect; - return NULL; -} - -/* If you try to create a section with a name which is already in use, - returns the old section by that name instead. */ -sec_ptr -DEFUN(bfd_make_section,(abfd, name), - bfd *abfd AND - CONST char *CONST name) -{ - asection *newsect; - asection ** prev = &abfd->sections; - asection * sect = abfd->sections; - - if (abfd->output_has_begun) { - bfd_error = invalid_operation; - return NULL; - } - - while (sect) { - if (!strcmp(sect->name, name)) return sect; - prev = §->next; - sect = sect->next; - } - - newsect = (asection *) bfd_zalloc(abfd, sizeof (asection)); - if (newsect == NULL) { - bfd_error = no_memory; - return NULL; - } - - newsect->name = name; - newsect->index = abfd->section_count++; - newsect->flags = SEC_NO_FLAGS; - - newsect->userdata = 0; - newsect->next = (asection *)NULL; - newsect->relocation = (arelent *)NULL; - newsect->reloc_count = 0; - newsect->line_filepos =0; - - if (BFD_SEND (abfd, _new_section_hook, (abfd, newsect)) != true) { - free (newsect); - return NULL; - } - - *prev = newsect; - return newsect; -} - -/* Call operation on each section. Operation gets three args: the bfd, - the section, and a void * pointer (whatever the user supplied). */ - -/* This is attractive except that without lexical closures its use is hard - to make reentrant. */ -/*VARARGS2*/ -void -bfd_map_over_sections (abfd, operation, user_storage) - bfd *abfd; - void (*operation)(); - PTR user_storage; -{ - asection *sect; - int i = 0; - - for (sect = abfd->sections; sect != NULL; i++, sect = sect->next) - (*operation) (abfd, sect, user_storage); - - if (i != abfd->section_count) /* Debugging */ - abort(); -} - -boolean -bfd_set_section_flags (abfd, section, flags) - bfd *abfd; - sec_ptr section; - flagword flags; -{ - if ((flags & bfd_applicable_section_flags (abfd)) != flags) { - bfd_error = invalid_operation; - return false; - } - - section->flags = flags; -return true; -} - - -boolean -bfd_set_section_size (abfd, ptr, val) - bfd *abfd; - sec_ptr ptr; - unsigned long val; -{ - /* Once you've started writing to any section you cannot create or change - the size of any others. */ - - if (abfd->output_has_begun) { - bfd_error = invalid_operation; - return false; - } - - ptr->size = val; - - return true; -} - -boolean -DEFUN(bfd_set_section_contents,(abfd, section, location, offset, count), - bfd *abfd AND - sec_ptr section AND - PTR location AND - file_ptr offset AND - bfd_size_type count) -{ - if (!(bfd_get_section_flags(abfd, section) & - SEC_HAS_CONTENTS)) { - bfd_error = no_contents; - return(false); - } /* if section has no contents */ - - if (BFD_SEND (abfd, _bfd_set_section_contents, - (abfd, section, location, offset, count))) { - abfd->output_has_begun = true; - return true; - } - - return false; -} - -boolean -DEFUN(bfd_get_section_contents,(abfd, section, location, offset, count), - bfd *abfd AND - sec_ptr section AND - PTR location AND - file_ptr offset AND - bfd_size_type count) -{ - if (section->flags & SEC_CONSTRUCTOR) { - memset(location, 0, (unsigned)count); - return true; - } - else { - return (BFD_SEND (abfd, _bfd_get_section_contents, - (abfd, section, location, offset, count))); - } -} - - -/** Some core file info commands */ - -/* Returns a read-only string explaining what program was running when - it failed. */ - -char * -bfd_core_file_failing_command (abfd) - bfd *abfd; -{ - if (abfd->format != bfd_core) { - bfd_error = invalid_operation; - return NULL; - } - return BFD_SEND (abfd, _core_file_failing_command, (abfd)); -} - -int -bfd_core_file_failing_signal (abfd) - bfd *abfd; -{ - if (abfd->format != bfd_core) { - bfd_error = invalid_operation; - return 0; - } - return BFD_SEND (abfd, _core_file_failing_signal, (abfd)); -} - -boolean -core_file_matches_executable_p (core_bfd, exec_bfd) - bfd *core_bfd, *exec_bfd; -{ - if ((core_bfd->format != bfd_core) || (exec_bfd->format != bfd_object)) { - bfd_error = wrong_format; - return false; - } - - return BFD_SEND (core_bfd, _core_file_matches_executable_p, (core_bfd, exec_bfd)); -} - + /** Symbols */ -boolean -bfd_set_symtab (abfd, location, symcount) - bfd *abfd; - asymbol **location; - unsigned int symcount; -{ - if ((abfd->format != bfd_object) || (bfd_read_p (abfd))) { - bfd_error = invalid_operation; - return false; - } - - bfd_get_outsymbols (abfd) = location; - bfd_get_symcount (abfd) = symcount; - return true; -} - /* returns the number of octets of storage required */ + unsigned int get_reloc_upper_bound (abfd, asect) bfd *abfd; @@ -573,32 +304,6 @@ bfd_canonicalize_reloc (abfd, asect, location, symbols) return BFD_SEND (abfd, _bfd_canonicalize_reloc, (abfd, asect, location, symbols)); } -void -bfd_print_symbol_vandf(file, symbol) -PTR file; -asymbol *symbol; -{ - flagword type = symbol->flags; - if (symbol->section != (asection *)NULL) - { - - fprintf_vma(file, symbol->value+symbol->section->vma); - } - else - { - fprintf_vma(file, symbol->value); - } - fprintf(file," %c%c%c%c%c%c%c", - (type & BSF_LOCAL) ? 'l':' ', - (type & BSF_GLOBAL) ? 'g' : ' ', - (type & BSF_IMPORT) ? 'i' : ' ', - (type & BSF_EXPORT) ? 'e' : ' ', - (type & BSF_UNDEFINED) ? 'u' : ' ', - (type & BSF_FORT_COMM) ? 'c' : ' ', - (type & BSF_DEBUGGING) ? 'd' :' '); - -} - boolean bfd_set_file_flags (abfd, flags) @@ -635,250 +340,6 @@ bfd_set_reloc (ignore_abfd, asect, location, count) asect->orelocation = location; asect->reloc_count = count; } -/* -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. -*/ - -bfd_reloc_status_enum_type -DEFUN(bfd_perform_relocation,(abfd, - reloc_entry, - data, - input_section, - output_bfd), - bfd *abfd AND - arelent *reloc_entry AND - PTR data AND - asection *input_section AND - bfd *output_bfd) -{ - bfd_vma relocation; - bfd_reloc_status_enum_type flag = bfd_reloc_ok; - bfd_vma addr = reloc_entry->address ; - bfd_vma output_base = 0; - reloc_howto_type *howto = reloc_entry->howto; - asection *reloc_target_output_section; - asection *reloc_target_input_section; - asymbol *symbol; - - if (reloc_entry->sym_ptr_ptr) { - symbol = *( reloc_entry->sym_ptr_ptr); - if ((symbol->flags & BSF_UNDEFINED) && output_bfd == (bfd *)NULL) { - flag = bfd_reloc_undefined; - } - } - else { - symbol = (asymbol*)NULL; - } - - if (howto->special_function){ - bfd_reloc_status_enum_type cont; - cont = howto->special_function(abfd, - reloc_entry, - symbol, - data, - input_section); - if (cont != bfd_reloc_continue) return cont; - } - - /* - Work out which section the relocation is targetted at and the - initial relocation command value. - */ - - - if (symbol != (asymbol *)NULL){ - if (symbol->flags & BSF_FORT_COMM) { - relocation = 0; - } - else { - relocation = symbol->value; - } - if (symbol->section != (asection *)NULL) - { - reloc_target_input_section = symbol->section; - } - else { - reloc_target_input_section = (asection *)NULL; - } - } - else if (reloc_entry->section != (asection *)NULL) - { - relocation = 0; - reloc_target_input_section = reloc_entry->section; - } - else { - relocation = 0; - reloc_target_input_section = (asection *)NULL; - } - - - if (reloc_target_input_section != (asection *)NULL) { - - reloc_target_output_section = - reloc_target_input_section->output_section; - - if (output_bfd && howto->partial_inplace==false) { - output_base = 0; - } - else { - output_base = reloc_target_output_section->vma; - - } - - relocation += output_base + reloc_target_input_section->output_offset; - } - - relocation += reloc_entry->addend ; - - - if(reloc_entry->address > (bfd_vma)(input_section->size)) - { - return bfd_reloc_outofrange; - } - - - if (howto->pc_relative == true) - { - /* - Anything which started out as pc relative should end up that - way too. - - There are two ways we can see a pcrel instruction. Sometimes - the pcrel displacement has been partially calculated, it - includes the distance from the start of the section to the - instruction in it (eg sun3), and sometimes the field is - totally blank - eg m88kbcs. - */ - - - relocation -= - output_base + input_section->output_offset; - - if (howto->pcrel_offset == true) { - relocation -= reloc_entry->address; - } - - } - - if (output_bfd!= (bfd *)NULL) { - if ( howto->partial_inplace == false) { - /* - This is a partial relocation, and we want to apply the relocation - to the reloc entry rather than the raw data. Modify the reloc - inplace to reflect what we now know. - */ - reloc_entry->addend = relocation ; - reloc_entry->section = reloc_target_input_section; - if (reloc_target_input_section != (asection *)NULL) { - /* If we know the output section we can forget the symbol */ - reloc_entry->sym_ptr_ptr = (asymbol**)NULL; - } - reloc_entry->address += - input_section->output_offset; - return flag; - } - else - { - /* This is a partial relocation, but inplace, so modify the - reloc record a bit - */ - - } - } - - reloc_entry->addend = 0; - - - /* - Either we are relocating all the way, or we don't want to apply - the relocation to the reloc entry (probably because there isn't - any room in the output format to describe addends to relocs) - */ - relocation >>= howto->rightshift; - - /* Shift everything up to where it's going to be used */ - - relocation <<= howto->bitpos; - - /* Wait for the day when all have the mask in them */ - - /* What we do: - i instruction to be left alone - o offset within instruction - r relocation offset to apply - S src mask - D dst mask - N ~dst mask - A part 1 - B part 2 - R result - - Do this: - i i i i i o o o o o from bfd_get<size> - and S S S S S to get the size offset we want - + r r r r r r r r r r to get the final value to place - and D D D D D to chop to right size - ----------------------- - A A A A A - And this: - ... i i i i i o o o o o from bfd_get<size> - and N N N N N get instruction - ----------------------- - ... B B B B B - - And then: - B B B B B - or A A A A A - ----------------------- - R R R R R R R R R R put into bfd_put<size> - */ - -#define DOIT(x) \ - x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask)) - - switch (howto->size) - { - case 0: - { - char x = bfd_get_8(abfd, (char *)data + addr); - DOIT(x); - bfd_put_8(abfd,x, (unsigned char *) data + addr); - } - break; - - case 1: - { - short x = bfd_get_16(abfd, (bfd_byte *)data + addr); - DOIT(x); - bfd_put_16(abfd, x, (unsigned char *)data + addr); - } - break; - case 2: - { - long x = bfd_get_32(abfd, (bfd_byte *) data + addr); - DOIT(x); - bfd_put_32(abfd,x, (bfd_byte *)data + addr); - } - break; - case 3: - /* Do nothing */ - break; - default: - return bfd_reloc_other; - } - - return flag; -} void bfd_assert(file, line) @@ -889,6 +350,14 @@ int line; } +/*proto* bfd_set_start_address + +Marks the entry point of an output bfd. Returns @code{true} on +success, @code{false} otherwise. + +*; PROTO(boolean, bfd_set_start_address,(bfd *, bfd_vma)); +*/ + boolean bfd_set_start_address(abfd, vma) bfd *abfd; @@ -899,19 +368,15 @@ bfd_vma vma; } -bfd_vma bfd_log2(x) -bfd_vma x; -{ - bfd_vma result = 0; - while ( (bfd_vma)(1<< result) < x) - result++; - return result; -} +/*proto* bfd_get_mtime + +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. -/* bfd_get_mtime: 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. */ +*;PROTO(long, bfd_get_mtime, (bfd *)); + +*/ long bfd_get_mtime (abfd) @@ -931,3 +396,33 @@ bfd_get_mtime (abfd) abfd->mtime = buf.st_mtime; return abfd->mtime; } + +/*proto* +*i stuff +*+ +#define bfd_sizeof_headers(abfd, reloc) \ + BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) + +#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)) + +#define bfd_debug_info_start(abfd) \ + BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) + +#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)) + +#define bfd_stat_arch_elt(abfd, stat) \ + BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) +*- + +*/ + + + + + + diff --git a/bfd/coffcode.h b/bfd/coffcode.h index 63630c3..2dea71a 100644 --- a/bfd/coffcode.h +++ b/bfd/coffcode.h @@ -5,17 +5,234 @@ This file is part of BFD, the Binary File Diddler. BFD is free software; you can redistribute it and/or modify it under the - terms of the GNU General Public License as published by the Free Software - Foundation; either version 1, or (at your option) any later version. +terms of the GNU General Public License as published by the Free Software +Foundation; either version 1, or (at your option) any later version. BFD is distributed in the hope that it will be useful, but WITHOUT ANY - WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - FOR A PARTICULAR PURPOSE. See the GNU General Public License for more - details. +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. +BFD; see the file COPYING. If not, write to the Free Software Foundation, +675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +/*doc* +@section coff backends + +BFD supports a number of different flavours of coff format. The major +difference between formats are the sizes and alignments of fields in +structures on disk, and the occasional extra field. + +Coff in all its varieties is implimented with a few common files and a +number of implementation specific files. For example, The 88k bcs coff +format is implemented in the file @code{m88k-bcs.c}. This file +@code{#include}s @code{m88k-bcs.h} which defines the external +structure of the coff format for the 88k, and @code{internalcoff.h} +which defines the internal structure. @code{m88k-bcs.c} also defines +the relocations used by the 88k format @xref{Relocations}. Then the +major portion of coff code is included (@code{coffcode.h}) which +defines the methods used to act upon the types defined in +@code{m88k-bcs.h} and @code{internalcoff.h}. + +The Intel i960 processor version of coff is implemented in +@code{icoff.c}. This file has the same structure as +@code{m88k-bcs.c}, except that it includes @code{intel-coff.h} rather +than @code{m88k-bcs.h}. + +@subsection Porting To A New Version of Coff + +The recommended method is to select from the existing implimentations +the version of coff which is most like the one you want to use, for +our purposes, we'll say that i386 coff is the one you select, and that +your coff flavour is called foo. Copy the @code{i386coff.c} to @code{foocoff.c}, +copy @code{../include/i386coff.h} to @code{../include/foocoff.h} and +add the lines to @code{targets.c} and @code{Makefile.in} so that your +new back end is used. + +Alter the shapes of the structures in @code{../include/foocoff.h} so +that they match what you need. You will probably also have to add +@code{#ifdef}s to the code in @code{internalcoff.h} and +@code{coffcode.h} if your version of coff is too wild. + +You can verify that your new bfd backend works quite simply by +building @code{objdump} from the @code{binutils} directory, and +making sure that its version of what's going on at your host systems +idea (assuming it has the pretty standard coff dump utility (usually +called @code{att-dump} or just @code{dump})) are the same. + +Then clean up your code, and send what you've done to Cygnus. Then your stuff +will be in the next release, and you won't have to keep integrating +it. + +@subsection How The Coff Backend Works + +@subsubsection Bit Twiddling +Each flavour of coff supported in bfd has its own header file +descibing the external layout of the structures. There is also an +internal description of the coff layout (in @code{internalcoff.h}) +file (@code{}). A major function of the coff backend is swapping the +bytes and twiddling the bits to translate the external form of the +structures into the normal internal form. This is all performed in the +@code{bfd_swap}_@i{thing}_@i{direction} routines. Some elements are +different sizes between different versions of coff, it is the duty of +the coff version specific include file to override the definitions of +various packing routines in @code{coffcode.h}. Eg the size of line +number entry in coff is sometimes 16 bits, and sometimes 32 bits. +@code{#define}ing @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will +select the correct one. No doubt, some day someone will find a version +of coff which has a varying field size not catered for at the moment. +To port bfd, that person will have to add more @code{#defines}. + +Three of the bit twiddling routines are exported to @code{gdb}; +@code{coff_swap_aux_in}, @code{coff_swap_sym_in} and +@code{coff_swap_linno_in}. @code{GDB} reads the symbol table on its +own, but uses bfd to fix things up. + +@subsubsection Symbol Reading +The simple canonical form for symbols used by bfd is not rich enough +to keep all the information available in a coff symbol table. The back +end gets around this by keeping the original symbol table around, +"behind the sceens". + +When a symbol table is requested (through a call to +@code{bfd_canonicalize_symtab}, a request gets through to +@code{get_normalized_symtab}. This reads the symbol table from the +coff file and swaps all the structures inside into the internal form. +It also fixes up all the pointers in the table (represented in the file +by offsets from the first symbol in the table) into physical pointers +to elements in the new internal table. This involves some work since +the meanings of fields changes depending upon context; a field that is a +pointer to another structure in the symbol table at one moment may be +the size in bytes of a structure in the next. + +Another pass is made over the table. All symbols which mark file names +(@code{C_FILE} symbols) are modified so that the internal string +points to the value in the auxent (the real filename) rather than the +normal text associated with the symbol (@code{".file"}). + +At this time the symbol names are moved around. Coff stores all +symbols less than nine characters long physically within the symbol +table, longer strings are kept at the end of the file in the string +table. This pass moves all strings into memory, and replaces them with +pointers to the strings. + +The symbol table is massaged once again, this time to create the +canonical table used by the bfd application. Each symbol is inspected +in turn, and a decision made (using the @code{sclass} field) about the +various flags to set in the @code{asymbol} @xref{Symbols}. The +generated canonical table shares strings with the hidden internal +symbol table. + +Any linenumbers are read from the coff file too, and attatched to the +symbols which own the functions the linenumbers belong to. + +@subsubsection Symbol Writing +Writing a symbol to a coff file which didn't come from a coff file +will lose any debugging information. The @code{asymbol} structure +remembers the bfd from which was born, and on output the back end +makes sure that the same destination target as source target is +present. + +When the symbols have come from a coff file then all the debugging +information is preserved. + +Symbol tables are provided for writing to the back end in a vector of +pointers to pointers. This allows applications like the linker to +accumulate and output large symbol tables without having to do too +much byte copying. + +The symbol table is not output to a writable bfd until it is closed. +The order of operations on the canonical symbol table at that point +are: +@table @code +@item coff_renumber_symbols +This function runs through the provided symbol table and patches each +symbol marked as a file place holder (@code{C_FILE}) to point to the +next file place holder in the list. It also marks each @code{offset} +field in the list with the offset from the first symbol of the current +symbol. + +Another function of this procedure is to turn the canonical value form +of bfd into the form used by coff. Internally, bfd expects symbol +values to be offsets from a section base; so a symbol physically at +0x120, but in a section starting at 0x100, would have the value 0x20. +Coff expects symbols to contain their final value, so symbols have +their values changed at this point to reflect their sum with their +owning section. Note that this transformation uses the +@code{output_section} field of the @code{asymbol}'s @code{asection} +@xref{Sections}. +@item coff_mangle_symbols +This routine runs though the provided symbol table and uses the +offsets generated by the previous pass and the pointers generated when +the symbol table was read in to create the structured hierachy +required by coff. It changes each pointer to a symbol to an index into +the symbol table of the symbol being referenced. +@item coff_write_symbols +This routine runs through the symbol table and patches up the symbols +from their internal form into the coff way, calls the bit twiddlers +and writes out the tabel to the file. +@end table +*/ + +/*proto* + +The hidden information for an asymbol is: + +*+++ + +$ typedef struct coff_ptr_struct +$ { + +Remembers the offset from the first symbol in the file for this +symbol. Generated by @code{coff_renumber_symbols}. + +$ unsigned int offset; + +Should the tag field of this symbol be renumbered. +Created by @code{coff_pointerize_aux}. + +$ char fix_tag; + +Should the endidx field of this symbol be renumbered. +Created by @code{coff_pointerize_aux}. + +$ char fix_end; + +The container for the symbol structure as read and translated from the file. + +$ union { +$ union internal_auxent auxent; +$ struct internal_syment syment; +$ } u; +$ } combined_entry_type; +$ + +*--- + +Each canonical asymbol really looks like this: + +*+++ + +$ typedef struct coff_symbol_struct +$ { + +The actual symbol which the rest of bfd works with + +$ asymbol symbol; + +A pointer to the hidden information for this symbol + +$ combined_entry_type *native; + +A pointer to the linenumber information for this symbol + +$ struct lineno_cache_entry *lineno; +$ } coff_symbol_type; + +*--- + */ /* $Id$ */ @@ -23,11 +240,6 @@ You should have received a copy of the GNU General Public License along with #include "archures.h" /* Machine architectures and types */ -/* SUPPRESS 558 */ -/* SUPPRESS 590 */ -/* SUPPRESS 529 */ -/* SUPPRESS 530 */ - /* Align an address upward to a boundary, expressed as a number of bytes. E.g. align to an 8-byte boundary with argument of 8. */ #define ALIGN(this, boundary) \ @@ -38,22 +250,59 @@ You should have received a copy of the GNU General Public License along with #define i960_align(addr, align) \ ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) -#define sp(x) bfd_h_put_x(abfd, x, &x) #define PUTWORD bfd_h_put_32 #define PUTHALF bfd_h_put_16 -#ifndef I960 -#define GDB_EXPORT static -#else -#define GDB_EXPORT /* nothing */ + +#ifndef GET_FCN_LNNOPTR +#define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr) +#endif + +#ifndef GET_FCN_ENDNDX +#define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx) +#endif + +#ifndef PUT_FCN_LNNOPTR +#define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr) +#endif +#ifndef PUT_FCN_ENDNDX +#define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, ext->x_sym.x_fcnary.x_fcn.x_endndx) +#endif +#ifndef GET_LNSZ_LNNO +#define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, ext->x_sym.x_misc.x_lnsz.x_lnno) +#endif +#ifndef GET_LNSZ_SIZE +#define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, ext->x_sym.x_misc.x_lnsz.x_size) +#endif +#ifndef PUT_LNSZ_LNNO +#define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, ext->x_sym.x_misc.x_lnsz.x_lnno) +#endif +#ifndef PUT_LNSZ_SIZE +#define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, ext->x_sym.x_misc.x_lnsz.x_size) +#endif +#ifndef GET_SCN_SCNLEN +#define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, ext->x_scn.x_scnlen) +#endif +#ifndef GET_SCN_NRELOC +#define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, ext->x_scn.x_nreloc) +#endif +#ifndef GET_SCN_NLINNO +#define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, ext->x_scn.x_nlinno) +#endif +#ifndef PUT_SCN_SCNLEN +#define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, ext->x_scn.x_scnlen) +#endif +#ifndef PUT_SCN_NRELOC +#define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in,ext->x_scn.x_nreloc) +#endif +#ifndef PUT_SCN_NLINNO +#define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, ext->x_scn.x_nlinno) #endif -PROTO(static void,force_indices_file_symbol_relative,(bfd *abfd, - struct internal_syment *symtab)); /* void warning(); */ -extern asection abs_section; + static int DEFUN(get_index,(symbol), @@ -71,10 +320,9 @@ DEFUN(set_index,(symbol, idx), } - - - -/* All the swapping routines: +/* ********************************************************************** +Here are all the routines for swapping the structures seen in the +outside world into the internal forms. */ @@ -123,7 +371,7 @@ DEFUN(bfd_swap_filehdr_in,(abfd, filehdr_src, filehdr_dst), filehdr_dst->f_flags = bfd_h_get_16(abfd,filehdr_src-> f_flags); } -GDB_EXPORT void +static void DEFUN(bfd_swap_filehdr_out,(abfd, filehdr_in, filehdr_out), bfd *abfd AND struct internal_filehdr *filehdr_in AND @@ -141,11 +389,14 @@ DEFUN(bfd_swap_filehdr_out,(abfd, filehdr_in, filehdr_out), static void -DEFUN(coff_swap_sym_in,(abfd, ext, in), +DEFUN(coff_swap_sym_in,(abfd, ext1, in1), bfd *abfd AND - SYMENT *ext AND - struct internal_syment *in) + PTR ext1 AND + PTR in1) { + SYMENT *ext = (SYMENT *)ext1; + struct internal_syment *in = (struct internal_syment *)in1; + if( ext->e.e_name[0] == 0) { in->_n._n_n._n_zeroes = 0; in->_n._n_n._n_offset = bfd_h_get_32(abfd, ext->e.e.e_offset); @@ -165,7 +416,7 @@ DEFUN(coff_swap_sym_in,(abfd, ext, in), in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux); } -GDB_EXPORT void +static void DEFUN(coff_swap_sym_out,(abfd,in, ext), bfd *abfd AND struct internal_syment *in AND @@ -193,13 +444,15 @@ DEFUN(coff_swap_sym_out,(abfd,in, ext), } static void -DEFUN(coff_swap_aux_in,(abfd, ext, type, class, in), +DEFUN(coff_swap_aux_in,(abfd, ext1, type, class, in1), bfd *abfd AND - AUXENT *ext AND + PTR ext1 AND int type AND int class AND - union internal_auxent *in) + PTR in1) { + AUXENT *ext = (AUXENT *)ext1; + union internal_auxent *in = (union internal_auxent *)in1; switch (class) { case C_FILE: if (ext->x_file.x_fname[0] == 0) { @@ -217,14 +470,16 @@ DEFUN(coff_swap_aux_in,(abfd, ext, type, class, in), #endif case C_HIDDEN: if (type == T_NULL) { - in->x_scn.x_scnlen = bfd_h_get_32(abfd, ext->x_scn.x_scnlen); - in->x_scn.x_nreloc = bfd_h_get_16(abfd, ext->x_scn.x_nreloc); - in->x_scn.x_nlinno = bfd_h_get_16(abfd, ext->x_scn.x_nlinno); + in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext); + in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext); + in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext); break; } default: - in->x_sym.x_tagndx = bfd_h_get_32(abfd, ext->x_sym.x_tagndx); + in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, ext->x_sym.x_tagndx); +#ifndef NO_TVNDX in->x_sym.x_tvndx = bfd_h_get_16(abfd, ext->x_sym.x_tvndx); +#endif if (ISARY(type) || class == C_BLOCK) { in->x_sym.x_fcnary.x_ary.x_dimen[0] = bfd_h_get_16(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]); @@ -232,21 +487,20 @@ DEFUN(coff_swap_aux_in,(abfd, ext, type, class, in), in->x_sym.x_fcnary.x_ary.x_dimen[2] = bfd_h_get_16(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]); in->x_sym.x_fcnary.x_ary.x_dimen[3] = bfd_h_get_16(abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]); } - else { - in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_32(abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); - in->x_sym.x_fcnary.x_fcn.x_endndx = bfd_h_get_32(abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx); - } + in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR(abfd, ext); + in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX(abfd, ext); + if (ISFCN(type)) { in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, ext->x_sym.x_misc.x_fsize); } else { - in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_16(abfd, ext->x_sym.x_misc.x_lnsz.x_lnno); - in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_16(abfd, ext->x_sym.x_misc.x_lnsz.x_size); + in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext); + in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext); } } } -GDB_EXPORT void +static void DEFUN(coff_swap_aux_out,(abfd, in, type, class, ext), bfd *abfd AND union internal_auxent *in AND @@ -260,7 +514,10 @@ DEFUN(coff_swap_aux_out,(abfd, in, type, class, ext), PUTWORD(abfd, 0, ext->x_file.x_n.x_zeroes ); PUTWORD(abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset); } - + else { + memcpy ( ext->x_file.x_fname,in->x_file.x_fname, + sizeof (in->x_file.x_fname)); + } break; case C_STAT: #ifdef C_LEAFSTAT @@ -268,64 +525,86 @@ DEFUN(coff_swap_aux_out,(abfd, in, type, class, ext), #endif case C_HIDDEN: if (type == T_NULL) { - PUTWORD(abfd, in->x_scn.x_scnlen, ext->x_scn.x_scnlen); - PUTWORD(abfd, in->x_scn.x_nreloc, ext->x_scn.x_nreloc); - PUTWORD(abfd, in->x_scn.x_nlinno, ext->x_scn.x_nlinno); + + PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext); + PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext); + PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext); break; } default: - PUTWORD(abfd, in->x_sym.x_tagndx, ext->x_sym.x_tagndx); + PUTWORD(abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx); +#ifndef NO_TVNDX PUTWORD(abfd, in->x_sym.x_tvndx , ext->x_sym.x_tvndx); +#endif - if (ISARY(type) || class == C_BLOCK) { - bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],ext->x_sym.x_fcnary.x_ary.x_dimen[0]); - bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],ext->x_sym.x_fcnary.x_ary.x_dimen[1]); - bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],ext->x_sym.x_fcnary.x_ary.x_dimen[2]); - bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],ext->x_sym.x_fcnary.x_ary.x_dimen[3]); - } - else { - PUTWORD(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); - PUTWORD(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx, ext->x_sym.x_fcnary.x_fcn.x_endndx); - } if (ISFCN(type)) { - PUTWORD(abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); + PUTWORD(abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); + PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext); + PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext); } else { - bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext->x_sym.x_misc.x_lnsz.x_lnno); - bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_size, ext->x_sym.x_misc.x_lnsz.x_size); + + if (ISARY(type) || class == C_BLOCK) { + bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],ext->x_sym.x_fcnary.x_ary.x_dimen[0]); + bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],ext->x_sym.x_fcnary.x_ary.x_dimen[1]); + bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],ext->x_sym.x_fcnary.x_ary.x_dimen[2]); + bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],ext->x_sym.x_fcnary.x_ary.x_dimen[3]); + + } + PUT_LNSZ_LNNO(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext); + PUT_LNSZ_SIZE(abfd, in->x_sym.x_misc.x_lnsz.x_size, ext); + + PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext); + PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext); + + } } } -GDB_EXPORT void -DEFUN(coff_swap_lineno_in,(abfd, ext, in), +static void +DEFUN(coff_swap_lineno_in,(abfd, ext1, in1), bfd *abfd AND - LINENO *ext AND - struct internal_lineno *in) + PTR ext1 AND + PTR in1) { - in->l_addr.l_symndx = bfd_h_get_32(abfd, ext->l_addr.l_symndx); - in->l_lnno = bfd_h_get_16(abfd, ext->l_lnno); + LINENO *ext = (LINENO *)ext1; + struct internal_lineno *in = (struct internal_lineno *)in1; + + in->l_addr.l_symndx = bfd_h_get_32(abfd, ext->l_addr.l_symndx); +#if defined(M88) + in->l_lnno = bfd_h_get_32(abfd, ext->l_lnno); +#else + in->l_lnno = bfd_h_get_16(abfd, ext->l_lnno); +#endif } -GDB_EXPORT void +static void DEFUN(coff_swap_lineno_out,(abfd, in, ext), bfd *abfd AND struct internal_lineno *in AND struct external_lineno *ext) { PUTWORD(abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); +#if defined(M88) + PUTWORD(abfd, in->l_lnno, ext->l_lnno); +#else PUTHALF(abfd, in->l_lnno, ext->l_lnno); +#endif } -GDB_EXPORT void -DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext, aouthdr_int), +static void +DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext1, aouthdr_int1), bfd *abfd AND - AOUTHDR *aouthdr_ext AND - struct internal_aouthdr *aouthdr_int) + PTR aouthdr_ext1 AND + PTR aouthdr_int1) { + AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1; + struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1; + aouthdr_int->magic = bfd_h_get_16(abfd, aouthdr_ext->magic); aouthdr_int->vstamp = bfd_h_get_16(abfd, aouthdr_ext->vstamp); aouthdr_int->tsize = bfd_h_get_32(abfd, aouthdr_ext->tsize); @@ -339,7 +618,7 @@ DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext, aouthdr_int), #endif } -GDB_EXPORT void +static void DEFUN(bfd_swap_aouthdr_out,(abfd, aouthdr_in, aouthdr_out), bfd *abfd AND struct internal_aouthdr *aouthdr_in AND @@ -358,7 +637,7 @@ DEFUN(bfd_swap_aouthdr_out,(abfd, aouthdr_in, aouthdr_out), #endif } -GDB_EXPORT void +static void DEFUN(coff_swap_scnhdr_in,(abfd, scnhdr_ext, scnhdr_int), bfd *abfd AND SCNHDR *scnhdr_ext AND @@ -371,9 +650,14 @@ DEFUN(coff_swap_scnhdr_in,(abfd, scnhdr_ext, scnhdr_int), scnhdr_int->s_scnptr = bfd_h_get_32(abfd, scnhdr_ext->s_scnptr); scnhdr_int->s_relptr = bfd_h_get_32(abfd, scnhdr_ext->s_relptr); scnhdr_int->s_lnnoptr = bfd_h_get_32(abfd, scnhdr_ext->s_lnnoptr); + scnhdr_int->s_flags = bfd_h_get_32(abfd, scnhdr_ext->s_flags); +#if defined(M88) + scnhdr_int->s_nreloc = bfd_h_get_32(abfd, scnhdr_ext->s_nreloc); + scnhdr_int->s_nlnno = bfd_h_get_32(abfd, scnhdr_ext->s_nlnno); +#else scnhdr_int->s_nreloc = bfd_h_get_16(abfd, scnhdr_ext->s_nreloc); scnhdr_int->s_nlnno = bfd_h_get_16(abfd, scnhdr_ext->s_nlnno); - scnhdr_int->s_flags = bfd_h_get_32(abfd, scnhdr_ext->s_flags); +#endif #ifdef I960 scnhdr_int->s_align = bfd_h_get_32(abfd, scnhdr_ext->s_align); #endif @@ -393,13 +677,49 @@ DEFUN(swap_scnhdr_out,(abfd, scnhdr_int, scnhdr_ext), PUTWORD(abfd, scnhdr_int->s_relptr, scnhdr_ext->s_relptr); PUTWORD(abfd, scnhdr_int->s_lnnoptr, scnhdr_ext->s_lnnoptr); PUTWORD(abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc); +#if defined(M88) + PUTWORD(abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno); + PUTWORD(abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); +#else PUTHALF(abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno); PUTHALF(abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags); -#ifdef I960 +#endif + +#if defined(I960) PUTWORD(abfd, scnhdr_int->s_align, scnhdr_ext->s_align); #endif } + +/* **********************************************************************/ +/* Return a pointer to a malloc'd copy of 'name'. 'name' may not be + \0-terminated, but will not exceed 'maxlen' characters. The copy *will* + be \0-terminated. + */ +static char * +DEFUN(copy_name,(abfd, name, maxlen), + bfd *abfd AND + char *name AND + int maxlen) +{ + int len; + char *newname; + + for (len = 0; len < maxlen; ++len) { + if (name[len] == '\0') { + break; + } + } + + if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) { + bfd_error = no_memory; + return (NULL); + } + strncpy(newname, name, len); + newname[len] = '\0'; + return newname; +} + /* initialize a section structure with information peculiar to this particular implementation of coff @@ -410,19 +730,7 @@ DEFUN(coff_new_section_hook,(abfd_ignore, section_ignore), bfd *abfd_ignore AND asection *section_ignore) { -#ifdef MC88MAGIC - /* FIXME, shouldn't this ifdef be on something that says we are - actually COMPILING FOR an 88K coff file, rather than simply - knowing its magic number? */ - /* Align to at least 16 bytes */ - section_ignore->alignment_power = 4; -#endif -#if M68 - section_ignore->alignment_power = 3; -#endif -#if I386 - section_ignore->alignment_power = 2; -#endif + section_ignore->alignment_power = abfd_ignore->xvec->align_power_min; return true; } @@ -514,23 +822,23 @@ DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a), struct internal_aouthdr *internal_a) { coff_data_type *coff; - + size_t readsize; /* length of file_info */ SCNHDR *external_sections; - + /* Build a play area */ if (coff_mkobject(abfd) != true) return 0; coff = coff_data(abfd); - - + + external_sections = (SCNHDR *)bfd_alloc(abfd, readsize = (nscns * SCNHSZ)); + if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) { goto fail; } - - - + + /* Now copy data as required; construct all asections etc */ coff->symbol_index_slew = 0; coff->relocbase =0; @@ -647,53 +955,53 @@ DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a), static bfd_target * DEFUN(coff_object_p,(abfd), bfd *abfd) - { - int nscns; - FILHDR filehdr; - AOUTHDR opthdr; - struct internal_filehdr internal_f; - struct internal_aouthdr internal_a; +{ + int nscns; + FILHDR filehdr; + AOUTHDR opthdr; + struct internal_filehdr internal_f; + struct internal_aouthdr internal_a; - bfd_error = system_call_error; + bfd_error = system_call_error; - /* figure out how much to read */ - if (bfd_read((PTR) &filehdr, 1, FILHSZ, abfd) != FILHSZ) - return 0; + /* figure out how much to read */ + if (bfd_read((PTR) &filehdr, 1, FILHSZ, abfd) != FILHSZ) + return 0; - bfd_swap_filehdr_in(abfd, &filehdr, &internal_f); + bfd_swap_filehdr_in(abfd, &filehdr, &internal_f); - if (BADMAG(internal_f)) { - bfd_error = wrong_format; - return 0; - } - nscns =internal_f.f_nscns; + if (BADMAG(internal_f)) { + bfd_error = wrong_format; + return 0; + } + nscns =internal_f.f_nscns; - if (internal_f.f_opthdr) { - if (bfd_read((PTR) &opthdr, 1,AOUTSZ, abfd) != AOUTSZ) { - return 0; - } - bfd_swap_aouthdr_in(abfd, &opthdr, &internal_a); + if (internal_f.f_opthdr) { + if (bfd_read((PTR) &opthdr, 1,AOUTSZ, abfd) != AOUTSZ) { + return 0; } + bfd_swap_aouthdr_in(abfd, &opthdr, &internal_a); + } - /* Seek past the opt hdr stuff */ - bfd_seek(abfd, internal_f.f_opthdr + FILHSZ, SEEK_SET); + /* Seek past the opt hdr stuff */ + bfd_seek(abfd, internal_f.f_opthdr + FILHSZ, SEEK_SET); - /* if the optional header is NULL or not the correct size then - quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) - and Intel 960 readwrite headers (I960WRMAGIC) is that the - optional header is of a different size. - - But the mips keeps extra stuff in it's opthdr, so dont check - when doing that - */ + /* if the optional header is NULL or not the correct size then + quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) + and Intel 960 readwrite headers (I960WRMAGIC) is that the + optional header is of a different size. + + But the mips keeps extra stuff in it's opthdr, so dont check + when doing that + */ #ifndef MIPS - if (internal_f.f_opthdr != 0 && AOUTSZ != internal_f.f_opthdr) - return (bfd_target *)NULL; + if (internal_f.f_opthdr != 0 && AOUTSZ != internal_f.f_opthdr) + return (bfd_target *)NULL; #endif - return coff_real_object_p(abfd, nscns, &internal_f, &internal_a); - } + return coff_real_object_p(abfd, nscns, &internal_f, &internal_a); +} @@ -706,15 +1014,15 @@ static coff_symbol_type * DEFUN(coff_symbol_from,(abfd, symbol), bfd *abfd AND asymbol *symbol) - { - if (symbol->the_bfd->xvec->flavour != bfd_target_coff_flavour_enum) - return (coff_symbol_type *)NULL; +{ + if (symbol->the_bfd->xvec->flavour != bfd_target_coff_flavour_enum) + return (coff_symbol_type *)NULL; - if (symbol->the_bfd->tdata == (PTR)NULL) - return (coff_symbol_type *)NULL; + if (symbol->the_bfd->tdata == (PTR)NULL) + return (coff_symbol_type *)NULL; - return (coff_symbol_type *) symbol; - } + return (coff_symbol_type *) symbol; +} @@ -725,101 +1033,167 @@ DEFUN(coff_symbol_from,(abfd, symbol), static void DEFUN(coff_count_linenumbers,(abfd), bfd *abfd) - { - unsigned int limit = bfd_get_symcount(abfd); - unsigned int i; - asymbol **p; - { - asection *s = abfd->sections->output_section; - while (s) { - BFD_ASSERT(s->lineno_count == 0); - s = s->next; - } +{ + unsigned int limit = bfd_get_symcount(abfd); + unsigned int i; + asymbol **p; + { + asection *s = abfd->sections->output_section; + while (s) { + BFD_ASSERT(s->lineno_count == 0); + s = s->next; } + } - for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { - asymbol *q_maybe = *p; - if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour_enum) { - coff_symbol_type *q = coffsymbol(q_maybe); - if (q->lineno) { - /* - This symbol has a linenumber, increment the owning - section's linenumber count - */ - alent *l = q->lineno; + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { + asymbol *q_maybe = *p; + if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour_enum) { + coff_symbol_type *q = coffsymbol(q_maybe); + if (q->lineno) { + /* + This symbol has a linenumber, increment the owning + section's linenumber count + */ + alent *l = q->lineno; + q->symbol.section->output_section->lineno_count++; + l++; + while (l->line_number) { q->symbol.section->output_section->lineno_count++; l++; - while (l->line_number) { - q->symbol.section->output_section->lineno_count++; - l++; - } } } } } +} -/* -This function returns true if the supplied SYMENT has an AUXENT with -a tagndx field which should be relocated. -The coff book says that all auxents have this and should be moved, -but all the actual implementations I've looked at do this .. -(sac@cygnus.com) -*/ -static boolean -DEFUN(uses_x_sym_x_tagndx_p,(abfd, native), - bfd *abfd AND - struct internal_syment *native) - { - if (BTYPE(native->n_type) == T_STRUCT) return true; - if (BTYPE(native->n_type) == T_UNION) return true; - if (BTYPE(native->n_type) == T_ENUM) return true; - return false; - } +static void +DEFUN(fixup_symbol_value,(coff_symbol_ptr, syment), +coff_symbol_type *coff_symbol_ptr AND +struct internal_syment *syment) +{ + /* Normalize the symbol flags */ + if (coff_symbol_ptr->symbol.flags & BSF_FORT_COMM) { + /* a common symbol is undefined with a value */ + syment->n_scnum = N_UNDEF; + syment->n_value = coff_symbol_ptr->symbol.value; + } + else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) { + syment->n_value = coff_symbol_ptr->symbol.value; + } + else if (coff_symbol_ptr->symbol.flags & BSF_UNDEFINED) { + syment->n_scnum = N_UNDEF; + syment->n_value = 0; + } + else if (coff_symbol_ptr->symbol.flags & BSF_ABSOLUTE) { + syment->n_scnum = N_ABS; + syment->n_value = coff_symbol_ptr->symbol.value; + } + else { + syment->n_scnum = + coff_symbol_ptr->symbol.section->output_section->index+1; + + syment->n_value = + coff_symbol_ptr->symbol.value + + coff_symbol_ptr->symbol.section->output_offset + + coff_symbol_ptr->symbol.section->output_section->vma; + } +} -/* -This procedure runs through the native entries in a coff symbol table -and links up all the elements which should point to one another, in -particular these are: +/* run through all the symbols in the symbol table and work out what + their indexes into the symbol table will be when output -strtag, entag and untags have an auxent endindex which points to the -first syment after the .eos. This is simple to do, we just keep a -pointer to the symbol with the most recent pending strtag and patch it -when we see the eos. This works since coff structs are never nested. + Coff requires that each C_FILE symbol points to the next one in the + chain, and that the last one points to the first external symbol. We + do that here too. -ISFCN type entries have an endindex which points to the next static or -extern in the table, thereby skipping the function contents. -The coff book says that an ISFCN's tagindex -points to the first .bf for the function, so far I havn't seen it -used. We do this using the same mechanism as strtags. +*/ +static void +DEFUN(coff_renumber_symbols,(bfd_ptr), + bfd *bfd_ptr) +{ + unsigned int symbol_count = bfd_get_symcount(bfd_ptr); + asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; + unsigned int native_index = 0; + struct internal_syment *last_file = (struct internal_syment *)NULL; + unsigned int symbol_index; + for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) + { + coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]); + if (coff_symbol_ptr && coff_symbol_ptr->native) { + combined_entry_type *s = coff_symbol_ptr->native; + int i; -Each file entry has a value which points to the next file entry, -the last file entry points to the first extern symbol in the table -which is not an ISFCN. + if (s->u.syment.n_sclass == C_FILE) + { + if (last_file != (struct internal_syment *)NULL) { + last_file->n_value = native_index; + } + last_file = &(s->u.syment); + } + else { -Each .bb entry points to the matching .eb entry, but these are nested -so we keep a stack of them. + /* Modify the symbol values according to their section and + type */ -The tagndx of .eos items points to the strtag attached to them, this -is simply the last_tagndx again. + fixup_symbol_value(coff_symbol_ptr, &(s->u.syment)); + } + for (i = 0; i < s->u.syment.n_numaux + 1; i++) { + s[i].offset = native_index ++; + } + } + else { + native_index++; + } + } +} -The tagndx of items with type strtag point to the defining struct. -This bit is complicated; We know that a struct ref and def must be -within the same file, so all the natives will be in the same vector. -This means that we can subtracts two pointers and get the index -differences between to items, used to work out the true index of the -target. -We store in the name field of each syment the actual native index -applied so we can dig it out through a pointer. */ +/*doc* + Run thorough the symbol table again, and fix it so that all pointers to + entries are changed to the entries' index in the output symbol table. +*/ static void DEFUN(coff_mangle_symbols,(bfd_ptr), bfd *bfd_ptr) - { +{ + unsigned int symbol_count = bfd_get_symcount(bfd_ptr); + asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; + unsigned int native_index = 0; + unsigned int symbol_index; + + + for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) + { + coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]); + if (coff_symbol_ptr && coff_symbol_ptr->native ) { + int i; + combined_entry_type *s = coff_symbol_ptr->native; + + + + + + for (i = 0; i < s->u.syment.n_numaux ; i++) { + combined_entry_type *a = s + i + 1; + if (a->fix_tag) { + a->u.auxent.x_sym.x_tagndx.l = a->u.auxent.x_sym.x_tagndx.p->offset; + } + if (a->fix_end) { + a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l = + a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset; + } + + } + } + } +} + +#if 0 unsigned int symbol_count = bfd_get_symcount(bfd_ptr); asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; struct internal_syment *last_tagndx = (struct internal_syment *)NULL; @@ -891,7 +1265,7 @@ DEFUN(coff_mangle_symbols,(bfd_ptr), && last_fcn != (struct internal_syment *)NULL) { union internal_auxent *auxent = (union internal_auxent *)(last_fcn+1); - auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index; + auxent->x_sym.x_fcnary.x_fcn.x_endndx.l = native_index; last_fcn = (struct internal_syment *)NULL; } @@ -901,17 +1275,18 @@ DEFUN(coff_mangle_symbols,(bfd_ptr), /* Remember that we keep the native index in the offset so patch the beginning of the struct to point to this */ - auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset; - auxent->x_sym.x_fcnary.x_fcn.x_endndx = syment->n_numaux + 1 + native_index; +/*if (last_ + auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset;*/ + auxent->x_sym.x_fcnary.x_fcn.x_endndx.l = syment->n_numaux + 1 + native_index; /* Now point the eos to the structure */ auxent = (union internal_auxent *)(syment+1); - auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset; + auxent->x_sym.x_tagndx.l = last_tagndx->_n._n_n._n_offset; } else if (syment->n_sclass == C_BLOCK && coff_symbol_ptr->symbol.name[1] == 'e') { union internal_auxent *auxent = (union internal_auxent *)((*(--last_block))+1); - auxent->x_sym.x_fcnary.x_fcn.x_endndx = native_index + syment->n_numaux + 1; + auxent->x_sym.x_fcnary.x_fcn.x_endndx.l = native_index + syment->n_numaux + 1; } if (syment->n_sclass == C_EXT && !ISFCN(syment->n_type) @@ -964,7 +1339,7 @@ DEFUN(coff_mangle_symbols,(bfd_ptr), union internal_auxent *auxent = (union internal_auxent *)(syment+1); bfd *bfd_ptr = coff_symbol_ptr->symbol.the_bfd; struct internal_syment *base = obj_raw_syments(bfd_ptr); - auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset; +/* auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset;*/ } @@ -986,16 +1361,209 @@ DEFUN(coff_mangle_symbols,(bfd_ptr), } +#endif +static int string_size; +static void +DEFUN(coff_fix_symbol_name,(abfd, symbol, native), + bfd *abfd AND + asymbol *symbol AND + combined_entry_type *native) +{ + unsigned int name_length; + union internal_auxent *auxent; +CONST char * name = symbol->name; + + if (name == (char *) NULL) { + /* + coff symbols always have names, so we'll make one up + */ + name = symbol->name = "strange"; + } + name_length = strlen(name); + + if (native->u.syment.n_sclass == C_FILE) { + strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN); + auxent = &(native+1)->u.auxent; + +#ifdef COFF_LONG_FILENAMES + if (name_length <= FILNMLEN) { + strncpy(auxent->x_file.x_fname, name, FILNMLEN); + } + else { + auxent->x_file.x_n.x_offset = string_size + 4; + auxent->x_file.x_n.x_zeroes = 0; + string_size += name_length + 1; + } +#else + strncpy(auxent->x_file.x_fname, name, FILNMLEN); + if (name_length > FILNMLEN) { + name[FILNMLEN] = '\0'; + } +#endif + } + else + { /* NOT A C_FILE SYMBOL */ + if (name_length <= SYMNMLEN) { + /* This name will fit into the symbol neatly */ + strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN); + } + else { + native->u.syment._n._n_n._n_offset = string_size + 4; + native->u.syment._n._n_n._n_zeroes = 0; + string_size += name_length + 1; + } + } +} + + + +static unsigned int +DEFUN(coff_write_symbol,(abfd, symbol, native, written), +bfd *abfd AND +asymbol *symbol AND +combined_entry_type *native AND +unsigned int written) +{ + unsigned int numaux = native->u.syment.n_numaux; + int type = native->u.syment.n_type; + int class = native->u.syment.n_sclass; + SYMENT buf; + unsigned int j; + + coff_fix_symbol_name(abfd, symbol, native); + coff_swap_sym_out(abfd, &native->u.syment, &buf); + bfd_write((PTR)& buf, 1, SYMESZ, abfd); + for (j = 0; j != native->u.syment.n_numaux; j++) + { + AUXENT buf1; + coff_swap_aux_out(abfd, + &( (native + j + 1)->u.auxent), type, class, &buf1); + bfd_write((PTR) (&buf1), 1, AUXESZ, abfd); + } + /* + Reuse somewhere in the symbol to keep the index + */ + set_index(symbol, written); + return written + 1 + numaux; +} + + +static unsigned int +DEFUN(coff_write_alien_symbol,(abfd, symbol, written), + bfd *abfd AND + asymbol *symbol AND + unsigned int written) +{ + /* + This symbol has been created by the loader, or come from a non + coff format. It has no native element to inherit, make our + own + */ + combined_entry_type *native; + combined_entry_type dummy; + native = &dummy; + native->u.syment.n_type = T_NULL; +#ifdef I960 + native->u.syment.n_flags = 0; +#endif + if (symbol->flags & BSF_ABSOLUTE) { + native->u.syment.n_scnum = N_ABS; + native->u.syment.n_value = symbol->value; + } + else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) { + native->u.syment.n_scnum = N_UNDEF; + native->u.syment.n_value = symbol->value; + } + else if (symbol->flags & BSF_DEBUGGING) { + /* + remove name so it doesn't take up any space + */ + symbol->name = ""; + } + else { + native->u.syment.n_scnum = symbol->section->output_section->index + + 1; + native->u.syment.n_value = symbol->value + + symbol->section->output_section->vma + + symbol->section->output_offset; +#ifdef I960 + /* Copy the any flags from the the file hdr into the symbol */ + { + coff_symbol_type *c = coff_symbol_from(abfd, symbol); + if (c != (coff_symbol_type *)NULL) { + native->u.syment.n_flags = c->symbol.the_bfd->flags; + } + } +#endif + } + +#ifdef HASPAD1 + native->u.syment.pad1[0] = 0; + native->u.syment.pad1[0] = 0; +#endif + + native->u.syment.n_type = 0; + if (symbol->flags & BSF_LOCAL) + native->u.syment.n_sclass = C_STAT; + else + native->u.syment.n_sclass = C_EXT; + native->u.syment.n_numaux = 0; + + return coff_write_symbol(abfd, symbol, native, written); +} + +static unsigned int +DEFUN(coff_write_native_symbol,(abfd, symbol, written), +bfd *abfd AND +coff_symbol_type *symbol AND +unsigned int written) +{ + /* + Does this symbol have an ascociated line number - if so then + make it remember this symbol index. Also tag the auxent of + this symbol to point to the right place in the lineno table + */ + combined_entry_type *native = symbol->native; + + alent *lineno = symbol->lineno; + + if (lineno) { + unsigned int count = 0; + lineno[count].u.offset = written; + if (native->u.syment.n_numaux) { + union internal_auxent *a = &((native+1)->u.auxent); + + a->x_sym.x_fcnary.x_fcn.x_lnnoptr = + symbol->symbol.section->output_section->moving_line_filepos; + } + /* + And count and relocate all other linenumbers + */ + count++; + while (lineno[count].line_number) { + lineno[count].u.offset += + symbol->symbol.section->output_section->vma + + symbol->symbol.section->output_offset; + count++; + } + symbol->symbol.section->output_section->moving_line_filepos += + count * LINESZ; + + } + return coff_write_symbol(abfd, &( symbol->symbol), native,written); +} + static void DEFUN(coff_write_symbols,(abfd), -bfd *abfd) + bfd *abfd) { unsigned int i; unsigned int limit = bfd_get_symcount(abfd); unsigned int written = 0; - struct internal_syment dummy; + asymbol **p; - unsigned int string_size = 0; + + string_size = 0; /* Seek to the right place */ @@ -1004,160 +1572,48 @@ bfd *abfd) /* Output all the symbols we have */ written = 0; - for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { - asymbol *symbol = *p; - coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol); - - unsigned int j; - struct internal_syment *native; - if (c_symbol == (coff_symbol_type *) NULL || - c_symbol->native == (struct internal_syment *) NULL) { - /* - This symbol has been created by the loader, or come from a non - coff format. It has no native element to inherit, make our - own - */ - - native = &dummy; - native->n_type = T_NULL; -#ifdef I960 - native->n_flags = 0; -#endif - if (symbol->flags & BSF_ABSOLUTE) { - native->n_scnum = N_ABS; - native->n_value = symbol->value; - } - else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) { - native->n_scnum = N_UNDEF; - native->n_value = symbol->value; - } - else if (symbol->flags & BSF_DEBUGGING) { - /* - remove name so it doesn't take up any space - */ - symbol->name = ""; - continue; - } - else { - native->n_scnum = symbol->section->output_section->index + - 1; - native->n_value = symbol->value + - symbol->section->output_section->vma + - symbol->section->output_offset; -#ifdef I960 - /* Copy the any flags from the the file hdr into the symbol */ - { - coff_symbol_type *c = coff_symbol_from(abfd, symbol); - if (c != (coff_symbol_type *)NULL) { - native->n_flags = c->symbol.the_bfd->flags; - } - } -#endif - } - -#ifdef HASPAD1 - native->pad1[0] = 0; - native->pad1[0] = 0; -#endif - - native->n_type = 0; - if (symbol->flags & BSF_LOCAL) - native->n_sclass = C_STAT; - else - native->n_sclass = C_EXT; - native->n_numaux = 0; - } - else - /* - Does this symbol have an ascociated line number - if so then - make it remember this symbol index. Also tag the auxent of - this symbol to point to the right place in the lineno table - */ - { - alent *lineno = c_symbol->lineno; - native = c_symbol->native; - if (lineno) { - unsigned int count = 0; - lineno[count].u.offset = written; - if (native->n_numaux) { - union internal_auxent *a = (union internal_auxent *) (native + 1); - - a->x_sym.x_fcnary.x_fcn.x_lnnoptr = - c_symbol->symbol.section->output_section->moving_line_filepos; - } - /* - And count and relocate all other linenumbers - */ - count++; - while (lineno[count].line_number) { - lineno[count].u.offset += - c_symbol->symbol.section->output_section->vma + - c_symbol->symbol.section->output_offset; - count++; - } - c_symbol->symbol.section->output_section->moving_line_filepos += - count * LINESZ; - - } - } /* if symbol new to coff */ - - /* Fix the symbol names */ + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { - unsigned int name_length; - if (symbol->name == (char *) NULL) { - /* - coff symbols always have names, so we'll make one up - */ - symbol->name = "strange"; - } - name_length = strlen(symbol->name); - if (name_length <= SYMNMLEN) { - /* This name will fit into the symbol neatly */ - strncpy(native->_n._n_name, symbol->name, SYMNMLEN); - } - else { - native->_n._n_n._n_offset = string_size + 4; - native->_n._n_n._n_zeroes = 0; - string_size += name_length + 1; - } - { - unsigned int numaux = native->n_numaux; - int type = native->n_type; - int class = native->n_sclass; - SYMENT buf; - coff_swap_sym_out(abfd, native, &buf); - bfd_write((PTR)& buf, 1, SYMESZ, abfd); - for (j = 0; j != native->n_numaux; - j++) { - AUXENT buf1; - coff_swap_aux_out(abfd, - (union internal_auxent *)(native + j + 1), type, class, &buf1); - bfd_write((PTR) (native + j + 1), 1, AUXESZ, abfd); + asymbol *symbol = *p; + coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol); + + + + if (c_symbol == (coff_symbol_type *) NULL || + c_symbol->native == (combined_entry_type *)NULL) + { + written = coff_write_alien_symbol(abfd, symbol, written); } - /* - Reuse somewhere in the symbol to keep the index - */ - set_index(symbol, written); - written += 1 + numaux; - } + else + { + written = coff_write_native_symbol(abfd, c_symbol, written); + } + } - } /* for each out symbol */ - + bfd_get_symcount(abfd) = written; + /* Now write out strings */ - if (string_size) { - unsigned int size = string_size + 4; - size = size; - bfd_write((PTR) &size, 1, sizeof(size), abfd); - for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { - asymbol *q = *p; - size_t name_length = strlen(q->name); - if (name_length > SYMNMLEN) { - bfd_write((PTR) (q->name), 1, name_length + 1, abfd); - } - } - } + if (string_size != 0) + { + unsigned int size = string_size + 4; + size = size; + bfd_write((PTR) &size, 1, sizeof(size), abfd); + for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) + { + asymbol *q = *p; + size_t name_length = strlen(q->name); + int maxlen; + coff_symbol_type* c_symbol = coff_symbol_from(abfd, q); + maxlen = ((c_symbol != NULL && c_symbol->native != NULL) && (c_symbol->native->u.syment.n_sclass == C_FILE)) ? + FILNMLEN : SYMNMLEN; + + if (name_length > maxlen) { + bfd_write((PTR) (q->name), 1, name_length + 1, abfd); + } + } + } else { /* We would normally not write anything here, but we'll write out 4 so that any stupid coff reader which tries to read @@ -1169,278 +1625,289 @@ bfd *abfd) bfd_write((PTR)&size, 1, sizeof(size), abfd); } - } +/*doc* +@subsubsection Writing Relocations +To write a relocations, all the back end does is step though the +canonical relocation table, and create an @code{internal_reloc}. The +symbol index to use is removed from the @code{offset} field in the +symbol table supplied, the address comes directly from the sum of the +section base address and the relocation offset and the type is dug +directly from the howto field. + +Then the @code{internal_reloc} is swapped into the shape of an +@code{external_reloc} and written out to disk. +*/ static void -coff_write_relocs(abfd) -bfd *abfd; - { - asection *s; - for (s = abfd->sections; s != (asection *) NULL; s = s->next) { - unsigned int i; - struct external_reloc dst; +DEFUN(coff_write_relocs,(abfd), + bfd *abfd) +{ + asection *s; + for (s = abfd->sections; s != (asection *) NULL; s = s->next) { + unsigned int i; + struct external_reloc dst; - arelent **p = s->orelocation; - bfd_seek(abfd, s->rel_filepos, SEEK_SET); - for (i = 0; i < s->reloc_count; i++) { - struct internal_reloc n; - arelent *q = p[i]; - memset((PTR)&n, 0, sizeof(n)); - n.r_vaddr = q->address + s->vma; - if (q->sym_ptr_ptr) { - n.r_symndx = get_index((*(q->sym_ptr_ptr))); - } + arelent **p = s->orelocation; + bfd_seek(abfd, s->rel_filepos, SEEK_SET); + for (i = 0; i < s->reloc_count; i++) { + struct internal_reloc n; + arelent *q = p[i]; + memset((PTR)&n, 0, sizeof(n)); + n.r_vaddr = q->address + s->vma; + if (q->sym_ptr_ptr) { + n.r_symndx = get_index((*(q->sym_ptr_ptr))); + } #ifdef SELECT_RELOC - /* Work out reloc type from what is required */ - SELECT_RELOC(n.r_type, q->howto); + /* Work out reloc type from what is required */ + SELECT_RELOC(n.r_type, q->howto); #else - n.r_type = q->howto->type; + n.r_type = q->howto->type; #endif - bfd_swap_reloc_out(abfd, &n, &dst); - bfd_write((PTR) &n, 1, RELSZ, abfd); - } + bfd_swap_reloc_out(abfd, &n, &dst); + bfd_write((PTR) &n, 1, RELSZ, abfd); } } +} static void DEFUN(coff_write_linenumbers,(abfd), bfd *abfd) - { - asection *s; - for (s = abfd->sections; s != (asection *) NULL; s = s->next) { - if (s->lineno_count) { - asymbol **q = abfd->outsymbols; - bfd_seek(abfd, s->line_filepos, SEEK_SET); - /* Find all the linenumbers in this section */ - while (*q) { - asymbol *p = *q; - alent *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p)); - if (l) { - /* Found a linenumber entry, output */ - struct internal_lineno out; - LINENO buff; - bzero( (PTR)&out, sizeof(out)); - out.l_lnno = 0; +{ + asection *s; + for (s = abfd->sections; s != (asection *) NULL; s = s->next) { + if (s->lineno_count) { + asymbol **q = abfd->outsymbols; + bfd_seek(abfd, s->line_filepos, SEEK_SET); + /* Find all the linenumbers in this section */ + while (*q) { + asymbol *p = *q; + alent *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p)); + if (l) { + /* Found a linenumber entry, output */ + struct internal_lineno out; + LINENO buff; + memset( (PTR)&out, 0, sizeof(out)); + out.l_lnno = 0; + out.l_addr.l_symndx = l->u.offset; + coff_swap_lineno_out(abfd, &out, &buff); + bfd_write((PTR) &buff, 1, LINESZ, abfd); + l++; + while (l->line_number) { + out.l_lnno = l->line_number; out.l_addr.l_symndx = l->u.offset; coff_swap_lineno_out(abfd, &out, &buff); bfd_write((PTR) &buff, 1, LINESZ, abfd); l++; - while (l->line_number) { - out.l_lnno = l->line_number; - out.l_addr.l_symndx = l->u.offset; - coff_swap_lineno_out(abfd, &out, &buff); - bfd_write((PTR) &buff, 1, LINESZ, abfd); - l++; - } } - q++; } + q++; } } } +} static asymbol * coff_make_empty_symbol(abfd) bfd *abfd; - { - coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type)); - if (new == NULL) { - bfd_error = no_memory; - return (NULL); - } /* on error */ - new->native = 0; - new->lineno = (alent *) NULL; - new->symbol.the_bfd = abfd; - return &new->symbol; - } +{ + coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type)); + if (new == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + new->native = 0; + new->lineno = (alent *) NULL; + new->symbol.the_bfd = abfd; + return &new->symbol; +} static void -coff_print_symbol(ignore_abfd, file, symbol, how) -bfd *ignore_abfd; -FILE *file; -asymbol *symbol; -bfd_print_symbol_enum_type how; - { - switch (how) { - case bfd_print_symbol_name_enum: - fprintf(file, "%s", symbol->name); - break; - case bfd_print_symbol_type_enum: - fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native, - (unsigned long) coffsymbol(symbol)->lineno); - break; - case bfd_print_symbol_all_enum: - { - CONST char *section_name = symbol->section == (asection *) NULL ? - "*abs" : symbol->section->name; - bfd_print_symbol_vandf((PTR) file, symbol); +DEFUN(coff_print_symbol,(ignore_abfd, file, symbol, how), + bfd *ignore_abfd AND + FILE *file AND + asymbol *symbol AND + bfd_print_symbol_enum_type how) +{ + switch (how) { + case bfd_print_symbol_name_enum: + fprintf(file, "%s", symbol->name); + break; + case bfd_print_symbol_type_enum: + fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native, + (unsigned long) coffsymbol(symbol)->lineno); + break; + case bfd_print_symbol_all_enum: + { + CONST char *section_name = symbol->section == (asection *) NULL ? + "*abs" : symbol->section->name; + bfd_print_symbol_vandf((PTR) file, symbol); - fprintf(file, " %-5s %s %s %s", - section_name, - coffsymbol(symbol)->native ? "n" : "g", - coffsymbol(symbol)->lineno ? "l" : " ", - symbol->name); - } + fprintf(file, " %-5s %s %s %s", + section_name, + coffsymbol(symbol)->native ? "n" : "g", + coffsymbol(symbol)->lineno ? "l" : " ", + symbol->name); + } - break; - } + break; } +} static alent * -coff_get_lineno(ignore_abfd, symbol) -bfd *ignore_abfd; -asymbol *symbol; - { - return coffsymbol(symbol)->lineno; - } +DEFUN(coff_get_lineno,(ignore_abfd, symbol), + bfd *ignore_abfd AND + asymbol *symbol) +{ + return coffsymbol(symbol)->lineno; +} /* Set flags and magic number of a coff file from architecture and machine type. Result is true if we can represent the arch&type, false if not. */ static boolean -coff_set_flags(abfd, magicp, flagsp) -bfd *abfd; -unsigned *magicp, -*flagsp; - { +DEFUN(coff_set_flags,(abfd, magicp, flagsp), + bfd *abfd AND + unsigned *magicp AND + unsigned short *flagsp) +{ - switch (abfd->obj_arch) { + switch (abfd->obj_arch) { #ifdef I960ROMAGIC - case bfd_arch_i960: + case bfd_arch_i960: - { - unsigned flags; - *magicp = I960ROMAGIC; - /* - ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC : - I960RWMAGIC); FIXME??? - */ - switch (abfd->obj_machine) { - case bfd_mach_i960_core: - flags = F_I960CORE; - break; - case bfd_mach_i960_kb_sb: - flags = F_I960KB; - break; - case bfd_mach_i960_mc: - flags = F_I960MC; - break; - case bfd_mach_i960_xa: - flags = F_I960XA; - break; - case bfd_mach_i960_ca: - flags = F_I960CA; - break; - case bfd_mach_i960_ka_sa: - flags = F_I960KA; - break; - default: - return false; - } - *flagsp = flags; - return true; + { + unsigned flags; + *magicp = I960ROMAGIC; + /* + ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC : + I960RWMAGIC); FIXME??? + */ + switch (abfd->obj_machine) { + case bfd_mach_i960_core: + flags = F_I960CORE; + break; + case bfd_mach_i960_kb_sb: + flags = F_I960KB; + break; + case bfd_mach_i960_mc: + flags = F_I960MC; + break; + case bfd_mach_i960_xa: + flags = F_I960XA; + break; + case bfd_mach_i960_ca: + flags = F_I960CA; + break; + case bfd_mach_i960_ka_sa: + flags = F_I960KA; + break; + default: + return false; } - break; + *flagsp = flags; + return true; + } + break; #endif #ifdef MIPS - case bfd_arch_mips: - *magicp = MIPS_MAGIC_2; - return true; - break; + case bfd_arch_mips: + *magicp = MIPS_MAGIC_2; + return true; + break; #endif #ifdef I386MAGIC - case bfd_arch_i386: - *magicp = I386MAGIC; - return true; + case bfd_arch_i386: + *magicp = I386MAGIC; + return true; #endif #ifdef MC68MAGIC - case bfd_arch_m68k: - *magicp = MC68MAGIC; - return true; + case bfd_arch_m68k: + *magicp = MC68MAGIC; + return true; #endif #ifdef MC88MAGIC - case bfd_arch_m88k: - *magicp = MC88OMAGIC; - return true; - break; + case bfd_arch_m88k: + *magicp = MC88OMAGIC; + return true; + break; #endif - default: /* Unknown architecture */ - return false; - } - + default: /* Unknown architecture */ return false; } + + return false; +} static boolean -coff_set_arch_mach(abfd, arch, machine) -bfd *abfd; -enum bfd_architecture arch; -unsigned long machine; - { - unsigned dummy1, - dummy2; +DEFUN(coff_set_arch_mach,(abfd, arch, machine), + bfd *abfd AND + enum bfd_architecture arch AND + unsigned long machine) +{ + unsigned dummy1; + unsigned short dummy2; abfd->obj_arch = arch; abfd->obj_machine = machine; if (arch != bfd_arch_unknown && coff_set_flags(abfd, &dummy1, &dummy2) != true) return false; /* We can't represent this type */ - return true; /* We're easy ... */ + return true; /* We're easy ... */ } /* Calculate the file position for each section. */ static void -coff_compute_section_file_positions(abfd) -bfd *abfd; - { - asection *current; - file_ptr sofar = FILHSZ; - if (bfd_get_start_address(abfd)) { - /* - A start address may have been added to the original file. In this - case it will need an optional header to record it. - */ - abfd->flags |= EXEC_P; - } - if (abfd->flags & EXEC_P) - sofar += AOUTSZ; - - - sofar += abfd->section_count * SCNHSZ; - - for (current = abfd->sections; current != NULL; current = - current->next) { - /* Only deal with sections which have contents */ - if (!(current->flags & SEC_HAS_CONTENTS)) - continue; - - /* Align the sections in the file to the same boundary on - which they are aligned in virtual memory. I960 doesn't - do this (FIXME) so we can stay in sync with Intel. 960 - doesn't yet page from files... */ +DEFUN(coff_compute_section_file_positions,(abfd), + bfd *abfd) +{ + asection *current; + file_ptr sofar = FILHSZ; + if (bfd_get_start_address(abfd)) { + /* + A start address may have been added to the original file. In this + case it will need an optional header to record it. + */ + abfd->flags |= EXEC_P; + } + if (abfd->flags & EXEC_P) + sofar += AOUTSZ; + + + sofar += abfd->section_count * SCNHSZ; + for (current = abfd->sections; + current != (asection *)NULL; + current = current->next) { + /* Only deal with sections which have contents */ + if (!(current->flags & SEC_HAS_CONTENTS)) + continue; + + /* Align the sections in the file to the same boundary on + which they are aligned in virtual memory. I960 doesn't + do this (FIXME) so we can stay in sync with Intel. 960 + doesn't yet page from files... */ #ifndef I960 - sofar = ALIGN(sofar, 1 << current->alignment_power); + sofar = ALIGN(sofar, 1 << current->alignment_power); #endif - /* FIXME, in demand paged files, the low order bits of the file - offset must match the low order bits of the virtual address. - "Low order" is apparently implementation defined. Add code - here to round sofar up to match the virtual address. */ - - current->filepos = sofar; - sofar += current->size; - } - obj_relocbase(abfd) = sofar; + /* FIXME, in demand paged files, the low order bits of the file + offset must match the low order bits of the virtual address. + "Low order" is apparently implementation defined. Add code + here to round sofar up to match the virtual address. */ + + current->filepos = sofar; + sofar += current->size; } + obj_relocbase(abfd) = sofar; +} @@ -1449,37 +1916,37 @@ bfd *abfd; /* SUPPRESS 529 */ static boolean DEFUN(coff_write_object_contents,(abfd), -bfd *abfd) -{ - asection *current; - boolean hasrelocs = false; - boolean haslinno = false; - file_ptr reloc_base; - file_ptr lineno_base; - file_ptr sym_base; - file_ptr scn_base; - file_ptr data_base; - unsigned long reloc_size = 0; - unsigned long lnno_size = 0; - asection *text_sec = NULL; - asection *data_sec = NULL; - asection *bss_sec = NULL; - - struct internal_filehdr internal_f; - struct internal_aouthdr internal_a; + bfd *abfd) + { + asection *current; + boolean hasrelocs = false; + boolean haslinno = false; + file_ptr reloc_base; + file_ptr lineno_base; + file_ptr sym_base; + file_ptr scn_base; + file_ptr data_base; + unsigned long reloc_size = 0; + unsigned long lnno_size = 0; + asection *text_sec = NULL; + asection *data_sec = NULL; + asection *bss_sec = NULL; - struct icofdata *coff = obj_icof(abfd); + struct internal_filehdr internal_f; + struct internal_aouthdr internal_a; + struct icofdata *coff = obj_icof(abfd); - bfd_error = system_call_error; + bfd_error = system_call_error; - if(abfd->output_has_begun == false) { - coff_compute_section_file_positions(abfd); - } - if (abfd->sections != (asection *)NULL) { - scn_base = abfd->sections->filepos; + if(abfd->output_has_begun == false) { + coff_compute_section_file_positions(abfd); + } + + if (abfd->sections != (asection *)NULL) { + scn_base = abfd->sections->filepos; } else { scn_base = 0; @@ -1648,10 +2115,8 @@ bfd *abfd) { int magic = 0; int flags = 0; - coff_set_flags(abfd, &magic, &flags); + coff_set_flags(abfd, &magic, &internal_f.f_flags); internal_f.f_magic = magic; - internal_f.f_flags = flags; - /* ...and the "opt"hdr... */ #ifdef I960 @@ -1665,6 +2130,7 @@ bfd *abfd) obj_sym_filepos(abfd) = sym_base; if (bfd_get_symcount(abfd) != 0) { + coff_renumber_symbols(abfd); coff_mangle_symbols(abfd); coff_write_symbols(abfd); coff_write_linenumbers(abfd); @@ -1701,13 +2167,46 @@ bfd *abfd) return true; } +/* +this function transforms the offsets into the symbol table into +pointers to syments. +*/ + + +static void +DEFUN(coff_pointerize_aux,(abfd, table_base, type, class, auxent), +bfd *abfd AND +combined_entry_type *table_base AND +int type AND +int class AND +combined_entry_type *auxent) +{ + /* Don't bother if this is a file or a section */ + if (class == C_STAT && type == T_NULL) return; + if (class == C_FILE) return; + + /* Otherwise patch up */ + if (ISFCN(type) || ISTAG(class) || class == C_BLOCK) { + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = table_base + + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; + auxent->fix_end = 1; + } +if (auxent->u.auxent.x_sym.x_tagndx.l != 0) { + auxent->u.auxent.x_sym.x_tagndx.p = table_base + auxent->u.auxent.x_sym.x_tagndx.l; + auxent->fix_tag = 1; +} + + + +} + static boolean -coff_set_section_contents(abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR location; - file_ptr offset; - size_t count; +DEFUN(coff_set_section_contents,(abfd, section, location, offset, count), + bfd *abfd AND + sec_ptr section AND + PTR location AND + file_ptr offset AND + size_t count) { if (abfd->output_has_begun == false) /* set by bfd.c handler */ coff_compute_section_file_positions(abfd); @@ -1765,67 +2264,39 @@ buy_and_read(abfd, where, seek_direction, size) return (area); } /* buy_and_read() */ -static void -DEFUN(offset_symbol_indices,(abfd, symtab, count, offset), - bfd *abfd AND - struct internal_syment *symtab AND - unsigned long count AND - long offset) + + +static char * +DEFUN(build_string_table,(abfd), +bfd *abfd) { - struct internal_syment *end = symtab + count; - for (; symtab < end; ++symtab) { - if (symtab->n_sclass == C_FILE) { - symtab->n_value = 0; - } - else if (symtab->n_sclass == C_ALIAS) { - /* - These guys have indices in their values. - */ - symtab->n_value = symtab->n_value + offset; - } - else if (symtab->n_numaux) { - /* - anybody else without an aux, has no indices. - */ - - if (symtab->n_sclass == C_EOS - || (BTYPE(symtab->n_type) == T_STRUCT - && symtab->n_sclass != C_STRTAG) - || BTYPE(symtab->n_type) == T_UNION - || BTYPE(symtab->n_type) == T_ENUM) { - /* If the tagndx is 0 then the struct hasn't really been - defined, so leave it alone */ - - if(((union internal_auxent *) (symtab + 1))->x_sym.x_tagndx != 0) { - ((union internal_auxent *) (symtab + 1))->x_sym.x_tagndx += offset; - } - - } /* These guys have a tagndx */ - if (symtab->n_sclass == C_STRTAG - || symtab->n_sclass == C_UNTAG - || symtab->n_sclass == C_ENTAG - || symtab->n_sclass == C_BLOCK - || symtab->n_sclass == C_FCN - || ISFCN(symtab->n_type)) { - - ((union internal_auxent *) (symtab + - 1))->x_sym.x_fcnary.x_fcn.x_endndx - += offset; - - } /* These guys have an endndx */ -#ifndef I960 - if (ISFCN(symtab->n_type)) { - ((union internal_auxent *) (symtab + 1))->x_sym.x_tvndx += offset; - } /* These guys have a tvndx. I think... - (FIXME) */ -#endif /* Not I960 */ - - } /* if value, else if aux */ - symtab += symtab->n_numaux; - } /* walk the symtab */ - - return; -} /* offset_symbol_indices() */ + char string_table_size_buffer[4]; + unsigned int string_table_size; + char *string_table; + /* + At this point we should be "seek"'d to the end of the + symbols === the symbol table size. + */ + + if (bfd_read((char *) string_table_size_buffer, + sizeof(string_table_size_buffer), + 1, abfd) != sizeof(string_table_size)) { + bfd_error = system_call_error; + return (NULL); + } /* on error */ + + string_table_size = bfd_h_get_32(abfd, string_table_size_buffer); + + if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on mallocation error */ + if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) { + bfd_error = system_call_error; + return (NULL); + } + return string_table; +} /* read a symbol table into freshly mallocated memory, swap it, and knit the @@ -1835,31 +2306,31 @@ Oh, and the first symbol MUST be a C_FILE. If there wasn't one there before, put one there. */ -static struct internal_syment * +static combined_entry_type * DEFUN(get_normalized_symtab,(abfd), bfd *abfd) { - struct internal_syment *internal; - struct internal_syment *internal_ptr; - struct internal_syment *internal_end; + combined_entry_type *internal; + combined_entry_type *internal_ptr; + combined_entry_type *internal_end; SYMENT *raw; SYMENT *raw_src; SYMENT *raw_end; char *string_table = NULL; unsigned long size; - char string_table_size_buffer[4]; + unsigned long string_table_size = 0; unsigned int raw_size; - if (obj_raw_syments(abfd) != (struct internal_syment *)NULL) { + if (obj_raw_syments(abfd) != (combined_entry_type *)NULL) { return obj_raw_syments(abfd); } - if ((size = bfd_get_symcount(abfd) * sizeof(struct internal_syment)) == 0) { + if ((size = bfd_get_symcount(abfd) * sizeof(combined_entry_type)) == 0) { bfd_error = no_symbols; return (NULL); } - internal = (struct internal_syment *)bfd_alloc(abfd, size); + internal = (combined_entry_type *)bfd_alloc(abfd, size); internal_end = internal + bfd_get_symcount(abfd); raw_size = bfd_get_symcount(abfd) * SYMESZ; @@ -1880,96 +2351,92 @@ bfd *abfd) /* Swap all the raw entries */ for (raw_src = raw, internal_ptr = internal; raw_src < raw_end; raw_src++, internal_ptr++) { unsigned int i; - coff_swap_sym_in(abfd, raw_src,internal_ptr); - for (i = internal_ptr->n_numaux; i; --i, raw_src++, internal_ptr++) { - coff_swap_aux_in(abfd, (AUXENT *)(raw_src +1), internal_ptr->n_type, - internal_ptr->n_sclass, (union - internal_auxent *)(internal_ptr +1)); + coff_swap_sym_in(abfd, raw_src,&internal_ptr->u.syment); + internal_ptr->fix_tag = 0; + internal_ptr->fix_end = 0; + + for (i = internal_ptr->u.syment.n_numaux; i; --i, raw_src++, internal_ptr++) { + (internal_ptr+1)->fix_tag = 0; + (internal_ptr+1)->fix_end = 0; + + coff_swap_aux_in(abfd, (AUXENT *)(raw_src +1), internal_ptr->u.syment.n_type, + internal_ptr->u.syment.n_sclass, & (internal_ptr+1)->u.auxent); + + coff_pointerize_aux(abfd, + internal, + internal_ptr->u.syment.n_type, + internal_ptr->u.syment.n_sclass, + internal_ptr +1); } } /* Free all the raw stuff */ bfd_release(abfd, raw_src); - for (internal_ptr = internal; internal_ptr < internal_end; internal_ptr ++) { + for (internal_ptr = internal; internal_ptr < internal_end; + internal_ptr ++) + { + if (internal_ptr->u.syment.n_sclass == C_FILE) { + /* make a file symbol point to the name in the auxent, since + the text ".file" is redundant */ + if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) { + /* the filename is a long one, point into the string table + */ + if (string_table == NULL) { + string_table = build_string_table(abfd); + } - if (internal_ptr->_n._n_n._n_zeroes != 0) { - /* - This is a "short" name. Make it long. - */ - unsigned long i = 0; - char *newstring = NULL; - /* - find the length of this string without walking into memory - that isn't ours. - */ + internal_ptr->u.syment._n._n_n._n_offset = + (int) (string_table - 4 + + (internal_ptr+1)->u.auxent.x_file.x_n.x_offset); + } + else { + /* ordinary short filename, put into memory anyway */ + internal_ptr->u.syment._n._n_n._n_offset = (int) + copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname, FILNMLEN); + + } + } + else { + if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) { + /* + This is a "short" name. Make it long. + */ + unsigned long i = 0; + char *newstring = NULL; + /* + find the length of this string without walking into memory + that isn't ours. + */ - for (i = 0; i < 8; ++i) { - if (internal_ptr->_n._n_name[i] == '\0') { - break; - } /* if end of string */ - } /* possible lengths of this string. */ + for (i = 0; i < 8; ++i) { + if (internal_ptr->u.syment._n._n_name[i] == '\0') { + break; + } /* if end of string */ + } /* possible lengths of this string. */ - if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) { - bfd_error = no_memory; - return (NULL); - } /* on error */ - bzero(newstring, i); - strncpy(newstring, internal_ptr->_n._n_name, i-1); - internal_ptr->_n._n_n._n_offset = (int) newstring; - internal_ptr->_n._n_n._n_zeroes = 0; + if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) { + bfd_error = no_memory; + return (NULL); + } /* on error */ + bzero(newstring, i); + strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1); + internal_ptr->u.syment._n._n_n._n_offset = (int) newstring; + internal_ptr->u.syment._n._n_n._n_zeroes = 0; - } - else { - if (string_table == NULL) { - /* - NOTE: we don't read the string table until now because we - don't necessarily know that we have one until now. - */ - /* - At this point we should be "seek"'d to the end of the - symbols === the symbol table size. - */ - - if (bfd_read((char *) string_table_size_buffer, - sizeof(string_table_size_buffer), - 1, abfd) != sizeof(string_table_size)) { - bfd_error = system_call_error; - return (NULL); - } /* on error */ - - string_table_size = bfd_h_get_32(abfd, string_table_size_buffer); - - if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) { - bfd_error = no_memory; - return (NULL); - } /* on mallocation error */ - if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) { - bfd_error = system_call_error; - return (NULL); - } /* on error */ - } /* have not yet read the string table. */ - /* - This is a long name already. Just point it at the string in - memory. - */ - internal_ptr->_n._n_n._n_offset = (int) (string_table - 4 + internal_ptr->_n._n_n._n_offset); + } + else { + /* This is a long name already. Just point it at the string in memory. */ + if (string_table == NULL) { + string_table = build_string_table(abfd); + } + internal_ptr->u.syment._n._n_n._n_offset = + (int) (string_table - 4 + internal_ptr->u.syment._n._n_n._n_offset); + } + } + internal_ptr += internal_ptr->u.syment.n_numaux; + } - } /* switch on type of symbol name */ - - internal_ptr += internal_ptr->n_numaux; - } /* for each symbol */ -#if 0 -#ifndef GNU960 - /* I'm not sure of the repercussions of this, so the Intel - folks will always do the force - */ - if (obj_symbol_slew(abfd) > 0) - force_indices_file_symbol_relative(abfd, internal); -#else - force_indices_file_symbol_relative(abfd, internal); -#endif -#endif obj_raw_syments(abfd) = internal; obj_string_table(abfd) = string_table; @@ -1994,6 +2461,23 @@ DEFUN(section_from_bfd_index,(abfd, index), +/*doc* +@subsubsection Reading Linenumbers +Createing the linenumber table is done by reading in the entire coff +linenumber table, and creating another table for internal use. + +A coff line number table is structured so that each +function is marked as having a line number of 0. Each line within the +function is an offset from the first line in the function. The base of +the line number information for the table is stored in the symbol +associated with the function. + +The information is copied from the external to the internal table, and +each symbol which marks a function is marked by pointing its... + +**How does this work ?** + +*/ static boolean coff_slurp_line_table(abfd, asect) @@ -2029,7 +2513,7 @@ asection *asect; coff_symbol_type *sym = (coff_symbol_type *) (dst.l_addr.l_symndx + obj_symbol_slew(abfd) - + obj_raw_syments(abfd))->_n._n_n._n_zeroes; + + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes; cache_ptr->u.sym = (asymbol *) sym; sym->lineno = cache_ptr; } @@ -2053,193 +2537,193 @@ asection *asect; static boolean DEFUN(coff_slurp_symbol_table,(abfd), bfd *abfd) - { - struct internal_syment *native_symbols; - coff_symbol_type *cached_area; - unsigned int *table_ptr; +{ + combined_entry_type *native_symbols; + coff_symbol_type *cached_area; + unsigned int *table_ptr; - unsigned int number_of_symbols = 0; - if (obj_symbols(abfd)) - return true; - bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET); + unsigned int number_of_symbols = 0; + if (obj_symbols(abfd)) + return true; + bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET); - /* Read in the symbol table */ - if ((native_symbols = get_normalized_symtab(abfd)) == NULL) { - return (false); - } /* on error */ + /* Read in the symbol table */ + if ((native_symbols = get_normalized_symtab(abfd)) == NULL) { + return (false); + } /* on error */ - /* Allocate enough room for all the symbols in cached form */ - cached_area = - (coff_symbol_type *) - bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type))); + /* Allocate enough room for all the symbols in cached form */ + cached_area = + (coff_symbol_type *) + bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type))); - if (cached_area == NULL) { - bfd_error = no_memory; - return false; - } /* on error */ - table_ptr = - (unsigned int *) - bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int))); + if (cached_area == NULL) { + bfd_error = no_memory; + return false; + } /* on error */ + table_ptr = + (unsigned int *) + bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int))); - if (table_ptr == NULL) { - bfd_error = no_memory; - return false; - } else { - coff_symbol_type *dst = cached_area; - unsigned int last_native_index = bfd_get_symcount(abfd); - unsigned int this_index = 0; - while (this_index < last_native_index) { - struct internal_syment *src = native_symbols + this_index; - table_ptr[this_index] = number_of_symbols; - dst->symbol.the_bfd = abfd; + if (table_ptr == NULL) { + bfd_error = no_memory; + return false; + } else { + coff_symbol_type *dst = cached_area; + unsigned int last_native_index = bfd_get_symcount(abfd); + unsigned int this_index = 0; + while (this_index < last_native_index) { + combined_entry_type *src = native_symbols + this_index; + table_ptr[this_index] = number_of_symbols; + dst->symbol.the_bfd = abfd; - dst->symbol.name = (char *)(src->_n._n_n._n_offset); - /* - We use the native name field to point to the cached field - */ - src->_n._n_n._n_zeroes = (int) dst; - dst->symbol.section = section_from_bfd_index(abfd, - src->n_scnum); - switch (src->n_sclass) { + dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset); + /* + We use the native name field to point to the cached field + */ + src->u.syment._n._n_n._n_zeroes = (int) dst; + dst->symbol.section = section_from_bfd_index(abfd, + src->u.syment.n_scnum); + switch (src->u.syment.n_sclass) { #ifdef I960 - case C_LEAFEXT: + case C_LEAFEXT: #if 0 - dst->symbol.value = src->n_value - dst->symbol.section->vma; - dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; - dst->symbol.flags |= BSF_NOT_AT_END; + dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma; + dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; + dst->symbol.flags |= BSF_NOT_AT_END; #endif - /* Fall through to next case */ + /* Fall through to next case */ #endif - case C_EXT: - if ((src->n_scnum) == 0) { - if ((src->n_value) == 0) { - dst->symbol.flags = BSF_UNDEFINED; - dst->symbol.value= 0; - } - else { - dst->symbol.flags = BSF_FORT_COMM; - dst->symbol.value = (src->n_value); - } + case C_EXT: + if ((src->u.syment.n_scnum) == 0) { + if ((src->u.syment.n_value) == 0) { + dst->symbol.flags = BSF_UNDEFINED; + dst->symbol.value= 0; } else { + dst->symbol.flags = BSF_FORT_COMM; + dst->symbol.value = (src->u.syment.n_value); + } + } + else { + /* + Base the value as an index from the base of the + section + */ + if (dst->symbol.section == (asection *) NULL) { + dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE; + dst->symbol.value = src->u.syment.n_value; + } + else { + dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; + dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma; + } + if (ISFCN((src->u.syment.n_type))) { /* - Base the value as an index from the base of the - section - */ - if (dst->symbol.section == (asection *) NULL) { - dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE; - dst->symbol.value = src->n_value; - } - else { - dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; - dst->symbol.value = src->n_value - dst->symbol.section->vma; - } - if (ISFCN((src->n_type))) { - /* - A function ext does not go at the end of a file - */ - dst->symbol.flags |= BSF_NOT_AT_END; - } + A function ext does not go at the end of a file + */ + dst->symbol.flags |= BSF_NOT_AT_END; } + } - break; - case C_STAT: /* static */ + break; + case C_STAT: /* static */ #ifdef I960 - case C_LEAFSTAT: /* static leaf procedure */ + case C_LEAFSTAT: /* static leaf procedure */ #endif - case C_LABEL: /* label */ - dst->symbol.flags = BSF_LOCAL; - /* - Base the value as an index from the base of the section - */ - dst->symbol.value = (src->n_value) - dst->symbol.section->vma; - break; + case C_LABEL: /* label */ + dst->symbol.flags = BSF_LOCAL; + /* + Base the value as an index from the base of the section + */ + dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma; + break; - case C_MOS: /* member of structure */ - case C_EOS: /* end of structure */ - case C_REGPARM: /* register parameter */ - case C_REG: /* register variable */ + case C_MOS: /* member of structure */ + case C_EOS: /* end of structure */ + case C_REGPARM: /* register parameter */ + case C_REG: /* register variable */ #ifdef C_AUTOARG - case C_AUTOARG: /* 960-specific storage class */ + case C_AUTOARG: /* 960-specific storage class */ #endif - case C_TPDEF: /* type definition */ + case C_TPDEF: /* type definition */ - case C_ARG: - case C_AUTO: /* automatic variable */ - case C_FIELD: /* bit field */ - case C_ENTAG: /* enumeration tag */ - case C_MOE: /* member of enumeration */ - case C_MOU: /* member of union */ - case C_UNTAG: /* union tag */ + case C_ARG: + case C_AUTO: /* automatic variable */ + case C_FIELD: /* bit field */ + case C_ENTAG: /* enumeration tag */ + case C_MOE: /* member of enumeration */ + case C_MOU: /* member of union */ + case C_UNTAG: /* union tag */ - dst->symbol.flags = BSF_DEBUGGING; - dst->symbol.value = (src->n_value); - break; + dst->symbol.flags = BSF_DEBUGGING; + dst->symbol.value = (src->u.syment.n_value); + break; - case C_FILE: /* file name */ - case C_STRTAG: /* structure tag */ - dst->symbol.flags = BSF_DEBUGGING; - dst->symbol.value = (src->n_value); + case C_FILE: /* file name */ + case C_STRTAG: /* structure tag */ + dst->symbol.flags = BSF_DEBUGGING; + dst->symbol.value = (src->u.syment.n_value); - break; - case C_BLOCK: /* ".bb" or ".eb" */ - case C_FCN: /* ".bf" or ".ef" */ - dst->symbol.flags = BSF_LOCAL; - /* - Base the value as an index from the base of the section - */ - dst->symbol.value = (src->n_value) - dst->symbol.section->vma; + break; + case C_BLOCK: /* ".bb" or ".eb" */ + case C_FCN: /* ".bf" or ".ef" */ + dst->symbol.flags = BSF_LOCAL; + /* + Base the value as an index from the base of the section + */ + dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma; - break; - case C_EFCN: /* physical end of function */ - case C_NULL: - case C_EXTDEF: /* external definition */ - case C_ULABEL: /* undefined label */ - case C_USTATIC: /* undefined static */ - case C_LINE: /* line # reformatted as symbol table entry */ - case C_ALIAS: /* duplicate tag */ - case C_HIDDEN: /* ext symbol in dmert public lib */ + break; + case C_EFCN: /* physical end of function */ + case C_NULL: + case C_EXTDEF: /* external definition */ + case C_ULABEL: /* undefined label */ + case C_USTATIC: /* undefined static */ + case C_LINE: /* line # reformatted as symbol table entry */ + case C_ALIAS: /* duplicate tag */ + case C_HIDDEN: /* ext symbol in dmert public lib */ - default: + default: - abort(); - dst->symbol.flags = BSF_DEBUGGING; - dst->symbol.value = (src->n_value); + abort(); + dst->symbol.flags = BSF_DEBUGGING; + dst->symbol.value = (src->u.syment.n_value); - break; - } + break; + } - BFD_ASSERT(dst->symbol.flags != 0); + BFD_ASSERT(dst->symbol.flags != 0); - dst->native = src; + dst->native = src; - dst->symbol.udata = 0; - dst->lineno = (alent *) NULL; - this_index += (src->n_numaux) + 1; - dst++; - number_of_symbols++; - } /* walk the native symtab */ - } /* bfdize the native symtab */ - - obj_symbols(abfd) = cached_area; - obj_raw_syments(abfd) = native_symbols; - - bfd_get_symcount(abfd) = number_of_symbols; - obj_convert(abfd) = table_ptr; - /* Slurp the line tables for each section too */ - { - asection *p; - p = abfd->sections; - while (p) { - coff_slurp_line_table(abfd, p); - p = p->next; - } + dst->symbol.udata = 0; + dst->lineno = (alent *) NULL; + this_index += (src->u.syment.n_numaux) + 1; + dst++; + number_of_symbols++; + } /* walk the native symtab */ + } /* bfdize the native symtab */ + + obj_symbols(abfd) = cached_area; + obj_raw_syments(abfd) = native_symbols; + + bfd_get_symcount(abfd) = number_of_symbols; + obj_convert(abfd) = table_ptr; + /* Slurp the line tables for each section too */ + { + asection *p; + p = abfd->sections; + while (p) { + coff_slurp_line_table(abfd, p); + p = p->next; } - return true; - } /* coff_slurp_symbol_table() */ + } + return true; +} /* coff_slurp_symbol_table() */ static unsigned int coff_get_symtab_upper_bound(abfd) @@ -2281,6 +2765,33 @@ sec_ptr asect; return (asect->reloc_count + 1) * sizeof(arelent *); } +/*doc* +@subsubsection Reading Relocations +Coff relocations are easily transformed into the internal bfd form +(@code{arelent}). + +Reading a coff relocation table is done in the following stages: +@itemize @bullet +@item +The entire coff relocation table is read into memory. +@item +Each relocation is processed in turn, first it is swapped from the +external to the internal form. +@item +The symbol referenced in the relocation's symbol index is turned into +a pointer into the canonical symbol table. Note that this table is the +same as the one returned by a call to @code{bfd_canonicalize_symtab}. +The back end will call the routine and save the result if a +canonicalization hasn't been done. +@item +The reloc index is turned into a pointer to a howto structure, in a +back end specific way. For instance, the 386 and 960 use the +@code{r_type} to directly produce an index into a howto table vector; +the 88k subtracts a number from the @code{r_type} field and creates an +addend field. +@end itemize +*/ + static boolean DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols), bfd *abfd AND @@ -2336,7 +2847,12 @@ DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols), && ptr->section != (asection *) NULL && ((ptr->flags & BSF_OLD_COMMON)== 0)) { +#ifndef M88 cache_ptr->addend = -(ptr->section->vma + ptr->value); +#else + cache_ptr->addend = 0; +#endif + } else { cache_ptr->addend = 0; @@ -2430,7 +2946,7 @@ DEFUN(coff_find_nearest_line,(abfd, unsigned int i = 0; struct icofdata *cof = obj_icof(abfd); /* Run through the raw syments if available */ - struct internal_syment *p; + combined_entry_type *p; alent *l; unsigned int line_base = 0; @@ -2445,40 +2961,16 @@ DEFUN(coff_find_nearest_line,(abfd, if (cof == (struct icofdata *)NULL) return false; - + p = cof->raw_syments; - /* - I don't know for sure what's right, but this isn't it. First off, an - object file may not have any C_FILE's in it. After - get_normalized_symtab(), it should have at least 1, the one I put - there, but otherwise, all bets are off. Point #2, the first C_FILE - isn't necessarily the right C_FILE because any given object may have - many. I think you'll have to track sections as they coelesce in order - to find the C_STAT symbol for this section. Then you'll have to work - backwards to find the previous C_FILE, or choke if you get to a C_STAT - for the same kind of section. That will mean that the original object - file didn't have a C_FILE. xoxorich. - */ -/* -#ifdef WEREBEINGPEDANTIC - return false; -#endif - */ for (i = 0; i < cof->raw_syment_count; i++) { - if (p->n_sclass == C_FILE) { - /* File name is embeded in auxent */ - /* - This isn't right. The fname should probably be normalized - during get_normalized_symtab(). In any case, what was here - wasn't right because a SYMENT.n_name isn't an - AUXENT.x_file.x_fname. xoxorich. - */ - - *filename_ptr = ((AUXENT *) (p + 1))->x_file.x_fname; + if (p->u.syment.n_sclass == C_FILE) { + /* File name has been moved into symbol */ + *filename_ptr = (char *) p->u.syment._n._n_n._n_offset; break; } - p += 1 + p->n_numaux; + p += 1 + p->u.syment.n_numaux; } /* Now wander though the raw linenumbers of the section */ /* @@ -2503,16 +2995,16 @@ DEFUN(coff_find_nearest_line,(abfd, coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym); *functionname_ptr = coff->symbol.name; if (coff->native) { - struct internal_syment *s = coff->native; - s = s + 1 + s->n_numaux; + combined_entry_type *s = coff->native; + s = s + 1 + s->u.syment.n_numaux; /* S should now point to the .bf of the function */ - if (s->n_numaux) { + if (s->u.syment.n_numaux) { /* The linenumber is stored in the auxent */ - union internal_auxent *a = (union internal_auxent *) (s + 1); + union internal_auxent *a = &((s + 1)->u.auxent); line_base = a->x_sym.x_misc.x_lnsz.x_lnno; } } @@ -2530,6 +3022,7 @@ DEFUN(coff_find_nearest_line,(abfd, cache_offset = offset; cache_i = i; cache_l = l; + return true; } @@ -2572,3 +3065,7 @@ DEFUN(coff_sizeof_headers,(abfd, reloc), #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt #define coff_get_section_contents bfd_generic_get_section_contents #define coff_close_and_cleanup bfd_generic_close_and_cleanup + +#define coff_bfd_debug_info_start bfd_void +#define coff_bfd_debug_info_end bfd_void +#define coff_bfd_debug_info_accumulate bfd_void @@ -119,14 +119,14 @@ standard requires: */ -#define this_byte(ieee) *(ieee->input_p) -#define next_byte(ieee) (ieee->input_p++) -#define this_byte_and_next(ieee) (*(ieee->input_p++)) +#define this_byte(ieee) *((ieee)->input_p) +#define next_byte(ieee) ((ieee)->input_p++) +#define this_byte_and_next(ieee) (*((ieee)->input_p++)) static unsigned short DEFUN(read_2bytes,(ieee), - ieee_data_type *ieee) + common_header_type *ieee) { unsigned char c1 = this_byte_and_next(ieee); unsigned char c2 = this_byte_and_next(ieee); @@ -136,7 +136,7 @@ DEFUN(read_2bytes,(ieee), static void DEFUN(bfd_get_string,(ieee, string, length), - ieee_data_type *ieee AND + common_header_type *ieee AND char *string AND size_t length) { @@ -148,7 +148,7 @@ DEFUN(bfd_get_string,(ieee, string, length), static char * DEFUN(read_id,(ieee), - ieee_data_type *ieee) + common_header_type *ieee) { size_t length; char *string; @@ -272,7 +272,7 @@ DEFUN(ieee_write_int5_out, (abfd, value), static boolean DEFUN(parse_int,(ieee, value_ptr), - ieee_data_type *ieee AND + common_header_type *ieee AND bfd_vma *value_ptr) { int value = this_byte(ieee); @@ -297,7 +297,7 @@ DEFUN(parse_int,(ieee, value_ptr), } static int DEFUN(parse_i,(ieee, ok), - ieee_data_type *ieee AND + common_header_type *ieee AND boolean *ok) { bfd_vma x; @@ -307,7 +307,7 @@ DEFUN(parse_i,(ieee, ok), static bfd_vma DEFUN(must_parse_int,(ieee), - ieee_data_type *ieee) + common_header_type *ieee) { bfd_vma result; BFD_ASSERT(parse_int(ieee, &result) == true); @@ -364,15 +364,15 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), ieee_value_type *sp = stack; while (loop) { - switch (this_byte(ieee)) + switch (this_byte(&(ieee->h))) { case ieee_variable_P_enum: /* P variable, current program counter for section n */ { int section_n ; - next_byte(ieee); + next_byte(&(ieee->h)); *pcrel = true; - section_n = must_parse_int(ieee); + section_n = must_parse_int(&(ieee->h)); PUSH(NOSYMBOL, 0, TOS.value = ieee->section_table[section_n]->vma + ieee_per_section(ieee->section_table[section_n])->pc); @@ -380,29 +380,29 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), } case ieee_variable_L_enum: /* L variable address of section N */ - next_byte(ieee); - PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0); + next_byte(&(ieee->h)); + PUSH(NOSYMBOL,ieee->section_table[must_parse_int(&(ieee->h))],0); break; case ieee_variable_R_enum: /* R variable, logical address of section module */ /* FIXME, this should be different to L */ - next_byte(ieee); - PUSH(NOSYMBOL,ieee->section_table[must_parse_int(ieee)],0); + next_byte(&(ieee->h)); + PUSH(NOSYMBOL,ieee->section_table[must_parse_int(&(ieee->h))],0); break; case ieee_variable_S_enum: /* S variable, size in MAUS of section module */ - next_byte(ieee); + next_byte(&(ieee->h)); PUSH(NOSYMBOL, 0, - ieee->section_table[must_parse_int(ieee)]->size); + ieee->section_table[must_parse_int(&(ieee->h))]->size); break; case ieee_variable_X_enum: /* Push the address of external variable n */ { ieee_symbol_index_type sy; - next_byte(ieee); - sy.index = (int)(must_parse_int(ieee)) ; + next_byte(&(ieee->h)); + sy.index = (int)(must_parse_int(&(ieee->h))) ; sy.letter = 'X'; PUSH(sy, 0, 0); @@ -413,7 +413,7 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), bfd_vma value1, value2; asection *section1, *section_dummy; ieee_symbol_index_type sy; - next_byte(ieee); + next_byte(&(ieee->h)); POP(sy, section1, value1); POP(sy, section_dummy, value2); @@ -427,7 +427,7 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), asection *section2; ieee_symbol_index_type sy1; ieee_symbol_index_type sy2; - next_byte(ieee); + next_byte(&(ieee->h)); POP(sy1, section1, value1); POP(sy2, section2, value2); @@ -437,9 +437,9 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), default: { bfd_vma va; - BFD_ASSERT(this_byte(ieee) < (int)ieee_variable_A_enum - || this_byte(ieee) > (int)ieee_variable_Z_enum); - if (parse_int(ieee, &va)) + BFD_ASSERT(this_byte(&(ieee->h)) < (int)ieee_variable_A_enum + || this_byte(&(ieee->h)) > (int)ieee_variable_Z_enum); + if (parse_int(&(ieee->h), &va)) { PUSH(NOSYMBOL,0, va); } @@ -472,7 +472,9 @@ DEFUN(parse_expression,(ieee, value, section, symbol, pcrel, extra), #define ieee_seek(abfd, offset) \ - ieee_data(abfd)->input_p = ieee_data(abfd)->first_byte + offset + ieee_data(abfd)->h.input_p = ieee_data(abfd)->h.first_byte + offset + +#define ieee_pos(abfd) ieee_data(abfd)->h.input_p -ieee_data(abfd)->h.first_byte static void DEFUN(ieee_slurp_external_symbols,(abfd), @@ -492,21 +494,21 @@ DEFUN(ieee_slurp_external_symbols,(abfd), ieee_seek(abfd, offset ); while (loop) { - switch (this_byte(ieee)) { + switch (this_byte(&(ieee->h))) { case ieee_external_symbol_enum: - next_byte(ieee); - symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type)); + next_byte(&(ieee->h)); + symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd, sizeof(ieee_symbol_type)); *prev_symbols_ptr = symbol; prev_symbols_ptr= &symbol->next; - symbol->index = must_parse_int(ieee); + symbol->index = must_parse_int(&(ieee->h)); if (symbol->index > ieee->external_symbol_max_index) { ieee->external_symbol_max_index = symbol->index; } BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index); symbol_count++; symbol->symbol.the_bfd = abfd; - symbol->symbol.name = read_id(ieee); + symbol->symbol.name = read_id(&(ieee->h)); symbol->symbol.udata = (PTR)NULL; symbol->symbol.flags = BSF_NO_FLAGS; break; @@ -516,13 +518,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd), unsigned int symbol_type_index; unsigned int symbol_attribute_def; bfd_vma value; - next_byte(ieee); /* Skip prefix */ - next_byte(ieee); - symbol_name_index = must_parse_int(ieee); - symbol_type_index = must_parse_int(ieee); - symbol_attribute_def = must_parse_int(ieee); + next_byte(&(ieee->h)); /* Skip prefix */ + next_byte(&(ieee->h)); + symbol_name_index = must_parse_int(&(ieee->h)); + symbol_type_index = must_parse_int(&(ieee->h)); + symbol_attribute_def = must_parse_int(&(ieee->h)); - parse_int(ieee,&value); + parse_int(&(ieee->h),&value); } break; @@ -532,10 +534,10 @@ DEFUN(ieee_slurp_external_symbols,(abfd), ieee_symbol_index_type symbol_ignore; boolean pcrel_ignore; unsigned int extra; - next_byte(ieee); - next_byte(ieee); + next_byte(&(ieee->h)); + next_byte(&(ieee->h)); - symbol_name_index = must_parse_int(ieee); + symbol_name_index = must_parse_int(&(ieee->h)); parse_expression(ieee, &symbol->symbol.value, &symbol->symbol.section, @@ -553,13 +555,13 @@ DEFUN(ieee_slurp_external_symbols,(abfd), case ieee_weak_external_reference_enum: { bfd_vma size; bfd_vma value ; - next_byte(ieee); + next_byte(&(ieee->h)); /* Throw away the external reference index */ - (void)must_parse_int(ieee); + (void)must_parse_int(&(ieee->h)); /* Fetch the default size if not resolved */ - size = must_parse_int(ieee); + size = must_parse_int(&(ieee->h)); /* Fetch the defautlt value if available */ - if ( parse_int(ieee, &value) == false) { + if ( parse_int(&(ieee->h), &value) == false) { value = 0; } /* This turns into a common */ @@ -569,14 +571,14 @@ DEFUN(ieee_slurp_external_symbols,(abfd), break; case ieee_external_reference_enum: - next_byte(ieee); - symbol = (ieee_symbol_type *)bfd_alloc(ieee->abfd, sizeof(ieee_symbol_type)); + next_byte(&(ieee->h)); + symbol = (ieee_symbol_type *)bfd_alloc(ieee->h.abfd, sizeof(ieee_symbol_type)); symbol_count++; *prev_reference_ptr = symbol; prev_reference_ptr = &symbol->next; - symbol->index = must_parse_int(ieee); + symbol->index = must_parse_int(&(ieee->h)); symbol->symbol.the_bfd = abfd; - symbol->symbol.name = read_id(ieee); + symbol->symbol.name = read_id(&(ieee->h)); symbol->symbol.udata = (PTR)NULL; symbol->symbol.section = (asection *)NULL; symbol->symbol.value = (bfd_vma)0; @@ -715,12 +717,12 @@ DEFUN(ieee_slurp_sections,(abfd), bfd_byte section_type[3]; ieee_seek(abfd, offset); while (true) { - switch (this_byte(ieee)) { + switch (this_byte(&(ieee->h))) { case ieee_section_type_enum: { unsigned int section_index ; - next_byte(ieee); - section_index = must_parse_int(ieee); + next_byte(&(ieee->h)); + section_index = must_parse_int(&(ieee->h)); /* Fixme to be nice about a silly number of sections */ BFD_ASSERT(section_index < NSECTIONS); @@ -728,24 +730,24 @@ DEFUN(ieee_slurp_sections,(abfd), ieee->section_table[section_index] = section; section->flags = SEC_NO_FLAGS; section->target_index = section_index; - section_type[0] = this_byte_and_next(ieee); + section_type[0] = this_byte_and_next(&(ieee->h)); switch (section_type[0]) { case 0xC3: - section_type[1] = this_byte(ieee); - section->flags = SEC_LOAD; + section_type[1] = this_byte(&(ieee->h)); + section->flags = SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS; switch (section_type[1]) { case 0xD0: /* Normal code */ - next_byte(ieee); + next_byte(&(ieee->h)); section->flags |= SEC_LOAD | SEC_CODE; break; case 0xC4: - next_byte(ieee); + next_byte(&(ieee->h)); section->flags |= SEC_LOAD | SEC_DATA; /* Normal data */ break; case 0xD2: - next_byte(ieee); + next_byte(&(ieee->h)); /* Normal rom data */ section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; break; @@ -753,11 +755,11 @@ DEFUN(ieee_slurp_sections,(abfd), break; } } - section->name = read_id(ieee); + section->name = read_id(&(ieee->h)); { bfd_vma parent, brother, context; - parse_int(ieee, &parent); - parse_int(ieee, &brother); - parse_int(ieee, &context); + parse_int(&(ieee->h), &parent); + parse_int(&(ieee->h), &brother); + parse_int(&(ieee->h), &context); } @@ -767,47 +769,47 @@ DEFUN(ieee_slurp_sections,(abfd), { unsigned int section_index; bfd_vma value; - next_byte(ieee); - section_index = must_parse_int(ieee); + next_byte(&(ieee->h)); + section_index = must_parse_int(&ieee->h); if (section_index > ieee->section_count) { ieee->section_count = section_index; } ieee->section_table[section_index]->alignment_power = - bfd_log2(must_parse_int(ieee)); - (void)parse_int(ieee, & value); + bfd_log2(must_parse_int(&ieee->h)); + (void)parse_int(&(ieee->h), & value); } break; case ieee_e2_first_byte_enum: { - ieee_record_enum_type t = read_2bytes(ieee); + ieee_record_enum_type t = read_2bytes(&(ieee->h)); switch (t) { case ieee_section_size_enum: - section = ieee->section_table[must_parse_int(ieee)]; - section->size = must_parse_int(ieee); + section = ieee->section_table[must_parse_int(&(ieee->h))]; + section->size = must_parse_int(&(ieee->h)); break; case ieee_physical_region_size_enum: - section = ieee->section_table[must_parse_int(ieee)]; - section->size = must_parse_int(ieee); + section = ieee->section_table[must_parse_int(&(ieee->h))]; + section->size = must_parse_int(&(ieee->h)); break; case ieee_region_base_address_enum: - section = ieee->section_table[must_parse_int(ieee)]; - section->vma = must_parse_int(ieee); + section = ieee->section_table[must_parse_int(&(ieee->h))]; + section->vma = must_parse_int(&(ieee->h)); break; case ieee_mau_size_enum: - must_parse_int(ieee); - must_parse_int(ieee); + must_parse_int(&(ieee->h)); + must_parse_int(&(ieee->h)); break; case ieee_m_value_enum: - must_parse_int(ieee); - must_parse_int(ieee); + must_parse_int(&(ieee->h)); + must_parse_int(&(ieee->h)); break; case ieee_section_base_address_enum: - section = ieee->section_table[must_parse_int(ieee)]; - section->vma = must_parse_int(ieee); + section = ieee->section_table[must_parse_int(&(ieee->h))]; + section->vma = must_parse_int(&(ieee->h)); break; case ieee_section_offset_enum: - (void) must_parse_int(ieee); - (void) must_parse_int(ieee); + (void) must_parse_int(&(ieee->h)); + (void) must_parse_int(&(ieee->h)); break; default: return; @@ -828,81 +830,107 @@ bfd_target * DEFUN(ieee_archive_p,(abfd), bfd *abfd) { - return 0; -#if 0 char *library; boolean loop; - ieee_ar_data_type *ar; + unsigned int i; +uint8e_type buffer[512]; + int buffer_i = 0; + int buffer_offset = 0; + ieee_ar_data_type *save = ieee_ar_data(abfd); + ieee_ar_data_type *ieee ; + set_tdata(abfd, bfd_alloc(abfd, sizeof(ieee_ar_data_type))); + ieee= ieee_ar_data(abfd); + + + bfd_read((PTR)buffer, 1, sizeof(buffer), abfd); + ieee->h.first_byte = buffer; + ieee->h.input_p = buffer; -/* FIXME */ - ieee_seek(abfd, (file_ptr) 0); - if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL; - next_byte(ieee); - library= read_id(ieee); + ieee->h.abfd = abfd; + + if (this_byte(&(ieee->h)) != Module_Beginning) return (bfd_target*)NULL; + + next_byte(&(ieee->h)); + library= read_id(&(ieee->h)); if (strcmp(library , "LIBRARY") != 0) { - free(library); + bfd_release(abfd, ieee); + ieee_ar_data(abfd)= save; return (bfd_target *)NULL; } /* Throw away the filename */ - free( read_id(ieee)); + free( read_id(&(ieee->h))); /* This must be an IEEE archive, so we'll buy some space to do things */ - ar = (ieee_ar_data_type *) malloc(sizeof(ieee_ar_data_type)); - set_tdata (abfd, ar); - ar->element_count = 0; - ar->element_index = 0; - obstack_init(&ar->element_obstack); + ieee->element_count = 0; + ieee->element_index = 0; - next_byte(ieee); /* Drop the ad part */ - must_parse_int(ieee); /* And the two dummy numbers */ - must_parse_int(ieee); + next_byte(&(ieee->h)); /* Drop the ad part */ + must_parse_int(&(ieee->h)); /* And the two dummy numbers */ + must_parse_int(&(ieee->h)); loop = true; /* Read the index of the BB table */ while (loop) { ieee_ar_obstack_type t; - int rec =read_2bytes(abfd); + int rec =read_2bytes(&(ieee->h)); if (rec ==ieee_assign_value_to_variable_enum) { - int record_number = must_parse_int(ieee); - t.file_offset = must_parse_int(ieee); + int record_number = must_parse_int(&(ieee->h)); + t.file_offset = must_parse_int(&(ieee->h)); t.abfd = (bfd *)NULL; - ar->element_count++; - obstack_grow(&ar->element_obstack, (PTR)&t, sizeof(t)); + ieee->element_count++; + bfd_alloc_grow(abfd, (PTR)&t, sizeof(t)); + + /* Make sure that we don't go over the end of the buffer */ + + if (ieee_pos(abfd) > sizeof(buffer)/2) { + /* Past half way, reseek and reprime */ + buffer_offset += ieee_pos(abfd); + bfd_seek(abfd, buffer_offset, SEEK_SET); + bfd_read(buffer, 1, sizeof(buffer), abfd); + ieee->h.first_byte = buffer; + ieee->h.input_p = buffer; + } } else loop = false; } - ar->elements = (ieee_ar_obstack_type *)obstack_base(&ar->element_obstack); + + ieee->elements = (ieee_ar_obstack_type *)bfd_alloc_finish(abfd); /* Now scan the area again, and replace BB offsets with file */ /* offsets */ - for (i = 2; i < ar->element_count; i++) { - ieee_seek(abfd, ar->elements[i].file_offset); - next_byte(ieee); /* Drop F8 */ - next_byte(ieee); /* Drop 14 */ - must_parse_int(ieee); /* Drop size of block */ - if (must_parse_int(ieee) != 0) { + for (i = 2; i < ieee->element_count; i++) { + bfd_seek(abfd, ieee->elements[i].file_offset, SEEK_SET); + bfd_read(buffer, 1, sizeof(buffer), abfd); + ieee->h.first_byte = buffer; + ieee->h.input_p = buffer; + + next_byte(&(ieee->h)); /* Drop F8 */ + next_byte(&(ieee->h)); /* Drop 14 */ + must_parse_int(&(ieee->h)); /* Drop size of block */ + if (must_parse_int(&(ieee->h)) != 0) { /* This object has been deleted */ - ar->elements[i].file_offset = 0; + ieee->elements[i].file_offset = 0; } else { - ar->elements[i].file_offset = must_parse_int(ieee); + ieee->elements[i].file_offset = must_parse_int(&(ieee->h)); } } - obstack_finish(&ar->element_obstack); return abfd->xvec; -#endif + } static boolean DEFUN(ieee_mkobject,(abfd), bfd *abfd) -{ - set_tdata (abfd, bfd_alloc(abfd,sizeof(ieee_data_type))); +{ + set_tdata (abfd, bfd_zalloc(abfd,sizeof(ieee_data_type))); + + return true; } @@ -922,8 +950,8 @@ DEFUN(ieee_object_p,(abfd), /* Read the first few bytes in to see if it makes sense */ bfd_read((PTR)buffer, 1, sizeof(buffer), abfd); - ieee->input_p = buffer; - if (this_byte_and_next(ieee) != Module_Beginning) goto fail; + ieee->h.input_p = buffer; + if (this_byte_and_next(&(ieee->h)) != Module_Beginning) goto fail; ieee->read_symbols= false; ieee->read_data= false; @@ -932,46 +960,46 @@ DEFUN(ieee_object_p,(abfd), ieee->external_symbol_min_index = IEEE_PUBLIC_BASE; ieee->external_reference_min_index =IEEE_REFERENCE_BASE; ieee->external_reference_max_index = 0; - ieee->abfd = abfd; + ieee->h.abfd = abfd; memset((PTR)ieee->section_table, 0, sizeof(ieee->section_table)); - processor = ieee->mb.processor = read_id(ieee); + processor = ieee->mb.processor = read_id(&(ieee->h)); if (strcmp(processor,"LIBRARY") == 0) goto fail; - ieee->mb.module_name = read_id(ieee); + ieee->mb.module_name = read_id(&(ieee->h)); if (abfd->filename == (char *)NULL) { abfd->filename = ieee->mb.module_name; } /* Determine the architecture and machine type of the object file. */ bfd_scan_arch_mach(processor, &abfd->obj_arch, &abfd->obj_machine); - if (this_byte(ieee) != ieee_address_descriptor_enum) { + if (this_byte(&(ieee->h)) != ieee_address_descriptor_enum) { goto fail; } - next_byte(ieee); + next_byte(&(ieee->h)); - if (parse_int(ieee, &ieee->ad.number_of_bits_mau) == false) { + if (parse_int(&(ieee->h), &ieee->ad.number_of_bits_mau) == false) { goto fail; } - if(parse_int(ieee, &ieee->ad.number_of_maus_in_address) == false) { + if(parse_int(&(ieee->h), &ieee->ad.number_of_maus_in_address) == false) { goto fail; } /* If there is a byte order info, take it */ - if (this_byte(ieee) == ieee_variable_L_enum || - this_byte(ieee) == ieee_variable_M_enum) - next_byte(ieee); + if (this_byte(&(ieee->h)) == ieee_variable_L_enum || + this_byte(&(ieee->h)) == ieee_variable_M_enum) + next_byte(&(ieee->h)); for (part = 0; part < N_W_VARIABLES; part++) { boolean ok; - if (read_2bytes(ieee) != ieee_assign_value_to_variable_enum) { + if (read_2bytes(&(ieee->h)) != ieee_assign_value_to_variable_enum) { goto fail; } - if (this_byte_and_next(ieee) != part) { + if (this_byte_and_next(&(ieee->h)) != part) { goto fail; } - ieee->w.offset[part] = parse_i(ieee, &ok); + ieee->w.offset[part] = parse_i(&(ieee->h), &ok); if (ok==false) { goto fail; } @@ -984,10 +1012,10 @@ DEFUN(ieee_object_p,(abfd), quickly. We can work out how big the file is from the trailer record */ - ieee_data(abfd)->first_byte = (uint8e_type *) bfd_alloc(ieee->abfd, ieee->w.r.me_record + ieee_data(abfd)->h.first_byte = (uint8e_type *) bfd_alloc(ieee->h.abfd, ieee->w.r.me_record + 50); bfd_seek(abfd, 0, 0); - bfd_read((PTR)(ieee_data(abfd)->first_byte), 1, ieee->w.r.me_record+50, abfd); + bfd_read((PTR)(ieee_data(abfd)->h.first_byte), 1, ieee->w.r.me_record+50, abfd); ieee_slurp_sections(abfd); return abfd->xvec; @@ -1049,18 +1077,18 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), uint8e_type *location_ptr AND asection *s) { - switch (this_byte(ieee)) + switch (this_byte(&(ieee->h))) { case ieee_load_constant_bytes_enum: { unsigned int number_of_maus; unsigned int i; - next_byte(ieee); - number_of_maus = must_parse_int(ieee); + next_byte(&(ieee->h)); + number_of_maus = must_parse_int(&(ieee->h)); for (i = 0; i < number_of_maus; i++) { - location_ptr[current_map->pc++]= this_byte(ieee); - next_byte(ieee); + location_ptr[current_map->pc++]= this_byte(&(ieee->h)); + next_byte(&(ieee->h)); } } break; @@ -1068,10 +1096,10 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), case ieee_load_with_relocation_enum: { boolean loop = true; - next_byte(ieee); + next_byte(&(ieee->h)); while (loop) { - switch (this_byte(ieee)) + switch (this_byte(&(ieee->h))) { case ieee_variable_R_enum: @@ -1083,13 +1111,13 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), boolean pcrel = false; ieee_reloc_type *r = - (ieee_reloc_type *) bfd_alloc(ieee->abfd, + (ieee_reloc_type *) bfd_alloc(ieee->h.abfd, sizeof(ieee_reloc_type)); *(current_map->reloc_tail_ptr) = r; current_map->reloc_tail_ptr= &r->next; r->next = (ieee_reloc_type *)NULL; - next_byte(ieee); + next_byte(&(ieee->h)); parse_expression(ieee, &r->relent.addend, &r->relent.section, @@ -1097,24 +1125,24 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), &pcrel, &extra); r->relent.address = current_map->pc; s->reloc_count++; - switch (this_byte(ieee)) { + switch (this_byte(&(ieee->h))) { case ieee_function_signed_close_b_enum: - next_byte(ieee); + next_byte(&(ieee->h)); break; case ieee_function_unsigned_close_b_enum: - next_byte(ieee); + next_byte(&(ieee->h)); break; case ieee_function_either_close_b_enum: - next_byte(ieee); + next_byte(&(ieee->h)); break; default: break; } /* Build a relocation entry for this type */ - if (this_byte(ieee) == ieee_comma) { - next_byte(ieee); + if (this_byte(&(ieee->h)) == ieee_comma) { + next_byte(&(ieee->h)); /* Fetch number of bytes to pad */ - extra = must_parse_int(ieee); + extra = must_parse_int(&(ieee->h)); }; /* If pc rel then stick -ve pc into instruction @@ -1126,14 +1154,14 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), case 4: if (pcrel == true) { - bfd_put_32(ieee->abfd, -current_map->pc, location_ptr + + bfd_put_32(ieee->h.abfd, -current_map->pc, location_ptr + current_map->pc); r->relent.howto = &rel32_howto; r->relent.addend -= current_map->pc; } else { - bfd_put_32(ieee->abfd, 0, location_ptr + + bfd_put_32(ieee->h.abfd, 0, location_ptr + current_map->pc); r->relent.howto = &abs32_howto; } @@ -1141,12 +1169,12 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), break; case 2: if (pcrel == true) { - bfd_put_16(ieee->abfd, (int)(-current_map->pc), location_ptr +current_map->pc); + bfd_put_16(ieee->h.abfd, (int)(-current_map->pc), location_ptr +current_map->pc); r->relent.addend -= current_map->pc; r->relent.howto = &rel16_howto; } else { - bfd_put_16(ieee->abfd, 0, location_ptr +current_map->pc); + bfd_put_16(ieee->h.abfd, 0, location_ptr +current_map->pc); r->relent.howto = &abs16_howto; } current_map->pc +=2; @@ -1161,11 +1189,11 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), default: { bfd_vma this_size ; - if (parse_int(ieee, &this_size) == true) { + if (parse_int(&(ieee->h), &this_size) == true) { unsigned int i; for (i = 0; i < this_size; i++) { - location_ptr[current_map->pc ++] = this_byte(ieee); - next_byte(ieee); + location_ptr[current_map->pc ++] = this_byte(&(ieee->h)); + next_byte(&(ieee->h)); } } else { @@ -1178,7 +1206,7 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), } } - /* Read in all the section data and relocation stuff too */ +/* Read in all the section data and relocation stuff too */ static boolean DEFUN(ieee_slurp_section_data,(abfd), bfd *abfd) @@ -1199,7 +1227,7 @@ DEFUN(ieee_slurp_section_data,(abfd), for (s = abfd->sections; s != (asection *)NULL; s = s->next) { ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd; - per->data = (bfd_byte *) bfd_alloc(ieee->abfd, s->size); + per->data = (bfd_byte *) bfd_alloc(ieee->h.abfd, s->size); /*SUPPRESS 68*/ per->reloc_tail_ptr = (ieee_reloc_type **)&(s->relocation); @@ -1208,15 +1236,15 @@ DEFUN(ieee_slurp_section_data,(abfd), while (true) { - switch (this_byte(ieee)) + switch (this_byte(&(ieee->h))) { /* IF we see anything strange then quit */ default: return true; case ieee_set_current_section_enum: - next_byte(ieee); - section_number = must_parse_int(ieee); + next_byte(&(ieee->h)); + section_number = must_parse_int(&(ieee->h)); s = ieee->section_table[section_number]; current_map = (ieee_per_section_type *) s->used_by_bfd; location_ptr = current_map->data - s->vma; @@ -1228,8 +1256,8 @@ DEFUN(ieee_slurp_section_data,(abfd), case ieee_e2_first_byte_enum: - next_byte(ieee); - switch (this_byte(ieee)) + next_byte(&(ieee->h)); + switch (this_byte(&(ieee->h))) { case ieee_set_current_pc_enum & 0xff: { @@ -1238,8 +1266,8 @@ DEFUN(ieee_slurp_section_data,(abfd), ieee_symbol_index_type symbol; unsigned int extra; boolean pcrel; - next_byte(ieee); - must_parse_int(ieee); /* Thow away section #*/ + next_byte(&(ieee->h)); + must_parse_int(&(ieee->h)); /* Thow away section #*/ parse_expression(ieee, &value, &dsection, &symbol, &pcrel, &extra); current_map->pc = value; @@ -1259,18 +1287,31 @@ DEFUN(ieee_slurp_section_data,(abfd), { /* Repeat the following LD or LR n times - we do this by remembering the stream pointer before running it and - resetting it and running it n times + resetting it and running it n times. We special case + the repetition of a repeat_data/load_constant */ unsigned int iterations ; uint8e_type *start ; - next_byte(ieee); - iterations = must_parse_int(ieee); - start = ieee->input_p; - while (iterations != 0) { - ieee->input_p = start; - do_one(ieee, current_map, location_ptr,s); - iterations --; + next_byte(&(ieee->h)); + iterations = must_parse_int(&(ieee->h)); + start = ieee->h.input_p; + if (start[0] == ieee_load_constant_bytes_enum && + start[1] == 1) { + while (iterations != 0) { + location_ptr[current_map->pc++] = start[2]; + iterations--; + } + next_byte(&(ieee->h)); + next_byte(&(ieee->h)); + next_byte(&(ieee->h)); + } + else { + while (iterations != 0) { + ieee->h.input_p = start; + do_one(ieee, current_map, location_ptr,s); + iterations --; + } } } break; @@ -1393,32 +1434,42 @@ DEFUN(ieee_write_section_part,(abfd), ieee_write_byte(abfd, ieee_section_type_enum); ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); - switch (s->flags & (SEC_LOAD | SEC_CODE | SEC_DATA | SEC_ROM)) { - case SEC_LOAD | SEC_CODE: - /* Normal named section, code */ - ieee_write_byte(abfd, ieee_variable_C_enum); - ieee_write_byte(abfd, ieee_variable_P_enum); - break; - case SEC_LOAD | SEC_DATA: - /* Normal named section, data */ - ieee_write_byte(abfd, ieee_variable_C_enum); - ieee_write_byte(abfd, ieee_variable_D_enum); - break; - case SEC_LOAD | SEC_DATA | SEC_ROM: - /* Normal named section, data rom */ - ieee_write_byte(abfd, ieee_variable_C_enum); - ieee_write_byte(abfd, ieee_variable_R_enum); - break; - default: - ieee_write_byte(abfd, ieee_variable_C_enum); - break; - } + if (abfd->flags & EXEC_P) + { + /* This image is executable, so output absolute sections */ + ieee_write_byte(abfd, ieee_variable_A_enum); + ieee_write_byte(abfd, ieee_variable_S_enum); + } + else + { + ieee_write_byte(abfd, ieee_variable_C_enum); + } + + switch (s->flags &(SEC_CODE | SEC_DATA | SEC_ROM)) + { + case SEC_CODE | SEC_LOAD: + case SEC_CODE: + ieee_write_byte(abfd, ieee_variable_P_enum); + break; + case SEC_DATA: + default: + ieee_write_byte(abfd, ieee_variable_D_enum); + break; + case SEC_ROM: + case SEC_ROM | SEC_DATA: + case SEC_ROM | SEC_LOAD: + case SEC_ROM | SEC_DATA | SEC_LOAD: + + ieee_write_byte(abfd, ieee_variable_R_enum); + } + ieee_write_id(abfd, s->name); +#if 0 ieee_write_int(abfd, 0); /* Parent */ ieee_write_int(abfd, 0); /* Brother */ ieee_write_int(abfd, 0); /* Context */ - +#endif /* Alignment */ ieee_write_byte(abfd, ieee_section_alignment_enum); ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); @@ -1430,7 +1481,7 @@ DEFUN(ieee_write_section_part,(abfd), ieee_write_int(abfd, s->size); /* Vma */ - ieee_write_2bytes(abfd, ieee_region_base_address_enum); + ieee_write_2bytes(abfd, ieee_section_base_address_enum); ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); ieee_write_int(abfd, s->vma); @@ -1439,128 +1490,737 @@ DEFUN(ieee_write_section_part,(abfd), -/* write the data in an ieee way */ -static void -DEFUN(ieee_write_data_part,(abfd), - bfd *abfd) +static void +DEFUN(do_with_relocs,(abfd, s), + bfd *abfd AND + asection *s) { - asection *s; - ieee_data_type *ieee = ieee_data(abfd); - ieee->w.r.data_part = bfd_tell(abfd); - for (s = abfd->sections; s != (asection *)NULL; s = s->next) + unsigned int relocs_to_go = s->reloc_count; + bfd_byte header[11]; + + bfd_byte *stream = ieee_per_section(s)->data; + arelent **p = s->orelocation; + + bfd_size_type current_byte_index = 0; + + qsort(s->orelocation, + relocs_to_go, + sizeof(arelent **), + comp); + + + + /* Output the section preheader */ + header[0] =ieee_set_current_section_enum; + header[1] = s->index + IEEE_SECTION_NUMBER_BASE; + + header[2] = ieee_set_current_pc_enum >> 8; + header[3]= ieee_set_current_pc_enum & 0xff; + header[4] = s->index + IEEE_SECTION_NUMBER_BASE; + ieee_write_int5(header+5, s->vma ); + header[10] = ieee_load_with_relocation_enum; + bfd_write((PTR)header, 1, sizeof(header), abfd); + + /* Output the data stream as the longest sequence of bytes + possible, allowing for the a reasonable packet size and + relocation stuffs */ + + if ((PTR)stream == (PTR)NULL) { + /* Outputting a section without data, fill it up */ + stream = (uint8e_type *)(bfd_alloc(abfd, s->size)); + memset((PTR)stream, 0, s->size); + } + while (current_byte_index < s->size) { + bfd_size_type run; + unsigned int MAXRUN = 32; + if (relocs_to_go) { + run = (*p)->address - current_byte_index; + } + else { + run = MAXRUN; + } + if (run > s->size - current_byte_index) { + run = s->size - current_byte_index; + } + + if (run != 0) { + /* Output a stream of bytes */ + ieee_write_int(abfd, run); + bfd_write((PTR)(stream + current_byte_index), + 1, + run, + abfd); + current_byte_index += run; + } + /* Output any relocations here */ + if (relocs_to_go && (*p) && (*p)->address == current_byte_index) { + while (relocs_to_go && (*p) && (*p)->address == current_byte_index) { + + arelent *r = *p; + bfd_vma ov; + if (r->howto->pc_relative) { + r->addend += current_byte_index; + } + + switch (r->howto->size) { + case 2: + + ov = bfd_get_32(abfd, + stream+current_byte_index); + current_byte_index +=4; + break; + case 1: + ov = bfd_get_16(abfd, + stream+current_byte_index); + current_byte_index +=2; + break; + default: + BFD_FAIL(); + } + ieee_write_byte(abfd, ieee_function_either_open_b_enum); + + if (r->sym_ptr_ptr != (asymbol **)NULL) { + ieee_write_expression(abfd, r->addend + ov, + r->section, + *(r->sym_ptr_ptr), + r->howto->pc_relative, s->target_index); + } + else { + ieee_write_expression(abfd, r->addend + ov, + r->section, + (asymbol *)NULL, + r->howto->pc_relative, s->target_index); + } + ieee_write_byte(abfd, + ieee_function_either_close_b_enum); + if (r->howto->size != 2) { + ieee_write_byte(abfd, ieee_comma); + ieee_write_int(abfd, 1<< r->howto->size); + } + + relocs_to_go --; + p++; + } + + } + } +} + +/* If there are no relocations in the output section then we can +be clever about how we write. We block items up into a max of 127 +bytes */ + +static void +DEFUN(do_as_repeat, (abfd, s), + bfd *abfd AND + asection *s) +{ + ieee_write_byte(abfd, ieee_set_current_section_enum); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_byte(abfd, ieee_set_current_pc_enum >> 8); + ieee_write_byte(abfd, ieee_set_current_pc_enum & 0xff); + ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); + ieee_write_int(abfd, s->vma ); + + ieee_write_byte(abfd,ieee_repeat_data_enum); + ieee_write_int(abfd, s->size); + ieee_write_byte(abfd, ieee_load_constant_bytes_enum); + ieee_write_byte(abfd, 1); + ieee_write_byte(abfd, 0); +} + +static void +DEFUN(do_without_relocs, (abfd, s), + bfd *abfd AND + asection *s) +{ + bfd_byte *stream = ieee_per_section(s)->data; + + if (stream == 0 || ((s->flags & SEC_LOAD) == 0)) { - bfd_byte header[11]; - bfd_byte *stream = ieee_per_section(s)->data; - arelent **p = s->orelocation; - unsigned int relocs_to_go = s->reloc_count; - bfd_size_type current_byte_index = 0; + do_as_repeat(abfd, s); + } + else + { + unsigned int i; + for (i = 0; i < s->size; i++) { + if (stream[i] != 0) { + do_with_relocs(abfd, s); + return; + } + } + do_as_repeat(abfd, s); + } + +} - /* Sort the reloc records so we can insert them in the correct - places */ - if (s->reloc_count != 0) { - qsort(s->orelocation, - relocs_to_go, - sizeof(arelent **), - comp); + +static unsigned char *output_ptr_start; +static unsigned char *output_ptr; +static unsigned char *output_ptr_end; +static unsigned char *input_ptr_start; +static unsigned char *input_ptr; +static unsigned char *input_ptr_end; +static bfd *input_bfd; +static bfd *output_bfd; +static int output_buffer; + +static void fill() +{ + bfd_read(input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd); + input_ptr = input_ptr_start; +} +static void flush() +{ + bfd_write(output_ptr_start,1,output_ptr - output_ptr_start, output_bfd); + output_ptr = output_ptr_start; + output_buffer++; +} + +#define THIS() ( *input_ptr ) +#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); } +#define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); } + +static void write_int(value) +int value; +{ + if (value >= 0 && value <= 127) { + OUT(value); + } + else { + unsigned int length; + /* How many significant bytes ? */ + /* FIXME FOR LONGER INTS */ + if (value & 0xff000000) { + length = 4; + } + else if (value & 0x00ff0000) { + length = 3; + } + else if (value & 0x0000ff00) { + length = 2; + } + else length = 1; + + OUT((int)ieee_number_repeat_start_enum + length); + switch (length) { + case 4: + OUT( value >> 24); + case 3: + OUT( value >> 16); + case 2: + OUT( value >> 8); + case 1: + OUT( value); + } + + } +} +static void copy_id() +{ + int length = THIS(); + char ch; + OUT(length); + NEXT(); + while (length--) { + ch = THIS(); + OUT(ch); + NEXT(); + } +} +#define VAR(x) ((x | 0x80)) +static void copy_expression() +{ + int stack[10]; + int *tos = stack; + int value = 0; + while (1) { + switch (THIS()) { + case 0x84: + NEXT(); + value = THIS(); NEXT(); + value = (value << 8) | THIS(); NEXT(); + value = (value << 8) | THIS(); NEXT(); + value = (value << 8) | THIS(); NEXT(); + *tos ++ = value; + break; + case 0x83: + NEXT(); + value = THIS(); NEXT(); + value = (value << 8) | THIS(); NEXT(); + value = (value << 8) | THIS(); NEXT(); + *tos ++ = value; + break; + case 0x82: + NEXT(); + value = THIS(); NEXT(); + value = (value << 8) | THIS(); NEXT(); + *tos ++ = value; + break; + case 0x81: + NEXT(); + value = THIS(); NEXT(); + *tos ++ = value; + break; + case 0x80: + NEXT(); + *tos ++ = 0; + break; + default: + if (THIS() >0x84) { + /* Not a number, just bug out with the answer */ + write_int(*(--tos)); + return; + } + *tos++ = THIS(); +NEXT(); + value = 0; + break; + case 0xa5: + /* PLUS anything */ + { + int value = *(--tos); + value += *(--tos); + *tos++ = value; + NEXT(); } + break; + case VAR('R') : + { + int section_number ; + ieee_data_type *ieee; + asection *s; + NEXT(); + section_number = THIS(); + + NEXT(); + ieee= ieee_data(input_bfd); + s = ieee->section_table[section_number]; + if (s->output_section) { + value = s->output_section->vma ; + } else { value = 0; } + value += s->output_offset; + *tos++ = value; + value = 0; + } + break; + case 0x90: + { + NEXT(); + write_int(*(--tos)); + OUT(0x90); + return; + } + } + } + +} - /* Output the section preheader */ - header[0] =ieee_set_current_section_enum; - header[1] = s->index + IEEE_SECTION_NUMBER_BASE; +/* Drop the int in the buffer, and copy a null into the gap, which we + will overwrite later */ - header[2] = ieee_set_current_pc_enum >> 8; - header[3]= ieee_set_current_pc_enum & 0xff; - header[4] = s->index + IEEE_SECTION_NUMBER_BASE; - ieee_write_int5(header+5, s->vma ); - header[10] = ieee_load_with_relocation_enum; - bfd_write((PTR)header, 1, sizeof(header), abfd); +struct output_buffer_struct { +unsigned char *ptrp; + int buffer; +} ; - /* Output the data stream as the longest sequence of bytes - possible, allowing for the a reasonable packet size and - relocation stuffs */ +static void +DEFUN(fill_int,(buf), + struct output_buffer_struct *buf) +{ + if (buf->buffer == output_buffer) { + /* Still a chance to output the size */ + int value = output_ptr - buf->ptrp + 3; + buf->ptrp[0] = value >> 24; + buf->ptrp[1] = value >> 16; + buf->ptrp[2] = value >> 8; + buf->ptrp[3] = value >> 0; + } - if ((PTR)stream == (PTR)NULL) { - /* Outputting a section without data, fill it up */ - stream = (uint8e_type *)(bfd_alloc(abfd, s->size)); - memset((PTR)stream, 0, s->size); +} +static void +DEFUN(drop_int,(buf), + struct output_buffer_struct *buf) +{ + int type = THIS(); + int ch; + if (type <= 0x84) { + NEXT(); + switch(type) { + case 0x84: ch = THIS(); NEXT(); + case 0x83: ch = THIS(); NEXT(); + case 0x82: ch = THIS(); NEXT(); + case 0x81: ch = THIS(); NEXT(); + case 0x80: break; + } + } + OUT(0x84); + buf->ptrp = output_ptr; + buf->buffer = output_buffer; + OUT(0);OUT(0);OUT(0);OUT(0); +} + +static void copy_int() +{ + int type = THIS(); + int ch; + if (type <= 0x84) { + OUT(type); + NEXT(); + switch(type) { + case 0x84: ch = THIS(); NEXT(); OUT(ch); + case 0x83: ch = THIS(); NEXT(); OUT(ch); + case 0x82: ch = THIS(); NEXT(); OUT(ch); + case 0x81: ch = THIS(); NEXT(); OUT(ch); + case 0x80: break; + } + } +} + +#define ID copy_id() +#define INT copy_int() +#define EXP copy_expression() +static void copy_till_end(); +#define INTn(q) copy_int() +#define EXPn(q) copy_expression() +static void f1_record() +{ + int ch; + /* ATN record */ + NEXT(); + ch = THIS(); + switch (ch) + { + default: + OUT(0xf1); OUT(ch); + break; + case 0xc9: + NEXT(); + OUT(0xf1); OUT(0xc9); + INT; INT; ch = THIS(); + switch (ch) + { + case 0x16: NEXT();break; + case 0x01: NEXT();break; + case 0x00: NEXT(); INT; break; + case 0x03: NEXT(); INT; break; + case 0x13: EXPn(instruction address); break; + default: + break; + } + break; + case 0xd8: + /* EXternal ref */ + NEXT(); + OUT(0xf1); OUT(0xd8); + EXP ; EXP; EXP; EXP; + break; + case 0xce: + NEXT(); + OUT(0xf1);OUT(0xce); INT; INT; ch = THIS(); INT; + switch (ch) { + case 0x01: + INT; INT; break; + case 0x02: + INT; break; + case 0x04: + EXPn(external function); break; + case 0x05: + break; + case 0x07: INTn(line number); INT; + case 0x08: break; + case 0x0a: INTn(locked register); INT; break; + case 0x3f: copy_till_end(); break; + case 0x3e: copy_till_end(); break; + case 0x40: copy_till_end(); break; + case 0x41: ID; break; } - while (current_byte_index < s->size) { - bfd_size_type run; - unsigned int MAXRUN = 32; - if (relocs_to_go) { - run = (*p)->address - current_byte_index; - } - else { - run = MAXRUN; + } + +} +static void f0_record() +{ + /* Attribute record */ + NEXT(); + OUT(0xf0); + INTn(Symbol name ); + ID; +} +static void copy_till_end() +{ + int ch = THIS(); + while (1) { + while (ch <= 0x80) + { + OUT(ch); + NEXT(); + ch = THIS(); + } + switch (ch) { + case 0x84: + OUT(THIS()); + NEXT(); + case 0x83: + OUT(THIS()); + NEXT(); + case 0x82: + OUT(THIS()); + NEXT(); + case 0x81: + OUT(THIS()); + NEXT(); + OUT(THIS()); + NEXT(); + + ch = THIS(); + break; + default: + return; + } + } + +} + +static void f2_record() +{ + int ch; + NEXT(); + OUT(0xf2); + INT ; + NEXT(); + OUT(0xce); + INT ; +copy_till_end(); +} + + +static void block(); +static void f8_record() +{ + int ch; + NEXT(); + ch = THIS(); + switch (ch) + { + case 0x01: + case 0x02: + case 0x03: + /* Unique typedefs for module */ + /* GLobal typedefs */ + /* High level module scope beginning */ + { + struct output_buffer_struct ob; + NEXT(); + OUT(0xf8); OUT(ch); + drop_int(&ob); ID ; + + block(); + + NEXT(); + fill_int(&ob); + OUT(0xf9); } - if (run > s->size - current_byte_index) { - run = s->size - current_byte_index; + break; + case 0x04: + /* Global function */ + { + struct output_buffer_struct ob; + NEXT(); + OUT(0xf8); OUT(0x04); + drop_int(&ob); ID ; INTn(stack size); INTn(ret val); + EXPn(offset); + + block(); + + NEXT(); + OUT(0xf9); + EXPn(size of block); + fill_int(&ob); } + break; - if (run != 0) { - /* Output a stream of bytes */ - ieee_write_int(abfd, run); - bfd_write((PTR)(stream + current_byte_index), - 1, - run, - abfd); - current_byte_index += run; + case 0x05: + /* File name for source line numbers */ + { + struct output_buffer_struct ob; + NEXT(); + OUT(0xf8); OUT(0x05); + drop_int(&ob); + ID; INTn(year); INTn(month); INTn(day); + INTn(hour); INTn(monute); INTn(second); + block(); + NEXT(); + OUT(0xf9); + fill_int(&ob); } - /* Output any relocations here */ - if (relocs_to_go && (*p) && (*p)->address == current_byte_index) { - while (relocs_to_go && (*p) && (*p)->address == current_byte_index) { - - arelent *r = *p; - bfd_vma ov; - if (r->howto->pc_relative) { - r->addend += current_byte_index; - } + break; + + case 0x06: + /* Local function */ + { struct output_buffer_struct ob; + NEXT(); OUT(0xf8); OUT(0x06); + drop_int(&ob); + ID; INTn(stack size); INTn(type return); + EXPn(offset); + block(); + NEXT(); + OUT(0xf9); + EXPn(size); + fill_int(&ob); + } + break; + + case 0x0a: + /* Assembler module scope beginning -*/ + { struct output_buffer_struct ob; - switch (r->howto->size) { - case 2: + NEXT(); + OUT(0xf8); OUT(0x0a); + drop_int(&ob); + ID; ID; INT; ID; INT; INT; INT; INT; INT; INT; - ov = bfd_get_32(abfd, - stream+current_byte_index); - current_byte_index +=4; - break; - case 1: - ov = bfd_get_16(abfd, - stream+current_byte_index); - current_byte_index +=2; - break; - default: - BFD_FAIL(); - } - ieee_write_byte(abfd, ieee_function_either_open_b_enum); + block(); - if (r->sym_ptr_ptr != (asymbol **)NULL) { - ieee_write_expression(abfd, r->addend + ov, - r->section, - *(r->sym_ptr_ptr), - r->howto->pc_relative, s->target_index); - } - else { - ieee_write_expression(abfd, r->addend + ov, - r->section, - (asymbol *)NULL, - r->howto->pc_relative, s->target_index); - } - ieee_write_byte(abfd, - ieee_function_either_close_b_enum); - if (r->howto->size != 2) { - ieee_write_byte(abfd, ieee_comma); - ieee_write_int(abfd, 1<< r->howto->size); - } + NEXT(); + OUT(0xf9); + fill_int(&ob); + } + break; + case 0x0b: + { + struct output_buffer_struct ob; + NEXT(); + OUT(0xf8); OUT(0x0b); + drop_int(&ob); ID ; INT; INTn(section index); EXPn(offset); INTn(stuff); - relocs_to_go --; - p++; - } + block(); + OUT(0xf9); + NEXT(); + EXPn(Size in Maus); + fill_int(&ob); } - } + break; } +} +static void e2_record() +{ + OUT(0xe2); + NEXT(); + OUT(0xce); + NEXT(); + INT; + EXP; +} + +static void DEFUN_VOID(block) +{ + int ch ; + while (1) { + ch = THIS(); + switch (ch) { + case 0xe1: + case 0xe5: + return; + case 0xf9: + return; + case 0xf0: + f0_record(); + break; + case 0xf1: + f1_record(); + break; + case 0xf2: + f2_record(); + break; + case 0xf8: + f8_record(); + break; + case 0xe2: + e2_record(); + break; + + } + } +} + + + +/* relocate_debug, + moves all the debug information from the source bfd to the output + bfd, and relocates any expressions it finds +*/ + +static void +DEFUN(relocate_debug,(output, input), + bfd *output AND + bfd *input) +{ +#define IBS 400 +#define OBS 400 + unsigned char input_buffer[IBS]; + + input_ptr_start = input_ptr = input_buffer; + input_ptr_end = input_buffer + IBS; + input_bfd = input; + bfd_read(input_ptr_start, 1, IBS, input); + block(); +} +/* + During linking, we we told about the bfds which made up our + contents, we have a list of them. They will still be open, so go to + the debug info in each, and copy it out, relocating it as we go. +*/ + +static void +DEFUN(ieee_write_debug_part, (abfd), + bfd *abfd) +{ + ieee_data_type *ieee = ieee_data(abfd); + bfd_chain_type *chain = ieee->chain_root; + unsigned char output_buffer[OBS]; + output_ptr_start = output_ptr = output_buffer ; + output_ptr_end = output_buffer + OBS; + output_ptr = output_buffer; + output_bfd = abfd; + ieee->w.r.debug_information_part = bfd_tell(abfd); + while (chain != (bfd_chain_type *)NULL) { + bfd *entry = chain->this; + ieee_data_type *entry_ieee = ieee_data(entry); + if (entry_ieee->w.r.debug_information_part) { + bfd_seek(entry, entry_ieee->w.r.debug_information_part, SEEK_SET); + relocate_debug(abfd, entry); + } + + chain = chain->next; + } + + flush(); + +} +/* write the data in an ieee way */ +static void +DEFUN(ieee_write_data_part,(abfd), + bfd *abfd) +{ + asection *s; + ieee_data_type *ieee = ieee_data(abfd); + ieee->w.r.data_part = bfd_tell(abfd); + for (s = abfd->sections; s != (asection *)NULL; s = s->next) + { + /* Sort the reloc records so we can insert them in the correct + places */ + if (s->reloc_count != 0) + { + do_with_relocs(abfd, s); + } + else + { + do_without_relocs(abfd, s); + } + } } @@ -1650,10 +2310,20 @@ DEFUN(ieee_write_external_part,(abfd), ieee_write_int(abfd, public_index); if (p->section != (asection *)NULL) { - ieee_write_expression(abfd, - p->value + p->section->output_offset, - p->section->output_section, - (asymbol *)NULL, false, 0); + if (abfd->flags & EXEC_P) + { + /* If fully linked, then output all symbols + relocated */ + ieee_write_int(abfd, + p->value + p->section->output_offset+ p->section->output_section->vma); + + } + else { + ieee_write_expression(abfd, + p->value + p->section->output_offset, + p->section->output_section, + (asymbol *)NULL, false, 0); + } } else { @@ -1701,14 +2371,36 @@ DEFUN(ieee_write_object_contents,(abfd), ieee_write_id(abfd, bfd_printable_arch_mach(abfd->obj_arch, abfd->obj_machine)); ieee_write_id(abfd, abfd->filename); + + + + + /* Fast forward over the variable bits */ + + + ieee_write_byte(abfd, ieee_address_descriptor_enum); ieee_write_byte(abfd, 8); /* Bits per MAU */ ieee_write_byte(abfd, 4); /* MAU's per address */ - /* Fast forward over the variable bits */ old = bfd_tell(abfd); bfd_seek(abfd, 8 * N_W_VARIABLES, 1); + + ieee->w.r.extension_record = bfd_tell(abfd); + ieee->w.r.environmental_record = bfd_tell(abfd); + ieee_write_byte(abfd, 0xf0); + ieee_write_byte(abfd, 0x20); + ieee_write_byte(abfd, 0x00); + ieee_write_byte(abfd, 0xf1); + ieee_write_byte(abfd, 0xce); + ieee_write_byte(abfd, 0x20); + ieee_write_byte(abfd, 0x00); + ieee_write_byte(abfd, 0x55); + ieee_write_id(abfd,"built using BFD"); + + + /* First write the symbols, this changes their values into table indeces so we cant use it after this point @@ -1718,6 +2410,13 @@ DEFUN(ieee_write_object_contents,(abfd), ieee_write_section_part(abfd); ieee_write_byte(abfd, ieee_record_seperator_enum); + + + /* + Write any debugs we have been told about + */ +ieee_write_debug_part(abfd); + /* Can only write the data once the symbols have been written since the data contains relocation information which points to the @@ -1765,9 +2464,9 @@ DEFUN(ieee_make_empty_symbol,(abfd), } static bfd * -ieee_openr_next_archived_file(arch, prev) -bfd *arch; -bfd *prev; +DEFUN(ieee_openr_next_archived_file,(arch, prev), + bfd *arch AND + bfd *prev) { ieee_ar_data_type *ar = ieee_ar_data(arch); /* take the next one from the arch state, or reset */ @@ -1788,6 +2487,7 @@ bfd *prev; } } else { + bfd_error = no_more_archived_files; return (bfd *)NULL; } @@ -1838,13 +2538,76 @@ DEFUN(ieee_sizeof_headers,(abfd, x), return 0; } + + +static void +DEFUN(ieee_bfd_debug_info_start,(abfd), + bfd *abfd) + { + + } + +static void +DEFUN(ieee_bfd_debug_info_end,(abfd), + bfd *abfd) + { + + } + + +/* Add this section to the list of sections we have debug info for, to + be ready to output it at close time + */ +static void +DEFUN(ieee_bfd_debug_info_accumulate,(abfd, section), + bfd *abfd AND + asection *section) +{ + ieee_data_type *ieee = ieee_data(section->owner); + ieee_data_type *output_ieee = ieee_data(abfd); + /* can only accumulate data from other ieee bfds */ + if (section->owner->xvec != abfd->xvec) + return; + /* Only bother once per bfd */ + if (ieee->done_debug == true) + return; + ieee->done_debug = true; + + /* Don't bother if there is no debug info */ + if (ieee->w.r.debug_information_part == 0) + return; + + + /* Add to chain */ + { + bfd_chain_type *n = (bfd_chain_type *) bfd_alloc(abfd, sizeof(bfd_chain_type)); + n->this = section->owner; + n->next = (bfd_chain_type *)NULL; + + if (output_ieee->chain_head) { + output_ieee->chain_head->next = n; + } + else { + output_ieee->chain_root = n; + + } + output_ieee->chain_head = n; + } +} + + + + + + +#define FOO PROTO #define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr) #define ieee_core_file_failing_signal (int (*)())bfd_0 -#define ieee_core_file_matches_executable_p ( PROTO(boolean, (*),(bfd *, bfd *)))bfd_false +#define ieee_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false #define ieee_slurp_armap bfd_true #define ieee_slurp_extended_name_table bfd_true #define ieee_truncate_arname (void (*)())bfd_nullvoidptr -#define ieee_write_armap (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr +#define ieee_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr #define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr #define ieee_close_and_cleanup bfd_generic_close_and_cleanup @@ -1863,6 +2626,7 @@ bfd_target ieee_vec = |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ + 1, /* minimum alignment */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ diff --git a/bfd/libbfd.c b/bfd/libbfd.c index ff64c28..eb3515a 100644 --- a/bfd/libbfd.c +++ b/bfd/libbfd.c @@ -138,10 +138,10 @@ DEFUN(zalloc,(size), static int DEFUN(real_read,(where, a,b, file), - PTR where AND - int a AND - int b AND - FILE *file) + PTR where AND + int a AND + int b AND + FILE *file) { return fread(where, a,b,file); } @@ -171,43 +171,44 @@ DEFUN(bfd_seek,(abfd, position, direction), CONST file_ptr position AND CONST int direction) { - /* For the time being, a bfd may not seek to it's end. The - problem is that we don't easily have a way to recognize - the end of an element in an archive. */ - - BFD_ASSERT(direction == SEEK_SET - || direction == SEEK_CUR); - - if (direction == SEEK_SET && abfd->my_archive != NULL) - { - /* This is a set within an archive, so we need to - add the base of the object within the archive */ - return(fseek(bfd_cache_lookup(abfd), - position + abfd->origin, - direction)); - } - else - { - return(fseek(bfd_cache_lookup(abfd), position, direction)); - } + /* For the time being, a bfd may not seek to it's end. The + problem is that we don't easily have a way to recognize + the end of an element in an archive. */ + + BFD_ASSERT(direction == SEEK_SET + || direction == SEEK_CUR); + + if (direction == SEEK_SET && abfd->my_archive != NULL) + { + /* This is a set within an archive, so we need to + add the base of the object within the archive */ + return(fseek(bfd_cache_lookup(abfd), + position + abfd->origin, + direction)); + } + else + { + return(fseek(bfd_cache_lookup(abfd), position, direction)); + } } long DEFUN(bfd_tell,(abfd), bfd *abfd) { - file_ptr ptr; + file_ptr ptr; - ptr = ftell (bfd_cache_lookup(abfd)); + ptr = ftell (bfd_cache_lookup(abfd)); - if (abfd->my_archive) - ptr -= abfd->origin; - return ptr; + if (abfd->my_archive) + ptr -= abfd->origin; + return ptr; } /** Make a string table */ -/* Add string to table pointed to by table, at location starting with free_ptr. +/*>bfd.h< + Add string to table pointed to by table, at location starting with free_ptr. resizes the table if necessary (if it's NULL, creates it, ignoring table_length). Updates free_ptr, table, table_length */ @@ -227,7 +228,7 @@ DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr), /* Avoid a useless regrow if we can (but of course we still take it next time */ space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ? - DEFAULT_STRING_SPACE_SIZE : string_length+1); + DEFAULT_STRING_SPACE_SIZE : string_length+1); base = zalloc (space_length); if (base == NULL) { @@ -265,21 +266,76 @@ DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr), /* FIXME: Should these take a count argument? Answer (gnu@cygnus.com): No, but perhaps they should be inline - functions in swap.h #ifdef __GNUC__. - Gprof them later and find out. */ + functions in swap.h #ifdef __GNUC__. + Gprof them later and find out. */ + +/*proto* +*i bfd_put_size +*i bfd_get_size +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) \ + (*((char *)ptr)) +#define bfd_put_16(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx16, (val,ptr)) +#define bfd_get_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx16, (ptr)) +#define bfd_put_32(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx32, (val,ptr)) +#define bfd_get_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx32, (ptr)) +#define bfd_put_64(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_putx64, (val, ptr)) +#define bfd_get_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_getx64, (ptr)) +*- +*-*/ + +/*proto* +*i bfd_h_put_size +*i bfd_h_get_size +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) \ + (*((char *)ptr)) +#define bfd_h_put_16(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx16,(val,ptr)) +#define bfd_h_get_16(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx16,(ptr)) +#define bfd_h_put_32(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx32,(val,ptr)) +#define bfd_h_get_32(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx32,(ptr)) +#define bfd_h_put_64(abfd, val, ptr) \ + BFD_SEND(abfd, bfd_h_putx64,(val, ptr)) +#define bfd_h_get_64(abfd, ptr) \ + BFD_SEND(abfd, bfd_h_getx64,(ptr)) +*- +*-*/ unsigned int DEFUN(_do_getb16,(addr), register bfd_byte *addr) { - return (addr[0] << 8) | addr[1]; + return (addr[0] << 8) | addr[1]; } unsigned int DEFUN(_do_getl16,(addr), register bfd_byte *addr) { - return (addr[1] << 8) | addr[0]; + return (addr[1] << 8) | addr[0]; } void @@ -287,31 +343,31 @@ DEFUN(_do_putb16,(data, addr), int data AND register bfd_byte *addr) { - addr[0] = (bfd_byte)(data >> 8); - addr[1] = (bfd_byte )data; + addr[0] = (bfd_byte)(data >> 8); + addr[1] = (bfd_byte )data; } void DEFUN(_do_putl16,(data, addr), - int data AND + int data AND register bfd_byte *addr) { - addr[0] = (bfd_byte )data; - addr[1] = (bfd_byte)(data >> 8); + addr[0] = (bfd_byte )data; + addr[1] = (bfd_byte)(data >> 8); } unsigned int DEFUN(_do_getb32,(addr), register bfd_byte *addr) { - return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3]; + return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3]; } unsigned int _do_getl32 (addr) - register bfd_byte *addr; + register bfd_byte *addr; { - return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0]; + return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0]; } bfd_64_type @@ -322,18 +378,20 @@ DEFUN(_do_getb64,(addr), bfd_64_type low, high; high= ((((((((addr[0]) << 8) | - addr[1]) << 8) | - addr[2]) << 8) | - addr[3]) ); + addr[1]) << 8) | + addr[2]) << 8) | + addr[3]) ); low = ((((((((addr[4]) << 8) | - addr[5]) << 8) | - addr[6]) << 8) | - addr[7])); + addr[5]) << 8) | + addr[6]) << 8) | + addr[7])); return high << 32 | low; #else + bfd_64_type foo; BFD_FAIL(); + return foo; #endif } @@ -342,22 +400,26 @@ bfd_64_type DEFUN(_do_getl64,(addr), register bfd_byte *addr) { - bfd_64_type low, high; + #ifdef HOST_64_BIT + bfd_64_type low, high; high= (((((((addr[7] << 8) | - addr[6]) << 8) | - addr[5]) << 8) | - addr[4])); + addr[6]) << 8) | + addr[5]) << 8) | + addr[4])); low = (((((((addr[3] << 8) | - addr[2]) << 8) | - addr[1]) << 8) | - addr[0]) ); + addr[2]) << 8) | + addr[1]) << 8) | + addr[0]) ); return high << 32 | low; #else +bfd_64_type foo; BFD_FAIL(); +return foo; #endif + } void @@ -365,10 +427,10 @@ DEFUN(_do_putb32,(data, addr), unsigned long data AND register bfd_byte *addr) { - addr[0] = (bfd_byte)(data >> 24); - addr[1] = (bfd_byte)(data >> 16); - addr[2] = (bfd_byte)(data >> 8); - addr[3] = (bfd_byte)data; + addr[0] = (bfd_byte)(data >> 24); + addr[1] = (bfd_byte)(data >> 16); + addr[2] = (bfd_byte)(data >> 8); + addr[3] = (bfd_byte)data; } void @@ -376,15 +438,15 @@ DEFUN(_do_putl32,(data, addr), unsigned long data AND register bfd_byte *addr) { - addr[0] = (bfd_byte)data; - addr[1] = (bfd_byte)(data >> 8); - addr[2] = (bfd_byte)(data >> 16); - addr[3] = (bfd_byte)(data >> 24); + addr[0] = (bfd_byte)data; + addr[1] = (bfd_byte)(data >> 8); + addr[2] = (bfd_byte)(data >> 16); + addr[3] = (bfd_byte)(data >> 24); } void DEFUN(_do_putb64,(data, addr), - bfd_64_type data AND - register bfd_byte *addr) + bfd_64_type data AND + register bfd_byte *addr) { #ifdef HOST_64_BIT addr[0] = (bfd_byte)(data >> (7*8)); @@ -433,10 +495,26 @@ DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count) bfd_size_type count) { if (count == 0) - return true; + return true; if ((bfd_size_type)offset >= section->size - || bfd_seek(abfd,(file_ptr)( section->filepos + offset), SEEK_SET) == -1 - || bfd_read(location, (bfd_size_type)1, count, abfd) != count) - return (false); /* on error */ + || bfd_seek(abfd,(file_ptr)( section->filepos + offset), SEEK_SET) == -1 + || bfd_read(location, (bfd_size_type)1, count, abfd) != count) + return (false); /* on error */ return (true); } + +/*proto-internal* +*i bfd_log2 +Return the log base 2 of the value supplied, rounded up. eg an arg +of 1025 would return 11. +*; PROTO(bfd_vma, bfd_log2,(bfd_vma x)); +*-*/ + +bfd_vma bfd_log2(x) +bfd_vma x; +{ + bfd_vma result = 0; + while ( (bfd_vma)(1<< result) < x) + result++; + return result; +} diff --git a/bfd/libbfd.h b/bfd/libbfd.h index bef46dd..795682b 100644 --- a/bfd/libbfd.h +++ b/bfd/libbfd.h @@ -65,14 +65,17 @@ PROTO (char *, zalloc, (bfd_size_type size)); PROTO(PTR, bfd_alloc, (bfd *abfd, bfd_size_type size)); PROTO(PTR, bfd_zalloc,(bfd *abfd, bfd_size_type size)); PROTO(PTR, bfd_realloc,(bfd *abfd, PTR orig, bfd_size_type new)); +PROTO(void, bfd_alloc_grow,(bfd *abfd, PTR thing, bfd_size_type size)); +PROTO(PTR, bfd_alloc_finish,(bfd *abfd)); + #define bfd_release(x,y) (void) obstack_free(&(x->memory),y) -PROTO (bfd_target *, bfd_find_target, (CONST char *target_name, bfd *)); + PROTO (bfd_size_type, bfd_read, (PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd)); PROTO (bfd_size_type, bfd_write, (PTR ptr, bfd_size_type size, bfd_size_type nitems, bfd *abfd)); -PROTO (FILE *, bfd_cache_lookup, (bfd *)); -PROTO (void, bfd_cache_close, (bfd *)); + + PROTO (int, bfd_seek,(bfd* abfd, file_ptr fp , int direction)); PROTO (long, bfd_tell, (bfd *abfd)); PROTO (bfd *, _bfd_create_empty_archive_element_shell, (bfd *obfd)); @@ -161,8 +164,6 @@ PROTO (void, bfd_assert,(char*,int)); PROTO (FILE *, bfd_cache_lookup_worker, (bfd *)); extern bfd *bfd_last_cache; -#define bfd_cache_lookup(x) \ - (x==bfd_last_cache?(FILE*)(bfd_last_cache->iostream):bfd_cache_lookup_worker(x)) /* Now Steve, what's the story here? */ #ifdef lint @@ -175,3 +176,51 @@ extern bfd *bfd_last_cache; /* Generic routine for close_and_cleanup is really just bfd_true. */ #define bfd_generic_close_and_cleanup bfd_true + +/* THE FOLLOWING IS EXTRACTED FROM THE SOURCE*/ + +/* Return the log base 2 of the value supplied, rounded up. eg an arg +of 1025 would return 11. +*/ +PROTO(bfd_vma, bfd_log2,(bfd_vma x)); +/* The maxiumum number of files which the cache will keep open at one +time. +*/ +#define BFD_CACHE_MAX_OPEN 10 + +/* Zero, or a pointer to the topmost bfd on the chain. This is used by the +bfd_cache_lookup() macro in libbfd.h to determine when it can avoid a function +call. +*/ +extern bfd *bfd_last_cache; + +/* Checks to see if the required bfd is the same as the last one looked +up. If so then it can use the iostream in the bfd with impunity, since +it can't have changed since the last lookup, otherwise it has to +perform the complicated lookup function +*/ +#define bfd_cache_lookup(x) \ + ((x)==bfd_last_cache? \ + (FILE*)(bfd_last_cache->iostream): \ + bfd_cache_lookup_worker(x)) + + +/* Initialize a BFD by putting it on the cache LRU. +*/ +PROTO(void, bfd_cache_init, (bfd *)); +/* Remove the bfd from the cache. If the attatched file is open, then close it too. +*/ +PROTO(void, bfd_cache_close, (bfd *)); +/* Call the OS to open a file for this BFD. Returns the FILE * +(possibly null) that results from this operation. Sets up the +BFD so that future accesses know the file is open. If the FILE * +returned is null, then there is won't have been put in the cache, so +it won't have to be removed from it. +*/ +PROTO(FILE *, bfd_open_file, (bfd *)); +/* Called when the macro @code{bfd_cache_lookup} fails to find a quick +answer. Finds a file descriptor for this BFD. If necessary, it open it. +If there are already more than BFD_CACHE_MAX_OPEN files open, it trys to close +one first, to avoid running out of file descriptors. +*/ +PROTO(FILE *, bfd_cache_lookup_worker, (bfd *)); diff --git a/bfd/newsos3.c b/bfd/newsos3.c index a14a91c..e16648f 100644 --- a/bfd/newsos3.c +++ b/bfd/newsos3.c @@ -31,16 +31,22 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "bfd.h" #include "libbfd.h" #include "aout64.h" + +/**From: bothner@cs.wisc.edu***********************************************/ +#undef N_TXTOFF +#define N_TXTOFF(x) ( (N_MAGIC((x)) == ZMAGIC) ? PAGE_SIZE : EXEC_BYTES_SIZE) +/**************************************************************************/ + #include "stab.gnu.h" #include "ar.h" #include "libaout.h" /* BFD a.out internal data structures */ - +#if 0 int vfprintf(file, format, args) /* Temporary crock! */ FILE *file; char *format; char *args; { return _doprnt (format, args, file); } - +#endif bfd_target *newsos3_callback (); @@ -49,7 +55,7 @@ bfd_target * DEFUN(newsos3_object_p,(abfd), bfd *abfd) { - unsigned char magicbuf[LONG_SIZE]; /* Raw bytes of magic number from file */ + unsigned char magicbuf[4]; /* Raw bytes of magic number from file */ unsigned long magic; /* Swapped magic number */ bfd_error = system_call_error; @@ -99,19 +105,40 @@ DEFUN(newsos3_write_object_contents,(abfd), /* Transfer vectors for NEWS-OS version 3 */ /* We use BFD generic archive files. */ -#define aout_32_openr_next_archived_file bfd_generic_openr_next_archived_file -#define aout_32_generic_stat_arch_elt bfd_generic_stat_arch_elt -#define aout_32_slurp_armap bfd_slurp_bsd_armap -#define aout_32_slurp_extended_name_table bfd_true -#define aout_32_write_armap bsd_write_armap -#define aout_32_truncate_arname bfd_bsd_truncate_arname +#define newsos_openr_next_archived_file bfd_generic_openr_next_archived_file +#define newsos_generic_stat_arch_elt bfd_generic_stat_arch_elt +#define newsos_slurp_armap bfd_slurp_bsd_armap +#define newsos_slurp_extended_name_table bfd_true +#define newsos_write_armap bsd_write_armap +#define newsos_truncate_arname bfd_bsd_truncate_arname /* We don't support core files yet. FIXME. */ -#define aout_32_core_file_failing_command _bfd_dummy_core_file_failing_command -#define aout_32_core_file_failing_signal _bfd_dummy_core_file_failing_signal -#define aout_32_core_file_matches_executable_p \ +#define newsos_core_file_failing_command _bfd_dummy_core_file_failing_command +#define newsos_core_file_failing_signal _bfd_dummy_core_file_failing_signal +#define newsos_core_file_matches_executable_p \ _bfd_dummy_core_file_matches_executable_p -#define aout_32_core_file_p _bfd_dummy_target +#define newsos_core_file_p _bfd_dummy_target + +#define newsos_bfd_debug_info_start bfd_void +#define newsos_bfd_debug_info_end bfd_void +#define newsos_bfd_debug_info_accumulate bfd_void + +#define newsos_mkobject aout_32_mkobject +#define newsos_close_and_cleanup aout_32_close_and_cleanup +#define newsos_set_section_contents aout_32_set_section_contents +#define newsos_get_section_contents aout_32_get_section_contents +#define newsos_new_section_hook aout_32_new_section_hook +#define newsos_get_symtab_upper_bound aout_32_get_symtab_upper_bound +#define newsos_get_symtab aout_32_get_symtab +#define newsos_get_reloc_upper_bound aout_32_get_reloc_upper_bound +#define newsos_canonicalize_reloc aout_32_canonicalize_reloc +#define newsos_make_empty_symbol aout_32_make_empty_symbol +#define newsos_print_symbol aout_32_print_symbol +#define newsos_get_lineno aout_32_get_lineno +#define newsos_set_arch_mach aout_32_set_arch_mach +#define newsos_find_nearest_line aout_32_find_nearest_line +#define newsos_sizeof_headers aout_32_sizeof_headers + /* We define our own versions of these routines. */ @@ -128,16 +155,16 @@ bfd_target newsos3_vec = /* Sony 68k-based machines running newos3 */ (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - + 1, /* minimum alignment */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ {_bfd_dummy_target, newsos3_object_p, /* bfd_check_format */ - bfd_generic_archive_p, aout_32_core_file_p}, - {bfd_false, aout_32_mkobject, /* bfd_set_format */ + bfd_generic_archive_p, newsos_core_file_p}, + {bfd_false, newsos_mkobject, /* bfd_set_format */ _bfd_generic_mkarchive, bfd_false}, {bfd_false, newsos3_write_object_contents, /* bfd_write_contents */ _bfd_write_archive_contents, bfd_false}, - JUMP_TABLE(aout_32) + JUMP_TABLE(newsos) }; diff --git a/bfd/oasys.c b/bfd/oasys.c index 4719273..196bb12 100644 --- a/bfd/oasys.c +++ b/bfd/oasys.c @@ -30,6 +30,11 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "libbfd.h" #include "oasys.h" #include "liboasys.h" + + +/* Read in all the section data and relocation stuff too */ +PROTO(static boolean,oasys_slurp_section_data,(bfd *CONST abfd)); + static void DEFUN(oasys_read_record,(abfd, record), bfd *CONST abfd AND @@ -127,6 +132,12 @@ DEFUN(oasys_slurp_symbol_table,(abfd), if (record.header.type == oasys_record_is_local_enum) { dest->flags = BSF_LOCAL; + if (dest->section ==(asection *)(~0)) { + /* It seems that sometimes internal symbols are tied up, but + still get output, even though there is no + section */ + dest->section = 0; + } } else { @@ -258,7 +269,7 @@ DEFUN(oasys_archive_p,(abfd), oasys_module_table_type record; - oasys_external_module_table_type record_ext; + set_tdata(abfd, ar); ar->module = module; @@ -268,25 +279,53 @@ DEFUN(oasys_archive_p,(abfd), filepos = header.mod_tbl_offset; for (i = 0; i < header.mod_count; i++) { bfd_seek(abfd , filepos, SEEK_SET); - bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd); + + /* There are two ways of specifying the archive header */ + + if (0) { + oasys_external_module_table_type_a_type record_ext; + bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd); - record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size); - record.file_offset = bfd_h_get_32(abfd, - record_ext.file_offset); + record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size); + record.file_offset = bfd_h_get_32(abfd, + record_ext.file_offset); + + record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count); + record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count); + record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count); - record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count); - record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count); - record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count); + module[i].name = bfd_alloc(abfd,33); - module[i].name = bfd_alloc(abfd,33); + memcpy(module[i].name, record_ext.mod_name, 33); + filepos += + sizeof(record_ext) + + record.dep_count * 4 + + record.depee_count * 4 + + record.sect_count * 8 + 187; + } + else { + oasys_external_module_table_type_b_type record_ext; + bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd); + + record.mod_size = bfd_h_get_32(abfd, record_ext.mod_size); + record.file_offset = bfd_h_get_32(abfd, + record_ext.file_offset); + + record.dep_count = bfd_h_get_32(abfd, record_ext.dep_count); + record.depee_count = bfd_h_get_32(abfd, record_ext.depee_count); + record.sect_count = bfd_h_get_32(abfd, record_ext.sect_count); + record.module_name_size = bfd_h_get_32(abfd, record_ext.mod_name_length); + + module[i].name = bfd_alloc(abfd,record.module_name_size + 1); + bfd_read((PTR)module[i].name, 1, record.module_name_size, abfd); + module[i].name[record.module_name_size] = 0; + filepos += + sizeof(record_ext) + + record.dep_count * 4 + + record.module_name_size + 1; - memcpy(module[i].name, record_ext.mod_name, 33); - filepos += - sizeof(record_ext) + - record.dep_count * 4 + - record.depee_count * 4 + - record.sect_count * 8 + 187, + } module[i].size = record.mod_size; @@ -375,7 +414,7 @@ DEFUN(oasys_object_p,(abfd), s->size = bfd_h_get_32(abfd, & record.section.value[0]) ; s->vma = bfd_h_get_32(abfd, &record.section.vma[0]); - s->flags |= SEC_LOAD | SEC_HAS_CONTENTS; + s->flags= 0; had_usefull = true; } break; @@ -402,6 +441,14 @@ DEFUN(oasys_object_p,(abfd), if (abfd->symcount != 0) { abfd->flags |= HAS_SYMS; } + + /* + We don't know if a section has data until we've read it.. + */ + + oasys_slurp_section_data(abfd); + + return abfd->xvec; fail: @@ -465,169 +512,185 @@ DEFUN(oasys_slurp_section_data,(abfd), asection *s; - /* Buy enough memory for all the section data and relocations */ + /* See if the data has been slurped already .. */ for (s = abfd->sections; s != (asection *)NULL; s= s->next) { per = oasys_per_section(s); - if (per->data != (bfd_byte*)NULL) return true; - per->data = (bfd_byte *) bfd_alloc(abfd, s->size); - per->reloc_tail_ptr = (oasys_reloc_type **)&(s->relocation); - per->had_vma = false; - s->reloc_count = 0; + if (per->initialized == true) + return true; } if (data->first_data_record == 0) return true; + bfd_seek(abfd, data->first_data_record, SEEK_SET); while (loop) { oasys_read_record(abfd, &record); - switch (record.header.type) { - case oasys_record_is_header_enum: - break; - case oasys_record_is_data_enum: + switch (record.header.type) { + case oasys_record_is_header_enum: + break; + case oasys_record_is_data_enum: + { + + uint8e_type *src = record.data.data; + uint8e_type *end_src = ((uint8e_type *)&record) + + record.header.length; + unsigned int relbit; + bfd_byte *dst_ptr ; + bfd_byte *dst_base_ptr ; + unsigned int count; + asection * section = + data->sections[record.data.relb & RELOCATION_SECT_BITS]; + bfd_vma dst_offset ; + per = oasys_per_section(section); + + + if (per->initialized == false) + { + per->data = (bfd_byte *) bfd_zalloc(abfd, section->size); + per->reloc_tail_ptr = (oasys_reloc_type **)&(section->relocation); + per->had_vma = false; + per->initialized = true; + section->reloc_count = 0; + section->flags = SEC_ALLOC; + } - uint8e_type *src = record.data.data; - uint8e_type *end_src = ((uint8e_type *)&record) + - record.header.length; - unsigned int relbit; - bfd_byte *dst_ptr ; - bfd_byte *dst_base_ptr ; - unsigned int count; - asection * section = - data->sections[record.data.relb & RELOCATION_SECT_BITS]; - bfd_vma dst_offset ; - per = oasys_per_section(section); - dst_offset = bfd_h_get_32(abfd, record.data.addr) ; - if (per->had_vma == false) { - /* Take the first vma we see as the base */ - - section->vma = dst_offset; - per->had_vma = true; - } + dst_offset = bfd_h_get_32(abfd, record.data.addr) ; + if (per->had_vma == false) { + /* Take the first vma we see as the base */ + section->vma = dst_offset; + per->had_vma = true; + } - dst_offset -= section->vma; - - - dst_base_ptr = oasys_per_section(section)->data; - dst_ptr = oasys_per_section(section)->data + - dst_offset; - - while (src < end_src) { - uint32_type gap = end_src - src -1; - uint8e_type mod_byte = *src++; - count = 8; - if (mod_byte == 0 && gap >= 8) { - dst_ptr[0] = src[0]; - dst_ptr[1] = src[1]; - dst_ptr[2] = src[2]; - dst_ptr[3] = src[3]; - dst_ptr[4] = src[4]; - dst_ptr[5] = src[5]; - dst_ptr[6] = src[6]; - dst_ptr[7] = src[7]; - dst_ptr+= 8; - src += 8; - } - else { - for (relbit = 1; count-- != 0 && gap != 0; gap --, relbit <<=1) - { - if (relbit & mod_byte) - { - uint8e_type reloc = *src; - /* This item needs to be relocated */ - switch (reloc & RELOCATION_TYPE_BITS) { - case RELOCATION_TYPE_ABS: - - break; - - case RELOCATION_TYPE_REL: - { - /* Relocate the item relative to the section */ - oasys_reloc_type *r = - (oasys_reloc_type *) - bfd_alloc(abfd, - sizeof(oasys_reloc_type)); - *(per->reloc_tail_ptr) = r; - per->reloc_tail_ptr = &r->next; - r->next= (oasys_reloc_type *)NULL; - /* Reference to undefined symbol */ - src++; - /* There is no symbol */ - r->symbol = 0; - /* Work out the howto */ - r->relent.section = - data->sections[reloc & RELOCATION_SECT_BITS]; - r->relent.addend = - r->relent.section->vma; - r->relent.address = dst_ptr - dst_base_ptr; - r->relent.howto = &howto_table[reloc>>6]; - r->relent.sym_ptr_ptr = (asymbol **)NULL; - section->reloc_count++; - - /* Fake up the data to look like it's got the -ve pc in it, this makes - it much easier to convert into other formats. This is done by - hitting the addend. - */ - if (r->relent.howto->pc_relative == true) { - r->relent.addend -= dst_ptr - dst_base_ptr; - } + dst_offset -= section->vma; - } - break; - - - case RELOCATION_TYPE_UND: - { - oasys_reloc_type *r = - (oasys_reloc_type *) - bfd_alloc(abfd, - sizeof(oasys_reloc_type)); - *(per->reloc_tail_ptr) = r; - per->reloc_tail_ptr = &r->next; - r->next= (oasys_reloc_type *)NULL; - /* Reference to undefined symbol */ - src++; - /* Get symbol number */ - r->symbol = (src[0]<<8) | src[1]; - /* Work out the howto */ - r->relent.section = (asection *)NULL; - r->relent.addend = 0; - r->relent.address = dst_ptr - dst_base_ptr; - r->relent.howto = &howto_table[reloc>>6]; - r->relent.sym_ptr_ptr = (asymbol **)NULL; - section->reloc_count++; - - src+=2; - /* Fake up the data to look like it's got the -ve pc in it, this makes - it much easier to convert into other formats. This is done by - hitting the addend. - */ - if (r->relent.howto->pc_relative == true) { - r->relent.addend -= dst_ptr - dst_base_ptr; - } + + dst_base_ptr = oasys_per_section(section)->data; + dst_ptr = oasys_per_section(section)->data + + dst_offset; + + if (src < end_src) { + section->flags |= SEC_LOAD | SEC_HAS_CONTENTS; + } + while (src < end_src) { + uint8e_type mod_byte = *src++; + uint32_type gap = end_src - src; + + count = 8; + if (mod_byte == 0 && gap >= 8) { + dst_ptr[0] = src[0]; + dst_ptr[1] = src[1]; + dst_ptr[2] = src[2]; + dst_ptr[3] = src[3]; + dst_ptr[4] = src[4]; + dst_ptr[5] = src[5]; + dst_ptr[6] = src[6]; + dst_ptr[7] = src[7]; + dst_ptr+= 8; + src += 8; + } + else { + for (relbit = 1; count-- != 0 && src < end_src; relbit <<=1) + { + if (relbit & mod_byte) + { + uint8e_type reloc = *src; + /* This item needs to be relocated */ + switch (reloc & RELOCATION_TYPE_BITS) { + case RELOCATION_TYPE_ABS: + + break; + + case RELOCATION_TYPE_REL: + { + /* Relocate the item relative to the section */ + oasys_reloc_type *r = + (oasys_reloc_type *) + bfd_alloc(abfd, + sizeof(oasys_reloc_type)); + *(per->reloc_tail_ptr) = r; + per->reloc_tail_ptr = &r->next; + r->next= (oasys_reloc_type *)NULL; + /* Reference to undefined symbol */ + src++; + /* There is no symbol */ + r->symbol = 0; + /* Work out the howto */ + r->relent.section = + data->sections[reloc & RELOCATION_SECT_BITS]; + r->relent.addend = - r->relent.section->vma; + r->relent.address = dst_ptr - dst_base_ptr; + r->relent.howto = &howto_table[reloc>>6]; + r->relent.sym_ptr_ptr = (asymbol **)NULL; + section->reloc_count++; + + /* Fake up the data to look like it's got the -ve pc in it, this makes + it much easier to convert into other formats. This is done by + hitting the addend. + */ + if (r->relent.howto->pc_relative == true) { + r->relent.addend -= dst_ptr - dst_base_ptr; + } + + + } + break; + + + case RELOCATION_TYPE_UND: + { + oasys_reloc_type *r = + (oasys_reloc_type *) + bfd_alloc(abfd, + sizeof(oasys_reloc_type)); + *(per->reloc_tail_ptr) = r; + per->reloc_tail_ptr = &r->next; + r->next= (oasys_reloc_type *)NULL; + /* Reference to undefined symbol */ + src++; + /* Get symbol number */ + r->symbol = (src[0]<<8) | src[1]; + /* Work out the howto */ + r->relent.section = (asection *)NULL; + r->relent.addend = 0; + r->relent.address = dst_ptr - dst_base_ptr; + r->relent.howto = &howto_table[reloc>>6]; + r->relent.sym_ptr_ptr = (asymbol **)NULL; + section->reloc_count++; + + src+=2; + /* Fake up the data to look like it's got the -ve pc in it, this makes + it much easier to convert into other formats. This is done by + hitting the addend. + */ + if (r->relent.howto->pc_relative == true) { + r->relent.addend -= dst_ptr - dst_base_ptr; + } + } + break; + case RELOCATION_TYPE_COM: + BFD_FAIL(); } - break; - case RELOCATION_TYPE_COM: - BFD_FAIL(); - } - } - *dst_ptr++ = *src++; - } + } + *dst_ptr++ = *src++; + } + } + } } - } + break; + case oasys_record_is_local_enum: + case oasys_record_is_symbol_enum: + case oasys_record_is_section_enum: + break; + default: + loop = false; } - break; - case oasys_record_is_local_enum: - case oasys_record_is_symbol_enum: - case oasys_record_is_section_enum: - break; - default: - loop = false; - } } + return true; } @@ -646,7 +709,8 @@ DEFUN(oasys_new_section_hook,(abfd, newsect), oasys_per_section( newsect)->data = (bfd_byte *)NULL; oasys_per_section(newsect)->section = newsect; oasys_per_section(newsect)->offset = 0; - newsect->alignment_power = 3; + oasys_per_section(newsect)->initialized = false; + newsect->alignment_power = 1; /* Turn the section string into an index */ sscanf(newsect->name,"%u", &newsect->target_index); @@ -674,7 +738,14 @@ DEFUN(oasys_get_section_contents,(abfd, section, location, offset, count), { oasys_per_section_type *p = (oasys_per_section_type *) section->used_by_bfd; oasys_slurp_section_data(abfd); - (void) memcpy(location, p->data + offset, (int)count); + if (p->initialized == false) + { + (void) memset(location, 0, (int)count); + } + else + { + (void) memcpy(location, p->data + offset, (int)count); + } return true; } @@ -781,7 +852,15 @@ DEFUN(oasys_write_syms, (abfd), continue; } else { - symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index; + if (g->section == (asection *)NULL) { + /* Sometime, the oasys tools give out a symbol with illegal + bits in it, we'll output it in the same broken way */ + + symbol.relb = RELOCATION_TYPE_REL | 0; + } + else { + symbol.relb = RELOCATION_TYPE_REL |g->section->output_section->target_index; + } bfd_h_put_16(abfd, 0, (uint8e_type *)(&symbol.refno[0])); } while (src[l]) { @@ -900,140 +979,142 @@ DEFUN(oasys_write_data, (abfd), { asection *s; for (s = abfd->sections; s != (asection *)NULL; s = s->next) { - uint8e_type *raw_data = oasys_per_section(s)->data; - oasys_data_record_type processed_data; - bfd_size_type current_byte_index = 0; - unsigned int relocs_to_go = s->reloc_count; - arelent **p = s->orelocation; - if (s->reloc_count != 0) { - /* Sort the reloc records so it's easy to insert the relocs into the - data */ + if (s->flags & SEC_LOAD) { + uint8e_type *raw_data = oasys_per_section(s)->data; + oasys_data_record_type processed_data; + bfd_size_type current_byte_index = 0; + unsigned int relocs_to_go = s->reloc_count; + arelent **p = s->orelocation; + if (s->reloc_count != 0) { + /* Sort the reloc records so it's easy to insert the relocs into the + data */ - qsort(s->orelocation, - s->reloc_count, - sizeof(arelent **), - comp); - } - current_byte_index = 0; - processed_data.relb = s->target_index | RELOCATION_TYPE_REL; + qsort(s->orelocation, + s->reloc_count, + sizeof(arelent **), + comp); + } + current_byte_index = 0; + processed_data.relb = s->target_index | RELOCATION_TYPE_REL; - while (current_byte_index < s->size) - { - /* Scan forwards by eight bytes or however much is left and see if - there are any relocations going on */ - uint8e_type *mod = &processed_data.data[0]; - uint8e_type *dst = &processed_data.data[1]; + while (current_byte_index < s->size) + { + /* Scan forwards by eight bytes or however much is left and see if + there are any relocations going on */ + uint8e_type *mod = &processed_data.data[0]; + uint8e_type *dst = &processed_data.data[1]; - unsigned int i; - unsigned int long_length = 128; + unsigned int i; + unsigned int long_length = 128; - bfd_h_put_32(abfd, s->vma + current_byte_index, processed_data.addr); - if ((size_t)(long_length + current_byte_index) > (size_t)(s->size)) { - long_length = s->size - current_byte_index; - } - while (long_length > 0 && (dst - (uint8e_type*)&processed_data < 128)) { + bfd_h_put_32(abfd, s->vma + current_byte_index, processed_data.addr); + if ((size_t)(long_length + current_byte_index) > (size_t)(s->size)) { + long_length = s->size - current_byte_index; + } + while (long_length > 0 && (dst - (uint8e_type*)&processed_data < 128)) { - unsigned int length = long_length; - *mod =0; - if (length > 8) - length = 8; - - for (i = 0; i < length; i++) { - if (relocs_to_go != 0) { - arelent *r = *p; - reloc_howto_type *CONST how=r->howto; - /* There is a relocation, is it for this byte ? */ - if (r->address == current_byte_index) { - uint8e_type rel_byte; - p++; - relocs_to_go--; - - *mod |= (1<<i); - if(how->pc_relative) { - rel_byte = 0x80; - - /* Also patch the raw data so that it doesn't have - the -ve stuff any more */ - if (how->size != 2) { - bfd_put_16(abfd, + unsigned int length = long_length; + *mod =0; + if (length > 8) + length = 8; + + for (i = 0; i < length; i++) { + if (relocs_to_go != 0) { + arelent *r = *p; + reloc_howto_type *CONST how=r->howto; + /* There is a relocation, is it for this byte ? */ + if (r->address == current_byte_index) { + uint8e_type rel_byte; + p++; + relocs_to_go--; + + *mod |= (1<<i); + if(how->pc_relative) { + rel_byte = 0x80; + + /* Also patch the raw data so that it doesn't have + the -ve stuff any more */ + if (how->size != 2) { + bfd_put_16(abfd, bfd_get_16(abfd,raw_data) + current_byte_index, raw_data); - } + } + else { + bfd_put_32(abfd, + bfd_get_32(abfd,raw_data) + + current_byte_index, raw_data); + } + } else { - bfd_put_32(abfd, - bfd_get_32(abfd,raw_data) + - current_byte_index, raw_data); + rel_byte = 0; + } + if (how->size ==2) { + rel_byte |= 0x40; } - } - else { - rel_byte = 0; - } - if (how->size ==2) { - rel_byte |= 0x40; - } - /* Is this a section relative relocation, or a symbol - relative relocation ? */ - if (r->section != (asection*)NULL) - { - /* The relent has a section attatched, so it must be section - relative */ - rel_byte |= RELOCATION_TYPE_REL; - rel_byte |= r->section->output_section->target_index; - *dst++ = rel_byte; - } - else - { - asymbol *p = *(r->sym_ptr_ptr); - - /* If this symbol has a section attatched, then it - has already been resolved. Change from a symbol - ref to a section ref */ - if(p->section != (asection *)NULL) { + /* Is this a section relative relocation, or a symbol + relative relocation ? */ + if (r->section != (asection*)NULL) + { + /* The relent has a section attatched, so it must be section + relative */ rel_byte |= RELOCATION_TYPE_REL; - rel_byte |= - p->section->output_section->target_index; + rel_byte |= r->section->output_section->target_index; *dst++ = rel_byte; } - else { - rel_byte |= RELOCATION_TYPE_UND; + else + { + asymbol *p = *(r->sym_ptr_ptr); + + /* If this symbol has a section attatched, then it + has already been resolved. Change from a symbol + ref to a section ref */ + if(p->section != (asection *)NULL) { + rel_byte |= RELOCATION_TYPE_REL; + rel_byte |= + p->section->output_section->target_index; + *dst++ = rel_byte; + } + else { + rel_byte |= RELOCATION_TYPE_UND; - *dst++ = rel_byte; - /* Next two bytes are a symbol index - we can get - this from the symbol value which has been zapped - into the symbol index in the table when the - symbol table was written - */ - *dst++ = p->value >> 8; - *dst++ = p->value; - } + *dst++ = rel_byte; + /* Next two bytes are a symbol index - we can get + this from the symbol value which has been zapped + into the symbol index in the table when the + symbol table was written + */ + *dst++ = p->value >> 8; + *dst++ = p->value; + } - } + } + } } + /* If this is coming from an unloadable section then copy + zeros */ + if (raw_data == (uint8e_type *)NULL) { + *dst++ = 0; + } + else { + *dst++ = *raw_data++; + } + current_byte_index++; } - /* If this is coming from an unloadable section then copy - zeros */ - if (raw_data == (uint8e_type *)NULL) { - *dst++ = 0; - } - else { - *dst++ = *raw_data++; - } - current_byte_index++; + mod = dst++; + long_length -= length; } - mod = dst++; - long_length -= length; - } - oasys_write_record(abfd, - oasys_record_is_data_enum, - (oasys_record_union_type *)&processed_data, - dst - (uint8e_type*)&processed_data); + oasys_write_record(abfd, + oasys_record_is_data_enum, + (oasys_record_union_type *)&processed_data, + dst - (uint8e_type*)&processed_data); - } + } + } } } static boolean @@ -1180,17 +1261,20 @@ DEFUN(oasys_sizeof_headers,(abfd, exec), { return 0; } - +#define FOO PROTO #define oasys_core_file_failing_command (char *(*)())(bfd_nullvoidptr) #define oasys_core_file_failing_signal (int (*)())bfd_0 -#define oasys_core_file_matches_executable_p 0 /*(PROTO(boolean, (*),(bfd*, bfd*)))bfd_false*/ +#define oasys_core_file_matches_executable_p 0 #define oasys_slurp_armap bfd_true #define oasys_slurp_extended_name_table bfd_true #define oasys_truncate_arname (void (*)())bfd_nullvoidptr -#define oasys_write_armap 0 /* (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr*/ +#define oasys_write_armap 0 #define oasys_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr #define oasys_close_and_cleanup bfd_generic_close_and_cleanup +#define oasys_bfd_debug_info_start bfd_void +#define oasys_bfd_debug_info_end bfd_void +#define oasys_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *)))bfd_void /*SUPPRESS 460 */ @@ -1207,7 +1291,7 @@ bfd_target oasys_vec = |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - + 1, /* minimum alignment */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ diff --git a/bfd/opncls.c b/bfd/opncls.c index 84c6651..2601ef0 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -96,8 +96,19 @@ bfd *obfd; return nbfd; } -/** bfd_openr, bfd_fdopenr -- open for reading. - Returns a pointer to a freshly-allocated bfd on success, or NULL. */ +/*doc* +@section Opening and Closing BFDs + +*/ +/*proto* +*i bfd_openr +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 * DEFUN(bfd_openr, (filename, target), @@ -139,6 +150,15 @@ DEFUN(bfd_openr, (filename, target), close it if anything goes wrong. Closing the stream means closing the file descriptor too, even though we didn't open it. */ +/*proto* +*i bfd_fdopenr +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)); +*-*/ bfd * DEFUN(bfd_fdopenr,(filename, target, fd), @@ -155,7 +175,7 @@ DEFUN(bfd_fdopenr,(filename, target, fd), bfd_error = system_call_error; - fdflags = fcntl (fd, F_GETFL); + fdflags = fcntl (fd, F_GETFL, NULL); if (fdflags == -1) return NULL; #ifdef BFD_LOCKS @@ -214,6 +234,14 @@ DEFUN(bfd_fdopenr,(filename, target, fd), See comment by bfd_fdopenr before you try to modify this function. */ +/*proto* bfd_openw +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)); +*/ + bfd * DEFUN(bfd_openw,(filename, target), CONST char *filename AND @@ -246,11 +274,22 @@ DEFUN(bfd_openw,(filename, target), } return nbfd; } - -/* Close up shop, get your deposit back. */ + +/*proto* bfd_close +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 *)); +*/ + boolean -bfd_close (abfd) - bfd *abfd; +DEFUN(bfd_close,(abfd), + bfd *abfd) { if (!bfd_read_p(abfd)) if (BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)) != true) @@ -283,12 +322,18 @@ bfd_close (abfd) return true; } -/* Create a bfd with no associated file or target. */ +/*proto* bfd_create +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)); +*/ bfd * DEFUN(bfd_create,(filename, template), CONST char *filename AND - CONST bfd *template) + bfd *template) { bfd *nbfd = new_bfd(); if (nbfd == (bfd *)NULL) { @@ -313,6 +358,20 @@ DEFUN(PTR bfd_alloc_by_size_t,(abfd, size), PTR res = obstack_alloc(&(abfd->memory), size); return res; } + +DEFUN(void bfd_alloc_grow,(abfd, ptr, size), + bfd *abfd AND + PTR ptr AND + bfd_size_type size) +{ + obstack_grow(&(abfd->memory), ptr, size); +} +DEFUN(PTR bfd_alloc_finish,(abfd), + bfd *abfd) +{ + return obstack_finish(&(abfd->memory)); +} + DEFUN(PTR bfd_alloc, (abfd, size), bfd *abfd AND bfd_size_type size) @@ -339,8 +398,14 @@ DEFUN(PTR bfd_realloc,(abfd, old, size), return res; } +/*proto* bfd_alloc_size +Return the number of bytes in the obstacks connected to the supplied +bfd. +*; PROTO(bfd_size_type,bfd_alloc_size,(bfd *abfd)); +*/ -DEFUN(bfd_size_type bfd_alloc_size,(abfd), +bfd_size_type +DEFUN( bfd_alloc_size,(abfd), bfd *abfd) { struct _obstack_chunk *chunk = abfd->memory.chunk; @@ -187,7 +187,7 @@ asection *section; + (HEX(buffer.u.type_3.address+1) << 16) + (HEX(buffer.u.type_3.address+2) << 8) + (HEX(buffer.u.type_3.address+3)); - func(abfd,section, address, buffer.u.type_2.data, bytes_on_line -1); + func(abfd,section, address, buffer.u.type_3.data, bytes_on_line -1); break; @@ -320,7 +320,7 @@ int bytes_to_do; check_sum += TOHEX(buffer.u.type_3.address+3, address >> 0); size = bytes_this_chunk + 5; data = buffer.u.type_3.data; - + break; case 2: check_sum = TOHEX(buffer.u.type_3.address, address >> 16); check_sum += TOHEX(buffer.u.type_3.address+1, address >> 8); @@ -334,6 +334,7 @@ int bytes_to_do; check_sum += TOHEX(buffer.u.type_3.address+1, address >> 0); size = bytes_this_chunk + 3; data = buffer.u.type_1.data; + break; } for (i = 0; i < bytes_this_chunk; i++) { @@ -380,31 +381,32 @@ DEFUN(srec_make_empty_symbol, (abfd), new->the_bfd = abfd; return new; } -/*SUPPRESS 460 */ - -#define srec_new_section_hook (PROTO(boolean, (*), (bfd *, asection *)))bfd_true +#define FOO PROTO +#define srec_new_section_hook (FOO(boolean, (*), (bfd *, asection *)))bfd_true #define srec_get_symtab_upper_bound bfd_false -#define srec_get_symtab (PROTO(unsigned int, (*), (bfd *, asymbol **)))bfd_0 -#define srec_get_reloc_upper_bound (PROTO(unsigned int, (*),(bfd*, asection *)))bfd_false -#define srec_canonicalize_reloc (PROTO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0 +#define srec_get_symtab (FOO(unsigned int, (*), (bfd *, asymbol **)))bfd_0 +#define srec_get_reloc_upper_bound (FOO(unsigned int, (*),(bfd*, asection *)))bfd_false +#define srec_canonicalize_reloc (FOO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0 -#define srec_print_symbol (PROTO(void,(*),(bfd *, PTR, asymbol *, bfd_print_symbol_enum_type))) bfd_void +#define srec_print_symbol (FOO(void,(*),(bfd *, PTR, asymbol *, bfd_print_symbol_enum_type))) bfd_void -#define srec_openr_next_archived_file (PROTO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr -#define srec_find_nearest_line (PROTO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false -#define srec_generic_stat_arch_elt (PROTO(int, (*), (bfd *,struct stat *))) bfd_0 +#define srec_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr +#define srec_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false +#define srec_generic_stat_arch_elt (FOO(int, (*), (bfd *,struct stat *))) bfd_0 #define srec_core_file_failing_command (char *(*)())(bfd_nullvoidptr) #define srec_core_file_failing_signal (int (*)())bfd_0 -#define srec_core_file_matches_executable_p (PROTO(boolean, (*),(bfd*, bfd*)))bfd_false +#define srec_core_file_matches_executable_p (FOO(boolean, (*),(bfd*, bfd*)))bfd_false #define srec_slurp_armap bfd_true #define srec_slurp_extended_name_table bfd_true #define srec_truncate_arname (void (*)())bfd_nullvoidptr -#define srec_write_armap (PROTO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr +#define srec_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, int, int))) bfd_nullvoidptr #define srec_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr - #define srec_close_and_cleanup bfd_generic_close_and_cleanup +#define srec_bfd_debug_info_start bfd_void +#define srec_bfd_debug_info_end bfd_void +#define srec_bfd_debug_info_accumulate (FOO(void, (*), (bfd *, asection *))) bfd_void bfd_target srec_vec = @@ -420,6 +422,7 @@ bfd_target srec_vec = |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ + 1, /* minimum alignment */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */ _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ diff --git a/bfd/targets.c b/bfd/targets.c index 22cda5c..4a0236e 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -19,13 +19,262 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ */ -/* This -*- C -*- source file will someday be machine-generated */ - -/*** Defines the target vector through which operations dispatch */ #include <sysdep.h> #include "bfd.h" #include "libbfd.h" +/*doc* +@section Targets +Each port of BFD to a different machine requries the creation of a +target back end. All the back end provides to the root part of bfd is +a structure containing pointers to functions which perform certain low +level operations on files. BFD translates the applications's requests +through a pointer into calls to the back end routines. + +When a file is opened with @code{bfd_openr}, its format and target are +unknown. BFD uses various mechanisms to determine how to interpret the +file. The operatios performed are: +@itemize @bullet +@item +First a bfd is created by calling the internal routine +@code{new_bfd}, then @code{bfd_find_target} is called with the target +string supplied to @code{bfd_openr} and the new bfd pointer. +@item +If a null target string was provided to +@code{bfd_find_target}, it looks up the environment variable +@code{GNUTARGET} and uses that as the target string. +@item +If the target string is still NULL, or the target string +is @code{default}, then the first item in the target vector is used as +the target type. @xref{targets}. +@item +Otherwise, the elements in the target vector are +inspected one by one, until a match on target name is found. When +found, that is used. +@item +Otherwise the error @code{invalid_target} is returned to +@code{bfd_openr}. +@item +@code{bfd_openr} attempts to open the file using +@code{bfd_open_file}, and returns the bfd. +@end itemize +Once the bfd has been opened and the target selected, the file format +may be determined. This is done by calling @code{bfd_check_format} on +the bfd with a suggested format. The routine returns @code{true} when +the application guesses right. +*/ + + +/*proto* bfd_target +@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) + +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. + +FIXME, these names should be rationalised with the names of the +entry points which call them. Too bad we can't have one macro to +define them both! + +*+++ + +$typedef struct bfd_target +${ + +identifies the kind of target, eg SunOS4, Ultrix, etc + +$ char *name; + +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. + +$ 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 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 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_64_type, bfd_getx64, (bfd_byte *)); +$ SDEF (void, bfd_putx64, (bfd_64_type, bfd_byte *)); +$ SDEF (unsigned int, bfd_getx32, (bfd_byte *)); +$ SDEF (void, bfd_putx32, (unsigned long, bfd_byte *)); +$ SDEF (unsigned int, bfd_getx16, (bfd_byte *)); +$ SDEF (void, bfd_putx16, (int, bfd_byte *)); + +Byte swapping for the headers + +$ SDEF (bfd_64_type, bfd_h_getx64, (bfd_byte *)); +$ SDEF (void, bfd_h_putx64, (bfd_64_type, bfd_byte *)); +$ SDEF (unsigned int, bfd_h_getx32, (bfd_byte *)); +$ SDEF (void, bfd_h_putx32, (unsigned long, bfd_byte *)); +$ SDEF (unsigned int, bfd_h_getx16, (bfd_byte *)); +$ SDEF (void, bfd_h_putx16, (int, 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, +$ unsigned int elength, +$ struct orl *map, +$ int orl_count, +$ int stridx)); + +Standard stuff. + +$ SDEF (boolean, _close_and_cleanup, (bfd *)); +$ SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR, +$ file_ptr, bfd_size_type)); +$ SDEF (boolean, _bfd_get_section_contents, (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)); +$#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)); +$ +$} bfd_target; + +*--- + +*/ extern bfd_target ecoff_little_vec; extern bfd_target ecoff_big_vec; extern bfd_target sunos_big_vec; @@ -46,93 +295,93 @@ extern bfd_target DEFAULT_VECTOR; #endif #ifdef GNU960 -#define ICOFF_LITTLE_VEC icoff_little_vec -#define ICOFF_BIG_VEC icoff_big_vec -#define B_OUT_VEC_LITTLE_HOST b_out_vec_little_host -#define B_OUT_VEC_BIG_HOST b_out_vec_big_host +#define ICOFF_LITTLE_VEC icoff_little_vec +#define ICOFF_BIG_VEC icoff_big_vec +#define B_OUT_VEC_LITTLE_HOST b_out_vec_little_host +#define B_OUT_VEC_BIG_HOST b_out_vec_big_host #endif /* GNU960 */ #ifndef RESTRICTED -#define ECOFF_LITTLE_VEC ecoff_little_vec -#define ECOFF_BIG_VEC ecoff_big_vec -#define ICOFF_LITTLE_VEC icoff_little_vec -#define ICOFF_BIG_VEC icoff_big_vec -#define XB_OUT_VEC_LITTLE_HOST b_out_vec_little_host -#define XB_OUT_VEC_BIG_HOST b_out_vec_big_host -#define SUNOS_VEC_BIG_HOST sunos_big_vec -#define DEMO_64_VEC demo_64_vec -#define OASYS_VEC oasys_vec -#define IEEE_VEC ieee_vec -#define M88K_BCS_VEC m88k_bcs_vec -#define SREC_VEC srec_vec -#define M68KCOFF_VEC m68kcoff_vec -#define I386COFF_VEC i386coff_vec +#define ECOFF_LITTLE_VEC ecoff_little_vec +#define ECOFF_BIG_VEC ecoff_big_vec +#define ICOFF_LITTLE_VEC icoff_little_vec +#define ICOFF_BIG_VEC icoff_big_vec +#define ZB_OUT_VEC_LITTLE_HOST b_out_vec_little_host +#define ZB_OUT_VEC_BIG_HOST b_out_vec_big_host +#define SUNOS_VEC_BIG_HOST sunos_big_vec +#define DEMO_64_VEC demo_64_vec +#define OASYS_VEC oasys_vec +#define IEEE_VEC ieee_vec +#define M88K_BCS_VEC m88k_bcs_vec +#define SREC_VEC srec_vec +#define M68KCOFF_VEC m68kcoff_vec +#define I386COFF_VEC i386coff_vec #endif bfd_target *target_vector[] = { #ifdef DEFAULT_VECTOR - &DEFAULT_VECTOR, + &DEFAULT_VECTOR, #endif /* DEFAULT_VECTOR */ -#ifdef I386COFF_VEC - &I386COFF_VEC, -#endif /* I386COFF_VEC */ +#ifdef I386COFF_VEC + &I386COFF_VEC, +#endif /* I386COFF_VEC */ #ifdef ECOFF_LITTLE_VEC - &ECOFF_LITTLE_VEC, + &ECOFF_LITTLE_VEC, #endif #ifdef ECOFF_BIG_VEC - &ECOFF_BIG_VEC, + &ECOFF_BIG_VEC, #endif #ifdef IEEE_VEC - &IEEE_VEC, + &IEEE_VEC, #endif /* IEEE_VEC */ #ifdef OASYS_VEC - &OASYS_VEC, + &OASYS_VEC, #endif /* OASYS_VEC */ #ifdef SUNOS_VEC_BIG_HOST - &SUNOS_VEC_BIG_HOST, + &SUNOS_VEC_BIG_HOST, #endif /* SUNOS_BIG_VEC */ #ifdef HOST_64_BIT #ifdef DEMO_64_VEC - &DEMO_64_VEC, + &DEMO_64_VEC, #endif #endif #ifdef M88K_BCS_VEC - &M88K_BCS_VEC, + &M88K_BCS_VEC, #endif /* M88K_BCS_VEC */ #ifdef SREC_VEC - &SREC_VEC, + &SREC_VEC, #endif /* SREC_VEC */ - + #ifdef ICOFF_LITTLE_VEC - &ICOFF_LITTLE_VEC, + &ICOFF_LITTLE_VEC, #endif /* ICOFF_LITTLE_VEC */ #ifdef ICOFF_BIG_VEC - &ICOFF_BIG_VEC, + &ICOFF_BIG_VEC, #endif /* ICOFF_BIG_VEC */ #ifdef B_OUT_VEC_LITTLE_HOST - &B_OUT_VEC_LITTLE_HOST, + &B_OUT_VEC_LITTLE_HOST, #endif /* B_OUT_VEC_LITTLE_HOST */ #ifdef B_OUT_VEC_BIG_HOST - &B_OUT_VEC_BIG_HOST, + &B_OUT_VEC_BIG_HOST, #endif /* B_OUT_VEC_BIG_HOST */ -#ifdef M68KCOFF_VEC - &M68KCOFF_VEC, -#endif /* M68KCOFF_VEC */ +#ifdef M68KCOFF_VEC + &M68KCOFF_VEC, +#endif /* M68KCOFF_VEC */ - NULL, /* end of list marker */ + NULL, /* end of list marker */ }; @@ -141,7 +390,85 @@ bfd_target *target_vector[] = { bfd_target *default_vector[] = { #ifdef DEFAULT_VECTOR - &DEFAULT_VECTOR, + &DEFAULT_VECTOR, #endif - 0, + 0, }; + + + + +/*proto* +*i bfd_find_target +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 *)); +*-*/ + +bfd_target * +DEFUN(bfd_find_target,(target_name, abfd), + CONST char *target_name AND + bfd *abfd) +{ + bfd_target **target; + extern char *getenv (); + CONST char *targname = (target_name ? target_name : getenv ("GNUTARGET")); + + /* This is safe; the vector cannot be null */ + if (targname == NULL || !strcmp (targname, "default")) { + abfd->target_defaulted = true; + return abfd->xvec = target_vector[0]; + } + + abfd->target_defaulted = false; + + for (target = &target_vector[0]; *target != NULL; target++) { + if (!strcmp (targname, (*target)->name)) + return abfd->xvec = *target; + } + + bfd_error = invalid_target; + return NULL; +} + + +/*proto* +*i bfd_target_list +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,()); + +*-*/ + +CONST char ** +DEFUN_VOID(bfd_target_list) +{ + int vec_length= 0; + bfd_target **target; +CONST char **name_list, **name_ptr; + + for (target = &target_vector[0]; *target != NULL; target++) + vec_length++; + + name_ptr = + name_list = (CONST char **) zalloc ((vec_length + 1) * sizeof (char **)); + + if (name_list == NULL) { + bfd_error = no_memory; + return NULL; + } + + + + for (target = &target_vector[0]; *target != NULL; target++) + *(name_ptr++) = (*target)->name; + + return name_list; +} |