diff options
| -rw-r--r-- | bfd/ChangeLog | 48 | ||||
| -rwxr-xr-x | bfd/aout.c | 3 | ||||
| -rw-r--r-- | bfd/aoutf1.h | 490 | ||||
| -rw-r--r-- | bfd/aoutx.h | 1484 | ||||
| -rw-r--r-- | bfd/archive.c | 12 | ||||
| -rw-r--r-- | bfd/bfd.c | 103 | ||||
| -rw-r--r-- | bfd/bout.c | 754 | ||||
| -rw-r--r-- | bfd/coff-i960.c | 4 | ||||
| -rw-r--r-- | bfd/coff-mips.c | 7 | ||||
| -rw-r--r-- | bfd/host-aout.c | 2 | ||||
| -rw-r--r-- | bfd/ieee.c | 35 | ||||
| -rw-r--r-- | bfd/libbfd.c | 172 | ||||
| -rw-r--r-- | bfd/libbfd.h | 23 | ||||
| -rw-r--r-- | bfd/newsos3.c | 162 | ||||
| -rw-r--r-- | bfd/oasys.c | 108 | ||||
| -rw-r--r-- | bfd/opncls.c | 24 | ||||
| -rw-r--r-- | bfd/srec.c | 116 | ||||
| -rw-r--r-- | bfd/targets.c | 15 | ||||
| -rw-r--r-- | bfd/trad-core.c | 9 | ||||
| -rw-r--r-- | binutils/copy.c | 2 | ||||
| -rw-r--r-- | include/bfd.h | 36 | ||||
| -rwxr-xr-x | ld/config/hmake-sun4-64 | 4 |
22 files changed, 3210 insertions, 403 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 50bea85..506122f 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,51 @@ +Mon May 20 17:12:17 1991 Steve Chamberlain (steve at cygint.cygnus.com) + + * everything: Removed sysdep.h from bfd.h and put back into files + from which it was split out. Now 64 bit version is built with a + -DHOST_64_BIT="long long" on the compile line. + + +Fri May 17 19:35:26 1991 Steve Chamberlain (steve at cygint.cygnus.com) + + Changed all the [get|put][name] routines to use [get|put]_[size + in bytes]. + + Put in support for 64 bit work. Now two versions of bfd may be + generated, according to the state of TARGET_64_BIT, one which is + 32 bit only, and one which is 64/32 bits. + Created new back end 'demo64' to test 64 bit functionality. + + Renamed some files to work on DOS. + + * archive.c: lint * bfd.c: prototypes and lint. * ecoff.c: added + 64bit transfer * icoff.c: added 64bit transfer * ieee.c: name + chage, 64 bit transfer. * liba.out.h: Split out common code from + sunos and newsos into liba.out. Name changes and prototype mods. * + libbfd.c: lint and prototypes, extra 64bit swaps. * libbfd.h: + prototypes for new functions. * libcoff.h: lint * libieee.h: make + work on DOS * liboasys.h: make work on DOS * m88k-bcs.c: Name + change and 64bit stuff.* newsos3.c: common code removed, new jump + table. * oasys.c: Name change * opncls.c: Portability fixes * + srec.c: Name changes * sunos.c: Removed comon code. * targets.c: + Added demo * aout32, aout64.c include aoutx.h * bout.c: used to + be called b.out.c * coffcode.h: used to be called coff-code.h, now + 64bit ized. * demo64.c: 64 bit a.out back end + + + + + +Thu May 16 16:02:07 1991 Steve Chamberlain (steve at cygint.cygnus.com) + from bothner + * libieee.h: Make ieee_data and ieee_ar_data macros usable + on LHS of assignment, even when using old compilers. + * liboasys.h: Ditto for oasys_data and oasys_ar_data. + * m68kcoff.c: Add enum-to-int casts to accomodate old compilers. + * newsos3.c: Fix definitions of SEGMENT_SIZE and TEXT_START_ADDR. + * opncls.c: Define S_IXUSR, S_IXGRP, S_IXOTH if undefined. + * targets.c: Add declaration of newsos3_vec. + + Mon May 13 10:03:29 1991 Steve Chamberlain (steve at cygint.cygnus.com) * aout.c: fixxed some of the problems with filepos calculation. @@ -18,8 +18,9 @@ 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" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" diff --git a/bfd/aoutf1.h b/bfd/aoutf1.h new file mode 100644 index 0000000..197d7c7 --- /dev/null +++ b/bfd/aoutf1.h @@ -0,0 +1,490 @@ +/* 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. + +BFD is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +BFD is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with BFD; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <ansidecl.h> +#include <sysdep.h> +struct external_exec; +#include <a.out.sun4.h> +#include "bfd.h" +#include "liba.out.h" +#include "libbfd.h" + + + +#include "aout64.h" +#include "stab.gnu.h" +#include "ar.h" + + + +void (*bfd_error_trap)(); + +static bfd_target *sunos4_callback (); + +/*SUPPRESS558*/ +/*SUPPRESS529*/ + +bfd_target * +DEFUN(NAME(sunos,object_p), (abfd), + bfd *abfd) +{ + unsigned char magicbuf[4]; /* Raw bytes of magic number from file */ + unsigned long magic; /* Swapped magic number */ + + bfd_error = system_call_error; + + if (bfd_read ((PTR)magicbuf, 1 , 4, abfd) != + sizeof (magicbuf)) + return 0; + magic = bfd_h_get_32 (abfd, magicbuf); + + if (N_BADMAG (*((struct internal_exec *) &magic))) return 0; + + return NAME(aout,some_aout_object_p) (abfd, sunos4_callback); +} + + /* Determine the size of a relocation entry, based on the architecture */ +static void +DEFUN(choose_reloc_size,(abfd), +bfd *abfd) + { + switch (abfd->obj_arch) { + case bfd_arch_sparc: + case bfd_arch_a29k: + obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; + break; + default: + obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; + break; + } + } + +/* Set parameters about this a.out file that are machine-dependent. + This routine is called from some_aout_object_p just before it returns. */ + +static bfd_target * +sunos4_callback (abfd) + bfd *abfd; +{ + struct internal_exec *execp = exec_hdr (abfd); + + WORK_OUT_FILE_POSITIONS(abfd, execp); + /* Determine the architecture and machine type of the object file. */ + switch (N_MACHTYPE (*exec_hdr (abfd))) { + + case M_UNKNOWN: + abfd->obj_arch = bfd_arch_unknown; + abfd->obj_machine = 0; + break; + + case M_68010: + abfd->obj_arch = bfd_arch_m68k; + abfd->obj_machine = 68010; + break; + + case M_68020: + abfd->obj_arch = bfd_arch_m68k; + abfd->obj_machine = 68020; + break; + + case M_SPARC: + abfd->obj_arch = bfd_arch_sparc; + abfd->obj_machine = 0; + break; + + case M_386: + abfd->obj_arch = bfd_arch_i386; + abfd->obj_machine = 0; + break; + + case M_29K: + abfd->obj_arch = bfd_arch_a29k; + abfd->obj_machine = 0; + break; + + default: + abfd->obj_arch = bfd_arch_obscure; + abfd->obj_machine = 0; + break; + } + + choose_reloc_size(abfd); + return abfd->xvec; +} + + +/* Write an object file in SunOS format. +Section contents have already been written. We write the +file header, symbols, and relocation. */ + +boolean +DEFUN(NAME(aout,sunos4_write_object_contents),(abfd), + bfd *abfd) + + { + bfd_size_type data_pad = 0; + struct external_exec exec_bytes; + struct internal_exec *execp = exec_hdr (abfd); + + + + execp->a_text = obj_textsec (abfd)->size; + + /* Magic number, maestro, please! */ + switch (bfd_get_architecture(abfd)) { + case bfd_arch_m68k: + switch (bfd_get_machine(abfd)) { + case 68010: + N_SET_MACHTYPE(*execp, M_68010); + break; + default: + case 68020: + N_SET_MACHTYPE(*execp, M_68020); + break; + } + break; + case bfd_arch_sparc: + N_SET_MACHTYPE(*execp, M_SPARC); + break; + case bfd_arch_i386: + N_SET_MACHTYPE(*execp, M_386); + break; + case bfd_arch_a29k: + N_SET_MACHTYPE(*execp, M_29K); + break; + default: + N_SET_MACHTYPE(*execp, M_UNKNOWN); + } + + choose_reloc_size(abfd); + + /* FIXME */ + N_SET_FLAGS (*execp, 0x81); + + WRITE_HEADERS(abfd, execp); + + return true; +} + +/* core files */ + +#define CORE_MAGIC 0x080456 +#define CORE_NAMELEN 16 + +/* The core structure is taken from the Sun documentation. +Unfortunately, they don't document the FPA structure, or at least I +can't find it easily. Fortunately the core header contains its own +length. So this shouldn't cause problems, except for c_ucode, which +so far we don't use but is easy to find with a little arithmetic. */ + +/* But the reg structure can be gotten from the SPARC processor handbook. +This really should be in a GNU include file though so that gdb can use +the same info. */ +struct regs { + int r_psr; + int r_pc; + int r_npc; + int r_y; + int r_g1; + int r_g2; + int r_g3; + int r_g4; + int r_g5; + int r_g6; + int r_g7; + int r_o0; + int r_o1; + int r_o2; + int r_o3; + int r_o4; + int r_o5; + int r_o6; + int r_o7; +}; + +/* Taken from Sun documentation: */ + +/* FIXME: It's worse than we expect. This struct contains TWO substructs +neither of whose size we know, WITH STUFF IN BETWEEN THEM! We can't +even portably access the stuff in between! */ + +struct core { + int c_magic; /* Corefile magic number */ + int c_len; /* Sizeof (struct core) */ + struct regs c_regs; /* General purpose registers -- MACHDEP SIZE */ + struct internal_exec c_aouthdr; /* A.out header */ + int c_signo; /* Killing signal, if any */ + int c_tsize; /* Text size (bytes) */ + int c_dsize; /* Data size (bytes) */ + int c_ssize; /* Stack size (bytes) */ + char c_cmdname[CORE_NAMELEN + 1]; /* Command name */ + double fp_stuff[1]; /* external FPU state (size unknown by us) */ + /* The type "double" is critical here, for alignment. + SunOS declares a struct here, but the struct's alignment + is double since it contains doubles. */ + int c_ucode; /* Exception no. from u_code */ + /* (this member is not accessible by name since we don't + portably know the size of fp_stuff.) */ +}; + +/* Supposedly the user stack grows downward from the bottom of kernel memory. +Presuming that this remains true, this definition will work. */ +#define USRSTACK (-(128*1024*1024)) + +PROTO (static void, swapcore, (bfd *abfd, struct core *core)); + +/* need this cast b/c ptr is really void * */ +#define core_hdr(bfd) (((struct suncordata *) (bfd->tdata))->hdr) +#define core_datasec(bfd) (((struct suncordata *) ((bfd)->tdata))->data_section) +#define core_stacksec(bfd) (((struct suncordata*)((bfd)->tdata))->stack_section) +#define core_regsec(bfd) (((struct suncordata *) ((bfd)->tdata))->reg_section) +#define core_reg2sec(bfd) (((struct suncordata *) ((bfd)->tdata))->reg2_section) + +/* These are stored in the bfd's tdata */ +struct suncordata { +struct core *hdr; /* core file header */ +asection *data_section; +asection *stack_section; +asection *reg_section; +asection *reg2_section; +}; + +static bfd_target * +DEFUN(sunos4_core_file_p,(abfd), + bfd *abfd) +{ + unsigned char longbuf[4]; /* Raw bytes of various header fields */ + int core_size; + int core_mag; + struct core *core; + char *rawptr; + + bfd_error = system_call_error; + + if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) != + sizeof (longbuf)) + return 0; + core_mag = bfd_h_get_32 (abfd, longbuf); + + if (core_mag != CORE_MAGIC) return 0; + + /* SunOS core headers can vary in length; second word is size; */ + if (bfd_read ((PTR)longbuf, 1, sizeof (longbuf), abfd) != + sizeof (longbuf)) + return 0; + core_size = bfd_h_get_32 (abfd, longbuf); + /* Sanity check */ + if (core_size > 20000) + return 0; + + if (bfd_seek (abfd, 0L, false) < 0) return 0; + + rawptr = bfd_zalloc (abfd, core_size + sizeof (struct suncordata)); + if (rawptr == NULL) { + bfd_error = no_memory; + return 0; + } + + core = (struct core *) (rawptr + sizeof (struct suncordata)); + + if ((bfd_read ((PTR) core, 1, core_size, abfd)) != core_size) { + bfd_error = system_call_error; + bfd_release (abfd, rawptr); + return 0; + } + + swapcore (abfd, core); + set_tdata (abfd, ((struct suncordata *) rawptr)); + core_hdr (abfd) = core; + + /* create the sections. This is raunchy, but bfd_close wants to reclaim + them */ + core_stacksec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); + if (core_stacksec (abfd) == NULL) { + loser: + bfd_error = no_memory; + bfd_release (abfd, rawptr); + return 0; + } + core_datasec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); + if (core_datasec (abfd) == NULL) { + loser1: + bfd_release (abfd, core_stacksec (abfd)); + goto loser; + } + core_regsec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); + if (core_regsec (abfd) == NULL) { + loser2: + bfd_release (abfd, core_datasec (abfd)); + goto loser1; + } + core_reg2sec (abfd) = (asection *) bfd_zalloc (abfd, sizeof (asection)); + if (core_reg2sec (abfd) == NULL) { + bfd_release (abfd, core_regsec (abfd)); + goto loser2; + } + + core_stacksec (abfd)->name = ".stack"; + core_datasec (abfd)->name = ".data"; + core_regsec (abfd)->name = ".reg"; + core_reg2sec (abfd)->name = ".reg2"; + + core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD; + core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD; + core_regsec (abfd)->flags = SEC_ALLOC; + core_reg2sec (abfd)->flags = SEC_ALLOC; + + core_stacksec (abfd)->size = core->c_ssize; + core_datasec (abfd)->size = core->c_dsize; + core_regsec (abfd)->size = (sizeof core->c_regs); + /* Float regs take up end of struct, except c_ucode. */ + core_reg2sec (abfd)->size = core_size - (sizeof core->c_ucode) - + (file_ptr)(((struct core *)0)->fp_stuff); + + core_stacksec (abfd)->vma = (USRSTACK - core->c_ssize); + core_datasec (abfd)->vma = N_DATADDR(core->c_aouthdr); + core_regsec (abfd)->vma = -1; + core_reg2sec (abfd)->vma = -1; + + core_stacksec (abfd)->filepos = core->c_len + core->c_dsize; + core_datasec (abfd)->filepos = core->c_len; + /* In file header: */ + core_regsec (abfd)->filepos = (file_ptr)(&((struct core *)0)->c_regs); + core_reg2sec (abfd)->filepos = (file_ptr)(((struct core *)0)->fp_stuff); + + /* Align to word at least */ + core_stacksec (abfd)->alignment_power = 2; + core_datasec (abfd)->alignment_power = 2; + core_regsec (abfd)->alignment_power = 2; + core_reg2sec (abfd)->alignment_power = 2; + + abfd->sections = core_stacksec (abfd); + core_stacksec (abfd)->next = core_datasec (abfd); + core_datasec (abfd)->next = core_regsec (abfd); + core_regsec (abfd)->next = core_reg2sec (abfd); + + abfd->section_count = 4; + + return abfd->xvec; +} + +static char *sunos4_core_file_failing_command (abfd) +bfd *abfd; + { + return core_hdr (abfd)->c_cmdname; +} + +static int +DEFUN(sunos4_core_file_failing_signal,(abfd), + bfd *abfd) +{ + return core_hdr (abfd)->c_signo; +} + +static boolean +DEFUN(sunos4_core_file_matches_executable_p, (core_bfd, exec_bfd), + bfd *core_bfd AND + bfd *exec_bfd) +{ + if (core_bfd->xvec != exec_bfd->xvec) { + bfd_error = system_call_error; + return false; + } + + return (bcmp ((char *)&core_hdr (core_bfd), (char*) &exec_hdr (exec_bfd), + sizeof (struct internal_exec)) == 0) ? true : false; +} + +/* byte-swap core structure */ +/* FIXME, this needs more work to swap IN a core struct from raw bytes */ +static void +DEFUN(swapcore,(abfd, core), + bfd *abfd AND + struct core *core) +{ + struct external_exec exec_bytes; + + core->c_magic = bfd_h_get_32 (abfd, (unsigned char *)&core->c_magic); + core->c_len = bfd_h_get_32 (abfd, (unsigned char *)&core->c_len ); + /* Leave integer registers in target byte order. */ + bcopy ((char *)&(core->c_aouthdr), (char *)&exec_bytes, EXEC_BYTES_SIZE); + NAME(aout,swap_exec_header_in)(abfd, &exec_bytes, &core->c_aouthdr); + core->c_signo = bfd_h_get_32 (abfd, (unsigned char *)&core->c_signo); + core->c_tsize = bfd_h_get_32 (abfd, (unsigned char *)&core->c_tsize); + core->c_dsize = bfd_h_get_32 (abfd, (unsigned char *)&core->c_dsize); + core->c_ssize = bfd_h_get_32 (abfd, (unsigned char *)&core->c_ssize); + /* Leave FP registers in target byte order. */ + /* Leave "c_ucode" unswapped for now, since we can't find it easily. */ +} + +/* 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 aout_32_machine_type sunos_machine_type + +#define aout_32_core_file_failing_command sunos4_core_file_failing_command +#define aout_32_core_file_failing_signal sunos4_core_file_failing_signal +#define aout_32_core_file_matches_executable_p sunos4_core_file_matches_executable_p + + +#define aout_64_openr_next_archived_file bfd_generic_openr_next_archived_file +#define aout_64_generic_stat_arch_elt bfd_generic_stat_arch_elt +#define aout_64_slurp_armap bfd_slurp_bsd_armap +#define aout_64_slurp_extended_name_table bfd_true +#define aout_64_write_armap bsd_write_armap +#define aout_64_truncate_arname bfd_bsd_truncate_arname +#define aout_64_machine_type sunos_machine_type + +#define aout_64_core_file_failing_command sunos4_core_file_failing_command +#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 + +/* 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)) +}; diff --git a/bfd/aoutx.h b/bfd/aoutx.h new file mode 100644 index 0000000..399584c --- /dev/null +++ b/bfd/aoutx.h @@ -0,0 +1,1484 @@ + +/* BFD semi-generic back-end for a.out binaries */ + +/* Copyright (C) 1990, 1991 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Diddler. + +BFD is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +BFD is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with BFD; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +#include <sysdep.h> +#include <ansidecl.h> + + +#include "bfd.h" +struct external_exec; +#include "liba.out.h" +#include "libbfd.h" +#include "aout64.h" +#include "stab.gnu.h" +#include "ar.h" + +void (*bfd_error_trap)(); + +/*SUPPRESS558*/ +/*SUPPRESS529*/ + +#define CTOR_TABLE_RELOC_IDX 2 +static reloc_howto_type howto_table_ext[] = +{ + HOWTO(RELOC_8, 0, 0, 8, false, 0, true, true,0,"8", false, 0,0x000000ff, false), + HOWTO(RELOC_16, 0, 1, 16, false, 0, true, true,0,"16", false, 0,0x0000ffff, false), + HOWTO(RELOC_32, 0, 2, 32, false, 0, true, true,0,"32", false, 0,0xffffffff, false), + HOWTO(RELOC_DISP8, 0, 0, 8, true, 0, false, true,0,"DISP8", false, 0,0x000000ff, false), + HOWTO(RELOC_DISP16, 0, 1, 16, true, 0, false, true,0,"DISP16", false, 0,0x0000ffff, false), + HOWTO(RELOC_DISP32, 0, 2, 32, true, 0, false, true,0,"DISP32", false, 0,0xffffffff, false), + HOWTO(RELOC_WDISP30,2, 2, 30, true, 0, false, true,0,"WDISP30", false, 0,0x3fffffff, false), + HOWTO(RELOC_WDISP22,2, 2, 22, true, 0, false, true,0,"WDISP22", false, 0,0x003fffff, false), + HOWTO(RELOC_HI22, 10, 2, 22, false, 0, false, true,0,"HI22", false, 0,0x003fffff, false), + HOWTO(RELOC_22, 0, 2, 22, false, 0, false, true,0,"22", false, 0,0x003fffff, false), + HOWTO(RELOC_13, 0, 2, 13, false, 0, false, true,0,"13", false, 0,0x00001fff, false), + HOWTO(RELOC_LO10, 0, 2, 10, false, 0, false, true,0,"LO10", false, 0,0x000003ff, false), + HOWTO(RELOC_SFA_BASE,0, 2, 32, false, 0, false, true,0,"SFA_BASE", false, 0,0xffffffff, false), + HOWTO(RELOC_SFA_OFF13,0,2, 32, false, 0, false, true,0,"SFA_OFF13",false, 0,0xffffffff, false), + HOWTO(RELOC_BASE10, 0, 2, 16, false, 0, false, true,0,"BASE10", false, 0,0x0000ffff, false), + HOWTO(RELOC_BASE13, 0, 2, 13, false, 0, false, true,0,"BASE13", false, 0,0x00001fff, false), + HOWTO(RELOC_BASE22, 0, 2, 0, false, 0, false, true,0,"BASE22", false, 0,0x00000000, false), + HOWTO(RELOC_PC10, 0, 2, 10, false, 0, false, true,0,"PC10", false, 0,0x000003ff, false), + HOWTO(RELOC_PC22, 0, 2, 22, false, 0, false, true,0,"PC22", false, 0,0x003fffff, false), + HOWTO(RELOC_JMP_TBL,0, 2, 32, false, 0, false, true,0,"JMP_TBL", false, 0,0xffffffff, false), + HOWTO(RELOC_SEGOFF16,0, 2, 0, false, 0, false, true,0,"SEGOFF16", false, 0,0x00000000, false), + HOWTO(RELOC_GLOB_DAT,0, 2, 0, false, 0, false, true,0,"GLOB_DAT", false, 0,0x00000000, false), + HOWTO(RELOC_JMP_SLOT,0, 2, 0, false, 0, false, true,0,"JMP_SLOT", false, 0,0x00000000, false), + HOWTO(RELOC_RELATIVE,0, 2, 0, false, 0, false, true,0,"RELATIVE", false, 0,0x00000000, false), + HOWTO(RELOC_JUMPTARG,2, 13, 16, true, 0, false, true,0,"JUMPTARG", false, 0,0x0000ffff, false), + HOWTO(RELOC_CONST, 0, 13, 16, false, 0, false, true,0,"CONST", false, 0,0x0000ffff, false), + HOWTO(RELOC_CONSTH, 16, 13, 16, false, 0, false, true,0,"CONSTH", false, 0,0x0000ffff, false), +}; + +/* Convert standard reloc records to "arelent" format (incl byte swap). */ + +static reloc_howto_type howto_table_std[] = { + /* type rs size bsz pcrel bitpos abs ovrf sf name part_inpl readmask setmask pcdone */ +HOWTO( 0, 0, 0, 8, false, 0, true, true,0,"8", true, 0x000000ff,0x000000ff, false), +HOWTO( 1, 0, 1, 16, false, 0, true, true,0,"16", true, 0x0000ffff,0x0000ffff, false), +HOWTO( 2, 0, 2, 32, false, 0, true, true,0,"32", true, 0xffffffff,0xffffffff, false), +HOWTO( 3, 0, 3, 64, false, 0, true, true,0,"64", true, 0xdeaddead,0xdeaddead, false), +HOWTO( 4, 0, 0, 8, true, 0, false, true,0,"DISP8", true, 0x000000ff,0x000000ff, false), +HOWTO( 5, 0, 1, 16, true, 0, false, true,0,"DISP16", true, 0x0000ffff,0x0000ffff, false), +HOWTO( 6, 0, 2, 32, true, 0, false, true,0,"DISP32", true, 0xffffffff,0xffffffff, false), +HOWTO( 7, 0, 3, 64, true, 0, false, true,0,"DISP64", true, 0xfeedface,0xfeedface, false), +}; + + +bfd_error_vector_type bfd_error_vector; +void +DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp), + bfd *abfd AND + struct external_exec *raw_bytes AND + struct internal_exec *execp) +{ + struct external_exec *bytes = (struct external_exec *)raw_bytes; + + /* Now fill in fields in the execp, from the bytes in the raw data. */ + execp->a_info = bfd_h_get_32 (abfd, bytes->e_info); + execp->a_text = GET_WORD (abfd, bytes->e_text); + execp->a_data = GET_WORD (abfd, bytes->e_data); + execp->a_bss = GET_WORD (abfd, bytes->e_bss); + execp->a_syms = GET_WORD (abfd, bytes->e_syms); + execp->a_entry = GET_WORD (abfd, bytes->e_entry); + execp->a_trsize = GET_WORD (abfd, bytes->e_trsize); + execp->a_drsize = GET_WORD (abfd, bytes->e_drsize); +} + +void +DEFUN(NAME(aout,swap_exec_header_out),(abfd, execp, raw_bytes), + bfd *abfd AND + struct internal_exec *execp AND + struct external_exec *raw_bytes) +{ + struct external_exec *bytes = (struct external_exec *)raw_bytes; + + /* Now fill in fields in the raw data, from the fields in the exec struct. */ + bfd_h_put_32 (abfd, execp->a_info , bytes->e_info); + PUT_WORD (abfd, execp->a_text , bytes->e_text); + PUT_WORD (abfd, execp->a_data , bytes->e_data); + PUT_WORD (abfd, execp->a_bss , bytes->e_bss); + PUT_WORD (abfd, execp->a_syms , bytes->e_syms); + PUT_WORD (abfd, execp->a_entry , bytes->e_entry); + PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize); + PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize); +} + +struct container { + struct aoutdata a; + 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. */ + +bfd_target * +DEFUN(NAME(aout,some_aout_object_p),(abfd, callback_to_real_object_p), + bfd *abfd AND + bfd_target *(*callback_to_real_object_p) ()) +{ + struct external_exec exec_bytes; + struct internal_exec *execp; + struct container *rawptr; + + if (bfd_seek (abfd, 0L, false) < 0) { + bfd_error = system_call_error; + return 0; + } + + if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd) + != EXEC_BYTES_SIZE) { + bfd_error = wrong_format; + return 0; + } + + /* Use an intermediate variable for clarity */ + rawptr = (struct container *) bfd_zalloc (abfd, sizeof (struct container)); + + if (rawptr == NULL) { + bfd_error = no_memory; + return 0; + } + + set_tdata (abfd, rawptr); + exec_hdr (abfd) = execp = &(rawptr->e); + NAME(aout,swap_exec_header_in)(abfd, &exec_bytes, execp); + + /* Set the file flags */ + abfd->flags = NO_FLAGS; + if (execp->a_drsize || execp->a_trsize) + abfd->flags |= HAS_RELOC; + if (execp->a_entry) + abfd->flags |= EXEC_P; + if (execp->a_syms) + abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS; + + if (N_MAGIC (*execp) == ZMAGIC) abfd->flags |= D_PAGED; + if (N_MAGIC (*execp) == NMAGIC) abfd->flags |= WP_TEXT; + + bfd_get_start_address (abfd) = execp->a_entry; + + obj_aout_symbols (abfd) = (aout_symbol_type *)NULL; + bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist); + + /* Set the default architecture and machine type. These can be + overridden in the callback routine. */ + abfd->obj_arch = bfd_arch_unknown; + abfd->obj_machine = 0; + + /* The default relocation entry size is that of traditional V7 Unix. */ + obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; + + /* create the sections. This is raunchy, but bfd_close wants to reclaim + them */ + obj_textsec (abfd) = (asection *)NULL; + obj_datasec (abfd) = (asection *)NULL; + obj_bsssec (abfd) = (asection *)NULL; + (void)bfd_make_section(abfd, ".text"); + (void)bfd_make_section(abfd, ".data"); + (void)bfd_make_section(abfd, ".bss"); + + abfd->sections = obj_textsec (abfd); + obj_textsec (abfd)->next = obj_datasec (abfd); + obj_datasec (abfd)->next = obj_bsssec (abfd); + + obj_datasec (abfd)->size = execp->a_data; + obj_bsssec (abfd)->size = execp->a_bss; + obj_textsec (abfd)->size = execp->a_text; + + if (abfd->flags & D_PAGED) { + obj_textsec (abfd)->size -= EXEC_BYTES_SIZE; + } + + + obj_textsec (abfd)->flags = (execp->a_trsize != 0 ? + (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_HAS_CONTENTS) : + (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)); + obj_datasec (abfd)->flags = (execp->a_drsize != 0 ? + (SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_HAS_CONTENTS) : + (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)); + obj_bsssec (abfd)->flags = SEC_ALLOC; + +#ifdef THIS_IS_ONLY_DOCUMENTATION + /* Call back to the format-dependent code to fill in the rest of the + fields and do any further cleanup. Things that should be filled + in by the callback: */ + + struct exec *execp = exec_hdr (abfd); + + /* The virtual memory addresses of the sections */ + obj_datasec (abfd)->vma = N_DATADDR(*execp); + obj_bsssec (abfd)->vma = N_BSSADDR(*execp); + obj_textsec (abfd)->vma = N_TXTADDR(*execp); + + /* The file offsets of the sections */ + obj_textsec (abfd)->filepos = N_TXTOFF(*execp); + obj_datasec (abfd)->filepos = N_DATOFF(*execp); + + /* The file offsets of the relocation info */ + obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp); + obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp); + + /* The file offsets of the string table and symbol table. */ + obj_str_filepos (abfd) = N_STROFF (*execp); + obj_sym_filepos (abfd) = N_SYMOFF (*execp); + + /* This common code can't fill in those things because they depend + on either the start address of the text segment, the rounding + up of virtual addersses between segments, or the starting file + position of the text segment -- all of which varies among different + versions of a.out. */ + + /* Determine the architecture and machine type of the object file. */ + switch (N_MACHTYPE (*exec_hdr (abfd))) { + default: + abfd->obj_arch = bfd_arch_obscure; + break; + } + + /* Determine the size of a relocation entry */ + switch (abfd->obj_arch) { + case bfd_arch_sparc: + case bfd_arch_a29k: + obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; + default: + obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; + } + + return abfd->xvec; + + /* The architecture is encoded in various ways in various a.out variants, + or is not encoded at all in some of them. The relocation size depends + on the architecture and the a.out variant. Finally, the return value + is the bfd_target vector in use. If an error occurs, return zero and + set bfd_error to the appropriate error code. + + Formats such as b.out, which have additional fields in the a.out + header, should cope with them in this callback as well. */ +#endif /* DOCUMENTATION */ + + + return (*callback_to_real_object_p)(abfd); +} + + +boolean +DEFUN(NAME(aout,mkobject),(abfd), + bfd *abfd) +{ + struct container *rawptr; + + bfd_error = system_call_error; + + /* Use an intermediate variable for clarity */ + rawptr = (struct container *)bfd_zalloc (abfd, sizeof (struct container)); + + if (rawptr == NULL) { + bfd_error = no_memory; + return false; + } + + set_tdata (abfd, rawptr); + exec_hdr (abfd) = &(rawptr->e); + + /* For simplicity's sake we just make all the sections right here. */ + + obj_textsec (abfd) = (asection *)NULL; + obj_datasec (abfd) = (asection *)NULL; + obj_bsssec (abfd) = (asection *)NULL; + bfd_make_section (abfd, ".text"); + bfd_make_section (abfd, ".data"); + bfd_make_section (abfd, ".bss"); + + return true; +} + +/* 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. */ + +enum machine_type +DEFUN(NAME(aout,machine_type),(arch, machine), + enum bfd_architecture arch AND + unsigned long machine) +{ + enum machine_type arch_flags; + + arch_flags = M_UNKNOWN; + + switch (arch) { + case bfd_arch_sparc: + if (machine == 0) arch_flags = M_SPARC; + break; + + case bfd_arch_m68k: + switch (machine) { + case 0: arch_flags = M_68010; break; + case 68000: arch_flags = M_UNKNOWN; break; + case 68010: arch_flags = M_68010; break; + case 68020: arch_flags = M_68020; break; + default: arch_flags = M_UNKNOWN; break; + } + break; + + case bfd_arch_i386: + if (machine == 0) arch_flags = M_386; + break; + + case bfd_arch_a29k: + if (machine == 0) arch_flags = M_29K; + break; + + default: + arch_flags = M_UNKNOWN; + break; + } + return arch_flags; +} + +boolean +DEFUN(NAME(aout,set_arch_mach),(abfd, arch, machine), + bfd *abfd AND + enum bfd_architecture arch AND + unsigned long machine) +{ + abfd->obj_arch = arch; + abfd->obj_machine = machine; + if (arch != bfd_arch_unknown && + NAME(aout,machine_type) (arch, machine) == M_UNKNOWN) + return false; /* We can't represent this type */ + return true; /* We're easy ... */ +} + +/* exec and core file sections */ + +boolean +DEFUN(NAME(aout,new_section_hook),(abfd, newsect), + bfd *abfd AND + asection *newsect) +{ + /* align to double at least */ + newsect->alignment_power = 3; + + if (bfd_get_format (abfd) == bfd_object) { + if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) { + obj_textsec(abfd)= newsect; + return true; + } + + if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) { + obj_datasec(abfd) = newsect; + return true; + } + + if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) { + obj_bsssec(abfd) = newsect; + return true; + } + } + + /* We allow more than three sections internally */ + return true; +} + +boolean +DEFUN(NAME(aout,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 (abfd->output_has_begun == false) + { /* set by bfd.c handler */ + if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL)) + { + bfd_error = invalid_operation; + return false; + } +/* if (abfd->flags & D_PAGED) { + obj_textsec(abfd)->filepos = 0; + } + else*/ { + obj_textsec(abfd)->filepos = EXEC_BYTES_SIZE; + } + obj_textsec(abfd)->size = align_power(obj_textsec(abfd)->size, + obj_textsec(abfd)->alignment_power); + obj_datasec(abfd)->filepos = obj_textsec (abfd)->size + EXEC_BYTES_SIZE; + obj_datasec(abfd)->size = align_power(obj_datasec(abfd)->size, + obj_datasec(abfd)->alignment_power); + + + } + /* regardless, once we know what we're doing, we might as well get going */ + if (section != obj_bsssec(abfd)) + { + bfd_seek (abfd, section->filepos + offset, SEEK_SET); + + if (count) { + return (bfd_write ((PTR)location, 1, count, abfd) == count) ? + true : false; + } + return false; + } + return true; +} + +/* Classify stabs symbols */ + +#define sym_in_text_section(sym) \ +(((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_TEXT) + +#define sym_in_data_section(sym) \ +(((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_DATA) + +#define sym_in_bss_section(sym) \ +(((sym)->type & (N_ABS | N_TEXT | N_DATA | N_BSS))== N_BSS) + +/* Symbol is undefined if type is N_UNDF|N_EXT and if it has +zero in the "value" field. Nonzeroes there are fortrancommon +symbols. */ +#define sym_is_undefined(sym) \ +((sym)->type == (N_UNDF | N_EXT) && (sym)->symbol.value == 0) + +/* Symbol is a global definition if N_EXT is on and if it has +a nonzero type field. */ +#define sym_is_global_defn(sym) \ +(((sym)->type & N_EXT) && (sym)->type & N_TYPE) + +/* Symbol is debugger info if any bits outside N_TYPE or N_EXT +are on. */ +#define sym_is_debugger_info(sym) \ +((sym)->type & ~(N_EXT | N_TYPE)) + +#define sym_is_fortrancommon(sym) \ +(((sym)->type == (N_EXT)) && (sym)->symbol.value != 0) + +/* Symbol is absolute if it has N_ABS set */ +#define sym_is_absolute(sym) \ +(((sym)->type & N_TYPE)== N_ABS) + + +#define sym_is_indirect(sym) \ +(((sym)->type & N_ABS)== N_ABS) + +/* Only in their own functions for ease of debugging; when sym flags have +stabilised these should be inlined into their (single) caller */ + +static void +DEFUN(translate_from_native_sym_flags,(sym_pointer, cache_ptr, abfd), + struct external_nlist *sym_pointer AND + aout_symbol_type *cache_ptr AND + bfd *abfd) +{ + switch (cache_ptr->type & N_TYPE) { + case N_SETA: + case N_SETT: + case N_SETD: + case N_SETB: + { + asection *section = bfd_make_section(abfd, + cache_ptr->symbol.name); + arelent_chain *reloc = (arelent_chain *)bfd_alloc(abfd, sizeof(arelent_chain)); + + switch ( (cache_ptr->type & N_TYPE) ) { + case N_SETA: + reloc->relent.section = (asection *)NULL; + cache_ptr->symbol.section = (asection *)NULL; + break; + case N_SETT: + reloc->relent.section = (asection *)obj_textsec(abfd); + cache_ptr->symbol.value -= reloc->relent.section->vma; + break; + case N_SETD: + reloc->relent.section = (asection *)obj_datasec(abfd); + cache_ptr->symbol.value -= reloc->relent.section->vma; + break; + case N_SETB: + reloc->relent.section = (asection *)obj_bsssec(abfd); + cache_ptr->symbol.value -= reloc->relent.section->vma; + break; + } + cache_ptr->symbol.section = reloc->relent.section; + reloc->relent.addend = cache_ptr->symbol.value ; + + /* We modify the symbol to belong to a section depending upon the + name of the symbol - probably __CTOR__ or __DTOR__ but we don't + really care, and add to the size of the section to contain a + pointer to the symbol. Build a reloc entry to relocate to this + symbol attached to this section. */ + + section->flags = SEC_CONSTRUCTOR; + section->reloc_count++; + section->alignment_power = 2; + reloc->relent.sym_ptr_ptr = (asymbol **)NULL; + reloc->next = section->constructor_chain; + section->constructor_chain = reloc; + reloc->relent.address = section->size; + section->size += sizeof(int *); + + reloc->relent.howto = howto_table_ext +CTOR_TABLE_RELOC_IDX; + cache_ptr->symbol.flags |= BSF_DEBUGGING ; + } + break; + default: + + if (sym_is_debugger_info (cache_ptr)) { + cache_ptr->symbol.flags = BSF_DEBUGGING ; + /* Work out the section correct for this symbol */ + switch (cache_ptr->type & N_TYPE) + { + case N_TEXT: + case N_FN: + cache_ptr->symbol.section = obj_textsec (abfd); + cache_ptr->symbol.value -= obj_textsec(abfd)->vma; + break; + case N_DATA: + cache_ptr->symbol.value -= obj_datasec(abfd)->vma; + cache_ptr->symbol.section = obj_datasec (abfd); + break; + case N_BSS : + cache_ptr->symbol.section = obj_bsssec (abfd); + cache_ptr->symbol.value -= obj_bsssec(abfd)->vma; + break; + case N_ABS: + default: + cache_ptr->symbol.section = 0; + break; + } + } + else { + if (sym_is_fortrancommon (cache_ptr)) + { + cache_ptr->symbol.flags = BSF_FORT_COMM; + cache_ptr->symbol.section = (asection *)NULL; + } + else { + if (sym_is_undefined (cache_ptr)) { + cache_ptr->symbol.flags = BSF_UNDEFINED; + } + else if (sym_is_global_defn (cache_ptr)) { + cache_ptr->symbol.flags = BSF_GLOBAL | BSF_EXPORT; + } + + else if (sym_is_absolute (cache_ptr)) { + cache_ptr->symbol.flags = BSF_ABSOLUTE; + } + else { + cache_ptr->symbol.flags = BSF_LOCAL; + } + + /* In a.out, the value of a symbol is always relative to the + * start of the file, if this is a data symbol we'll subtract + * the size of the text section to get the section relative + * value. If this is a bss symbol (which would be strange) + * we'll subtract the size of the previous two sections + * to find the section relative address. + */ + + if (sym_in_text_section (cache_ptr)) { + cache_ptr->symbol.value -= obj_textsec(abfd)->vma; + cache_ptr->symbol.section = obj_textsec (abfd); + } + else if (sym_in_data_section (cache_ptr)){ + cache_ptr->symbol.value -= obj_datasec(abfd)->vma; + cache_ptr->symbol.section = obj_datasec (abfd); + } + else if (sym_in_bss_section(cache_ptr)) { + cache_ptr->symbol.section = obj_bsssec (abfd); + cache_ptr->symbol.value -= obj_bsssec(abfd)->vma; + } + else { + cache_ptr->symbol.section = (asection *)NULL; + cache_ptr->symbol.flags |= BSF_ABSOLUTE; + } + } + } + } +} + +static void +DEFUN(translate_to_native_sym_flags,(sym_pointer, cache_ptr, abfd), + struct external_nlist *sym_pointer AND + asymbol *cache_ptr AND + bfd *abfd) +{ + bfd_vma value = cache_ptr->value; + + if (bfd_get_section(cache_ptr)) { + if (bfd_get_output_section(cache_ptr) == obj_bsssec (abfd)) { + sym_pointer->e_type[0] |= N_BSS; + } + else if (bfd_get_output_section(cache_ptr) == obj_datasec (abfd)) { + sym_pointer->e_type[0] |= N_DATA; + } + else if (bfd_get_output_section(cache_ptr) == obj_textsec (abfd)) { + sym_pointer->e_type[0] |= N_TEXT; + } + else { + bfd_error_vector.nonrepresentable_section(abfd, + bfd_get_output_section(cache_ptr)->name); + } + /* Turn the symbol from section relative to absolute again */ + + value += + cache_ptr->section->output_section->vma + + cache_ptr->section->output_offset ; + } + else { + sym_pointer->e_type[0] |= N_ABS; + } + + if (cache_ptr->flags & (BSF_FORT_COMM | BSF_UNDEFINED)) { + sym_pointer->e_type[0] = (N_UNDF | N_EXT); + } + else { + if (cache_ptr->flags & BSF_ABSOLUTE) { + sym_pointer->e_type[0] |= N_ABS; + } + + if (cache_ptr->flags & (BSF_GLOBAL | BSF_EXPORT)) { + sym_pointer->e_type[0] |= N_EXT; + } + if (cache_ptr->flags & BSF_DEBUGGING) { + sym_pointer->e_type [0]= ((aout_symbol_type *)cache_ptr)->type; + } + } + PUT_WORD(abfd, value, sym_pointer->e_value); +} + +/* Native-level interface to symbols. */ + +/* We read the symbols into a buffer, which is discarded when this +function exits. We read the strings into a buffer large enough to +hold them all plus all the cached symbol entries. */ + +asymbol * +DEFUN(NAME(aout,make_empty_symbol),(abfd), + bfd *abfd) + { + aout_symbol_type *new = + (aout_symbol_type *)bfd_zalloc (abfd, sizeof (aout_symbol_type)); + new->symbol.the_bfd = abfd; + + return &new->symbol; + } + +boolean +DEFUN(NAME(aout,slurp_symbol_table),(abfd), + bfd *abfd) + { + bfd_size_type symbol_size; + bfd_size_type string_size; + unsigned char string_chars[BYTES_IN_WORD]; + struct external_nlist *syms; + char *strings; + aout_symbol_type *cached; + + /* If there's no work to be done, don't do any */ + if (obj_aout_symbols (abfd) != (aout_symbol_type *)NULL) return true; + symbol_size = exec_hdr(abfd)->a_syms; + if (symbol_size == 0) { + bfd_error = no_symbols; + return false; + } + + bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET); + if (bfd_read ((PTR)string_chars, BYTES_IN_WORD, 1, abfd) != BYTES_IN_WORD) + return false; + string_size = GET_WORD (abfd, string_chars); + + strings =(char *) bfd_alloc(abfd, string_size + 1); + cached = (aout_symbol_type *) + bfd_zalloc(abfd, (bfd_size_type)(bfd_get_symcount (abfd) * sizeof(aout_symbol_type))); + /* Alloc this last, so we can free it if obstack is in use. */ + syms = (struct external_nlist *) bfd_alloc(abfd, symbol_size); + + bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET); + if (bfd_read ((PTR)syms, 1, symbol_size, abfd) != symbol_size) { + bailout: + if (syms) bfd_release (abfd, syms); + if (cached) bfd_release (abfd, cached); + if (strings)bfd_release (abfd, strings); + return false; + } + + bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET); + if (bfd_read ((PTR)strings, 1, string_size, abfd) != string_size) { + goto bailout; + } + + /* OK, now walk the new symtable, cacheing symbol properties */ + { + register struct external_nlist *sym_pointer; + register struct external_nlist *sym_end = syms + bfd_get_symcount (abfd); + register aout_symbol_type *cache_ptr = cached; + + /* Run through table and copy values */ + for (sym_pointer = syms, cache_ptr = cached; + sym_pointer < sym_end; sym_pointer++, cache_ptr++) + { + bfd_vma x = GET_WORD(abfd, sym_pointer->e_strx); + cache_ptr->symbol.the_bfd = abfd; + if (x) + cache_ptr->symbol.name = x + strings; + else + cache_ptr->symbol.name = (char *)NULL; + + cache_ptr->symbol.value = GET_SWORD(abfd, sym_pointer->e_value); + cache_ptr->desc = bfd_get_16(abfd, sym_pointer->e_desc); + cache_ptr->other =bfd_get_8(abfd, sym_pointer->e_other); + cache_ptr->type = bfd_get_8(abfd, sym_pointer->e_type); + cache_ptr->symbol.udata = 0; + translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd); + } + } + + obj_aout_symbols (abfd) = cached; + bfd_release (abfd, (PTR)syms); + + return true; + } + + +void +DEFUN(NAME(aout,write_syms),(abfd), + bfd *abfd) + { + unsigned int count ; + asymbol **generic = bfd_get_outsymbols (abfd); + + bfd_size_type stindex = BYTES_IN_WORD; /* initial string length */ + + for (count = 0; count < bfd_get_symcount (abfd); count++) { + asymbol *g = generic[count]; + struct external_nlist nsp; + + + if (g->name) { + unsigned int length = strlen(g->name) +1; + PUT_WORD (abfd, stindex, (unsigned char *)nsp.e_strx); + stindex += length; + } + else { + PUT_WORD (abfd, 0, (unsigned char *)nsp.e_strx); + } + + if (g->the_bfd->xvec->flavour == abfd->xvec->flavour) + { + bfd_h_put_16(abfd, aout_symbol(g)->desc, nsp.e_desc); + bfd_h_put_8(abfd, aout_symbol(g)->other, nsp.e_other); + bfd_h_put_8(abfd, aout_symbol(g)->type, nsp.e_type); + } + else + { + bfd_h_put_16(abfd,0, nsp.e_desc); + bfd_h_put_8(abfd, 0, nsp.e_other); + bfd_h_put_8(abfd, 0, nsp.e_type); + } + + + + translate_to_native_sym_flags (&nsp, (PTR)g, abfd); + + bfd_write((PTR)&nsp,1,EXTERNAL_LIST_SIZE, abfd); + } + + + /* Now output the strings. Be sure to put string length into correct + * byte ordering before writing it. + */ + { + char buffer[BYTES_IN_WORD]; + PUT_WORD (abfd, stindex, (unsigned char *)buffer); + + bfd_write((PTR)buffer, 1, BYTES_IN_WORD, abfd); + } + generic = bfd_get_outsymbols(abfd); + for (count = 0; count < bfd_get_symcount(abfd); count++) + { + asymbol *g = *(generic++); + + if (g->name) + { + size_t length = strlen(g->name)+1; + bfd_write((PTR)g->name, 1, length, abfd); + } + if ((g->flags & BSF_FAKE)==0) { + g->name = itos(count); /* smash the generic symbol */ + } + } + } + + + +unsigned int +DEFUN(NAME(aout,get_symtab),(abfd, location), + bfd *abfd AND + asymbol **location) + { + unsigned int counter = 0; + aout_symbol_type *symbase; + + if (!NAME(aout,slurp_symbol_table)(abfd)) return 0; + + for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);) + *(location++) = (asymbol *)( symbase++); + *location++ =0; + return bfd_get_symcount(abfd); + } + + +/* Standard reloc stuff */ +/* Output standard relocation information to a file in target byte order. */ + +void +DEFUN(NAME(aout,swap_std_reloc_out),(abfd, g, natptr), + bfd *abfd AND + arelent *g AND + struct reloc_std_external *natptr) + { + int r_index; + int r_extern; + unsigned int r_length; + int r_pcrel; + int r_baserel, r_jmptable, r_relative; + unsigned int r_addend; + + PUT_WORD(abfd, g->address, natptr->r_address); + + r_length = g->howto->size ; /* Size as a power of two */ + r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */ + /* r_baserel, r_jmptable, r_relative??? FIXME-soon */ + r_baserel = 0; + r_jmptable = 0; + r_relative = 0; + + r_addend = g->addend; /* Start here, see how it goes */ + + /* name was clobbered by aout_write_syms to be symbol index */ + + if (g->sym_ptr_ptr != NULL) + { + if ((*(g->sym_ptr_ptr))->section) { + /* put the section offset into the addend for output */ + r_addend += (*(g->sym_ptr_ptr))->section->vma; + } + + r_index = stoi((*(g->sym_ptr_ptr))->name); + r_extern = 1; + } + else { + r_extern = 0; + if (g->section == NULL) { + /* It is possible to have a reloc with nothing, we generate an + abs + 0 */ + r_addend = 0; + r_index = N_ABS | N_EXT; + } + else if(g->section->output_section == obj_textsec(abfd)) { + r_index = N_TEXT | N_EXT; + r_addend += g->section->output_section->vma; + } + else if (g->section->output_section == obj_datasec(abfd)) { + r_index = N_DATA | N_EXT; + r_addend += g->section->output_section->vma; + } + else if (g->section->output_section == obj_bsssec(abfd)) { + r_index = N_BSS | N_EXT ; + r_addend += g->section->output_section->vma; + } + else { + BFD_ASSERT(0); + } + } + + /* now the fun stuff */ + if (abfd->xvec->header_byteorder_big_p != false) { + natptr->r_index[0] = r_index >> 16; + natptr->r_index[1] = r_index >> 8; + natptr->r_index[2] = r_index; + natptr->r_type[0] = + (r_extern? RELOC_STD_BITS_EXTERN_BIG: 0) + | (r_pcrel? RELOC_STD_BITS_PCREL_BIG: 0) + | (r_baserel? RELOC_STD_BITS_BASEREL_BIG: 0) + | (r_jmptable? RELOC_STD_BITS_JMPTABLE_BIG: 0) + | (r_relative? RELOC_STD_BITS_RELATIVE_BIG: 0) + | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG); + } else { + natptr->r_index[2] = r_index >> 16; + natptr->r_index[1] = r_index >> 8; + natptr->r_index[0] = r_index; + natptr->r_type[0] = + (r_extern? RELOC_STD_BITS_EXTERN_LITTLE: 0) + | (r_pcrel? RELOC_STD_BITS_PCREL_LITTLE: 0) + | (r_baserel? RELOC_STD_BITS_BASEREL_LITTLE: 0) + | (r_jmptable? RELOC_STD_BITS_JMPTABLE_LITTLE: 0) + | (r_relative? RELOC_STD_BITS_RELATIVE_LITTLE: 0) + | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE); + } + } + + +/* Extended stuff */ +/* Output extended relocation information to a file in target byte order. */ + +void +DEFUN(NAME(aout,swap_ext_reloc_out),(abfd, g, natptr), + bfd *abfd AND + arelent *g AND + register struct reloc_ext_external *natptr) + { + int r_index; + int r_extern; + unsigned int r_type; + unsigned int r_addend; + + PUT_WORD (abfd, g->address, natptr->r_address); + + /* Find a type in the output format which matches the input howto - + at the moment we assume input format == output format FIXME!! */ + r_type = (enum reloc_type) g->howto->type; + + r_addend = g->addend; /* Start here, see how it goes */ + + /* name was clobbered by aout_write_syms to be symbol index*/ + + if (g->sym_ptr_ptr != NULL) + { + if ((*(g->sym_ptr_ptr))->section) { + /* put the section offset into the addend for output */ + r_addend += (*(g->sym_ptr_ptr))->section->vma; + } + + r_index = stoi((*(g->sym_ptr_ptr))->name); + r_extern = 1; + } + else { + r_extern = 0; + if (g->section == NULL) { + BFD_ASSERT(0); + r_index = N_ABS | N_EXT; + } + else if(g->section->output_section == obj_textsec(abfd)) { + r_index = N_TEXT | N_EXT; + r_addend += g->section->output_section->vma; + } + else if (g->section->output_section == obj_datasec(abfd)) { + r_index = N_DATA | N_EXT; + r_addend += g->section->output_section->vma; + } + else if (g->section->output_section == obj_bsssec(abfd)) { + r_index = N_BSS | N_EXT ; + r_addend += g->section->output_section->vma; + } + else { + BFD_ASSERT(0); + } + } + + /* now the fun stuff */ + if (abfd->xvec->header_byteorder_big_p != false) { + natptr->r_index[0] = r_index >> 16; + natptr->r_index[1] = r_index >> 8; + natptr->r_index[2] = r_index; + natptr->r_type[0] = + (r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0) + | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG); + } else { + natptr->r_index[2] = r_index >> 16; + natptr->r_index[1] = r_index >> 8; + natptr->r_index[0] = r_index; + natptr->r_type[0] = + (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0) + | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE); + } + + PUT_WORD (abfd, r_addend, natptr->r_addend); +} + +#define MOVE_ADDRESS(ad) \ + if (r_extern) { \ + cache_ptr->sym_ptr_ptr = symbols + r_index; \ + cache_ptr->section = (asection *)NULL; \ + cache_ptr->addend = ad; \ + } else { \ + cache_ptr->sym_ptr_ptr = (asymbol **)NULL; \ + switch (r_index) { \ + case N_TEXT: \ + case N_TEXT | N_EXT: \ + cache_ptr->section = obj_textsec(abfd); \ + cache_ptr->addend = ad - su->textsec->vma; \ + break; \ + case N_DATA: \ + case N_DATA | N_EXT: \ + cache_ptr->section = obj_datasec(abfd); \ + cache_ptr->addend = ad - su->datasec->vma; \ + break; \ + case N_BSS: \ + case N_BSS | N_EXT: \ + cache_ptr->section = obj_bsssec(abfd); \ + cache_ptr->addend = ad - su->bsssec->vma; \ + break; \ + case N_ABS: \ + case N_ABS | N_EXT: \ + cache_ptr->section = NULL; /* No section */ \ + cache_ptr->addend = ad; /* FIXME, is this right? */ \ + BFD_ASSERT(1); \ + break; \ + default: \ + cache_ptr->section = NULL; /* No section */ \ + cache_ptr->addend = ad; /* FIXME, is this right? */ \ + BFD_ASSERT(1); \ + break; \ + } \ + } \ + +void +DEFUN(NAME(aout,swap_ext_reloc_in), (abfd, bytes, cache_ptr, symbols), + bfd *abfd AND + struct reloc_ext_external *bytes AND + arelent *cache_ptr AND + asymbol **symbols) +{ + int r_index; + int r_extern; + unsigned int r_type; + struct aoutdata *su = (struct aoutdata *)(abfd->tdata); + + cache_ptr->address = (GET_SWORD (abfd, bytes->r_address)); + + /* now the fun stuff */ + if (abfd->xvec->header_byteorder_big_p != false) { + r_index = (bytes->r_index[0] << 16) + | (bytes->r_index[1] << 8) + | bytes->r_index[2]; + r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG)); + r_type = (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG) + >> RELOC_EXT_BITS_TYPE_SH_BIG; + } else { + r_index = (bytes->r_index[2] << 16) + | (bytes->r_index[1] << 8) + | bytes->r_index[0]; + r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE)); + r_type = (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE) + >> RELOC_EXT_BITS_TYPE_SH_LITTLE; + } + + cache_ptr->howto = howto_table_ext + r_type; + MOVE_ADDRESS(GET_SWORD(abfd,bytes->r_addend)); +} + +void +DEFUN(NAME(aout,swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols), + bfd *abfd AND + struct reloc_std_external *bytes AND + arelent *cache_ptr AND + asymbol **symbols) +{ + int r_index; + int r_extern; + unsigned int r_length; + int r_pcrel; + int r_baserel, r_jmptable, r_relative; + struct aoutdata *su = (struct aoutdata *)(abfd->tdata); + + cache_ptr->address = (int32_type)(bfd_h_get_32 (abfd, bytes->r_address)); + + /* now the fun stuff */ + if (abfd->xvec->header_byteorder_big_p != false) { + r_index = (bytes->r_index[0] << 16) + | (bytes->r_index[1] << 8) + | bytes->r_index[2]; + r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG)); + r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG)); + r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG)); + r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG)); + r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG)); + r_length = (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG) + >> RELOC_STD_BITS_LENGTH_SH_BIG; + } else { + r_index = (bytes->r_index[2] << 16) + | (bytes->r_index[1] << 8) + | bytes->r_index[0]; + r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE)); + r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE)); + r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE)); + r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE)); + r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE)); + r_length = (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE) + >> RELOC_STD_BITS_LENGTH_SH_LITTLE; + } + + cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel; + /* FIXME-soon: Roll baserel, jmptable, relative bits into howto setting */ + + MOVE_ADDRESS(0); +} + +/* Reloc hackery */ + +boolean +DEFUN(NAME(aout,slurp_reloc_table),(abfd, asect, symbols), + bfd *abfd AND + sec_ptr asect AND + asymbol **symbols) +{ + unsigned int count; + bfd_size_type reloc_size; + PTR relocs; + arelent *reloc_cache; + size_t each_size; + + if (asect->relocation) return true; + + if (asect->flags & SEC_CONSTRUCTOR) return true; + + if (asect == obj_datasec (abfd)) { + reloc_size = exec_hdr(abfd)->a_drsize; + goto doit; + } + + if (asect == obj_textsec (abfd)) { + reloc_size = exec_hdr(abfd)->a_trsize; + goto doit; + } + + bfd_error = invalid_operation; + return false; + + doit: + bfd_seek (abfd, asect->rel_filepos, SEEK_SET); + each_size = obj_reloc_entry_size (abfd); + + count = reloc_size / each_size; + + + reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t)(count * sizeof + (arelent))); + if (!reloc_cache) { +nomem: + bfd_error = no_memory; + return false; + } + + relocs = (PTR) bfd_alloc (abfd, reloc_size); + if (!relocs) { + bfd_release (abfd, reloc_cache); + goto nomem; + } + + if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size) { + bfd_release (abfd, relocs); + bfd_release (abfd, reloc_cache); + bfd_error = system_call_error; + return false; + } + + if (each_size == RELOC_EXT_SIZE) { + register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs; + unsigned int counter = 0; + arelent *cache_ptr = reloc_cache; + + for (; counter < count; counter++, rptr++, cache_ptr++) { + NAME(aout,swap_ext_reloc_in)(abfd, rptr, cache_ptr, symbols); + } + } else { + register struct reloc_std_external *rptr = (struct reloc_std_external*) relocs; + unsigned int counter = 0; + arelent *cache_ptr = reloc_cache; + + for (; counter < count; counter++, rptr++, cache_ptr++) { + NAME(aout,swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols); + } + + } + + bfd_release (abfd,relocs); + asect->relocation = reloc_cache; + asect->reloc_count = count; + return true; +} + + + +/* Write out a relocation section into an object file. */ + +boolean +DEFUN(NAME(aout,squirt_out_relocs),(abfd, section), + bfd *abfd AND + asection *section) +{ + arelent **generic; + unsigned char *native, *natptr; + size_t each_size; + + unsigned int count = section->reloc_count; + size_t natsize; + + if (count == 0) return true; + + each_size = obj_reloc_entry_size (abfd); + natsize = each_size * count; + native = (unsigned char *) bfd_zalloc (abfd, natsize); + if (!native) { + bfd_error = no_memory; + return false; + } + + generic = section->orelocation; + + if (each_size == RELOC_EXT_SIZE) + { + for (natptr = native; + count != 0; + --count, natptr += each_size, ++generic) + NAME(aout,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *)natptr); + } + else + { + for (natptr = native; + count != 0; + --count, natptr += each_size, ++generic) + NAME(aout,swap_std_reloc_out)(abfd, *generic, (struct reloc_std_external *)natptr); + } + + if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) { + bfd_release(abfd, native); + return false; + } + bfd_release (abfd, native); + + return true; +} + +/* This is stupid. This function should be a boolean predicate */ +unsigned int +DEFUN(NAME(aout,canonicalize_reloc),(abfd, section, relptr, symbols), + bfd *abfd AND + sec_ptr section AND + arelent **relptr AND + asymbol **symbols) +{ + arelent *tblptr = section->relocation; + unsigned int count; + + if (!(tblptr || NAME(aout,slurp_reloc_table)(abfd, section, symbols))) + return 0; + + if (section->flags & SEC_CONSTRUCTOR) { + arelent_chain *chain = section->constructor_chain; + for (count = 0; count < section->reloc_count; count ++) { + *relptr ++ = &chain->relent; + chain = chain->next; + } + } + else { + tblptr = section->relocation; + if (!tblptr) return 0; + + for (count = 0; count++ < section->reloc_count;) + { + *relptr++ = tblptr++; + } + } + *relptr = 0; + + return section->reloc_count; +} + +unsigned int +DEFUN(NAME(aout,get_reloc_upper_bound),(abfd, asect), + bfd *abfd AND + sec_ptr asect) +{ + if (bfd_get_format (abfd) != bfd_object) { + bfd_error = invalid_operation; + return 0; + } + if (asect->flags & SEC_CONSTRUCTOR) { + return (sizeof (arelent *) * (asect->reloc_count+1)); + } + + + if (asect == obj_datasec (abfd)) + return (sizeof (arelent *) * + ((exec_hdr(abfd)->a_drsize / obj_reloc_entry_size (abfd)) + +1)); + + if (asect == obj_textsec (abfd)) + return (sizeof (arelent *) * + ((exec_hdr(abfd)->a_trsize / obj_reloc_entry_size (abfd)) + +1)); + + bfd_error = invalid_operation; + return 0; +} + + + unsigned int +DEFUN(NAME(aout,get_symtab_upper_bound),(abfd), + bfd *abfd) +{ + if (!NAME(aout,slurp_symbol_table)(abfd)) return 0; + + return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *)); +} + alent * +DEFUN(NAME(aout,get_lineno),(ignore_abfd, ignore_symbol), + bfd *ignore_abfd AND + asymbol *ignore_symbol) +{ +return (alent *)NULL; +} + + +void +DEFUN(NAME(aout,print_symbol),(ignore_abfd, afile, symbol, how), + bfd *ignore_abfd AND + PTR afile AND + asymbol *symbol AND + bfd_print_symbol_enum_type how) +{ + FILE *file = (FILE *)afile; + + switch (how) { + case bfd_print_symbol_name_enum: + fprintf(file,"%s", symbol->name); + break; + case bfd_print_symbol_type_enum: + fprintf(file,"%4x %2x %2x",(unsigned)(aout_symbol(symbol)->desc & 0xffff), + (unsigned)(aout_symbol(symbol)->other & 0xff), + (unsigned)(aout_symbol(symbol)->type)); + 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 %04x %02x %02x %s", + section_name, + (unsigned)(aout_symbol(symbol)->desc & 0xffff), + (unsigned)(aout_symbol(symbol)->other & 0xff), + (unsigned)(aout_symbol(symbol)->type & 0xff), + symbol->name); + } + break; + } +} + +/* + provided a bfd, a section and an offset into the section, calculate + and return the name of the source file and the line nearest to the + wanted location. +*/ + +boolean +DEFUN(NAME(aout,find_nearest_line),(abfd, + section, + symbols, + offset, + filename_ptr, + functionname_ptr, + line_ptr), + bfd *abfd AND + asection *section AND + asymbol **symbols AND + bfd_vma offset AND + CONST char **filename_ptr AND + CONST char **functionname_ptr AND + unsigned int *line_ptr) +{ + /* Run down the file looking for the filename, function and linenumber */ + asymbol **p; + static char buffer[100]; + bfd_vma high_line_vma = ~0; + bfd_vma low_func_vma = 0; + asymbol *func = 0; + *filename_ptr = abfd->filename; + *functionname_ptr = 0; + *line_ptr = 0; + if (symbols != (asymbol **)NULL) { + for (p = symbols; *p; p++) { + aout_symbol_type *q = (aout_symbol_type *)(*p); + switch (q->type){ + case N_SO: + *filename_ptr = q->symbol.name; + if (obj_textsec(abfd) != section) { + return true; + } + break; + case N_SLINE: + + case N_DSLINE: + case N_BSLINE: + /* We'll keep this if it resolves nearer than the one we have already */ + if (q->symbol.value >= offset && + q->symbol.value < high_line_vma) { + *line_ptr = q->desc; + high_line_vma = q->symbol.value; + } + break; + case N_FUN: + { + /* We'll keep this if it is nearer than the one we have already */ + if (q->symbol.value >= low_func_vma && + q->symbol.value <= offset) { + low_func_vma = q->symbol.value; + func = (asymbol *)q; + } + if (*line_ptr && func) { + CONST char *function = func->name; + char *p; + strncpy(buffer, function, sizeof(buffer)-1); + buffer[sizeof(buffer)-1] = 0; + /* Have to remove : stuff */ + p = strchr(buffer,':'); + if (p != NULL) {*p = NULL; } + *functionname_ptr = buffer; + return true; + + } + } + break; + } + } + } + + return true; + +} + +int +DEFUN(NAME(aout,sizeof_headers),(ignore_abfd, execable), + bfd *ignore_abfd AND + boolean execable) +{ + return EXEC_BYTES_SIZE; +} diff --git a/bfd/archive.c b/bfd/archive.c index 3058d33..b417d3b 100644 --- a/bfd/archive.c +++ b/bfd/archive.c @@ -29,7 +29,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ */ -#include "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" #include "ar.h" @@ -169,6 +169,9 @@ get_extended_arelt_filename (arch, name) bfd *arch; char *name; { +#ifndef errno + extern int errno; +#endif unsigned long index = 0; /* Should extract string so that I can guarantee not to overflow into @@ -196,7 +199,10 @@ struct areltdata * snarf_ar_hdr (abfd) bfd *abfd; { - extern int errno; +#ifndef errno + extern int errno; +#endif + struct ar_hdr hdr; char *hdrp = (char *) &hdr; unsigned int parsed_size; @@ -1061,7 +1067,7 @@ compute_and_write_armap (arch, elength) orl_max * sizeof (struct orl)); } - (map[orl_count]).name = &((syms[src_count])->name); + (map[orl_count]).name = (char **) &((syms[src_count])->name); (map[orl_count]).pos = elt_no; (map[orl_count]).namidx = stridx; @@ -2,7 +2,7 @@ /*** bfd -- binary file diddling routines by Gumby Wallace of Cygnus Support. Every definition in this file should be exported and declared - in bfd.c. If you don't want it to be user-visible, put it in + in bfd.h. If you don't want it to be user-visible, put it in libbfd.c! */ @@ -25,7 +25,7 @@ along with BFD; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ */ -#include "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" @@ -81,7 +81,7 @@ bfd_error_vector_type bfd_error_vector = bfd_nonrepresentable_section }; -#if !defined(ANSI_LIBRARIES) +#if 1 || !defined(ANSI_LIBRARIES) && !defined(__STDC__) char * strerror (code) int code; @@ -99,7 +99,9 @@ char * bfd_errmsg (error_tag) bfd_ec error_tag; { - +#ifndef errno + extern int errno; +#endif if (error_tag == system_call_error) return strerror (errno); @@ -206,7 +208,7 @@ bfd_target_list () return name_list; } - + /** Init a bfd for read of the proper format. */ @@ -219,9 +221,9 @@ bfd_target_list () guessing. -- Gumby, 14 Februar 1991*/ boolean -bfd_check_format (abfd, format) - bfd *abfd; - bfd_format format; +DEFUN(bfd_check_format,(abfd, format), + bfd *abfd AND + bfd_format format) { bfd_target **target, *save_targ, *right_targ; int match_count; @@ -285,12 +287,12 @@ bfd_check_format (abfd, format) bfd_error = ((match_count == 0) ? file_not_recognized : file_ambiguously_recognized); return false; -} + } boolean -bfd_set_format (abfd, format) - bfd *abfd; - bfd_format format; +DEFUN(bfd_set_format,(abfd, format), + bfd *abfd AND + bfd_format format) { if (bfd_read_p (abfd) || @@ -332,7 +334,7 @@ DEFUN(bfd_get_section_by_name,(abfd, name), sec_ptr DEFUN(bfd_make_section,(abfd, name), bfd *abfd AND - CONST char *name) + CONST char *CONST name) { asection *newsect; asection ** prev = &abfd->sections; @@ -432,12 +434,12 @@ bfd_set_section_size (abfd, ptr, val) } boolean -bfd_set_section_contents (abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR location; - file_ptr offset; - int count; +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)) { @@ -455,15 +457,15 @@ bfd_set_section_contents (abfd, section, location, offset, count) } boolean -bfd_get_section_contents (abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR location; - file_ptr offset; - int count; +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, count); + memset(location, 0, (unsigned)count); return true; } else { @@ -495,7 +497,7 @@ bfd_core_file_failing_signal (abfd) { if (abfd->format != bfd_core) { bfd_error = invalid_operation; - return NULL; + return 0; } return BFD_SEND (abfd, _core_file_failing_signal, (abfd)); } @@ -566,14 +568,15 @@ asymbol *symbol; { flagword type = symbol->flags; if (symbol->section != (asection *)NULL) - { - fprintf(file,"%08lx ", symbol->value+symbol->section->vma); - } + { + + fprintf_vma(file, symbol->value+symbol->section->vma); + } else - { - fprintf(file,"%08lx ", symbol->value); - } - fprintf(file,"%c%c%c%c%c%c%c", + { + 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' : ' ', @@ -635,16 +638,16 @@ this problem. */ bfd_reloc_status_enum_type -bfd_perform_relocation(abfd, - reloc_entry, - data, - input_section, - output_bfd) -bfd *abfd; -arelent *reloc_entry; -PTR data; -asection *input_section; -bfd *output_bfd; +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; @@ -835,24 +838,24 @@ bfd *output_bfd; { case 0: { - char x = bfd_getchar(abfd, (char *)data + addr); + char x = bfd_get_8(abfd, (char *)data + addr); DOIT(x); - bfd_putchar(abfd,x, (unsigned char *) data + addr); + bfd_put_8(abfd,x, (unsigned char *) data + addr); } break; case 1: { - short x = bfd_getshort(abfd, (bfd_byte *)data + addr); + short x = bfd_get_16(abfd, (bfd_byte *)data + addr); DOIT(x); - bfd_putshort(abfd, x, (unsigned char *)data + addr); + bfd_put_16(abfd, x, (unsigned char *)data + addr); } break; case 2: { - long x = bfd_getlong(abfd, (bfd_byte *) data + addr); + long x = bfd_get_32(abfd, (bfd_byte *) data + addr); DOIT(x); - bfd_putlong(abfd,x, (bfd_byte *)data + addr); + bfd_put_32(abfd,x, (bfd_byte *)data + addr); } break; case 3: diff --git a/bfd/bout.c b/bfd/bout.c new file mode 100644 index 0000000..5e854e0 --- /dev/null +++ b/bfd/bout.c @@ -0,0 +1,754 @@ +/* BFD back-end for i960 b.out binaries */ + +/* Copyright (C) 1990, 1991 Free Software Foundation, Inc. + +This file is part of BFD, the Binary File Diddler. + +BFD is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +BFD is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with BFD; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* $Id$ */ + +#include <sysdep.h> +#include "bfd.h" +#include "libbfd.h" + + +#include "bout.h" + + +#include "stab.gnu.h" +#include "liba.out.h" /* BFD a.out internal data structures */ +#include "archures.h" + +/* Align an address by rounding it up to a power of two. It leaves the + address unchanged if align == 0 (2^0 = alignment of 1 byte) */ +#define i960_align(addr, align) \ + ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) + +extern uint64_type _do_getl64 (), _do_getb64 (); +extern uint32_type _do_getl32 (), _do_getb32 (); +extern uint16_type _do_getl16 (), _do_getb16 (); +extern void _do_putl64 (), _do_putb64 (); +extern void _do_putl32 (), _do_putb32 (); +extern void _do_putl16 (), _do_putb16 (); + + +PROTO (static boolean, b_out_squirt_out_relocs,(bfd *abfd, asection *section)); +PROTO (static bfd_target *, b_out_callback, (bfd *)); + +PROTO (boolean, aout_slurp_symbol_table, (bfd *abfd)); +PROTO (void , aout_write_syms, ()); + +PROTO (static void, swap_exec_header, (bfd *abfd, struct exec *execp)); + +static bfd_target * +b_out_little_object_p (abfd) + bfd *abfd; +{ + unsigned char magicbytes[LONG_SIZE]; + struct exec anexec; + + if (bfd_read ((PTR)magicbytes, 1, LONG_SIZE, abfd) != LONG_SIZE) { + bfd_error = system_call_error; + return 0; + } + anexec.a_magic = _do_getl32 (magicbytes); + + if (N_BADMAG (anexec)) { + bfd_error = wrong_format; + return 0; + } + return some_aout_object_p (abfd, b_out_callback); +} + +static bfd_target * +b_out_big_object_p (abfd) + bfd *abfd; +{ + unsigned char magicbytes[LONG_SIZE]; + struct exec anexec; + + if (bfd_read ((PTR)magicbytes, 1, LONG_SIZE, abfd) != LONG_SIZE) { + bfd_error = system_call_error; + return 0; + } + + anexec.a_magic = _do_getb32 (magicbytes); + + if (N_BADMAG (anexec)) { + bfd_error = wrong_format; + return 0; + } + return some_aout_object_p (abfd, b_out_callback); +} + +/* Finish up the opening of a b.out file for reading. Fill in all the + fields that are not handled by common code. */ + +static bfd_target * +b_out_callback (abfd) + bfd *abfd; +{ + struct exec anexec; + struct exec *execp = &anexec; + unsigned long bss_start; + + /* Reread the exec header, because the common code didn't get all of + our extended header. */ + + if (bfd_seek (abfd, 0L, SEEK_SET) < 0) { + bfd_error = system_call_error; + return 0; + } + + /* FIXME, needs to be hacked for character array read-in ala sunos.c. */ + if (bfd_read ((PTR) execp, 1, sizeof (struct exec), abfd) + != sizeof (struct exec)) { + bfd_error = wrong_format; + return 0; + } + + swap_exec_header (abfd, execp); + + /* Architecture and machine type */ + abfd->obj_arch = bfd_arch_i960; /* B.out only used on i960 */ + abfd->obj_machine = bfd_mach_i960_core; /* Default */ +/* FIXME: Set real machine type from file here */ + + /* The positions of the string table and symbol table. */ + obj_str_filepos (abfd) = N_STROFF (anexec); + obj_sym_filepos (abfd) = N_SYMOFF (anexec); + + /* The alignments of the sections */ + obj_textsec (abfd)->alignment_power = execp->a_talign; + obj_datasec (abfd)->alignment_power = execp->a_dalign; + obj_bsssec (abfd)->alignment_power = execp->a_balign; + + /* The starting addresses of the sections. */ + obj_textsec (abfd)->vma = anexec.a_tload; + obj_datasec (abfd)->vma = anexec.a_dload; + bss_start = anexec.a_dload + anexec.a_data; /* BSS = end of data section */ + obj_bsssec (abfd)->vma = i960_align (bss_start, anexec.a_balign); + + /* The file positions of the sections */ + obj_textsec (abfd)->filepos = N_TXTOFF(anexec); + obj_datasec (abfd)->filepos = N_DATOFF(anexec); + + /* The file positions of the relocation info */ + obj_textsec (abfd)->rel_filepos = N_TROFF(anexec); + obj_datasec (abfd)->rel_filepos = N_DROFF(anexec); + + return abfd->xvec; +} + + +static boolean +b_out_mkobject (abfd) + bfd *abfd; +{ + PTR rawptr; + + bfd_error = system_call_error; + + /* Use an intermediate variable for clarity */ + rawptr = (PTR) zalloc (sizeof (struct aoutdata) + sizeof (struct exec)); + + if (rawptr == (PTR)NULL) { + bfd_error = no_memory; + return false; + } + + set_tdata(abfd, (struct aoutdata *) rawptr); + exec_hdr (abfd) = (struct exec *) ( (char*)rawptr + sizeof (struct aoutdata)); + + /* For simplicity's sake we just make all the sections right here. */ + obj_textsec (abfd) = (asection *)NULL; + obj_datasec (abfd) = (asection *)NULL; + obj_bsssec (abfd) = (asection *)NULL; + + bfd_make_section (abfd, ".text"); + bfd_make_section (abfd, ".data"); + bfd_make_section (abfd, ".bss"); + + return true; +} + +static boolean +b_out_write_object_contents (abfd) + bfd *abfd; +{ + struct exec swapped_hdr; + + exec_hdr (abfd)->a_magic = BMAGIC; + + exec_hdr (abfd)->a_text = obj_textsec (abfd)->size; + exec_hdr (abfd)->a_data = obj_datasec (abfd)->size; + exec_hdr (abfd)->a_bss = obj_bsssec (abfd)->size; + exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd) * sizeof (struct nlist); + exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd); + exec_hdr (abfd)->a_trsize = ((obj_textsec (abfd)->reloc_count) * + sizeof (struct relocation_info)); + exec_hdr (abfd)->a_drsize = ((obj_datasec (abfd)->reloc_count) * + sizeof (struct relocation_info)); + + exec_hdr (abfd)->a_talign = obj_textsec (abfd)->alignment_power; + exec_hdr (abfd)->a_dalign = obj_datasec (abfd)->alignment_power; + exec_hdr (abfd)->a_balign = obj_bsssec (abfd)->alignment_power; + + exec_hdr (abfd)->a_tload = obj_textsec (abfd)->vma; + exec_hdr (abfd)->a_dload = obj_datasec (abfd)->vma; + + /* FIXME, turn the header into bytes here, to avoid problems with + sizes and alignments of its fields. */ + swapped_hdr = *exec_hdr(abfd); + swap_exec_header (abfd, &swapped_hdr); + + bfd_seek (abfd, 0L, SEEK_SET); + bfd_write ((PTR) &swapped_hdr, 1, sizeof (struct exec), abfd); + + /* Now write out reloc info, followed by syms and strings */ + if (bfd_get_symcount (abfd) != 0) + { + bfd_seek (abfd, + (long)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET); + + aout_write_syms (abfd); + + bfd_seek (abfd, (long)(N_TROFF(*exec_hdr(abfd))), SEEK_SET); + + if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd))) return false; + bfd_seek (abfd, (long)(N_DROFF(*exec_hdr(abfd))), SEEK_SET); + + if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd))) return false; + } + return true; +} + +static void +swap_exec_header (abfd, execp) + bfd *abfd; + struct exec *execp; +{ +#define swapme(field) field = bfd_h_get_32 (abfd, (unsigned char *)&field); + swapme (execp->a_magic); + swapme (execp->a_text); + swapme (execp->a_data); + swapme (execp->a_bss); + swapme (execp->a_syms); + swapme (execp->a_entry); + swapme (execp->a_trsize); + swapme (execp->a_drsize); + swapme (execp->a_tload); + swapme (execp->a_dload); + /* talign, dalign, and balign are one-byte fields and don't swap. */ +#undef swapme +} + +/** Some reloc hackery */ + +#define CALLS 0x66003800 /* Template for 'calls' instruction */ +#define BAL 0x0b000000 /* Template for 'bal' instruction */ +#define BAL_MASK 0x00ffffff + +static bfd_reloc_status_enum_type +callj_callback(abfd, reloc_entry, symbol_in, data, input_section) +bfd *abfd; +arelent *reloc_entry; +asymbol *symbol_in; +unsigned char *data; +asection *input_section; +{ + int word = bfd_get_32(abfd, data+reloc_entry->address); + aout_symbol_type *symbol = aout_symbol(symbol_in); + + if (IS_OTHER(symbol->other)) { + /* Call to a system procedure - replace code with system + procedure number + */ + + word = CALLS | (symbol->other - 1); + bfd_put_32(abfd, word, data+reloc_entry->address); /* replace */ + return bfd_reloc_ok; + } + + if (IS_CALLNAME(symbol->other)) { + aout_symbol_type *balsym = symbol+1; + /* The next symbol should be an N_BALNAME */ + BFD_ASSERT(IS_BALNAME(balsym->other)); + + /* We are calling a leaf - so replace the call instruction + with a bal */ + + word = BAL | + (((word & BAL_MASK) + + balsym->symbol.section->output_offset + + balsym->symbol.section->output_section->vma+ + balsym->symbol.value + reloc_entry->addend - + ( input_section->output_section->vma + input_section->output_offset)) + & BAL_MASK); + + bfd_put_32(abfd, word, data+reloc_entry->address); /* replace */ + return bfd_reloc_ok; + } + return bfd_reloc_continue; + +} +/* type rshift size bitsize pcrel bitpos absolute overflow check*/ + + +static reloc_howto_type howto_reloc_callj = +HOWTO( 3, 0, 2, 24, true, 0, true, true, callj_callback,"callj", true, 0x00ffffff, 0x00ffffff,false); +static reloc_howto_type howto_reloc_abs32 = +HOWTO(1, 0, 2, 32, false, 0, true, true,0,"abs32", true, 0xffffffff,0xffffffff,false); +static reloc_howto_type howto_reloc_pcrel24 = +HOWTO(2, 0, 2, 24, true, 0, true, true,0,"pcrel24", true, 0x00ffffff,0x00ffffff,false); + +/* Allocate enough room for all the reloc entries, plus pointers to them all */ + +static boolean +b_out_slurp_reloc_table (abfd, asect, symbols) + bfd *abfd; + sec_ptr asect; + asymbol **symbols; +{ + unsigned int count; + size_t reloc_size; + struct relocation_info *relocs; + arelent *reloc_cache; + + if (asect->relocation) return true; + if (!aout_slurp_symbol_table (abfd)) return false; + + if (asect == obj_datasec (abfd)) { + reloc_size = exec_hdr(abfd)->a_drsize; + goto doit; + } + + if (asect == obj_textsec (abfd)) { + reloc_size = exec_hdr(abfd)->a_trsize; + goto doit; + } + + bfd_error = invalid_operation; + return false; + + doit: + bfd_seek (abfd, (long)(asect->rel_filepos), SEEK_SET); + count = reloc_size / sizeof (struct relocation_info); + + relocs = (struct relocation_info *) malloc (reloc_size); + if (!relocs) { + bfd_error = no_memory; + return false; + } + reloc_cache = (arelent *) malloc ((count+1) * sizeof (arelent)); + if (!reloc_cache) { + free ((char*)relocs); + bfd_error = no_memory; + return false; + } + + if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) { + bfd_error = system_call_error; + free (reloc_cache); + free (relocs); + return false; + } + + { + register struct relocation_info *rptr = relocs; + unsigned int counter = 0; + arelent *cache_ptr = reloc_cache; + int extern_mask, pcrel_mask, callj_mask; + + if (abfd->xvec->header_byteorder_big_p) { + /* Big-endian bit field allocation order */ + pcrel_mask = 0x80; + extern_mask = 0x10; + callj_mask = 0x02; + } else { + /* Little-endian bit field allocation order */ + pcrel_mask = 0x01; + extern_mask = 0x08; + callj_mask = 0x40; + } + + for (; counter < count; counter++, rptr++, cache_ptr++) + { + unsigned char *raw = (unsigned char *)rptr; + unsigned int symnum; + cache_ptr->address = bfd_h_get_32 (abfd, raw + 0); + if (abfd->xvec->header_byteorder_big_p) { + symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6]; + } else { + symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4]; + } + + if (raw[7] & extern_mask) { + /* If this is set then the r_index is a index into the symbol table; + * if the bit is not set then r_index contains a section map. + * We either fill in the sym entry with a pointer to the symbol, + * or point to the correct section + */ + cache_ptr->sym_ptr_ptr = symbols + symnum; + cache_ptr->addend = 0; + cache_ptr->section = (asection*)NULL; + } else { + /* In a.out symbols are relative to the beginning of the + * file rather than sections ? + * (look in translate_from_native_sym_flags) + * The reloc entry addend has added to it the offset into the + * file of the data, so subtract the base to make the reloc + * section relative */ + cache_ptr->sym_ptr_ptr = (asymbol **)NULL; + switch (symnum) { + case N_TEXT: + case N_TEXT | N_EXT: + cache_ptr->section = obj_textsec(abfd); + cache_ptr->addend = -obj_textsec(abfd)->vma; + break; + case N_DATA: + case N_DATA | N_EXT: + cache_ptr->section = obj_datasec(abfd); + cache_ptr->addend = - obj_datasec(abfd)->vma; + break; + case N_BSS: + case N_BSS | N_EXT: + cache_ptr->section = obj_bsssec(abfd); + cache_ptr->addend = - obj_bsssec(abfd)->vma; + break; + case N_ABS: + case N_ABS | N_EXT: + BFD_ASSERT(0); + break; + default: + BFD_ASSERT(0); + break; + } + + } + + /* The i960 only has a few relocation types: + abs 32-bit and pcrel 24bit. Except for callj's! */ + if (raw[7] & callj_mask) + cache_ptr->howto = &howto_reloc_callj; + else if ( raw[7] & pcrel_mask) + cache_ptr->howto = &howto_reloc_pcrel24; + else + cache_ptr->howto = &howto_reloc_abs32; + } + } + + free (relocs); + asect->relocation = reloc_cache; + asect->reloc_count = count; + return true; +} + + +static boolean +b_out_squirt_out_relocs (abfd, section) + bfd *abfd; + asection *section; +{ + arelent **generic; + + unsigned int count = section->reloc_count; + struct relocation_info *native, *natptr; + size_t natsize = count * sizeof (struct relocation_info); + int extern_mask, pcrel_mask, len_2, callj_mask; + if (count == 0) return true; + generic = section->orelocation; + native = ((struct relocation_info *) malloc (natsize)); + if (!native) { + bfd_error = no_memory; + return false; + } + + if (abfd->xvec->header_byteorder_big_p) { + /* Big-endian bit field allocation order */ + pcrel_mask = 0x80; + extern_mask = 0x10; + len_2 = 0x40; + callj_mask = 0x02; + } else { + /* Little-endian bit field allocation order */ + pcrel_mask = 0x01; + extern_mask = 0x08; + len_2 = 0x04; + callj_mask = 0x40; + } + + for (natptr = native; count > 0; --count, ++natptr, ++generic) + { + arelent *g = *generic; + unsigned char *raw = (unsigned char *)natptr; + unsigned int symnum; + + bfd_h_put_32(abfd, g->address, raw); + /* Find a type in the output format which matches the input howto - + * at the moment we assume input format == output format FIXME!! + */ + /* FIXME: Need callj stuff here, and to check the howto entries to + be sure they are real for this architecture. */ + if (g->howto== &howto_reloc_callj) { + raw[7] = callj_mask + pcrel_mask + len_2; + } + else if (g->howto == &howto_reloc_pcrel24) { + raw[7] = pcrel_mask +len_2; + } + else { + raw[7] = len_2; + } + if (g->sym_ptr_ptr != (asymbol **)NULL) + { + /* name clobbered by aout_write_syms to be symbol index*/ + if ((*(g->sym_ptr_ptr))->section) { + /* replace the section offset into the addent */ + g->addend += (*(g->sym_ptr_ptr))->section->vma ; + } + symnum = stoi((*(g->sym_ptr_ptr))->name); + raw[7] |= extern_mask; + BFD_ASSERT(g->addend == 0); + } + else { + if (g->section == (asection *)NULL) { + symnum = N_ABS; + BFD_ASSERT(0); + } + else if(g->section->output_section == obj_textsec(abfd)) { + symnum = N_TEXT; + BFD_ASSERT(g->addend == 0); + } + else if (g->section->output_section == obj_datasec(abfd)) { + symnum = N_DATA; + BFD_ASSERT(g->addend + obj_textsec(abfd)->size == 0); + } + else if (g->section->output_section == obj_bsssec(abfd)) { + symnum = N_BSS; + BFD_ASSERT(g->addend + obj_textsec(abfd)->size + + obj_datasec(abfd)->size == 0); + + } + else { + BFD_ASSERT(0); + } + } + if (abfd->xvec->header_byteorder_big_p) { + raw[4] = (unsigned char) (symnum >> 16); + raw[5] = (unsigned char) (symnum >> 8); + raw[6] = (unsigned char) (symnum ); + } else { + raw[6] = (unsigned char) (symnum >> 16); + raw[5] = (unsigned char) (symnum >> 8); + raw[4] = (unsigned char) (symnum ); + } + } + + if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) { + free((PTR)native); + return false; + } + free ((PTR)native); + + return true; +} + +/* This is stupid. This function should be a boolean predicate */ +static unsigned int +b_out_canonicalize_reloc (abfd, section, relptr, symbols) + bfd *abfd; + sec_ptr section; + arelent **relptr; + asymbol **symbols; +{ + arelent *tblptr = section->relocation; + unsigned int count = 0; + + if (!(tblptr || b_out_slurp_reloc_table (abfd, section, symbols))) return 0; + tblptr = section->relocation; + if (!tblptr) return 0; + + for (; count++ < section->reloc_count;) + *relptr++ = tblptr++; + + *relptr = 0; + + return section->reloc_count; +} + +static unsigned int +b_out_get_reloc_upper_bound (abfd, asect) + bfd *abfd; + sec_ptr asect; +{ + if (bfd_get_format (abfd) != bfd_object) { + bfd_error = invalid_operation; + return 0; + } + + if (asect == obj_datasec (abfd)) + return (sizeof (arelent *) * + ((exec_hdr(abfd)->a_drsize / sizeof (struct relocation_info)) + +1)); + + if (asect == obj_textsec (abfd)) + return (sizeof (arelent *) * + ((exec_hdr(abfd)->a_trsize / sizeof (struct relocation_info)) + +1)); + + bfd_error = invalid_operation; + return 0; +} + +static boolean +b_out_set_section_contents (abfd, section, location, offset, count) + bfd *abfd; + sec_ptr section; + unsigned char *location; + file_ptr offset; + int count; +{ + if (abfd->output_has_begun == false) { /* set by bfd.c handler */ + if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL) /*|| + (obj_textsec (abfd)->size == 0) || (obj_datasec (abfd)->size == 0)*/) { + bfd_error = invalid_operation; + return false; + } + + obj_textsec (abfd)->filepos = sizeof(struct exec); + obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos + + obj_textsec (abfd)->size; + + } + /* regardless, once we know what we're doing, we might as well get going */ + bfd_seek (abfd, section->filepos + offset, SEEK_SET); + + if (count != 0) { + return (bfd_write ((PTR)location, 1, count, abfd) == count) ?true:false; + } + return false; +} + +static boolean +b_out_set_arch_mach (abfd, arch, machine) + bfd *abfd; + enum bfd_architecture arch; + unsigned long machine; +{ + abfd->obj_arch = arch; + abfd->obj_machine = machine; + if (arch == bfd_arch_unknown) /* Unknown machine arch is OK */ + return true; + if (arch == bfd_arch_i960) /* i960 default is OK */ + switch (machine) { + case bfd_mach_i960_core: + case bfd_mach_i960_kb_sb: + case bfd_mach_i960_mc: + case bfd_mach_i960_xa: + case bfd_mach_i960_ca: + case bfd_mach_i960_ka_sa: + return true; + default: + return false; + } + + return false; +} + +static int +DEFUN(b_out_sizeof_headers,(abfd, exec), + bfd *abfd AND + boolean execable) +{ +return sizeof(struct exec); +} + +/* Build the transfer vectors for Big and Little-Endian B.OUT files. */ + +/* We don't have core files. */ +#define aout_core_file_failing_command _bfd_dummy_core_file_failing_command +#define aout_core_file_failing_signal _bfd_dummy_core_file_failing_signal +#define aout_core_file_matches_executable_p \ + _bfd_dummy_core_file_matches_executable_p + +/* We use BSD-Unix generic archive files. */ +#define aout_openr_next_archived_file bfd_generic_openr_next_archived_file +#define aout_generic_stat_arch_elt bfd_generic_stat_arch_elt +#define aout_slurp_armap bfd_slurp_bsd_armap +#define aout_slurp_extended_name_table bfd_true +#define aout_write_armap bsd_write_armap +#define aout_truncate_arname bfd_bsd_truncate_arname + +/* We override these routines from the usual a.out file routines. */ +#define aout_canonicalize_reloc b_out_canonicalize_reloc +#define aout_get_reloc_upper_bound b_out_get_reloc_upper_bound +#define aout_set_section_contents b_out_set_section_contents +#define aout_set_arch_mach b_out_set_arch_mach +#define aout_sizeof_headers b_out_sizeof_headers + + +bfd_target b_out_vec_big_host = +{ + "b.out.big", /* name */ + bfd_target_aout_flavour_enum, + false, /* data byte order is little */ + true, /* hdr byte order is big */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT ), + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + + +_do_getl64, _do_putl64, _do_getl32, _do_putl32, _do_getl16, _do_putl16, /* data */ +_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */ + {_bfd_dummy_target, b_out_big_object_p, /* bfd_check_format */ + bfd_generic_archive_p, _bfd_dummy_target}, + {bfd_false, b_out_mkobject, /* bfd_set_format */ + _bfd_generic_mkarchive, bfd_false}, + {bfd_false, b_out_write_object_contents, /* bfd_write_contents */ + _bfd_write_archive_contents, bfd_false}, + + JUMP_TABLE(aout) +}; + + +bfd_target b_out_vec_little_host = +{ + "b.out.little", /* name */ + bfd_target_aout_flavour_enum, + false, /* data byte order is little */ + false, /* header byte order is little */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT ), + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + +_do_getl64, _do_putl64, _do_getl32, _do_putl32, _do_getl16, _do_putl16, /* data */ +_do_getl64, _do_putl64, _do_getl32, _do_putl32, _do_getl16, _do_putl16, /* hdrs */ + + {_bfd_dummy_target, b_out_little_object_p, /* bfd_check_format */ + bfd_generic_archive_p, _bfd_dummy_target}, + {bfd_false, b_out_mkobject, /* bfd_set_format */ + _bfd_generic_mkarchive, bfd_false}, + {bfd_false, b_out_write_object_contents, /* bfd_write_contents */ + _bfd_write_archive_contents, bfd_false}, + JUMP_TABLE(aout) +}; + diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c index a0b04be..23fd039 100644 --- a/bfd/coff-i960.c +++ b/bfd/coff-i960.c @@ -24,7 +24,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define BADMAG(x) I960BADMAG(x) #include <ansidecl.h> - +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" #include "obstack.h" @@ -141,7 +141,7 @@ static reloc_howto_type howto_table[] = /* The real code is in coff-code.h */ -#include "coff-code.h" +#include "coffcode.h" bfd_target icoff_little_vec = { diff --git a/bfd/coff-mips.c b/bfd/coff-mips.c index 362be56..abfea6a 100644 --- a/bfd/coff-mips.c +++ b/bfd/coff-mips.c @@ -23,10 +23,13 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ able to test it there either since the latest merge!). So it stays out by default. */ +#include <sysdep.h> #define MIPS 1 +#if 0 + #include <stdio.h> #include <string.h> - +#endif #include "bfd.h" #include "libbfd.h" @@ -36,7 +39,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define BADMAG(x) ECOFFBADMAG(x) -#include "coff-code.h" +#include "coffcode.h" bfd_target ecoff_little_vec = {"ecoff-littlemips", /* name */ bfd_target_coff_flavour_enum, diff --git a/bfd/host-aout.c b/bfd/host-aout.c index aaf9e6f..3d50ea49 100644 --- a/bfd/host-aout.c +++ b/bfd/host-aout.c @@ -19,7 +19,7 @@ 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" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" @@ -22,8 +22,8 @@ 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 "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" #include "ieee.h" @@ -1042,7 +1042,7 @@ DEFUN(ieee_print_symbol,(ignore_abfd, afile, symbol, how), } -static boolean +static void DEFUN(do_one,(ieee, current_map, location_ptr,s), ieee_data_type *ieee AND ieee_per_section_type *current_map AND @@ -1126,14 +1126,14 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), case 4: if (pcrel == true) { - bfd_putlong(ieee->abfd, -current_map->pc, location_ptr + + bfd_put_32(ieee->abfd, -current_map->pc, location_ptr + current_map->pc); r->relent.howto = &rel32_howto; r->relent.addend -= current_map->pc; } else { - bfd_putlong(ieee->abfd, 0, location_ptr + + bfd_put_32(ieee->abfd, 0, location_ptr + current_map->pc); r->relent.howto = &abs32_howto; } @@ -1141,12 +1141,12 @@ DEFUN(do_one,(ieee, current_map, location_ptr,s), break; case 2: if (pcrel == true) { - bfd_putshort(ieee->abfd, (int)(-current_map->pc), location_ptr +current_map->pc); + bfd_put_16(ieee->abfd, (int)(-current_map->pc), location_ptr +current_map->pc); r->relent.addend -= current_map->pc; r->relent.howto = &rel16_howto; } else { - bfd_putshort(ieee->abfd, 0, location_ptr +current_map->pc); + bfd_put_16(ieee->abfd, 0, location_ptr +current_map->pc); r->relent.howto = &abs16_howto; } current_map->pc +=2; @@ -1315,11 +1315,11 @@ DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count), sec_ptr section AND PTR location AND file_ptr offset AND - int count) + bfd_size_type count) { ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; ieee_slurp_section_data(abfd); - (void) memcpy(location, p->data + offset, count); + (void) memcpy(location, p->data + offset, (unsigned)count); return true; } @@ -1453,7 +1453,7 @@ DEFUN(ieee_write_data_part,(abfd), bfd_byte *stream = ieee_per_section(s)->data; arelent **p = s->orelocation; unsigned int relocs_to_go = s->reloc_count; - size_t current_byte_index = 0; + bfd_size_type current_byte_index = 0; /* Sort the reloc records so we can insert them in the correct places */ @@ -1486,7 +1486,7 @@ DEFUN(ieee_write_data_part,(abfd), memset((PTR)stream, 0, s->size); } while (current_byte_index < s->size) { - size_t run; + bfd_size_type run; unsigned int MAXRUN = 32; if (relocs_to_go) { run = (*p)->address - current_byte_index; @@ -1520,12 +1520,12 @@ DEFUN(ieee_write_data_part,(abfd), switch (r->howto->size) { case 2: - ov = bfd_getlong(abfd, + ov = bfd_get_32(abfd, stream+current_byte_index); current_byte_index +=4; break; case 1: - ov = bfd_getshort(abfd, + ov = bfd_get_16(abfd, stream+current_byte_index); current_byte_index +=2; break; @@ -1588,12 +1588,14 @@ DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count), sec_ptr section AND PTR location AND file_ptr offset AND - int count) + bfd_size_type count) { if (ieee_per_section(section)->data == (bfd_byte *)NULL) { init_for_output(abfd); } - (void) memcpy(ieee_per_section(section)->data + offset, location, count); + (void) memcpy(ieee_per_section(section)->data + offset, + location, + (unsigned int)count); return true; } @@ -1861,9 +1863,8 @@ bfd_target ieee_vec = |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ +_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, ieee_object_p, /* bfd_check_format */ diff --git a/bfd/libbfd.c b/bfd/libbfd.c index ec6a223..f703dfd 100644 --- a/bfd/libbfd.c +++ b/bfd/libbfd.c @@ -19,7 +19,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ */ /*** libbfd.c -- random bfd support routines used internally only. */ -#include "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" @@ -117,7 +117,7 @@ char * zalloc (size) bfd_size_type size; { - char *ptr = (char *) malloc (size); + char *ptr = (char *) malloc ((int)size); if ((ptr != NULL) && (size != 0)) memset(ptr,0, size); @@ -136,31 +136,40 @@ zalloc (size) contents (0 for non-archive elements). For archive entries this is the first octet in the file, NOT the beginning of the archive header. */ +static +int DEFUN(real_read,(where, a,b, file), + PTR where AND + int a AND + int b AND + FILE *file) +{ + return fread(where, a,b,file); +} bfd_size_type -bfd_read (ptr, size, nitems, abfd) - PTR ptr; - bfd_size_type size; - bfd_size_type nitems; - bfd *abfd; +DEFUN(bfd_read,(ptr, size, nitems, abfd), + PTR ptr AND + bfd_size_type size AND + bfd_size_type nitems AND + bfd *abfd) { - return fread (ptr, 1, size*nitems, bfd_cache_lookup(abfd)); + return (bfd_size_type)real_read (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd)); } bfd_size_type -bfd_write (ptr, size, nitems, abfd) - PTR ptr; - bfd_size_type size; - bfd_size_type nitems; - bfd *abfd; +DEFUN(bfd_write,(ptr, size, nitems, abfd), + PTR ptr AND + bfd_size_type size AND + bfd_size_type nitems AND + bfd *abfd) { - return fwrite (ptr, 1, size*nitems, bfd_cache_lookup(abfd)); + return fwrite (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd)); } int -bfd_seek (abfd, position, direction) -bfd * CONST abfd; -CONST file_ptr position; -CONST int direction; +DEFUN(bfd_seek,(abfd, position, direction), + bfd * CONST abfd AND + 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 @@ -258,22 +267,22 @@ bfd_add_to_string_table (table, new_string, table_length, free_ptr) functions in swap.h #ifdef __GNUC__. Gprof them later and find out. */ -short -_do_getbshort (addr) +unsigned int +_do_getb16 (addr) register bfd_byte *addr; { return (addr[0] << 8) | addr[1]; } -short -_do_getlshort (addr) +unsigned int +_do_getl16 (addr) register bfd_byte *addr; { return (addr[1] << 8) | addr[0]; } void -_do_putbshort (data, addr) +_do_putb16 (data, addr) int data; /* Actually short, but ansi C sucks */ register bfd_byte *addr; { @@ -282,7 +291,7 @@ _do_putbshort (data, addr) } void -_do_putlshort (data, addr) +_do_putl16 (data, addr) int data; /* Actually short, but ansi C sucks */ register bfd_byte *addr; { @@ -290,22 +299,67 @@ _do_putlshort (data, addr) addr[1] = (bfd_byte)(data >> 8); } -long -_do_getblong (addr) +unsigned int +_do_getb32 (addr) register bfd_byte *addr; { return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3]; } -long -_do_getllong (addr) +unsigned int +_do_getl32 (addr) register bfd_byte *addr; { return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0]; } +bfd_64_type +_do_getb64(addr) + register bfd_byte *addr; +{ + bfd_64_type low, high; +#ifdef __GNUC__ + high= ((((((((addr[0]) << 8) | + addr[1]) << 8) | + addr[2]) << 8) | + addr[3]) ); + + low = ((((((((addr[4]) << 8) | + addr[5]) << 8) | + addr[6]) << 8) | + addr[7])); + + return high << 32 | low; +#else + BFD_FAIL(); +#endif + +} + +bfd_64_type +_do_getl64 (addr) + register bfd_byte *addr; +{ + bfd_64_type low, high; +#ifdef __GNUC__ + high= (((((((addr[7] << 8) | + addr[6]) << 8) | + addr[5]) << 8) | + addr[4])); + + low = (((((((addr[3] << 8) | + addr[2]) << 8) | + addr[1]) << 8) | + addr[0]) ); + + return high << 32 | low; +#else + BFD_FAIL(); +#endif +} + void -_do_putblong (data, addr) +_do_putb32 (data, addr) unsigned long data; register bfd_byte *addr; { @@ -316,7 +370,7 @@ _do_putblong (data, addr) } void -_do_putllong (data, addr) +_do_putl32 (data, addr) unsigned long data; register bfd_byte *addr; { @@ -325,22 +379,62 @@ _do_putllong (data, addr) addr[2] = (bfd_byte)(data >> 16); addr[3] = (bfd_byte)(data >> 24); } +void +_do_putb64 (data, addr) + bfd_64_type data; + register bfd_byte *addr; +{ +#ifdef __GNUC__ + addr[0] = (bfd_byte)(data >> (7*8)); + addr[1] = (bfd_byte)(data >> (6*8)); + addr[2] = (bfd_byte)(data >> (5*8)); + addr[3] = (bfd_byte)(data >> (4*8)); + addr[4] = (bfd_byte)(data >> (3*8)); + addr[5] = (bfd_byte)(data >> (2*8)); + addr[6] = (bfd_byte)(data >> (1*8)); + addr[7] = (bfd_byte)(data >> (0*8)); +#else +BFD_FAIL(); +#endif + +} + +void +_do_putl64 (data, addr) + bfd_64_type data; + register bfd_byte *addr; +{ +#ifdef __GNUC__ + addr[7] = (bfd_byte)(data >> (7*8)); + addr[6] = (bfd_byte)(data >> (6*8)); + addr[5] = (bfd_byte)(data >> (5*8)); + addr[4] = (bfd_byte)(data >> (4*8)); + addr[3] = (bfd_byte)(data >> (3*8)); + addr[2] = (bfd_byte)(data >> (2*8)); + addr[1] = (bfd_byte)(data >> (1*8)); + addr[0] = (bfd_byte)(data >> (0*8)); +#else + BFD_FAIL(); +#endif + +} + /* Default implementation */ boolean -bfd_generic_get_section_contents (abfd, section, location, offset, count) - bfd *abfd; - sec_ptr section; - PTR location; - file_ptr offset; - int count; +DEFUN(bfd_generic_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 (count == 0) return true; - if (offset >= section->size - || bfd_seek(abfd, section->filepos + offset, SEEK_SET) == -1 - || bfd_read(location, 1, count, abfd) != count) + 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 */ return (true); } diff --git a/bfd/libbfd.h b/bfd/libbfd.h index 8949689..97aef7f 100644 --- a/bfd/libbfd.h +++ b/bfd/libbfd.h @@ -90,15 +90,18 @@ PROTO (bfd *, new_bfd, ()); PROTO (boolean, bfd_add_to_string_table, (char **table, char *new_string, unsigned int *table_length, char **free_ptr)); - -PROTO (long, _do_getblong, (unsigned char *addr)); -PROTO (long, _do_getllong, (unsigned char *addr)); -PROTO (short, _do_getbshort, (unsigned char *addr)); -PROTO (short, _do_getlshort, (unsigned char *addr)); -PROTO (void, _do_putblong, (unsigned long data, unsigned char *addr)); -PROTO (void, _do_putllong, (unsigned long data, unsigned char *addr)); -PROTO (void, _do_putbshort, (int data, unsigned char *addr)); -PROTO (void, _do_putlshort, (int data, unsigned char *addr)); +PROTO (bfd_64_type, _do_getb64, (unsigned char *addr)); +PROTO (bfd_64_type, _do_getl64, (unsigned char *addr)); +PROTO (unsigned int, _do_getb32, (unsigned char *addr)); +PROTO (unsigned int, _do_getl32, (unsigned char *addr)); +PROTO (unsigned int, _do_getb16, (unsigned char *addr)); +PROTO (unsigned int, _do_getl16, (unsigned char *addr)); +PROTO (void, _do_putb64, (bfd_64_type data, unsigned char *addr)); +PROTO (void, _do_putl64, (bfd_64_type data, unsigned char *addr)); +PROTO (void, _do_putb32, (unsigned long data, unsigned char *addr)); +PROTO (void, _do_putl32, (unsigned long data, unsigned char *addr)); +PROTO (void, _do_putb16, (int data, unsigned char *addr)); +PROTO (void, _do_putl16, (int data, unsigned char *addr)); PROTO (boolean, bfd_false, (bfd *ignore)); PROTO (boolean, bfd_true, (bfd *ignore)); @@ -134,7 +137,7 @@ PROTO (bfd *, bfd_generic_openr_next_archived_file, (bfd *archive, PROTO(int, bfd_generic_stat_arch_elt, (bfd *, struct stat *)); PROTO(boolean, bfd_generic_get_section_contents, - (bfd *abfd, sec_ptr section, PTR location, file_ptr offset, int count)); + (bfd *abfd, sec_ptr section, PTR location, file_ptr offset, bfd_size_type count)); /* Macros to tell if bfds are read or write enabled. diff --git a/bfd/newsos3.c b/bfd/newsos3.c index 146f76a..b509792 100644 --- a/bfd/newsos3.c +++ b/bfd/newsos3.c @@ -20,10 +20,20 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define TARGET_BYTE_ORDER_BIG_P 1 +#define PAGE_SIZE 4096 +#define SEGMENT_SIZE PAGE_SIZE +#define TEXT_START_ADDR 0 +#define ARCH 32 +#define BYTES_IN_WORD 4 + #include <ansidecl.h> -#include "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" +#include "aout64.h" +#include "stab.gnu.h" +#include "ar.h" +#include "liba.out.h" /* BFD a.out internal data structures */ int vfprintf(file, format, args) /* Temporary crock! */ FILE *file; char *format; char *args; @@ -31,20 +41,13 @@ int vfprintf(file, format, args) /* Temporary crock! */ return _doprnt (format, args, file); } -#define PAGE_SIZE 4096 -#define SEGMENT_SIZE 0x2000 /* FIXME, is this right?? */ -#define TEXT_START_ADDR PAGE_SIZE -#include "a.out.gnu.h" -#include "stab.gnu.h" -#include "ar.h" -#include "liba.out.h" /* BFD a.out internal data structures */ bfd_target *newsos3_callback (); bfd_target * -newsos3_object_p (abfd) - bfd *abfd; +DEFUN(newsos3_object_p,(abfd), + bfd *abfd) { unsigned char magicbuf[LONG_SIZE]; /* Raw bytes of magic number from file */ unsigned long magic; /* Swapped magic number */ @@ -54,37 +57,22 @@ newsos3_object_p (abfd) if (bfd_read ((PTR)magicbuf, 1, sizeof (magicbuf), abfd) != sizeof (magicbuf)) return 0; - magic = bfd_h_getlong (abfd, magicbuf); + magic = bfd_h_get_32 (abfd, magicbuf); - if (N_BADMAG (*((struct exec *) &magic))) return 0; + if (N_BADMAG (*((struct internal_exec *) &magic))) return 0; - return some_aout_object_p (abfd, newsos3_callback); + return aout_32_some_aout_object_p (abfd, newsos3_callback); } /* Finish up the reading of a NEWS-OS a.out file header */ bfd_target * -newsos3_callback (abfd) - bfd *abfd; +DEFUN(newsos3_callback,(abfd), + bfd *abfd) { - struct exec *execp = exec_hdr (abfd); - - /* The virtual memory addresses of the sections */ - obj_datasec (abfd)->vma = N_DATADDR(*execp); - obj_bsssec (abfd)->vma = N_BSSADDR(*execp); - obj_textsec (abfd)->vma = N_TXTADDR(*execp); - - /* The file offsets of the sections */ - obj_textsec (abfd)->filepos = N_TXTOFF(*execp); - obj_datasec (abfd)->filepos = N_DATOFF(*execp); - - /* The file offsets of the relocation info */ - obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp); - obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp); - - /* The file offsets of the string table and symbol table. */ - obj_str_filepos (abfd) = N_STROFF (*execp); - obj_sym_filepos (abfd) = N_SYMOFF (*execp); - + struct internal_exec *execp = exec_hdr (abfd); + + WORK_OUT_FILE_POSITIONS(abfd, execp) ; + /* Determine the architecture and machine type of the object file. */ abfd->obj_arch = bfd_arch_m68k; abfd->obj_machine = 0; @@ -97,85 +85,33 @@ newsos3_callback (abfd) file header, symbols, and relocation. */ boolean -newsos3_write_object_contents (abfd) - bfd *abfd; +DEFUN(newsos3_write_object_contents,(abfd), + bfd *abfd) { - size_t data_pad = 0; - unsigned char exec_bytes[EXEC_BYTES_SIZE]; - struct exec *execp = exec_hdr (abfd); - - execp->a_text = obj_textsec (abfd)->size; - - if (abfd->flags & D_PAGED) - execp->a_info = ZMAGIC; - else if (abfd->flags & WP_TEXT) - execp->a_info = NMAGIC; - else - execp->a_info = OMAGIC; - - if (abfd->flags & D_PAGED) - { - data_pad = ((obj_datasec(abfd)->size + PAGE_SIZE -1) - & (- PAGE_SIZE)) - obj_datasec(abfd)->size; - - if (data_pad > obj_bsssec(abfd)->size) - execp->a_bss = 0; - else - execp->a_bss = obj_bsssec(abfd)->size - data_pad; - execp->a_data = obj_datasec(abfd)->size + data_pad; - - } - else { - execp->a_data = obj_datasec (abfd)->size; - execp->a_bss = obj_bsssec (abfd)->size; - } - - execp->a_syms = bfd_get_symcount (abfd) * sizeof (struct nlist); - execp->a_entry = bfd_get_start_address (abfd); - - execp->a_trsize = ((obj_textsec (abfd)->reloc_count) * - obj_reloc_entry_size (abfd)); - - execp->a_drsize = ((obj_datasec (abfd)->reloc_count) * - obj_reloc_entry_size (abfd)); - - bfd_aout_swap_exec_header_out (abfd, execp, exec_bytes); - - bfd_seek (abfd, 0L, false); - bfd_write ((PTR) exec_bytes, 1, EXEC_BYTES_SIZE, abfd); - - /* Now write out reloc info, followed by syms and strings */ - - if (bfd_get_symcount (abfd) != 0) - { - bfd_seek (abfd, (long)(N_SYMOFF(*execp)), false); - aout_write_syms (abfd); - - bfd_seek (abfd, (long)(N_TRELOFF(*execp)), false); - if (!aout_squirt_out_relocs (abfd, obj_textsec (abfd))) return false; - - bfd_seek (abfd, (long)(N_DRELOFF(*execp)), false); - if (!aout_squirt_out_relocs (abfd, obj_datasec (abfd))) return false; - } + bfd_size_type data_pad = 0; + struct external_exec exec_bytes; + struct internal_exec *execp = exec_hdr (abfd); + + WRITE_HEADERS(abfd, execp); return true; } /* Transfer vectors for NEWS-OS version 3 */ /* We use BFD generic archive files. */ -#define aout_openr_next_archived_file bfd_generic_openr_next_archived_file -#define aout_generic_stat_arch_elt bfd_generic_stat_arch_elt -#define aout_slurp_armap bfd_slurp_bsd_armap -#define aout_slurp_extended_name_table bfd_true -#define aout_write_armap bsd_write_armap -#define aout_truncate_arname bfd_bsd_truncate_arname +#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 /* We don't support core files yet. FIXME. */ -#define aout_core_file_failing_command _bfd_dummy_core_file_failing_command -#define aout_core_file_failing_signal _bfd_dummy_core_file_failing_signal -#define aout_core_file_matches_executable_p \ +#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 \ _bfd_dummy_core_file_matches_executable_p -#define aout_core_file_p _bfd_dummy_target +#define aout_32_core_file_p _bfd_dummy_target /* We define our own versions of these routines. */ @@ -193,15 +129,15 @@ bfd_target newsos3_vec = /* Sony 68k-based machines running newos3 */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ + _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_core_file_p}, - {bfd_false, aout_mkobject, /* bfd_set_format */ - _bfd_generic_mkarchive, bfd_false}, - {bfd_false, newsos3_write_object_contents, /* bfd_write_contents */ - _bfd_write_archive_contents, bfd_false}, + {_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_mkarchive, bfd_false}, + {bfd_false, newsos3_write_object_contents, /* bfd_write_contents */ + _bfd_write_archive_contents, bfd_false}, - JUMP_TABLE(aout) -}; + JUMP_TABLE(aout_32) + }; diff --git a/bfd/oasys.c b/bfd/oasys.c index d9f48db..ff24148 100644 --- a/bfd/oasys.c +++ b/bfd/oasys.c @@ -24,8 +24,8 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define UNDERSCORE_HACK 1 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier) #include <ansidecl.h> +#include <sysdep.h> -#include "sysdep.h" #include "bfd.h" #include "libbfd.h" #include "oasys.h" @@ -134,7 +134,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd), } break; case RELOCATION_TYPE_UND: - dest = data->symbols + bfd_h_getshort(abfd, (bfd_byte *)&record.symbol.refno[0]); + dest = data->symbols + bfd_h_get_16(abfd, (bfd_byte *)&record.symbol.refno[0]); dest->section = (asection *)NULL; dest->flags = BSF_UNDEFINED; break; @@ -150,7 +150,7 @@ DEFUN(oasys_slurp_symbol_table,(abfd), dest->name = string_ptr; dest->the_bfd = abfd; dest->udata = (PTR)NULL; - dest->value = bfd_h_getlong(abfd, &record.symbol.value[0]); + dest->value = bfd_h_get_32(abfd, &record.symbol.value[0]); #ifdef UNDERSCORE_HACK if (record.symbol.name[0] != '_') { @@ -223,14 +223,14 @@ DEFUN(oasys_archive_p,(abfd), bfd_read((PTR)&header_ext, 1, sizeof(header_ext), abfd); - header.version = bfd_h_get_x(abfd, header_ext.version); - header.mod_count = bfd_h_get_x(abfd, header_ext.mod_count); - header.mod_tbl_offset = bfd_h_get_x(abfd, header_ext.mod_tbl_offset); - header.sym_tbl_size = bfd_h_get_x(abfd, header_ext.sym_tbl_size); - header.sym_count = bfd_h_get_x(abfd, header_ext.sym_count); - header.sym_tbl_offset = bfd_h_get_x(abfd, header_ext.sym_tbl_offset); - header.xref_count = bfd_h_get_x(abfd, header_ext.xref_count); - header.xref_lst_offset = bfd_h_get_x(abfd, header_ext.xref_lst_offset); + header.version = bfd_h_get_32(abfd, header_ext.version); + header.mod_count = bfd_h_get_32(abfd, header_ext.mod_count); + header.mod_tbl_offset = bfd_h_get_32(abfd, header_ext.mod_tbl_offset); + header.sym_tbl_size = bfd_h_get_32(abfd, header_ext.sym_tbl_size); + header.sym_count = bfd_h_get_32(abfd, header_ext.sym_count); + header.sym_tbl_offset = bfd_h_get_32(abfd, header_ext.sym_tbl_offset); + header.xref_count = bfd_h_get_32(abfd, header_ext.xref_count); + header.xref_lst_offset = bfd_h_get_32(abfd, header_ext.xref_lst_offset); /* There isn't a magic number in an Oasys archive, so the best we @@ -267,9 +267,9 @@ DEFUN(oasys_archive_p,(abfd), for (i = 0; i < header.mod_count; i++) { bfd_read((PTR)&record_ext, 1, sizeof(record_ext), abfd); - record.mod_size = bfd_h_get_x(abfd, record_ext.mod_size); - record.file_offset = bfd_h_get_x(abfd, record_ext.file_offset); - record.mod_name_length = bfd_h_get_x(abfd, record_ext.mod_name_length); + 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_name_length = bfd_h_get_32(abfd, record_ext.mod_name_length); module[i].name = bfd_alloc(abfd,record.mod_name_length+1); @@ -361,8 +361,8 @@ DEFUN(oasys_object_p,(abfd), BFD_FAIL(); } - s->size = bfd_h_getlong(abfd, & record.section.value[0]) ; - s->vma = bfd_h_getlong(abfd, &record.section.vma[0]); + 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; had_usefull = true; } @@ -484,7 +484,7 @@ DEFUN(oasys_slurp_section_data,(abfd), data->sections[record.data.relb & RELOCATION_SECT_BITS]; bfd_vma dst_offset ; per = oasys_per_section(section); - dst_offset = bfd_h_getlong(abfd, record.data.addr) ; + dst_offset = bfd_h_get_32(abfd, record.data.addr) ; if (per->had_vma == false) { /* Take the first vma we see as the base */ @@ -658,11 +658,11 @@ DEFUN(oasys_get_section_contents,(abfd, section, location, offset, count), sec_ptr section AND PTR location AND file_ptr offset AND - int count) + bfd_size_type 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, count); + (void) memcpy(location, p->data + offset, (int)count); return true; } @@ -750,17 +750,17 @@ DEFUN(oasys_write_syms, (abfd), if (g->flags & BSF_FORT_COMM) { symbol.relb = RELOCATION_TYPE_COM; - bfd_h_putshort(abfd, index, (uint8e_type *)(&symbol.refno[0])); + bfd_h_put_16(abfd, index, (uint8e_type *)(&symbol.refno[0])); index++; } else if (g->flags & BSF_ABSOLUTE) { symbol.relb = RELOCATION_TYPE_ABS; - bfd_h_putshort(abfd, 0, (uint8e_type *)(&symbol.refno[0])); + bfd_h_put_16(abfd, 0, (uint8e_type *)(&symbol.refno[0])); } else if (g->flags & BSF_UNDEFINED) { symbol.relb = RELOCATION_TYPE_UND ; - bfd_h_putshort(abfd, index, (uint8e_type *)(&symbol.refno[0])); + bfd_h_put_16(abfd, index, (uint8e_type *)(&symbol.refno[0])); /* Overload the value field with the output index number */ index++; } @@ -770,14 +770,14 @@ DEFUN(oasys_write_syms, (abfd), } else { symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index; - bfd_h_putshort(abfd, 0, (uint8e_type *)(&symbol.refno[0])); + bfd_h_put_16(abfd, 0, (uint8e_type *)(&symbol.refno[0])); } while (src[l]) { dst[l] = src[l]; l++; } - bfd_h_putlong(abfd, g->value, symbol.value); + bfd_h_put_32(abfd, g->value, symbol.value); if (g->flags & BSF_LOCAL) { @@ -812,8 +812,8 @@ DEFUN(oasys_write_sections, (abfd), s->name); } out.relb = RELOCATION_TYPE_REL | s->target_index; - bfd_h_putlong(abfd, s->size, out.value); - bfd_h_putlong(abfd, s->vma, out.vma); + bfd_h_put_32(abfd, s->size, out.value); + bfd_h_put_32(abfd, s->vma, out.vma); oasys_write_record(abfd, oasys_record_is_section_enum, @@ -858,8 +858,8 @@ DEFUN(oasys_write_end,(abfd), oasys_end_record_type end; uint8e_type null = 0; end.relb = RELOCATION_TYPE_ABS; - bfd_h_putlong(abfd, abfd->start_address, end.entry); - bfd_h_putshort(abfd, 0, end.fill); + bfd_h_put_32(abfd, abfd->start_address, end.entry); + bfd_h_put_16(abfd, 0, end.fill); end.zero =0; oasys_write_record(abfd, oasys_record_is_end_enum, @@ -890,7 +890,7 @@ DEFUN(oasys_write_data, (abfd), 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; - unsigned int current_byte_index = 0; + bfd_size_type current_byte_index = 0; unsigned int relocs_to_go = s->reloc_count; arelent **p = s->orelocation; if (s->reloc_count != 0) { @@ -905,7 +905,7 @@ DEFUN(oasys_write_data, (abfd), current_byte_index = 0; processed_data.relb = s->target_index | RELOCATION_TYPE_REL; - while ((size_t)current_byte_index < s->size) + 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 */ @@ -916,7 +916,7 @@ DEFUN(oasys_write_data, (abfd), unsigned int long_length = 128; - bfd_h_putlong(abfd, s->vma + current_byte_index, processed_data.addr); + 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; } @@ -944,14 +944,14 @@ DEFUN(oasys_write_data, (abfd), /* Also patch the raw data so that it doesn't have the -ve stuff any more */ if (how->size != 2) { - bfd_putshort(abfd, - bfd_getshort(abfd,raw_data) + + bfd_put_16(abfd, + bfd_get_16(abfd,raw_data) + current_byte_index, raw_data); } else { - bfd_putlong(abfd, - bfd_getlong(abfd,raw_data) + + bfd_put_32(abfd, + bfd_get_32(abfd,raw_data) + current_byte_index, raw_data); } } @@ -1050,7 +1050,7 @@ DEFUN(oasys_set_section_contents,(abfd, section, location, offset, count), sec_ptr section AND PTR location AND file_ptr offset AND - int count) + bfd_size_type count) { if (count != 0) { if (oasys_per_section(section)->data == (bfd_byte *)NULL ) @@ -1196,25 +1196,25 @@ bfd_target oasys_vec = ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ + _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, - oasys_object_p, /* bfd_check_format */ - oasys_archive_p, - _bfd_dummy_target, + {_bfd_dummy_target, + oasys_object_p, /* bfd_check_format */ + oasys_archive_p, + _bfd_dummy_target, }, - { /* bfd_set_format */ - bfd_false, - oasys_mkobject, - _bfd_generic_mkarchive, - bfd_false + { /* bfd_set_format */ + bfd_false, + oasys_mkobject, + _bfd_generic_mkarchive, + bfd_false + }, + { /* bfd_write_contents */ + bfd_false, + oasys_write_object_contents, + _bfd_write_archive_contents, + bfd_false, }, - { /* bfd_write_contents */ - bfd_false, - oasys_write_object_contents, - _bfd_write_archive_contents, - bfd_false, - }, JUMP_TABLE(oasys) -}; + }; diff --git a/bfd/opncls.c b/bfd/opncls.c index 65687e6..fdd7f4b 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -20,7 +20,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* $Id$ */ -#include "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" @@ -64,7 +64,7 @@ bfd *new_bfd() if (!nbfd) return 0; - obstack_begin(&nbfd->memory, 128); + obstack_begin((PTR)&nbfd->memory, 128); nbfd->direction = no_direction; nbfd->iostream = NULL; @@ -271,6 +271,16 @@ bfd_close (abfd) && abfd->flags & EXEC_P) { struct stat buf; stat(abfd->filename, &buf); +#ifndef S_IXUSR +#define S_IXUSR 0100 /* Execute by owner. */ +#endif +#ifndef S_IXGRP +#define S_IXGRP 0010 /* Execute by group. */ +#endif +#ifndef S_IXOTH +#define S_IXOTH 0001 /* Execute by others. */ +#endif + chmod(abfd->filename,buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH); } (void) obstack_free (&abfd->memory, (PTR)0); @@ -301,12 +311,18 @@ DEFUN(bfd_create,(filename, template), /* Memory allocation */ +DEFUN(PTR bfd_alloc_by_size_t,(abfd, size), + bfd *abfd AND + size_t size) +{ + PTR res = obstack_alloc(&(abfd->memory), size); + return res; +} DEFUN(PTR bfd_alloc, (abfd, size), bfd *abfd AND bfd_size_type size) { - PTR res = obstack_alloc(&(abfd->memory), (int)size); - return res; + return bfd_alloc_by_size_t(abfd, (size_t)size); } DEFUN(PTR bfd_zalloc,(abfd, size), @@ -40,54 +40,8 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ */ -/* $Id$ - * $Log$ - * Revision 1.8 1991/05/11 00:38:46 gnu - * Cleanups of interface, including close_and_cleanup and write_contents - * transfer vector changes. See ChangeLog. - * - * Revision 1.7 1991/05/08 19:21:47 steve - * Various portability lints. - * Fixed reloc bug in ieee and oasys. - * - * Revision 1.6 1991/04/25 04:06:21 gnu - * Fix minor pointer type problems that "cc" complains about. - * - * Revision 1.5 1991/04/23 22:44:14 steve - * *** empty log message *** - * - * Revision 1.4 1991/04/23 16:01:02 steve - * *** empty log message *** - * - * Revision 1.3 1991/04/08 23:22:31 steve - * *** empty log message *** - * - * Revision 1.2 1991/04/03 22:10:51 steve - * Fixed typo - * - * Revision 1.1.1.1 1991/03/21 21:11:22 gumby - * Back from Intel with Steve - * - * Revision 1.1 1991/03/21 21:11:20 gumby - * Initial revision - * - * Revision 1.1 1991/03/13 00:22:29 chrisb - * Initial revision - * - * Revision 1.3 1991/03/10 19:11:40 rich - * Modified Files: - * bfd.c coff-code.h libbfd.c libbfd.h srec.c sunos.c - * - * Working bugs out of coff support. - * - * Revision 1.2 1991/03/07 02:26:18 sac - * Tidied up xfer table - * - * Revision 1.1 1991/03/05 16:28:12 sac - * Initial revision - * - */ -#include "sysdep.h" + +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" @@ -403,28 +357,30 @@ srec_write_object_contents (abfd) bfd *abfd; { bfd_write("S9030000FC\n", 1,11,abfd); + return true; } static int -DEFUN(srec_sizeof_headers,(abfd), - bfd *abfd) +DEFUN(srec_sizeof_headers,(abfd, exec), + bfd *abfd AND + boolean exec) { return 0; } /*SUPPRESS 460 */ -#define srec_new_section_hook bfd_false +#define srec_new_section_hook (PROTO(boolean, (*), (bfd *, asection *)))bfd_false #define srec_get_symtab_upper_bound bfd_false -#define srec_get_symtab bfd_false -#define srec_get_reloc_upper_bound bfd_false -#define srec_canonicalize_reloc bfd_false -#define srec_make_empty_symbol bfd_false -#define srec_print_symbol 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_make_empty_symbol (PROTO(asymbol *,(*),(bfd*))) bfd_nullvoidptr +#define srec_print_symbol (PROTO(void,(*),(bfd *, PTR, asymbol *, bfd_print_symbol_enum_type))) bfd_void -#define srec_openr_next_archived_file bfd_false -#define srec_find_nearest_line bfd_false -#define srec_generic_stat_arch_elt bfd_false +#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_core_file_failing_command (char *(*)())(bfd_nullvoidptr) @@ -452,25 +408,25 @@ bfd_target srec_vec = |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ - _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ - - {_bfd_dummy_target, - srec_object_p, /* bfd_check_format */ - (struct bfd_target *(*)()) bfd_nullvoidptr, - (struct bfd_target *(*)()) bfd_nullvoidptr, - }, - { - bfd_false, - bfd_true, /* mkobject */ - _bfd_generic_mkarchive, - bfd_false, - }, - { /* bfd_write_contents */ - bfd_false, - srec_write_object_contents, - _bfd_write_archive_contents, - bfd_false, - }, + _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, + srec_object_p, /* bfd_check_format */ + (struct bfd_target *(*)()) bfd_nullvoidptr, + (struct bfd_target *(*)()) bfd_nullvoidptr, + }, + { + bfd_false, + bfd_true, /* mkobject */ + _bfd_generic_mkarchive, + bfd_false, + }, + { /* bfd_write_contents */ + bfd_false, + srec_write_object_contents, + _bfd_write_archive_contents, + bfd_false, + }, JUMP_TABLE(srec) -}; + }; diff --git a/bfd/targets.c b/bfd/targets.c index bbcdd51..2036d5b 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -22,13 +22,14 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* This -*- C -*- source file will someday be machine-generated */ /*** Defines the target vector through which operations dispatch */ -#include "sysdep.h" +#include <sysdep.h> #include "bfd.h" #include "libbfd.h" extern bfd_target ecoff_little_vec; extern bfd_target ecoff_big_vec; extern bfd_target sunos_big_vec; +extern bfd_target demo_64_vec; extern bfd_target srec_vec; extern bfd_target b_out_vec_little_host; extern bfd_target b_out_vec_big_host; @@ -51,9 +52,10 @@ extern bfd_target m68kcoff_vec; #define ECOFF_BIG_VEC ecoff_big_vec #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 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 @@ -88,6 +90,13 @@ bfd_target *target_vector[] = { &SUNOS_VEC_BIG_HOST, #endif /* SUNOS_BIG_VEC */ + +#ifdef HOST_64_BIT +#ifdef DEMO_64_VEC + &DEMO_64_VEC, +#endif +#endif + #ifdef M88K_BCS_VEC &M88K_BCS_VEC, #endif /* M88K_BCS_VEC */ diff --git a/bfd/trad-core.c b/bfd/trad-core.c index dadfd14..2d5155f 100644 --- a/bfd/trad-core.c +++ b/bfd/trad-core.c @@ -3,7 +3,7 @@ /* This file does not define a particular back-end, but it defines routines that can be used by other back-ends. */ - +#include <sysdep.h> #include "bfd.h" #include <stdio.h> #include "libbfd.h" @@ -37,6 +37,7 @@ struct core_data { asection *reg_section; }; +/* ARGSUSED */ bfd_target * trad_unix_core_file_p (abfd) bfd *abfd; @@ -144,13 +145,15 @@ trad_unix_core_file_failing_command (abfd) return 0; } +/* ARGSUSED */ int -trad_unix_core_file_failing_signal (abfd) - bfd *abfd; +trad_unix_core_file_failing_signal (ignore_abfd) + bfd *ignore_abfd; { return -1; /* FIXME, where is it? */ } +/* ARGSUSED */ boolean trad_unix_core_file_matches_executable_p (core_bfd, exec_bfd) bfd *core_bfd, *exec_bfd; diff --git a/binutils/copy.c b/binutils/copy.c index a11ddec..7d4e4e3 100644 --- a/binutils/copy.c +++ b/binutils/copy.c @@ -1,6 +1,6 @@ /*** copy.c -- copy object file from input to output, optionally massaging it */ - +#include <sysdep.h> #include "bfd.h" diff --git a/include/bfd.h b/include/bfd.h index 8d50c43..3879d9f 100644 --- a/include/bfd.h +++ b/include/bfd.h @@ -29,7 +29,6 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define __BFD_H_SEEN__ #include "ansidecl.h" -#include "sysdep.h" #include "obstack.h" /* Make it easier to declare prototypes (puts conditional here) */ @@ -57,17 +56,18 @@ typedef long int file_ptr; /* Support for different sizes of target format ints */ -#ifdef TARGET_64_BIT -/* 64 bit machines use these items */ -typedef uint64_type rawdata_offset; -typedef uint64_type bfd_vma; -typedef uint64_type bfd_word; -typedef uint64_type bfd_offset; -typedef uint64_type bfd_size_type; -typedef uint64_type symvalue; +#ifdef HOST_64_BIT +typedef HOST_64_BIT rawdata_offset; +typedef HOST_64_BIT bfd_vma; +typedef HOST_64_BIT bfd_word; +typedef HOST_64_BIT bfd_offset; +typedef HOST_64_BIT bfd_size_type; +typedef HOST_64_BIT symvalue; +typedef HOST_64_BIT bfd_64_type; #define printf_vma(x) printf("%08x%08x",uint64_typeHIGH(x), uint64_typeLOW(x)) #define fprintf_vma(s,x) fprintf(s,"%08x%08x",uint64_typeHIGH(x), uint64_typeLOW(x)) #else +typedef struct { int a,b;} bfd_64_type; typedef unsigned long int rawdata_offset; typedef unsigned long bfd_vma; typedef unsigned long bfd_offset; @@ -356,7 +356,7 @@ typedef struct sec file_ptr filepos; /* File position of section data */ file_ptr rel_filepos; /* File position of relocation info */ file_ptr line_filepos; - struct user_section *userdata; + PTR *userdata; struct lang_output_section *otheruserdata; int index; /* Which section is it 0..nth */ alent *lineno; @@ -484,19 +484,19 @@ typedef struct bfd_target /* Byte swapping for data */ /* Note that these don't take bfd as first arg. Certain other handlers could do the same. */ - SDEF (uint64_type,bfd_getx64, (bfd_byte *)); - SDEF (void, bfd_putx64, (uint64_type, bfd_byte *)); - SDEF (uint32_type, bfd_getx32, (bfd_byte *)); + 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 (uint16_type, bfd_getx16, (bfd_byte *)); + SDEF (unsigned int, bfd_getx16, (bfd_byte *)); SDEF (void, bfd_putx16, (int, bfd_byte *)); /* Byte swapping for headers */ - SDEF (uint64_type, bfd_h_getx64, (bfd_byte *)); - SDEF (void, bfd_h_putx64, (uint64_type, bfd_byte *)); - SDEF (uint32_type, bfd_h_getx32, (bfd_byte *)); + 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 (uint16_type, bfd_h_getx16, (bfd_byte *)); + SDEF (unsigned int, bfd_h_getx16, (bfd_byte *)); SDEF (void, bfd_h_putx16, (int, bfd_byte *)); /* Format-dependent */ diff --git a/ld/config/hmake-sun4-64 b/ld/config/hmake-sun4-64 index 8d8e68e..92f74ad 100755 --- a/ld/config/hmake-sun4-64 +++ b/ld/config/hmake-sun4-64 @@ -1,6 +1,6 @@ -HDEFINES=-DHOST_SYS=SUN4_SYS -DTARGET_64_BIT +HDEFINES=-DHOST_SYS=SUN4_SYS -DHOST_64_BIT="long long" YACC=yacc -tvd -CC=/usr/local/bin/gcc -Wall -ansi +CC=/usr/latest/bin/gcc -Wall -ansi #stuff for self hosting HOSTING_CRT0=/lib/crt0.o HOSTING_LIBS=/limbo/latest/=sun4/lib/gcc/sparc/1.93/gnulib -lc |