/* Support for the generic parts of most COFF variants, for BFD.
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.
Written by Cygnus Support.
@file{coffcode.h} because it would not be used by any other
target.
+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
At this time the symbol names are moved around. Coff stores
all symbols less than nine characters long physically
within the symbol table; longer strings are kept at the end of
- the file in the string table. This pass moves all strings
+ the file in the string table. This pass moves all strings
into memory and replaces them with pointers to the strings.
The symbol table is massaged once again, this time to create
#define DOT_DEBUG ".debug"
#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
(const char *, flagword);
static bfd_boolean styp_to_sec_flags
\f
/* 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
the incoming SEC_* flags. The inverse of this function is
styp_to_sec_flags(). NOTE: If you add to/change this routine, you
{
/* Handle the XCOFF debug section and DWARF2 debug sections. */
if (!sec_name[6])
- styp_flags = STYP_XCOFF_DEBUG;
+ styp_flags = STYP_XCOFF_DEBUG;
else
- styp_flags = STYP_DEBUG_INFO;
+ styp_flags = STYP_DEBUG_INFO;
}
else if (CONST_STRNEQ (sec_name, ".stab"))
{
/* FIXME: There is no gas syntax to specify the debug section flag. */
if (CONST_STRNEQ (sec_name, DOT_DEBUG)
|| CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
- sec_flags = SEC_DEBUGGING;
+ sec_flags = SEC_DEBUGGING | SEC_READONLY;
/* skip LOAD */
/* READONLY later */
/* skip LINK_DUPLICATES */
/* skip LINKER_CREATED */
- if (sec_flags & (SEC_ALLOC | SEC_LOAD))
- {
- /* 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)
- styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
- if (sec_flags & SEC_CODE)
- styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
- if (sec_flags & SEC_COFF_SHARED)
- styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
- }
+ if ((sec_flags & SEC_COFF_NOREAD) == 0)
+ styp_flags |= IMAGE_SCN_MEM_READ; /* Invert NOREAD for read. */
+ if ((sec_flags & SEC_READONLY) == 0)
+ styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
+ if (sec_flags & SEC_CODE)
+ styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
+ if (sec_flags & SEC_COFF_SHARED)
+ styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
return styp_flags;
}
but there's some checking we can do to be
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_value == 0))
abort ();
names like .text$foo__Fv (in the case of a
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'"),
abfd, symname, name);
amt = sizeof (struct coff_comdat_info);
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)
abort ();
(esym - esymstart) / bfd_coff_symesz (abfd);
amt = strlen (symname) + 1;
- newname = bfd_alloc (abfd, amt);
+ newname = (char *) bfd_alloc (abfd, amt);
if (newname == NULL)
abort ();
/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
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. */
while (styp_flags)
{
break;
#endif
case IMAGE_SCN_MEM_READ:
- /* Ignored, assume it always to be true. */
+ sec_flags &= ~SEC_COFF_NOREAD;
break;
case IMAGE_SCN_TYPE_NO_PAD:
/* Skip. */
sec_flags &= ~ SEC_READONLY;
break;
case IMAGE_SCN_MEM_DISCARDABLE:
- /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
- but we do not want them to be labelled as debug section, since
- then strip would remove them. */
- if (! CONST_STRNEQ (name, ".reloc"))
+ /* The MS PE spec says that debug sections are DISCARDABLE,
+ but the presence of a DISCARDABLE flag does not necessarily
+ mean that a given section contains debug information. Thus
+ 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;
break;
case IMAGE_SCN_MEM_SHARED:
. unsigned int _bfd_linesz;
. unsigned int _bfd_filnmlen;
. bfd_boolean _bfd_coff_long_filenames;
+.
. 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;
. bfd_boolean _bfd_coff_force_symnames_in_strings;
. unsigned int _bfd_coff_debug_string_prefix_length;
. bfd_boolean (*_bfd_coff_final_link_postscript)
. (bfd *, struct coff_final_link_info *);
.
+. bfd_boolean (*_bfd_coff_print_pdata)
+. (bfd *, void *);
+.
.} bfd_coff_backend_data;
.
.#define coff_backend_info(abfd) \
. (coff_backend_info (abfd)->_bfd_coff_long_filenames)
.#define bfd_coff_long_section_names(abfd) \
. (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) \
. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
.#define 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. */
@@ The 10 is a guess at a plausible maximum number of aux entries
(but shouldn't be a constant). */
amt = sizeof (combined_entry_type) * 10;
- native = bfd_zalloc (abfd, amt);
+ native = (combined_entry_type *) bfd_zalloc (abfd, amt);
if (native == NULL)
return FALSE;
struct internal_reloc n;
file_ptr oldpos = bfd_tell (abfd);
bfd_size_type relsz = bfd_coff_relsz (abfd);
-
+
bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
if (bfd_bread (& dst, relsz, abfd) != relsz)
return;
abfd->flags |= HAS_DEBUG;
#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;
}
#endif
case MAXQ20MAGIC:
arch = bfd_arch_maxq;
switch (internal_f->f_flags & F_MACHMASK)
- {
- case F_MAXQ10:
- machine = bfd_mach_maxq10;
- break;
- case F_MAXQ20:
- machine = bfd_mach_maxq20;
- break;
- default:
- return FALSE;
+ {
+ case F_MAXQ10:
+ machine = bfd_mach_maxq10;
+ break;
+ case F_MAXQ20:
+ machine = bfd_mach_maxq20;
+ break;
+ default:
+ return FALSE;
}
break;
#endif
case TICOFF1MAGIC:
case TICOFF2MAGIC:
switch (internal_f->f_target_id)
- {
+ {
#ifdef TI_TARGET_ID
- case TI_TARGET_ID:
- arch = TICOFF_TARGET_ARCH;
+ case TI_TARGET_ID:
+ arch = TICOFF_TARGET_ARCH;
machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
- break;
-#endif
- default:
- arch = bfd_arch_obscure;
- (*_bfd_error_handler)
- (_("Unrecognized TI COFF target id '0x%x'"),
- internal_f->f_target_id);
- break;
- }
+ break;
+#endif
+ default:
+ arch = bfd_arch_obscure;
+ (*_bfd_error_handler)
+ (_("Unrecognized TI COFF target id '0x%x'"),
+ internal_f->f_target_id);
+ break;
+ }
break;
#endif
#define FORCE_SYMNAMES_IN_STRINGS
#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
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
unsigned int indaux,
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)
{
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
}
/* Return TRUE to indicate that the caller should not do any
- further work on this auxent. */
+ further work on this auxent. */
return TRUE;
}
unsigned int indaux ATTRIBUTE_UNUSED)
{
#ifdef RS6000COFF_C
- if ((symbol->u.syment.n_sclass == C_EXT
- || symbol->u.syment.n_sclass == C_HIDEXT)
+ if (CSECT_SYM_P (symbol->u.syment.n_sclass)
&& indaux + 1 == symbol->u.syment.n_numaux)
{
/* This is a csect entry. */
if (q->sym_ptr_ptr)
{
#ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
- if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
+ if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
#else
if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
&& ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
case bfd_mach_i960_ka_sa: flags = F_I960KA; break;
case bfd_mach_i960_jx: flags = F_I960JX; break;
case bfd_mach_i960_hx: flags = F_I960HX; break;
- default: return FALSE;
+ default: return FALSE;
}
*flagsp = flags;
return TRUE;
case TICOFF_TARGET_ARCH:
/* If there's no indication of which version we want, use the default. */
if (!abfd->xvec )
- *magicp = TICOFF_DEFAULT_MAGIC;
+ *magicp = TICOFF_DEFAULT_MAGIC;
else
- {
- /* We may want to output in a different COFF version. */
- switch (abfd->xvec->name[4])
- {
- case '0':
- *magicp = TICOFF0MAGIC;
- break;
- case '1':
- *magicp = TICOFF1MAGIC;
- break;
- case '2':
- *magicp = TICOFF2MAGIC;
- break;
- default:
- return FALSE;
- }
- }
+ {
+ /* We may want to output in a different COFF version. */
+ switch (abfd->xvec->name[4])
+ {
+ case '0':
+ *magicp = TICOFF0MAGIC;
+ break;
+ case '1':
+ *magicp = TICOFF1MAGIC;
+ break;
+ case '2':
+ *magicp = TICOFF2MAGIC;
+ break;
+ default:
+ return FALSE;
+ }
+ }
TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
return TRUE;
#endif
#ifdef OR32_MAGIC_BIG
case bfd_arch_or32:
if (bfd_big_endian (abfd))
- * magicp = OR32_MAGIC_BIG;
+ * magicp = OR32_MAGIC_BIG;
else
- * magicp = OR32_MAGIC_LITTLE;
+ * magicp = OR32_MAGIC_LITTLE;
return TRUE;
#endif
/* If no file alignment has been set, default to one.
This repairs 'ld -r' for arm-wince-pe target. */
if (page_size == 0)
- page_size = 1;
+ page_size = 1;
}
else
page_size = PE_DEF_FILE_ALIGNMENT;
int target_index;
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;
for (current = abfd->sections; current != NULL; current = current->next)
++count;
/* We allocate an extra cell to simplify the final loop. */
amt = sizeof (struct asection *) * (count + 1);
- section_list = bfd_malloc (amt);
+ section_list = (asection **) bfd_malloc (amt);
if (section_list == NULL)
return FALSE;
#ifdef COFF_IMAGE_WITH_PE
/* For PE we need to make sure we pad out to the aligned
- size, in case the caller only writes out data to the
- unaligned size. */
+ size, in case the caller only writes out data to the
+ unaligned size. */
if (pei_section_data (abfd, current)->virt_size < current->size)
align_adjust = TRUE;
#endif
bfd_boolean is_reloc_section = FALSE;
#ifdef COFF_IMAGE_WITH_PE
- if (strcmp (current->name, ".reloc") == 0)
+ if (strcmp (current->name, DOT_RELOC) == 0)
{
is_reloc_section = TRUE;
hasrelocs = TRUE;
#ifdef COFF_LONG_SECTION_NAMES
/* Handle long section names as in PE. This must be compatible
- with the code in coff_write_symbols and _bfd_coff_final_link. */
- {
- size_t len;
+ with the code in coff_write_symbols and _bfd_coff_final_link. */
+ if (bfd_coff_long_section_names (abfd))
+ {
+ size_t len;
- len = strlen (current->name);
- if (len > SCNNMLEN)
- {
- memset (section.s_name, 0, SCNNMLEN);
- sprintf (section.s_name, "/%lu", (unsigned long) string_size);
- string_size += len + 1;
- long_section_names = TRUE;
- }
- }
+ len = strlen (current->name);
+ if (len > SCNNMLEN)
+ {
+ /* The s_name field is defined to be NUL-padded but need not be
+ 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;
+ long_section_names = TRUE;
+ }
+ }
#endif
#ifdef _LIB
section.s_size = current->size;
#ifdef coff_get_section_load_page
section.s_page = coff_get_section_load_page (current);
+#else
+ section.s_page = 0;
#endif
#ifdef COFF_WITH_PE
#ifdef COFF_WITH_PE
/* PE stores COMDAT section information in the symbol table. If
- this section is supposed to have some COMDAT info, track down
- the symbol in the symbol table and modify it. */
+ this section is supposed to have some COMDAT info, track down
+ the symbol in the symbol table and modify it. */
if ((current->flags & SEC_LINK_ONCE) != 0)
{
unsigned int i, count;
continue;
/* Remember the location of the first symbol in this
- section. */
+ section. */
if (psymsec == NULL)
psymsec = psym;
}
/* The COMDAT symbol must be the first symbol from this
- section in the symbol table. In order to make this
- work, we move the COMDAT symbol before the first
- symbol we found in the search above. It's OK to
- rearrange the symbol table at this point, because
- coff_renumber_symbols is going to rearrange it
- further and fix up all the aux entries. */
+ section in the symbol table. In order to make this
+ work, we move the COMDAT symbol before the first
+ symbol we found in the search above. It's OK to
+ rearrange the symbol table at this point, because
+ coff_renumber_symbols is going to rearrange it
+ further and fix up all the aux entries. */
if (psym != psymsec)
{
asymbol *hold;
#define __A_MAGIC_SET__
internal_a.magic = MAXQ20MAGIC;
#endif
-
+
#ifndef __A_MAGIC_SET__
#include "Your aouthdr magic number is not being set!"
#else
else if (long_section_names && ! obj_coff_strings_written (abfd))
{
/* If we have long section names we have to write out the string
- table even if there are no symbols. */
+ table even if there are no symbols. */
if (! coff_write_symbols (abfd))
return FALSE;
}
bfd_byte b;
/* PowerPC PE appears to require that all executable files be
- rounded up to the page size. */
+ rounded up to the page size. */
b = 0;
if (bfd_seek (abfd,
(file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
internal_f.f_symptr = sym_base;
#ifdef RS6000COFF_C
/* AIX appears to require that F_RELFLG not be set if there are
- local symbols but no relocations. */
+ local symbols but no relocations. */
internal_f.f_flags &=~ F_RELFLG;
#endif
}
char * buff;
bfd_size_type amount = bfd_coff_filhsz (abfd);
- buff = bfd_malloc (amount);
+ buff = (char *) bfd_malloc (amount);
if (buff == NULL)
return FALSE;
char * buff;
bfd_size_type amount = bfd_coff_aoutsz (abfd);
- buff = bfd_malloc (amount);
+ buff = (char *) bfd_malloc (amount);
if (buff == NULL)
return FALSE;
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;
native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
if (native_lineno == NULL)
{
(*_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;
}
- 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;
+ asect->lineno = lineno_cache;
src = native_lineno;
nbr_func = 0;
src++;
}
cache_ptr->line_number = 0;
+ bfd_release (abfd, native_lineno);
/* On some systems (eg AIX5.3) the lineno table may not be sorted. */
if (!ordered)
alent *n_lineno_cache;
/* 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)
{
alent **p = func_table;
qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
/* 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)
{
alent *n_cache_ptr = n_lineno_cache;
*n_cache_ptr++ = *old_ptr++;
}
n_cache_ptr->line_number = 0;
- bfd_release (abfd, lineno_cache);
- lineno_cache = n_lineno_cache;
+ memcpy (lineno_cache, n_lineno_cache, amt);
}
- free (func_table);
+ bfd_release (abfd, func_table);
}
}
- asect->lineno = lineno_cache;
- bfd_release (abfd, native_lineno);
return TRUE;
}
/* Allocate enough room for all the symbols in cached form. */
amt = obj_raw_syment_count (abfd);
amt *= sizeof (coff_symbol_type);
- cached_area = bfd_alloc (abfd, amt);
+ cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
if (cached_area == NULL)
return FALSE;
amt = obj_raw_syment_count (abfd);
amt *= sizeof (unsigned int);
- table_ptr = bfd_alloc (abfd, amt);
+ table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
if (table_ptr == NULL)
return FALSE;
case C_EXT:
case C_WEAKEXT:
#if defined ARM
- case C_THUMBEXT:
- case C_THUMBEXTFUNC:
+ case C_THUMBEXT:
+ case C_THUMBEXTFUNC:
#endif
#ifdef RS6000COFF_C
case C_HIDEXT:
case C_SYSTEM: /* System Wide variable. */
#endif
#ifdef COFF_WITH_PE
- /* In PE, 0x68 (104) denotes a section symbol. */
- case C_SECTION:
+ /* In PE, 0x68 (104) denotes a section symbol. */
+ case C_SECTION:
/* In PE, 0x69 (105) denotes a weak external symbol. */
case C_NT_WEAK:
#endif
dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
#if defined COFF_WITH_PE
/* PE sets the symbol to a value relative to the
- start of the section. */
+ start of the section. */
dst->symbol.value = src->u.syment.n_value;
#else
dst->symbol.value = (src->u.syment.n_value
dst->symbol.flags = BSF_LOCAL;
#if defined COFF_WITH_PE
/* PE sets the symbol to a value relative to the
- start of the section. */
+ start of the section. */
dst->symbol.value = src->u.syment.n_value;
#else
dst->symbol.value = (src->u.syment.n_value
case C_LEAFSTAT: /* Static leaf procedure. */
#endif
#if defined ARM
- case C_THUMBSTAT: /* Thumb static. */
- case C_THUMBLABEL: /* Thumb label. */
- case C_THUMBSTATFUNC:/* Thumb static function. */
+ case C_THUMBSTAT: /* Thumb static. */
+ case C_THUMBLABEL: /* Thumb label. */
+ case C_THUMBSTATFUNC:/* Thumb static function. */
#endif
case C_LABEL: /* Label. */
if (src->u.syment.n_scnum == N_DEBUG)
{
#if defined COFF_WITH_PE
/* PE sets the symbol to a value relative to the
- start of the section. */
+ start of the section. */
dst->symbol.value = src->u.syment.n_value;
#else
dst->symbol.value = (src->u.syment.n_value
case C_EOS: /* End of structure. */
case C_REGPARM: /* Register parameter. */
case C_REG: /* register variable. */
- /* C_AUTOARG conflicts with TI COFF C_UEXT. */
+ /* C_AUTOARG conflicts with TI COFF C_UEXT. */
#if !defined (TIC80COFF) && !defined (TICOFF)
#ifdef C_AUTOARG
case C_AUTOARG: /* 960-specific storage class. */
case C_BINCL: /* Beginning of include file. */
case C_EINCL: /* Ending of include file. */
/* The value is actually a pointer into the line numbers
- of the file. We locate the line number entry, and
- set the section to the section which contains it, and
- the value to the index in that section. */
+ of the file. We locate the line number entry, and
+ set the section to the section which contains it, and
+ the value to the index in that section. */
{
asection *sec;
if (strcmp (dst->symbol.name, ".bf") != 0)
{
/* PE uses funny values for .ef and .lf; don't
- relocate them. */
+ relocate them. */
dst->symbol.flags = BSF_DEBUGGING;
}
else
break;
case C_STATLAB: /* Static load time label. */
- dst->symbol.value = src->u.syment.n_value;
- dst->symbol.flags = BSF_GLOBAL;
- break;
+ dst->symbol.value = src->u.syment.n_value;
+ dst->symbol.flags = BSF_GLOBAL;
+ break;
case C_NULL:
/* PE DLLs sometimes have zeroed out symbols for some
- reason. Just ignore them without a warning. */
+ reason. Just ignore them without a warning. */
if (src->u.syment.n_type == 0
&& src->u.syment.n_value == 0
&& src->u.syment.n_scnum == 0)
case C_ULABEL: /* Undefined label. */
case C_USTATIC: /* Undefined static. */
#ifndef COFF_WITH_PE
- /* C_LINE in regular coff is 0x68. NT has taken over this storage
- class to represent a section symbol. */
+ /* C_LINE in regular coff is 0x68. NT has taken over this storage
+ class to represent a section symbol. */
case C_LINE: /* line # reformatted as symbol table entry. */
/* NT uses 0x67 for a weak symbol, not C_ALIAS. */
case C_ALIAS: /* Duplicate tag. */
#ifdef STRICT_PE_FORMAT
/* This is correct for Microsoft generated objects, but it
- breaks gas generated objects. */
+ breaks gas generated objects. */
if (syment->n_value == 0)
{
asection *sec;
if (syment->n_sclass == C_SECTION)
{
/* In some cases in a DLL generated by the Microsoft linker, the
- n_value field will contain garbage. FIXME: This should
- probably be handled by the swapping function instead. */
+ n_value field will contain garbage. FIXME: This should
+ probably be handled by the swapping function instead. */
syment->n_value = 0;
if (syment->n_scnum == 0)
return COFF_SYMBOL_UNDEFINED;
*/
#ifndef CALC_ADDEND
-#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
- { \
- coff_symbol_type *coffsym = NULL; \
- \
- if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
- coffsym = (obj_symbols (abfd) \
- + (cache_ptr->sym_ptr_ptr - symbols)); \
- else if (ptr) \
- coffsym = coff_symbol_from (abfd, ptr); \
- if (coffsym != NULL \
- && coffsym->native->u.syment.n_scnum == 0) \
- cache_ptr->addend = 0; \
- else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
- && ptr->section != NULL) \
- cache_ptr->addend = - (ptr->section->vma + ptr->value); \
- else \
- cache_ptr->addend = 0; \
+#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
+ { \
+ coff_symbol_type *coffsym = NULL; \
+ \
+ if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
+ coffsym = (obj_symbols (abfd) \
+ + (cache_ptr->sym_ptr_ptr - symbols)); \
+ else if (ptr) \
+ coffsym = coff_symbol_from (abfd, ptr); \
+ if (coffsym != NULL \
+ && coffsym->native->u.syment.n_scnum == 0) \
+ cache_ptr->addend = 0; \
+ else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
+ && ptr->section != NULL) \
+ cache_ptr->addend = - (ptr->section->vma + ptr->value); \
+ else \
+ cache_ptr->addend = 0; \
}
#endif
amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
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)
return FALSE;
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
#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_out, coff_SWAP_sym_out,
#else
FALSE,
#endif
-#ifdef COFF_LONG_SECTION_NAMES
- TRUE,
-#else
- FALSE,
-#endif
+ COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
TRUE,
coff_classify_symbol, coff_compute_section_file_positions,
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
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
/* 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_out, coff_SWAP_sym_out,
#else
FALSE,
#endif
-#ifdef COFF_LONG_SECTION_NAMES
- TRUE,
-#else
- FALSE,
-#endif
+ COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
TRUE,
coff_classify_symbol, coff_compute_section_file_positions,
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
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
#ifdef TICOFF
/* 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_out, coff_SWAP_sym_out,
#else
FALSE,
#endif
-#ifdef COFF_LONG_SECTION_NAMES
- TRUE,
-#else
- FALSE,
-#endif
+ COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
TRUE,
coff_classify_symbol, coff_compute_section_file_positions,
coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
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
#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
#endif
#ifndef coff_bfd_free_cached_info
-#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
+#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
#endif
#ifndef coff_get_section_contents
-#define coff_get_section_contents _bfd_generic_get_section_contents
+#define coff_get_section_contents _bfd_generic_get_section_contents
#endif
#ifndef coff_bfd_copy_private_symbol_data
#endif
#ifndef coff_bfd_set_private_flags
-#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
+#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
#endif
#ifndef coff_bfd_print_private_bfd_data
_bfd_generic_section_already_linked
#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) \
const bfd_target VAR = \
{ \
UNDER, /* Leading symbol underscore. */ \
'/', /* AR_pad_char. */ \
15, /* AR_max_namelen. */ \
- \
+ \
/* Data conversion functions. */ \
bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
- \
+ \
/* Header conversion functions. */ \
bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
BFD_JUMP_TABLE_WRITE (coff), \
BFD_JUMP_TABLE_LINK (coff), \
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
- \
+ \
ALTERNATIVE, \
- \
+ \
SWAP_TABLE \
};
UNDER, /* Leading symbol underscore. */ \
'/', /* AR_pad_char. */ \
15, /* AR_max_namelen. */ \
- \
+ \
/* Data conversion functions. */ \
bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
- \
+ \
/* Header conversion functions. */ \
bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
BFD_JUMP_TABLE_WRITE (coff), \
BFD_JUMP_TABLE_LINK (coff), \
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
- \
+ \
ALTERNATIVE, \
- \
+ \
SWAP_TABLE \
};
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
\
ALTERNATIVE, \
- \
+ \
SWAP_TABLE \
};
projects / msp430-binutils.git / blobdiff