doc cleanup
This commit is contained in:
parent
5090e82cca
commit
c188b0bec3
|
@ -1,3 +1,13 @@
|
|||
Fri Nov 5 10:41:07 1993 David J. Mackenzie (djm@thepub.cygnus.com)
|
||||
|
||||
* aoutx.h, archive.c, archures.c, bfd.c, cache.c, coffcode.h,
|
||||
core.c, ctor.c, format.c, init.c, libbfd.c, opncls.c, reloc.c,
|
||||
section.c, syms.c, targets.c:
|
||||
Doc cleanup (spelling, punctuation, grammar, formatting).
|
||||
* bfd-in2.h, libbfd.h: Rebuild.
|
||||
* reloc.c (bfd_get_reloc_upper_bound, bfd_canonicalize_reloc,
|
||||
bfd_set_reloc): Moved from bfd.c.
|
||||
|
||||
Thu Nov 4 14:46:14 1993 John Gilmore (gnu@rtl.cygnus.com)
|
||||
|
||||
* bfd-in.h (bfd_get_cacheable, bfd_set_cacheable): New accessors.
|
||||
|
@ -75,6 +85,10 @@ Sun Oct 31 09:35:49 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
|
|||
|
||||
* som.c: Add comment about how abort() on corrupt executable is evil.
|
||||
|
||||
Sat Oct 30 12:27:09 1993 David J. Mackenzie (djm@thepub.cygnus.com)
|
||||
|
||||
* aoutx.h (aout,slurp_reloc_table): Avoid a goto.
|
||||
|
||||
Fri Oct 29 16:04:33 1993 David J. Mackenzie (djm@thepub.cygnus.com)
|
||||
|
||||
* gen-aout.c, libbfd.c: exit(1) instead of exit(-1).
|
||||
|
|
361
bfd/aoutx.h
361
bfd/aoutx.h
|
@ -28,28 +28,28 @@ DESCRIPTION
|
|||
BFD supports a number of different flavours of a.out format,
|
||||
though the major differences are only the sizes of the
|
||||
structures on disk, and the shape of the relocation
|
||||
information.
|
||||
information.
|
||||
|
||||
The support is split into a basic support file @code{aoutx.h}
|
||||
The support is split into a basic support file @file{aoutx.h}
|
||||
and other files which derive functions from the base. One
|
||||
derivation file is @code{aoutf1.h} (for a.out flavour 1), and
|
||||
derivation file is @file{aoutf1.h} (for a.out flavour 1), and
|
||||
adds to the basic a.out functions support for sun3, sun4, 386
|
||||
and 29k a.out files, to create a target jump vector for a
|
||||
specific target.
|
||||
specific target.
|
||||
|
||||
This information is further split out into more specific files
|
||||
for each machine, including @code{sunos.c} for sun3 and sun4,
|
||||
@code{newsos3.c} for the Sony NEWS, and @code{demo64.c} for a
|
||||
for each machine, including @file{sunos.c} for sun3 and sun4,
|
||||
@file{newsos3.c} for the Sony NEWS, and @file{demo64.c} for a
|
||||
demonstration of a 64 bit a.out format.
|
||||
|
||||
The base file @code{aoutx.h} defines general mechanisms for
|
||||
reading and writing records to and from disk, and various
|
||||
The base file @file{aoutx.h} defines general mechanisms for
|
||||
reading and writing records to and from disk and various
|
||||
other methods which BFD requires. It is included by
|
||||
@code{aout32.c} and @code{aout64.c} to form the names
|
||||
aout_32_swap_exec_header_in, aout_64_swap_exec_header_in, etc.
|
||||
@file{aout32.c} and @file{aout64.c} to form the names
|
||||
<<aout_32_swap_exec_header_in>>, <<aout_64_swap_exec_header_in>>, etc.
|
||||
|
||||
As an example, this is what goes on to make the back end for a
|
||||
sun4, from aout32.c
|
||||
sun4, from @file{aout32.c}:
|
||||
|
||||
| #define ARCH_SIZE 32
|
||||
| #include "aoutx.h"
|
||||
|
@ -63,18 +63,18 @@ DESCRIPTION
|
|||
| aout_32_get_reloc_upper_bound
|
||||
| ...
|
||||
|
||||
from sunos.c
|
||||
from @file{sunos.c}:
|
||||
|
||||
| #define ARCH 32
|
||||
| #define TARGET_NAME "a.out-sunos-big"
|
||||
| #define VECNAME sunos_big_vec
|
||||
| #include "aoutf1.h"
|
||||
|
||||
requires all the names from aout32.c, and produces the jump vector
|
||||
requires all the names from @file{aout32.c}, and produces the jump vector
|
||||
|
||||
| sunos_big_vec
|
||||
|
||||
The file host-aout.c is a special case. It is for a large set
|
||||
The file @file{host-aout.c} is a special case. It is for a large set
|
||||
of hosts that use ``more or less standard'' a.out files, and
|
||||
for which cross-debugging is not interesting. It uses the
|
||||
standard 32-bit a.out support routines, but determines the
|
||||
|
@ -82,7 +82,7 @@ DESCRIPTION
|
|||
sections, the machine architecture and machine type, and the
|
||||
entry point address, in a host-dependent manner. Once these
|
||||
values have been determined, generic code is used to handle
|
||||
the object file.
|
||||
the object file.
|
||||
|
||||
When porting it to run on a new system, you must supply:
|
||||
|
||||
|
@ -97,12 +97,12 @@ DESCRIPTION
|
|||
values, plus the structures and macros defined in <<a.out.h>> on
|
||||
your host system, will produce a BFD target that will access
|
||||
ordinary a.out files on your host. To configure a new machine
|
||||
to use <<host-aout.c>., specify:
|
||||
to use <<host-aout.c>., specify:
|
||||
|
||||
| TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
|
||||
| TDEPFILES= host-aout.o trad-core.o
|
||||
|
||||
in the <<config/mt-XXX>> file, and modify configure.in to use the
|
||||
in the <<config/mt-XXX>> file, and modify @file{configure.in} to use the
|
||||
<<mt-XXX>> file (by setting "<<bfd_target=XXX>>") when your
|
||||
configuration is selected.
|
||||
|
||||
|
@ -140,13 +140,13 @@ SUBSECTION
|
|||
relocations
|
||||
|
||||
DESCRIPTION
|
||||
The file @code{aoutx.h} caters for both the @emph{standard}
|
||||
The file @file{aoutx.h} provides for both the @emph{standard}
|
||||
and @emph{extended} forms of a.out relocation records.
|
||||
|
||||
The standard records are characterised by containing only an
|
||||
address, a symbol index and a type field. The extended records
|
||||
The standard records contain only an
|
||||
address, a symbol index, and a type field. The extended records
|
||||
(used on 29ks and sparcs) also have a full integer for an
|
||||
addend.
|
||||
addend.
|
||||
|
||||
*/
|
||||
#define CTOR_TABLE_RELOC_IDX 2
|
||||
|
@ -154,7 +154,7 @@ DESCRIPTION
|
|||
#define howto_table_ext NAME(aout,ext_howto_table)
|
||||
#define howto_table_std NAME(aout,std_howto_table)
|
||||
|
||||
reloc_howto_type howto_table_ext[] =
|
||||
reloc_howto_type howto_table_ext[] =
|
||||
{
|
||||
/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
|
||||
HOWTO(RELOC_8, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", false, 0,0x000000ff, false),
|
||||
|
@ -186,17 +186,22 @@ reloc_howto_type howto_table_ext[] =
|
|||
/* Convert standard reloc records to "arelent" format (incl byte swap). */
|
||||
|
||||
reloc_howto_type howto_table_std[] = {
|
||||
/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
|
||||
HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false),
|
||||
/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
|
||||
HOWTO( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false),
|
||||
HOWTO( 1, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", true, 0x0000ffff,0x0000ffff, false),
|
||||
HOWTO( 2, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", true, 0xffffffff,0xffffffff, false),
|
||||
HOWTO( 3, 0, 3, 64, false, 0, complain_overflow_bitfield,0,"64", true, 0xdeaddead,0xdeaddead, false),
|
||||
HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed,0,"DISP8", true, 0x000000ff,0x000000ff, false),
|
||||
HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed,0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
|
||||
HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed,0,"DISP32", true, 0xffffffff,0xffffffff, false),
|
||||
HOWTO( 7, 0, 3, 64, true, 0, complain_overflow_signed,0,"DISP64", true, 0xfeedface,0xfeedface, false),
|
||||
HOWTO( 3, 0, 4, 64, false, 0, complain_overflow_bitfield,0,"64", true, 0xdeaddead,0xdeaddead, false),
|
||||
HOWTO( 4, 0, 0, 8, true, 0, complain_overflow_signed, 0,"DISP8", true, 0x000000ff,0x000000ff, false),
|
||||
HOWTO( 5, 0, 1, 16, true, 0, complain_overflow_signed, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
|
||||
HOWTO( 6, 0, 2, 32, true, 0, complain_overflow_signed, 0,"DISP32", true, 0xffffffff,0xffffffff, false),
|
||||
HOWTO( 7, 0, 4, 64, true, 0, complain_overflow_signed, 0,"DISP64", true, 0xfeedface,0xfeedface, false),
|
||||
{ -1 },
|
||||
HOWTO( 9, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"BASE16", false,0xffffffff,0xffffffff, false),
|
||||
HOWTO(10, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"BASE32", false,0xffffffff,0xffffffff, false),
|
||||
};
|
||||
|
||||
#define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
|
||||
|
||||
CONST struct reloc_howto_struct *
|
||||
DEFUN(NAME(aout,reloc_type_lookup),(abfd,code),
|
||||
bfd *abfd AND
|
||||
|
@ -219,6 +224,7 @@ DEFUN(NAME(aout,reloc_type_lookup),(abfd,code),
|
|||
EXT (BFD_RELOC_HI22, 8);
|
||||
EXT (BFD_RELOC_LO10, 11);
|
||||
EXT (BFD_RELOC_32_PCREL_S2, 6);
|
||||
EXT (BFD_RELOC_SPARC_WDISP22, 7);
|
||||
default: return (CONST struct reloc_howto_struct *) 0;
|
||||
}
|
||||
else
|
||||
|
@ -230,6 +236,8 @@ DEFUN(NAME(aout,reloc_type_lookup),(abfd,code),
|
|||
STD (BFD_RELOC_8_PCREL, 4);
|
||||
STD (BFD_RELOC_16_PCREL, 5);
|
||||
STD (BFD_RELOC_32_PCREL, 6);
|
||||
STD (BFD_RELOC_16_BASEREL, 9);
|
||||
STD (BFD_RELOC_32_BASEREL, 10);
|
||||
default: return (CONST struct reloc_howto_struct *) 0;
|
||||
}
|
||||
}
|
||||
|
@ -241,7 +249,7 @@ SUBSECTION
|
|||
Internal Entry Points
|
||||
|
||||
DESCRIPTION
|
||||
@code{aoutx.h} exports several routines for accessing the
|
||||
@file{aoutx.h} exports several routines for accessing the
|
||||
contents of an a.out file, which are gathered and exported in
|
||||
turn by various format specific files (eg sunos.c).
|
||||
|
||||
|
@ -249,20 +257,20 @@ DESCRIPTION
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_swap_exec_header_in
|
||||
|
||||
DESCRIPTION
|
||||
Swaps the information in an executable header taken from a raw
|
||||
byte stream memory image, into the internal exec_header
|
||||
structure.
|
||||
aout_@var{size}_swap_exec_header_in
|
||||
|
||||
SYNOPSIS
|
||||
void aout_<size>_swap_exec_header_in,
|
||||
void aout_@var{size}_swap_exec_header_in,
|
||||
(bfd *abfd,
|
||||
struct external_exec *raw_bytes,
|
||||
struct internal_exec *execp);
|
||||
|
||||
DESCRIPTION
|
||||
Swap the information in an executable header @var{raw_bytes} taken
|
||||
from a raw byte stream memory image into the internal exec header
|
||||
structure @var{execp}.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef NAME_swap_exec_header_in
|
||||
void
|
||||
DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
|
||||
|
@ -292,22 +300,22 @@ DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_swap_exec_header_out
|
||||
|
||||
DESCRIPTION
|
||||
Swaps the information in an internal exec header structure
|
||||
into the supplied buffer ready for writing to disk.
|
||||
aout_@var{size}_swap_exec_header_out
|
||||
|
||||
SYNOPSIS
|
||||
void aout_<size>_swap_exec_header_out
|
||||
void aout_@var{size}_swap_exec_header_out
|
||||
(bfd *abfd,
|
||||
struct internal_exec *execp,
|
||||
struct external_exec *raw_bytes);
|
||||
|
||||
DESCRIPTION
|
||||
Swap the information in an internal exec header structure
|
||||
@var{execp} into the buffer @var{raw_bytes} ready for writing to disk.
|
||||
*/
|
||||
void
|
||||
DEFUN(NAME(aout,swap_exec_header_out),(abfd, execp, raw_bytes),
|
||||
bfd *abfd AND
|
||||
struct internal_exec *execp AND
|
||||
struct internal_exec *execp AND
|
||||
struct external_exec *raw_bytes)
|
||||
{
|
||||
struct external_exec *bytes = (struct external_exec *)raw_bytes;
|
||||
|
@ -327,21 +335,21 @@ DEFUN(NAME(aout,swap_exec_header_out),(abfd, execp, raw_bytes),
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_some_aout_object_p
|
||||
|
||||
DESCRIPTION
|
||||
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.
|
||||
aout_@var{size}_some_aout_object_p
|
||||
|
||||
SYNOPSIS
|
||||
bfd_target *aout_<size>_some_aout_object_p
|
||||
bfd_target *aout_@var{size}_some_aout_object_p
|
||||
(bfd *abfd,
|
||||
bfd_target *(*callback_to_real_object_p)());
|
||||
|
||||
DESCRIPTION
|
||||
Some a.out variant thinks that the file open in @var{abfd}
|
||||
checking is an a.out file. Do some more checking, and set up
|
||||
for access if it really is. Call back to the calling
|
||||
environment's "finish up" function just before returning, to
|
||||
handle any last-minute setup.
|
||||
*/
|
||||
|
||||
|
||||
bfd_target *
|
||||
DEFUN(NAME(aout,some_aout_object_p),(abfd, execp, callback_to_real_object_p),
|
||||
bfd *abfd AND
|
||||
|
@ -376,7 +384,7 @@ DEFUN(NAME(aout,some_aout_object_p),(abfd, execp, callback_to_real_object_p),
|
|||
if (execp->a_drsize || execp->a_trsize)
|
||||
abfd->flags |= HAS_RELOC;
|
||||
/* Setting of EXEC_P has been deferred to the bottom of this function */
|
||||
if (execp->a_syms)
|
||||
if (execp->a_syms)
|
||||
abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
|
||||
|
||||
if (N_MAGIC (*execp) == ZMAGIC)
|
||||
|
@ -430,11 +438,11 @@ DEFUN(NAME(aout,some_aout_object_p),(abfd, execp, callback_to_real_object_p),
|
|||
#ifdef THIS_IS_ONLY_DOCUMENTATION
|
||||
/* The common code can't fill in these 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
|
||||
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. */
|
||||
|
||||
/* Call back to the format-dependent code to fill in the rest of the
|
||||
/* 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: */
|
||||
|
||||
|
@ -479,7 +487,7 @@ DEFUN(NAME(aout,some_aout_object_p),(abfd, execp, callback_to_real_object_p),
|
|||
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 */
|
||||
|
@ -490,7 +498,7 @@ DEFUN(NAME(aout,some_aout_object_p),(abfd, execp, callback_to_real_object_p),
|
|||
guess at whether the file is executable. If the entry point
|
||||
is within the text segment, assume it is. (This makes files
|
||||
executable even if their entry point address is 0, as long as
|
||||
their text starts at zero.)
|
||||
their text starts at zero.)
|
||||
|
||||
At some point we should probably break down and stat the file and
|
||||
declare it executable if (one of) its 'x' bits are on... */
|
||||
|
@ -515,13 +523,13 @@ DEFUN(NAME(aout,some_aout_object_p),(abfd, execp, callback_to_real_object_p),
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_mkobject
|
||||
|
||||
DESCRIPTION
|
||||
This routine initializes a BFD for use with a.out files.
|
||||
aout_@var{size}_mkobject
|
||||
|
||||
SYNOPSIS
|
||||
boolean aout_<size>_mkobject, (bfd *);
|
||||
boolean aout_@var{size}_mkobject, (bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Initialize BFD @var{abfd} for use with a.out files.
|
||||
*/
|
||||
|
||||
boolean
|
||||
|
@ -534,17 +542,17 @@ DEFUN(NAME(aout,mkobject),(abfd),
|
|||
|
||||
/* Use an intermediate variable for clarity */
|
||||
rawptr = (struct aout_data_struct *)bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
|
||||
|
||||
|
||||
if (rawptr == NULL) {
|
||||
bfd_error = no_memory;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
abfd->tdata.aout_data = 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;
|
||||
|
@ -554,28 +562,28 @@ DEFUN(NAME(aout,mkobject),(abfd),
|
|||
bfd_make_section (abfd, BFD_ABS_SECTION_NAME);
|
||||
bfd_make_section (abfd, BFD_UND_SECTION_NAME);
|
||||
bfd_make_section (abfd, BFD_COM_SECTION_NAME);
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_machine_type
|
||||
aout_@var{size}_machine_type
|
||||
|
||||
SYNOPSIS
|
||||
enum machine_type aout_@var{size}_machine_type
|
||||
(enum bfd_architecture arch,
|
||||
unsigned long machine));
|
||||
|
||||
DESCRIPTION
|
||||
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.
|
||||
a.out's. Return the <<machine_type>> for a particular
|
||||
architecture and machine, or <<M_UNKNOWN>> if that exact architecture
|
||||
and machine can't be represented in a.out format.
|
||||
|
||||
If the architecture is understood, machine type 0 (default)
|
||||
should always be understood.
|
||||
|
||||
SYNOPSIS
|
||||
enum machine_type aout_<size>_machine_type
|
||||
(enum bfd_architecture arch,
|
||||
unsigned long machine));
|
||||
is always understood.
|
||||
*/
|
||||
|
||||
enum machine_type
|
||||
|
@ -584,14 +592,14 @@ DEFUN(NAME(aout,machine_type),(arch, machine),
|
|||
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;
|
||||
|
@ -601,15 +609,15 @@ DEFUN(NAME(aout,machine_type),(arch, machine),
|
|||
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;
|
||||
|
||||
|
||||
case bfd_arch_mips:
|
||||
switch (machine) {
|
||||
case 0:
|
||||
|
@ -631,18 +639,18 @@ DEFUN(NAME(aout,machine_type),(arch, machine),
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_set_arch_mach
|
||||
|
||||
DESCRIPTION
|
||||
Sets the architecture and the machine of the BFD to those
|
||||
values supplied. Verifies that the format can support the
|
||||
architecture required.
|
||||
aout_@var{size}_set_arch_mach
|
||||
|
||||
SYNOPSIS
|
||||
boolean aout_<size>_set_arch_mach,
|
||||
boolean aout_@var{size}_set_arch_mach,
|
||||
(bfd *,
|
||||
enum bfd_architecture,
|
||||
enum bfd_architecture arch,
|
||||
unsigned long machine));
|
||||
|
||||
DESCRIPTION
|
||||
Set the architecture and the machine of the BFD @var{abfd} to the
|
||||
values @var{arch} and @var{machine}. Verify that @var{abfd}'s format
|
||||
can support the architecture required.
|
||||
*/
|
||||
|
||||
boolean
|
||||
|
@ -678,13 +686,13 @@ DEFUN (NAME (aout,adjust_sizes_and_vmas), (abfd, text_size, text_end),
|
|||
bfd *abfd AND bfd_size_type *text_size AND file_ptr *text_end)
|
||||
{
|
||||
struct internal_exec *execp = exec_hdr (abfd);
|
||||
if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL))
|
||||
if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL))
|
||||
{
|
||||
bfd_error = invalid_operation;
|
||||
return false;
|
||||
}
|
||||
if (adata(abfd).magic != undecided_magic) return true;
|
||||
obj_textsec(abfd)->_raw_size =
|
||||
obj_textsec(abfd)->_raw_size =
|
||||
align_power(obj_textsec(abfd)->_raw_size,
|
||||
obj_textsec(abfd)->alignment_power);
|
||||
|
||||
|
@ -894,16 +902,16 @@ DEFUN (NAME (aout,adjust_sizes_and_vmas), (abfd, text_size, text_end),
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
aout_<size>_new_section_hook
|
||||
|
||||
aout_@var{size}_new_section_hook
|
||||
|
||||
SYNOPSIS
|
||||
boolean aout_@var{size}_new_section_hook,
|
||||
(bfd *abfd,
|
||||
asection *newsect));
|
||||
|
||||
DESCRIPTION
|
||||
Called by the BFD in response to a @code{bfd_make_section}
|
||||
request.
|
||||
|
||||
SYNOPSIS
|
||||
boolean aout_<size>_new_section_hook,
|
||||
(bfd *abfd,
|
||||
asection *newsect));
|
||||
*/
|
||||
boolean
|
||||
DEFUN(NAME(aout,new_section_hook),(abfd, newsect),
|
||||
|
@ -913,21 +921,21 @@ DEFUN(NAME(aout,new_section_hook),(abfd, newsect),
|
|||
/* align to double at least */
|
||||
newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
|
||||
|
||||
|
||||
if (bfd_get_format (abfd) == bfd_object)
|
||||
|
||||
if (bfd_get_format (abfd) == bfd_object)
|
||||
{
|
||||
if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) {
|
||||
obj_textsec(abfd)= newsect;
|
||||
newsect->target_index = N_TEXT | N_EXT;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) {
|
||||
obj_datasec(abfd) = newsect;
|
||||
newsect->target_index = N_DATA | N_EXT;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) {
|
||||
obj_bsssec(abfd) = newsect;
|
||||
newsect->target_index = N_BSS | N_EXT;
|
||||
|
@ -935,7 +943,7 @@ DEFUN(NAME(aout,new_section_hook),(abfd, newsect),
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/* We allow more than three sections internally */
|
||||
return true;
|
||||
}
|
||||
|
@ -960,10 +968,10 @@ DEFUN(NAME(aout,set_section_contents),(abfd, section, location, offset, count),
|
|||
}
|
||||
|
||||
/* regardless, once we know what we're doing, we might as well get going */
|
||||
if (section != obj_bsssec(abfd))
|
||||
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;
|
||||
|
@ -998,7 +1006,7 @@ DEFUN(NAME(aout,set_section_contents),(abfd, section, location, offset, count),
|
|||
/* 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))
|
||||
(((sym)->type & ~(N_EXT | N_TYPE)) || (sym)->type == N_FN)
|
||||
|
||||
#define sym_is_fortrancommon(sym) \
|
||||
(((sym)->type == (N_EXT)) && (sym)->symbol.value != 0)
|
||||
|
@ -1013,7 +1021,7 @@ DEFUN(NAME(aout,set_section_contents),(abfd, section, location, offset, count),
|
|||
|
||||
/* 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
|
||||
|
@ -1235,7 +1243,7 @@ DEFUN(translate_to_native_sym_flags,(sym_pointer, cache_ptr, abfd),
|
|||
to another */
|
||||
sym_pointer->e_type[0] &= ~N_TYPE;
|
||||
|
||||
|
||||
|
||||
/* We attempt to order these tests by decreasing frequency of success,
|
||||
according to tcov when linking the linker. */
|
||||
if (bfd_get_output_section(cache_ptr) == &bfd_abs_section) {
|
||||
|
@ -1250,41 +1258,41 @@ DEFUN(translate_to_native_sym_flags,(sym_pointer, cache_ptr, abfd),
|
|||
else 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) == &bfd_und_section)
|
||||
else if (bfd_get_output_section(cache_ptr) == &bfd_und_section)
|
||||
{
|
||||
sym_pointer->e_type[0] = (N_UNDF | N_EXT);
|
||||
}
|
||||
else if (bfd_get_output_section(cache_ptr) == &bfd_ind_section)
|
||||
else if (bfd_get_output_section(cache_ptr) == &bfd_ind_section)
|
||||
{
|
||||
sym_pointer->e_type[0] = N_INDR;
|
||||
}
|
||||
else if (bfd_is_com_section (bfd_get_output_section (cache_ptr))) {
|
||||
sym_pointer->e_type[0] = (N_UNDF | N_EXT);
|
||||
}
|
||||
else {
|
||||
if (cache_ptr->section->output_section)
|
||||
}
|
||||
else {
|
||||
if (cache_ptr->section->output_section)
|
||||
{
|
||||
|
||||
|
||||
bfd_error_vector.nonrepresentable_section(abfd,
|
||||
bfd_get_output_section(cache_ptr)->name);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
bfd_error_vector.nonrepresentable_section(abfd,
|
||||
cache_ptr->section->name);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
/* Turn the symbol from section relative to absolute again */
|
||||
|
||||
|
||||
value += cache_ptr->section->output_section->vma + cache_ptr->section->output_offset ;
|
||||
|
||||
|
||||
if (cache_ptr->flags & (BSF_WARNING)) {
|
||||
(sym_pointer+1)->e_type[0] = 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (cache_ptr->flags & BSF_DEBUGGING) {
|
||||
sym_pointer->e_type[0] = ((aout_symbol_type *)cache_ptr)->type;
|
||||
}
|
||||
|
@ -1383,7 +1391,7 @@ DEFUN(NAME(aout,slurp_symbol_table),(abfd),
|
|||
|
||||
/* Run through table and copy values */
|
||||
for (sym_pointer = syms, cache_ptr = cached;
|
||||
sym_pointer < sym_end; sym_pointer ++, cache_ptr++)
|
||||
sym_pointer < sym_end; sym_pointer ++, cache_ptr++)
|
||||
{
|
||||
long x = GET_WORD(abfd, sym_pointer->e_strx);
|
||||
cache_ptr->symbol.the_bfd = abfd;
|
||||
|
@ -1882,27 +1890,28 @@ DEFUN(NAME(aout,swap_std_reloc_out),(abfd, g, natptr),
|
|||
|
||||
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;
|
||||
/* XXX This relies on relocs coming from a.out files. */
|
||||
r_baserel = (g->howto->type & 8) != 0;
|
||||
/* r_jmptable, r_relative??? FIXME-soon */
|
||||
r_jmptable = 0;
|
||||
r_relative = 0;
|
||||
|
||||
|
||||
r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
|
||||
|
||||
|
||||
/* name was clobbered by aout_write_syms to be symbol index */
|
||||
|
||||
/* If this relocation is relative to a symbol then set the
|
||||
/* If this relocation is relative to a symbol then set the
|
||||
r_index to the symbols index, and the r_extern bit.
|
||||
|
||||
Absolute symbols can come in in two ways, either as an offset
|
||||
from the abs section, or as a symbol which has an abs value.
|
||||
check for that here
|
||||
*/
|
||||
|
||||
|
||||
|
||||
if (bfd_is_com_section (output_section)
|
||||
|| output_section == &bfd_abs_section
|
||||
|| output_section == &bfd_und_section)
|
||||
|| output_section == &bfd_und_section)
|
||||
{
|
||||
if (bfd_abs_section.symbol == sym)
|
||||
{
|
||||
|
@ -1911,19 +1920,19 @@ DEFUN(NAME(aout,swap_std_reloc_out),(abfd, g, natptr),
|
|||
r_index = 0;
|
||||
r_extern = 0;
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
/* Fill in symbol */
|
||||
r_extern = 1;
|
||||
r_index = stoi((*(g->sym_ptr_ptr))->KEEPIT);
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
/* Just an ordinary section */
|
||||
r_extern = 0;
|
||||
r_index = output_section->target_index;
|
||||
r_index = output_section->target_index;
|
||||
}
|
||||
|
||||
/* now the fun stuff */
|
||||
|
@ -1966,24 +1975,22 @@ DEFUN(NAME(aout,swap_ext_reloc_out),(abfd, g, natptr),
|
|||
int r_extern;
|
||||
unsigned int r_type;
|
||||
unsigned int r_addend;
|
||||
asymbol *sym = *(g->sym_ptr_ptr);
|
||||
asymbol *sym = *(g->sym_ptr_ptr);
|
||||
asection *output_section = sym->section->output_section;
|
||||
|
||||
|
||||
PUT_WORD (abfd, g->address, natptr->r_address);
|
||||
|
||||
|
||||
r_type = (unsigned int) g->howto->type;
|
||||
|
||||
|
||||
r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
|
||||
|
||||
|
||||
/* If this relocation is relative to a symbol then set the
|
||||
/* If this relocation is relative to a symbol then set the
|
||||
r_index to the symbols index, and the r_extern bit.
|
||||
|
||||
Absolute symbols can come in in two ways, either as an offset
|
||||
from the abs section, or as a symbol which has an abs value.
|
||||
check for that here
|
||||
*/
|
||||
|
||||
check for that here. */
|
||||
|
||||
if (bfd_is_com_section (output_section)
|
||||
|| output_section == &bfd_abs_section
|
||||
|| output_section == &bfd_und_section)
|
||||
|
@ -1995,28 +2002,27 @@ DEFUN(NAME(aout,swap_ext_reloc_out),(abfd, g, natptr),
|
|||
r_index = 0;
|
||||
r_extern = 0;
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
r_extern = 1;
|
||||
r_index = stoi((*(g->sym_ptr_ptr))->KEEPIT);
|
||||
}
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
/* Just an ordinary section */
|
||||
r_extern = 0;
|
||||
r_index = output_section->target_index;
|
||||
r_index = output_section->target_index;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* 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);
|
||||
((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;
|
||||
|
@ -2031,7 +2037,7 @@ DEFUN(NAME(aout,swap_ext_reloc_out),(abfd, g, natptr),
|
|||
|
||||
/* BFD deals internally with all things based from the section they're
|
||||
in. so, something in 10 bytes into a text section with a base of
|
||||
50 would have a symbol (.text+10) and know .text vma was 50.
|
||||
50 would have a symbol (.text+10) and know .text vma was 50.
|
||||
|
||||
Aout keeps all it's symbols based from zero, so the symbol would
|
||||
contain 60. This macro subs the base of each section from the value
|
||||
|
@ -2119,6 +2125,7 @@ DEFUN(NAME(aout,swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
|
|||
int r_pcrel;
|
||||
int r_baserel, r_jmptable, r_relative;
|
||||
struct aoutdata *su = &(abfd->tdata.aout_data->a);
|
||||
int howto_idx;
|
||||
|
||||
cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
|
||||
|
||||
|
@ -2132,7 +2139,7 @@ DEFUN(NAME(aout,swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
|
|||
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)
|
||||
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)
|
||||
|
@ -2143,12 +2150,17 @@ DEFUN(NAME(aout,swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
|
|||
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)
|
||||
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 */
|
||||
howto_idx = r_length + 4 * r_pcrel + 8 * r_baserel;
|
||||
BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
|
||||
cache_ptr->howto = howto_table_std + howto_idx;
|
||||
BFD_ASSERT (cache_ptr->howto->type != -1);
|
||||
BFD_ASSERT (r_jmptable == 0);
|
||||
BFD_ASSERT (r_relative == 0);
|
||||
/* FIXME-soon: Roll jmptable, relative bits into howto setting */
|
||||
|
||||
MOVE_ADDRESS(0);
|
||||
}
|
||||
|
@ -2173,18 +2185,13 @@ DEFUN(NAME(aout,slurp_reloc_table),(abfd, asect, symbols),
|
|||
|
||||
if (asect == obj_datasec (abfd)) {
|
||||
reloc_size = exec_hdr(abfd)->a_drsize;
|
||||
goto doit;
|
||||
}
|
||||
|
||||
if (asect == obj_textsec (abfd)) {
|
||||
} else if (asect == obj_textsec (abfd)) {
|
||||
reloc_size = exec_hdr(abfd)->a_trsize;
|
||||
goto doit;
|
||||
} else {
|
||||
bfd_error = invalid_operation;
|
||||
return false;
|
||||
}
|
||||
|
||||
bfd_error = invalid_operation;
|
||||
return false;
|
||||
|
||||
doit:
|
||||
bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
|
||||
each_size = obj_reloc_entry_size (abfd);
|
||||
|
||||
|
@ -2221,12 +2228,12 @@ nomem:
|
|||
NAME(aout,swap_ext_reloc_in)(abfd, rptr, cache_ptr, symbols);
|
||||
}
|
||||
} else {
|
||||
register struct reloc_std_external *rptr = (struct reloc_std_external*) relocs;
|
||||
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);
|
||||
NAME(aout,swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -2265,14 +2272,14 @@ DEFUN(NAME(aout,squirt_out_relocs),(abfd, section),
|
|||
|
||||
generic = section->orelocation;
|
||||
|
||||
if (each_size == RELOC_EXT_SIZE)
|
||||
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
|
||||
else
|
||||
{
|
||||
for (natptr = native;
|
||||
count != 0;
|
||||
|
@ -2314,7 +2321,7 @@ DEFUN(NAME(aout,canonicalize_reloc),(abfd, section, relptr, symbols),
|
|||
tblptr = section->relocation;
|
||||
if (!tblptr) return 0;
|
||||
|
||||
for (count = 0; count++ < section->reloc_count;)
|
||||
for (count = 0; count++ < section->reloc_count;)
|
||||
{
|
||||
*relptr++ = tblptr++;
|
||||
}
|
||||
|
@ -2369,7 +2376,7 @@ DEFUN(NAME(aout,get_lineno),(ignore_abfd, ignore_symbol),
|
|||
return (alent *)NULL;
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
DEFUN(NAME(aout,get_symbol_info),(ignore_abfd, symbol, ret),
|
||||
bfd *ignore_abfd AND
|
||||
asymbol *symbol AND
|
||||
|
@ -2395,7 +2402,7 @@ DEFUN(NAME(aout,get_symbol_info),(ignore_abfd, symbol, ret),
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
DEFUN(NAME(aout,print_symbol),(ignore_abfd, afile, symbol, how),
|
||||
bfd *ignore_abfd AND
|
||||
PTR afile AND
|
||||
|
@ -2433,12 +2440,12 @@ DEFUN(NAME(aout,print_symbol),(ignore_abfd, afile, symbol, how),
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
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,
|
||||
|
@ -2548,7 +2555,7 @@ DEFUN(NAME(aout,find_nearest_line),(abfd,
|
|||
|
||||
}
|
||||
|
||||
int
|
||||
int
|
||||
DEFUN(NAME(aout,sizeof_headers),(abfd, execable),
|
||||
bfd *abfd AND
|
||||
boolean execable)
|
||||
|
|
145
bfd/archive.c
145
bfd/archive.c
|
@ -24,28 +24,26 @@ SECTION
|
|||
Archives
|
||||
|
||||
DESCRIPTION
|
||||
Archives are supported in BFD in <<archive.c>>.
|
||||
|
||||
An archive (or library) is just another BFD. It has a symbol
|
||||
table, although there's not much a user program will do with it.
|
||||
|
||||
The big difference between an archive BFD and an ordinary BFD
|
||||
is that the archive doesn't have sections. Instead it has a
|
||||
chain of BFDs considered its contents. These BFDs can be
|
||||
manipulated just like any other. The BFDs contained in an
|
||||
archive opened for reading will all be opened for reading; you
|
||||
chain of BFDs that are considered its contents. These BFDs can
|
||||
be manipulated like any other. The BFDs contained in an
|
||||
archive opened for reading will all be opened for reading. You
|
||||
may put either input or output BFDs into an archive opened for
|
||||
output; it will be handled correctly when the archive is closed.
|
||||
output; they will be handled correctly when the archive is closed.
|
||||
|
||||
Use <<bfd_openr_next_archived_file>> to step through all
|
||||
the contents of an archive opened for input. It's not
|
||||
required that you read the entire archive if you don't want
|
||||
Use <<bfd_openr_next_archived_file>> to step through
|
||||
the contents of an archive opened for input. You don't
|
||||
have to read the entire archive if you don't want
|
||||
to! Read it until you find what you want.
|
||||
|
||||
Archive contents of output BFDs are chained through the
|
||||
<<next>> pointer in a BFD. The first one is findable through
|
||||
the <<archive_head>> slot of the archive. Set it with
|
||||
<<set_archive_head>> (q.v.). A given BFD may be in only one
|
||||
<<bfd_set_archive_head>> (q.v.). A given BFD may be in only one
|
||||
open output archive at a time.
|
||||
|
||||
As expected, the BFD archive code is more general than the
|
||||
|
@ -56,7 +54,7 @@ DESCRIPTION
|
|||
|
||||
This can cause unexpected confusion, since some archive
|
||||
formats are more expressive than others. For instance, Intel
|
||||
COFF archives can preserve long filenames; Sun a.out archives
|
||||
COFF archives can preserve long filenames; SunOS a.out archives
|
||||
cannot. If you move a file from the first to the second
|
||||
format and back again, the filename may be truncated.
|
||||
Likewise, different a.out environments have different
|
||||
|
@ -67,10 +65,13 @@ DESCRIPTION
|
|||
|
||||
Beware: most of these formats do not react well to the
|
||||
presence of spaces in filenames. We do the best we can, but
|
||||
can't always handle this due to restrctions in the format of
|
||||
archives. Many unix utilities are braindead in regards to
|
||||
can't always handle this case due to restrictions in the format of
|
||||
archives. Many Unix utilities are braindead in regards to
|
||||
spaces and such in filenames anyway, so this shouldn't be much
|
||||
of a restriction.
|
||||
|
||||
Archives are supported in BFD in <<archive.c>>.
|
||||
|
||||
*/
|
||||
|
||||
/* Assumes:
|
||||
|
@ -80,12 +81,12 @@ DESCRIPTION
|
|||
*/
|
||||
|
||||
/* Some formats provide a way to cram a long filename into the short
|
||||
(16 chars) space provided by a bsd archive. The trick is: make a
|
||||
(16 chars) space provided by a BSD archive. The trick is: make a
|
||||
special "file" in the front of the archive, sort of like the SYMDEF
|
||||
entry. If the filename is too long to fit, put it in the extended
|
||||
name table, and use its index as the filename. To prevent
|
||||
confusion prepend the index with a space. This means you can't
|
||||
have filenames that start with a space, but then again, many unix
|
||||
have filenames that start with a space, but then again, many Unix
|
||||
utilities can't handle that anyway.
|
||||
|
||||
This scheme unfortunately requires that you stand on your head in
|
||||
|
@ -99,7 +100,7 @@ DESCRIPTION
|
|||
|
||||
BSD 4.4 uses a third scheme: It writes a long filename
|
||||
directly after the header. This allows 'ar q' to work.
|
||||
We current can read BSD 4.4 archives, but not write them.
|
||||
We currently can read BSD 4.4 archives, but not write them.
|
||||
*/
|
||||
|
||||
/* Summary of archive member names:
|
||||
|
@ -141,6 +142,15 @@ extern int errno;
|
|||
#define BFD_GNU960_ARMAG(abfd) (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
|
||||
#endif
|
||||
|
||||
/* Can't define this in hosts/foo.h, because (e.g. in gprof) the hosts file
|
||||
is included, then obstack.h, which thinks if offsetof is defined, it
|
||||
doesn't need to include stddef.h. */
|
||||
/* Define offsetof for those systems which lack it */
|
||||
|
||||
#if !defined (offsetof)
|
||||
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
|
||||
#endif
|
||||
|
||||
/* We keep a cache of archive filepointers to archive elements to
|
||||
speed up searching the archive by filepos. We only add an entry to
|
||||
the cache when we actually read one. We also don't sort the cache;
|
||||
|
@ -190,15 +200,15 @@ FUNCTION
|
|||
bfd_get_next_mapent
|
||||
|
||||
SYNOPSIS
|
||||
symindex bfd_get_next_mapent(bfd *, symindex previous, carsym ** sym);
|
||||
symindex bfd_get_next_mapent(bfd *abfd, symindex previous, carsym **sym);
|
||||
|
||||
DESCRIPTION
|
||||
This function steps through an archive's symbol table (if it
|
||||
has one). Successively updates <<sym>> with the next symbol's
|
||||
Step through archive @var{abfd}'s symbol table (if it
|
||||
has one). Successively update @var{sym} with the next symbol's
|
||||
information, returning that symbol's (internal) index into the
|
||||
symbol table.
|
||||
|
||||
Supply BFD_NO_MORE_SYMBOLS as the <<previous>> entry to get
|
||||
Supply BFD_NO_MORE_SYMBOLS as the @var{previous} entry to get
|
||||
the first one; returns BFD_NO_MORE_SYMBOLS when you're already
|
||||
got the last one.
|
||||
|
||||
|
@ -226,6 +236,7 @@ DEFUN(bfd_get_next_mapent,(abfd, prev, entry),
|
|||
}
|
||||
|
||||
/* To be called by backends only */
|
||||
|
||||
bfd *
|
||||
_bfd_create_empty_archive_element_shell (obfd)
|
||||
bfd *obfd;
|
||||
|
@ -233,10 +244,11 @@ _bfd_create_empty_archive_element_shell (obfd)
|
|||
bfd *nbfd;
|
||||
|
||||
nbfd = new_bfd_contained_in(obfd);
|
||||
if (nbfd == NULL) {
|
||||
bfd_error = no_memory;
|
||||
return NULL;
|
||||
}
|
||||
if (nbfd == NULL)
|
||||
{
|
||||
bfd_error = no_memory;
|
||||
return NULL;
|
||||
}
|
||||
return nbfd;
|
||||
}
|
||||
|
||||
|
@ -248,8 +260,8 @@ SYNOPSIS
|
|||
boolean bfd_set_archive_head(bfd *output, bfd *new_head);
|
||||
|
||||
DESCRIPTION
|
||||
Used whilst processing archives. Sets the head of the chain of
|
||||
BFDs contained in an archive to @var{new_head}.
|
||||
Set the head of the chain of
|
||||
BFDs contained in the archive @var{output} to @var{new_head}.
|
||||
*/
|
||||
|
||||
boolean
|
||||
|
@ -463,28 +475,33 @@ snarf_ar_hdr (abfd)
|
|||
*/
|
||||
|
||||
bfd *
|
||||
DEFUN (get_elt_at_filepos, (archive, filepos),
|
||||
bfd *archive AND
|
||||
file_ptr filepos)
|
||||
get_elt_at_filepos (archive, filepos)
|
||||
bfd *archive;
|
||||
file_ptr filepos;
|
||||
{
|
||||
struct areltdata *new_areldata;
|
||||
bfd *n_nfd;
|
||||
|
||||
n_nfd = look_for_bfd_in_cache (archive, filepos);
|
||||
if (n_nfd) return n_nfd;
|
||||
if (n_nfd)
|
||||
return n_nfd;
|
||||
|
||||
if (0 > bfd_seek (archive, filepos, SEEK_SET)) {
|
||||
bfd_error = system_call_error;
|
||||
if (0 > bfd_seek (archive, filepos, SEEK_SET))
|
||||
{
|
||||
bfd_error = system_call_error;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((new_areldata = snarf_ar_hdr (archive)) == NULL)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((new_areldata = snarf_ar_hdr (archive)) == NULL) return NULL;
|
||||
|
||||
n_nfd = _bfd_create_empty_archive_element_shell (archive);
|
||||
if (n_nfd == NULL) {
|
||||
bfd_release (archive, (PTR)new_areldata);
|
||||
return NULL;
|
||||
}
|
||||
if (n_nfd == NULL)
|
||||
{
|
||||
bfd_release (archive, (PTR)new_areldata);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
n_nfd->origin = bfd_tell (archive);
|
||||
n_nfd->arelt_data = (PTR) new_areldata;
|
||||
n_nfd->filename = new_areldata->filename;
|
||||
|
@ -503,11 +520,12 @@ FUNCTION
|
|||
bfd_get_elt_at_index
|
||||
|
||||
SYNOPSIS
|
||||
bfd *bfd_get_elt_at_index(bfd * archive, int index);
|
||||
bfd *bfd_get_elt_at_index(bfd *archive, int index);
|
||||
|
||||
DESCRIPTION
|
||||
Return the bfd which is referenced by the symbol indexed by <<index>>.
|
||||
<<index>> should have been returned by <<bfd_get_next_mapent>> (q.v.).
|
||||
Return the BFD which is referenced by the symbol in @var{archive}
|
||||
indexed by @var{index}. @var{index} should have been returned by
|
||||
<<bfd_get_next_mapent>> (q.v.).
|
||||
|
||||
*/
|
||||
bfd *
|
||||
|
@ -526,12 +544,12 @@ FUNCTION
|
|||
bfd_openr_next_archived_file
|
||||
|
||||
SYNOPSIS
|
||||
bfd* bfd_openr_next_archived_file(bfd *archive, bfd *previous);
|
||||
bfd *bfd_openr_next_archived_file(bfd *archive, bfd *previous);
|
||||
|
||||
DESCRIPTION
|
||||
Initially provided a BFD containing an archive and NULL, opens
|
||||
an inpout BFD on the first contained element and returns that.
|
||||
Subsequent calls to bfd_openr_next_archived_file should pass
|
||||
Provided a BFD, @var{archive}, containing an archive and NULL, open
|
||||
an input BFD on the first contained element and returns that.
|
||||
Subsequent calls should pass
|
||||
the archive and the previous return value to return a created
|
||||
BFD to the next contained element. NULL is returned when there
|
||||
are no more.
|
||||
|
@ -539,26 +557,25 @@ DESCRIPTION
|
|||
*/
|
||||
|
||||
bfd *
|
||||
DEFUN(bfd_openr_next_archived_file,(archive, last_file),
|
||||
bfd *archive AND
|
||||
bfd*last_file)
|
||||
bfd_openr_next_archived_file (archive, last_file)
|
||||
bfd *archive;
|
||||
bfd *last_file;
|
||||
{
|
||||
if ((bfd_get_format (archive) != bfd_archive) ||
|
||||
(archive->direction == write_direction))
|
||||
{
|
||||
bfd_error = invalid_operation;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((bfd_get_format (archive) != bfd_archive) ||
|
||||
(archive->direction == write_direction)) {
|
||||
bfd_error = invalid_operation;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
return BFD_SEND (archive,
|
||||
openr_next_archived_file,
|
||||
(archive,
|
||||
last_file));
|
||||
|
||||
return BFD_SEND (archive,
|
||||
openr_next_archived_file,
|
||||
(archive,
|
||||
last_file));
|
||||
}
|
||||
|
||||
bfd *bfd_generic_openr_next_archived_file(archive, last_file)
|
||||
bfd *
|
||||
bfd_generic_openr_next_archived_file (archive, last_file)
|
||||
bfd *archive;
|
||||
bfd *last_file;
|
||||
{
|
||||
|
@ -1496,6 +1513,7 @@ compute_and_write_armap (arch, elength)
|
|||
syms[src_count]->section;
|
||||
|
||||
if ((flags & BSF_GLOBAL ||
|
||||
flags & BSF_WEAK ||
|
||||
flags & BSF_INDIRECT ||
|
||||
bfd_is_com_section (sec))
|
||||
&& (sec != &bfd_und_section)) {
|
||||
|
@ -1559,7 +1577,8 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
|
|||
sprintf (hdr.ar_name, RANLIBMAG);
|
||||
/* Remember the timestamp, to keep it holy. But fudge it a little. */
|
||||
bfd_ardata(arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
|
||||
bfd_ardata(arch)->armap_datepos = SARMAG + offsetof(struct ar_hdr, ar_date);
|
||||
bfd_ardata(arch)->armap_datepos = SARMAG +
|
||||
offsetof(struct ar_hdr, ar_date[0]);
|
||||
sprintf (hdr.ar_date, "%ld", bfd_ardata(arch)->armap_timestamp);
|
||||
sprintf (hdr.ar_uid, "%d", getuid());
|
||||
sprintf (hdr.ar_gid, "%d", getgid());
|
||||
|
|
130
bfd/archures.c
130
bfd/archures.c
|
@ -24,17 +24,16 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
SECTION
|
||||
Architectures
|
||||
|
||||
BFD's idea of an architecture is implimented in
|
||||
<<archures.c>>. BFD keeps one atom in a BFD describing the
|
||||
architecture of the data attached to the BFD; a pointer to a
|
||||
BFD keeps one atom in a BFD describing the
|
||||
architecture of the data attached to the BFD: a pointer to a
|
||||
<<bfd_arch_info_type>>.
|
||||
|
||||
Pointers to structures can be requested independently of a bfd
|
||||
Pointers to structures can be requested independently of a BFD
|
||||
so that an architecture's information can be interrogated
|
||||
without access to an open bfd.
|
||||
without access to an open BFD.
|
||||
|
||||
The arch information is provided by each architecture package.
|
||||
The set of default architectures is selected by the #define
|
||||
The architecture information is provided by each architecture package.
|
||||
The set of default architectures is selected by the macro
|
||||
<<SELECT_ARCHITECTURES>>. This is normally set up in the
|
||||
<<config/target.mt>> file of your choice. If the name is not
|
||||
defined, then all the architectures supported are included.
|
||||
|
@ -44,6 +43,8 @@ SECTION
|
|||
insert as many items into the list of architectures as it wants to;
|
||||
generally this would be one for each machine and one for the
|
||||
default case (an item with a machine field of 0).
|
||||
|
||||
BFD's idea of an architecture is implemented in <<archures.c>>.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
@ -53,11 +54,11 @@ SUBSECTION
|
|||
|
||||
DESCRIPTION
|
||||
This enum gives the object file's CPU architecture, in a
|
||||
global sense --- i.e., what processor family does it belong to?
|
||||
There is another field, which indicates what processor within
|
||||
global sense---i.e., what processor family does it belong to?
|
||||
Another field indicates which processor within
|
||||
the family is in use. The machine gives a number which
|
||||
distingushes different versions of the architecture,
|
||||
containing for example 2 and 3 for Intel i960 KA and i960 KB,
|
||||
distinguishes different versions of the architecture,
|
||||
containing, for example, 2 and 3 for Intel i960 KA and i960 KB,
|
||||
and 68020 and 68030 for Motorola 68020 and 68030.
|
||||
|
||||
.enum bfd_architecture
|
||||
|
@ -166,7 +167,7 @@ SYNOPSIS
|
|||
|
||||
DESCRIPTION
|
||||
Return a printable string representing the architecture and machine
|
||||
from the pointer to the arch info structure
|
||||
from the pointer to the architecture info structure.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -184,12 +185,11 @@ FUNCTION
|
|||
bfd_scan_arch
|
||||
|
||||
SYNOPSIS
|
||||
bfd_arch_info_type *bfd_scan_arch(CONST char *);
|
||||
bfd_arch_info_type *bfd_scan_arch(CONST char *string);
|
||||
|
||||
DESCRIPTION
|
||||
This routine is provided with a string and tries to work out
|
||||
if bfd supports any cpu which could be described with the name
|
||||
provided. The routine returns a pointer to an arch_info
|
||||
Figure out if BFD supports any cpu which could be described with
|
||||
the name @var{string}. Return a pointer to an <<arch_info>>
|
||||
structure if a machine is found, otherwise NULL.
|
||||
|
||||
*/
|
||||
|
@ -223,11 +223,11 @@ SYNOPSIS
|
|||
CONST bfd *bbfd);
|
||||
|
||||
DESCRIPTION
|
||||
This routine is used to determine whether two BFDs'
|
||||
architectures and achine types are compatible. It calculates
|
||||
Determine whether two BFDs'
|
||||
architectures and machine types are compatible. Calculates
|
||||
the lowest common denominator between the two architectures
|
||||
and machine types implied by the BFDs and returns a pointer to
|
||||
an arch_info structure describing the compatible machine.
|
||||
an <<arch_info>> structure describing the compatible machine.
|
||||
*/
|
||||
|
||||
CONST bfd_arch_info_type *
|
||||
|
@ -268,8 +268,10 @@ FUNCTION
|
|||
bfd_set_arch_info
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_set_arch_info(bfd *, bfd_arch_info_type *);
|
||||
void bfd_set_arch_info(bfd *abfd, bfd_arch_info_type *arg);
|
||||
|
||||
DESCRIPTION
|
||||
Set the architecture info of @var{abfd} to @var{arg}.
|
||||
*/
|
||||
|
||||
void DEFUN(bfd_set_arch_info,(abfd, arg),
|
||||
|
@ -289,8 +291,9 @@ SYNOPSIS
|
|||
unsigned long mach);
|
||||
|
||||
DESCRIPTION
|
||||
Set the architecture and machine type in a bfd. This finds the
|
||||
correct pointer to structure and inserts it into the arch_info
|
||||
Set the architecture and machine type in BFD @var{abfd}
|
||||
to @var{arch} and @var{mach}. Find the correct
|
||||
pointer to a structure and insert it into the <<arch_info>>
|
||||
pointer.
|
||||
*/
|
||||
|
||||
|
@ -333,9 +336,6 @@ boolean DEFUN(bfd_default_set_arch_mach,(abfd, arch, mach),
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_get_arch
|
||||
|
@ -344,8 +344,8 @@ SYNOPSIS
|
|||
enum bfd_architecture bfd_get_arch(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns the enumerated type which describes the supplied bfd's
|
||||
architecture
|
||||
Return the enumerated type which describes the BFD @var{abfd}'s
|
||||
architecture.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -362,8 +362,8 @@ SYNOPSIS
|
|||
unsigned long bfd_get_mach(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns the long type which describes the supplied bfd's
|
||||
machine
|
||||
Return the long type which describes the BFD @var{abfd}'s
|
||||
machine.
|
||||
*/
|
||||
|
||||
unsigned long
|
||||
|
@ -380,14 +380,15 @@ SYNOPSIS
|
|||
unsigned int bfd_arch_bits_per_byte(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns the number of bits in one of the architectures bytes
|
||||
Return the number of bits in one of the BFD @var{abfd}'s
|
||||
architecture's bytes.
|
||||
|
||||
*/
|
||||
|
||||
unsigned int DEFUN(bfd_arch_bits_per_byte, (abfd), bfd *abfd)
|
||||
{
|
||||
return abfd->arch_info->bits_per_byte;
|
||||
}
|
||||
{
|
||||
return abfd->arch_info->bits_per_byte;
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
|
@ -397,33 +398,32 @@ SYNOPSIS
|
|||
unsigned int bfd_arch_bits_per_address(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns the number of bits in one of the architectures addresses
|
||||
Return the number of bits in one of the BFD @var{abfd}'s
|
||||
architecture's addresses.
|
||||
*/
|
||||
|
||||
unsigned int DEFUN(bfd_arch_bits_per_address, (abfd), bfd *abfd)
|
||||
{
|
||||
return abfd->arch_info->bits_per_address;
|
||||
}
|
||||
{
|
||||
return abfd->arch_info->bits_per_address;
|
||||
}
|
||||
|
||||
|
||||
|
||||
extern void bfd_h8300_arch PARAMS ((void));
|
||||
extern void bfd_sh_arch PARAMS ((void));
|
||||
extern void bfd_h8500_arch PARAMS ((void));
|
||||
extern void bfd_alpha_arch PARAMS ((void));
|
||||
extern void bfd_i960_arch PARAMS ((void));
|
||||
extern void bfd_empty_arch PARAMS ((void));
|
||||
extern void bfd_sparc_arch PARAMS ((void));
|
||||
extern void bfd_m88k_arch PARAMS ((void));
|
||||
extern void bfd_m68k_arch PARAMS ((void));
|
||||
extern void bfd_vax_arch PARAMS ((void));
|
||||
extern void bfd_a29k_arch PARAMS ((void));
|
||||
extern void bfd_mips_arch PARAMS ((void));
|
||||
extern void bfd_i386_arch PARAMS ((void));
|
||||
extern void bfd_rs6000_arch PARAMS ((void));
|
||||
extern void bfd_alpha_arch PARAMS ((void));
|
||||
extern void bfd_h8300_arch PARAMS ((void));
|
||||
extern void bfd_h8500_arch PARAMS ((void));
|
||||
extern void bfd_hppa_arch PARAMS ((void));
|
||||
extern void bfd_z8k_arch PARAMS ((void));
|
||||
extern void bfd_i386_arch PARAMS ((void));
|
||||
extern void bfd_i960_arch PARAMS ((void));
|
||||
extern void bfd_m68k_arch PARAMS ((void));
|
||||
extern void bfd_m88k_arch PARAMS ((void));
|
||||
extern void bfd_mips_arch PARAMS ((void));
|
||||
extern void bfd_rs6000_arch PARAMS ((void));
|
||||
extern void bfd_sh_arch PARAMS ((void));
|
||||
extern void bfd_sparc_arch PARAMS ((void));
|
||||
extern void bfd_vax_arch PARAMS ((void));
|
||||
extern void bfd_we32k_arch PARAMS ((void));
|
||||
extern void bfd_z8k_arch PARAMS ((void));
|
||||
|
||||
static void (*archures_init_table[]) PARAMS ((void)) =
|
||||
{
|
||||
|
@ -457,10 +457,10 @@ INTERNAL_FUNCTION
|
|||
bfd_arch_init
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_arch_init(void);
|
||||
void bfd_arch_init(void);
|
||||
|
||||
DESCRIPTION
|
||||
This routine initializes the architecture dispatch table by
|
||||
Initialize the architecture dispatch table by
|
||||
calling all installed architecture packages and getting them
|
||||
to poke around.
|
||||
*/
|
||||
|
@ -483,10 +483,10 @@ INTERNAL_FUNCTION
|
|||
bfd_arch_linkin
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_arch_linkin(bfd_arch_info_type *);
|
||||
void bfd_arch_linkin(bfd_arch_info_type *ptr);
|
||||
|
||||
DESCRIPTION
|
||||
Link the provided arch info structure into the list
|
||||
Link the architecture info structure @var{ptr} into the list.
|
||||
*/
|
||||
|
||||
void DEFUN(bfd_arch_linkin,(ptr),
|
||||
|
@ -532,7 +532,7 @@ INTERNAL_FUNCTION
|
|||
bfd_default_scan
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_default_scan(CONST struct bfd_arch_info *, CONST char *);
|
||||
boolean bfd_default_scan(CONST struct bfd_arch_info *info, CONST char *string);
|
||||
|
||||
DESCRIPTION
|
||||
The default function for working out whether this is an
|
||||
|
@ -649,16 +649,15 @@ CONST char *string)
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_get_arch_info
|
||||
|
||||
|
||||
SYNOPSIS
|
||||
bfd_arch_info_type * bfd_get_arch_info(bfd *);
|
||||
bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Return the architecture info struct in @var{abfd}.
|
||||
*/
|
||||
|
||||
bfd_arch_info_type *
|
||||
|
@ -680,8 +679,8 @@ SYNOPSIS
|
|||
long machine);
|
||||
|
||||
DESCRIPTION
|
||||
Look for the architecure info struct which matches the
|
||||
arguments given. A machine of 0 will match the
|
||||
Look for the architecure info structure which matches the
|
||||
arguments @var{arch} and @var{machine}. A machine of 0 matches the
|
||||
machine/architecture structure which marks itself as the
|
||||
default.
|
||||
*/
|
||||
|
@ -706,20 +705,19 @@ long machine)
|
|||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_printable_arch_mach
|
||||
|
||||
SYNOPSIS
|
||||
CONST char * bfd_printable_arch_mach
|
||||
CONST char *bfd_printable_arch_mach
|
||||
(enum bfd_architecture arch, unsigned long machine);
|
||||
|
||||
DESCRIPTION
|
||||
Return a printable string representing the architecture and
|
||||
machine type.
|
||||
|
||||
NB. The use of this routine is depreciated.
|
||||
This routine is depreciated.
|
||||
*/
|
||||
|
||||
CONST char *
|
||||
|
|
170
bfd/bfd-in2.h
170
bfd/bfd-in2.h
|
@ -466,7 +466,7 @@ void
|
|||
bfd_init PARAMS ((void));
|
||||
|
||||
bfd *
|
||||
bfd_openr PARAMS ((CONST char *filename, CONST char*target));
|
||||
bfd_openr PARAMS ((CONST char *filename, CONST char *target));
|
||||
|
||||
bfd *
|
||||
bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd));
|
||||
|
@ -475,7 +475,7 @@ bfd *
|
|||
bfd_openw PARAMS ((CONST char *filename, CONST char *target));
|
||||
|
||||
boolean
|
||||
bfd_close PARAMS ((bfd *));
|
||||
bfd_close PARAMS ((bfd *abfd));
|
||||
|
||||
boolean
|
||||
bfd_close_all_done PARAMS ((bfd *));
|
||||
|
@ -566,12 +566,12 @@ bfd_create PARAMS ((CONST char *filename, bfd *templ));
|
|||
|
||||
typedef struct sec
|
||||
{
|
||||
/* The name of the section, the name isn't a copy, the pointer is
|
||||
/* The name of the section; the name isn't a copy, the pointer is
|
||||
the same as that passed to bfd_make_section. */
|
||||
|
||||
CONST char *name;
|
||||
|
||||
/* Which section is it 0.nth */
|
||||
/* Which section is it; 0..nth. */
|
||||
|
||||
int index;
|
||||
|
||||
|
@ -579,7 +579,7 @@ typedef struct sec
|
|||
|
||||
struct sec *next;
|
||||
|
||||
/* The field flags contains attributes of the section. Some of
|
||||
/* The field flags contains attributes of the section. Some
|
||||
flags are read in from the object file, and some are
|
||||
synthesized from other information. */
|
||||
|
||||
|
@ -587,17 +587,17 @@ typedef struct sec
|
|||
|
||||
#define SEC_NO_FLAGS 0x000
|
||||
|
||||
/* Tells the OS to allocate space for this section when loaded.
|
||||
This would clear for a section containing debug information
|
||||
/* Tells the OS to allocate space for this section when loading.
|
||||
This is clear for a section containing debug information
|
||||
only. */
|
||||
#define SEC_ALLOC 0x001
|
||||
|
||||
/* Tells the OS to load the section from the file when loading.
|
||||
This would be clear for a .bss section */
|
||||
This is clear for a .bss section. */
|
||||
#define SEC_LOAD 0x002
|
||||
|
||||
/* The section contains data still to be relocated, so there will
|
||||
be some relocation information too. */
|
||||
/* The section contains data still to be relocated, so there is
|
||||
some relocation information too. */
|
||||
#define SEC_RELOC 0x004
|
||||
|
||||
#if 0 /* Obsolete ? */
|
||||
|
@ -621,10 +621,10 @@ typedef struct sec
|
|||
type is used by the linker to create lists of constructors and
|
||||
destructors used by <<g++>>. When a back end sees a symbol
|
||||
which should be used in a constructor list, it creates a new
|
||||
section for the type of name (eg <<__CTOR_LIST__>>), attaches
|
||||
the symbol to it and builds a relocation. To build the lists
|
||||
section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
|
||||
the symbol to it, and builds a relocation. To build the lists
|
||||
of constructors, all the linker has to do is catenate all the
|
||||
sections called <<__CTOR_LIST__>> and relocte the data
|
||||
sections called <<__CTOR_LIST__>> and relocate the data
|
||||
contained within - exactly the operations it would peform on
|
||||
standard data. */
|
||||
#define SEC_CONSTRUCTOR 0x100
|
||||
|
@ -636,13 +636,12 @@ typedef struct sec
|
|||
#define SEC_CONSTRUCTOR_BSS 0x3100
|
||||
|
||||
/* The section has contents - a data section could be
|
||||
<<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>, a debug section could be
|
||||
<<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
|
||||
<<SEC_HAS_CONTENTS>> */
|
||||
#define SEC_HAS_CONTENTS 0x200
|
||||
|
||||
/* An instruction to the linker not to output sections
|
||||
containing this flag even if they have information which
|
||||
would normally be written. */
|
||||
/* An instruction to the linker to not output the section
|
||||
even if it has information which would normally be written. */
|
||||
#define SEC_NEVER_LOAD 0x400
|
||||
|
||||
/* The section is a shared library section. The linker must leave
|
||||
|
@ -676,18 +675,18 @@ typedef struct sec
|
|||
boolean user_set_vma;
|
||||
|
||||
/* The load address of the section - where it would be in a
|
||||
rom image, really only used for writing section header
|
||||
rom image; really only used for writing section header
|
||||
information. */
|
||||
|
||||
bfd_vma lma;
|
||||
|
||||
/* The size of the section in bytes, as it will be output.
|
||||
contains a value even if the section has no contents (eg, the
|
||||
contains a value even if the section has no contents (e.g., the
|
||||
size of <<.bss>>). This will be filled in after relocation */
|
||||
|
||||
bfd_size_type _cooked_size;
|
||||
|
||||
/* The size on disk of the section in bytes originally. Normally this
|
||||
/* The original size on disk of the section, in bytes. Normally this
|
||||
value is the same as the size, but if some relaxing has
|
||||
been done, then this value will be bigger. */
|
||||
|
||||
|
@ -695,7 +694,7 @@ typedef struct sec
|
|||
|
||||
/* If this section is going to be output, then this value is the
|
||||
offset into the output section of the first byte in the input
|
||||
section. Eg, if this was going to start at the 100th byte in
|
||||
section. E.g., if this was going to start at the 100th byte in
|
||||
the output section, this value would be 100. */
|
||||
|
||||
bfd_vma output_offset;
|
||||
|
@ -704,8 +703,8 @@ typedef struct sec
|
|||
|
||||
struct sec *output_section;
|
||||
|
||||
/* The alignment requirement of the section, as an exponent - eg
|
||||
3 aligns to 2^3 (or 8) */
|
||||
/* The alignment requirement of the section, as an exponent of 2 -
|
||||
e.g., 3 aligns to 2^3 (or 8). */
|
||||
|
||||
unsigned int alignment_power;
|
||||
|
||||
|
@ -757,7 +756,7 @@ typedef struct sec
|
|||
|
||||
file_ptr moving_line_filepos;
|
||||
|
||||
/* what the section number is in the target world */
|
||||
/* What the section number is in the target world */
|
||||
|
||||
int target_index;
|
||||
|
||||
|
@ -811,16 +810,16 @@ asection *
|
|||
bfd_get_section_by_name PARAMS ((bfd *abfd, CONST char *name));
|
||||
|
||||
asection *
|
||||
bfd_make_section_old_way PARAMS ((bfd *, CONST char *name));
|
||||
bfd_make_section_old_way PARAMS ((bfd *abfd, CONST char *name));
|
||||
|
||||
asection *
|
||||
bfd_make_section_anyway PARAMS ((bfd *, CONST char *name));
|
||||
bfd_make_section_anyway PARAMS ((bfd *abfd, CONST char *name));
|
||||
|
||||
asection *
|
||||
bfd_make_section PARAMS ((bfd *, CONST char *name));
|
||||
|
||||
boolean
|
||||
bfd_set_section_flags PARAMS ((bfd *, asection *, flagword));
|
||||
bfd_set_section_flags PARAMS ((bfd *abfd, asection *sec, flagword flags));
|
||||
|
||||
void
|
||||
bfd_map_over_sections PARAMS ((bfd *abfd,
|
||||
|
@ -830,7 +829,7 @@ bfd_map_over_sections PARAMS ((bfd *abfd,
|
|||
PTR obj));
|
||||
|
||||
boolean
|
||||
bfd_set_section_size PARAMS ((bfd *, asection *, bfd_size_type val));
|
||||
bfd_set_section_size PARAMS ((bfd *abfd, asection *sec, bfd_size_type val));
|
||||
|
||||
boolean
|
||||
bfd_set_section_contents
|
||||
|
@ -924,7 +923,7 @@ CONST char *
|
|||
bfd_printable_name PARAMS ((bfd *abfd));
|
||||
|
||||
bfd_arch_info_type *
|
||||
bfd_scan_arch PARAMS ((CONST char *));
|
||||
bfd_scan_arch PARAMS ((CONST char *string));
|
||||
|
||||
CONST bfd_arch_info_type *
|
||||
bfd_arch_get_compatible PARAMS ((
|
||||
|
@ -932,7 +931,7 @@ bfd_arch_get_compatible PARAMS ((
|
|||
CONST bfd *bbfd));
|
||||
|
||||
void
|
||||
bfd_set_arch_info PARAMS ((bfd *, bfd_arch_info_type *));
|
||||
bfd_set_arch_info PARAMS ((bfd *abfd, bfd_arch_info_type *arg));
|
||||
|
||||
enum bfd_architecture
|
||||
bfd_get_arch PARAMS ((bfd *abfd));
|
||||
|
@ -947,7 +946,7 @@ unsigned int
|
|||
bfd_arch_bits_per_address PARAMS ((bfd *abfd));
|
||||
|
||||
bfd_arch_info_type *
|
||||
bfd_get_arch_info PARAMS ((bfd *));
|
||||
bfd_get_arch_info PARAMS ((bfd *abfd));
|
||||
|
||||
bfd_arch_info_type *
|
||||
bfd_lookup_arch
|
||||
|
@ -955,7 +954,7 @@ bfd_lookup_arch
|
|||
arch,
|
||||
long machine));
|
||||
|
||||
CONST char *
|
||||
CONST char *
|
||||
bfd_printable_arch_mach
|
||||
PARAMS ((enum bfd_architecture arch, unsigned long machine));
|
||||
|
||||
|
@ -973,10 +972,10 @@ typedef enum bfd_reloc_status
|
|||
/* Used by special functions */
|
||||
bfd_reloc_continue,
|
||||
|
||||
/* Unused */
|
||||
/* Unsupported relocation size requested. */
|
||||
bfd_reloc_notsupported,
|
||||
|
||||
/* Unsupported relocation size requested. */
|
||||
/* Unused */
|
||||
bfd_reloc_other,
|
||||
|
||||
/* The symbol to relocate against was undefined. */
|
||||
|
@ -1023,13 +1022,13 @@ enum complain_overflow
|
|||
complain_overflow_unsigned
|
||||
};
|
||||
|
||||
typedef CONST struct reloc_howto_struct
|
||||
typedef struct reloc_howto_struct
|
||||
{
|
||||
/* The type field has mainly a documetary use - the back end can
|
||||
to what it wants with it, though the normally the back end's
|
||||
external idea of what a reloc number would be would be stored
|
||||
in this field. For example, the a PC relative word relocation
|
||||
in a coff environment would have the type 023 - because that's
|
||||
do what it wants with it, though normally the back end's
|
||||
external idea of what a reloc number is stored
|
||||
in this field. For example, a PC relative word relocation
|
||||
in a coff environment has the type 023 - because that's
|
||||
what the outside world calls a R_PCRWORD reloc. */
|
||||
unsigned int type;
|
||||
|
||||
|
@ -1087,7 +1086,7 @@ typedef CONST struct reloc_howto_struct
|
|||
relocations rather than the data - this flag signals this.*/
|
||||
boolean partial_inplace;
|
||||
|
||||
/* The src_mask is used to select what parts of the read in data
|
||||
/* The src_mask selects which parts of the read in data
|
||||
are to be used in the relocation sum. E.g., if this was an 8 bit
|
||||
bit of data which we read and relocated, this would be
|
||||
0x000000ff. When we have relocs which have an addend, such as
|
||||
|
@ -1096,7 +1095,7 @@ typedef CONST struct reloc_howto_struct
|
|||
the mask would be 0x00000000. */
|
||||
bfd_vma src_mask;
|
||||
|
||||
/* The dst_mask is what parts of the instruction are replaced
|
||||
/* The dst_mask selects which parts of the instruction are replaced
|
||||
into the instruction. In most cases src_mask == dst_mask,
|
||||
except in the above special case, where dst_mask would be
|
||||
0x000000ff, and src_mask would be 0x00000000. */
|
||||
|
@ -1107,7 +1106,7 @@ typedef CONST struct reloc_howto_struct
|
|||
slot of the instruction, so that a PC relative relocation can
|
||||
be made just by adding in an ordinary offset (e.g., sun3 a.out).
|
||||
Some formats leave the displacement part of an instruction
|
||||
empty (e.g., m88k bcs), this flag signals the fact.*/
|
||||
empty (e.g., m88k bcs); this flag signals the fact.*/
|
||||
boolean pcrel_offset;
|
||||
|
||||
} reloc_howto_type;
|
||||
|
@ -1135,7 +1134,7 @@ typedef struct relent_chain {
|
|||
bfd_reloc_status_type
|
||||
|
||||
bfd_perform_relocation
|
||||
PARAMS ((bfd * abfd,
|
||||
PARAMS ((bfd *abfd,
|
||||
arelent *reloc_entry,
|
||||
PTR data,
|
||||
asection *input_section,
|
||||
|
@ -1361,6 +1360,22 @@ CONST struct reloc_howto_struct *
|
|||
|
||||
bfd_reloc_type_lookup PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
|
||||
|
||||
unsigned int
|
||||
bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
|
||||
|
||||
unsigned int
|
||||
bfd_canonicalize_reloc
|
||||
PARAMS ((bfd *abfd,
|
||||
asection *sec,
|
||||
arelent **loc,
|
||||
asymbol **syms));
|
||||
|
||||
void
|
||||
bfd_set_reloc
|
||||
PARAMS ((bfd *abfd, sec_ptr *sec, arelent **rel, unsigned int count)
|
||||
|
||||
);
|
||||
|
||||
|
||||
typedef struct symbol_cache_entry
|
||||
{
|
||||
|
@ -1376,7 +1391,7 @@ typedef struct symbol_cache_entry
|
|||
|
||||
struct _bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */
|
||||
|
||||
/* The text of the symbol. The name is left alone, and not copied - the
|
||||
/* The text of the symbol. The name is left alone, and not copied; the
|
||||
application may not alter it. */
|
||||
CONST char *name;
|
||||
|
||||
|
@ -1397,7 +1412,7 @@ typedef struct symbol_cache_entry
|
|||
value is the offset into the section of the data. */
|
||||
#define BSF_GLOBAL 0x02
|
||||
|
||||
/* The symbol has global scope, and is exported. The value is
|
||||
/* The symbol has global scope and is exported. The value is
|
||||
the offset into the section of the data. */
|
||||
#define BSF_EXPORT BSF_GLOBAL /* no real difference */
|
||||
|
||||
|
@ -1476,7 +1491,7 @@ typedef struct symbol_cache_entry
|
|||
BFD_SEND (abfd, _bfd_canonicalize_symtab,\
|
||||
(abfd, location))
|
||||
boolean
|
||||
bfd_set_symtab PARAMS ((bfd *, asymbol **, unsigned int ));
|
||||
bfd_set_symtab PARAMS ((bfd *abfd, asymbol **location, unsigned int count));
|
||||
|
||||
void
|
||||
bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol));
|
||||
|
@ -1512,8 +1527,8 @@ struct _bfd
|
|||
boolean cacheable;
|
||||
|
||||
/* Marks whether there was a default target specified when the
|
||||
BFD was opened. This is used to select what matching algorithm
|
||||
to use to chose the back end. */
|
||||
BFD was opened. This is used to select which matching algorithm
|
||||
to use to choose the back end. */
|
||||
|
||||
boolean target_defaulted;
|
||||
|
||||
|
@ -1523,12 +1538,11 @@ struct _bfd
|
|||
struct _bfd *lru_prev, *lru_next;
|
||||
|
||||
/* When a file is closed by the caching routines, BFD retains
|
||||
state information on the file here:
|
||||
*/
|
||||
state information on the file here: */
|
||||
|
||||
file_ptr where;
|
||||
|
||||
/* and here:*/
|
||||
/* and here: (``once'' means at least once) */
|
||||
|
||||
boolean opened_once;
|
||||
|
||||
|
@ -1545,7 +1559,7 @@ struct _bfd
|
|||
|
||||
int ifd;
|
||||
|
||||
/* The format which belongs to the BFD.*/
|
||||
/* The format which belongs to the BFD. (object, core, etc.) */
|
||||
|
||||
bfd_format format;
|
||||
|
||||
|
@ -1567,7 +1581,7 @@ struct _bfd
|
|||
file_ptr origin;
|
||||
|
||||
/* Remember when output has begun, to stop strange things
|
||||
happening. */
|
||||
from happening. */
|
||||
boolean output_has_begun;
|
||||
|
||||
/* Pointer to linked list of sections*/
|
||||
|
@ -1583,7 +1597,7 @@ struct _bfd
|
|||
/* Used for input and output*/
|
||||
unsigned int symcount;
|
||||
|
||||
/* Symbol table for output BFD*/
|
||||
/* Symbol table for output BFD (with symcount entries) */
|
||||
struct symbol_cache_entry **outsymbols;
|
||||
|
||||
/* Pointer to structure which contains architecture information*/
|
||||
|
@ -1591,9 +1605,9 @@ struct _bfd
|
|||
|
||||
/* Stuff only useful for archives:*/
|
||||
PTR arelt_data;
|
||||
struct _bfd *my_archive;
|
||||
struct _bfd *next;
|
||||
struct _bfd *archive_head;
|
||||
struct _bfd *my_archive; /* The containing archive BFD. */
|
||||
struct _bfd *next; /* The next BFD in the archive. */
|
||||
struct _bfd *archive_head; /* The first BFD in the archive. */
|
||||
boolean has_armap;
|
||||
|
||||
/* Used by the back end to hold private data. */
|
||||
|
@ -1633,39 +1647,23 @@ struct _bfd
|
|||
asymbol **ld_symbols;
|
||||
};
|
||||
|
||||
unsigned int
|
||||
bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
|
||||
|
||||
unsigned int
|
||||
bfd_canonicalize_reloc
|
||||
PARAMS ((bfd *abfd,
|
||||
asection *sec,
|
||||
arelent **loc,
|
||||
asymbol **syms));
|
||||
|
||||
boolean
|
||||
bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags));
|
||||
|
||||
void
|
||||
bfd_set_reloc
|
||||
PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count)
|
||||
|
||||
);
|
||||
|
||||
boolean
|
||||
bfd_set_start_address PARAMS ((bfd *, bfd_vma));
|
||||
bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma));
|
||||
|
||||
long
|
||||
bfd_get_mtime PARAMS ((bfd *));
|
||||
bfd_get_mtime PARAMS ((bfd *abfd));
|
||||
|
||||
long
|
||||
bfd_get_size PARAMS ((bfd *));
|
||||
bfd_get_size PARAMS ((bfd *abfd));
|
||||
|
||||
int
|
||||
bfd_get_gp_size PARAMS ((bfd *));
|
||||
bfd_get_gp_size PARAMS ((bfd *abfd));
|
||||
|
||||
void
|
||||
bfd_set_gp_size PARAMS ((bfd *, int));
|
||||
bfd_set_gp_size PARAMS ((bfd *abfd, int i));
|
||||
|
||||
bfd_vma
|
||||
bfd_scan_vma PARAMS ((CONST char *string, CONST char **end, int base));
|
||||
|
@ -1702,22 +1700,22 @@ bfd_scan_vma PARAMS ((CONST char *string, CONST char **end, int base));
|
|||
#define bfd_seclet_link(abfd, data, relocateable) \
|
||||
BFD_SEND (abfd, _bfd_seclet_link, (abfd, data, relocateable))
|
||||
symindex
|
||||
bfd_get_next_mapent PARAMS ((bfd *, symindex previous, carsym ** sym));
|
||||
bfd_get_next_mapent PARAMS ((bfd *abfd, symindex previous, carsym **sym));
|
||||
|
||||
boolean
|
||||
bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head));
|
||||
|
||||
bfd *
|
||||
bfd_get_elt_at_index PARAMS ((bfd * archive, int index));
|
||||
bfd_get_elt_at_index PARAMS ((bfd *archive, int index));
|
||||
|
||||
bfd*
|
||||
bfd *
|
||||
bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous));
|
||||
|
||||
CONST char *
|
||||
bfd_core_file_failing_command PARAMS ((bfd *));
|
||||
bfd_core_file_failing_command PARAMS ((bfd *abfd));
|
||||
|
||||
int
|
||||
bfd_core_file_failing_signal PARAMS ((bfd *));
|
||||
bfd_core_file_failing_signal PARAMS ((bfd *abfd));
|
||||
|
||||
boolean
|
||||
core_file_matches_executable_p
|
||||
|
@ -1849,7 +1847,7 @@ typedef struct bfd_target
|
|||
PTR backend_data;
|
||||
} bfd_target;
|
||||
bfd_target *
|
||||
bfd_find_target PARAMS ((CONST char *, bfd *));
|
||||
bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd));
|
||||
|
||||
CONST char **
|
||||
bfd_target_list PARAMS ((void));
|
||||
|
@ -1858,9 +1856,9 @@ boolean
|
|||
bfd_check_format PARAMS ((bfd *abfd, bfd_format format));
|
||||
|
||||
boolean
|
||||
bfd_set_format PARAMS ((bfd *, bfd_format));
|
||||
bfd_set_format PARAMS ((bfd *abfd, bfd_format format));
|
||||
|
||||
CONST char *
|
||||
bfd_format_string PARAMS ((bfd_format));
|
||||
bfd_format_string PARAMS ((bfd_format format));
|
||||
|
||||
#endif
|
||||
|
|
203
bfd/bfd.c
203
bfd/bfd.c
|
@ -22,13 +22,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
SECTION
|
||||
<<typedef bfd>>
|
||||
|
||||
A BFD is has type <<bfd>>; objects of this type are the
|
||||
cornerstone of any application using <<libbfd>>. References
|
||||
though the BFD and to data in the BFD give the entire BFD
|
||||
functionality.
|
||||
A BFD has type <<bfd>>; objects of this type are the
|
||||
cornerstone of any application using <<libbfd>>. Using BFD
|
||||
consists of making references though the BFD and to data in the BFD.
|
||||
|
||||
Here is the struct used to define the type <<bfd>>. This
|
||||
contains the major data about the file, and contains pointers
|
||||
Here is the structure that defines the type <<bfd>>. It
|
||||
contains the major data about the file and pointers
|
||||
to the rest of the data.
|
||||
|
||||
CODE_FRAGMENT
|
||||
|
@ -54,8 +53,8 @@ CODE_FRAGMENT
|
|||
. boolean cacheable;
|
||||
.
|
||||
. {* Marks whether there was a default target specified when the
|
||||
. BFD was opened. This is used to select what matching algorithm
|
||||
. to use to chose the back end. *}
|
||||
. BFD was opened. This is used to select which matching algorithm
|
||||
. to use to choose the back end. *}
|
||||
.
|
||||
. boolean target_defaulted;
|
||||
.
|
||||
|
@ -65,12 +64,11 @@ CODE_FRAGMENT
|
|||
. struct _bfd *lru_prev, *lru_next;
|
||||
.
|
||||
. {* When a file is closed by the caching routines, BFD retains
|
||||
. state information on the file here:
|
||||
. *}
|
||||
. state information on the file here: *}
|
||||
.
|
||||
. file_ptr where;
|
||||
.
|
||||
. {* and here:*}
|
||||
. {* and here: (``once'' means at least once) *}
|
||||
.
|
||||
. boolean opened_once;
|
||||
.
|
||||
|
@ -87,7 +85,7 @@ CODE_FRAGMENT
|
|||
.
|
||||
. int ifd;
|
||||
.
|
||||
. {* The format which belongs to the BFD.*}
|
||||
. {* The format which belongs to the BFD. (object, core, etc.) *}
|
||||
.
|
||||
. bfd_format format;
|
||||
.
|
||||
|
@ -109,7 +107,7 @@ CODE_FRAGMENT
|
|||
. file_ptr origin;
|
||||
.
|
||||
. {* Remember when output has begun, to stop strange things
|
||||
. happening. *}
|
||||
. from happening. *}
|
||||
. boolean output_has_begun;
|
||||
.
|
||||
. {* Pointer to linked list of sections*}
|
||||
|
@ -125,7 +123,7 @@ CODE_FRAGMENT
|
|||
. {* Used for input and output*}
|
||||
. unsigned int symcount;
|
||||
.
|
||||
. {* Symbol table for output BFD*}
|
||||
. {* Symbol table for output BFD (with symcount entries) *}
|
||||
. struct symbol_cache_entry **outsymbols;
|
||||
.
|
||||
. {* Pointer to structure which contains architecture information*}
|
||||
|
@ -133,9 +131,9 @@ CODE_FRAGMENT
|
|||
.
|
||||
. {* Stuff only useful for archives:*}
|
||||
. PTR arelt_data;
|
||||
. struct _bfd *my_archive;
|
||||
. struct _bfd *next;
|
||||
. struct _bfd *archive_head;
|
||||
. struct _bfd *my_archive; {* The containing archive BFD. *}
|
||||
. struct _bfd *next; {* The next BFD in the archive. *}
|
||||
. struct _bfd *archive_head; {* The first BFD in the archive. *}
|
||||
. boolean has_armap;
|
||||
.
|
||||
. {* Used by the back end to hold private data. *}
|
||||
|
@ -319,77 +317,6 @@ DEFUN(bfd_perror,(message),
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
/** Symbols */
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_get_reloc_upper_bound
|
||||
|
||||
SYNOPSIS
|
||||
unsigned int bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
|
||||
|
||||
DESCRIPTION
|
||||
This function return the number of bytes required to store the
|
||||
relocation information associated with section <<sect>>
|
||||
attached to bfd <<abfd>>
|
||||
|
||||
*/
|
||||
|
||||
|
||||
unsigned int
|
||||
DEFUN(bfd_get_reloc_upper_bound,(abfd, asect),
|
||||
bfd *abfd AND
|
||||
sec_ptr asect)
|
||||
{
|
||||
if (abfd->format != bfd_object) {
|
||||
bfd_error = invalid_operation;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_canonicalize_reloc
|
||||
|
||||
SYNOPSIS
|
||||
unsigned int bfd_canonicalize_reloc
|
||||
(bfd *abfd,
|
||||
asection *sec,
|
||||
arelent **loc,
|
||||
asymbol **syms);
|
||||
|
||||
DESCRIPTION
|
||||
This function calls the back end associated with the open
|
||||
<<abfd>> and translates the external form of the relocation
|
||||
information attached to <<sec>> into the internal canonical
|
||||
form. The table is placed into memory at <<loc>>, which has
|
||||
been preallocated, usually by a call to
|
||||
<<bfd_get_reloc_upper_bound>>.
|
||||
|
||||
The <<syms>> table is also needed for horrible internal magic
|
||||
reasons.
|
||||
|
||||
|
||||
*/
|
||||
unsigned int
|
||||
DEFUN(bfd_canonicalize_reloc,(abfd, asect, location, symbols),
|
||||
bfd *abfd AND
|
||||
sec_ptr asect AND
|
||||
arelent **location AND
|
||||
asymbol **symbols)
|
||||
{
|
||||
if (abfd->format != bfd_object) {
|
||||
bfd_error = invalid_operation;
|
||||
return 0;
|
||||
}
|
||||
return BFD_SEND (abfd, _bfd_canonicalize_reloc,
|
||||
(abfd, asect, location, symbols));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
|
@ -399,16 +326,15 @@ SYNOPSIS
|
|||
boolean bfd_set_file_flags(bfd *abfd, flagword flags);
|
||||
|
||||
DESCRIPTION
|
||||
This function attempts to set the flag word in the referenced
|
||||
BFD structure to the value supplied.
|
||||
Set the flag word in the BFD @var{abfd} to the value @var{flags}.
|
||||
|
||||
Possible errors are:
|
||||
o wrong_format - The target bfd was not of object format.
|
||||
o invalid_operation - The target bfd was open for reading.
|
||||
o invalid_operation -
|
||||
The flag word contained a bit which was not applicable to the
|
||||
type of file. eg, an attempt was made to set the D_PAGED bit
|
||||
on a bfd format which does not support demand paging
|
||||
type of file. E.g., an attempt was made to set the D_PAGED bit
|
||||
on a bfd format which does not support demand paging.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -436,31 +362,6 @@ bfd_set_file_flags (abfd, flags)
|
|||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_set_reloc
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_set_reloc
|
||||
(bfd *abfd, asection *sec, arelent **rel, unsigned int count)
|
||||
|
||||
DESCRIPTION
|
||||
This function sets the relocation pointer and count within a
|
||||
section to the supplied values.
|
||||
|
||||
*/
|
||||
/*ARGSUSED*/
|
||||
void
|
||||
bfd_set_reloc (ignore_abfd, asect, location, count)
|
||||
bfd *ignore_abfd;
|
||||
sec_ptr asect;
|
||||
arelent **location;
|
||||
unsigned int count;
|
||||
{
|
||||
asect->orelocation = location;
|
||||
asect->reloc_count = count;
|
||||
}
|
||||
|
||||
void
|
||||
bfd_assert(file, line)
|
||||
char *file;
|
||||
|
@ -474,14 +375,14 @@ int line;
|
|||
FUNCTION
|
||||
bfd_set_start_address
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_set_start_address(bfd *abfd, bfd_vma vma);
|
||||
|
||||
DESCRIPTION
|
||||
Marks the entry point of an output BFD.
|
||||
Make @var{vma} the entry point of output BFD @var{abfd}.
|
||||
|
||||
RETURNS
|
||||
Returns <<true>> on success, <<false>> otherwise.
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_set_start_address(bfd *, bfd_vma);
|
||||
*/
|
||||
|
||||
boolean
|
||||
|
@ -496,14 +397,14 @@ bfd_vma vma;
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
The bfd_get_mtime function
|
||||
bfd_get_mtime
|
||||
|
||||
SYNOPSIS
|
||||
long bfd_get_mtime(bfd *);
|
||||
long bfd_get_mtime(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Return file modification time (as read from file system, or
|
||||
from archive header for archive members).
|
||||
Return the file modification time (as read from the file system, or
|
||||
from the archive header for archive members).
|
||||
|
||||
*/
|
||||
|
||||
|
@ -527,32 +428,32 @@ bfd_get_mtime (abfd)
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
The bfd_get_size function
|
||||
bfd_get_size
|
||||
|
||||
SYNOPSIS
|
||||
long bfd_get_size(bfd *);
|
||||
long bfd_get_size(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Return file size (as read from file system) for the file
|
||||
associated with a bfd.
|
||||
Return the file size (as read from file system) for the file
|
||||
associated with BFD @var{abfd}.
|
||||
|
||||
Note that the initial motivation for, and use of, this routine is not
|
||||
so we can get the exact size of the object the bfd applies to, since
|
||||
that might not be generally possible (archive members for example?).
|
||||
Although it would be ideal if someone could eventually modify
|
||||
The initial motivation for, and use of, this routine is not
|
||||
so we can get the exact size of the object the BFD applies to, since
|
||||
that might not be generally possible (archive members for example).
|
||||
It would be ideal if someone could eventually modify
|
||||
it so that such results were guaranteed.
|
||||
|
||||
Instead, we want to ask questions like "is this NNN byte sized
|
||||
object I'm about to try read from file offset YYY reasonable?"
|
||||
As as example of where we might want to do this, some object formats
|
||||
use string tables for which the first sizeof(long) bytes of the table
|
||||
contain the size of the table itself, including the size bytes.
|
||||
As as example of where we might do this, some object formats
|
||||
use string tables for which the first <<sizeof(long)>> bytes of the
|
||||
table contain the size of the table itself, including the size bytes.
|
||||
If an application tries to read what it thinks is one of these
|
||||
string tables, without some way to validate the size, and for
|
||||
some reason the size is wrong (byte swapping error, wrong location
|
||||
for the string table, etc), the only clue is likely to be a read
|
||||
for the string table, etc.), the only clue is likely to be a read
|
||||
error when it tries to read the table, or a "virtual memory
|
||||
exhausted" error when it tries to allocated 15 bazillon bytes
|
||||
exhausted" error when it tries to allocate 15 bazillon bytes
|
||||
of space for the 15 bazillon byte table it is about to read.
|
||||
This function at least allows us to answer the quesion, "is the
|
||||
size reasonable?".
|
||||
|
@ -574,13 +475,13 @@ bfd_get_size (abfd)
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
The bfd_get_gp_size function
|
||||
bfd_get_gp_size
|
||||
|
||||
SYNOPSIS
|
||||
int bfd_get_gp_size(bfd *);
|
||||
int bfd_get_gp_size(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Get the maximum size of objects to be optimized using the GP
|
||||
Return the maximum size of objects to be optimized using the GP
|
||||
register under MIPS ECOFF. This is typically set by the -G
|
||||
argument to the compiler, assembler or linker.
|
||||
*/
|
||||
|
@ -596,10 +497,10 @@ bfd_get_gp_size (abfd)
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
The bfd_set_gp_size function
|
||||
bfd_set_gp_size
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_set_gp_size(bfd *, int);
|
||||
void bfd_set_gp_size(bfd *abfd, int i);
|
||||
|
||||
DESCRIPTION
|
||||
Set the maximum size of objects to be optimized using the GP
|
||||
|
@ -622,20 +523,20 @@ bfd_set_gp_size (abfd, i)
|
|||
FUNCTION
|
||||
bfd_scan_vma
|
||||
|
||||
SYNOPSIS
|
||||
bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base);
|
||||
|
||||
DESCRIPTION
|
||||
Converts, like strtoul, a numerical expression as a
|
||||
string into a bfd_vma integer, and returns that integer.
|
||||
(Though without as many bells and whistles as strtoul.)
|
||||
Convert, like <<strtoul>>, a numerical expression
|
||||
@var{string} into a bfd_vma integer, and returns that integer.
|
||||
(Though without as many bells and whistles as <<strtoul>>.)
|
||||
The expression is assumed to be unsigned (i.e. positive).
|
||||
If given a base, it is used as the base for conversion.
|
||||
If given a @var{base}, it is used as the base for conversion.
|
||||
A base of 0 causes the function to interpret the string
|
||||
in hex if a leading "0x" or "0X" is found, otherwise
|
||||
in octal if a leading zero is found, otherwise in decimal.
|
||||
|
||||
Overflow is not detected.
|
||||
|
||||
SYNOPSIS
|
||||
bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base);
|
||||
*/
|
||||
|
||||
bfd_vma
|
||||
|
@ -697,7 +598,7 @@ FUNCTION
|
|||
stuff
|
||||
|
||||
DESCRIPTION
|
||||
stuff which should be documented
|
||||
Stuff which should be documented:
|
||||
|
||||
.#define bfd_sizeof_headers(abfd, reloc) \
|
||||
. BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
|
||||
|
|
96
bfd/cache.c
96
bfd/cache.c
|
@ -20,7 +20,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
|
||||
/*
|
||||
SECTION
|
||||
File Caching
|
||||
File caching
|
||||
|
||||
The file caching mechanism is embedded within BFD and allows
|
||||
the application to open as many BFDs as it wants without
|
||||
|
@ -28,7 +28,7 @@ SECTION
|
|||
limit (often as low as 20 open files). The module in
|
||||
<<cache.c>> maintains a least recently used list of
|
||||
<<BFD_CACHE_MAX_OPEN>> files, and exports the name
|
||||
<<bfd_cache_lookup>> which runs around and makes sure that
|
||||
<<bfd_cache_lookup>>, which runs around and makes sure that
|
||||
the required BFD is open. If not, then it chooses a file to
|
||||
close, closes it and opens the one wanted, returning its file
|
||||
handle.
|
||||
|
@ -52,6 +52,12 @@ DESCRIPTION
|
|||
*/
|
||||
|
||||
|
||||
static boolean
|
||||
bfd_cache_delete PARAMS ((bfd *));
|
||||
|
||||
/* Number of bfds on the chain. All such bfds have their file open;
|
||||
if it closed, they get snipd()d from the chain. */
|
||||
|
||||
static int open_files;
|
||||
|
||||
static bfd *cache_sentinel; /* Chain of BFDs with active fds we've
|
||||
|
@ -73,26 +79,23 @@ DESCRIPTION
|
|||
bfd *bfd_last_cache;
|
||||
|
||||
/*
|
||||
* INTERNAL_FUNCTION
|
||||
* bfd_cache_lookup
|
||||
*
|
||||
* DESCRIPTION
|
||||
* Checks to see if the required BFD is the same as the last one
|
||||
* looked up. If so then it can use the iostream in the BFD with
|
||||
* impunity, since it can't have changed since the last lookup,
|
||||
* otherwise it has to perform the complicated lookup function
|
||||
*
|
||||
* .#define bfd_cache_lookup(x) \
|
||||
* . ((x)==bfd_last_cache? \
|
||||
* . (FILE*)(bfd_last_cache->iostream): \
|
||||
* . bfd_cache_lookup_worker(x))
|
||||
*
|
||||
*
|
||||
INTERNAL_FUNCTION
|
||||
bfd_cache_lookup
|
||||
|
||||
DESCRIPTION
|
||||
Check to see if the required BFD is the same as the last one
|
||||
looked up. If so, then it can use the stream in the BFD with
|
||||
impunity, since it can't have changed since the last lookup;
|
||||
otherwise, it has to perform the complicated lookup function.
|
||||
|
||||
.#define bfd_cache_lookup(x) \
|
||||
. ((x)==bfd_last_cache? \
|
||||
. (FILE*)(bfd_last_cache->iostream): \
|
||||
. bfd_cache_lookup_worker(x))
|
||||
|
||||
|
||||
*/
|
||||
|
||||
static boolean EXFUN(bfd_cache_delete,(bfd *));
|
||||
|
||||
|
||||
static void
|
||||
DEFUN_VOID(close_one)
|
||||
{
|
||||
|
@ -161,22 +164,16 @@ DEFUN(insert,(x,y),
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
INTERNAL_FUNCTION
|
||||
bfd_cache_init
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_cache_init (bfd *);
|
||||
|
||||
DESCRIPTION
|
||||
Initialize a BFD by putting it on the cache LRU.
|
||||
*/
|
||||
/* Initialize a BFD by putting it on the cache LRU. */
|
||||
|
||||
void
|
||||
DEFUN(bfd_cache_init,(abfd),
|
||||
bfd *abfd)
|
||||
{
|
||||
if (open_files >= BFD_CACHE_MAX_OPEN)
|
||||
close_one ();
|
||||
cache_sentinel = insert(abfd, cache_sentinel);
|
||||
++open_files;
|
||||
}
|
||||
|
||||
|
||||
|
@ -184,12 +181,12 @@ DEFUN(bfd_cache_init,(abfd),
|
|||
INTERNAL_FUNCTION
|
||||
bfd_cache_close
|
||||
|
||||
DESCRIPTION
|
||||
Remove the BFD from the cache. If the attached file is open,
|
||||
then close it too.
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_cache_close (bfd *);
|
||||
boolean bfd_cache_close (bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Remove the BFD @var{abfd} from the cache. If the attached file is open,
|
||||
then close it too.
|
||||
|
||||
RETURNS
|
||||
<<false>> is returned if closing the file fails, <<true>> is
|
||||
|
@ -214,15 +211,15 @@ DEFUN(bfd_cache_close,(abfd),
|
|||
INTERNAL_FUNCTION
|
||||
bfd_open_file
|
||||
|
||||
DESCRIPTION
|
||||
Call the OS to open a file for this BFD. Returns the FILE *
|
||||
(possibly null) that results from this operation. Sets up the
|
||||
BFD so that future accesses know the file is open. If the FILE
|
||||
* returned is null, then there is won't have been put in the
|
||||
cache, so it won't have to be removed from it.
|
||||
|
||||
SYNOPSIS
|
||||
FILE* bfd_open_file(bfd *);
|
||||
FILE* bfd_open_file(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
|
||||
(possibly NULL) that results from this operation. Set up the
|
||||
BFD so that future accesses know the file is open. If the <<FILE *>>
|
||||
returned is NULL, then it won't have been put in the
|
||||
cache, so it won't have to be removed from it.
|
||||
*/
|
||||
|
||||
FILE *
|
||||
|
@ -256,7 +253,6 @@ DEFUN(bfd_open_file, (abfd),
|
|||
}
|
||||
|
||||
if (abfd->iostream) {
|
||||
open_files++;
|
||||
bfd_cache_init (abfd);
|
||||
}
|
||||
|
||||
|
@ -267,16 +263,16 @@ DEFUN(bfd_open_file, (abfd),
|
|||
INTERNAL_FUNCTION
|
||||
bfd_cache_lookup_worker
|
||||
|
||||
SYNOPSIS
|
||||
FILE *bfd_cache_lookup_worker(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Called when the macro <<bfd_cache_lookup>> fails to find a
|
||||
quick answer. Finds a file descriptor for this BFD. If
|
||||
necessary, it open it. If there are already more than
|
||||
BFD_CACHE_MAX_OPEN files open, it trys to close one first, to
|
||||
quick answer. Find a file descriptor for @var{abfd}. If
|
||||
necessary, it open it. If there are already more than
|
||||
<<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
|
||||
avoid running out of file descriptors.
|
||||
|
||||
SYNOPSIS
|
||||
FILE *bfd_cache_lookup_worker(bfd *);
|
||||
|
||||
*/
|
||||
|
||||
FILE *
|
||||
|
|
170
bfd/coffcode.h
170
bfd/coffcode.h
|
@ -28,55 +28,55 @@ SECTION
|
|||
coff backends
|
||||
|
||||
BFD supports a number of different flavours of coff format.
|
||||
The major difference between formats are the sizes and
|
||||
The major differences between formats are the sizes and
|
||||
alignments of fields in structures on disk, and the occasional
|
||||
extra field.
|
||||
|
||||
Coff in all its varieties is implimented with a few common
|
||||
Coff in all its varieties is implemented with a few common
|
||||
files and a number of implementation specific files. For
|
||||
example, The 88k bcs coff format is implemented in the file
|
||||
@code{coff-m88k.c}. This file @code{#include}s
|
||||
@code{coff/m88k.h} which defines the external structure of the
|
||||
coff format for the 88k, and @code{coff/internal.h} which
|
||||
defines the internal structure. @code{coff-m88k.c} also
|
||||
@file{coff-m88k.c}. This file @code{#include}s
|
||||
@file{coff/m88k.h} which defines the external structure of the
|
||||
coff format for the 88k, and @file{coff/internal.h} which
|
||||
defines the internal structure. @file{coff-m88k.c} also
|
||||
defines the relocations used by the 88k format
|
||||
@xref{Relocations}.
|
||||
|
||||
The Intel i960 processor version of coff is implemented in
|
||||
@code{coff-i960.c}. This file has the same structure as
|
||||
@code{coff-m88k.c}, except that it includes @code{coff/i960.h}
|
||||
rather than @code{coff-m88k.h}.
|
||||
@file{coff-i960.c}. This file has the same structure as
|
||||
@file{coff-m88k.c}, except that it includes @file{coff/i960.h}
|
||||
rather than @file{coff-m88k.h}.
|
||||
|
||||
SUBSECTION
|
||||
Porting To A New Version of Coff
|
||||
Porting to a new version of coff
|
||||
|
||||
The recommended method is to select from the existing
|
||||
implimentations the version of coff which is most like the one
|
||||
you want to use, for our purposes, we'll say that i386 coff is
|
||||
implementations the version of coff which is most like the one
|
||||
you want to use. For example, we'll say that i386 coff is
|
||||
the one you select, and that your coff flavour is called foo.
|
||||
Copy the @code{i386coff.c} to @code{foocoff.c}, copy
|
||||
@code{../include/coff/i386.h} to @code{../include/coff/foo.h}
|
||||
and add the lines to @code{targets.c} and @code{Makefile.in}
|
||||
Copy @file{i386coff.c} to @file{foocoff.c}, copy
|
||||
@file{../include/coff/i386.h} to @file{../include/coff/foo.h},
|
||||
and add the lines to @file{targets.c} and @file{Makefile.in}
|
||||
so that your new back end is used. Alter the shapes of the
|
||||
structures in @code{../include/coff/foo.h} so that they match
|
||||
structures in @file{../include/coff/foo.h} so that they match
|
||||
what you need. You will probably also have to add
|
||||
@code{#ifdef}s to the code in @code{coff/internal.h} and
|
||||
@code{coffcode.h} if your version of coff is too wild.
|
||||
@code{#ifdef}s to the code in @file{coff/internal.h} and
|
||||
@file{coffcode.h} if your version of coff is too wild.
|
||||
|
||||
You can verify that your new BFD backend works quite simply by
|
||||
building @code{objdump} from the @code{binutils} directory,
|
||||
and making sure that its version of what's going on at your
|
||||
host systems idea (assuming it has the pretty standard coff
|
||||
dump utility (usually called @code{att-dump} or just
|
||||
@code{dump})) are the same. Then clean up your code, and send
|
||||
building @file{objdump} from the @file{binutils} directory,
|
||||
and making sure that its version of what's going on and your
|
||||
host system's idea (assuming it has the pretty standard coff
|
||||
dump utility, usually called @code{att-dump} or just
|
||||
@code{dump}) are the same. Then clean up your code, and send
|
||||
what you've done to Cygnus. Then your stuff will be in the
|
||||
next release, and you won't have to keep integrating it.
|
||||
|
||||
SUBSECTION
|
||||
How The Coff Backend Works
|
||||
How the coff backend works
|
||||
|
||||
SUBSUBSECTION
|
||||
File Layout
|
||||
File layout
|
||||
|
||||
The Coff backend is split into generic routines that are
|
||||
applicable to any Coff target and routines that are specific
|
||||
|
@ -91,7 +91,7 @@ SUBSUBSECTION
|
|||
structure, one of which exists for each target.
|
||||
|
||||
The essentially similar target-specific routines are in
|
||||
@file{coffcode.h}. This header file includes executable code.
|
||||
@file{coffcode.h}. This header file includes executable C code.
|
||||
The various Coff targets first include the appropriate Coff
|
||||
header file, make any special defines that are needed, and
|
||||
then include @file{coffcode.h}.
|
||||
|
@ -109,24 +109,24 @@ SUBSUBSECTION
|
|||
target.
|
||||
|
||||
SUBSUBSECTION
|
||||
Bit Twiddling
|
||||
Bit twiddling
|
||||
|
||||
Each flavour of coff supported in BFD has its own header file
|
||||
descibing the external layout of the structures. There is also
|
||||
an internal description of the coff layout (in
|
||||
@code{coff/internal.h}). A major function of the
|
||||
describing the external layout of the structures. There is also
|
||||
an internal description of the coff layout, in
|
||||
@file{coff/internal.h}. A major function of the
|
||||
coff backend is swapping the bytes and twiddling the bits to
|
||||
translate the external form of the structures into the normal
|
||||
internal form. This is all performed in the
|
||||
@code{bfd_swap}_@i{thing}_@i{direction} routines. Some
|
||||
elements are different sizes between different versions of
|
||||
coff, it is the duty of the coff version specific include file
|
||||
coff; it is the duty of the coff version specific include file
|
||||
to override the definitions of various packing routines in
|
||||
@code{coffcode.h}. Eg the size of line number entry in coff is
|
||||
@file{coffcode.h}. E.g., the size of line number entry in coff is
|
||||
sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
|
||||
@code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
|
||||
correct one. No doubt, some day someone will find a version of
|
||||
coff which has a varying field size not catered for at the
|
||||
coff which has a varying field size not catered to at the
|
||||
moment. To port BFD, that person will have to add more @code{#defines}.
|
||||
Three of the bit twiddling routines are exported to
|
||||
@code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
|
||||
|
@ -139,29 +139,29 @@ SUBSUBSECTION
|
|||
@code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
|
||||
of all the symbol table and reloc drudgery itself, thereby
|
||||
saving the internal BFD overhead, but uses BFD to swap things
|
||||
on the way out, making cross ports much safer. This also
|
||||
on the way out, making cross ports much safer. Doing so also
|
||||
allows BFD (and thus the linker) to use the same header files
|
||||
as @code{gas}, which makes one avenue to disaster disappear.
|
||||
|
||||
SUBSUBSECTION
|
||||
Symbol Reading
|
||||
Symbol reading
|
||||
|
||||
The simple canonical form for symbols used by BFD is not rich
|
||||
enough to keep all the information available in a coff symbol
|
||||
table. The back end gets around this by keeping the original
|
||||
table. The back end gets around this problem by keeping the original
|
||||
symbol table around, "behind the scenes".
|
||||
|
||||
When a symbol table is requested (through a call to
|
||||
@code{bfd_canonicalize_symtab}, a request gets through to
|
||||
@code{bfd_canonicalize_symtab}), a request gets through to
|
||||
@code{coff_get_normalized_symtab}. This reads the symbol table from
|
||||
the coff file and swaps all the structures inside into the
|
||||
internal form. It also fixes up all the pointers in the table
|
||||
(represented in the file by offsets from the first symbol in
|
||||
the table) into physical pointers to elements in the new
|
||||
internal table. This involves some work since the meanings of
|
||||
fields changes depending upon context; a field that is a
|
||||
fields change depending upon context: a field that is a
|
||||
pointer to another structure in the symbol table at one moment
|
||||
may be the size in bytes of a structure in the next. Another
|
||||
may be the size in bytes of a structure at the next. Another
|
||||
pass is made over the table. All symbols which mark file names
|
||||
(<<C_FILE>> symbols) are modified so that the internal
|
||||
string points to the value in the auxent (the real filename)
|
||||
|
@ -170,28 +170,28 @@ SUBSUBSECTION
|
|||
|
||||
At this time the symbol names are moved around. Coff stores
|
||||
all symbols less than nine characters long physically
|
||||
within the symbol table, longer strings are kept at the end of
|
||||
within the symbol table; longer strings are kept at the end of
|
||||
the file in the string table. This pass moves all strings
|
||||
into memory, and replaces them with pointers to the strings.
|
||||
into memory and replaces them with pointers to the strings.
|
||||
|
||||
|
||||
The symbol table is massaged once again, this time to create
|
||||
the canonical table used by the BFD application. Each symbol
|
||||
is inspected in turn, and a decision made (using the
|
||||
@code{sclass} field) about the various flags to set in the
|
||||
@code{asymbol} @xref{Symbols}. The generated canonical table
|
||||
@code{asymbol}. @xref{Symbols}. The generated canonical table
|
||||
shares strings with the hidden internal symbol table.
|
||||
|
||||
Any linenumbers are read from the coff file too, and attached
|
||||
to the symbols which own the functions the linenumbers belong to.
|
||||
|
||||
SUBSUBSECTION
|
||||
Symbol Writing
|
||||
Symbol writing
|
||||
|
||||
Writing a symbol to a coff file which didn't come from a coff
|
||||
file will lose any debugging information. The @code{asymbol}
|
||||
structure remembers the BFD from which was born, and on output
|
||||
the back end makes sure that the same destination target as
|
||||
structure remembers the BFD from which the symbol was taken, and on
|
||||
output the back end makes sure that the same destination target as
|
||||
source target is present.
|
||||
|
||||
When the symbols have come from a coff file then all the
|
||||
|
@ -215,24 +215,23 @@ SUBSUBSECTION
|
|||
0x100, would have the value 0x20. Coff expects symbols to
|
||||
contain their final value, so symbols have their values
|
||||
changed at this point to reflect their sum with their owning
|
||||
section. Note that this transformation uses the
|
||||
section. This transformation uses the
|
||||
<<output_section>> field of the @code{asymbol}'s
|
||||
@code{asection} @xref{Sections}.
|
||||
|
||||
o coff_mangle_symbols
|
||||
o <<coff_mangle_symbols>>
|
||||
|
||||
This routine runs though the provided symbol table and uses
|
||||
the offsets generated by the previous pass and the pointers
|
||||
generated when the symbol table was read in to create the
|
||||
structured hierachy required by coff. It changes each pointer
|
||||
to a symbol to an index into the symbol table of the symbol
|
||||
being referenced.
|
||||
to a symbol into the index into the symbol table of the asymbol.
|
||||
|
||||
o coff_write_symbols
|
||||
o <<coff_write_symbols>>
|
||||
|
||||
This routine runs through the symbol table and patches up the
|
||||
symbols from their internal form into the coff way, calls the
|
||||
bit twiddlers and writes out the tabel to the file.
|
||||
bit twiddlers, and writes out the table to the file.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -241,8 +240,8 @@ INTERNAL_DEFINITION
|
|||
coff_symbol_type
|
||||
|
||||
DESCRIPTION
|
||||
The hidden information for an asymbol is described in a
|
||||
coff_ptr_struct, which is typedefed to a combined_entry_type
|
||||
The hidden information for an <<asymbol>> is described in a
|
||||
<<combined_entry_type>>:
|
||||
|
||||
CODE_FRAGMENT
|
||||
.
|
||||
|
@ -472,7 +471,7 @@ INTERNAL_DEFINITION
|
|||
|
||||
CODE_FRAGMENT
|
||||
|
||||
Special entry points for gdb to swap in coff symbol table parts
|
||||
Special entry points for gdb to swap in coff symbol table parts:
|
||||
.typedef struct
|
||||
.{
|
||||
. void (*_bfd_coff_swap_aux_in) PARAMS ((
|
||||
|
@ -493,7 +492,7 @@ Special entry points for gdb to swap in coff symbol table parts
|
|||
. PTR in));
|
||||
.
|
||||
|
||||
Special entry points for gas to swap coff parts
|
||||
Special entry points for gas to swap out coff parts:
|
||||
|
||||
. unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
|
||||
. bfd *abfd,
|
||||
|
@ -534,7 +533,7 @@ Special entry points for gas to swap coff parts
|
|||
.
|
||||
|
||||
Special entry points for generic COFF routines to call target
|
||||
dependent COFF routines
|
||||
dependent COFF routines:
|
||||
|
||||
. unsigned int _bfd_filhsz;
|
||||
. unsigned int _bfd_aoutsz;
|
||||
|
@ -845,7 +844,7 @@ coff_set_arch_mach_hook(abfd, filehdr)
|
|||
case I386MAGIC:
|
||||
case I386PTXMAGIC:
|
||||
case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
|
||||
case I386LYNXMAGIC:
|
||||
case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
|
||||
arch = bfd_arch_i386;
|
||||
machine = 0;
|
||||
break;
|
||||
|
@ -867,6 +866,9 @@ coff_set_arch_mach_hook(abfd, filehdr)
|
|||
#endif
|
||||
#ifdef APOLLOM68KMAGIC
|
||||
case APOLLOM68KMAGIC:
|
||||
#endif
|
||||
#ifdef LYNXCOFFMAGIC
|
||||
case LYNXCOFFMAGIC:
|
||||
#endif
|
||||
arch = bfd_arch_m68k;
|
||||
machine = 68020;
|
||||
|
@ -975,6 +977,13 @@ coff_set_arch_mach_hook(abfd, filehdr)
|
|||
break;
|
||||
#endif
|
||||
|
||||
#ifdef SPARCMAGIC
|
||||
case SPARCMAGIC:
|
||||
arch = bfd_arch_sparc;
|
||||
machine = 0;
|
||||
break;
|
||||
#endif
|
||||
|
||||
default: /* Unreadable input file type */
|
||||
arch = bfd_arch_obscure;
|
||||
break;
|
||||
|
@ -1003,14 +1012,14 @@ DEFUN (symname_in_debug_hook, (abfd, sym),
|
|||
|
||||
/*
|
||||
SUBSUBSECTION
|
||||
Writing Relocations
|
||||
Writing relocations
|
||||
|
||||
To write relocations, all the back end does is step though the
|
||||
canonical relocation table, and create an
|
||||
To write relocations, the back end steps though the
|
||||
canonical relocation table and create an
|
||||
@code{internal_reloc}. The symbol index to use is removed from
|
||||
the @code{offset} field in the symbol table supplied, the
|
||||
the @code{offset} field in the symbol table supplied. The
|
||||
address comes directly from the sum of the section base
|
||||
address and the relocation offset and the type is dug directly
|
||||
address and the relocation offset; the type is dug directly
|
||||
from the howto field. Then the @code{internal_reloc} is
|
||||
swapped into the shape of an @code{external_reloc} and written
|
||||
out to disk.
|
||||
|
@ -1142,6 +1151,10 @@ DEFUN(coff_set_flags,(abfd, magicp, flagsp),
|
|||
#ifdef I386MAGIC
|
||||
case bfd_arch_i386:
|
||||
*magicp = I386MAGIC;
|
||||
#ifdef LYNXOS
|
||||
/* Just overwrite the usual value if we're doing Lynx. */
|
||||
*magicp = LYNXCOFFMAGIC;
|
||||
#endif
|
||||
return true;
|
||||
break;
|
||||
#endif
|
||||
|
@ -1151,6 +1164,10 @@ DEFUN(coff_set_flags,(abfd, magicp, flagsp),
|
|||
*magicp = APOLLO_COFF_VERSION_NUMBER;
|
||||
#else
|
||||
*magicp = MC68MAGIC;
|
||||
#endif
|
||||
#ifdef LYNXOS
|
||||
/* Just overwrite the usual value if we're doing Lynx. */
|
||||
*magicp = LYNXCOFFMAGIC;
|
||||
#endif
|
||||
return true;
|
||||
break;
|
||||
|
@ -1183,6 +1200,17 @@ DEFUN(coff_set_flags,(abfd, magicp, flagsp),
|
|||
break;
|
||||
#endif
|
||||
|
||||
#ifdef SPARCMAGIC
|
||||
case bfd_arch_sparc:
|
||||
*magicp = SPARCMAGIC;
|
||||
#ifdef LYNXOS
|
||||
/* Just overwrite the usual value if we're doing Lynx. */
|
||||
*magicp = LYNXCOFFMAGIC;
|
||||
#endif
|
||||
return true;
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef H8500MAGIC
|
||||
case bfd_arch_h8500:
|
||||
*magicp = H8500MAGIC;
|
||||
|
@ -1795,12 +1823,12 @@ buy_and_read(abfd, where, seek_direction, size)
|
|||
|
||||
/*
|
||||
SUBSUBSECTION
|
||||
Reading Linenumbers
|
||||
Reading linenumbers
|
||||
|
||||
Creating the linenumber table is done by reading in the entire
|
||||
coff linenumber table, and creating another table for internal use.
|
||||
|
||||
A coff line number table is structured so that each function
|
||||
A coff linenumber table is structured so that each function
|
||||
is marked as having a line number of 0. Each line within the
|
||||
function is an offset from the first line in the function. The
|
||||
base of the line number information for the table is stored in
|
||||
|
@ -2093,22 +2121,22 @@ DEFUN(coff_slurp_symbol_table,(abfd),
|
|||
|
||||
/*
|
||||
SUBSUBSECTION
|
||||
Reading Relocations
|
||||
Reading relocations
|
||||
|
||||
Coff relocations are easily transformed into the internal BFD form
|
||||
(@code{arelent}).
|
||||
|
||||
Reading a coff relocation table is done in the following stages:
|
||||
|
||||
o The entire coff relocation table is read into memory.
|
||||
o Read the entire coff relocation table into memory.
|
||||
|
||||
o Each relocation is processed in turn, first it is swapped from the
|
||||
o Process each relocation in turn; first swap it from the
|
||||
external to the internal form.
|
||||
|
||||
o The symbol referenced in the relocation's symbol index is
|
||||
turned intoa pointer into the canonical symbol table. Note
|
||||
that this table is the same as the one returned by a call to
|
||||
@code{bfd_canonicalize_symtab}. The back end will call the
|
||||
o Turn the symbol referenced in the relocation's symbol index
|
||||
into a pointer into the canonical symbol table.
|
||||
This table is the same as the one returned by a call to
|
||||
@code{bfd_canonicalize_symtab}. The back end will call that
|
||||
routine and save the result if a canonicalization hasn't been done.
|
||||
|
||||
o The reloc index is turned into a pointer to a howto
|
||||
|
|
14
bfd/core.c
14
bfd/core.c
|
@ -23,7 +23,7 @@ SECTION
|
|||
Core files
|
||||
|
||||
DESCRIPTION
|
||||
Buff output this facinating topic
|
||||
These are functions pertaining to core files.
|
||||
*/
|
||||
|
||||
#include "bfd.h"
|
||||
|
@ -36,11 +36,11 @@ FUNCTION
|
|||
bfd_core_file_failing_command
|
||||
|
||||
SYNOPSIS
|
||||
CONST char *bfd_core_file_failing_command(bfd *);
|
||||
CONST char *bfd_core_file_failing_command(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns a read-only string explaining what program was running
|
||||
when it failed and produced the core file being read
|
||||
Return a read-only string explaining which program was running
|
||||
when it failed and produced the core file @var{abfd}.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -60,11 +60,11 @@ FUNCTION
|
|||
bfd_core_file_failing_signal
|
||||
|
||||
SYNOPSIS
|
||||
int bfd_core_file_failing_signal(bfd *);
|
||||
int bfd_core_file_failing_signal(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns the signal number which caused the core dump which
|
||||
generated the file the BFD is attached to.
|
||||
generated the file the BFD @var{abfd} is attached to.
|
||||
*/
|
||||
|
||||
int
|
||||
|
@ -88,7 +88,7 @@ SYNOPSIS
|
|||
(bfd *core_bfd, bfd *exec_bfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns <<true>> if the core file attached to @var{core_bfd}
|
||||
Return <<true>> if the core file attached to @var{core_bfd}
|
||||
was generated by a run of the executable file attached to
|
||||
@var{exec_bfd}, or else <<false>>.
|
||||
*/
|
||||
|
|
41
bfd/ctor.c
41
bfd/ctor.c
|
@ -25,27 +25,27 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
SECTION
|
||||
Constructors
|
||||
|
||||
Classes in C++ have `constructors' and `destructors'. These
|
||||
Classes in C++ have @dfn{constructors} and @dfn{destructors}. These
|
||||
are functions which are called automatically by the language
|
||||
whenever data of a class is created or destroyed. Class data
|
||||
which is static data may also be have a type which requires
|
||||
`construction', the contructor must be called before the data
|
||||
which is static may also be have a type which requires
|
||||
`construction'; the contructor must be called before the data
|
||||
can be referenced, so the contructor must be called before the
|
||||
program begins.
|
||||
|
||||
The common solution to this problem is for the compiler to
|
||||
call a magic function as the first statement <<main>>.
|
||||
This magic function, (often called <<__main>>) runs around
|
||||
call a magic function as the first statement before <<main>>.
|
||||
This magic function (often called <<__main>>) runs around
|
||||
calling the constructors for all the things needing it.
|
||||
|
||||
With COFF the compile has a bargain with the linker et al.
|
||||
All constructors are given strange names, for example
|
||||
With COFF, the compiler has a bargain with the linker et al.
|
||||
All constructors are given strange names; for example,
|
||||
<<__GLOBAL__$I$foo>> might be the label of a contructor for
|
||||
the class @var{foo}. The solution on unfortunate systems
|
||||
(most system V machines) is to perform a partial link on all
|
||||
(most System V machines) is to perform a partial link on all
|
||||
the <<.o>> files, do an <<nm>> on the result, run <<awk>> or some
|
||||
such over the result looking for strange <<__GLOBAL__$>>
|
||||
symbols, generate a C program from this, compile it and link
|
||||
symbols, generate a C program from this, compile it, and link
|
||||
with the partially linked input. This process is usually
|
||||
called <<collect>>.
|
||||
|
||||
|
@ -54,10 +54,10 @@ SECTION
|
|||
from the compiler with a special stab code saying that they
|
||||
are constructors, and the linker can deal with them directly.
|
||||
|
||||
BFD allows applications (ie the linker) to deal with
|
||||
BFD allows applications (i.e., the linker) to deal with
|
||||
constructor information independently of their external
|
||||
implimentation by providing a set of entry points for the
|
||||
indiviual object back ends to call which maintains a database
|
||||
implementation by providing a set of entry points for the
|
||||
indiviual object back ends to call to maintain a database
|
||||
of the contructor information. The application can
|
||||
interrogate the database to find out what it wants. The
|
||||
construction data essential for the linker to be able to
|
||||
|
@ -71,15 +71,15 @@ SECTION
|
|||
The type of symbol, i.e., is it a constructor, a destructor or
|
||||
something else someone dreamed up to make our lives difficult.
|
||||
|
||||
This module takes this information and then builds extra
|
||||
sections attached to the bfds which own the entry points. It
|
||||
The constructor module takes this information and builds extra
|
||||
sections attached to the BFDs which own the entry points. It
|
||||
creates these sections as if they were tables of pointers to
|
||||
the entry points, and builds relocation entries to go with
|
||||
them so that the tables can be relocated along with the data
|
||||
they reference.
|
||||
|
||||
These sections are marked with a special bit
|
||||
(<<SEC_CONSTRUCTOR>>) which the linker notices and do with
|
||||
(<<SEC_CONSTRUCTOR>>), which the linker notices and does with
|
||||
what it wants.
|
||||
|
||||
*/
|
||||
|
@ -101,11 +101,11 @@ SYNOPSIS
|
|||
|
||||
|
||||
DESCRIPTION
|
||||
This function is called with an a symbol describing the
|
||||
function to be called, an string which descibes the xtor type,
|
||||
e.g., something like "CTOR" or "DTOR" would be fine. And the bfd
|
||||
which owns the function. Its duty is to create a section
|
||||
called "CTOR" or "DTOR" or whatever if the bfd doesn't already
|
||||
@var{symbol_ptr_ptr} describes the
|
||||
function to be called; @var{type} descibes the xtor type,
|
||||
e.g., something like "CTOR" or "DTOR" would be fine. @var{abfd}
|
||||
is the BFD which owns the function. Create a section
|
||||
called "CTOR" or "DTOR" or whatever if the BFD doesn't already
|
||||
have one, and grow a relocation table for the entry points as
|
||||
they accumulate.
|
||||
|
||||
|
@ -116,7 +116,6 @@ void DEFUN(bfd_constructor_entry,(abfd, symbol_ptr_ptr, type),
|
|||
bfd *abfd AND
|
||||
asymbol **symbol_ptr_ptr AND
|
||||
CONST char *type)
|
||||
|
||||
{
|
||||
/* Look up the section we're using to store the table in */
|
||||
asection *rel_section = bfd_get_section_by_name (abfd, type);
|
||||
|
|
178
bfd/format.c
178
bfd/format.c
|
@ -18,57 +18,74 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
/*doc*
|
||||
@section File Formats
|
||||
A format is a BFD concept of high level file contents. The
|
||||
formats supported by BFD are:
|
||||
@table @code
|
||||
@item bfd_object
|
||||
The BFD may contain data, symbols, relocations and debug info.
|
||||
@item bfd_archive
|
||||
The BFD contains other BFDs and an optional index.
|
||||
@item bfd_core
|
||||
The BFD contains the result of an executable core dump.
|
||||
@end table
|
||||
*/
|
||||
#include "sysdep.h"
|
||||
#include "bfd.h"
|
||||
#include "libbfd.h"
|
||||
/*
|
||||
SECTION
|
||||
File Formats
|
||||
|
||||
A format is a BFD concept of high level file contents type. The
|
||||
formats supported by BFD are:
|
||||
|
||||
o <<bfd_object>>
|
||||
|
||||
The BFD may contain data, symbols, relocations and debug info.
|
||||
|
||||
o <<bfd_archive>>
|
||||
|
||||
The BFD contains other BFDs and an optional index.
|
||||
|
||||
o <<bfd_core>>
|
||||
|
||||
The BFD contains the result of an executable core dump.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
#include "bfd.h"
|
||||
#include "sysdep.h"
|
||||
#include "libbfd.h"
|
||||
|
||||
extern bfd_target *target_vector[];
|
||||
extern bfd_target *default_vector[];
|
||||
|
||||
|
||||
/*proto*
|
||||
*i bfd_check_format
|
||||
This routine is supplied a BFD and a format. It attempts to verify if
|
||||
the file attatched to the BFD is indeed compatible with the format
|
||||
specified (ie, one of @code{bfd_object}, @code{bfd_archive} or
|
||||
@code{bfd_core}).
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_check_format
|
||||
|
||||
If the BFD has been set to a specific @var{target} before the call,
|
||||
only the named target and format combination will be checked. If the
|
||||
target has not been set, or has been set to @code{default} then all
|
||||
the known target backends will be interrogated to determine a match.
|
||||
SYNOPSIS
|
||||
boolean bfd_check_format(bfd *abfd, bfd_format format);
|
||||
|
||||
The function returns @code{true} on success, otherwise @code{false}
|
||||
with one of the following error codes:
|
||||
@table @code
|
||||
@item
|
||||
invalid_operation
|
||||
if @code{format} is not one of @code{bfd_object}, @code{bfd_archive}
|
||||
or @code{bfd_core}.
|
||||
@item system_call_error
|
||||
if an error occured during a read - even some file mismatches can
|
||||
cause system_call_errros
|
||||
@item file_not_recognised
|
||||
none of the backends recognised the file format
|
||||
@item file_ambiguously_recognized
|
||||
more than one backend recognised the file format.
|
||||
@end table
|
||||
*; PROTO(boolean, bfd_check_format, (bfd *abfd, bfd_format format));
|
||||
*-*/
|
||||
DESCRIPTION
|
||||
Verify if the file attached to the BFD @var{abfd} is compatible
|
||||
with the format @var{format} (i.e., one of <<bfd_object>>,
|
||||
<<bfd_archive>> or <<bfd_core>>).
|
||||
|
||||
If the BFD has been set to a specific target before the
|
||||
call, only the named target and format combination is
|
||||
checked. If the target has not been set, or has been set to
|
||||
<<default>>, then all the known target backends is
|
||||
interrogated to determine a match. If the default target
|
||||
matches, it is used. If not, exactly one target must recognize
|
||||
the file, or an error results.
|
||||
|
||||
The function returns <<true>> on success, otherwise <<false>>
|
||||
with one of the following error codes:
|
||||
|
||||
o invalid_operation -
|
||||
if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
|
||||
<<bfd_core>>.
|
||||
|
||||
o system_call_error -
|
||||
if an error occured during a read - even some file mismatches
|
||||
can cause system_call_errors.
|
||||
|
||||
o file_not_recognised -
|
||||
none of the backends recognised the file format.
|
||||
|
||||
o file_ambiguously_recognized -
|
||||
more than one backend recognised the file format.
|
||||
|
||||
*/
|
||||
|
||||
boolean
|
||||
DEFUN(bfd_check_format,(abfd, format),
|
||||
|
@ -88,6 +105,15 @@ DEFUN(bfd_check_format,(abfd, format),
|
|||
if (abfd->format != bfd_unknown)
|
||||
return (abfd->format == format)? true: false;
|
||||
|
||||
|
||||
/* Since the target type was defaulted, check them
|
||||
all in the hope that one will be uniquely recognized. */
|
||||
|
||||
save_targ = abfd->xvec;
|
||||
match_count = 0;
|
||||
right_targ = 0;
|
||||
|
||||
|
||||
/* presume the answer is yes */
|
||||
abfd->format = format;
|
||||
|
||||
|
@ -101,22 +127,17 @@ DEFUN(bfd_check_format,(abfd, format),
|
|||
abfd->xvec = right_targ; /* Set the target as returned */
|
||||
return true; /* File position has moved, BTW */
|
||||
}
|
||||
abfd->format = bfd_unknown;
|
||||
return false; /* Specified target is not right */
|
||||
}
|
||||
|
||||
/* Since the target type was defaulted, check them
|
||||
all in the hope that one will be uniquely recognized. */
|
||||
|
||||
save_targ = abfd->xvec;
|
||||
match_count = 0;
|
||||
right_targ = 0;
|
||||
|
||||
for (target = target_vector; *target != NULL; target++) {
|
||||
bfd_target *temp;
|
||||
|
||||
abfd->xvec = *target; /* Change BFD's target temporarily */
|
||||
bfd_seek (abfd, (file_ptr)0, SEEK_SET);
|
||||
/* If _bfd_check_format neglects to set bfd_error, assume wrong_format.
|
||||
We didn't used to even pay any attention to bfd_error, so I suspect
|
||||
that some _bfd_check_format might have this problem. */
|
||||
bfd_error = wrong_format;
|
||||
temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
|
||||
if (temp) { /* This format checks out as ok! */
|
||||
right_targ = temp;
|
||||
|
@ -125,7 +146,10 @@ DEFUN(bfd_check_format,(abfd, format),
|
|||
might match. People who want those other targets have to set
|
||||
the GNUTARGET variable. */
|
||||
if (temp == default_vector[0])
|
||||
break;
|
||||
{
|
||||
match_count = 1;
|
||||
break;
|
||||
}
|
||||
#ifdef GNU960
|
||||
/* Big- and little-endian b.out archives look the same, but it doesn't
|
||||
* matter: there is no difference in their headers, and member file byte
|
||||
|
@ -135,6 +159,10 @@ DEFUN(bfd_check_format,(abfd, format),
|
|||
*/
|
||||
break;
|
||||
#endif
|
||||
} else if (bfd_error != wrong_format) {
|
||||
abfd->xvec = save_targ;
|
||||
abfd->format = bfd_unknown;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -149,14 +177,23 @@ DEFUN(bfd_check_format,(abfd, format),
|
|||
file_ambiguously_recognized);
|
||||
return false;
|
||||
}
|
||||
/*proto*
|
||||
*i bfd_set_format
|
||||
This function sets the file format of the supplied BFD to the format
|
||||
requested. If the target set in the BFD does not support the format
|
||||
requested, the format is illegal or the BFD is not open for writing
|
||||
than an error occurs.
|
||||
*; PROTO(boolean,bfd_set_format,(bfd *, bfd_format));
|
||||
*-*/
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_set_format
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_set_format(bfd *abfd, bfd_format format);
|
||||
|
||||
DESCRIPTION
|
||||
This function sets the file format of the BFD @var{abfd} to the
|
||||
format @var{format}. If the target set in the BFD does not
|
||||
support the format requested, the format is invalid, or the BFD
|
||||
is not open for writing, then an error occurs.
|
||||
|
||||
*/
|
||||
|
||||
boolean
|
||||
DEFUN(bfd_set_format,(abfd, format),
|
||||
bfd *abfd AND
|
||||
|
@ -185,13 +222,18 @@ DEFUN(bfd_set_format,(abfd, format),
|
|||
}
|
||||
|
||||
|
||||
/*proto*
|
||||
*i bfd_format_string
|
||||
This function takes one argument, and enumerated type (bfd_format) and
|
||||
returns a pointer to a const string "invalid", "object", "archive",
|
||||
"core" or "unknown" depending upon the value of the enumeration.
|
||||
*; PROTO(CONST char *, bfd_format_string, (bfd_format));
|
||||
*-*/
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_format_string
|
||||
|
||||
SYNOPSIS
|
||||
CONST char *bfd_format_string(bfd_format format);
|
||||
|
||||
DESCRIPTION
|
||||
Return a pointer to a const string
|
||||
<<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
|
||||
depending upon the value of @var{format}.
|
||||
*/
|
||||
|
||||
CONST char *
|
||||
DEFUN(bfd_format_string,(format),
|
||||
|
|
51
bfd/init.c
51
bfd/init.c
|
@ -17,21 +17,36 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
#include <sysdep.h>
|
||||
|
||||
#include "bfd.h"
|
||||
#include "sysdep.h"
|
||||
#include "libbfd.h"
|
||||
|
||||
extern void DEFUN_VOID (bfd_section_init);
|
||||
|
||||
static boolean initialized = false;
|
||||
|
||||
/*proto* bfd_init
|
||||
/*
|
||||
SECTION
|
||||
Initialization
|
||||
|
||||
This routine must be called before any other bfd function to initialize
|
||||
magical internal data structures.
|
||||
|
||||
*; void EXFUN(bfd_init,(void));
|
||||
These are the functions that handle initializing a BFD.
|
||||
*/
|
||||
|
||||
void DEFUN_VOID(bfd_init)
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_init
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_init(void);
|
||||
|
||||
DESCRIPTION
|
||||
This routine must be called before any other libbfd function to
|
||||
initialize magical internal data structures.
|
||||
*/
|
||||
|
||||
void
|
||||
bfd_init ()
|
||||
{
|
||||
if (initialized == false) {
|
||||
initialized = true;
|
||||
|
@ -41,22 +56,24 @@ void DEFUN_VOID(bfd_init)
|
|||
}
|
||||
|
||||
|
||||
/*proto-internal* bfd_check_init
|
||||
/*
|
||||
INTERNAL_FUNCTION
|
||||
bfd_check_init
|
||||
|
||||
This routine is called before any other bfd function using initialized
|
||||
data is used to ensure that the structures have been initialized.
|
||||
Soon this function will go away, and the bfd library will assume that
|
||||
bfd_init has been called.
|
||||
SYNOPSIS
|
||||
void bfd_check_init(void);
|
||||
|
||||
*; void EXFUN(bfd_check_init,(void));
|
||||
DESCRIPTION
|
||||
This routine is called before any other libbfd function using
|
||||
initialized data. It ensures that the structures have
|
||||
been initialized. Soon this function will go away, and the bfd
|
||||
library will assume that <<bfd_init>> has been called.
|
||||
*/
|
||||
|
||||
void DEFUN_VOID(bfd_check_init)
|
||||
void
|
||||
bfd_check_init ()
|
||||
{
|
||||
if (initialized == false) {
|
||||
fprintf(stderr,"The bfd library now requires you to call bfd_init()\n");
|
||||
fprintf(stderr,"before any other calls to bfd routines. Please\n");
|
||||
fprintf(stderr,"change your source\n");
|
||||
bfd_init();
|
||||
}
|
||||
}
|
||||
|
|
23
bfd/libbfd.c
23
bfd/libbfd.c
|
@ -27,7 +27,7 @@ SECTION
|
|||
libbfd
|
||||
|
||||
DESCRIPTION
|
||||
This file contains various routines which are used within BFD.
|
||||
These routines are used within BFD.
|
||||
They are not intended for export, but are documented here for
|
||||
completeness.
|
||||
*/
|
||||
|
@ -138,7 +138,7 @@ SYNOPSIS
|
|||
PTR bfd_xmalloc( bfd_size_type size);
|
||||
|
||||
DESCRIPTION
|
||||
Like malloc, but exit if no more memory.
|
||||
Like <<malloc>>, but exit if no more memory.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -157,7 +157,7 @@ DEFUN(PTR bfd_xmalloc,(size),
|
|||
if (!ptr)
|
||||
{
|
||||
write (2, no_memory_message, sizeof(no_memory_message)-1);
|
||||
exit (-1);
|
||||
exit (1);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
@ -170,8 +170,8 @@ SYNOPSIS
|
|||
PTR bfd_xmalloc_by_size_t ( size_t size);
|
||||
|
||||
DESCRIPTION
|
||||
Like malloc, but exit if no more memory.
|
||||
Uses size_t, so it's suitable for use as obstack_chunk_alloc.
|
||||
Like <<malloc>>, but exit if no more memory.
|
||||
Uses <<size_t>>, so it's suitable for use as <<obstack_chunk_alloc>>.
|
||||
*/
|
||||
PTR
|
||||
DEFUN(bfd_xmalloc_by_size_t, (size),
|
||||
|
@ -246,8 +246,8 @@ SYNOPSIS
|
|||
void bfd_write_bigendian_4byte_int(bfd *abfd, int i);
|
||||
|
||||
DESCRIPTION
|
||||
Writes a 4 byte integer to the outputing bfd, in big endian
|
||||
mode regardless of what else is going on. This is useful in
|
||||
Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
|
||||
endian order regardless of what else is going on. This is useful in
|
||||
archives.
|
||||
|
||||
*/
|
||||
|
@ -501,15 +501,14 @@ DESCRIPTION
|
|||
/*
|
||||
FUNCTION
|
||||
bfd_h_put_size
|
||||
FUNCTION
|
||||
bfd_h_get_size
|
||||
|
||||
DESCRIPTION
|
||||
These macros have the same function as their <<bfd_get_x>>
|
||||
bretherin, except that they are used for removing information
|
||||
bretheren, except that they are used for removing information
|
||||
for the header records of object files. Believe it or not,
|
||||
some object files keep their header records in big endian
|
||||
order, and their data in little endian order.
|
||||
order and their data in little endian order.
|
||||
.
|
||||
.{* Byte swapping macros for file header data. *}
|
||||
.
|
||||
|
@ -850,8 +849,8 @@ INTERNAL_FUNCTION
|
|||
bfd_log2
|
||||
|
||||
DESCRIPTION
|
||||
Return the log base 2 of the value supplied, rounded up. eg an
|
||||
arg of 1025 would return 11.
|
||||
Return the log base 2 of the value supplied, rounded up. E.g., an
|
||||
@var{x} of 1025 returns 11.
|
||||
|
||||
SYNOPSIS
|
||||
unsigned int bfd_log2(bfd_vma x);
|
||||
|
|
16
bfd/libbfd.h
16
bfd/libbfd.h
|
@ -44,8 +44,8 @@ struct artdata {
|
|||
carsym *symdefs; /* the symdef entries */
|
||||
symindex symdef_count; /* how many there are */
|
||||
char *extended_names; /* clever intel extension */
|
||||
|
||||
time_t armap_timestamp; /* Timestamp value written into armap.
|
||||
/* when more compilers are standard C, this can be a time_t */
|
||||
long armap_timestamp; /* Timestamp value written into armap.
|
||||
This is used for BSD archives to check
|
||||
that the timestamp is recent enough
|
||||
for the BSD linker to not complain,
|
||||
|
@ -212,13 +212,13 @@ extern bfd *bfd_last_cache;
|
|||
(FILE*)(bfd_last_cache->iostream): \
|
||||
bfd_cache_lookup_worker(x))
|
||||
boolean
|
||||
bfd_cache_close PARAMS ((bfd *));
|
||||
bfd_cache_close PARAMS ((bfd *abfd));
|
||||
|
||||
FILE*
|
||||
bfd_open_file PARAMS ((bfd *));
|
||||
bfd_open_file PARAMS ((bfd *abfd));
|
||||
|
||||
FILE *
|
||||
bfd_cache_lookup_worker PARAMS ((bfd *));
|
||||
bfd_cache_lookup_worker PARAMS ((bfd *abfd));
|
||||
|
||||
void
|
||||
bfd_constructor_entry PARAMS ((bfd *abfd,
|
||||
|
@ -255,11 +255,11 @@ bfd_default_set_arch_mach PARAMS ((bfd *abfd,
|
|||
enum bfd_architecture arch,
|
||||
unsigned long mach));
|
||||
|
||||
void
|
||||
void
|
||||
bfd_arch_init PARAMS ((void));
|
||||
|
||||
void
|
||||
bfd_arch_linkin PARAMS ((bfd_arch_info_type *));
|
||||
bfd_arch_linkin PARAMS ((bfd_arch_info_type *ptr));
|
||||
|
||||
CONST bfd_arch_info_type *
|
||||
bfd_default_compatible
|
||||
|
@ -267,7 +267,7 @@ bfd_default_compatible
|
|||
CONST bfd_arch_info_type *b));
|
||||
|
||||
boolean
|
||||
bfd_default_scan PARAMS ((CONST struct bfd_arch_info *, CONST char *));
|
||||
bfd_default_scan PARAMS ((CONST struct bfd_arch_info *info, CONST char *string));
|
||||
|
||||
struct elf_internal_shdr *
|
||||
bfd_elf_find_section PARAMS ((bfd *abfd, char *name));
|
||||
|
|
43
bfd/opncls.c
43
bfd/opncls.c
|
@ -93,14 +93,17 @@ FUNCTION
|
|||
bfd_openr
|
||||
|
||||
SYNOPSIS
|
||||
bfd *bfd_openr(CONST char *filename, CONST char*target);
|
||||
bfd *bfd_openr(CONST char *filename, CONST char *target);
|
||||
|
||||
DESCRIPTION
|
||||
This function opens the file supplied (using <<fopen>>) with the target
|
||||
supplied, it returns a pointer to the created BFD.
|
||||
Open the file @var{filename} (using <<fopen>>) with the target
|
||||
@var{target}. Return a pointer to the created BFD.
|
||||
|
||||
If NULL is returned then an error has occured. Possible errors
|
||||
are <<no_memory>>, <<invalid_target>> or <<system_call>> error.
|
||||
|
||||
Calls <<bfd_find_target>>, so @var{target} is interpreted as by
|
||||
that function.
|
||||
*/
|
||||
|
||||
bfd *
|
||||
|
@ -151,11 +154,11 @@ SYNOPSIS
|
|||
bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd);
|
||||
|
||||
DESCRIPTION
|
||||
bfd_fdopenr is to bfd_fopenr much like fdopen is to fopen.
|
||||
<<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to <<fopen>>.
|
||||
It opens a BFD on a file already described by the @var{fd}
|
||||
supplied.
|
||||
|
||||
When the file is later bfd_closed, the file descriptor will be closed.
|
||||
When the file is later <<bfd_close>>d, the file descriptor will be closed.
|
||||
|
||||
If the caller desires that this file descriptor be cached by BFD
|
||||
(opened as needed, closed as needed to free descriptors for
|
||||
|
@ -163,11 +166,10 @@ DESCRIPTION
|
|||
file descriptor (but subject to closure at any time), call
|
||||
bfd_set_cacheable(bfd, 1) on the returned BFD. The default is to
|
||||
assume no cacheing; the file descriptor will remain open until
|
||||
bfd_close, and will not be affected by BFD operations on other
|
||||
<<bfd_close>>, and will not be affected by BFD operations on other
|
||||
files.
|
||||
|
||||
Possible errors are no_memory, invalid_target and system_call
|
||||
error.
|
||||
Possible errors are <<no_memory>>, <<invalid_target>> and <<system_call_error>>.
|
||||
*/
|
||||
|
||||
bfd *
|
||||
|
@ -250,11 +252,11 @@ SYNOPSIS
|
|||
bfd *bfd_openw(CONST char *filename, CONST char *target);
|
||||
|
||||
DESCRIPTION
|
||||
Creates a BFD, associated with file @var{filename}, using the
|
||||
file format @var{target}, and returns a pointer to it.
|
||||
Create a BFD, associated with file @var{filename}, using the
|
||||
file format @var{target}, and return a pointer to it.
|
||||
|
||||
Possible errors are system_call_error, no_memory,
|
||||
invalid_target.
|
||||
Possible errors are <<system_call_error>>, <<no_memory>>,
|
||||
<<invalid_target>>.
|
||||
*/
|
||||
|
||||
bfd *
|
||||
|
@ -296,11 +298,11 @@ FUNCTION
|
|||
bfd_close
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_close(bfd *);
|
||||
boolean bfd_close(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
|
||||
This function closes a BFD. If the BFD was open for writing,
|
||||
Close a BFD. If the BFD was open for writing,
|
||||
then pending operations are completed and the file written out
|
||||
and closed. If the created file is executable, then
|
||||
<<chmod>> is called to mark it as such.
|
||||
|
@ -308,7 +310,7 @@ DESCRIPTION
|
|||
All memory attached to the BFD's obstacks is released.
|
||||
|
||||
The file descriptor associated with the BFD is closed (even
|
||||
if it was passed in to BFD by bfd_fdopenr).
|
||||
if it was passed in to BFD by <<bfd_fdopenr>>).
|
||||
|
||||
RETURNS
|
||||
<<true>> is returned if all is ok, otherwise <<false>>.
|
||||
|
@ -361,7 +363,7 @@ SYNOPSIS
|
|||
boolean bfd_close_all_done(bfd *);
|
||||
|
||||
DESCRIPTION
|
||||
This function closes a BFD. It differs from <<bfd_close>>
|
||||
Close a BFD. Differs from <<bfd_close>>
|
||||
since it does not complete any pending operations. This
|
||||
routine would be used if the application had just used BFD for
|
||||
swapping and didn't want to use any of the writing code.
|
||||
|
@ -417,8 +419,7 @@ SYNOPSIS
|
|||
bfd_size_type bfd_alloc_size(bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Return the number of bytes in the obstacks connected to the
|
||||
supplied BFD.
|
||||
Return the number of bytes in the obstacks connected to @var{abfd}.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -445,7 +446,7 @@ SYNOPSIS
|
|||
bfd *bfd_create(CONST char *filename, bfd *templ);
|
||||
|
||||
DESCRIPTION
|
||||
This routine creates a new BFD in the manner of
|
||||
Create a new BFD in the manner of
|
||||
<<bfd_openw>>, but without opening a file. The new BFD
|
||||
takes the target from the target used by @var{template}. The
|
||||
format is always set to <<bfd_object>>.
|
||||
|
@ -479,8 +480,8 @@ SYNOPSIS
|
|||
PTR bfd_alloc_by_size_t(bfd *abfd, size_t wanted);
|
||||
|
||||
DESCRIPTION
|
||||
This function allocates a block of memory in the obstack
|
||||
attatched to <<abfd>> and returns a pointer to it.
|
||||
Allocate a block of @var{wanted} bytes of memory in the obstack
|
||||
attatched to <<abfd>> and return a pointer to it.
|
||||
*/
|
||||
|
||||
|
||||
|
|
350
bfd/reloc.c
350
bfd/reloc.c
|
@ -22,18 +22,18 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
SECTION
|
||||
Relocations
|
||||
|
||||
BFD maintains relocations in much the same was as it maintains
|
||||
symbols; they are left alone until required, then read in
|
||||
en-mass and traslated into an internal form. There is a common
|
||||
routine <<bfd_perform_relocation>> which acts upon the
|
||||
canonical form to do the actual fixup.
|
||||
BFD maintains relocations in much the same way it maintains
|
||||
symbols: they are left alone until required, then read in
|
||||
en-mass and translated into an internal form. A common
|
||||
routine <<bfd_perform_relocation>> acts upon the
|
||||
canonical form to do the fixup.
|
||||
|
||||
Note that relocations are maintained on a per section basis,
|
||||
whilst symbols are maintained on a per BFD basis.
|
||||
Relocations are maintained on a per section basis,
|
||||
while symbols are maintained on a per BFD basis.
|
||||
|
||||
All a back end has to do to fit the BFD interface is to create
|
||||
as many <<struct reloc_cache_entry>> as there are relocations
|
||||
in a particular section, and fill in the right bits:
|
||||
All that a back end has to do to fit the BFD interface is to create
|
||||
a <<struct reloc_cache_entry>> for each relocation
|
||||
in a particular section, and fill in the right bits of the structures.
|
||||
|
||||
@menu
|
||||
@* typedef arelent::
|
||||
|
@ -71,10 +71,10 @@ CODE_FRAGMENT
|
|||
. {* Used by special functions *}
|
||||
. bfd_reloc_continue,
|
||||
.
|
||||
. {* Unused *}
|
||||
. {* Unsupported relocation size requested. *}
|
||||
. bfd_reloc_notsupported,
|
||||
.
|
||||
. {* Unsupported relocation size requested. *}
|
||||
. {* Unused *}
|
||||
. bfd_reloc_other,
|
||||
.
|
||||
. {* The symbol to relocate against was undefined. *}
|
||||
|
@ -109,14 +109,14 @@ CODE_FRAGMENT
|
|||
/*
|
||||
DESCRIPTION
|
||||
|
||||
Here is a description of each of the fields within a relent:
|
||||
Here is a description of each of the fields within an <<arelent>>:
|
||||
|
||||
o sym_ptr_ptr
|
||||
o <<sym_ptr_ptr>>
|
||||
|
||||
The symbol table pointer points to a pointer to the symbol
|
||||
associated with the relocation request. This would naturally
|
||||
be the pointer into the table returned by the back end's
|
||||
get_symtab action. @xref{Symbols}. The symbol is referenced
|
||||
associated with the relocation request. It is
|
||||
the pointer into the table returned by the back end's
|
||||
<<get_symtab>> action. @xref{Symbols}. The symbol is referenced
|
||||
through a pointer to a pointer so that tools like the linker
|
||||
can fix up all the symbols of the same name by modifying only
|
||||
one pointer. The relocation routine looks in the symbol and
|
||||
|
@ -124,19 +124,19 @@ DESCRIPTION
|
|||
value of the symbol as the initial relocation offset. If the
|
||||
symbol pointer is zero, then the section provided is looked up.
|
||||
|
||||
o address
|
||||
o <<address>>
|
||||
|
||||
The address field gives the offset in bytes from the base of
|
||||
The <<address>> field gives the offset in bytes from the base of
|
||||
the section data which owns the relocation record to the first
|
||||
byte of relocatable information. The actual data relocated
|
||||
will be relative to this point - for example, a relocation
|
||||
will be relative to this point; for example, a relocation
|
||||
type which modifies the bottom two bytes of a four byte word
|
||||
would not touch the first byte pointed to in a big endian
|
||||
world.
|
||||
|
||||
o addend
|
||||
o <<addend>>
|
||||
|
||||
The addend is a value provided by the back end to be added (!)
|
||||
The <<addend>> is a value provided by the back end to be added (!)
|
||||
to the relocation offset. Its interpretation is dependent upon
|
||||
the howto. For example, on the 68k the code:
|
||||
|
||||
|
@ -156,8 +156,8 @@ DESCRIPTION
|
|||
| rts
|
||||
|
||||
|
||||
This could create a reloc pointing to foo, but leave the
|
||||
offset in the data (something like)
|
||||
This could create a reloc pointing to <<foo>>, but leave the
|
||||
offset in the data, something like:
|
||||
|
||||
|
||||
|RELOCATION RECORDS FOR [.text]:
|
||||
|
@ -181,7 +181,7 @@ DESCRIPTION
|
|||
| jmp r1
|
||||
|
||||
|
||||
This should create two relocs, both pointing to _foo, and with
|
||||
This should create two relocs, both pointing to <<_foo>>, and with
|
||||
0x12340000 in their addend field. The data would consist of:
|
||||
|
||||
|
||||
|
@ -196,17 +196,17 @@ DESCRIPTION
|
|||
|
||||
|
||||
The relocation routine digs out the value from the data, adds
|
||||
it to the addend to get the original offset and then adds the
|
||||
value of _foo. Note that all 32 bits have to be kept around
|
||||
it to the addend to get the original offset, and then adds the
|
||||
value of <<_foo>>. Note that all 32 bits have to be kept around
|
||||
somewhere, to cope with carry from bit 15 to bit 16.
|
||||
|
||||
One further example is the sparc and the a.out format. The
|
||||
sparc has a similar problem to the 88k, in that some
|
||||
instructions don't have room for an entire offset, but on the
|
||||
sparc the parts are created odd sized lumps. The designers of
|
||||
the a.out format chose not to use the data within the section
|
||||
sparc the parts are created in odd sized lumps. The designers of
|
||||
the a.out format chose to not use the data within the section
|
||||
for storing part of the offset; all the offset is kept within
|
||||
the reloc. Any thing in the data should be ignored.
|
||||
the reloc. Anything in the data should be ignored.
|
||||
|
||||
| save %sp,-112,%sp
|
||||
| sethi %hi(_foo+0x12345678),%g2
|
||||
|
@ -214,7 +214,7 @@ DESCRIPTION
|
|||
| ret
|
||||
| restore
|
||||
|
||||
Both relocs contains a pointer to foo, and the offsets would
|
||||
Both relocs contains a pointer to <<foo>>, and the offsets
|
||||
contain junk.
|
||||
|
||||
|
||||
|
@ -230,11 +230,11 @@ DESCRIPTION
|
|||
|00000010 81e80000 ; restore
|
||||
|
||||
|
||||
o howto
|
||||
o <<howto>>
|
||||
|
||||
The howto field can be imagined as a
|
||||
relocation instruction. It is a pointer to a struct which
|
||||
contains information on what to do with all the other
|
||||
The <<howto>> field can be imagined as a
|
||||
relocation instruction. It is a pointer to a structure which
|
||||
contains information on what to do with all of the other
|
||||
information in the reloc record and data section. A back end
|
||||
would normally have a relocation instruction set and turn
|
||||
relocations into pointers to the correct structure on input -
|
||||
|
@ -276,18 +276,18 @@ SUBSUBSECTION
|
|||
<<reloc_howto_type>>
|
||||
|
||||
The <<reloc_howto_type>> is a structure which contains all the
|
||||
information that BFD needs to know to tie up a back end's data.
|
||||
information that libbfd needs to know to tie up a back end's data.
|
||||
|
||||
CODE_FRAGMENT
|
||||
.struct symbol_cache_entry; {* Forward declaration *}
|
||||
.
|
||||
.typedef CONST struct reloc_howto_struct
|
||||
.typedef struct reloc_howto_struct
|
||||
.{
|
||||
. {* The type field has mainly a documetary use - the back end can
|
||||
. to what it wants with it, though the normally the back end's
|
||||
. external idea of what a reloc number would be would be stored
|
||||
. in this field. For example, the a PC relative word relocation
|
||||
. in a coff environment would have the type 023 - because that's
|
||||
. do what it wants with it, though normally the back end's
|
||||
. external idea of what a reloc number is stored
|
||||
. in this field. For example, a PC relative word relocation
|
||||
. in a coff environment has the type 023 - because that's
|
||||
. what the outside world calls a R_PCRWORD reloc. *}
|
||||
. unsigned int type;
|
||||
.
|
||||
|
@ -345,7 +345,7 @@ CODE_FRAGMENT
|
|||
. relocations rather than the data - this flag signals this.*}
|
||||
. boolean partial_inplace;
|
||||
.
|
||||
. {* The src_mask is used to select what parts of the read in data
|
||||
. {* The src_mask selects which parts of the read in data
|
||||
. are to be used in the relocation sum. E.g., if this was an 8 bit
|
||||
. bit of data which we read and relocated, this would be
|
||||
. 0x000000ff. When we have relocs which have an addend, such as
|
||||
|
@ -354,7 +354,7 @@ CODE_FRAGMENT
|
|||
. the mask would be 0x00000000. *}
|
||||
. bfd_vma src_mask;
|
||||
.
|
||||
. {* The dst_mask is what parts of the instruction are replaced
|
||||
. {* The dst_mask selects which parts of the instruction are replaced
|
||||
. into the instruction. In most cases src_mask == dst_mask,
|
||||
. except in the above special case, where dst_mask would be
|
||||
. 0x000000ff, and src_mask would be 0x00000000. *}
|
||||
|
@ -365,7 +365,7 @@ CODE_FRAGMENT
|
|||
. slot of the instruction, so that a PC relative relocation can
|
||||
. be made just by adding in an ordinary offset (e.g., sun3 a.out).
|
||||
. Some formats leave the displacement part of an instruction
|
||||
. empty (e.g., m88k bcs), this flag signals the fact.*}
|
||||
. empty (e.g., m88k bcs); this flag signals the fact.*}
|
||||
. boolean pcrel_offset;
|
||||
.
|
||||
.} reloc_howto_type;
|
||||
|
@ -374,7 +374,7 @@ CODE_FRAGMENT
|
|||
|
||||
/*
|
||||
FUNCTION
|
||||
the HOWTO macro
|
||||
The HOWTO Macro
|
||||
|
||||
DESCRIPTION
|
||||
The HOWTO define is horrible and will go away.
|
||||
|
@ -385,7 +385,7 @@ DESCRIPTION
|
|||
|
||||
DESCRIPTION
|
||||
And will be replaced with the totally magic way. But for the
|
||||
moment, we are compatible, so do it this way..
|
||||
moment, we are compatible, so do it this way.
|
||||
|
||||
|
||||
.#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
|
||||
|
@ -409,11 +409,11 @@ DESCRIPTION
|
|||
|
||||
/*
|
||||
TYPEDEF
|
||||
reloc_chain
|
||||
arelent_chain
|
||||
|
||||
DESCRIPTION
|
||||
|
||||
How relocs are tied together
|
||||
How relocs are tied together in an <<asection>>:
|
||||
|
||||
.typedef unsigned char bfd_byte;
|
||||
.
|
||||
|
@ -433,18 +433,18 @@ FUNCTION
|
|||
SYNOPSIS
|
||||
bfd_reloc_status_type
|
||||
bfd_perform_relocation
|
||||
(bfd * abfd,
|
||||
(bfd *abfd,
|
||||
arelent *reloc_entry,
|
||||
PTR data,
|
||||
asection *input_section,
|
||||
bfd *output_bfd);
|
||||
|
||||
DESCRIPTION
|
||||
If an output_bfd is supplied to this function the generated
|
||||
image will be relocatable, the relocations are copied to the
|
||||
If @var{output_bfd} is supplied to this function, the generated
|
||||
image will be relocatable; the relocations are copied to the
|
||||
output file after they have been changed to reflect the new
|
||||
state of the world. There are two ways of reflecting the
|
||||
results of partial linkage in an output file; by modifying the
|
||||
results of partial linkage in an output file: by modifying the
|
||||
output data in place, and by modifying the relocation record.
|
||||
Some native formats (e.g., basic a.out and basic coff) have no
|
||||
way of specifying an addend in the relocation type, so the
|
||||
|
@ -532,16 +532,38 @@ DEFUN(bfd_perform_relocation,(abfd,
|
|||
/* Add in supplied addend. */
|
||||
relocation += reloc_entry->addend;
|
||||
|
||||
/* Here the variable relocation holds the final address of the
|
||||
symbol we are relocating against, plus any addend. */
|
||||
|
||||
if (howto->pc_relative == true)
|
||||
{
|
||||
/* Anything which started out as pc relative should end up that
|
||||
way too.
|
||||
/* This is a PC relative relocation. We want to set RELOCATION
|
||||
to the distance between the address of the symbol and the
|
||||
location. RELOCATION is already the address of the symbol.
|
||||
|
||||
There are two ways we can see a pcrel instruction. Sometimes
|
||||
the pcrel displacement has been partially calculated, it
|
||||
includes the distance from the start of the section to the
|
||||
instruction in it (e.g., sun3), and sometimes the field is
|
||||
totally blank - e.g., m88kbcs. */
|
||||
We start by subtracting the address of the section containing
|
||||
the location.
|
||||
|
||||
If pcrel_offset is set, we must further subtract the position
|
||||
of the location within the section. Some targets arrange for
|
||||
the addend to be the negative of the position of the location
|
||||
within the section; for example, i386-aout does this. For
|
||||
i386-aout, pcrel_offset is false. Some other targets do not
|
||||
include the position of the location; for example, m88kbcs,
|
||||
or ELF. For those targets, pcrel_offset is true.
|
||||
|
||||
If we are producing relocateable output, then we must ensure
|
||||
that this reloc will be correctly computed when the final
|
||||
relocation is done. If pcrel_offset is false we want to wind
|
||||
up with the negative of the location within the section,
|
||||
which means we must adjust the existing addend by the change
|
||||
in the location within the section. If pcrel_offset is true
|
||||
we do not want to adjust the existing addend at all.
|
||||
|
||||
FIXME: This seems logical to me, but for the case of
|
||||
producing relocateable output it is not what the code
|
||||
actually does. I don't want to change it, because it seems
|
||||
far too likely that something will break. */
|
||||
|
||||
relocation -=
|
||||
input_section->output_section->vma + input_section->output_offset;
|
||||
|
@ -574,7 +596,78 @@ DEFUN(bfd_perform_relocation,(abfd,
|
|||
/* WTF?? */
|
||||
if (abfd->xvec->flavour == bfd_target_coff_flavour)
|
||||
{
|
||||
#if 1
|
||||
/* For m68k-coff, the addend was being subtracted twice during
|
||||
relocation with -r. Removing the line below this comment
|
||||
fixes that problem; see PR 2953.
|
||||
|
||||
However, Ian wrote the following, regarding removing the line below,
|
||||
which explains why it is still enabled: --djm
|
||||
|
||||
If you put a patch like that into BFD you need to check all the COFF
|
||||
linkers. I am fairly certain that patch will break coff-i386 (e.g.,
|
||||
SCO); see coff_i386_reloc in coff-i386.c where I worked around the
|
||||
problem in a different way. There may very well be a reason that the
|
||||
code works as it does.
|
||||
|
||||
Hmmm. The first obvious point is that bfd_perform_relocation should
|
||||
not have any tests that depend upon the flavour. It's seem like
|
||||
entirely the wrong place for such a thing. The second obvious point
|
||||
is that the current code ignores the reloc addend when producing
|
||||
relocateable output for COFF. That's peculiar. In fact, I really
|
||||
have no idea what the point of the line you want to remove is.
|
||||
|
||||
A typical COFF reloc subtracts the old value of the symbol and adds in
|
||||
the new value to the location in the object file (if it's a pc
|
||||
relative reloc it adds the difference between the symbol value and the
|
||||
location). When relocating we need to preserve that property.
|
||||
|
||||
BFD handles this by setting the addend to the negative of the old
|
||||
value of the symbol. Unfortunately it handles common symbols in a
|
||||
non-standard way (it doesn't subtract the old value) but that's a
|
||||
different story (we can't change it without losing backward
|
||||
compatibility with old object files) (coff-i386 does subtract the old
|
||||
value, to be compatible with existing coff-i386 targets, like SCO).
|
||||
|
||||
So everything works fine when not producing relocateable output. When
|
||||
we are producing relocateable output, logically we should do exactly
|
||||
what we do when not producing relocateable output. Therefore, your
|
||||
patch is correct. In fact, it should probably always just set
|
||||
reloc_entry->addend to 0 for all cases, since it is, in fact, going to
|
||||
add the value into the object file. This won't hurt the COFF code,
|
||||
which doesn't use the addend; I'm not sure what it will do to other
|
||||
formats (the thing to check for would be whether any formats both use
|
||||
the addend and set partial_inplace).
|
||||
|
||||
When I wanted to make coff-i386 produce relocateable output, I ran
|
||||
into the problem that you are running into: I wanted to remove that
|
||||
line. Rather than risk it, I made the coff-i386 relocs use a special
|
||||
function; it's coff_i386_reloc in coff-i386.c. The function
|
||||
specifically adds the addend field into the object file, knowing that
|
||||
bfd_perform_relocation is not going to. If you remove that line, then
|
||||
coff-i386.c will wind up adding the addend field in twice. It's
|
||||
trivial to fix; it just needs to be done.
|
||||
|
||||
The problem with removing the line is just that it may break some
|
||||
working code. With BFD it's hard to be sure of anything. The right
|
||||
way to deal with this is simply to build and test at least all the
|
||||
supported COFF targets. It should be straightforward if time and disk
|
||||
space consuming. For each target:
|
||||
1) build the linker
|
||||
2) generate some executable, and link it using -r (I would
|
||||
probably use paranoia.o and link against newlib/libc.a, which
|
||||
for all the supported targets would be available in
|
||||
/usr/cygnus/progressive/H-host/target/lib/libc.a).
|
||||
3) make the change to reloc.c
|
||||
4) rebuild the linker
|
||||
5) repeat step 2
|
||||
6) if the resulting object files are the same, you have at least
|
||||
made it no worse
|
||||
7) if they are different you have to figure out which version is
|
||||
right
|
||||
*/
|
||||
relocation -= reloc_entry->addend;
|
||||
#endif
|
||||
reloc_entry->addend = 0;
|
||||
}
|
||||
else
|
||||
|
@ -674,11 +767,35 @@ DEFUN(bfd_perform_relocation,(abfd,
|
|||
the relocation to the reloc entry (probably because there isn't
|
||||
any room in the output format to describe addends to relocs)
|
||||
*/
|
||||
relocation >>= howto->rightshift;
|
||||
|
||||
/* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
|
||||
(OSF version 1.3, compiler version 3.11). It miscompiles the
|
||||
following program:
|
||||
|
||||
struct str
|
||||
{
|
||||
unsigned int i0;
|
||||
} s = { 0 };
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
unsigned long x;
|
||||
|
||||
x = 0x100000000;
|
||||
x <<= (unsigned long) s.i0;
|
||||
if (x == 0)
|
||||
printf ("failed\n");
|
||||
else
|
||||
printf ("succeeded (%lx)\n", x);
|
||||
}
|
||||
*/
|
||||
|
||||
relocation >>= (bfd_vma) howto->rightshift;
|
||||
|
||||
/* Shift everything up to where it's going to be used */
|
||||
|
||||
relocation <<= howto->bitpos;
|
||||
relocation <<= (bfd_vma) howto->bitpos;
|
||||
|
||||
/* Wait for the day when all have the mask in them */
|
||||
|
||||
|
@ -904,6 +1021,14 @@ CODE_FRAGMENT
|
|||
. {* 16 bit relocation relative to the global pointer. *}
|
||||
. BFD_RELOC_MIPS_GPREL,
|
||||
.
|
||||
. {* Relocation against a MIPS literal section. *}
|
||||
. BFD_RELOC_MIPS_LITERAL,
|
||||
.
|
||||
. {* MIPS ELF relocations. *}
|
||||
. BFD_RELOC_MIPS_GOT16,
|
||||
. BFD_RELOC_MIPS_CALL16,
|
||||
. BFD_RELOC_MIPS_GPREL32,
|
||||
.
|
||||
. {* These are, so far, specific to HPPA processors. I'm not sure that some
|
||||
. don't duplicate other reloc types, such as BFD_RELOC_32 and _32_PCREL.
|
||||
. Also, many more were in the list I got that don't fit in well in the
|
||||
|
@ -1018,7 +1143,7 @@ CODE_FRAGMENT
|
|||
|
||||
|
||||
/*
|
||||
SECTION
|
||||
FUNCTION
|
||||
bfd_reloc_type_lookup
|
||||
|
||||
SYNOPSIS
|
||||
|
@ -1026,8 +1151,8 @@ SYNOPSIS
|
|||
bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
|
||||
|
||||
DESCRIPTION
|
||||
This routine returns a pointer to a howto struct which when
|
||||
invoked, will perform the supplied relocation on data from the
|
||||
Return a pointer to a howto struct which, when
|
||||
invoked, will perform the relocation @var{code} on data from the
|
||||
architecture noted.
|
||||
|
||||
*/
|
||||
|
@ -1216,4 +1341,101 @@ DEFUN(bfd_generic_get_relocated_section_contents,(abfd,
|
|||
return data;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/** Symbols */
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_get_reloc_upper_bound
|
||||
|
||||
SYNOPSIS
|
||||
unsigned int bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
|
||||
|
||||
DESCRIPTION
|
||||
Return the number of bytes required to store the
|
||||
relocation information associated with section @var{sect}
|
||||
attached to bfd @var{abfd}.
|
||||
|
||||
*/
|
||||
|
||||
|
||||
unsigned int
|
||||
DEFUN(bfd_get_reloc_upper_bound,(abfd, asect),
|
||||
bfd *abfd AND
|
||||
sec_ptr asect)
|
||||
{
|
||||
if (abfd->format != bfd_object) {
|
||||
bfd_error = invalid_operation;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_canonicalize_reloc
|
||||
|
||||
SYNOPSIS
|
||||
unsigned int bfd_canonicalize_reloc
|
||||
(bfd *abfd,
|
||||
asection *sec,
|
||||
arelent **loc,
|
||||
asymbol **syms);
|
||||
|
||||
DESCRIPTION
|
||||
Call the back end associated with the open BFD
|
||||
@var{abfd} and translate the external form of the relocation
|
||||
information attached to @var{sec} into the internal canonical
|
||||
form. Place the table into memory at @var{loc}, which has
|
||||
been preallocated, usually by a call to
|
||||
<<bfd_get_reloc_upper_bound>>.
|
||||
|
||||
The @var{syms} table is also needed for horrible internal magic
|
||||
reasons.
|
||||
|
||||
|
||||
*/
|
||||
unsigned int
|
||||
DEFUN(bfd_canonicalize_reloc,(abfd, asect, location, symbols),
|
||||
bfd *abfd AND
|
||||
sec_ptr asect AND
|
||||
arelent **location AND
|
||||
asymbol **symbols)
|
||||
{
|
||||
if (abfd->format != bfd_object) {
|
||||
bfd_error = invalid_operation;
|
||||
return 0;
|
||||
}
|
||||
return BFD_SEND (abfd, _bfd_canonicalize_reloc,
|
||||
(abfd, asect, location, symbols));
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_set_reloc
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_set_reloc
|
||||
(bfd *abfd, sec_ptr *sec, arelent **rel, unsigned int count)
|
||||
|
||||
DESCRIPTION
|
||||
Set the relocation pointer and count within
|
||||
section @var{sec} to the values @var{rel} and @var{count}.
|
||||
The argument @var{abfd} is ignored.
|
||||
|
||||
*/
|
||||
/*ARGSUSED*/
|
||||
void
|
||||
bfd_set_reloc (ignore_abfd, asect, location, count)
|
||||
bfd *ignore_abfd;
|
||||
sec_ptr asect;
|
||||
arelent **location;
|
||||
unsigned int count;
|
||||
{
|
||||
asect->orelocation = location;
|
||||
asect->reloc_count = count;
|
||||
}
|
||||
|
|
259
bfd/section.c
259
bfd/section.c
|
@ -22,13 +22,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
SECTION
|
||||
Sections
|
||||
|
||||
Sections are supported in BFD in <<section.c>>.
|
||||
|
||||
The raw data contained within a BFD is maintained through the
|
||||
section abstraction. A single BFD may have any number of
|
||||
sections, and keeps hold of them by pointing to the first,
|
||||
sections. It keeps hold of them by pointing to the first;
|
||||
each one points to the next in the list.
|
||||
|
||||
Sections are supported in BFD in <<section.c>>.
|
||||
|
||||
@menu
|
||||
@* Section Input::
|
||||
@* Section Output::
|
||||
|
@ -45,22 +45,25 @@ SUBSECTION
|
|||
created and attached to the BFD.
|
||||
|
||||
Each section has a name which describes the section in the
|
||||
outside world - for example, <<a.out>> would contain at least
|
||||
outside world---for example, <<a.out>> would contain at least
|
||||
three sections, called <<.text>>, <<.data>> and <<.bss>>.
|
||||
|
||||
Sometimes a BFD will contain more than the 'natural' number of
|
||||
Names need not be unique; for example a COFF file may have several
|
||||
sections named <<.data>>.
|
||||
|
||||
Sometimes a BFD will contain more than the ``natural'' number of
|
||||
sections. A back end may attach other sections containing
|
||||
constructor data, or an application may add a section (using
|
||||
bfd_make_section) to the sections attached to an already open
|
||||
BFD. For example, the linker creates a supernumary section
|
||||
<<bfd_make_section>>) to the sections attached to an already open
|
||||
BFD. For example, the linker creates an extra section
|
||||
<<COMMON>> for each input file's BFD to hold information about
|
||||
common storage.
|
||||
|
||||
The raw data is not necessarily read in at the same time as
|
||||
The raw data is not necessarily read in when
|
||||
the section descriptor is created. Some targets may leave the
|
||||
data in place until a <<bfd_get_section_contents>> call is
|
||||
made. Other back ends may read in all the data at once - For
|
||||
example; an S-record file has to be read once to determine the
|
||||
made. Other back ends may read in all the data at once. For
|
||||
example, an S-record file has to be read once to determine the
|
||||
size of the data. An IEEE-695 file doesn't contain raw data in
|
||||
sections, but data and relocation expressions intermixed, so
|
||||
the data area has to be parsed to get out the data and
|
||||
|
@ -74,27 +77,28 @@ SUBSECTION
|
|||
|
||||
To write a new object style BFD, the various sections to be
|
||||
written have to be created. They are attached to the BFD in
|
||||
the same way as input sections, data is written to the
|
||||
the same way as input sections; data is written to the
|
||||
sections using <<bfd_set_section_contents>>.
|
||||
|
||||
Any program that creates or combines sections (e.g., the assembler
|
||||
and linker) must use the fields <<output_section>> and
|
||||
and linker) must use the <<asection>> fields <<output_section>> and
|
||||
<<output_offset>> to indicate the file sections to which each
|
||||
section must be written. (If the section is being created from
|
||||
scratch, <<output_section>> should probably point to the section
|
||||
itself, and <<output_offset>> should probably be zero.)
|
||||
itself and <<output_offset>> should probably be zero.)
|
||||
|
||||
The data to be written comes from input sections attached to
|
||||
The data to be written comes from input sections attached
|
||||
(via <<output_section>> pointers) to
|
||||
the output sections. The output section structure can be
|
||||
considered a filter for the input section, the output section
|
||||
considered a filter for the input section: the output section
|
||||
determines the vma of the output data and the name, but the
|
||||
input section determines the offset into the output section of
|
||||
the data to be written.
|
||||
|
||||
E.g., to create a section "O", starting at 0x100, 0x123 long,
|
||||
containing two subsections, "A" at offset 0x0 (ie at vma
|
||||
0x100) and "B" at offset 0x20 (ie at vma 0x120) the structures
|
||||
would look like:
|
||||
containing two subsections, "A" at offset 0x0 (i.e., at vma
|
||||
0x100) and "B" at offset 0x20 (i.e., at vma 0x120) the <<asection>>
|
||||
structures would look like:
|
||||
|
||||
| section name "A"
|
||||
| output_offset 0x00
|
||||
|
@ -108,23 +112,23 @@ SUBSECTION
|
|||
|
||||
|
||||
SUBSECTION
|
||||
Seglets
|
||||
Seclets
|
||||
|
||||
The data within a section is stored in a <<seglet>>. These
|
||||
are much like the fixups in <<gas>>. The seglet abstraction
|
||||
allows the a section to grow and shrink within itself.
|
||||
The data within a section is stored in a <<seclet>>. These
|
||||
are much like the fixups in <<gas>>. The seclet abstraction
|
||||
allows a section to grow and shrink within itself.
|
||||
|
||||
A seglet knows how big it is, and which is the next seglet and
|
||||
where the raw data for it is, and also points to a list of
|
||||
A seclet knows how big it is, and which is the next seclet and
|
||||
where the raw data for it is; it also points to a list of
|
||||
relocations which apply to it.
|
||||
|
||||
The seglet is used by the linker to perform relaxing on final
|
||||
code. The application creates code which is as big as
|
||||
The seclet is used by the linker to perform relaxing on final
|
||||
code. The compiler creates code which is as big as
|
||||
necessary to make it work without relaxing, and the user can
|
||||
select whether to relax. Sometimes relaxing takes a lot of
|
||||
time. The linker runs around the relocations to see if any
|
||||
are attached to data which can be shrunk, if so it does it on
|
||||
a seglet by seglet basis.
|
||||
a seclet by seclet basis.
|
||||
|
||||
*/
|
||||
|
||||
|
@ -141,18 +145,18 @@ typedef asection, section prototypes, Section Output, Sections
|
|||
SUBSECTION
|
||||
typedef asection
|
||||
|
||||
The shape of a section struct:
|
||||
Here is the section structure:
|
||||
|
||||
CODE_FRAGMENT
|
||||
.
|
||||
.typedef struct sec
|
||||
.{
|
||||
. {* The name of the section, the name isn't a copy, the pointer is
|
||||
. {* The name of the section; the name isn't a copy, the pointer is
|
||||
. the same as that passed to bfd_make_section. *}
|
||||
.
|
||||
. CONST char *name;
|
||||
.
|
||||
. {* Which section is it 0.nth *}
|
||||
. {* Which section is it; 0..nth. *}
|
||||
.
|
||||
. int index;
|
||||
.
|
||||
|
@ -160,7 +164,7 @@ CODE_FRAGMENT
|
|||
.
|
||||
. struct sec *next;
|
||||
.
|
||||
. {* The field flags contains attributes of the section. Some of
|
||||
. {* The field flags contains attributes of the section. Some
|
||||
. flags are read in from the object file, and some are
|
||||
. synthesized from other information. *}
|
||||
.
|
||||
|
@ -168,17 +172,17 @@ CODE_FRAGMENT
|
|||
.
|
||||
.#define SEC_NO_FLAGS 0x000
|
||||
.
|
||||
. {* Tells the OS to allocate space for this section when loaded.
|
||||
. This would clear for a section containing debug information
|
||||
. {* Tells the OS to allocate space for this section when loading.
|
||||
. This is clear for a section containing debug information
|
||||
. only. *}
|
||||
.#define SEC_ALLOC 0x001
|
||||
.
|
||||
. {* Tells the OS to load the section from the file when loading.
|
||||
. This would be clear for a .bss section *}
|
||||
. This is clear for a .bss section. *}
|
||||
.#define SEC_LOAD 0x002
|
||||
.
|
||||
. {* The section contains data still to be relocated, so there will
|
||||
. be some relocation information too. *}
|
||||
. {* The section contains data still to be relocated, so there is
|
||||
. some relocation information too. *}
|
||||
.#define SEC_RELOC 0x004
|
||||
.
|
||||
.#if 0 {* Obsolete ? *}
|
||||
|
@ -202,10 +206,10 @@ CODE_FRAGMENT
|
|||
. type is used by the linker to create lists of constructors and
|
||||
. destructors used by <<g++>>. When a back end sees a symbol
|
||||
. which should be used in a constructor list, it creates a new
|
||||
. section for the type of name (eg <<__CTOR_LIST__>>), attaches
|
||||
. the symbol to it and builds a relocation. To build the lists
|
||||
. of constructors, all the linker has to to is catenate all the
|
||||
. sections called <<__CTOR_LIST__>> and relocte the data
|
||||
. section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
|
||||
. the symbol to it, and builds a relocation. To build the lists
|
||||
. of constructors, all the linker has to do is catenate all the
|
||||
. sections called <<__CTOR_LIST__>> and relocate the data
|
||||
. contained within - exactly the operations it would peform on
|
||||
. standard data. *}
|
||||
.#define SEC_CONSTRUCTOR 0x100
|
||||
|
@ -217,13 +221,12 @@ CODE_FRAGMENT
|
|||
.#define SEC_CONSTRUCTOR_BSS 0x3100
|
||||
.
|
||||
. {* The section has contents - a data section could be
|
||||
. <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>, a debug section could be
|
||||
. <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
|
||||
. <<SEC_HAS_CONTENTS>> *}
|
||||
.#define SEC_HAS_CONTENTS 0x200
|
||||
.
|
||||
. {* An instruction to the linker not to output sections
|
||||
. containing this flag even if they have information which
|
||||
. would normally be written. *}
|
||||
. {* An instruction to the linker to not output the section
|
||||
. even if it has information which would normally be written. *}
|
||||
.#define SEC_NEVER_LOAD 0x400
|
||||
.
|
||||
. {* The section is a shared library section. The linker must leave
|
||||
|
@ -238,6 +241,12 @@ CODE_FRAGMENT
|
|||
. translate to bfd_com_section), but ECOFF has two. *}
|
||||
.#define SEC_IS_COMMON 0x8000
|
||||
.
|
||||
. {* The section contains only debugging information. For
|
||||
. example, this is set for ELF .debug and .stab sections.
|
||||
. strip tests this flag to see if a section can be
|
||||
. discarded. *}
|
||||
.#define SEC_DEBUGGING 0x10000
|
||||
.
|
||||
. {* End of section flags. *}
|
||||
.
|
||||
. {* The virtual memory address of the section - where it will be
|
||||
|
@ -251,18 +260,18 @@ CODE_FRAGMENT
|
|||
. boolean user_set_vma;
|
||||
.
|
||||
. {* The load address of the section - where it would be in a
|
||||
. rom image, really only used for writing section header
|
||||
. rom image; really only used for writing section header
|
||||
. information. *}
|
||||
.
|
||||
. bfd_vma lma;
|
||||
.
|
||||
. {* The size of the section in bytes, as it will be output.
|
||||
. contains a value even if the section has no contents (eg, the
|
||||
. contains a value even if the section has no contents (e.g., the
|
||||
. size of <<.bss>>). This will be filled in after relocation *}
|
||||
.
|
||||
. bfd_size_type _cooked_size;
|
||||
.
|
||||
. {* The size on disk of the section in bytes originally. Normally this
|
||||
. {* The original size on disk of the section, in bytes. Normally this
|
||||
. value is the same as the size, but if some relaxing has
|
||||
. been done, then this value will be bigger. *}
|
||||
.
|
||||
|
@ -270,7 +279,7 @@ CODE_FRAGMENT
|
|||
.
|
||||
. {* If this section is going to be output, then this value is the
|
||||
. offset into the output section of the first byte in the input
|
||||
. section. Eg, if this was going to start at the 100th byte in
|
||||
. section. E.g., if this was going to start at the 100th byte in
|
||||
. the output section, this value would be 100. *}
|
||||
.
|
||||
. bfd_vma output_offset;
|
||||
|
@ -279,8 +288,8 @@ CODE_FRAGMENT
|
|||
.
|
||||
. struct sec *output_section;
|
||||
.
|
||||
. {* The alignment requirement of the section, as an exponent - eg
|
||||
. 3 aligns to 2^3 (or 8) *}
|
||||
. {* The alignment requirement of the section, as an exponent of 2 -
|
||||
. e.g., 3 aligns to 2^3 (or 8). *}
|
||||
.
|
||||
. unsigned int alignment_power;
|
||||
.
|
||||
|
@ -332,7 +341,7 @@ CODE_FRAGMENT
|
|||
.
|
||||
. file_ptr moving_line_filepos;
|
||||
.
|
||||
. {* what the section number is in the target world *}
|
||||
. {* What the section number is in the target world *}
|
||||
.
|
||||
. int target_index;
|
||||
.
|
||||
|
@ -414,7 +423,7 @@ SUBSECTION
|
|||
section prototypes
|
||||
|
||||
These are the functions exported by the section handling part of
|
||||
<<libbfd>.
|
||||
<<libbfd>>.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
@ -425,10 +434,14 @@ SYNOPSIS
|
|||
asection *bfd_get_section_by_name(bfd *abfd, CONST char *name);
|
||||
|
||||
DESCRIPTION
|
||||
Runs through the provided @var{abfd} and returns the
|
||||
<<asection>> who's name matches that provided, otherwise NULL.
|
||||
Run through the provided @var{abfd} and return the one of the
|
||||
<<asection>>s whose name matches @var{name}, otherwise NULL.
|
||||
@xref{Sections}, for more information.
|
||||
|
||||
This should only be used in special cases; the normal way to process
|
||||
all sections of a given name is to use bfd_map_over_sections and
|
||||
strcmp on the name (or better yet, base it on the section flags
|
||||
or something else) for each section.
|
||||
*/
|
||||
|
||||
asection *
|
||||
|
@ -449,17 +462,17 @@ FUNCTION
|
|||
bfd_make_section_old_way
|
||||
|
||||
SYNOPSIS
|
||||
asection *bfd_make_section_old_way(bfd *, CONST char *name);
|
||||
asection *bfd_make_section_old_way(bfd *abfd, CONST char *name);
|
||||
|
||||
DESCRIPTION
|
||||
This function creates a new empty section called @var{name}
|
||||
and attaches it to the end of the chain of sections for the
|
||||
BFD supplied. An attempt to create a section with a name which
|
||||
Create a new empty section called @var{name}
|
||||
and attach it to the end of the chain of sections for the
|
||||
BFD @var{abfd}. An attempt to create a section with a name which
|
||||
is already in use, returns its pointer without changing the
|
||||
section chain.
|
||||
|
||||
It has the funny name since this is the way it used to be
|
||||
before is was rewritten...
|
||||
before it was rewritten....
|
||||
|
||||
Possible errors are:
|
||||
o invalid_operation -
|
||||
|
@ -483,62 +496,39 @@ DEFUN(bfd_make_section_old_way,(abfd, name),
|
|||
return sec;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_make_section
|
||||
bfd_make_section_anyway
|
||||
|
||||
SYNOPSIS
|
||||
asection * bfd_make_section(bfd *, CONST char *name);
|
||||
asection *bfd_make_section_anyway(bfd *abfd, CONST char *name);
|
||||
|
||||
DESCRIPTION
|
||||
This function creates a new empty section called @var{name}
|
||||
and attaches it to the end of the chain of sections for the
|
||||
BFD supplied. An attempt to create a section with a name which
|
||||
is already in use, returns NULL without changing the section
|
||||
chain.
|
||||
Create a new empty section called @var{name} and attach it to the end of
|
||||
the chain of sections for @var{abfd}. Create a new section even if there
|
||||
is already a section with that name.
|
||||
|
||||
Possible errors are:
|
||||
o invalid_operation - If output has already started for this BFD.
|
||||
o no_memory - If obstack alloc fails.
|
||||
Returns NULL and sets bfd_error on error; possible errors are:
|
||||
o invalid_operation - If output has already started for @var{abfd}.
|
||||
o no_memory - If obstack alloc fails.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
sec_ptr
|
||||
DEFUN(bfd_make_section,(abfd, name),
|
||||
bfd *abfd AND
|
||||
CONST char * name)
|
||||
bfd_make_section_anyway (abfd, name)
|
||||
bfd *abfd;
|
||||
CONST char *name;
|
||||
{
|
||||
asection *newsect;
|
||||
asection ** prev = &abfd->sections;
|
||||
asection *newsect;
|
||||
asection **prev = &abfd->sections;
|
||||
asection * sect = abfd->sections;
|
||||
|
||||
if (abfd->output_has_begun) {
|
||||
bfd_error = invalid_operation;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (strcmp(name, BFD_ABS_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_abs_section;
|
||||
}
|
||||
if (strcmp(name, BFD_COM_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_com_section;
|
||||
}
|
||||
if (strcmp(name, BFD_UND_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_und_section;
|
||||
}
|
||||
if (abfd->output_has_begun)
|
||||
{
|
||||
bfd_error = invalid_operation;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (strcmp(name, BFD_IND_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_ind_section;
|
||||
}
|
||||
|
||||
while (sect) {
|
||||
if (!strcmp(sect->name, name)) return NULL;
|
||||
prev = §->next;
|
||||
sect = sect->next;
|
||||
}
|
||||
|
@ -568,10 +558,9 @@ DEFUN(bfd_make_section,(abfd, name),
|
|||
newsect->symbol->value = 0;
|
||||
newsect->symbol->section = newsect;
|
||||
newsect->symbol->flags = BSF_SECTION_SYM;
|
||||
|
||||
|
||||
newsect->symbol_ptr_ptr = &newsect->symbol;
|
||||
|
||||
|
||||
if (BFD_SEND (abfd, _new_section_hook, (abfd, newsect)) != true) {
|
||||
free (newsect);
|
||||
return NULL;
|
||||
|
@ -581,18 +570,66 @@ DEFUN(bfd_make_section,(abfd, name),
|
|||
return newsect;
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_make_section
|
||||
|
||||
SYNOPSIS
|
||||
asection *bfd_make_section(bfd *, CONST char *name);
|
||||
|
||||
DESCRIPTION
|
||||
Like <<bfd_make_section_anyway>>, but return NULL (without setting
|
||||
bfd_error) without changing the section chain if there is already a
|
||||
section named @var{name}. If there is an error, return NULL and set
|
||||
bfd_error.
|
||||
*/
|
||||
|
||||
sec_ptr
|
||||
DEFUN(bfd_make_section,(abfd, name),
|
||||
bfd *abfd AND
|
||||
CONST char * name)
|
||||
{
|
||||
asection * sect = abfd->sections;
|
||||
|
||||
if (strcmp(name, BFD_ABS_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_abs_section;
|
||||
}
|
||||
if (strcmp(name, BFD_COM_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_com_section;
|
||||
}
|
||||
if (strcmp(name, BFD_UND_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_und_section;
|
||||
}
|
||||
|
||||
if (strcmp(name, BFD_IND_SECTION_NAME) == 0)
|
||||
{
|
||||
return &bfd_ind_section;
|
||||
}
|
||||
|
||||
while (sect) {
|
||||
if (!strcmp(sect->name, name)) return NULL;
|
||||
sect = sect->next;
|
||||
}
|
||||
|
||||
/* The name is not already used; go ahead and make a new section. */
|
||||
return bfd_make_section_anyway (abfd, name);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_set_section_flags
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_set_section_flags(bfd *, asection *, flagword);
|
||||
boolean bfd_set_section_flags(bfd *abfd, asection *sec, flagword flags);
|
||||
|
||||
DESCRIPTION
|
||||
Attempts to set the attributes of the section named in the BFD
|
||||
supplied to the value. Returns true on success, false on
|
||||
error. Possible error returns are:
|
||||
Set the attributes of the section @var{sec} in the BFD
|
||||
@var{abfd} to the value @var{flags}. Returns <<true>> on success,
|
||||
<<false>> on error. Possible error returns are:
|
||||
|
||||
o invalid operation -
|
||||
The section cannot have one or more of the attributes
|
||||
|
@ -636,13 +673,13 @@ SYNOPSIS
|
|||
PTR obj);
|
||||
|
||||
DESCRIPTION
|
||||
Calls the provided function @var{func} for each section
|
||||
Call the provided function @var{func} for each section
|
||||
attached to the BFD @var{abfd}, passing @var{obj} as an
|
||||
argument. The function will be called as if by
|
||||
|
||||
| func(abfd, the_section, obj);
|
||||
|
||||
This is the prefered method for iterating over sections, an
|
||||
This is the prefered method for iterating over sections; an
|
||||
alternative would be to use a loop:
|
||||
|
||||
| section *p;
|
||||
|
@ -675,10 +712,10 @@ FUNCTION
|
|||
bfd_set_section_size
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_set_section_size(bfd *, asection *, bfd_size_type val);
|
||||
boolean bfd_set_section_size(bfd *abfd, asection *sec, bfd_size_type val);
|
||||
|
||||
DESCRIPTION
|
||||
Sets @var{section} to the size @var{val}. If the operation is
|
||||
Set @var{sec} to the size @var{val}. If the operation is
|
||||
ok, then <<true>> is returned, else <<false>>.
|
||||
|
||||
Possible error returns:
|
||||
|
@ -812,7 +849,7 @@ SYNOPSIS
|
|||
file_ptr offset, bfd_size_type count);
|
||||
|
||||
DESCRIPTION
|
||||
This function reads data from @var{section} in BFD @var{abfd}
|
||||
Read data from @var{section} in BFD @var{abfd}
|
||||
into memory starting at @var{location}. The data is read at an
|
||||
offset of @var{offset} from the start of the input section,
|
||||
and is read for @var{count} bytes.
|
||||
|
|
288
bfd/syms.c
288
bfd/syms.c
|
@ -1,5 +1,5 @@
|
|||
/* Generic symbol-table support for the BFD library.
|
||||
Copyright (C) 1990-1991 Free Software Foundation, Inc.
|
||||
Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
|
||||
Written by Cygnus Support.
|
||||
|
||||
This file is part of BFD, the Binary File Descriptor library.
|
||||
|
@ -22,20 +22,20 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
SECTION
|
||||
Symbols
|
||||
|
||||
BFD trys to maintain as much symbol information as it can when
|
||||
BFD tries to maintain as much symbol information as it can when
|
||||
it moves information from file to file. BFD passes information
|
||||
to applications though the <<asymbol>> structure. When the
|
||||
application requests the symbol table, BFD reads the table in
|
||||
the native form and translates parts of it into the internal
|
||||
format. To maintain more than the infomation passed to
|
||||
applications some targets keep some information 'behind the
|
||||
sceans', in a structure only the particular back end knows
|
||||
format. To maintain more than the information passed to
|
||||
applications, some targets keep some information ``behind the
|
||||
scenes'' in a structure only the particular back end knows
|
||||
about. For example, the coff back end keeps the original
|
||||
symbol table structure as well as the canonical structure when
|
||||
a BFD is read in. On output, the coff back end can reconstruct
|
||||
the output symbol table so that no information is lost, even
|
||||
information unique to coff which BFD doesn't know or
|
||||
understand. If a coff symbol table was read, but was written
|
||||
understand. If a coff symbol table were read, but were written
|
||||
through an a.out back end, all the coff specific information
|
||||
would be lost. The symbol table of a BFD
|
||||
is not necessarily read in until a canonicalize request is
|
||||
|
@ -43,8 +43,8 @@ SECTION
|
|||
application with pointers to the canonical information. To
|
||||
output symbols, the application provides BFD with a table of
|
||||
pointers to pointers to <<asymbol>>s. This allows applications
|
||||
like the linker to output a symbol as read, since the 'behind
|
||||
the sceens' information will be still available.
|
||||
like the linker to output a symbol as it was read, since the ``behind
|
||||
the scenes'' information will be still available.
|
||||
@menu
|
||||
@* Reading Symbols::
|
||||
@* Writing Symbols::
|
||||
|
@ -52,13 +52,14 @@ SECTION
|
|||
@* symbol handling functions::
|
||||
@end menu
|
||||
|
||||
@node Reading Symbols, Writing Symbols, Symbols, Symbols
|
||||
INODE
|
||||
Reading Symbols, Writing Symbols, Symbols, Symbols
|
||||
SUBSECTION
|
||||
Reading Symbols
|
||||
|
||||
There are two stages to reading a symbol table from a BFD;
|
||||
There are two stages to reading a symbol table from a BFD:
|
||||
allocating storage, and the actual reading process. This is an
|
||||
excerpt from an appliction which reads the symbol table:
|
||||
excerpt from an application which reads the symbol table:
|
||||
|
||||
| unsigned int storage_needed;
|
||||
| asymbol **symbol_table;
|
||||
|
@ -80,10 +81,11 @@ SUBSECTION
|
|||
| }
|
||||
|
||||
All storage for the symbols themselves is in an obstack
|
||||
connected to the BFD, and is freed when the BFD is closed.
|
||||
connected to the BFD; it is freed when the BFD is closed.
|
||||
|
||||
|
||||
@node Writing Symbols, typedef asymbol, Reading Symbols, Symbols
|
||||
INODE
|
||||
Writing Symbols, typedef asymbol, Reading Symbols, Symbols
|
||||
SUBSECTION
|
||||
Writing Symbols
|
||||
|
||||
|
@ -92,9 +94,9 @@ SUBSECTION
|
|||
pointers to pointers to symbols to the BFD being written, and
|
||||
fills in the symbol count. The close and cleanup code reads
|
||||
through the table provided and performs all the necessary
|
||||
operations. The outputing code must always be provided with an
|
||||
'owned' symbol; one which has come from another BFD, or one
|
||||
which has been created using <<bfd_make_empty_symbol>>. An
|
||||
operations. The BFD output code must always be provided with an
|
||||
``owned'' symbol: one which has come from another BFD, or one
|
||||
which has been created using <<bfd_make_empty_symbol>>. Here is an
|
||||
example showing the creation of a symbol table with only one element:
|
||||
|
||||
| #include "bfd.h"
|
||||
|
@ -124,7 +126,7 @@ SUBSECTION
|
|||
| 00012345 A dummy_symbol
|
||||
|
||||
Many formats cannot represent arbitary symbol information; for
|
||||
instance the <<a.out>> object format does not allow an
|
||||
instance, the <<a.out>> object format does not allow an
|
||||
arbitary number of sections. A symbol pointing to a section
|
||||
which is not one of <<.text>>, <<.data>> or <<.bss>> cannot
|
||||
be described.
|
||||
|
@ -132,8 +134,11 @@ SUBSECTION
|
|||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
@node typedef asymbol, symbol handling functions, Writing Symbols, Symbols
|
||||
DOCDD
|
||||
INODE
|
||||
typedef asymbol, symbol handling functions, Writing Symbols, Symbols
|
||||
|
||||
*/
|
||||
/*
|
||||
|
@ -147,20 +152,28 @@ SUBSECTION
|
|||
/*
|
||||
CODE_FRAGMENT
|
||||
|
||||
.
|
||||
.typedef struct symbol_cache_entry
|
||||
.{
|
||||
. {* A pointer to the BFD which owns the symbol. This information
|
||||
. is necessary so that a back end can work out what additional
|
||||
. (invisible to the application writer) information is carried
|
||||
. with the symbol. *}
|
||||
. information (invisible to the application writer) is carried
|
||||
. with the symbol.
|
||||
.
|
||||
. struct _bfd *the_bfd;
|
||||
. This field is *almost* redundant, since you can use section->owner
|
||||
. instead, except that some symbols point to the global sections
|
||||
. bfd_{abs,com,und}_section. This could be fixed by making
|
||||
. these globals be per-bfd (or per-target-flavor). FIXME. *}
|
||||
.
|
||||
. {* The text of the symbol. The name is left alone, and not copied - the
|
||||
. struct _bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *}
|
||||
.
|
||||
. {* The text of the symbol. The name is left alone, and not copied; the
|
||||
. application may not alter it. *}
|
||||
. CONST char *name;
|
||||
.
|
||||
. {* The value of the symbol.*}
|
||||
. {* The value of the symbol. This really should be a union of a
|
||||
. numeric value with a pointer, since some flags indicate that
|
||||
. a pointer to another symbol is stored here. *}
|
||||
. symvalue value;
|
||||
.
|
||||
. {* Attributes of a symbol: *}
|
||||
|
@ -175,43 +188,37 @@ CODE_FRAGMENT
|
|||
. value is the offset into the section of the data. *}
|
||||
.#define BSF_GLOBAL 0x02
|
||||
.
|
||||
. {* Obsolete *}
|
||||
.#define BSF_IMPORT 0x04
|
||||
.
|
||||
. {* The symbol has global scope, and is exported. The value is
|
||||
. {* The symbol has global scope and is exported. The value is
|
||||
. the offset into the section of the data. *}
|
||||
.#define BSF_EXPORT 0x08
|
||||
.
|
||||
. {* The symbol is undefined. <<extern>> in <<C>>. The value has
|
||||
. no meaning. *}
|
||||
.#define BSF_UNDEFINED_OBS 0x10
|
||||
.
|
||||
. {* The symbol is common, initialized to zero; default in
|
||||
. <<C>>. The value is the size of the object in bytes. *}
|
||||
.#define BSF_FORT_COMM_OBS 0x20
|
||||
.#define BSF_EXPORT BSF_GLOBAL {* no real difference *}
|
||||
.
|
||||
. {* A normal C symbol would be one of:
|
||||
. <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or
|
||||
. <<BSF_EXPORT|BSD_GLOBAL>> *}
|
||||
. <<BSF_GLOBAL>> *}
|
||||
.
|
||||
. {* The symbol is a debugging record. The value has an arbitary
|
||||
. meaning. *}
|
||||
.#define BSF_DEBUGGING 0x40
|
||||
.#define BSF_DEBUGGING 0x08
|
||||
.
|
||||
. {* Used by the linker *}
|
||||
.#define BSF_KEEP 0x10000
|
||||
.#define BSF_KEEP_G 0x80000
|
||||
. {* The symbol denotes a function entry point. Used in ELF,
|
||||
. perhaps others someday. *}
|
||||
.#define BSF_FUNCTION 0x10
|
||||
.
|
||||
. {* Unused *}
|
||||
.#define BSF_WEAK 0x100000
|
||||
.#define BSF_CTOR 0x200000
|
||||
. {* Used by the linker. *}
|
||||
.#define BSF_KEEP 0x20
|
||||
.#define BSF_KEEP_G 0x40
|
||||
.
|
||||
. {* This symbol was created to point to a section *}
|
||||
.#define BSF_SECTION_SYM 0x400000
|
||||
. {* A weak global symbol, overridable without warnings by
|
||||
. a regular global symbol of the same name. *}
|
||||
.#define BSF_WEAK 0x80
|
||||
.
|
||||
. {* This symbol was created to point to a section, e.g. ELF's
|
||||
. STT_SECTION symbols. *}
|
||||
.#define BSF_SECTION_SYM 0x100
|
||||
.
|
||||
. {* The symbol used to be a common symbol, but now it is
|
||||
. allocated. *}
|
||||
.#define BSF_OLD_COMMON 0x800000
|
||||
.#define BSF_OLD_COMMON 0x200
|
||||
.
|
||||
. {* The default value for common data. *}
|
||||
.#define BFD_FORT_COMM_DEFAULT_VALUE 0
|
||||
|
@ -222,21 +229,25 @@ CODE_FRAGMENT
|
|||
. declared and not at the end of a section. This bit is set
|
||||
. by the target BFD part to convey this information. *}
|
||||
.
|
||||
.#define BSF_NOT_AT_END 0x40000
|
||||
.#define BSF_NOT_AT_END 0x400
|
||||
.
|
||||
. {* Signal that the symbol is the label of constructor section. *}
|
||||
.#define BSF_CONSTRUCTOR 0x1000000
|
||||
.#define BSF_CONSTRUCTOR 0x800
|
||||
.
|
||||
. {* Signal that the symbol is a warning symbol. If the symbol
|
||||
. is a warning symbol, then the value field (I know this is
|
||||
. tacky) will point to the asymbol which when referenced will
|
||||
. cause the warning. *}
|
||||
.#define BSF_WARNING 0x2000000
|
||||
.#define BSF_WARNING 0x1000
|
||||
.
|
||||
. {* Signal that the symbol is indirect. The value of the symbol
|
||||
. is a pointer to an undefined asymbol which contains the
|
||||
. name to use instead. *}
|
||||
.#define BSF_INDIRECT 0x4000000
|
||||
.#define BSF_INDIRECT 0x2000
|
||||
.
|
||||
. {* BSF_FILE marks symbols that contain a file name. This is used
|
||||
. for ELF STT_FILE symbols. *}
|
||||
.#define BSF_FILE 0x4000
|
||||
.
|
||||
. flagword flags;
|
||||
.
|
||||
|
@ -247,18 +258,21 @@ CODE_FRAGMENT
|
|||
.
|
||||
. {* Back end special data. This is being phased out in favour
|
||||
. of making this a union. *}
|
||||
. PTR udata;
|
||||
. PTR udata;
|
||||
.
|
||||
.} asymbol;
|
||||
*/
|
||||
|
||||
#include "bfd.h"
|
||||
#include "sysdep.h"
|
||||
|
||||
#include "libbfd.h"
|
||||
#include "aout/stab_gnu.h"
|
||||
|
||||
/*
|
||||
@node symbol handling functions, , typedef asymbol, Symbols
|
||||
DOCDD
|
||||
INODE
|
||||
symbol handling functions, , typedef asymbol, Symbols
|
||||
SUBSECTION
|
||||
Symbol Handling Functions
|
||||
*/
|
||||
|
@ -268,10 +282,10 @@ FUNCTION
|
|||
get_symtab_upper_bound
|
||||
|
||||
DESCRIPTION
|
||||
Returns the number of bytes required in a vector of pointers
|
||||
to <<asymbols>> for all the symbols in the supplied BFD,
|
||||
Return the number of bytes required to store a vector of pointers
|
||||
to <<asymbols>> for all the symbols in the BFD @var{abfd},
|
||||
including a terminal NULL pointer. If there are no symbols in
|
||||
the BFD, then 0 is returned.
|
||||
the BFD, then return 0.
|
||||
|
||||
.#define get_symtab_upper_bound(abfd) \
|
||||
. BFD_SEND (abfd, _get_symtab_upper_bound, (abfd))
|
||||
|
@ -283,10 +297,10 @@ FUNCTION
|
|||
bfd_canonicalize_symtab
|
||||
|
||||
DESCRIPTION
|
||||
Supplied a BFD and a pointer to an uninitialized vector of
|
||||
pointers. This reads in the symbols from the BFD, and fills in
|
||||
the table with pointers to the symbols, and a trailing NULL.
|
||||
The routine returns the actual number of symbol pointers not
|
||||
Read the symbols from the BFD @var{abfd}, and fills in
|
||||
the vector @var{location} with pointers to the symbols and
|
||||
a trailing NULL.
|
||||
Return the actual number of symbol pointers, not
|
||||
including the NULL.
|
||||
|
||||
|
||||
|
@ -301,12 +315,13 @@ DESCRIPTION
|
|||
FUNCTION
|
||||
bfd_set_symtab
|
||||
|
||||
DESCRIPTION
|
||||
Provided a table of pointers to symbols and a count, writes to
|
||||
the output BFD the symbols when closed.
|
||||
|
||||
SYNOPSIS
|
||||
boolean bfd_set_symtab (bfd *, asymbol **, unsigned int );
|
||||
boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count);
|
||||
|
||||
DESCRIPTION
|
||||
Arrange that when the output BFD @var{abfd} is closed,
|
||||
the table @var{location} of @var{count} pointers to symbols
|
||||
will be written.
|
||||
*/
|
||||
|
||||
boolean
|
||||
|
@ -329,11 +344,12 @@ bfd_set_symtab (abfd, location, symcount)
|
|||
FUNCTION
|
||||
bfd_print_symbol_vandf
|
||||
|
||||
DESCRIPTION
|
||||
Prints the value and flags of the symbol supplied to the stream file.
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_print_symbol_vandf(PTR file, asymbol *symbol);
|
||||
|
||||
DESCRIPTION
|
||||
Print the value and flags of the @var{symbol} supplied to the
|
||||
stream @var{file}.
|
||||
*/
|
||||
void
|
||||
DEFUN(bfd_print_symbol_vandf,(file, symbol),
|
||||
|
@ -349,11 +365,10 @@ asymbol *symbol)
|
|||
{
|
||||
fprintf_vma(file, symbol->value);
|
||||
}
|
||||
fprintf(file," %c%c%c%c%c%c%c%c",
|
||||
fprintf(file," %c%c%c%c%c%c%c",
|
||||
(type & BSF_LOCAL) ? 'l':' ',
|
||||
(type & BSF_GLOBAL) ? 'g' : ' ',
|
||||
(type & BSF_IMPORT) ? 'i' : ' ',
|
||||
(type & BSF_EXPORT) ? 'e' : ' ',
|
||||
(type & BSF_WEAK) ? 'w' : ' ',
|
||||
(type & BSF_CONSTRUCTOR) ? 'C' : ' ',
|
||||
(type & BSF_WARNING) ? 'W' : ' ',
|
||||
(type & BSF_INDIRECT) ? 'I' : ' ',
|
||||
|
@ -367,10 +382,10 @@ FUNCTION
|
|||
bfd_make_empty_symbol
|
||||
|
||||
DESCRIPTION
|
||||
This function creates a new <<asymbol>> structure for the BFD,
|
||||
and returns a pointer to it.
|
||||
Create a new <<asymbol>> structure for the BFD @var{abfd}
|
||||
and return a pointer to it.
|
||||
|
||||
This routine is necessary, since each back end has private
|
||||
This routine is necessary because each back end has private
|
||||
information surrounding the <<asymbol>>. Building your own
|
||||
<<asymbol>> and pointing to it will not create the private
|
||||
information, and will cause problems later on.
|
||||
|
@ -379,13 +394,68 @@ DESCRIPTION
|
|||
. BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
|
||||
*/
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_make_debug_symbol
|
||||
|
||||
DESCRIPTION
|
||||
Create a new <<asymbol>> structure for the BFD @var{abfd},
|
||||
to be used as a debugging symbol. Further details of its use have
|
||||
yet to be worked out.
|
||||
|
||||
.#define bfd_make_debug_symbol(abfd,ptr,size) \
|
||||
. BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
|
||||
*/
|
||||
|
||||
struct section_to_type
|
||||
{
|
||||
CONST char *section;
|
||||
char type;
|
||||
};
|
||||
|
||||
/* Map section names to POSIX/BSD single-character symbol types.
|
||||
This table is probably incomplete. It is sorted for convenience of
|
||||
adding entries. Since it is so short, a linear search is used. */
|
||||
static CONST struct section_to_type stt[] = {
|
||||
{"*DEBUG*", 'N'},
|
||||
{".bss", 'b'},
|
||||
{".data", 'd'},
|
||||
{".sbss", 's'}, /* Small BSS (uninitialized data) */
|
||||
{".scommon", 'c'}, /* Small common */
|
||||
{".sdata", 'g'}, /* Small initialized data */
|
||||
{".text", 't'},
|
||||
{0, 0}
|
||||
};
|
||||
|
||||
/* Return the single-character symbol type corresponding to
|
||||
section S, or '?' for an unknown COFF section. */
|
||||
|
||||
static char
|
||||
coff_section_type (s)
|
||||
char *s;
|
||||
{
|
||||
CONST struct section_to_type *t;
|
||||
|
||||
for (t = &stt[0]; t->section; t++)
|
||||
if (!strcmp (s, t->section))
|
||||
return t->type;
|
||||
return '?';
|
||||
}
|
||||
|
||||
#ifndef islower
|
||||
#define islower(c) ((c) >= 'a' && (c) <= 'z')
|
||||
#endif
|
||||
#ifndef toupper
|
||||
#define toupper(c) (islower(c) ? ((c) & ~0x20) : (c))
|
||||
#endif
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_decode_symclass
|
||||
|
||||
DESCRIPTION
|
||||
Return a lower-case character corresponding to the symbol
|
||||
class of symbol.
|
||||
Return a character corresponding to the symbol
|
||||
class of @var{symbol}, or '?' for an unknown class.
|
||||
|
||||
SYNOPSIS
|
||||
int bfd_decode_symclass(asymbol *symbol);
|
||||
|
@ -394,23 +464,26 @@ int
|
|||
DEFUN(bfd_decode_symclass,(symbol),
|
||||
asymbol *symbol)
|
||||
{
|
||||
flagword flags = symbol->flags;
|
||||
|
||||
if (symbol->section == &bfd_com_section) return 'C';
|
||||
if (symbol->section == &bfd_und_section) return 'U';
|
||||
|
||||
if ( flags & (BSF_GLOBAL|BSF_LOCAL) ) {
|
||||
if ( symbol->section == &bfd_abs_section)
|
||||
return (flags & BSF_GLOBAL) ? 'A' : 'a';
|
||||
else if ( !strcmp(symbol->section->name, ".text") )
|
||||
return (flags & BSF_GLOBAL) ? 'T' : 't';
|
||||
else if ( !strcmp(symbol->section->name, ".data") )
|
||||
return (flags & BSF_GLOBAL) ? 'D' : 'd';
|
||||
else if ( !strcmp(symbol->section->name, ".bss") )
|
||||
return (flags & BSF_GLOBAL) ? 'B' : 'b';
|
||||
else
|
||||
return (flags & BSF_GLOBAL) ? 'O' : 'o';
|
||||
}
|
||||
char c;
|
||||
|
||||
if (bfd_is_com_section (symbol->section))
|
||||
return 'C';
|
||||
if (symbol->section == &bfd_und_section)
|
||||
return 'U';
|
||||
if (symbol->section == &bfd_ind_section)
|
||||
return 'I';
|
||||
if (!(symbol->flags & (BSF_GLOBAL|BSF_LOCAL)))
|
||||
return '?';
|
||||
|
||||
if (symbol->section == &bfd_abs_section)
|
||||
c = 'a';
|
||||
else if (symbol->section)
|
||||
c = coff_section_type (symbol->section->name);
|
||||
else
|
||||
return '?';
|
||||
if (symbol->flags & BSF_GLOBAL)
|
||||
c = toupper (c);
|
||||
return c;
|
||||
|
||||
/* We don't have to handle these cases just yet, but we will soon:
|
||||
N_SETV: 'v';
|
||||
|
@ -420,14 +493,37 @@ asymbol *symbol)
|
|||
N_SETB: 's';
|
||||
N_INDR: 'i';
|
||||
*/
|
||||
|
||||
return '?';
|
||||
}
|
||||
|
||||
/*
|
||||
FUNCTION
|
||||
bfd_symbol_info
|
||||
|
||||
DESCRIPTION
|
||||
Fill in the basic info about symbol that nm needs.
|
||||
Additional info may be added by the back-ends after
|
||||
calling this function.
|
||||
|
||||
SYNOPSIS
|
||||
void bfd_symbol_info(asymbol *symbol, symbol_info *ret);
|
||||
*/
|
||||
|
||||
void
|
||||
DEFUN(bfd_symbol_info,(symbol, ret),
|
||||
asymbol *symbol AND
|
||||
symbol_info *ret)
|
||||
{
|
||||
ret->type = bfd_decode_symclass (symbol);
|
||||
if (ret->type != 'U')
|
||||
ret->value = symbol->value+symbol->section->vma;
|
||||
else
|
||||
ret->value = 0;
|
||||
ret->name = symbol->name;
|
||||
}
|
||||
|
||||
void
|
||||
bfd_symbol_is_absolute()
|
||||
{
|
||||
|
||||
abort();
|
||||
}
|
||||
|
||||
|
|
116
bfd/targets.c
116
bfd/targets.c
|
@ -38,25 +38,25 @@ DESCRIPTION
|
|||
target are unknown. BFD uses various mechanisms to determine
|
||||
how to interpret the file. The operations performed are:
|
||||
|
||||
o First a BFD is created by calling the internal routine
|
||||
<<new_bfd>>, then <<bfd_find_target>> is called with the
|
||||
o Create a BFD by calling the internal routine
|
||||
<<new_bfd>>, then call <<bfd_find_target>> with the
|
||||
target string supplied to <<bfd_openr>> and the new BFD pointer.
|
||||
|
||||
o If a null target string was provided to <<bfd_find_target>>,
|
||||
it looks up the environment variable <<GNUTARGET>> and uses
|
||||
look up the environment variable <<GNUTARGET>> and use
|
||||
that as the target string.
|
||||
|
||||
o If the target string is still NULL, or the target string is
|
||||
<<default>>, then the first item in the target vector is used
|
||||
as the target type, and <<target_defaulted>> is set to
|
||||
<<default>>, then use the first item in the target vector
|
||||
as the target type, and set <<target_defaulted>> in the BFD to
|
||||
cause <<bfd_check_format>> to loop through all the targets.
|
||||
@xref{bfd_target}. @xref{Formats}.
|
||||
|
||||
o Otherwise, the elements in the target vector are inspected
|
||||
o Otherwise, inspect the elements in the target vector
|
||||
one by one, until a match on target name is found. When found,
|
||||
that is used.
|
||||
use it.
|
||||
|
||||
o Otherwise the error <<invalid_target>> is returned to
|
||||
o Otherwise return the error <<invalid_target>> to
|
||||
<<bfd_openr>>.
|
||||
|
||||
o <<bfd_openr>> attempts to open the file using
|
||||
|
@ -66,8 +66,8 @@ DESCRIPTION
|
|||
format may be determined. This is done by calling
|
||||
<<bfd_check_format>> on the BFD with a suggested format.
|
||||
If <<target_defaulted>> has been set, each possible target
|
||||
type is tried to see if it recognizes the specified format. The
|
||||
routine returns <<true>> when the application guesses right.
|
||||
type is tried to see if it recognizes the specified format.
|
||||
<<bfd_check_format>> returns <<true>> when the caller guesses right.
|
||||
@menu
|
||||
@* bfd_target::
|
||||
@end menu
|
||||
|
@ -84,16 +84,16 @@ SUBSECTION
|
|||
|
||||
DESCRIPTION
|
||||
This structure contains everything that BFD knows about a
|
||||
target. It includes things like its byte order, name, what
|
||||
routines to call to do various operations, etc.
|
||||
target. It includes things like its byte order, name, and which
|
||||
routines to call to do various operations.
|
||||
|
||||
Every BFD points to a target structure with its <<xvec>>
|
||||
member.
|
||||
|
||||
These macros are used to dispatch to functions through the
|
||||
bfd_target vector. They are used in a number of macros further
|
||||
The macros below are used to dispatch to functions through the
|
||||
<<bfd_target>> vector. They are used in a number of macros further
|
||||
down in @file{bfd.h}, and are also used when calling various
|
||||
routines by hand inside the BFD implementation. The "arglist"
|
||||
routines by hand inside the BFD implementation. The @var{arglist}
|
||||
argument must be parenthesized; it contains all the arguments
|
||||
to the called function.
|
||||
|
||||
|
@ -103,12 +103,12 @@ DESCRIPTION
|
|||
.#define BFD_SEND(bfd, message, arglist) \
|
||||
. ((*((bfd)->xvec->message)) arglist)
|
||||
|
||||
For operations which index on the BFD format
|
||||
For operations which index on the BFD format:
|
||||
|
||||
.#define BFD_SEND_FMT(bfd, message, arglist) \
|
||||
. (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
|
||||
|
||||
This is the struct which defines the type of BFD this is. The
|
||||
This is the structure which defines the type of BFD this is. The
|
||||
<<xvec>> member of the struct <<bfd>> itself points here. Each
|
||||
module that implements access to a different target under BFD,
|
||||
defines one of these.
|
||||
|
@ -118,28 +118,30 @@ DESCRIPTION
|
|||
the entry points which call them. Too bad we can't have one
|
||||
macro to define them both!
|
||||
|
||||
.enum bfd_flavour {
|
||||
. bfd_target_unknown_flavour,
|
||||
. bfd_target_aout_flavour,
|
||||
. bfd_target_coff_flavour,
|
||||
. bfd_target_ecoff_flavour,
|
||||
. bfd_target_elf_flavour,
|
||||
. bfd_target_ieee_flavour,
|
||||
. bfd_target_nlm_flavour,
|
||||
. bfd_target_oasys_flavour,
|
||||
. bfd_target_tekhex_flavour,
|
||||
. bfd_target_srec_flavour,
|
||||
. bfd_target_som_flavour};
|
||||
|
||||
.typedef struct bfd_target
|
||||
.{
|
||||
|
||||
Identifies the kind of target, eg SunOS4, Ultrix, etc.
|
||||
Identifies the kind of target, e.g., SunOS4, Ultrix, etc.
|
||||
|
||||
. char *name;
|
||||
|
||||
The "flavour" of a back end is a general indication about the contents
|
||||
of a file.
|
||||
|
||||
. enum target_flavour {
|
||||
. bfd_target_unknown_flavour,
|
||||
. bfd_target_aout_flavour,
|
||||
. bfd_target_coff_flavour,
|
||||
. bfd_target_ecoff_flavour,
|
||||
. bfd_target_elf_flavour,
|
||||
. bfd_target_ieee_flavour,
|
||||
. bfd_target_nlm_flavour,
|
||||
. bfd_target_oasys_flavour,
|
||||
. bfd_target_tekhex_flavour,
|
||||
. bfd_target_srec_flavour,
|
||||
. bfd_target_som_flavour} flavour;
|
||||
. enum bfd_flavour flavour;
|
||||
|
||||
The order of bytes within the data area of a file.
|
||||
|
||||
|
@ -149,22 +151,22 @@ The order of bytes within the header parts of a file.
|
|||
|
||||
. boolean header_byteorder_big_p;
|
||||
|
||||
This is a mask of all the flags which an executable may have set -
|
||||
A mask of all the flags which an executable may have set -
|
||||
from the set <<NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>.
|
||||
|
||||
. flagword object_flags;
|
||||
|
||||
This is a mask of all the flags which a section may have set - from
|
||||
A mask of all the flags which a section may have set - from
|
||||
the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>.
|
||||
|
||||
. flagword section_flags;
|
||||
|
||||
The character normally found at the front of a symbol
|
||||
(if any), perhaps _.
|
||||
(if any), perhaps `_'.
|
||||
|
||||
. char symbol_leading_char;
|
||||
|
||||
The pad character for filenames within an archive header.
|
||||
The pad character for file names within an archive header.
|
||||
|
||||
. char ar_pad_char;
|
||||
|
||||
|
@ -176,9 +178,9 @@ The minimum alignment restriction for any section.
|
|||
|
||||
. unsigned int align_power_min;
|
||||
|
||||
Entries for byte swapping for data. These are different to the other
|
||||
entry points, since they don't take BFD as first arg. Certain other handlers
|
||||
could do the same.
|
||||
Entries for byte swapping for data. These are different from the other
|
||||
entry points, since they don't take a BFD asthe first argument.
|
||||
Certain other handlers could do the same.
|
||||
|
||||
. bfd_vma (*bfd_getx64) PARAMS ((bfd_byte *));
|
||||
. bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((bfd_byte *));
|
||||
|
@ -205,7 +207,7 @@ Byte swapping for the headers
|
|||
Format dependent routines: these are vectors of entry points
|
||||
within the target vector structure, one for each format to check.
|
||||
|
||||
Check the format of a file being read. Return bfd_target * or zero.
|
||||
Check the format of a file being read. Return a <<bfd_target *>> or zero.
|
||||
|
||||
. struct bfd_target * (*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
|
||||
|
||||
|
@ -213,22 +215,22 @@ Set the format of a file being written.
|
|||
|
||||
. boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *));
|
||||
|
||||
Write cached information into a file being written, at bfd_close.
|
||||
Write cached information into a file being written, at <<bfd_close>>.
|
||||
|
||||
. boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *));
|
||||
|
||||
The following functions are defined in <<JUMP_TABLE>>. The idea is
|
||||
that the back end writer of <<foo>> names all the routines
|
||||
<<foo_>>@var{entry_point}, <<JUMP_TABLE>> will built the entries
|
||||
<<foo_>>@var{entry_point}; <<JUMP_TABLE>> will build the entries
|
||||
in this structure in the right order.
|
||||
|
||||
Core file entry points
|
||||
Core file entry points.
|
||||
|
||||
. char * (*_core_file_failing_command) PARAMS ((bfd *));
|
||||
. int (*_core_file_failing_signal) PARAMS ((bfd *));
|
||||
. boolean (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *));
|
||||
|
||||
Archive entry points
|
||||
Archive entry points.
|
||||
|
||||
. boolean (*_bfd_slurp_armap) PARAMS ((bfd *));
|
||||
. boolean (*_bfd_slurp_extended_name_table) PARAMS ((bfd *));
|
||||
|
@ -248,7 +250,7 @@ Standard stuff.
|
|||
. file_ptr, bfd_size_type));
|
||||
. boolean (*_new_section_hook) PARAMS ((bfd *, sec_ptr));
|
||||
|
||||
Symbols and relocations
|
||||
Symbols and relocations.
|
||||
|
||||
. unsigned int (*_get_symtab_upper_bound) PARAMS ((bfd *));
|
||||
. unsigned int (*_bfd_canonicalize_symtab) PARAMS ((bfd *,
|
||||
|
@ -379,6 +381,8 @@ extern bfd_target nlm64_little_generic_vec;
|
|||
extern bfd_target oasys_vec;
|
||||
extern bfd_target rs6000coff_vec;
|
||||
extern bfd_target shcoff_vec;
|
||||
extern bfd_target sparclynx_aout_vec;
|
||||
extern bfd_target sparclynx_coff_vec;
|
||||
extern bfd_target sunos_big_vec;
|
||||
extern bfd_target tekhex_vec;
|
||||
extern bfd_target we32kcoff_vec;
|
||||
|
@ -503,6 +507,8 @@ bfd_target *target_vector[] = {
|
|||
#endif
|
||||
&rs6000coff_vec,
|
||||
&shcoff_vec,
|
||||
&sparclynx_aout_vec,
|
||||
&sparclynx_coff_vec,
|
||||
&sunos_big_vec,
|
||||
#if 0
|
||||
&tekhex_vec,
|
||||
|
@ -551,19 +557,19 @@ bfd_target *default_vector[] = {
|
|||
FUNCTION
|
||||
bfd_find_target
|
||||
|
||||
SYNOPSIS
|
||||
bfd_target *bfd_find_target(CONST char *target_name, bfd *abfd);
|
||||
|
||||
DESCRIPTION
|
||||
Returns a pointer to the transfer vector for the object target
|
||||
named target_name. If target_name is NULL, chooses the one in
|
||||
the environment variable GNUTARGET; if that is null or not
|
||||
defined thenthe first entry in the target list is chosen.
|
||||
Return a pointer to the transfer vector for the object target
|
||||
named @var{target_name}. If @var{target_name} is NULL, choose the
|
||||
one in the environment variable GNUTARGET; if that is null or not
|
||||
defined, then choose the first entry in the target list.
|
||||
Passing in the string "default" or setting the environment
|
||||
variable to "default" will cause the first entry in the target
|
||||
list to be returned, and "target_defaulted" will be set in the
|
||||
BFD. This causes <<bfd_check_format>> to loop over all the
|
||||
targets to find the one that matches the file being read.
|
||||
|
||||
SYNOPSIS
|
||||
bfd_target *bfd_find_target(CONST char *, bfd *);
|
||||
*/
|
||||
|
||||
bfd_target *
|
||||
|
@ -598,14 +604,14 @@ DEFUN(bfd_find_target,(target_name, abfd),
|
|||
FUNCTION
|
||||
bfd_target_list
|
||||
|
||||
DESCRIPTION
|
||||
This function returns a freshly malloced NULL-terminated
|
||||
vector of the names of all the valid BFD targets. Do not
|
||||
modify the names
|
||||
|
||||
SYNOPSIS
|
||||
CONST char **bfd_target_list(void);
|
||||
|
||||
DESCRIPTION
|
||||
Return a freshly malloced NULL-terminated
|
||||
vector of the names of all the valid BFD targets. Do not
|
||||
modify the names.
|
||||
|
||||
*/
|
||||
|
||||
CONST char **
|
||||
|
|
Loading…
Reference in New Issue