Browse Source
bfd/ * Makefile.am: Remove sparc-aout and sparc-coff support. * config.bfd: Likewise. * configure.ac: Likewise. * targets.c: Likewise. * aout-sparcle.c: Delete. * aoutf1.h: Delete. * cf-sparclynx.c: Delete. * coff-sparc.c: Delete. * demo64.c: Delete. * sparclinux.c: Delete. * sparclynx.c: Delete. * sparcnetbsd.c: Delete. * sunos.c: Delete. * Makefile.in: Regenerate. * configure: Regenerate. * po/SRC-POTFILES.in: Regenerate. binutils/ * testsuite/lib/binutils-common.exp: Remove sparc-aout and sparc-coff support. gas/ * Makefile.am: Remove sparc-aout and sparc-coff support. * config/obj-coff.h: Likewise. * config/tc-sparc.c: Likewise. * config/tc-sparc.h: Likewise. * configure.tgt: Likewise. * config/te-sparcaout.h: Delete. * testsuite/gas/sun4/addend.d: Delete. * testsuite/gas/sun4/addend.exp: Delete. * testsuite/gas/sun4/addend.s: Delete. * Makefile.in: Regenerate. * po/POTFILES.in: Regenerate. ld/ * Makefile.am: Remove sparc-aout and sparc-coff support. * configure.tgt: Likewise. * testsuite/ld-elfvers/vers.exp: Likewise. * testsuite/ld-elfvsb/elfvsb.exp: Likewise. * testsuite/ld-elfweak/elfweak.exp: Likewise. * testsuite/ld-shared/shared.exp: Likewise. * emulparams/coff_sparc.sh: Delete. * emulparams/sparcaout.sh: Delete. * emulparams/sparclinux.sh: Delete. * emulparams/sparcnbsd.sh: Delete. * emulparams/sun4.sh: Delete. * scripttempl/sparccoff.sc: Delete. * Makefile.in: Regenerate. * po/BLD-POTFILES.in: Regenerate.binutils-2_31-branch
Alan Modra
8 years ago
46 changed files with 104 additions and 5662 deletions
@ -1,37 +0,0 @@ |
|||
/* BFD backend for sparc little-endian aout binaries.
|
|||
Copyright (C) 1996-2018 Free Software Foundation, Inc. |
|||
Written by Cygnus Support. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ |
|||
|
|||
#define TARGETNAME "a.out-sparc-little" |
|||
|
|||
/* Do not "beautify" the CONCAT* macro args. Traditional C will not
|
|||
remove whitespace added here, and thus will fail to concatenate |
|||
the tokens. */ |
|||
#define MY(OP) CONCAT2 (sparc_aout_le_,OP) |
|||
|
|||
#include "sysdep.h" |
|||
#include "bfd.h" |
|||
#include "bfdlink.h" |
|||
#include "libaout.h" |
|||
|
|||
#define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_SPARCLET) |
|||
|
|||
/* Include the usual a.out support. */ |
|||
#define TARGET_IS_LITTLE_ENDIAN_P |
|||
#include "aoutf1.h" |
|||
@ -1,747 +0,0 @@ |
|||
/* A.out "format 1" file handling code for BFD.
|
|||
Copyright (C) 1990-2018 Free Software Foundation, Inc. |
|||
Written by Cygnus Support. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
#include "sysdep.h" |
|||
#include "bfd.h" |
|||
#include "libbfd.h" |
|||
|
|||
#include "aout/sun4.h" |
|||
#include "libaout.h" /* BFD a.out internal data structures. */ |
|||
|
|||
#include "aout/aout64.h" |
|||
#include "aout/stab_gnu.h" |
|||
#include "aout/ar.h" |
|||
|
|||
/* This is needed to reject a NewsOS file, e.g. in
|
|||
gdb/testsuite/gdb.t10/crossload.exp. <kingdon@cygnus.com> |
|||
I needed to add M_UNKNOWN to recognize a 68000 object, so this will |
|||
probably no longer reject a NewsOS object. <ian@cygnus.com>. */ |
|||
#ifndef MACHTYPE_OK |
|||
#define MACHTYPE_OK(mtype) \ |
|||
((mtype) == M_SPARC && bfd_lookup_arch (bfd_arch_sparc, 0) != NULL) |
|||
#endif |
|||
|
|||
/* The file @code{aoutf1.h} contains the code for BFD's
|
|||
a.out back end. Control over the generated back end is given by these |
|||
two preprocessor names: |
|||
@table @code |
|||
@item ARCH_SIZE |
|||
This value should be either 32 or 64, depending upon the size of an |
|||
int in the target format. It changes the sizes of the structs which |
|||
perform the memory/disk mapping of structures. |
|||
|
|||
The 64 bit backend may only be used if the host compiler supports 64 |
|||
ints (eg long long with gcc), by defining the name @code{BFD_HOST_64_BIT} in @code{bfd.h}. |
|||
With this name defined, @emph{all} bfd operations are performed with 64bit |
|||
arithmetic, not just those to a 64bit target. |
|||
|
|||
@item TARGETNAME |
|||
The name put into the target vector. |
|||
@item |
|||
@end table. */ |
|||
|
|||
#if ARCH_SIZE == 64 |
|||
#define sunos_set_arch_mach sunos_64_set_arch_mach |
|||
#define sunos_write_object_contents aout_64_sunos4_write_object_contents |
|||
#else |
|||
#define sunos_set_arch_mach sunos_32_set_arch_mach |
|||
#define sunos_write_object_contents aout_32_sunos4_write_object_contents |
|||
#endif |
|||
|
|||
/* Merge backend data into the output file.
|
|||
This is necessary on sparclet-aout where we want the resultant machine |
|||
number to be M_SPARCLET if any input file is M_SPARCLET. */ |
|||
|
|||
#define MY_bfd_merge_private_bfd_data sunos_merge_private_bfd_data |
|||
|
|||
static bfd_boolean |
|||
sunos_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) |
|||
{ |
|||
bfd *obfd = info->output_bfd; |
|||
if (bfd_get_flavour (ibfd) != bfd_target_aout_flavour |
|||
|| bfd_get_flavour (obfd) != bfd_target_aout_flavour) |
|||
return TRUE; |
|||
|
|||
if (bfd_get_arch (obfd) == bfd_arch_sparc) |
|||
{ |
|||
if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) |
|||
bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); |
|||
} |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
/* This is either sunos_32_set_arch_mach or sunos_64_set_arch_mach,
|
|||
depending upon ARCH_SIZE. */ |
|||
|
|||
static void |
|||
sunos_set_arch_mach (bfd *abfd, enum machine_type machtype) |
|||
{ |
|||
/* Determine the architecture and machine type of the object file. */ |
|||
enum bfd_architecture arch; |
|||
unsigned long machine; |
|||
|
|||
switch (machtype) |
|||
{ |
|||
case M_SPARC: |
|||
arch = bfd_arch_sparc; |
|||
machine = 0; |
|||
break; |
|||
|
|||
case M_SPARCLET: |
|||
arch = bfd_arch_sparc; |
|||
machine = bfd_mach_sparc_sparclet; |
|||
break; |
|||
|
|||
case M_SPARCLITE_LE: |
|||
arch = bfd_arch_sparc; |
|||
machine = bfd_mach_sparc_sparclite_le; |
|||
break; |
|||
|
|||
case M_386: |
|||
case M_386_DYNIX: |
|||
arch = bfd_arch_i386; |
|||
machine = 0; |
|||
break; |
|||
|
|||
default: |
|||
arch = bfd_arch_obscure; |
|||
machine = 0; |
|||
break; |
|||
} |
|||
bfd_set_arch_mach (abfd, arch, machine); |
|||
} |
|||
|
|||
#define SET_ARCH_MACH(ABFD, EXECP) \ |
|||
NAME(sunos,set_arch_mach) (ABFD, N_MACHTYPE (EXECP)); \ |
|||
choose_reloc_size(ABFD); |
|||
|
|||
/* Determine the size of a relocation entry, based on the architecture. */ |
|||
|
|||
static void |
|||
choose_reloc_size (bfd *abfd) |
|||
{ |
|||
switch (bfd_get_arch (abfd)) |
|||
{ |
|||
case bfd_arch_sparc: |
|||
obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; |
|||
break; |
|||
default: |
|||
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
/* Write an object file in SunOS format. Section contents have
|
|||
already been written. We write the file header, symbols, and |
|||
relocation. The real name of this function is either |
|||
aout_64_sunos4_write_object_contents or |
|||
aout_32_sunos4_write_object_contents, depending upon ARCH_SIZE. */ |
|||
|
|||
static bfd_boolean |
|||
sunos_write_object_contents (bfd *abfd) |
|||
{ |
|||
struct external_exec exec_bytes; |
|||
struct internal_exec *execp = exec_hdr (abfd); |
|||
|
|||
/* Magic number, maestro, please! */ |
|||
switch (bfd_get_arch (abfd)) |
|||
{ |
|||
case bfd_arch_sparc: |
|||
switch (bfd_get_mach (abfd)) |
|||
{ |
|||
case bfd_mach_sparc_sparclet: |
|||
N_SET_MACHTYPE (execp, M_SPARCLET); |
|||
break; |
|||
case bfd_mach_sparc_sparclite_le: |
|||
N_SET_MACHTYPE (execp, M_SPARCLITE_LE); |
|||
break; |
|||
default: |
|||
N_SET_MACHTYPE (execp, M_SPARC); |
|||
break; |
|||
} |
|||
break; |
|||
case bfd_arch_i386: |
|||
N_SET_MACHTYPE (execp, M_386); |
|||
break; |
|||
default: |
|||
N_SET_MACHTYPE (execp, M_UNKNOWN); |
|||
} |
|||
|
|||
choose_reloc_size (abfd); |
|||
|
|||
N_SET_FLAGS (execp, aout_backend_info (abfd)->exec_hdr_flags); |
|||
|
|||
N_SET_DYNAMIC (execp, (long)(bfd_get_file_flags (abfd) & DYNAMIC)); |
|||
|
|||
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 external_sparc_core |
|||
{ |
|||
int c_magic; /* Corefile magic number. */ |
|||
int c_len; /* Sizeof (struct core). */ |
|||
#define SPARC_CORE_LEN 432 |
|||
struct regs c_regs; /* General purpose registers -- MACHDEP SIZE. */ |
|||
struct external_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. */ |
|||
}; |
|||
|
|||
/* Core files generated by the BCP (the part of Solaris which allows
|
|||
it to run SunOS4 a.out files). */ |
|||
struct external_solaris_bcp_core |
|||
{ |
|||
int c_magic; /* Corefile magic number. */ |
|||
int c_len; /* Sizeof (struct core). */ |
|||
#define SOLARIS_BCP_CORE_LEN 456 |
|||
struct regs c_regs; /* General purpose registers -- MACHDEP SIZE. */ |
|||
int c_exdata_vp; /* Exdata structure. */ |
|||
int c_exdata_tsize; |
|||
int c_exdata_dsize; |
|||
int c_exdata_bsize; |
|||
int c_exdata_lsize; |
|||
int c_exdata_nshlibs; |
|||
short c_exdata_mach; |
|||
short c_exdata_mag; |
|||
int c_exdata_toffset; |
|||
int c_exdata_doffset; |
|||
int c_exdata_loffset; |
|||
int c_exdata_txtorg; |
|||
int c_exdata_datorg; |
|||
int c_exdata_entloc; |
|||
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. */ |
|||
}; |
|||
|
|||
struct external_sun3_core |
|||
{ |
|||
int c_magic; /* Corefile magic number. */ |
|||
int c_len; /* Sizeof (struct core). */ |
|||
#define SUN3_CORE_LEN 826 /* As of SunOS 4.1.1. */ |
|||
int c_regs[18]; /* General purpose registers -- MACHDEP SIZE. */ |
|||
struct external_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. */ |
|||
}; |
|||
|
|||
struct internal_sunos_core |
|||
{ |
|||
int c_magic; /* Corefile magic number. */ |
|||
int c_len; /* Sizeof (struct core). */ |
|||
long c_regs_pos; /* File offset of General purpose registers. */ |
|||
int c_regs_size; /* Size of General purpose registers. */ |
|||
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). */ |
|||
bfd_vma c_data_addr; /* Data start (address). */ |
|||
int c_ssize; /* Stack size (bytes). */ |
|||
bfd_vma c_stacktop; /* Stack top (address). */ |
|||
char c_cmdname[CORE_NAMELEN + 1]; /* Command name. */ |
|||
long fp_stuff_pos; /* File offset of external FPU state (regs). */ |
|||
int fp_stuff_size; /* Size of it. */ |
|||
int c_ucode; /* Exception no. from u_code. */ |
|||
}; |
|||
|
|||
/* Byte-swap in the Sun-3 core structure. */ |
|||
|
|||
static void |
|||
swapcore_sun3 (bfd *abfd, char *ext, struct internal_sunos_core *intcore) |
|||
{ |
|||
struct external_sun3_core *extcore = (struct external_sun3_core *) ext; |
|||
|
|||
intcore->c_magic = H_GET_32 (abfd, &extcore->c_magic); |
|||
intcore->c_len = H_GET_32 (abfd, &extcore->c_len); |
|||
intcore->c_regs_pos = offsetof (struct external_sun3_core, c_regs); |
|||
intcore->c_regs_size = sizeof (extcore->c_regs); |
|||
#if ARCH_SIZE == 64 |
|||
aout_64_swap_exec_header_in |
|||
#else |
|||
aout_32_swap_exec_header_in |
|||
#endif |
|||
(abfd, &extcore->c_aouthdr, &intcore->c_aouthdr); |
|||
intcore->c_signo = H_GET_32 (abfd, &extcore->c_signo); |
|||
intcore->c_tsize = H_GET_32 (abfd, &extcore->c_tsize); |
|||
intcore->c_dsize = H_GET_32 (abfd, &extcore->c_dsize); |
|||
intcore->c_data_addr = N_DATADDR (&intcore->c_aouthdr); |
|||
intcore->c_ssize = H_GET_32 (abfd, &extcore->c_ssize); |
|||
memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); |
|||
intcore->fp_stuff_pos = offsetof (struct external_sun3_core, fp_stuff); |
|||
/* FP stuff takes up whole rest of struct, except c_ucode. */ |
|||
intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - |
|||
offsetof (struct external_sun3_core, fp_stuff); |
|||
/* Ucode is the last thing in the struct -- just before the end. */ |
|||
intcore->c_ucode = H_GET_32 (abfd, |
|||
(intcore->c_len |
|||
- sizeof (extcore->c_ucode) |
|||
+ (unsigned char *) extcore)); |
|||
intcore->c_stacktop = 0x0E000000; /* By experimentation. */ |
|||
} |
|||
|
|||
/* Byte-swap in the Sparc core structure. */ |
|||
|
|||
static void |
|||
swapcore_sparc (bfd *abfd, char *ext, struct internal_sunos_core *intcore) |
|||
{ |
|||
struct external_sparc_core *extcore = (struct external_sparc_core *) ext; |
|||
|
|||
intcore->c_magic = H_GET_32 (abfd, &extcore->c_magic); |
|||
intcore->c_len = H_GET_32 (abfd, &extcore->c_len); |
|||
intcore->c_regs_pos = offsetof (struct external_sparc_core, c_regs); |
|||
intcore->c_regs_size = sizeof (extcore->c_regs); |
|||
#if ARCH_SIZE == 64 |
|||
aout_64_swap_exec_header_in |
|||
#else |
|||
aout_32_swap_exec_header_in |
|||
#endif |
|||
(abfd, &extcore->c_aouthdr, &intcore->c_aouthdr); |
|||
intcore->c_signo = H_GET_32 (abfd, &extcore->c_signo); |
|||
intcore->c_tsize = H_GET_32 (abfd, &extcore->c_tsize); |
|||
intcore->c_dsize = H_GET_32 (abfd, &extcore->c_dsize); |
|||
intcore->c_data_addr = N_DATADDR (&intcore->c_aouthdr); |
|||
intcore->c_ssize = H_GET_32 (abfd, &extcore->c_ssize); |
|||
memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); |
|||
intcore->fp_stuff_pos = offsetof (struct external_sparc_core, fp_stuff); |
|||
/* FP stuff takes up whole rest of struct, except c_ucode. */ |
|||
intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - |
|||
offsetof (struct external_sparc_core, fp_stuff); |
|||
/* Ucode is the last thing in the struct -- just before the end. */ |
|||
intcore->c_ucode = H_GET_32 (abfd, |
|||
(intcore->c_len |
|||
- sizeof (extcore->c_ucode) |
|||
+ (unsigned char *) extcore)); |
|||
|
|||
/* Supposedly the user stack grows downward from the bottom of kernel memory.
|
|||
Presuming that this remains true, this definition will work. */ |
|||
/* Now sun has provided us with another challenge. The value is different
|
|||
for sparc2 and sparc10 (both running SunOS 4.1.3). We pick one or |
|||
the other based on the current value of the stack pointer. This |
|||
loses (a) if the stack pointer has been clobbered, or (b) if the stack |
|||
is larger than 128 megabytes. |
|||
|
|||
It's times like these you're glad they're switching to ELF. |
|||
|
|||
Note that using include files or nlist on /vmunix would be wrong, |
|||
because we want the value for this core file, no matter what kind of |
|||
machine we were compiled on or are running on. */ |
|||
#define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000) |
|||
#define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000) |
|||
{ |
|||
bfd_vma sp = H_GET_32 (abfd, &extcore->c_regs.r_o6); |
|||
if (sp < SPARC_USRSTACK_SPARC10) |
|||
intcore->c_stacktop = SPARC_USRSTACK_SPARC10; |
|||
else |
|||
intcore->c_stacktop = SPARC_USRSTACK_SPARC2; |
|||
} |
|||
} |
|||
|
|||
/* Byte-swap in the Solaris BCP core structure. */ |
|||
|
|||
static void |
|||
swapcore_solaris_bcp (bfd *abfd, char *ext, struct internal_sunos_core *intcore) |
|||
{ |
|||
struct external_solaris_bcp_core *extcore = |
|||
(struct external_solaris_bcp_core *) ext; |
|||
|
|||
intcore->c_magic = H_GET_32 (abfd, &extcore->c_magic); |
|||
intcore->c_len = H_GET_32 (abfd, &extcore->c_len); |
|||
intcore->c_regs_pos = offsetof (struct external_solaris_bcp_core, c_regs); |
|||
intcore->c_regs_size = sizeof (extcore->c_regs); |
|||
|
|||
/* The Solaris BCP exdata structure does not contain an a_syms field,
|
|||
so we are unable to synthesize an internal exec header. |
|||
Luckily we are able to figure out the start address of the data section, |
|||
which is the only thing needed from the internal exec header, |
|||
from the exdata structure. |
|||
|
|||
As of Solaris 2.3, BCP core files for statically linked executables |
|||
are buggy. The exdata structure is not properly filled in, and |
|||
the data section is written from address zero instead of the data |
|||
start address. */ |
|||
memset ((void *) &intcore->c_aouthdr, 0, sizeof (struct internal_exec)); |
|||
intcore->c_data_addr = H_GET_32 (abfd, &extcore->c_exdata_datorg); |
|||
intcore->c_signo = H_GET_32 (abfd, &extcore->c_signo); |
|||
intcore->c_tsize = H_GET_32 (abfd, &extcore->c_tsize); |
|||
intcore->c_dsize = H_GET_32 (abfd, &extcore->c_dsize); |
|||
intcore->c_ssize = H_GET_32 (abfd, &extcore->c_ssize); |
|||
memcpy (intcore->c_cmdname, extcore->c_cmdname, sizeof (intcore->c_cmdname)); |
|||
intcore->fp_stuff_pos = |
|||
offsetof (struct external_solaris_bcp_core, fp_stuff); |
|||
/* FP stuff takes up whole rest of struct, except c_ucode. */ |
|||
intcore->fp_stuff_size = intcore->c_len - (sizeof extcore->c_ucode) - |
|||
offsetof (struct external_solaris_bcp_core, fp_stuff); |
|||
/* Ucode is the last thing in the struct -- just before the end */ |
|||
intcore->c_ucode = H_GET_32 (abfd, |
|||
(intcore->c_len |
|||
- sizeof (extcore->c_ucode) |
|||
+ (unsigned char *) extcore)); |
|||
|
|||
/* Supposedly the user stack grows downward from the bottom of kernel memory.
|
|||
Presuming that this remains true, this definition will work. */ |
|||
/* Now sun has provided us with another challenge. The value is different
|
|||
for sparc2 and sparc10 (both running SunOS 4.1.3). We pick one or |
|||
the other based on the current value of the stack pointer. This |
|||
loses (a) if the stack pointer has been clobbered, or (b) if the stack |
|||
is larger than 128 megabytes. |
|||
|
|||
It's times like these you're glad they're switching to ELF. |
|||
|
|||
Note that using include files or nlist on /vmunix would be wrong, |
|||
because we want the value for this core file, no matter what kind of |
|||
machine we were compiled on or are running on. */ |
|||
#define SPARC_USRSTACK_SPARC2 ((bfd_vma)0xf8000000) |
|||
#define SPARC_USRSTACK_SPARC10 ((bfd_vma)0xf0000000) |
|||
{ |
|||
bfd_vma sp = H_GET_32 (abfd, &extcore->c_regs.r_o6); |
|||
if (sp < SPARC_USRSTACK_SPARC10) |
|||
intcore->c_stacktop = SPARC_USRSTACK_SPARC10; |
|||
else |
|||
intcore->c_stacktop = SPARC_USRSTACK_SPARC2; |
|||
} |
|||
} |
|||
|
|||
/* Need this cast because ptr is really void *. */ |
|||
#define core_hdr(bfd) ((bfd)->tdata.sun_core_data) |
|||
#define core_datasec(bfd) (core_hdr (bfd)->data_section) |
|||
#define core_stacksec(bfd) (core_hdr (bfd)->stack_section) |
|||
#define core_regsec(bfd) (core_hdr (bfd)->reg_section) |
|||
#define core_reg2sec(bfd) (core_hdr (bfd)->reg2_section) |
|||
|
|||
/* These are stored in the bfd's tdata. */ |
|||
struct sun_core_struct |
|||
{ |
|||
struct internal_sunos_core *hdr; /* Core file header. */ |
|||
asection *data_section; |
|||
asection *stack_section; |
|||
asection *reg_section; |
|||
asection *reg2_section; |
|||
}; |
|||
|
|||
static const bfd_target * |
|||
sunos4_core_file_p (bfd *abfd) |
|||
{ |
|||
unsigned char longbuf[4]; /* Raw bytes of various header fields. */ |
|||
bfd_size_type core_size, amt; |
|||
unsigned long core_mag; |
|||
struct internal_sunos_core *core; |
|||
char *extcore; |
|||
struct mergem |
|||
{ |
|||
struct sun_core_struct suncoredata; |
|||
struct internal_sunos_core internal_sunos_core; |
|||
char external_core[1]; |
|||
} *mergem; |
|||
flagword flags; |
|||
|
|||
if (bfd_bread ((void *) longbuf, (bfd_size_type) sizeof (longbuf), abfd) |
|||
!= sizeof (longbuf)) |
|||
return NULL; |
|||
core_mag = H_GET_32 (abfd, longbuf); |
|||
|
|||
if (core_mag != CORE_MAGIC) |
|||
return NULL; |
|||
|
|||
/* SunOS core headers can vary in length; second word is size; */ |
|||
if (bfd_bread ((void *) longbuf, (bfd_size_type) sizeof (longbuf), abfd) |
|||
!= sizeof (longbuf)) |
|||
return NULL; |
|||
core_size = H_GET_32 (abfd, longbuf); |
|||
/* Sanity check. */ |
|||
if (core_size > 20000) |
|||
return NULL; |
|||
|
|||
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) |
|||
return NULL; |
|||
|
|||
amt = core_size + sizeof (struct mergem); |
|||
mergem = bfd_zalloc (abfd, amt); |
|||
if (mergem == NULL) |
|||
return NULL; |
|||
|
|||
extcore = mergem->external_core; |
|||
|
|||
if ((bfd_bread ((void *) extcore, core_size, abfd)) != core_size) |
|||
{ |
|||
loser: |
|||
bfd_release (abfd, (char *) mergem); |
|||
abfd->tdata.any = NULL; |
|||
bfd_section_list_clear (abfd); |
|||
return NULL; |
|||
} |
|||
|
|||
/* Validate that it's a core file we know how to handle, due to sun
|
|||
botching the positioning of registers and other fields in a machine |
|||
dependent way. */ |
|||
core = &mergem->internal_sunos_core; |
|||
switch (core_size) |
|||
{ |
|||
case SPARC_CORE_LEN: |
|||
swapcore_sparc (abfd, extcore, core); |
|||
break; |
|||
case SUN3_CORE_LEN: |
|||
swapcore_sun3 (abfd, extcore, core); |
|||
break; |
|||
case SOLARIS_BCP_CORE_LEN: |
|||
swapcore_solaris_bcp (abfd, extcore, core); |
|||
break; |
|||
default: |
|||
bfd_set_error (bfd_error_system_call); /* FIXME. */ |
|||
goto loser; |
|||
} |
|||
|
|||
abfd->tdata.sun_core_data = &mergem->suncoredata; |
|||
abfd->tdata.sun_core_data->hdr = core; |
|||
|
|||
/* Create the sections. */ |
|||
flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; |
|||
core_stacksec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".stack", |
|||
flags); |
|||
if (core_stacksec (abfd) == NULL) |
|||
/* bfd_release frees everything allocated after it's arg. */ |
|||
goto loser; |
|||
|
|||
flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS; |
|||
core_datasec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".data", |
|||
flags); |
|||
if (core_datasec (abfd) == NULL) |
|||
goto loser; |
|||
|
|||
flags = SEC_HAS_CONTENTS; |
|||
core_regsec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".reg", |
|||
flags); |
|||
if (core_regsec (abfd) == NULL) |
|||
goto loser; |
|||
|
|||
flags = SEC_HAS_CONTENTS; |
|||
core_reg2sec (abfd) = bfd_make_section_anyway_with_flags (abfd, ".reg2", |
|||
flags); |
|||
if (core_reg2sec (abfd) == NULL) |
|||
goto loser; |
|||
|
|||
core_stacksec (abfd)->size = core->c_ssize; |
|||
core_datasec (abfd)->size = core->c_dsize; |
|||
core_regsec (abfd)->size = core->c_regs_size; |
|||
core_reg2sec (abfd)->size = core->fp_stuff_size; |
|||
|
|||
core_stacksec (abfd)->vma = (core->c_stacktop - core->c_ssize); |
|||
core_datasec (abfd)->vma = core->c_data_addr; |
|||
core_regsec (abfd)->vma = 0; |
|||
core_reg2sec (abfd)->vma = 0; |
|||
|
|||
core_stacksec (abfd)->filepos = core->c_len + core->c_dsize; |
|||
core_datasec (abfd)->filepos = core->c_len; |
|||
/* We'll access the regs afresh in the core file, like any section: */ |
|||
core_regsec (abfd)->filepos = (file_ptr) core->c_regs_pos; |
|||
core_reg2sec (abfd)->filepos = (file_ptr) core->fp_stuff_pos; |
|||
|
|||
/* 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; |
|||
|
|||
return abfd->xvec; |
|||
} |
|||
|
|||
static char * |
|||
sunos4_core_file_failing_command (bfd *abfd) |
|||
{ |
|||
return core_hdr (abfd)->hdr->c_cmdname; |
|||
} |
|||
|
|||
static int |
|||
sunos4_core_file_failing_signal (bfd *abfd) |
|||
{ |
|||
return core_hdr (abfd)->hdr->c_signo; |
|||
} |
|||
|
|||
static bfd_boolean |
|||
sunos4_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd) |
|||
{ |
|||
if (core_bfd->xvec != exec_bfd->xvec) |
|||
{ |
|||
bfd_set_error (bfd_error_system_call); |
|||
return FALSE; |
|||
} |
|||
|
|||
/* Solaris core files do not include an aouthdr. */ |
|||
if ((core_hdr (core_bfd)->hdr)->c_len == SOLARIS_BCP_CORE_LEN) |
|||
return TRUE; |
|||
|
|||
return memcmp ((char *) &((core_hdr (core_bfd)->hdr)->c_aouthdr), |
|||
(char *) exec_hdr (exec_bfd), |
|||
sizeof (struct internal_exec)) == 0; |
|||
} |
|||
|
|||
#define MY_set_sizes sunos4_set_sizes |
|||
|
|||
static bfd_boolean |
|||
sunos4_set_sizes (bfd *abfd) |
|||
{ |
|||
switch (bfd_get_arch (abfd)) |
|||
{ |
|||
default: |
|||
return FALSE; |
|||
case bfd_arch_sparc: |
|||
adata (abfd).page_size = 0x2000; |
|||
adata (abfd).segment_size = 0x2000; |
|||
adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; |
|||
return TRUE; |
|||
} |
|||
} |
|||
|
|||
/* We default to setting the toolversion field to 1, as is required by
|
|||
SunOS. */ |
|||
#ifndef MY_exec_hdr_flags |
|||
#define MY_exec_hdr_flags 1 |
|||
#endif |
|||
|
|||
#ifndef MY_entry_is_text_address |
|||
#define MY_entry_is_text_address 0 |
|||
#endif |
|||
#ifndef MY_add_dynamic_symbols |
|||
#define MY_add_dynamic_symbols 0 |
|||
#endif |
|||
#ifndef MY_add_one_symbol |
|||
#define MY_add_one_symbol 0 |
|||
#endif |
|||
#ifndef MY_link_dynamic_object |
|||
#define MY_link_dynamic_object 0 |
|||
#endif |
|||
#ifndef MY_write_dynamic_symbol |
|||
#define MY_write_dynamic_symbol 0 |
|||
#endif |
|||
#ifndef MY_check_dynamic_reloc |
|||
#define MY_check_dynamic_reloc 0 |
|||
#endif |
|||
#ifndef MY_finish_dynamic_link |
|||
#define MY_finish_dynamic_link 0 |
|||
#endif |
|||
|
|||
static const struct aout_backend_data sunos4_aout_backend = |
|||
{ |
|||
0, /* Zmagic files are not contiguous. */ |
|||
1, /* Text includes header. */ |
|||
MY_entry_is_text_address, |
|||
MY_exec_hdr_flags, |
|||
0, /* Default text vma. */ |
|||
sunos4_set_sizes, |
|||
0, /* Header is counted in zmagic text. */ |
|||
MY_add_dynamic_symbols, |
|||
MY_add_one_symbol, |
|||
MY_link_dynamic_object, |
|||
MY_write_dynamic_symbol, |
|||
MY_check_dynamic_reloc, |
|||
MY_finish_dynamic_link |
|||
}; |
|||
|
|||
#define MY_core_file_failing_command sunos4_core_file_failing_command |
|||
#define MY_core_file_failing_signal sunos4_core_file_failing_signal |
|||
#define MY_core_file_matches_executable_p sunos4_core_file_matches_executable_p |
|||
|
|||
#define MY_bfd_debug_info_start _bfd_void_bfd |
|||
#define MY_bfd_debug_info_end _bfd_void_bfd |
|||
#define MY_bfd_debug_info_accumulate _bfd_void_bfd_asection |
|||
#define MY_core_file_p sunos4_core_file_p |
|||
#define MY_write_object_contents NAME(aout, sunos4_write_object_contents) |
|||
#define MY_backend_data & sunos4_aout_backend |
|||
|
|||
#ifndef TARGET_IS_LITTLE_ENDIAN_P |
|||
#define TARGET_IS_BIG_ENDIAN_P |
|||
#endif |
|||
|
|||
#include "aout-target.h" |
|||
@ -1,29 +0,0 @@ |
|||
/* BFD back-end for Sparc COFF LynxOS files.
|
|||
Copyright (C) 1993-2018 Free Software Foundation, Inc. |
|||
Written by Cygnus Support. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
#define TARGET_SYM sparc_coff_lynx_vec |
|||
#define TARGET_NAME "coff-sparc-lynx" |
|||
|
|||
#define LYNXOS |
|||
|
|||
#define COFF_LONG_FILENAMES |
|||
|
|||
#include "coff-sparc.c" |
|||
@ -1,208 +0,0 @@ |
|||
/* BFD back-end for Sparc COFF files.
|
|||
Copyright (C) 1990-2018 Free Software Foundation, Inc. |
|||
Written by Cygnus Support. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
#include "sysdep.h" |
|||
#include "bfd.h" |
|||
#include "libbfd.h" |
|||
#include "coff/sparc.h" |
|||
#include "coff/internal.h" |
|||
#include "libcoff.h" |
|||
|
|||
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3) |
|||
|
|||
#define BADMAG(x) ((x).f_magic != SPARCMAGIC && (x).f_magic != LYNXCOFFMAGIC) |
|||
|
|||
/* The page size is a guess based on ELF. */ |
|||
#define COFF_PAGE_SIZE 0x10000 |
|||
|
|||
enum reloc_type |
|||
{ |
|||
R_SPARC_NONE = 0, |
|||
R_SPARC_8, R_SPARC_16, R_SPARC_32, |
|||
R_SPARC_DISP8, R_SPARC_DISP16, R_SPARC_DISP32, |
|||
R_SPARC_WDISP30, R_SPARC_WDISP22, |
|||
R_SPARC_HI22, R_SPARC_22, |
|||
R_SPARC_13, R_SPARC_LO10, |
|||
R_SPARC_GOT10, R_SPARC_GOT13, R_SPARC_GOT22, |
|||
R_SPARC_PC10, R_SPARC_PC22, |
|||
R_SPARC_WPLT30, |
|||
R_SPARC_COPY, |
|||
R_SPARC_GLOB_DAT, R_SPARC_JMP_SLOT, |
|||
R_SPARC_RELATIVE, |
|||
R_SPARC_UA32, |
|||
R_SPARC_max |
|||
}; |
|||
|
|||
/* This is stolen pretty directly from elf.c. */ |
|||
|
|||
static bfd_reloc_status_type |
|||
bfd_coff_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, |
|||
arelent *reloc_entry, |
|||
asymbol *symbol, |
|||
void * data ATTRIBUTE_UNUSED, |
|||
asection *input_section, |
|||
bfd *output_bfd, |
|||
char **error_message ATTRIBUTE_UNUSED) |
|||
{ |
|||
if (output_bfd != (bfd *) NULL |
|||
&& (symbol->flags & BSF_SECTION_SYM) == 0) |
|||
{ |
|||
reloc_entry->address += input_section->output_offset; |
|||
return bfd_reloc_ok; |
|||
} |
|||
|
|||
return bfd_reloc_continue; |
|||
} |
|||
|
|||
static reloc_howto_type coff_sparc_howto_table[] = |
|||
{ |
|||
HOWTO(R_SPARC_NONE, 0,3, 0,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_NONE", FALSE,0,0x00000000,TRUE), |
|||
HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_8", FALSE,0,0x000000ff,TRUE), |
|||
HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_16", FALSE,0,0x0000ffff,TRUE), |
|||
HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_32", FALSE,0,0xffffffff,TRUE), |
|||
HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_coff_generic_reloc,"R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE), |
|||
HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_coff_generic_reloc,"R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE), |
|||
HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_coff_generic_reloc,"R_SPARC_DISP32", FALSE,0,0x00ffffff,TRUE), |
|||
HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_coff_generic_reloc,"R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE), |
|||
HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_coff_generic_reloc,"R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE), |
|||
HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_HI22", FALSE,0,0x003fffff,TRUE), |
|||
HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_22", FALSE,0,0x003fffff,TRUE), |
|||
HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_13", FALSE,0,0x00001fff,TRUE), |
|||
HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_LO10", FALSE,0,0x000003ff,TRUE), |
|||
HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE), |
|||
HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE), |
|||
HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE), |
|||
HOWTO(R_SPARC_PC10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_PC10", FALSE,0,0x000003ff,TRUE), |
|||
HOWTO(R_SPARC_PC22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_coff_generic_reloc,"R_SPARC_PC22", FALSE,0,0x003fffff,TRUE), |
|||
HOWTO(R_SPARC_WPLT30, 0,0,00,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_WPLT30", FALSE,0,0x00000000,TRUE), |
|||
HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_COPY", FALSE,0,0x00000000,TRUE), |
|||
HOWTO(R_SPARC_GLOB_DAT,0,0,00,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_GLOB_DAT",FALSE,0,0x00000000,TRUE), |
|||
HOWTO(R_SPARC_JMP_SLOT,0,0,00,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_JMP_SLOT",FALSE,0,0x00000000,TRUE), |
|||
HOWTO(R_SPARC_RELATIVE,0,0,00,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE), |
|||
HOWTO(R_SPARC_UA32, 0,0,00,FALSE,0,complain_overflow_dont, bfd_coff_generic_reloc,"R_SPARC_UA32", FALSE,0,0x00000000,TRUE), |
|||
}; |
|||
|
|||
struct coff_reloc_map |
|||
{ |
|||
bfd_reloc_code_real_type bfd_reloc_val; |
|||
unsigned char coff_reloc_val; |
|||
}; |
|||
|
|||
static const struct coff_reloc_map sparc_reloc_map[] = |
|||
{ |
|||
{ BFD_RELOC_NONE, R_SPARC_NONE, }, |
|||
{ BFD_RELOC_16, R_SPARC_16, }, |
|||
{ BFD_RELOC_8, R_SPARC_8 }, |
|||
{ BFD_RELOC_8_PCREL, R_SPARC_DISP8 }, |
|||
{ BFD_RELOC_CTOR, R_SPARC_32 }, /* @@ Assumes 32 bits. */ |
|||
{ BFD_RELOC_32, R_SPARC_32 }, |
|||
{ BFD_RELOC_32_PCREL, R_SPARC_DISP32 }, |
|||
{ BFD_RELOC_HI22, R_SPARC_HI22 }, |
|||
{ BFD_RELOC_LO10, R_SPARC_LO10, }, |
|||
{ BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 }, |
|||
{ BFD_RELOC_SPARC22, R_SPARC_22 }, |
|||
{ BFD_RELOC_SPARC13, R_SPARC_13 }, |
|||
{ BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 }, |
|||
{ BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 }, |
|||
{ BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 }, |
|||
{ BFD_RELOC_SPARC_PC10, R_SPARC_PC10 }, |
|||
{ BFD_RELOC_SPARC_PC22, R_SPARC_PC22 }, |
|||
{ BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 }, |
|||
{ BFD_RELOC_SPARC_COPY, R_SPARC_COPY }, |
|||
{ BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT }, |
|||
{ BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT }, |
|||
{ BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE }, |
|||
{ BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 }, |
|||
/* { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */ |
|||
}; |
|||
|
|||
static reloc_howto_type * |
|||
coff_sparc_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, |
|||
bfd_reloc_code_real_type code) |
|||
{ |
|||
unsigned int i; |
|||
for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct coff_reloc_map); i++) |
|||
{ |
|||
if (sparc_reloc_map[i].bfd_reloc_val == code) |
|||
return &coff_sparc_howto_table[(int) sparc_reloc_map[i].coff_reloc_val]; |
|||
} |
|||
return 0; |
|||
} |
|||
#define coff_bfd_reloc_type_lookup coff_sparc_reloc_type_lookup |
|||
|
|||
static reloc_howto_type * |
|||
coff_sparc_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, |
|||
const char *r_name) |
|||
{ |
|||
unsigned int i; |
|||
|
|||
for (i = 0; |
|||
i < (sizeof (coff_sparc_howto_table) |
|||
/ sizeof (coff_sparc_howto_table[0])); |
|||
i++) |
|||
if (coff_sparc_howto_table[i].name != NULL |
|||
&& strcasecmp (coff_sparc_howto_table[i].name, r_name) == 0) |
|||
return &coff_sparc_howto_table[i]; |
|||
|
|||
return NULL; |
|||
} |
|||
#define coff_bfd_reloc_name_lookup coff_sparc_reloc_name_lookup |
|||
|
|||
static void |
|||
rtype2howto (arelent *cache_ptr, struct internal_reloc *dst) |
|||
{ |
|||
BFD_ASSERT (dst->r_type < (unsigned int) R_SPARC_max); |
|||
cache_ptr->howto = &coff_sparc_howto_table[dst->r_type]; |
|||
} |
|||
|
|||
#define RTYPE2HOWTO(internal, relocentry) rtype2howto(internal,relocentry) |
|||
|
|||
#define SWAP_IN_RELOC_OFFSET H_GET_32 |
|||
#define SWAP_OUT_RELOC_OFFSET H_PUT_32 |
|||
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ |
|||
cache_ptr->addend = reloc.r_offset; |
|||
|
|||
/* Clear the r_spare field in relocs. */ |
|||
#define SWAP_OUT_RELOC_EXTRA(abfd,src,dst) \ |
|||
do { \ |
|||
dst->r_spare[0] = 0; \ |
|||
dst->r_spare[1] = 0; \ |
|||
} while (0) |
|||
|
|||
#define __A_MAGIC_SET__ |
|||
|
|||
/* Enable Sparc-specific hacks in coffcode.h. */ |
|||
|
|||
#define COFF_SPARC |
|||
|
|||
#define bfd_pe_print_pdata NULL |
|||
|
|||
#include "coffcode.h" |
|||
|
|||
#ifndef TARGET_SYM |
|||
#define TARGET_SYM sparc_coff_vec |
|||
#endif |
|||
|
|||
#ifndef TARGET_NAME |
|||
#define TARGET_NAME "coff-sparc" |
|||
#endif |
|||
|
|||
CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, '_', NULL, COFF_SWAP_TABLE) |
|||
@ -1,30 +0,0 @@ |
|||
/* BFD backend for demonstration 64-bit a.out binaries.
|
|||
Copyright (C) 1990-2018 Free Software Foundation, Inc. |
|||
Written by Cygnus Support. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
#define ARCH_SIZE 64 |
|||
|
|||
/* Do not "beautify" the CONCAT* macro args. Traditional C will not
|
|||
remove whitespace added here, and thus will fail to concatenate |
|||
the tokens. */ |
|||
#define MY(OP) CONCAT2 (aout64_,OP) |
|||
|
|||
#define TARGETNAME "demo64" |
|||
#include "aoutf1.h" |
|||
@ -1,730 +0,0 @@ |
|||
/* BFD back-end for linux flavored sparc a.out binaries.
|
|||
Copyright (C) 1992-2018 Free Software Foundation, Inc. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
#define TARGET_PAGE_SIZE 4096 |
|||
#define ZMAGIC_DISK_BLOCK_SIZE 1024 |
|||
#define SEGMENT_SIZE TARGET_PAGE_SIZE |
|||
#define TEXT_START_ADDR 0x0 |
|||
|
|||
#define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_UNKNOWN) |
|||
|
|||
#include "sysdep.h" |
|||
#include "bfd.h" |
|||
#include "libbfd.h" |
|||
#include "aout/aout64.h" |
|||
#include "aout/stab_gnu.h" |
|||
#include "aout/ar.h" |
|||
#include "libaout.h" /* BFD a.out internal data structures */ |
|||
|
|||
#define DEFAULT_ARCH bfd_arch_sparc |
|||
/* Do not "beautify" the CONCAT* macro args. Traditional C will not
|
|||
remove whitespace added here, and thus will fail to concatenate |
|||
the tokens. */ |
|||
#define MY(OP) CONCAT2 (sparc_aout_linux_,OP) |
|||
#define TARGETNAME "a.out-sparc-linux" |
|||
|
|||
extern const bfd_target MY(vec); |
|||
|
|||
/* We always generate QMAGIC files in preference to ZMAGIC files. It
|
|||
would be possible to make this a linker option, if that ever |
|||
becomes important. */ |
|||
|
|||
static void MY_final_link_callback |
|||
(bfd *, file_ptr *, file_ptr *, file_ptr *); |
|||
|
|||
static bfd_boolean |
|||
sparclinux_bfd_final_link (bfd *abfd, struct bfd_link_info *info) |
|||
{ |
|||
obj_aout_subformat (abfd) = q_magic_format; |
|||
return NAME(aout,final_link) (abfd, info, MY_final_link_callback); |
|||
} |
|||
|
|||
#define MY_bfd_final_link sparclinux_bfd_final_link |
|||
|
|||
/* Set the machine type correctly. */ |
|||
|
|||
static bfd_boolean |
|||
sparclinux_write_object_contents (bfd *abfd) |
|||
{ |
|||
struct external_exec exec_bytes; |
|||
struct internal_exec *execp = exec_hdr (abfd); |
|||
|
|||
N_SET_MACHTYPE (execp, M_SPARC); |
|||
|
|||
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; |
|||
|
|||
WRITE_HEADERS (abfd, execp); |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
#define MY_write_object_contents sparclinux_write_object_contents |
|||
/* Code to link against Linux a.out shared libraries. */ |
|||
|
|||
/* See if a symbol name is a reference to the global offset table. */ |
|||
|
|||
#ifndef GOT_REF_PREFIX |
|||
#define GOT_REF_PREFIX "__GOT_" |
|||
#endif |
|||
|
|||
#define IS_GOT_SYM(name) (CONST_STRNEQ (name, GOT_REF_PREFIX)) |
|||
|
|||
/* See if a symbol name is a reference to the procedure linkage table. */ |
|||
|
|||
#ifndef PLT_REF_PREFIX |
|||
#define PLT_REF_PREFIX "__PLT_" |
|||
#endif |
|||
|
|||
#define IS_PLT_SYM(name) (CONST_STRNEQ (name, PLT_REF_PREFIX)) |
|||
|
|||
/* This string is used to generate specialized error messages. */ |
|||
|
|||
#ifndef NEEDS_SHRLIB |
|||
#define NEEDS_SHRLIB "__NEEDS_SHRLIB_" |
|||
#endif |
|||
|
|||
/* This special symbol is a set vector that contains a list of
|
|||
pointers to fixup tables. It will be present in any dynamically |
|||
linked file. The linker generated fixup table should also be added |
|||
to the list, and it should always appear in the second slot (the |
|||
first one is a dummy with a magic number that is defined in |
|||
crt0.o). */ |
|||
|
|||
#ifndef SHARABLE_CONFLICTS |
|||
#define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__" |
|||
#endif |
|||
|
|||
/* We keep a list of fixups. The terminology is a bit strange, but
|
|||
each fixup contains two 32 bit numbers. A regular fixup contains |
|||
an address and a pointer, and at runtime we should store the |
|||
address at the location pointed to by the pointer. A builtin fixup |
|||
contains two pointers, and we should read the address using one |
|||
pointer and store it at the location pointed to by the other |
|||
pointer. Builtin fixups come into play when we have duplicate |
|||
__GOT__ symbols for the same variable. The builtin fixup will copy |
|||
the GOT pointer from one over into the other. */ |
|||
|
|||
struct fixup |
|||
{ |
|||
struct fixup *next; |
|||
struct linux_link_hash_entry *h; |
|||
bfd_vma value; |
|||
|
|||
/* Nonzero if this is a jump instruction that needs to be fixed,
|
|||
zero if this is just a pointer */ |
|||
char jump; |
|||
|
|||
char builtin; |
|||
}; |
|||
|
|||
/* We don't need a special hash table entry structure, but we do need
|
|||
to keep some information between linker passes, so we use a special |
|||
hash table. */ |
|||
|
|||
struct linux_link_hash_entry |
|||
{ |
|||
struct aout_link_hash_entry root; |
|||
}; |
|||
|
|||
struct linux_link_hash_table |
|||
{ |
|||
struct aout_link_hash_table root; |
|||
|
|||
/* First dynamic object found in link. */ |
|||
bfd *dynobj; |
|||
|
|||
/* Number of fixups. */ |
|||
size_t fixup_count; |
|||
|
|||
/* Number of builtin fixups. */ |
|||
size_t local_builtins; |
|||
|
|||
/* List of fixups. */ |
|||
struct fixup *fixup_list; |
|||
}; |
|||
|
|||
|
|||
/* Routine to create an entry in an Linux link hash table. */ |
|||
|
|||
static struct bfd_hash_entry * |
|||
linux_link_hash_newfunc (struct bfd_hash_entry *entry, |
|||
struct bfd_hash_table *table, |
|||
const char *string) |
|||
{ |
|||
struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry; |
|||
|
|||
/* Allocate the structure if it has not already been allocated by a
|
|||
subclass. */ |
|||
if (ret == (struct linux_link_hash_entry *) NULL) |
|||
ret = ((struct linux_link_hash_entry *) |
|||
bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry))); |
|||
if (ret == NULL) |
|||
return (struct bfd_hash_entry *) ret; |
|||
|
|||
/* Call the allocation method of the superclass. */ |
|||
ret = ((struct linux_link_hash_entry *) |
|||
NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret, |
|||
table, string)); |
|||
if (ret != NULL) |
|||
{ |
|||
/* Set local fields; there aren't any. */ |
|||
} |
|||
|
|||
return (struct bfd_hash_entry *) ret; |
|||
} |
|||
|
|||
/* Create a Linux link hash table. */ |
|||
|
|||
static struct bfd_link_hash_table * |
|||
linux_link_hash_table_create (bfd *abfd) |
|||
{ |
|||
struct linux_link_hash_table *ret; |
|||
bfd_size_type amt = sizeof (struct linux_link_hash_table); |
|||
|
|||
ret = (struct linux_link_hash_table *) bfd_zmalloc (amt); |
|||
if (ret == (struct linux_link_hash_table *) NULL) |
|||
return (struct bfd_link_hash_table *) NULL; |
|||
if (!NAME(aout,link_hash_table_init) (&ret->root, abfd, |
|||
linux_link_hash_newfunc, |
|||
sizeof (struct linux_link_hash_entry))) |
|||
{ |
|||
free (ret); |
|||
return (struct bfd_link_hash_table *) NULL; |
|||
} |
|||
|
|||
return &ret->root.root; |
|||
} |
|||
|
|||
/* Look up an entry in a Linux link hash table. */ |
|||
|
|||
#define linux_link_hash_lookup(table, string, create, copy, follow) \ |
|||
((struct linux_link_hash_entry *) \ |
|||
aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\ |
|||
(follow))) |
|||
|
|||
/* Traverse a Linux link hash table. */ |
|||
|
|||
#define linux_link_hash_traverse(table, func, info) \ |
|||
(aout_link_hash_traverse \ |
|||
(&(table)->root, \ |
|||
(bfd_boolean (*) (struct aout_link_hash_entry *, void *)) (func), \ |
|||
(info))) |
|||
|
|||
/* Get the Linux link hash table from the info structure. This is
|
|||
just a cast. */ |
|||
|
|||
#define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash)) |
|||
|
|||
/* Store the information for a new fixup. */ |
|||
|
|||
static struct fixup * |
|||
new_fixup (struct bfd_link_info *info, |
|||
struct linux_link_hash_entry *h, |
|||
bfd_vma value, |
|||
int builtin) |
|||
{ |
|||
struct fixup *f; |
|||
|
|||
f = (struct fixup *) bfd_hash_allocate (&info->hash->table, |
|||
sizeof (struct fixup)); |
|||
if (f == NULL) |
|||
return f; |
|||
f->next = linux_hash_table (info)->fixup_list; |
|||
linux_hash_table (info)->fixup_list = f; |
|||
f->h = h; |
|||
f->value = value; |
|||
f->builtin = builtin; |
|||
f->jump = 0; |
|||
++linux_hash_table (info)->fixup_count; |
|||
return f; |
|||
} |
|||
|
|||
/* We come here once we realize that we are going to link to a shared
|
|||
library. We need to create a special section that contains the |
|||
fixup table, and we ultimately need to add a pointer to this into |
|||
the set vector for SHARABLE_CONFLICTS. At this point we do not |
|||
know the size of the section, but that's OK - we just need to |
|||
create it for now. */ |
|||
|
|||
static bfd_boolean |
|||
linux_link_create_dynamic_sections (bfd *abfd, |
|||
struct bfd_link_info *info ATTRIBUTE_UNUSED) |
|||
{ |
|||
flagword flags; |
|||
asection *s; |
|||
|
|||
/* Note that we set the SEC_IN_MEMORY flag. */ |
|||
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY; |
|||
|
|||
/* We choose to use the name ".linux-dynamic" for the fixup table.
|
|||
Why not? */ |
|||
s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags); |
|||
if (s == NULL |
|||
|| ! bfd_set_section_alignment (abfd, s, 2)) |
|||
return FALSE; |
|||
s->size = 0; |
|||
s->contents = 0; |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
/* Function to add a single symbol to the linker hash table. This is
|
|||
a wrapper around _bfd_generic_link_add_one_symbol which handles the |
|||
tweaking needed for dynamic linking support. */ |
|||
|
|||
static bfd_boolean |
|||
linux_add_one_symbol (struct bfd_link_info *info, |
|||
bfd *abfd, |
|||
const char *name, |
|||
flagword flags, |
|||
asection *section, |
|||
bfd_vma value, |
|||
const char *string, |
|||
bfd_boolean copy, |
|||
bfd_boolean collect, |
|||
struct bfd_link_hash_entry **hashp) |
|||
{ |
|||
struct linux_link_hash_entry *h; |
|||
bfd_boolean insert; |
|||
|
|||
/* Look up and see if we already have this symbol in the hash table.
|
|||
If we do, and the defining entry is from a shared library, we |
|||
need to create the dynamic sections. |
|||
|
|||
FIXME: What if abfd->xvec != info->output_bfd->xvec? We may |
|||
want to be able to link Linux a.out and ELF objects together, |
|||
but serious confusion is possible. */ |
|||
|
|||
insert = FALSE; |
|||
|
|||
if (! bfd_link_relocatable (info) |
|||
&& linux_hash_table (info)->dynobj == NULL |
|||
&& strcmp (name, SHARABLE_CONFLICTS) == 0 |
|||
&& (flags & BSF_CONSTRUCTOR) != 0 |
|||
&& abfd->xvec == info->output_bfd->xvec) |
|||
{ |
|||
if (! linux_link_create_dynamic_sections (abfd, info)) |
|||
return FALSE; |
|||
linux_hash_table (info)->dynobj = abfd; |
|||
insert = TRUE; |
|||
} |
|||
|
|||
if (bfd_is_abs_section (section) |
|||
&& abfd->xvec == info->output_bfd->xvec) |
|||
{ |
|||
h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE, |
|||
FALSE, FALSE); |
|||
if (h != NULL |
|||
&& (h->root.root.type == bfd_link_hash_defined |
|||
|| h->root.root.type == bfd_link_hash_defweak)) |
|||
{ |
|||
struct fixup *f; |
|||
|
|||
if (hashp != NULL) |
|||
*hashp = (struct bfd_link_hash_entry *) h; |
|||
|
|||
f = new_fixup (info, h, value, ! IS_PLT_SYM (name)); |
|||
if (f == NULL) |
|||
return FALSE; |
|||
f->jump = IS_PLT_SYM (name); |
|||
|
|||
return TRUE; |
|||
} |
|||
} |
|||
|
|||
/* Do the usual procedure for adding a symbol. */ |
|||
if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, |
|||
value, string, copy, collect, |
|||
hashp)) |
|||
return FALSE; |
|||
|
|||
/* Insert a pointer to our table in the set vector. The dynamic
|
|||
linker requires this information. */ |
|||
if (insert) |
|||
{ |
|||
asection *s; |
|||
|
|||
/* Here we do our special thing to add the pointer to the
|
|||
dynamic section in the SHARABLE_CONFLICTS set vector. */ |
|||
s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, |
|||
".linux-dynamic"); |
|||
BFD_ASSERT (s != NULL); |
|||
|
|||
if (! (_bfd_generic_link_add_one_symbol |
|||
(info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS, |
|||
BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL, |
|||
FALSE, FALSE, NULL))) |
|||
return FALSE; |
|||
} |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
/* We will crawl the hash table and come here for every global symbol.
|
|||
We will examine each entry and see if there are indications that we |
|||
need to add a fixup. There are two possible cases - one is where |
|||
you have duplicate definitions of PLT or GOT symbols - these will |
|||
have already been caught and added as "builtin" fixups. If we find |
|||
that the corresponding non PLT/GOT symbol is also present, we |
|||
convert it to a regular fixup instead. |
|||
|
|||
This function is called via linux_link_hash_traverse. */ |
|||
|
|||
static bfd_boolean |
|||
linux_tally_symbols (struct linux_link_hash_entry *h, void * data) |
|||
{ |
|||
struct bfd_link_info *info = (struct bfd_link_info *) data; |
|||
struct fixup *f, *f1; |
|||
int is_plt; |
|||
struct linux_link_hash_entry *h1, *h2; |
|||
bfd_boolean exists; |
|||
|
|||
if (h->root.root.type == bfd_link_hash_undefined |
|||
&& CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB)) |
|||
{ |
|||
const char *name; |
|||
char *p; |
|||
char *alloc = NULL; |
|||
|
|||
name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1; |
|||
p = strrchr (name, '_'); |
|||
if (p != NULL) |
|||
alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1); |
|||
|
|||
if (p == NULL || alloc == NULL) |
|||
_bfd_error_handler (_("output file requires shared library `%s'"), |
|||
name); |
|||
else |
|||
{ |
|||
strcpy (alloc, name); |
|||
p = strrchr (alloc, '_'); |
|||
*p++ = '\0'; |
|||
_bfd_error_handler |
|||
/* xgettext:c-format */ |
|||
(_("output file requires shared library `%s.so.%s'"), |
|||
alloc, p); |
|||
free (alloc); |
|||
} |
|||
|
|||
abort (); |
|||
} |
|||
|
|||
/* If this symbol is not a PLT/GOT, we do not even need to look at
|
|||
it. */ |
|||
is_plt = IS_PLT_SYM (h->root.root.root.string); |
|||
|
|||
if (is_plt || IS_GOT_SYM (h->root.root.root.string)) |
|||
{ |
|||
/* Look up this symbol twice. Once just as a regular lookup,
|
|||
and then again following all of the indirect links until we |
|||
reach a real symbol. */ |
|||
h1 = linux_link_hash_lookup (linux_hash_table (info), |
|||
(h->root.root.root.string |
|||
+ sizeof PLT_REF_PREFIX - 1), |
|||
FALSE, FALSE, TRUE); |
|||
/* h2 does not follow indirect symbols. */ |
|||
h2 = linux_link_hash_lookup (linux_hash_table (info), |
|||
(h->root.root.root.string |
|||
+ sizeof PLT_REF_PREFIX - 1), |
|||
FALSE, FALSE, FALSE); |
|||
|
|||
/* The real symbol must exist but if it is also an ABS symbol,
|
|||
there is no need to have a fixup. This is because they both |
|||
came from the same library. If on the other hand, we had to |
|||
use an indirect symbol to get to the real symbol, we add the |
|||
fixup anyway, since there are cases where these symbols come |
|||
from different shared libraries */ |
|||
if (h1 != NULL |
|||
&& (((h1->root.root.type == bfd_link_hash_defined |
|||
|| h1->root.root.type == bfd_link_hash_defweak) |
|||
&& ! bfd_is_abs_section (h1->root.root.u.def.section)) |
|||
|| h2->root.root.type == bfd_link_hash_indirect)) |
|||
{ |
|||
/* See if there is a "builtin" fixup already present
|
|||
involving this symbol. If so, convert it to a regular |
|||
fixup. In the end, this relaxes some of the requirements |
|||
about the order of performing fixups. */ |
|||
exists = FALSE; |
|||
for (f1 = linux_hash_table (info)->fixup_list; |
|||
f1 != NULL; |
|||
f1 = f1->next) |
|||
{ |
|||
if ((f1->h != h && f1->h != h1) |
|||
|| (! f1->builtin && ! f1->jump)) |
|||
continue; |
|||
if (f1->h == h1) |
|||
exists = TRUE; |
|||
if (! exists |
|||
&& bfd_is_abs_section (h->root.root.u.def.section)) |
|||
{ |
|||
f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0); |
|||
f->jump = is_plt; |
|||
} |
|||
f1->h = h1; |
|||
f1->jump = is_plt; |
|||
f1->builtin = 0; |
|||
exists = TRUE; |
|||
} |
|||
if (! exists |
|||
&& bfd_is_abs_section (h->root.root.u.def.section)) |
|||
{ |
|||
f = new_fixup (info, h1, h->root.root.u.def.value, 0); |
|||
if (f == NULL) |
|||
{ |
|||
/* FIXME: No way to return error. */ |
|||
abort (); |
|||
} |
|||
f->jump = is_plt; |
|||
} |
|||
} |
|||
|
|||
/* Quick and dirty way of stripping these symbols from the
|
|||
symtab. */ |
|||
if (bfd_is_abs_section (h->root.root.u.def.section)) |
|||
h->root.written = TRUE; |
|||
} |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
/* This is called to set the size of the .linux-dynamic section is.
|
|||
It is called by the Linux linker emulation before_allocation |
|||
routine. We have finished reading all of the input files, and now |
|||
we just scan the hash tables to find out how many additional fixups |
|||
are required. */ |
|||
|
|||
bfd_boolean |
|||
bfd_sparclinux_size_dynamic_sections (bfd *output_bfd, |
|||
struct bfd_link_info *info) |
|||
{ |
|||
struct fixup *f; |
|||
asection *s; |
|||
|
|||
if (output_bfd->xvec != &MY(vec)) |
|||
return TRUE; |
|||
|
|||
/* First find the fixups... */ |
|||
linux_link_hash_traverse (linux_hash_table (info), |
|||
linux_tally_symbols, |
|||
info); |
|||
|
|||
/* If there are builtin fixups, leave room for a marker. This is
|
|||
used by the dynamic linker so that it knows that all that follow |
|||
are builtin fixups instead of regular fixups. */ |
|||
for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) |
|||
{ |
|||
if (f->builtin) |
|||
{ |
|||
++linux_hash_table (info)->fixup_count; |
|||
++linux_hash_table (info)->local_builtins; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (linux_hash_table (info)->dynobj == NULL) |
|||
{ |
|||
if (linux_hash_table (info)->fixup_count > 0) |
|||
abort (); |
|||
return TRUE; |
|||
} |
|||
|
|||
/* Allocate memory for our fixup table. We will fill it in later. */ |
|||
s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, |
|||
".linux-dynamic"); |
|||
if (s != NULL) |
|||
{ |
|||
s->size = linux_hash_table (info)->fixup_count + 1; |
|||
s->size *= 8; |
|||
s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size); |
|||
if (s->contents == NULL) |
|||
return FALSE; |
|||
} |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
/* We come here once we are ready to actually write the fixup table to
|
|||
the output file. Scan the fixup tables and so forth and generate |
|||
the stuff we need. */ |
|||
|
|||
static bfd_boolean |
|||
linux_finish_dynamic_link (bfd *output_bfd, struct bfd_link_info *info) |
|||
{ |
|||
asection *s, *os, *is; |
|||
bfd_byte *fixup_table; |
|||
struct linux_link_hash_entry *h; |
|||
struct fixup *f; |
|||
unsigned int new_addr; |
|||
int section_offset; |
|||
unsigned int fixups_written; |
|||
|
|||
if (linux_hash_table (info)->dynobj == NULL) |
|||
return TRUE; |
|||
|
|||
s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, |
|||
".linux-dynamic"); |
|||
BFD_ASSERT (s != NULL); |
|||
os = s->output_section; |
|||
fixups_written = 0; |
|||
|
|||
#ifdef LINUX_LINK_DEBUG |
|||
printf ("Fixup table file offset: %x VMA: %x\n", |
|||
os->filepos + s->output_offset, |
|||
os->vma + s->output_offset); |
|||
#endif |
|||
|
|||
fixup_table = s->contents; |
|||
bfd_put_32 (output_bfd, |
|||
(bfd_vma) linux_hash_table (info)->fixup_count, fixup_table); |
|||
fixup_table += 4; |
|||
|
|||
/* Fill in fixup table. */ |
|||
for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) |
|||
{ |
|||
if (f->builtin) |
|||
continue; |
|||
|
|||
if (f->h->root.root.type != bfd_link_hash_defined |
|||
&& f->h->root.root.type != bfd_link_hash_defweak) |
|||
{ |
|||
_bfd_error_handler |
|||
(_("symbol %s not defined for fixups"), |
|||
f->h->root.root.root.string); |
|||
continue; |
|||
} |
|||
|
|||
is = f->h->root.root.u.def.section; |
|||
section_offset = is->output_section->vma + is->output_offset; |
|||
new_addr = f->h->root.root.u.def.value + section_offset; |
|||
|
|||
#ifdef LINUX_LINK_DEBUG |
|||
printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string, |
|||
new_addr, f->value); |
|||
#endif |
|||
|
|||
if (f->jump) |
|||
{ |
|||
/* Relative address */ |
|||
new_addr = new_addr - (f->value + 5); |
|||
bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); |
|||
fixup_table += 4; |
|||
bfd_put_32 (output_bfd, f->value + 1, fixup_table); |
|||
fixup_table += 4; |
|||
} |
|||
else |
|||
{ |
|||
bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); |
|||
fixup_table += 4; |
|||
bfd_put_32 (output_bfd, f->value, fixup_table); |
|||
fixup_table += 4; |
|||
} |
|||
++fixups_written; |
|||
} |
|||
|
|||
if (linux_hash_table (info)->local_builtins != 0) |
|||
{ |
|||
/* Special marker so we know to switch to the other type of fixup */ |
|||
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); |
|||
fixup_table += 4; |
|||
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); |
|||
fixup_table += 4; |
|||
++fixups_written; |
|||
for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) |
|||
{ |
|||
if (! f->builtin) |
|||
continue; |
|||
|
|||
if (f->h->root.root.type != bfd_link_hash_defined |
|||
&& f->h->root.root.type != bfd_link_hash_defweak) |
|||
{ |
|||
_bfd_error_handler |
|||
(_("symbol %s not defined for fixups"), |
|||
f->h->root.root.root.string); |
|||
continue; |
|||
} |
|||
|
|||
is = f->h->root.root.u.def.section; |
|||
section_offset = is->output_section->vma + is->output_offset; |
|||
new_addr = f->h->root.root.u.def.value + section_offset; |
|||
|
|||
#ifdef LINUX_LINK_DEBUG |
|||
printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string, |
|||
new_addr, f->value); |
|||
#endif |
|||
|
|||
bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); |
|||
fixup_table += 4; |
|||
bfd_put_32 (output_bfd, f->value, fixup_table); |
|||
fixup_table += 4; |
|||
++fixups_written; |
|||
} |
|||
} |
|||
|
|||
if (linux_hash_table (info)->fixup_count != fixups_written) |
|||
{ |
|||
_bfd_error_handler (_("warning: fixup count mismatch")); |
|||
while (linux_hash_table (info)->fixup_count > fixups_written) |
|||
{ |
|||
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); |
|||
fixup_table += 4; |
|||
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); |
|||
fixup_table += 4; |
|||
++fixups_written; |
|||
} |
|||
} |
|||
|
|||
h = linux_link_hash_lookup (linux_hash_table (info), |
|||
"__BUILTIN_FIXUPS__", |
|||
FALSE, FALSE, FALSE); |
|||
|
|||
if (h != NULL |
|||
&& (h->root.root.type == bfd_link_hash_defined |
|||
|| h->root.root.type == bfd_link_hash_defweak)) |
|||
{ |
|||
is = h->root.root.u.def.section; |
|||
section_offset = is->output_section->vma + is->output_offset; |
|||
new_addr = h->root.root.u.def.value + section_offset; |
|||
|
|||
#ifdef LINUX_LINK_DEBUG |
|||
printf ("Builtin fixup table at %x\n", new_addr); |
|||
#endif |
|||
|
|||
bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); |
|||
} |
|||
else |
|||
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); |
|||
|
|||
if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset), |
|||
SEEK_SET) != 0) |
|||
return FALSE; |
|||
|
|||
if (bfd_bwrite (s->contents, s->size, output_bfd) != s->size) |
|||
return FALSE; |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
#define MY_bfd_link_hash_table_create linux_link_hash_table_create |
|||
#define MY_add_one_symbol linux_add_one_symbol |
|||
#define MY_finish_dynamic_link linux_finish_dynamic_link |
|||
|
|||
#define MY_zmagic_contiguous 1 |
|||
|
|||
#include "aout-target.h" |
|||
@ -1,245 +0,0 @@ |
|||
/* BFD support for Sparc binaries under LynxOS.
|
|||
Copyright (C) 1990-2018 Free Software Foundation, Inc. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
|
|||
/* Do not "beautify" the CONCAT* macro args. Traditional C will not
|
|||
remove whitespace added here, and thus will fail to concatenate |
|||
the tokens. */ |
|||
#define MY(OP) CONCAT2 (sparc_aout_lynx_,OP) |
|||
#define TARGETNAME "a.out-sparc-lynx" |
|||
|
|||
#include "sysdep.h" |
|||
#include "bfd.h" |
|||
#include "libbfd.h" |
|||
|
|||
#include "aout/sun4.h" |
|||
#include "libaout.h" /* BFD a.out internal data structures */ |
|||
|
|||
#include "aout/aout64.h" |
|||
#include "aout/stab_gnu.h" |
|||
#include "aout/ar.h" |
|||
|
|||
void NAME (lynx,set_arch_mach) (bfd *, unsigned long); |
|||
static void choose_reloc_size (bfd *); |
|||
static bfd_boolean NAME (aout,sparclynx_write_object_contents) (bfd *); |
|||
|
|||
/* This is needed to reject a NewsOS file, e.g. in
|
|||
gdb/testsuite/gdb.t10/crossload.exp. <kingdon@cygnus.com> |
|||
I needed to add M_UNKNOWN to recognize a 68000 object, so this will |
|||
probably no longer reject a NewsOS object. <ian@cygnus.com>. */ |
|||
#define MACHTYPE_OK(mtype) ( (mtype) == M_UNKNOWN \ |
|||
|| (mtype) == M_68010 \ |
|||
|| (mtype) == M_68020 \ |
|||
|| (mtype) == M_SPARC) |
|||
|
|||
/* The file @code{aoutf1.h} contains the code for BFD's
|
|||
a.out back end. Control over the generated back end is given by these |
|||
two preprocessor names: |
|||
@table @code |
|||
@item ARCH_SIZE |
|||
This value should be either 32 or 64, depending upon the size of an |
|||
int in the target format. It changes the sizes of the structs which |
|||
perform the memory/disk mapping of structures. |
|||
|
|||
The 64 bit backend may only be used if the host compiler supports 64 |
|||
ints (eg long long with gcc), by defining the name @code{BFD_HOST_64_BIT} in @code{bfd.h}. |
|||
With this name defined, @emph{all} bfd operations are performed with 64bit |
|||
arithmetic, not just those to a 64bit target. |
|||
|
|||
@item TARGETNAME |
|||
The name put into the target vector. |
|||
@item |
|||
@end table */ |
|||
|
|||
void |
|||
NAME(lynx,set_arch_mach) (bfd *abfd, unsigned long machtype) |
|||
{ |
|||
/* Determine the architecture and machine type of the object file. */ |
|||
enum bfd_architecture arch; |
|||
unsigned long machine; |
|||
|
|||
switch (machtype) |
|||
{ |
|||
case M_UNKNOWN: |
|||
/* Some Sun3s make magic numbers without cpu types in them, so
|
|||
we'll default to the 68000. */ |
|||
arch = bfd_arch_m68k; |
|||
machine = bfd_mach_m68000; |
|||
break; |
|||
|
|||
case M_68010: |
|||
case M_HP200: |
|||
arch = bfd_arch_m68k; |
|||
machine = bfd_mach_m68010; |
|||
break; |
|||
|
|||
case M_68020: |
|||
case M_HP300: |
|||
arch = bfd_arch_m68k; |
|||
machine = bfd_mach_m68020; |
|||
break; |
|||
|
|||
case M_SPARC: |
|||
arch = bfd_arch_sparc; |
|||
machine = 0; |
|||
break; |
|||
|
|||
case M_386: |
|||
case M_386_DYNIX: |
|||
arch = bfd_arch_i386; |
|||
machine = 0; |
|||
break; |
|||
|
|||
case M_HPUX: |
|||
arch = bfd_arch_m68k; |
|||
machine = 0; |
|||
break; |
|||
|
|||
default: |
|||
arch = bfd_arch_obscure; |
|||
machine = 0; |
|||
break; |
|||
} |
|||
bfd_set_arch_mach (abfd, arch, machine); |
|||
} |
|||
|
|||
#define SET_ARCH_MACH(ABFD, EXECP) \ |
|||
NAME(lynx,set_arch_mach) (ABFD, N_MACHTYPE (EXECP)); \ |
|||
choose_reloc_size(ABFD); |
|||
|
|||
/* Determine the size of a relocation entry, based on the architecture. */ |
|||
|
|||
static void |
|||
choose_reloc_size (bfd *abfd) |
|||
{ |
|||
switch (bfd_get_arch (abfd)) |
|||
{ |
|||
case bfd_arch_sparc: |
|||
obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE; |
|||
break; |
|||
default: |
|||
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
/* Write an object file in LynxOS format.
|
|||
Section contents have already been written. We write the |
|||
file header, symbols, and relocation. */ |
|||
|
|||
static bfd_boolean |
|||
NAME(aout,sparclynx_write_object_contents) (bfd *abfd) |
|||
{ |
|||
struct external_exec exec_bytes; |
|||
struct internal_exec *execp = exec_hdr (abfd); |
|||
|
|||
/* Magic number, maestro, please! */ |
|||
switch (bfd_get_arch (abfd)) |
|||
{ |
|||
case bfd_arch_m68k: |
|||
switch (bfd_get_mach (abfd)) |
|||
{ |
|||
case bfd_mach_m68010: |
|||
N_SET_MACHTYPE (execp, M_68010); |
|||
break; |
|||
default: |
|||
case bfd_mach_m68020: |
|||
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; |
|||
default: |
|||
N_SET_MACHTYPE (execp, M_UNKNOWN); |
|||
} |
|||
|
|||
choose_reloc_size (abfd); |
|||
|
|||
N_SET_FLAGS (execp, aout_backend_info (abfd)->exec_hdr_flags); |
|||
|
|||
WRITE_HEADERS (abfd, execp); |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
#define MY_set_sizes sparclynx_set_sizes |
|||
static bfd_boolean sparclynx_set_sizes (bfd *); |
|||
|
|||
static bfd_boolean |
|||
sparclynx_set_sizes (bfd *abfd) |
|||
{ |
|||
switch (bfd_get_arch (abfd)) |
|||
{ |
|||
default: |
|||
return FALSE; |
|||
case bfd_arch_sparc: |
|||
adata (abfd).page_size = 0x2000; |
|||
adata (abfd).segment_size = 0x2000; |
|||
adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; |
|||
return TRUE; |
|||
case bfd_arch_m68k: |
|||
adata (abfd).page_size = 0x2000; |
|||
adata (abfd).segment_size = 0x20000; |
|||
adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; |
|||
return TRUE; |
|||
} |
|||
} |
|||
|
|||
static const struct aout_backend_data sparclynx_aout_backend = |
|||
{ |
|||
0, 1, 0, 1, 0, sparclynx_set_sizes, 0, |
|||
0, /* add_dynamic_symbols */ |
|||
0, /* add_one_symbol */ |
|||
0, /* link_dynamic_object */ |
|||
0, /* write_dynamic_symbol */ |
|||
0, /* check_dynamic_reloc */ |
|||
0 /* finish_dynamic_link */ |
|||
}; |
|||
|
|||
|
|||
#define MY_bfd_debug_info_start _bfd_void_bfd |
|||
#define MY_bfd_debug_info_end _bfd_void_bfd |
|||
#define MY_bfd_debug_info_accumulate _bfd_void_bfd_asection |
|||
|
|||
#define MY_write_object_contents NAME(aout,sparclynx_write_object_contents) |
|||
#define MY_backend_data &sparclynx_aout_backend |
|||
|
|||
#define TARGET_IS_BIG_ENDIAN_P |
|||
|
|||
#ifdef LYNX_CORE |
|||
|
|||
char * lynx_core_file_failing_command (); |
|||
int lynx_core_file_failing_signal (); |
|||
bfd_boolean lynx_core_file_matches_executable_p (); |
|||
const bfd_target * lynx_core_file_p (); |
|||
|
|||
#define MY_core_file_failing_command lynx_core_file_failing_command |
|||
#define MY_core_file_failing_signal lynx_core_file_failing_signal |
|||
#define MY_core_file_matches_executable_p lynx_core_file_matches_executable_p |
|||
#define MY_core_file_p lynx_core_file_p |
|||
|
|||
#endif /* LYNX_CORE */ |
|||
|
|||
#include "aout-target.h" |
|||
@ -1,39 +0,0 @@ |
|||
/* BFD back-end for NetBSD/sparc a.out-ish binaries.
|
|||
Copyright (C) 1990-2018 Free Software Foundation, Inc. |
|||
|
|||
This file is part of BFD, the Binary File Descriptor library. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
|||
MA 02110-1301, USA. */ |
|||
|
|||
|
|||
#define TARGET_IS_BIG_ENDIAN_P |
|||
|
|||
/* SPARC chips use either 4K or 8K pages, but object files always
|
|||
assume 8K page alignment so they will work on either one. */ |
|||
#define TARGET_PAGE_SIZE 0x2000 |
|||
|
|||
#define DEFAULT_ARCH bfd_arch_sparc |
|||
#define DEFAULT_MID M_SPARC_NETBSD |
|||
|
|||
/* Do not "beautify" the CONCAT* macro args. Traditional C will not
|
|||
remove whitespace added here, and thus will fail to concatenate |
|||
the tokens. */ |
|||
#define MY(OP) CONCAT2 (sparc_aout_nbsd_,OP) |
|||
|
|||
/* This needs to start with a.out so GDB knows it is an a.out variant. */ |
|||
#define TARGETNAME "a.out-sparc-netbsd" |
|||
|
|||
#include "netbsd.h" |
|||
File diff suppressed because it is too large
@ -1,22 +0,0 @@ |
|||
/* te-sparcaout.h -- embedded sparc-aout target environment declarations.
|
|||
Copyright (C) 1996-2018 Free Software Foundation, Inc. |
|||
|
|||
This file is part of GAS, the GNU Assembler. |
|||
|
|||
GAS 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 3, or (at your option) |
|||
any later version. |
|||
|
|||
GAS 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 GAS; see the file COPYING. If not, write to |
|||
the Free Software Foundation, 51 Franklin Street - Fifth Floor, |
|||
Boston, MA 02110-1301, USA. */ |
|||
|
|||
#define TE_SPARCAOUT 1 |
|||
#include "obj-format.h" |
|||
@ -1,13 +0,0 @@ |
|||
#objdump: -r |
|||
# name : addends |
|||
.*: +file format a.out-sunos-big |
|||
|
|||
RELOCATION RECORDS FOR \[.text\]: |
|||
OFFSET TYPE +VALUE |
|||
0+08 WDISP22 +foo1\+0xf+fc |
|||
0+0c WDISP22 +foo1\+0xf+f8 |
|||
0+10 WDISP22 +foo1\+0xf+f0 |
|||
0+14 WDISP22 +foo1\+0xf+ec |
|||
0+1c 32 +foo1 |
|||
0+20 32 +foo1\+0x0+4 |
|||
#0+20 32 +foo1\+0x0+4 |
|||
@ -1,23 +0,0 @@ |
|||
# Copyright (C) 2012-2018 Free Software Foundation, Inc. |
|||
|
|||
# This program is free software; you can redistribute it and/or modify |
|||
# it under the terms of the GNU General Public License as published by |
|||
# the Free Software Foundation; either version 3 of the License, or |
|||
# (at your option) any later version. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU General Public License for more details. |
|||
# |
|||
# You should have received a copy of the GNU General Public License |
|||
# along with this program; if not, write to the Free Software |
|||
# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. |
|||
|
|||
# |
|||
# SunOS4 on SPARC tests |
|||
# |
|||
|
|||
if [istarget sparc-*-sunos4*] then { |
|||
run_dump_test "addend" |
|||
} |
|||
@ -1,11 +0,0 @@ |
|||
.global foo |
|||
foo: |
|||
nop |
|||
nop |
|||
ba foo1+0x4 |
|||
ba foo1+0x4 |
|||
ba foo1 |
|||
ba foo1 |
|||
nop |
|||
.word foo1 |
|||
.word foo1+4 |
|||
@ -1,9 +0,0 @@ |
|||
SCRIPT_NAME=sparccoff |
|||
OUTPUT_FORMAT="coff-sparc" |
|||
# following are dubious (borrowed from sparc lynx) |
|||
TARGET_PAGE_SIZE=0x1000 |
|||
TEXT_START_ADDR=0 |
|||
case ${LD_FLAG} in |
|||
n|N) TEXT_START_ADDR=0x1000 ;; |
|||
esac |
|||
ARCH=sparc |
|||
@ -1,10 +0,0 @@ |
|||
SCRIPT_NAME=aout |
|||
OUTPUT_FORMAT="a.out-sunos-big" |
|||
BIG_OUTPUT_FORMAT="a.out-sunos-big" |
|||
LITTLE_OUTPUT_FORMAT="a.out-sparc-little" |
|||
TEXT_START_ADDR=0x2020 |
|||
case ${LD_FLAG} in |
|||
n|N) TEXT_START_ADDR=0x2000 ;; |
|||
esac |
|||
TARGET_PAGE_SIZE=0x2000 |
|||
ARCH=sparc |
|||
@ -1,9 +0,0 @@ |
|||
SCRIPT_NAME=aout |
|||
OUTPUT_FORMAT="a.out-sparc-linux" |
|||
TARGET_PAGE_SIZE=0x1000 |
|||
TEXT_START_ADDR=0x1020 |
|||
case ${LD_FLAG} in |
|||
n|N) TEXT_START_ADDR=0 ;; |
|||
esac |
|||
ARCH=sparc |
|||
TEMPLATE_NAME=linux |
|||
@ -1,5 +0,0 @@ |
|||
SCRIPT_NAME=aout |
|||
TEXT_START_ADDR=0x1020 |
|||
OUTPUT_FORMAT="a.out-sparc-netbsd" |
|||
TARGET_PAGE_SIZE=0x1000 |
|||
ARCH=sparc |
|||
@ -1,7 +0,0 @@ |
|||
SCRIPT_NAME=aout |
|||
OUTPUT_FORMAT="a.out-sunos-big" |
|||
TEXT_START_ADDR=0x2020 |
|||
TARGET_PAGE_SIZE=0x2000 |
|||
ALIGNMENT=8 |
|||
ARCH=sparc |
|||
TEMPLATE_NAME=sunos |
|||
@ -1,62 +0,0 @@ |
|||
# Linker script for Sparc COFF. |
|||
# Based on i386coff.sc by Ian Taylor <ian@cygnus.com>. |
|||
# |
|||
# Copyright (C) 2014-2018 Free Software Foundation, Inc. |
|||
# |
|||
# Copying and distribution of this file, with or without modification, |
|||
# are permitted in any medium without royalty provided the copyright |
|||
# notice and this notice are preserved. |
|||
|
|||
test -z "$ENTRY" && ENTRY=_start |
|||
|
|||
cat <<EOF |
|||
/* Copyright (C) 2014-2018 Free Software Foundation, Inc. |
|||
|
|||
Copying and distribution of this script, with or without modification, |
|||
are permitted in any medium without royalty provided the copyright |
|||
notice and this notice are preserved. */ |
|||
|
|||
OUTPUT_FORMAT("${OUTPUT_FORMAT}") |
|||
${LIB_SEARCH_DIRS} |
|||
|
|||
${RELOCATING+ENTRY (${ENTRY})} |
|||
|
|||
SECTIONS |
|||
{ |
|||
.text ${RELOCATING+ SIZEOF_HEADERS} : { |
|||
*(.init) |
|||
*(.text) |
|||
${RELOCATING+ etext = .;} |
|||
${CONSTRUCTING+ ___CTOR_LIST__ = .;} |
|||
${CONSTRUCTING+ LONG((___CTOR_END__ - ___CTOR_LIST__) / 4 - 2)} |
|||
${CONSTRUCTING+ *(.ctors)} |
|||
${CONSTRUCTING+ LONG(0)} |
|||
${CONSTRUCTING+ ___CTOR_END__ = .;} |
|||
${CONSTRUCTING+ ___DTOR_LIST__ = .;} |
|||
${CONSTRUCTING+ LONG((___DTOR_END__ - ___DTOR_LIST__) / 4 - 2)} |
|||
${CONSTRUCTING+ *(.dtors)} |
|||
${CONSTRUCTING+ LONG(0)} |
|||
${CONSTRUCTING+ ___DTOR_END__ = .;} |
|||
*(.fini) |
|||
${RELOCATING+ etext = .}; |
|||
} |
|||
.data ${RELOCATING+ 0x400000 + (. & 0xffc00fff)} : { |
|||
*(.data) |
|||
${RELOCATING+ edata = .}; |
|||
} |
|||
.bss ${RELOCATING+ SIZEOF(.data) + ADDR(.data)} : |
|||
{ |
|||
*(.bss) |
|||
*(COMMON) |
|||
${RELOCATING+ end = .}; |
|||
} |
|||
.stab 0 ${RELOCATING+(NOLOAD)} : |
|||
{ |
|||
[ .stab ] |
|||
} |
|||
.stabstr 0 ${RELOCATING+(NOLOAD)} : |
|||
{ |
|||
[ .stabstr ] |
|||
} |
|||
} |
|||
EOF |
|||
Loading…
Reference in new issue