| Line 1... |
Line 1... |
/* Support for the generic parts of most COFF variants, for BFD.
|
/* Support for the generic parts of most COFF variants, for BFD.
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Written by Cygnus Support.
|
Written by Cygnus Support.
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
| Line 107... |
Line 107... |
manipulate the i960 relocs. This code is not in
|
manipulate the i960 relocs. This code is not in
|
@file{coffcode.h} because it would not be used by any other
|
@file{coffcode.h} because it would not be used by any other
|
target.
|
target.
|
|
|
SUBSUBSECTION
|
SUBSUBSECTION
|
|
Coff long section names
|
|
|
|
In the standard Coff object format, section names are limited to
|
|
the eight bytes available in the @code{s_name} field of the
|
|
@code{SCNHDR} section header structure. The format requires the
|
|
field to be NUL-padded, but not necessarily NUL-terminated, so
|
|
the longest section names permitted are a full eight characters.
|
|
|
|
The Microsoft PE variants of the Coff object file format add
|
|
an extension to support the use of long section names. This
|
|
extension is defined in section 4 of the Microsoft PE/COFF
|
|
specification (rev 8.1). If a section name is too long to fit
|
|
into the section header's @code{s_name} field, it is instead
|
|
placed into the string table, and the @code{s_name} field is
|
|
filled with a slash ("/") followed by the ASCII decimal
|
|
representation of the offset of the full name relative to the
|
|
string table base.
|
|
|
|
Note that this implies that the extension can only be used in object
|
|
files, as executables do not contain a string table. The standard
|
|
specifies that long section names from objects emitted into executable
|
|
images are to be truncated.
|
|
|
|
However, as a GNU extension, BFD can generate executable images
|
|
that contain a string table and long section names. This
|
|
would appear to be technically valid, as the standard only says
|
|
that Coff debugging information is deprecated, not forbidden,
|
|
and in practice it works, although some tools that parse PE files
|
|
expecting the MS standard format may become confused; @file{PEview} is
|
|
one known example.
|
|
|
|
The functionality is supported in BFD by code implemented under
|
|
the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
|
|
defined, the format does not support long section names in any way.
|
|
If defined, it is used to initialise a flag,
|
|
@code{_bfd_coff_long_section_names}, and a hook function pointer,
|
|
@code{_bfd_coff_set_long_section_names}, in the Coff backend data
|
|
structure. The flag controls the generation of long section names
|
|
in output BFDs at runtime; if it is false, as it will be by default
|
|
when generating an executable image, long section names are truncated;
|
|
if true, the long section names extension is employed. The hook
|
|
points to a function that allows the value of the flag to be altered
|
|
at runtime, on formats that support long section names at all; on
|
|
other formats it points to a stub that returns an error indication.
|
|
|
|
With input BFDs, the flag is set according to whether any long section
|
|
names are detected while reading the section headers. For a completely
|
|
new BFD, the flag is set to the default for the target format. This
|
|
information can be used by a client of the BFD library when deciding
|
|
what output format to generate, and means that a BFD that is opened
|
|
for read and subsequently converted to a writeable BFD and modified
|
|
in-place will retain whatever format it had on input.
|
|
|
|
If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
|
|
defined to the value "1", then long section names are enabled by
|
|
default; if it is defined to the value zero, they are disabled by
|
|
default (but still accepted in input BFDs). The header @file{coffcode.h}
|
|
defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
|
|
used in the backends to initialise the backend data structure fields
|
|
appropriately; see the comments for further detail.
|
|
|
|
SUBSUBSECTION
|
Bit twiddling
|
Bit twiddling
|
|
|
Each flavour of coff supported in BFD has its own header file
|
Each flavour of coff supported in BFD has its own header file
|
describing the external layout of the structures. There is also
|
describing the external layout of the structures. There is also
|
an internal description of the coff layout, in
|
an internal description of the coff layout, in
|
| Line 307... |
Line 369... |
|
|
#define STRING_SIZE_SIZE 4
|
#define STRING_SIZE_SIZE 4
|
|
|
#define DOT_DEBUG ".debug"
|
#define DOT_DEBUG ".debug"
|
#define GNU_LINKONCE_WI ".gnu.linkonce.wi."
|
#define GNU_LINKONCE_WI ".gnu.linkonce.wi."
|
|
#define DOT_RELOC ".reloc"
|
|
|
|
#if defined (COFF_LONG_SECTION_NAMES)
|
|
/* Needed to expand the inputs to BLANKOR1TOODD. */
|
|
#define COFFLONGSECTIONCATHELPER(x,y) x ## y
|
|
/* If the input macro Y is blank or '1', return an odd number; if it is
|
|
'0', return an even number. Result undefined in all other cases. */
|
|
#define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
|
|
/* Defined to numerical 0 or 1 according to whether generation of long
|
|
section names is disabled or enabled by default. */
|
|
#define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
|
|
/* Where long section names are supported, we allow them to be enabled
|
|
and disabled at runtime, so select an appropriate hook function for
|
|
_bfd_coff_set_long_section_names. */
|
|
#define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
|
|
#else /* !defined (COFF_LONG_SECTION_NAMES) */
|
|
/* If long section names are not supported, this stub disallows any
|
|
attempt to enable them at run-time. */
|
|
#define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
|
|
#endif /* defined (COFF_LONG_SECTION_NAMES) */
|
|
|
|
/* Define a macro that can be used to initialise both the fields relating
|
|
to long section names in the backend data struct simultaneously. */
|
|
#if COFF_ENABLE_LONG_SECTION_NAMES
|
|
#define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
|
|
#else /* !COFF_ENABLE_LONG_SECTION_NAMES */
|
|
#define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
|
|
#endif /* COFF_ENABLE_LONG_SECTION_NAMES */
|
|
|
|
#if defined (COFF_LONG_SECTION_NAMES)
|
|
static bfd_boolean bfd_coff_set_long_section_names_allowed
|
|
(bfd *, int);
|
|
#else /* !defined (COFF_LONG_SECTION_NAMES) */
|
|
static bfd_boolean bfd_coff_set_long_section_names_disallowed
|
|
(bfd *, int);
|
|
#endif /* defined (COFF_LONG_SECTION_NAMES) */
|
static long sec_to_styp_flags
|
static long sec_to_styp_flags
|
(const char *, flagword);
|
(const char *, flagword);
|
static bfd_boolean styp_to_sec_flags
|
static bfd_boolean styp_to_sec_flags
|
(bfd *, void *, const char *, asection *, flagword *);
|
(bfd *, void *, const char *, asection *, flagword *);
|
static bfd_boolean coff_bad_format_hook
|
static bfd_boolean coff_bad_format_hook
|
| Line 370... |
Line 467... |
(bfd *, void * );
|
(bfd *, void * );
|
#endif
|
#endif
|
|
|
/* void warning(); */
|
/* void warning(); */
|
|
|
|
#if defined (COFF_LONG_SECTION_NAMES)
|
|
static bfd_boolean
|
|
bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
|
|
{
|
|
coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
|
|
return TRUE;
|
|
}
|
|
#else /* !defined (COFF_LONG_SECTION_NAMES) */
|
|
static bfd_boolean
|
|
bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
|
|
{
|
|
(void) abfd;
|
|
(void) enable;
|
|
return FALSE;
|
|
}
|
|
#endif /* defined (COFF_LONG_SECTION_NAMES) */
|
|
|
/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
|
/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
|
the incoming SEC_* flags. The inverse of this function is
|
the incoming SEC_* flags. The inverse of this function is
|
styp_to_sec_flags(). NOTE: If you add to/change this routine, you
|
styp_to_sec_flags(). NOTE: If you add to/change this routine, you
|
should probably mirror the changes in styp_to_sec_flags(). */
|
should probably mirror the changes in styp_to_sec_flags(). */
|
|
|
| Line 530... |
Line 644... |
but there are more IMAGE_SCN_* flags. */
|
but there are more IMAGE_SCN_* flags. */
|
|
|
/* FIXME: There is no gas syntax to specify the debug section flag. */
|
/* FIXME: There is no gas syntax to specify the debug section flag. */
|
if (CONST_STRNEQ (sec_name, DOT_DEBUG)
|
if (CONST_STRNEQ (sec_name, DOT_DEBUG)
|
|| CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
|
|| CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
|
sec_flags = SEC_DEBUGGING;
|
sec_flags = SEC_DEBUGGING | SEC_READONLY;
|
|
|
/* skip LOAD */
|
/* skip LOAD */
|
/* READONLY later */
|
/* READONLY later */
|
/* skip RELOC */
|
/* skip RELOC */
|
if ((sec_flags & SEC_CODE) != 0)
|
if ((sec_flags & SEC_CODE) != 0)
|
| Line 559... |
Line 673... |
if (sec_flags & SEC_LINK_ONCE)
|
if (sec_flags & SEC_LINK_ONCE)
|
styp_flags |= IMAGE_SCN_LNK_COMDAT;
|
styp_flags |= IMAGE_SCN_LNK_COMDAT;
|
/* skip LINK_DUPLICATES */
|
/* skip LINK_DUPLICATES */
|
/* skip LINKER_CREATED */
|
/* skip LINKER_CREATED */
|
|
|
if (sec_flags & (SEC_ALLOC | SEC_LOAD))
|
if ((sec_flags & SEC_COFF_NOREAD) == 0)
|
{
|
styp_flags |= IMAGE_SCN_MEM_READ; /* Invert NOREAD for read. */
|
/* For now, the read/write bits are mapped onto SEC_READONLY, even
|
|
though the semantics don't quite match. The bits from the input
|
|
are retained in pei_section_data(abfd, section)->pe_flags. */
|
|
styp_flags |= IMAGE_SCN_MEM_READ; /* Always readable. */
|
|
if ((sec_flags & SEC_READONLY) == 0)
|
if ((sec_flags & SEC_READONLY) == 0)
|
styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
|
styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
|
if (sec_flags & SEC_CODE)
|
if (sec_flags & SEC_CODE)
|
styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
|
styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
|
if (sec_flags & SEC_COFF_SHARED)
|
if (sec_flags & SEC_COFF_SHARED)
|
styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
|
styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
|
}
|
|
|
|
return styp_flags;
|
return styp_flags;
|
}
|
}
|
|
|
#endif /* COFF_WITH_PE */
|
#endif /* COFF_WITH_PE */
|
| Line 834... |
Line 943... |
|
|
Here, we think we've found the first one,
|
Here, we think we've found the first one,
|
but there's some checking we can do to be
|
but there's some checking we can do to be
|
sure. */
|
sure. */
|
|
|
if (! (isym.n_sclass == C_STAT
|
if (! ((isym.n_sclass == C_STAT
|
|
|| isym.n_sclass == C_EXT)
|
&& isym.n_type == T_NULL
|
&& isym.n_type == T_NULL
|
&& isym.n_value == 0))
|
&& isym.n_value == 0))
|
abort ();
|
abort ();
|
|
|
/* FIXME LATER: MSVC generates section names
|
/* FIXME LATER: MSVC generates section names
|
like .text for comdats. Gas generates
|
like .text for comdats. Gas generates
|
names like .text$foo__Fv (in the case of a
|
names like .text$foo__Fv (in the case of a
|
function). See comment above for more. */
|
function). See comment above for more. */
|
|
|
if (strcmp (name, symname) != 0)
|
if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
|
_bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
|
_bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
|
abfd, symname, name);
|
abfd, symname, name);
|
|
|
seen_state = 1;
|
seen_state = 1;
|
|
|
| Line 957... |
Line 1067... |
Intel puts the two adjacent, but Alpha (at
|
Intel puts the two adjacent, but Alpha (at
|
least) spreads them out. */
|
least) spreads them out. */
|
|
|
amt = sizeof (struct coff_comdat_info);
|
amt = sizeof (struct coff_comdat_info);
|
coff_section_data (abfd, section)->comdat
|
coff_section_data (abfd, section)->comdat
|
= bfd_alloc (abfd, amt);
|
= (struct coff_comdat_info *) bfd_alloc (abfd, amt);
|
if (coff_section_data (abfd, section)->comdat == NULL)
|
if (coff_section_data (abfd, section)->comdat == NULL)
|
abort ();
|
abort ();
|
|
|
coff_section_data (abfd, section)->comdat->symbol =
|
coff_section_data (abfd, section)->comdat->symbol =
|
(esym - esymstart) / bfd_coff_symesz (abfd);
|
(esym - esymstart) / bfd_coff_symesz (abfd);
|
|
|
amt = strlen (symname) + 1;
|
amt = strlen (symname) + 1;
|
newname = bfd_alloc (abfd, amt);
|
newname = (char *) bfd_alloc (abfd, amt);
|
if (newname == NULL)
|
if (newname == NULL)
|
abort ();
|
abort ();
|
|
|
strcpy (newname, symname);
|
strcpy (newname, symname);
|
coff_section_data (abfd, section)->comdat->name
|
coff_section_data (abfd, section)->comdat->name
|
| Line 1010... |
Line 1120... |
bfd_boolean result = TRUE;
|
bfd_boolean result = TRUE;
|
|
|
/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
|
/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
|
sec_flags = SEC_READONLY;
|
sec_flags = SEC_READONLY;
|
|
|
|
/* If section disallows read, then set the NOREAD flag. */
|
|
if ((styp_flags & IMAGE_SCN_MEM_READ) == 0)
|
|
sec_flags |= SEC_COFF_NOREAD;
|
|
|
/* Process each flag bit in styp_flags in turn. */
|
/* Process each flag bit in styp_flags in turn. */
|
while (styp_flags)
|
while (styp_flags)
|
{
|
{
|
long flag = styp_flags & - styp_flags;
|
long flag = styp_flags & - styp_flags;
|
char * unhandled = NULL;
|
char * unhandled = NULL;
|
| Line 1042... |
Line 1156... |
case STYP_NOLOAD:
|
case STYP_NOLOAD:
|
sec_flags |= SEC_NEVER_LOAD;
|
sec_flags |= SEC_NEVER_LOAD;
|
break;
|
break;
|
#endif
|
#endif
|
case IMAGE_SCN_MEM_READ:
|
case IMAGE_SCN_MEM_READ:
|
/* Ignored, assume it always to be true. */
|
sec_flags &= ~SEC_COFF_NOREAD;
|
break;
|
break;
|
case IMAGE_SCN_TYPE_NO_PAD:
|
case IMAGE_SCN_TYPE_NO_PAD:
|
/* Skip. */
|
/* Skip. */
|
break;
|
break;
|
case IMAGE_SCN_LNK_OTHER:
|
case IMAGE_SCN_LNK_OTHER:
|
| Line 1067... |
Line 1181... |
break;
|
break;
|
case IMAGE_SCN_MEM_WRITE:
|
case IMAGE_SCN_MEM_WRITE:
|
sec_flags &= ~ SEC_READONLY;
|
sec_flags &= ~ SEC_READONLY;
|
break;
|
break;
|
case IMAGE_SCN_MEM_DISCARDABLE:
|
case IMAGE_SCN_MEM_DISCARDABLE:
|
/* The MS PE spec sets the DISCARDABLE flag on .reloc sections
|
/* The MS PE spec says that debug sections are DISCARDABLE,
|
but we do not want them to be labelled as debug section, since
|
but the presence of a DISCARDABLE flag does not necessarily
|
then strip would remove them. */
|
mean that a given section contains debug information. Thus
|
if (! CONST_STRNEQ (name, ".reloc"))
|
we only set the SEC_DEBUGGING flag on sections that we
|
|
recognise as containing debug information. */
|
|
if (CONST_STRNEQ (name, DOT_DEBUG)
|
|
#ifdef _COMMENT
|
|
|| strcmp (name, _COMMENT) == 0
|
|
#endif
|
|
#ifdef COFF_LONG_SECTION_NAMES
|
|
|| CONST_STRNEQ (name, GNU_LINKONCE_WI)
|
|
#endif
|
|
|| CONST_STRNEQ (name, ".stab"))
|
sec_flags |= SEC_DEBUGGING;
|
sec_flags |= SEC_DEBUGGING;
|
break;
|
break;
|
case IMAGE_SCN_MEM_SHARED:
|
case IMAGE_SCN_MEM_SHARED:
|
sec_flags |= SEC_COFF_SHARED;
|
sec_flags |= SEC_COFF_SHARED;
|
break;
|
break;
|
| Line 1203... |
Line 1326... |
. unsigned int _bfd_auxesz;
|
. unsigned int _bfd_auxesz;
|
. unsigned int _bfd_relsz;
|
. unsigned int _bfd_relsz;
|
. unsigned int _bfd_linesz;
|
. unsigned int _bfd_linesz;
|
. unsigned int _bfd_filnmlen;
|
. unsigned int _bfd_filnmlen;
|
. bfd_boolean _bfd_coff_long_filenames;
|
. bfd_boolean _bfd_coff_long_filenames;
|
|
.
|
. bfd_boolean _bfd_coff_long_section_names;
|
. bfd_boolean _bfd_coff_long_section_names;
|
|
. bfd_boolean (*_bfd_coff_set_long_section_names)
|
|
. (bfd *, int);
|
|
.
|
. unsigned int _bfd_coff_default_section_alignment_power;
|
. unsigned int _bfd_coff_default_section_alignment_power;
|
. bfd_boolean _bfd_coff_force_symnames_in_strings;
|
. bfd_boolean _bfd_coff_force_symnames_in_strings;
|
. unsigned int _bfd_coff_debug_string_prefix_length;
|
. unsigned int _bfd_coff_debug_string_prefix_length;
|
.
|
.
|
. void (*_bfd_coff_swap_filehdr_in)
|
. void (*_bfd_coff_swap_filehdr_in)
|
| Line 1290... |
Line 1417... |
. (bfd *, struct coff_final_link_info *);
|
. (bfd *, struct coff_final_link_info *);
|
.
|
.
|
. bfd_boolean (*_bfd_coff_final_link_postscript)
|
. bfd_boolean (*_bfd_coff_final_link_postscript)
|
. (bfd *, struct coff_final_link_info *);
|
. (bfd *, struct coff_final_link_info *);
|
.
|
.
|
|
. bfd_boolean (*_bfd_coff_print_pdata)
|
|
. (bfd *, void *);
|
|
.
|
.} bfd_coff_backend_data;
|
.} bfd_coff_backend_data;
|
.
|
.
|
.#define coff_backend_info(abfd) \
|
.#define coff_backend_info(abfd) \
|
. ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
|
. ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
|
.
|
.
|
| Line 1337... |
Line 1467... |
.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
|
.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
|
.#define bfd_coff_long_filenames(abfd) \
|
.#define bfd_coff_long_filenames(abfd) \
|
. (coff_backend_info (abfd)->_bfd_coff_long_filenames)
|
. (coff_backend_info (abfd)->_bfd_coff_long_filenames)
|
.#define bfd_coff_long_section_names(abfd) \
|
.#define bfd_coff_long_section_names(abfd) \
|
. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
|
. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
|
|
.#define bfd_coff_set_long_section_names(abfd, enable) \
|
|
. ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
|
.#define bfd_coff_default_section_alignment_power(abfd) \
|
.#define bfd_coff_default_section_alignment_power(abfd) \
|
. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
|
. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
|
.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
|
.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
|
. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
|
. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
|
.
|
.
|
| Line 1422... |
Line 1554... |
.#define bfd_coff_link_output_has_begun(a,p) \
|
.#define bfd_coff_link_output_has_begun(a,p) \
|
. ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
|
. ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
|
.#define bfd_coff_final_link_postscript(a,p) \
|
.#define bfd_coff_final_link_postscript(a,p) \
|
. ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
|
. ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
|
.
|
.
|
|
.#define bfd_coff_have_print_pdata(a) \
|
|
. (coff_backend_info (a)->_bfd_coff_print_pdata)
|
|
.#define bfd_coff_print_pdata(a,p) \
|
|
. ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
|
|
.
|
|
.{* Macro: Returns true if the bfd is a PE executable as opposed to a
|
|
. PE object file. *}
|
|
.#define bfd_pei_p(abfd) \
|
|
. (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
|
*/
|
*/
|
|
|
/* See whether the magic number matches. */
|
/* See whether the magic number matches. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
| Line 1569... |
Line 1710... |
related info.
|
related info.
|
|
|
@@ The 10 is a guess at a plausible maximum number of aux entries
|
@@ The 10 is a guess at a plausible maximum number of aux entries
|
(but shouldn't be a constant). */
|
(but shouldn't be a constant). */
|
amt = sizeof (combined_entry_type) * 10;
|
amt = sizeof (combined_entry_type) * 10;
|
native = bfd_zalloc (abfd, amt);
|
native = (combined_entry_type *) bfd_zalloc (abfd, amt);
|
if (native == NULL)
|
if (native == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
/* We don't need to set up n_name, n_value, or n_scnum in the native
|
/* We don't need to set up n_name, n_value, or n_scnum in the native
|
symbol information, since they'll be overridden by the BFD symbol
|
symbol information, since they'll be overridden by the BFD symbol
|
| Line 1849... |
Line 1990... |
defines coff_mkobject_hook. */
|
defines coff_mkobject_hook. */
|
if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
|
if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
|
abfd->flags |= HAS_DEBUG;
|
abfd->flags |= HAS_DEBUG;
|
#endif
|
#endif
|
|
|
|
if ((internal_f->f_flags & F_GO32STUB) != 0)
|
|
coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
|
|
if (coff->go32stub != NULL)
|
|
memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE);
|
|
|
return coff;
|
return coff;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Determine the machine architecture and type. FIXME: This is target
|
/* Determine the machine architecture and type. FIXME: This is target
|
| Line 2286... |
Line 2432... |
|
|
#ifdef XCOFF64
|
#ifdef XCOFF64
|
#define FORCE_SYMNAMES_IN_STRINGS
|
#define FORCE_SYMNAMES_IN_STRINGS
|
#endif
|
#endif
|
|
|
/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
|
/* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
|
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
|
combined_entry_type *table_base,
|
combined_entry_type *table_base,
|
combined_entry_type *symbol,
|
combined_entry_type *symbol,
|
unsigned int indaux,
|
unsigned int indaux,
|
combined_entry_type *aux)
|
combined_entry_type *aux)
|
{
|
{
|
int class = symbol->u.syment.n_sclass;
|
int n_sclass = symbol->u.syment.n_sclass;
|
|
|
if ((class == C_EXT || class == C_HIDEXT)
|
if (CSECT_SYM_P (n_sclass)
|
&& indaux + 1 == symbol->u.syment.n_numaux)
|
&& indaux + 1 == symbol->u.syment.n_numaux)
|
{
|
{
|
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
|
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
|
{
|
{
|
aux->u.auxent.x_csect.x_scnlen.p =
|
aux->u.auxent.x_csect.x_scnlen.p =
|
| Line 2355... |
Line 2501... |
combined_entry_type *symbol ATTRIBUTE_UNUSED,
|
combined_entry_type *symbol ATTRIBUTE_UNUSED,
|
combined_entry_type *aux ATTRIBUTE_UNUSED,
|
combined_entry_type *aux ATTRIBUTE_UNUSED,
|
unsigned int indaux ATTRIBUTE_UNUSED)
|
unsigned int indaux ATTRIBUTE_UNUSED)
|
{
|
{
|
#ifdef RS6000COFF_C
|
#ifdef RS6000COFF_C
|
if ((symbol->u.syment.n_sclass == C_EXT
|
if (CSECT_SYM_P (symbol->u.syment.n_sclass)
|
|| symbol->u.syment.n_sclass == C_HIDEXT)
|
|
&& indaux + 1 == symbol->u.syment.n_numaux)
|
&& indaux + 1 == symbol->u.syment.n_numaux)
|
{
|
{
|
/* This is a csect entry. */
|
/* This is a csect entry. */
|
fprintf (file, "AUX ");
|
fprintf (file, "AUX ");
|
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
|
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
|
| Line 3045... |
Line 3190... |
asection **section_list;
|
asection **section_list;
|
unsigned int i;
|
unsigned int i;
|
int target_index;
|
int target_index;
|
bfd_size_type amt;
|
bfd_size_type amt;
|
|
|
|
#ifdef COFF_PAGE_SIZE
|
|
/* Clear D_PAGED if section alignment is smaller than
|
|
COFF_PAGE_SIZE. */
|
|
if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE)
|
|
abfd->flags &= ~D_PAGED;
|
|
#endif
|
|
|
count = 0;
|
count = 0;
|
for (current = abfd->sections; current != NULL; current = current->next)
|
for (current = abfd->sections; current != NULL; current = current->next)
|
++count;
|
++count;
|
|
|
/* We allocate an extra cell to simplify the final loop. */
|
/* We allocate an extra cell to simplify the final loop. */
|
amt = sizeof (struct asection *) * (count + 1);
|
amt = sizeof (struct asection *) * (count + 1);
|
section_list = bfd_malloc (amt);
|
section_list = (asection **) bfd_malloc (amt);
|
if (section_list == NULL)
|
if (section_list == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
i = 0;
|
i = 0;
|
for (current = abfd->sections; current != NULL; current = current->next)
|
for (current = abfd->sections; current != NULL; current = current->next)
|
| Line 3477... |
Line 3629... |
{
|
{
|
struct internal_scnhdr section;
|
struct internal_scnhdr section;
|
bfd_boolean is_reloc_section = FALSE;
|
bfd_boolean is_reloc_section = FALSE;
|
|
|
#ifdef COFF_IMAGE_WITH_PE
|
#ifdef COFF_IMAGE_WITH_PE
|
if (strcmp (current->name, ".reloc") == 0)
|
if (strcmp (current->name, DOT_RELOC) == 0)
|
{
|
{
|
is_reloc_section = TRUE;
|
is_reloc_section = TRUE;
|
hasrelocs = TRUE;
|
hasrelocs = TRUE;
|
pe_data (abfd)->has_reloc_section = 1;
|
pe_data (abfd)->has_reloc_section = 1;
|
}
|
}
|
| Line 3492... |
Line 3644... |
strncpy (section.s_name, current->name, SCNNMLEN);
|
strncpy (section.s_name, current->name, SCNNMLEN);
|
|
|
#ifdef COFF_LONG_SECTION_NAMES
|
#ifdef COFF_LONG_SECTION_NAMES
|
/* Handle long section names as in PE. This must be compatible
|
/* Handle long section names as in PE. This must be compatible
|
with the code in coff_write_symbols and _bfd_coff_final_link. */
|
with the code in coff_write_symbols and _bfd_coff_final_link. */
|
|
if (bfd_coff_long_section_names (abfd))
|
{
|
{
|
size_t len;
|
size_t len;
|
|
|
len = strlen (current->name);
|
len = strlen (current->name);
|
if (len > SCNNMLEN)
|
if (len > SCNNMLEN)
|
{
|
{
|
memset (section.s_name, 0, SCNNMLEN);
|
/* The s_name field is defined to be NUL-padded but need not be
|
sprintf (section.s_name, "/%lu", (unsigned long) string_size);
|
NUL-terminated. We use a temporary buffer so that we can still
|
|
sprintf all eight chars without splatting a terminating NUL
|
|
over the first byte of the following member (s_paddr). */
|
|
char s_name_buf[SCNNMLEN + 1];
|
|
|
|
/* An inherent limitation of the /nnnnnnn notation used to indicate
|
|
the offset of the long name in the string table is that we
|
|
cannot address entries beyone the ten million byte boundary. */
|
|
if (string_size >= 10000000)
|
|
{
|
|
bfd_set_error (bfd_error_file_too_big);
|
|
(*_bfd_error_handler)
|
|
(_("%B: section %s: string table overflow at offset %ld"),
|
|
abfd, current->name, string_size);
|
|
return FALSE;
|
|
}
|
|
|
|
/* snprintf not strictly necessary now we've verified the value
|
|
has less than eight ASCII digits, but never mind. */
|
|
snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
|
|
/* Then strncpy takes care of any padding for us. */
|
|
strncpy (section.s_name, s_name_buf, SCNNMLEN);
|
string_size += len + 1;
|
string_size += len + 1;
|
long_section_names = TRUE;
|
long_section_names = TRUE;
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
| Line 3518... |
Line 3692... |
section.s_vaddr = current->vma;
|
section.s_vaddr = current->vma;
|
section.s_paddr = current->lma;
|
section.s_paddr = current->lma;
|
section.s_size = current->size;
|
section.s_size = current->size;
|
#ifdef coff_get_section_load_page
|
#ifdef coff_get_section_load_page
|
section.s_page = coff_get_section_load_page (current);
|
section.s_page = coff_get_section_load_page (current);
|
|
#else
|
|
section.s_page = 0;
|
#endif
|
#endif
|
|
|
#ifdef COFF_WITH_PE
|
#ifdef COFF_WITH_PE
|
section.s_paddr = 0;
|
section.s_paddr = 0;
|
#endif
|
#endif
|
| Line 4098... |
Line 4274... |
|
|
{
|
{
|
char * buff;
|
char * buff;
|
bfd_size_type amount = bfd_coff_filhsz (abfd);
|
bfd_size_type amount = bfd_coff_filhsz (abfd);
|
|
|
buff = bfd_malloc (amount);
|
buff = (char *) bfd_malloc (amount);
|
if (buff == NULL)
|
if (buff == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
|
bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
|
amount = bfd_bwrite (buff, amount, abfd);
|
amount = bfd_bwrite (buff, amount, abfd);
|
| Line 4118... |
Line 4294... |
/* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
|
/* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
|
include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
|
include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
|
char * buff;
|
char * buff;
|
bfd_size_type amount = bfd_coff_aoutsz (abfd);
|
bfd_size_type amount = bfd_coff_aoutsz (abfd);
|
|
|
buff = bfd_malloc (amount);
|
buff = (char *) bfd_malloc (amount);
|
if (buff == NULL)
|
if (buff == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
coff_swap_aouthdr_out (abfd, & internal_a, buff);
|
coff_swap_aouthdr_out (abfd, & internal_a, buff);
|
amount = bfd_bwrite (buff, amount, abfd);
|
amount = bfd_bwrite (buff, amount, abfd);
|
| Line 4286... |
Line 4462... |
unsigned int nbr_func;
|
unsigned int nbr_func;
|
LINENO *src;
|
LINENO *src;
|
|
|
BFD_ASSERT (asect->lineno == NULL);
|
BFD_ASSERT (asect->lineno == NULL);
|
|
|
|
amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
|
|
lineno_cache = (alent *) bfd_alloc (abfd, amt);
|
|
if (lineno_cache == NULL)
|
|
return FALSE;
|
|
|
amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
|
amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
|
native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
|
native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
|
if (native_lineno == NULL)
|
if (native_lineno == NULL)
|
{
|
{
|
(*_bfd_error_handler)
|
(*_bfd_error_handler)
|
(_("%B: warning: line number table read failed"), abfd);
|
(_("%B: warning: line number table read failed"), abfd);
|
|
bfd_release (abfd, lineno_cache);
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
|
|
lineno_cache = bfd_alloc (abfd, amt);
|
|
if (lineno_cache == NULL)
|
|
return FALSE;
|
|
|
|
cache_ptr = lineno_cache;
|
cache_ptr = lineno_cache;
|
|
asect->lineno = lineno_cache;
|
src = native_lineno;
|
src = native_lineno;
|
nbr_func = 0;
|
nbr_func = 0;
|
|
|
for (counter = 0; counter < asect->lineno_count; counter++)
|
for (counter = 0; counter < asect->lineno_count; counter++)
|
{
|
{
|
| Line 4354... |
Line 4532... |
|
|
cache_ptr++;
|
cache_ptr++;
|
src++;
|
src++;
|
}
|
}
|
cache_ptr->line_number = 0;
|
cache_ptr->line_number = 0;
|
|
bfd_release (abfd, native_lineno);
|
|
|
/* On some systems (eg AIX5.3) the lineno table may not be sorted. */
|
/* On some systems (eg AIX5.3) the lineno table may not be sorted. */
|
if (!ordered)
|
if (!ordered)
|
{
|
{
|
/* Sort the table. */
|
/* Sort the table. */
|
alent **func_table;
|
alent **func_table;
|
alent *n_lineno_cache;
|
alent *n_lineno_cache;
|
|
|
/* Create a table of functions. */
|
/* Create a table of functions. */
|
func_table = bfd_malloc (nbr_func * sizeof (alent *));
|
func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *));
|
if (func_table != NULL)
|
if (func_table != NULL)
|
{
|
{
|
alent **p = func_table;
|
alent **p = func_table;
|
unsigned int i;
|
unsigned int i;
|
|
|
| Line 4377... |
Line 4556... |
|
|
/* Sort by functions. */
|
/* Sort by functions. */
|
qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
|
qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
|
|
|
/* Create the new sorted table. */
|
/* Create the new sorted table. */
|
n_lineno_cache = bfd_alloc (abfd, amt);
|
amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
|
|
n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
|
if (n_lineno_cache != NULL)
|
if (n_lineno_cache != NULL)
|
{
|
{
|
alent *n_cache_ptr = n_lineno_cache;
|
alent *n_cache_ptr = n_lineno_cache;
|
|
|
for (i = 0; i < nbr_func; i++)
|
for (i = 0; i < nbr_func; i++)
|
| Line 4399... |
Line 4579... |
/* Copy the line number entries. */
|
/* Copy the line number entries. */
|
while (old_ptr->line_number != 0)
|
while (old_ptr->line_number != 0)
|
*n_cache_ptr++ = *old_ptr++;
|
*n_cache_ptr++ = *old_ptr++;
|
}
|
}
|
n_cache_ptr->line_number = 0;
|
n_cache_ptr->line_number = 0;
|
bfd_release (abfd, lineno_cache);
|
memcpy (lineno_cache, n_lineno_cache, amt);
|
lineno_cache = n_lineno_cache;
|
|
}
|
}
|
free (func_table);
|
bfd_release (abfd, func_table);
|
}
|
}
|
}
|
}
|
|
|
asect->lineno = lineno_cache;
|
|
bfd_release (abfd, native_lineno);
|
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/* Slurp in the symbol table, converting it to generic form. Note
|
/* Slurp in the symbol table, converting it to generic form. Note
|
that if coff_relocate_section is defined, the linker will read
|
that if coff_relocate_section is defined, the linker will read
|
| Line 4434... |
Line 4611... |
return FALSE;
|
return FALSE;
|
|
|
/* Allocate enough room for all the symbols in cached form. */
|
/* Allocate enough room for all the symbols in cached form. */
|
amt = obj_raw_syment_count (abfd);
|
amt = obj_raw_syment_count (abfd);
|
amt *= sizeof (coff_symbol_type);
|
amt *= sizeof (coff_symbol_type);
|
cached_area = bfd_alloc (abfd, amt);
|
cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
|
if (cached_area == NULL)
|
if (cached_area == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
amt = obj_raw_syment_count (abfd);
|
amt = obj_raw_syment_count (abfd);
|
amt *= sizeof (unsigned int);
|
amt *= sizeof (unsigned int);
|
table_ptr = bfd_alloc (abfd, amt);
|
table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
|
|
|
if (table_ptr == NULL)
|
if (table_ptr == NULL)
|
return FALSE;
|
return FALSE;
|
else
|
else
|
{
|
{
|
| Line 4932... |
Line 5109... |
return FALSE;
|
return FALSE;
|
|
|
amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
|
amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
|
native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
|
native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
|
amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
|
amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
|
reloc_cache = bfd_alloc (abfd, amt);
|
reloc_cache = (arelent *) bfd_alloc (abfd, amt);
|
|
|
if (reloc_cache == NULL || native_relocs == NULL)
|
if (reloc_cache == NULL || native_relocs == NULL)
|
return FALSE;
|
return FALSE;
|
|
|
for (idx = 0; idx < asect->reloc_count; idx++)
|
for (idx = 0; idx < asect->reloc_count; idx++)
|
| Line 5224... |
Line 5401... |
#endif
|
#endif
|
#ifndef coff_SWAP_scnhdr_in
|
#ifndef coff_SWAP_scnhdr_in
|
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
|
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
|
#endif
|
#endif
|
|
|
static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
|
static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
|
{
|
{
|
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
|
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
|
coff_SWAP_aux_out, coff_SWAP_sym_out,
|
coff_SWAP_aux_out, coff_SWAP_sym_out,
|
coff_SWAP_lineno_out, coff_SWAP_reloc_out,
|
coff_SWAP_lineno_out, coff_SWAP_reloc_out,
|
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
|
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
|
| Line 5237... |
Line 5414... |
#ifdef COFF_LONG_FILENAMES
|
#ifdef COFF_LONG_FILENAMES
|
TRUE,
|
TRUE,
|
#else
|
#else
|
FALSE,
|
FALSE,
|
#endif
|
#endif
|
#ifdef COFF_LONG_SECTION_NAMES
|
COFF_DEFAULT_LONG_SECTION_NAMES,
|
TRUE,
|
|
#else
|
|
FALSE,
|
|
#endif
|
|
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
|
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
|
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
|
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
|
TRUE,
|
TRUE,
|
#else
|
#else
|
FALSE,
|
FALSE,
|
| Line 5261... |
Line 5434... |
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
|
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
|
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
|
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
|
coff_classify_symbol, coff_compute_section_file_positions,
|
coff_classify_symbol, coff_compute_section_file_positions,
|
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
|
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
|
coff_adjust_symndx, coff_link_add_one_symbol,
|
coff_adjust_symndx, coff_link_add_one_symbol,
|
coff_link_output_has_begun, coff_final_link_postscript
|
coff_link_output_has_begun, coff_final_link_postscript,
|
|
bfd_pe_print_pdata
|
};
|
};
|
|
|
#ifdef TICOFF
|
#ifdef TICOFF
|
/* COFF0 differs in file/section header size and relocation entry size. */
|
/* COFF0 differs in file/section header size and relocation entry size. */
|
|
|
static const bfd_coff_backend_data ticoff0_swap_table =
|
static bfd_coff_backend_data ticoff0_swap_table =
|
{
|
{
|
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
|
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
|
coff_SWAP_aux_out, coff_SWAP_sym_out,
|
coff_SWAP_aux_out, coff_SWAP_sym_out,
|
coff_SWAP_lineno_out, coff_SWAP_reloc_out,
|
coff_SWAP_lineno_out, coff_SWAP_reloc_out,
|
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
|
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
|
| Line 5280... |
Line 5454... |
#ifdef COFF_LONG_FILENAMES
|
#ifdef COFF_LONG_FILENAMES
|
TRUE,
|
TRUE,
|
#else
|
#else
|
FALSE,
|
FALSE,
|
#endif
|
#endif
|
#ifdef COFF_LONG_SECTION_NAMES
|
COFF_DEFAULT_LONG_SECTION_NAMES,
|
TRUE,
|
|
#else
|
|
FALSE,
|
|
#endif
|
|
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
|
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
|
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
|
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
|
TRUE,
|
TRUE,
|
#else
|
#else
|
FALSE,
|
FALSE,
|
| Line 5304... |
Line 5474... |
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
|
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
|
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
|
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
|
coff_classify_symbol, coff_compute_section_file_positions,
|
coff_classify_symbol, coff_compute_section_file_positions,
|
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
|
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
|
coff_adjust_symndx, coff_link_add_one_symbol,
|
coff_adjust_symndx, coff_link_add_one_symbol,
|
coff_link_output_has_begun, coff_final_link_postscript
|
coff_link_output_has_begun, coff_final_link_postscript,
|
|
bfd_pe_print_pdata
|
};
|
};
|
#endif
|
#endif
|
|
|
#ifdef TICOFF
|
#ifdef TICOFF
|
/* COFF1 differs in section header size. */
|
/* COFF1 differs in section header size. */
|
|
|
static const bfd_coff_backend_data ticoff1_swap_table =
|
static bfd_coff_backend_data ticoff1_swap_table =
|
{
|
{
|
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
|
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
|
coff_SWAP_aux_out, coff_SWAP_sym_out,
|
coff_SWAP_aux_out, coff_SWAP_sym_out,
|
coff_SWAP_lineno_out, coff_SWAP_reloc_out,
|
coff_SWAP_lineno_out, coff_SWAP_reloc_out,
|
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
|
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
|
| Line 5324... |
Line 5495... |
#ifdef COFF_LONG_FILENAMES
|
#ifdef COFF_LONG_FILENAMES
|
TRUE,
|
TRUE,
|
#else
|
#else
|
FALSE,
|
FALSE,
|
#endif
|
#endif
|
#ifdef COFF_LONG_SECTION_NAMES
|
COFF_DEFAULT_LONG_SECTION_NAMES,
|
TRUE,
|
|
#else
|
|
FALSE,
|
|
#endif
|
|
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
|
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
|
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
|
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
|
TRUE,
|
TRUE,
|
#else
|
#else
|
FALSE,
|
FALSE,
|
| Line 5348... |
Line 5515... |
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
|
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
|
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
|
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
|
coff_classify_symbol, coff_compute_section_file_positions,
|
coff_classify_symbol, coff_compute_section_file_positions,
|
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
|
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
|
coff_adjust_symndx, coff_link_add_one_symbol,
|
coff_adjust_symndx, coff_link_add_one_symbol,
|
coff_link_output_has_begun, coff_final_link_postscript
|
coff_link_output_has_begun, coff_final_link_postscript,
|
|
bfd_pe_print_pdata /* huh */
|
};
|
};
|
#endif
|
#endif
|
|
|
#ifndef coff_close_and_cleanup
|
#ifndef coff_close_and_cleanup
|
#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
|
#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
|
| Line 5447... |
Line 5615... |
#ifndef coff_section_already_linked
|
#ifndef coff_section_already_linked
|
#define coff_section_already_linked \
|
#define coff_section_already_linked \
|
_bfd_generic_section_already_linked
|
_bfd_generic_section_already_linked
|
#endif
|
#endif
|
|
|
|
#ifndef coff_bfd_define_common_symbol
|
|
#define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
|
|
#endif
|
|
|
#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
|
#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
|
const bfd_target VAR = \
|
const bfd_target VAR = \
|
{ \
|
{ \
|
NAME , \
|
NAME , \
|
bfd_target_coff_flavour, \
|
bfd_target_coff_flavour, \
|
