/* Support for the generic parts of most COFF variants, for BFD.
- Copyright (C) 1990-2014 Free Software Foundation, Inc.
+ Copyright (C) 1990-2021 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
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
- @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
+ example, the i386 coff format is implemented in the file
+ @file{coff-i386.c}. This file @code{#include}s
+ @file{coff/i386.h} which defines the external structure of the
+ coff format for the i386, and @file{coff/internal.h} which
+ defines the internal structure. @file{coff-i386.c} also
+ defines the relocations used by the i386 coff format
@xref{Relocations}.
- The Intel i960 processor version of coff is implemented in
- @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
Some of the Coff targets then also have additional routines in
the target source file itself.
- For example, @file{coff-i960.c} includes
- @file{coff/internal.h} and @file{coff/i960.h}. It then
- defines a few constants, such as @code{I960}, and includes
- @file{coffcode.h}. Since the i960 has complex relocation
- types, @file{coff-i960.c} also includes some code to
- manipulate the i960 relocs. This code is not in
- @file{coffcode.h} because it would not be used by any other
- target.
-
SUBSUBSECTION
Coff long section names
.typedef struct coff_ptr_struct
.{
. {* Remembers the offset from the first symbol in the file for
-. this symbol. Generated by coff_renumber_symbols. *}
+. this symbol. Generated by coff_renumber_symbols. *}
. unsigned int offset;
.
. {* Should the value of this symbol be renumbered. Used for
. unsigned int fix_value : 1;
.
. {* Should the tag field of this symbol be renumbered.
-. Created by coff_pointerize_aux. *}
+. Created by coff_pointerize_aux. *}
. unsigned int fix_tag : 1;
.
. {* Should the endidx field of this symbol be renumbered.
-. Created by coff_pointerize_aux. *}
+. Created by coff_pointerize_aux. *}
. unsigned int fix_end : 1;
.
. {* Should the x_csect.x_scnlen field be renumbered.
-. Created by coff_pointerize_aux. *}
+. Created by coff_pointerize_aux. *}
. unsigned int fix_scnlen : 1;
.
. {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
. unsigned int fix_line : 1;
.
. {* The container for the symbol structure as read and translated
-. from the file. *}
+. from the file. *}
. union
. {
. union internal_auxent auxent;
. struct internal_syment syment;
. } u;
+.
+. {* Selector for the union above. *}
+. bool is_sym;
.} combined_entry_type;
.
.
. struct lineno_cache_entry *lineno;
.
. {* Have the line numbers been relocated yet ? *}
-. bfd_boolean done_lineno;
+. bool done_lineno;
.} coff_symbol_type;
*/
#define GNU_LINKONCE_WT ".gnu.linkonce.wt."
#define DOT_RELOC ".reloc"
+#if defined(COFF_WITH_PE) || defined(COFF_GO32_EXE) || defined(COFF_GO32)
+# define COFF_WITH_EXTENDED_RELOC_COUNTER
+#endif
+
#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)
+#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)
/* 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
+#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
+#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
+static bool 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
+static bool 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
+static bool styp_to_sec_flags
(bfd *, void *, const char *, asection *, flagword *);
-static bfd_boolean coff_bad_format_hook
+static bool coff_bad_format_hook
(bfd *, void *);
static void coff_set_custom_section_alignment
(bfd *, asection *, const struct coff_section_alignment_entry *,
const unsigned int);
-static bfd_boolean coff_new_section_hook
+static bool coff_new_section_hook
(bfd *, asection *);
-static bfd_boolean coff_set_arch_mach_hook
+static bool coff_set_arch_mach_hook
(bfd *, void *);
-static bfd_boolean coff_write_relocs
+static bool coff_write_relocs
(bfd *, int);
-static bfd_boolean coff_set_flags
+static bool coff_set_flags
(bfd *, unsigned int *, unsigned short *);
-static bfd_boolean coff_set_arch_mach
+static bool coff_set_arch_mach
(bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
-static bfd_boolean coff_compute_section_file_positions
+static bool coff_compute_section_file_positions
(bfd *);
-static bfd_boolean coff_write_object_contents
+static bool coff_write_object_contents
(bfd *) ATTRIBUTE_UNUSED;
-static bfd_boolean coff_set_section_contents
+static bool coff_set_section_contents
(bfd *, asection *, const void *, file_ptr, bfd_size_type);
-static void * buy_and_read
- (bfd *, file_ptr, bfd_size_type);
-static bfd_boolean coff_slurp_line_table
+static bool coff_slurp_line_table
(bfd *, asection *);
-static bfd_boolean coff_slurp_symbol_table
+static bool coff_slurp_symbol_table
(bfd *);
static enum coff_symbol_classification coff_classify_symbol
(bfd *, struct internal_syment *);
-static bfd_boolean coff_slurp_reloc_table
+static bool coff_slurp_reloc_table
(bfd *, asection *, asymbol **);
static long coff_canonicalize_reloc
(bfd *, asection *, arelent **, asymbol **);
static flagword handle_COMDAT
(bfd *, flagword, void *, const char *, asection *);
#endif
-#ifdef COFF_IMAGE_WITH_PE
-static bfd_boolean coff_read_word
- (bfd *, unsigned int *);
-static unsigned int coff_compute_checksum
- (bfd *);
-static bfd_boolean coff_apply_checksum
- (bfd *);
-#endif
#ifdef TICOFF
-static bfd_boolean ticoff0_bad_format_hook
+static bool ticoff0_bad_format_hook
(bfd *, void * );
-static bfd_boolean ticoff1_bad_format_hook
+static bool ticoff1_bad_format_hook
(bfd *, void * );
#endif
\f
/* void warning(); */
#if defined (COFF_LONG_SECTION_NAMES)
-static bfd_boolean
+static bool
bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
{
coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
- return TRUE;
+ return true;
}
#else /* !defined (COFF_LONG_SECTION_NAMES) */
-static bfd_boolean
+static bool
bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
{
(void) abfd;
(void) enable;
- return FALSE;
+ return false;
}
#endif /* defined (COFF_LONG_SECTION_NAMES) */
styp_flags = STYP_LIT;
#endif /* _LIT */
}
- else if (CONST_STRNEQ (sec_name, DOT_DEBUG)
- || CONST_STRNEQ (sec_name, DOT_ZDEBUG))
+ else if (startswith (sec_name, DOT_DEBUG)
+ || startswith (sec_name, DOT_ZDEBUG))
{
/* Handle the XCOFF debug section and DWARF2 debug sections. */
if (!sec_name[6])
else
styp_flags = STYP_DEBUG_INFO;
}
- else if (CONST_STRNEQ (sec_name, ".stab"))
+ else if (startswith (sec_name, ".stab"))
{
styp_flags = STYP_DEBUG_INFO;
}
#ifdef COFF_LONG_SECTION_NAMES
- else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
- || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT))
+ else if (startswith (sec_name, GNU_LINKONCE_WI)
+ || startswith (sec_name, GNU_LINKONCE_WT))
{
styp_flags = STYP_DEBUG_INFO;
}
#endif
#ifdef RS6000COFF_C
+ else if (!strcmp (sec_name, _TDATA))
+ {
+ styp_flags = STYP_TDATA;
+ }
+ else if (!strcmp (sec_name, _TBSS))
+ {
+ styp_flags = STYP_TBSS;
+ }
else if (!strcmp (sec_name, _PAD))
{
styp_flags = STYP_PAD;
int i;
for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
- if (!strcmp (sec_name, xcoff_dwsect_names[i].name))
- {
- styp_flags = STYP_DWARF | xcoff_dwsect_names[i].flag;
- break;
- }
+ if (!strcmp (sec_name, xcoff_dwsect_names[i].name))
+ {
+ styp_flags = STYP_DWARF | xcoff_dwsect_names[i].flag;
+ break;
+ }
}
#endif
/* Try and figure out what it should be */
sec_to_styp_flags (const char *sec_name, flagword sec_flags)
{
long styp_flags = 0;
- bfd_boolean is_dbg = FALSE;
+ bool is_dbg = false;
- if (CONST_STRNEQ (sec_name, DOT_DEBUG)
- || CONST_STRNEQ (sec_name, DOT_ZDEBUG)
+ if (startswith (sec_name, DOT_DEBUG)
+ || startswith (sec_name, DOT_ZDEBUG)
#ifdef COFF_LONG_SECTION_NAMES
- || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
- || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT)
+ || startswith (sec_name, GNU_LINKONCE_WI)
+ || startswith (sec_name, GNU_LINKONCE_WT)
#endif
- || CONST_STRNEQ (sec_name, ".stab"))
- is_dbg = TRUE;
+ || startswith (sec_name, ".stab"))
+ is_dbg = true;
/* caution: there are at least three groups of symbols that have
very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
if (is_dbg)
{
sec_flags &= (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
- | SEC_LINK_DUPLICATES_SAME_CONTENTS
- | SEC_LINK_DUPLICATES_SAME_SIZE);
+ | SEC_LINK_DUPLICATES_SAME_CONTENTS
+ | SEC_LINK_DUPLICATES_SAME_SIZE);
sec_flags |= SEC_DEBUGGING | SEC_READONLY;
}
/* skip ROM */
/* skip constRUCTOR */
/* skip CONTENTS */
+#ifndef COFF_IMAGE_WITH_PE
+ /* I don't think any of the IMAGE_SCN_LNK_* flags set below should be set
+ when the output is PE. Only object files should have them, for the linker
+ to consume. */
if ((sec_flags & SEC_IS_COMMON) != 0)
styp_flags |= IMAGE_SCN_LNK_COMDAT;
+#endif
if ((sec_flags & SEC_DEBUGGING) != 0)
styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
- if ((sec_flags & SEC_EXCLUDE) != 0 && !is_dbg)
- styp_flags |= IMAGE_SCN_LNK_REMOVE;
- if ((sec_flags & SEC_NEVER_LOAD) != 0 && !is_dbg)
+ if ((sec_flags & (SEC_EXCLUDE | SEC_NEVER_LOAD)) != 0 && !is_dbg)
+#ifdef COFF_IMAGE_WITH_PE
+ styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
+#else
styp_flags |= IMAGE_SCN_LNK_REMOVE;
+#endif
/* skip IN_MEMORY */
/* skip SORT */
+#ifndef COFF_IMAGE_WITH_PE
if (sec_flags & SEC_LINK_ONCE)
styp_flags |= IMAGE_SCN_LNK_COMDAT;
if ((sec_flags
& (SEC_LINK_DUPLICATES_DISCARD | SEC_LINK_DUPLICATES_SAME_CONTENTS
- | SEC_LINK_DUPLICATES_SAME_SIZE)) != 0)
+ | SEC_LINK_DUPLICATES_SAME_SIZE)) != 0)
styp_flags |= IMAGE_SCN_LNK_COMDAT;
+#endif
/* skip LINKER_CREATED */
#ifndef COFF_WITH_PE
-static bfd_boolean
-styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
+static bool
+styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
asection *section ATTRIBUTE_UNUSED,
flagword *flags_ptr)
{
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
- long styp_flags = internal_s->s_flags;
+ unsigned long styp_flags = internal_s->s_flags;
flagword sec_flags = 0;
#ifdef STYP_BLOCK
else if (styp_flags & STYP_PAD)
sec_flags = 0;
#ifdef RS6000COFF_C
+ else if (styp_flags & STYP_TDATA)
+ {
+ if (sec_flags & SEC_NEVER_LOAD)
+ sec_flags |= SEC_DATA | SEC_THREAD_LOCAL | SEC_COFF_SHARED_LIBRARY;
+ else
+ sec_flags |= SEC_DATA | SEC_THREAD_LOCAL | SEC_LOAD | SEC_ALLOC;
+ }
+ else if (styp_flags & STYP_TBSS)
+ {
+#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
+ if (sec_flags & SEC_NEVER_LOAD)
+ sec_flags |= SEC_ALLOC | SEC_THREAD_LOCAL | SEC_COFF_SHARED_LIBRARY;
+ else
+#endif
+ sec_flags |= SEC_ALLOC | SEC_THREAD_LOCAL;
+ }
else if (styp_flags & STYP_EXCEPT)
sec_flags |= SEC_LOAD;
else if (styp_flags & STYP_LOADER)
#endif
sec_flags |= SEC_ALLOC;
}
- else if (CONST_STRNEQ (name, DOT_DEBUG)
- || CONST_STRNEQ (name, DOT_ZDEBUG)
+ else if (startswith (name, DOT_DEBUG)
+ || startswith (name, DOT_ZDEBUG)
#ifdef _COMMENT
|| strcmp (name, _COMMENT) == 0
#endif
#ifdef COFF_LONG_SECTION_NAMES
- || CONST_STRNEQ (name, GNU_LINKONCE_WI)
- || CONST_STRNEQ (name, GNU_LINKONCE_WT)
+ || startswith (name, GNU_LINKONCE_WI)
+ || startswith (name, GNU_LINKONCE_WT)
#endif
- || CONST_STRNEQ (name, ".stab"))
+ || startswith (name, ".stab"))
{
#ifdef COFF_PAGE_SIZE
sec_flags |= SEC_DEBUGGING;
sec_flags = (SEC_LOAD | SEC_ALLOC);
#endif /* STYP_SDATA */
+ if ((bfd_applicable_section_flags (abfd) & SEC_SMALL_DATA) != 0
+ && (startswith (name, ".sbss")
+ || startswith (name, ".sdata")))
+ sec_flags |= SEC_SMALL_DATA;
+
#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
/* As a GNU extension, if the name begins with .gnu.linkonce, we
only link a single copy of the section. This is used to support
The symbols will be defined as weak, so that multiple definitions
are permitted. The GNU linker extension is to actually discard
all but one of the sections. */
- if (CONST_STRNEQ (name, ".gnu.linkonce"))
+ if (startswith (name, ".gnu.linkonce"))
sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
#endif
if (flags_ptr == NULL)
- return FALSE;
+ return false;
* flags_ptr = sec_flags;
- return TRUE;
+ return true;
}
#else /* COFF_WITH_PE */
bfd_coff_swap_sym_in (abfd, esym, & isym);
- if (sizeof (internal_s->s_name) > SYMNMLEN)
- {
- /* This case implies that the matching
- symbol name will be in the string table. */
- abort ();
- }
+ BFD_ASSERT (sizeof (internal_s->s_name) <= SYMNMLEN);
if (isym.n_scnum == section->target_index)
{
/* All 3 branches use this. */
symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
+ /* PR 17512 file: 078-11867-0.004 */
if (symname == NULL)
- abort ();
+ {
+ _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
+ abfd);
+ break;
+ }
switch (seen_state)
{
|| isym.n_sclass == C_EXT)
&& BTYPE (isym.n_type) == T_NULL
&& isym.n_value == 0))
- abort ();
+ {
+ /* Malformed input files can trigger this test.
+ cf PR 21781. */
+ _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
+ abfd, symname);
+ goto breakloop;
+ }
/* FIXME LATER: MSVC generates section names
like .text for comdats. Gas generates
function). See comment above for more. */
if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
- _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
+ " does not match section name '%s'"),
abfd, symname, name);
seen_state = 1;
+ /* PR 17512: file: e2cfe54f. */
+ if (esym + bfd_coff_symesz (abfd) >= esymend)
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: warning: no symbol for"
+ " section '%s' found"),
+ abfd, symname);
+ break;
+ }
/* This is the section symbol. */
bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)),
isym.n_type, isym.n_sclass,
drop through from the above). */
{
char *newname;
- bfd_size_type amt;
+ size_t amt;
/* This must the second symbol with the
section #. It is the actual symbol name.
required information. FIXME: Is the COMDAT symbol index used for
any purpose other than objdump? */
-static bfd_boolean
+static bool
styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
flagword *flags_ptr)
{
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
- long styp_flags = internal_s->s_flags;
+ unsigned long styp_flags = internal_s->s_flags;
flagword sec_flags;
- bfd_boolean result = TRUE;
- bfd_boolean is_dbg = FALSE;
+ bool result = true;
+ bool is_dbg = false;
- if (CONST_STRNEQ (name, DOT_DEBUG)
- || CONST_STRNEQ (name, DOT_ZDEBUG)
+ if (startswith (name, DOT_DEBUG)
+ || startswith (name, DOT_ZDEBUG)
#ifdef COFF_LONG_SECTION_NAMES
- || CONST_STRNEQ (name, GNU_LINKONCE_WI)
- || CONST_STRNEQ (name, GNU_LINKONCE_WT)
-#endif
- || CONST_STRNEQ (name, ".stab"))
- is_dbg = TRUE;
+ || startswith (name, GNU_LINKONCE_WI)
+ || startswith (name, GNU_LINKONCE_WT)
+ /* FIXME: These definitions ought to be in a header file. */
+#define GNU_DEBUGLINK ".gnu_debuglink"
+#define GNU_DEBUGALTLINK ".gnu_debugaltlink"
+ || startswith (name, GNU_DEBUGLINK)
+ || startswith (name, GNU_DEBUGALTLINK)
+#endif
+ || startswith (name, ".stab"))
+ is_dbg = true;
/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
sec_flags = SEC_READONLY;
/* Process each flag bit in styp_flags in turn. */
while (styp_flags)
{
- long flag = styp_flags & - styp_flags;
+ unsigned long flag = styp_flags & - styp_flags;
char * unhandled = NULL;
styp_flags &= ~ flag;
/* Generate a warning message rather using the 'unhandled'
variable as this will allow some .sys files generate by
other toolchains to be processed. See bugzilla issue 196. */
- _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
- abfd, name);
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: warning: ignoring section flag"
+ " %s in section %s"),
+ abfd, "IMAGE_SCN_MEM_NOT_PAGED", name);
break;
case IMAGE_SCN_MEM_EXECUTE:
sec_flags |= SEC_CODE;
/* If the section flag was not handled, report it here. */
if (unhandled != NULL)
{
- (*_bfd_error_handler)
- (_("%B (%s): Section flag %s (0x%x) ignored"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB (%s): section flag %s (%#lx) ignored"),
abfd, name, unhandled, flag);
- result = FALSE;
+ result = false;
}
}
+ if ((bfd_applicable_section_flags (abfd) & SEC_SMALL_DATA) != 0
+ && (startswith (name, ".sbss")
+ || startswith (name, ".sdata")))
+ sec_flags |= SEC_SMALL_DATA;
+
#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
/* As a GNU extension, if the name begins with .gnu.linkonce, we
only link a single copy of the section. This is used to support
The symbols will be defined as weak, so that multiple definitions
are permitted. The GNU linker extension is to actually discard
all but one of the sections. */
- if (CONST_STRNEQ (name, ".gnu.linkonce"))
+ if (startswith (name, ".gnu.linkonce"))
sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
#endif
. COFF_SYMBOL_PE_SECTION
.};
.
+.typedef asection * (*coff_gc_mark_hook_fn)
+. (asection *, struct bfd_link_info *, struct internal_reloc *,
+. struct coff_link_hash_entry *, struct internal_syment *);
+.
Special entry points for gdb to swap in coff symbol table parts:
.typedef struct
.{
. unsigned int _bfd_relsz;
. unsigned int _bfd_linesz;
. unsigned int _bfd_filnmlen;
-. bfd_boolean _bfd_coff_long_filenames;
+. bool _bfd_coff_long_filenames;
.
-. bfd_boolean _bfd_coff_long_section_names;
-. bfd_boolean (*_bfd_coff_set_long_section_names)
+. bool _bfd_coff_long_section_names;
+. bool (*_bfd_coff_set_long_section_names)
. (bfd *, int);
.
. unsigned int _bfd_coff_default_section_alignment_power;
-. bfd_boolean _bfd_coff_force_symnames_in_strings;
+. bool _bfd_coff_force_symnames_in_strings;
. unsigned int _bfd_coff_debug_string_prefix_length;
. unsigned int _bfd_coff_max_nscns;
.
. void (*_bfd_coff_swap_reloc_in)
. (bfd *abfd, void *, void *);
.
-. bfd_boolean (*_bfd_coff_bad_format_hook)
+. bool (*_bfd_coff_bad_format_hook)
. (bfd *, void *);
.
-. bfd_boolean (*_bfd_coff_set_arch_mach_hook)
+. bool (*_bfd_coff_set_arch_mach_hook)
. (bfd *, void *);
.
. void * (*_bfd_coff_mkobject_hook)
. (bfd *, void *, void *);
.
-. bfd_boolean (*_bfd_styp_to_sec_flags_hook)
+. bool (*_bfd_styp_to_sec_flags_hook)
. (bfd *, void *, const char *, asection *, flagword *);
.
. void (*_bfd_set_alignment_hook)
. (bfd *, asection *, void *);
.
-. bfd_boolean (*_bfd_coff_slurp_symbol_table)
+. bool (*_bfd_coff_slurp_symbol_table)
. (bfd *);
.
-. bfd_boolean (*_bfd_coff_symname_in_debug)
+. bool (*_bfd_coff_symname_in_debug)
. (bfd *, struct internal_syment *);
.
-. bfd_boolean (*_bfd_coff_pointerize_aux_hook)
+. bool (*_bfd_coff_pointerize_aux_hook)
. (bfd *, combined_entry_type *, combined_entry_type *,
-. unsigned int, combined_entry_type *);
+. unsigned int, combined_entry_type *);
.
-. bfd_boolean (*_bfd_coff_print_aux)
+. bool (*_bfd_coff_print_aux)
. (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
-. combined_entry_type *, unsigned int);
+. combined_entry_type *, unsigned int);
.
. void (*_bfd_coff_reloc16_extra_cases)
. (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
-. bfd_byte *, unsigned int *, unsigned int *);
+. bfd_byte *, unsigned int *, unsigned int *);
.
. int (*_bfd_coff_reloc16_estimate)
. (bfd *, asection *, arelent *, unsigned int,
-. struct bfd_link_info *);
+. struct bfd_link_info *);
.
. enum coff_symbol_classification (*_bfd_coff_classify_symbol)
. (bfd *, struct internal_syment *);
.
-. bfd_boolean (*_bfd_coff_compute_section_file_positions)
+. bool (*_bfd_coff_compute_section_file_positions)
. (bfd *);
.
-. bfd_boolean (*_bfd_coff_start_final_link)
+. bool (*_bfd_coff_start_final_link)
. (bfd *, struct bfd_link_info *);
.
-. bfd_boolean (*_bfd_coff_relocate_section)
+. bool (*_bfd_coff_relocate_section)
. (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
-. struct internal_reloc *, struct internal_syment *, asection **);
+. struct internal_reloc *, struct internal_syment *, asection **);
.
. reloc_howto_type *(*_bfd_coff_rtype_to_howto)
. (bfd *, asection *, struct internal_reloc *,
-. struct coff_link_hash_entry *, struct internal_syment *,
-. bfd_vma *);
+. struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
.
-. bfd_boolean (*_bfd_coff_adjust_symndx)
+. bool (*_bfd_coff_adjust_symndx)
. (bfd *, struct bfd_link_info *, bfd *, asection *,
-. struct internal_reloc *, bfd_boolean *);
+. struct internal_reloc *, bool *);
.
-. bfd_boolean (*_bfd_coff_link_add_one_symbol)
+. bool (*_bfd_coff_link_add_one_symbol)
. (struct bfd_link_info *, bfd *, const char *, flagword,
-. asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
-. struct bfd_link_hash_entry **);
+. asection *, bfd_vma, const char *, bool, bool,
+. struct bfd_link_hash_entry **);
.
-. bfd_boolean (*_bfd_coff_link_output_has_begun)
+. bool (*_bfd_coff_link_output_has_begun)
. (bfd *, struct coff_final_link_info *);
.
-. bfd_boolean (*_bfd_coff_final_link_postscript)
+. bool (*_bfd_coff_final_link_postscript)
. (bfd *, struct coff_final_link_info *);
.
-. bfd_boolean (*_bfd_coff_print_pdata)
+. bool (*_bfd_coff_print_pdata)
. (bfd *, void *);
.
.} bfd_coff_backend_data;
. (abfd, file, base, symbol, aux, indaux))
.
.#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
-. reloc, data, src_ptr, dst_ptr)\
+. reloc, data, src_ptr, dst_ptr)\
. ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
. (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
.
. ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
. (obfd, info, ibfd, sec, rel, adjustedp))
.#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
-. value, string, cp, coll, hashp)\
+. value, string, cp, coll, hashp)\
. ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
. (info, abfd, name, flags, section, value, string, cp, coll, hashp))
.
.{* 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-"))
+. (startswith ((abfd)->xvec->name, "pei-"))
*/
/* See whether the magic number matches. */
-static bfd_boolean
+static bool
coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (BADMAG (*internal_f))
- return FALSE;
-
- /* If the optional header is NULL or not the correct size then
- quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
- and Intel 960 readwrite headers (I960WRMAGIC) is that the
- optional header is of a different size.
-
- But the mips keeps extra stuff in it's opthdr, so dont check
- when doing that. */
-
-#if defined(M88) || defined(I960)
- if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
- return FALSE;
-#endif
+ return false;
- return TRUE;
+ return true;
}
#ifdef TICOFF
-static bfd_boolean
+static bool
ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (COFF0_BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#endif
#ifdef TICOFF
-static bfd_boolean
+static bool
ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (COFF1_BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#endif
for (i = 0; i < table_size; ++i)
{
- const char *secname = bfd_get_section_name (abfd, section);
+ const char *secname = bfd_section_name (section);
if (alignment_table[i].comparison_length == (unsigned int) -1
? strcmp (alignment_table[i].name, secname) == 0
/* Initialize a section structure with information peculiar to this
particular implementation of COFF. */
-static bfd_boolean
+static bool
coff_new_section_hook (bfd * abfd, asection * section)
{
combined_entry_type *native;
- bfd_size_type amt;
+ size_t amt;
unsigned char sclass = C_STAT;
section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
#ifdef RS6000COFF_C
if (bfd_xcoff_text_align_power (abfd) != 0
- && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
+ && strcmp (bfd_section_name (section), ".text") == 0)
section->alignment_power = bfd_xcoff_text_align_power (abfd);
else if (bfd_xcoff_data_align_power (abfd) != 0
- && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
+ && strcmp (bfd_section_name (section), ".data") == 0)
section->alignment_power = bfd_xcoff_data_align_power (abfd);
else
{
int i;
for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
- if (strcmp (bfd_get_section_name (abfd, section),
- xcoff_dwsect_names[i].name) == 0)
- {
- section->alignment_power = 0;
- sclass = C_DWARF;
- break;
- }
+ if (strcmp (bfd_section_name (section),
+ xcoff_dwsect_names[i].name) == 0)
+ {
+ section->alignment_power = 0;
+ sclass = C_DWARF;
+ break;
+ }
}
#endif
/* Set up the section symbol. */
if (!_bfd_generic_new_section_hook (abfd, section))
- return FALSE;
+ return false;
/* Allocate aux records for section symbols, to store size and
related info.
amt = sizeof (combined_entry_type) * 10;
native = (combined_entry_type *) bfd_zalloc (abfd, amt);
if (native == NULL)
- return FALSE;
+ return false;
/* 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
in case this symbol winds up getting written out. The value 0
for n_numaux is already correct. */
+ native->is_sym = true;
native->u.syment.n_type = T_NULL;
native->u.syment.n_sclass = sclass;
coff_section_alignment_table,
coff_section_alignment_table_size);
- return TRUE;
+ return true;
}
#ifdef COFF_ALIGN_IN_SECTION_HEADER
struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
unsigned int i;
-#ifdef I960
- /* Extract ALIGN from 2**ALIGN stored in section header. */
- for (i = 0; i < 32; i++)
- if ((1 << i) >= hdr->s_align)
- break;
-#endif
-#ifdef TIC80COFF
- /* TI tools puts the alignment power in bits 8-11. */
- i = (hdr->s_flags >> 8) & 0xF ;
-#endif
#ifdef COFF_DECODE_ALIGNMENT
i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
#endif
void * scnhdr)
{
struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
- bfd_size_type amt;
+ size_t amt;
unsigned int alignment_power_const
= hdr->s_flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK;
section->rel_filepos += relsz;
}
else if (hdr->s_nreloc == 0xffff)
- (*_bfd_error_handler)
- ("%s: warning: claims to have 0xffff relocs, without overflow",
- bfd_get_filename (abfd));
+ _bfd_error_handler
+ (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
+ abfd);
}
#undef ALIGN_SET
#undef ELIFALIGN_SET
}
#else /* ! RS6000COFF_C */
+#if defined (COFF_GO32_EXE) || defined (COFF_GO32)
+
+static void
+coff_set_alignment_hook (bfd * abfd, asection * section, void * scnhdr)
+{
+ struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
+
+ /* Check for extended relocs. */
+ if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
+ {
+ struct external_reloc dst;
+ struct internal_reloc n;
+ const file_ptr oldpos = bfd_tell (abfd);
+ const bfd_size_type relsz = bfd_coff_relsz (abfd);
+
+ if (bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0) != 0)
+ return;
+ if (bfd_bread (& dst, relsz, abfd) != relsz)
+ return;
+
+ coff_swap_reloc_in (abfd, &dst, &n);
+ if (bfd_seek (abfd, oldpos, 0) != 0)
+ return;
+ section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
+ section->rel_filepos += relsz;
+ }
+ else if (hdr->s_nreloc == 0xffff)
+ _bfd_error_handler
+ (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
+ abfd);
+}
+
+#else /* ! COFF_GO32_EXE && ! COFF_GO32 */
-#define coff_set_alignment_hook \
- ((void (*) (bfd *, asection *, void *)) bfd_void)
+static void
+coff_set_alignment_hook (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *section ATTRIBUTE_UNUSED,
+ void *scnhdr ATTRIBUTE_UNUSED)
+{
+}
+#endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
#endif /* ! RS6000COFF_C */
#endif /* ! COFF_WITH_PE */
#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
#ifndef coff_mkobject
-static bfd_boolean
+static bool
coff_mkobject (bfd * abfd)
{
coff_data_type *coff;
- bfd_size_type amt = sizeof (coff_data_type);
+ size_t amt = sizeof (coff_data_type);
abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
if (abfd->tdata.coff_obj_data == NULL)
- return FALSE;
+ return false;
coff = coff_data (abfd);
coff->symbols = NULL;
coff->conversion_table = NULL;
/* make_abs_section(abfd);*/
- return TRUE;
+ return true;
}
#endif
# else
xcoff->xcoff64 = 0;
# endif
- xcoff->full_aouthdr = TRUE;
+ xcoff->full_aouthdr = true;
xcoff->toc = internal_a->o_toc;
xcoff->sntoc = internal_a->o_sntoc;
xcoff->snentry = internal_a->o_snentry;
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
would be target independent and would also be much more successful
at linking together COFF files for different architectures. */
-static bfd_boolean
+static bool
coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
{
unsigned long machine;
machine = 0;
switch (internal_f->f_magic)
{
-#ifdef OR32_MAGIC_BIG
- case OR32_MAGIC_BIG:
- case OR32_MAGIC_LITTLE:
- arch = bfd_arch_or32;
- break;
-#endif
-#ifdef PPCMAGIC
- case PPCMAGIC:
- arch = bfd_arch_powerpc;
- break;
-#endif
#ifdef I386MAGIC
case I386MAGIC:
case I386PTXMAGIC:
case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */
- case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */
+ case LYNXCOFFMAGIC:
+ case I386_APPLE_MAGIC:
+ case I386_FREEBSD_MAGIC:
+ case I386_LINUX_MAGIC:
+ case I386_NETBSD_MAGIC:
arch = bfd_arch_i386;
break;
#endif
#ifdef AMD64MAGIC
case AMD64MAGIC:
+ case AMD64_APPLE_MAGIC:
+ case AMD64_FREEBSD_MAGIC:
+ case AMD64_LINUX_MAGIC:
+ case AMD64_NETBSD_MAGIC:
arch = bfd_arch_i386;
machine = bfd_mach_x86_64;
break;
}
break;
#endif
-#ifdef MC68MAGIC
- case MC68MAGIC:
- case M68MAGIC:
-#ifdef MC68KBCSMAGIC
- case MC68KBCSMAGIC:
-#endif
-#ifdef APOLLOM68KMAGIC
- case APOLLOM68KMAGIC:
-#endif
-#ifdef LYNXCOFFMAGIC
- case LYNXCOFFMAGIC:
-#endif
- arch = bfd_arch_m68k;
- machine = bfd_mach_m68020;
- break;
-#endif
-#ifdef MC88MAGIC
- case MC88MAGIC:
- case MC88DMAGIC:
- case MC88OMAGIC:
- arch = bfd_arch_m88k;
- machine = 88100;
- break;
-#endif
#ifdef Z80MAGIC
case Z80MAGIC:
arch = bfd_arch_z80;
switch (internal_f->f_flags & F_MACHMASK)
{
- case 0:
case bfd_mach_z80strict << 12:
case bfd_mach_z80 << 12:
+ case bfd_mach_z80n << 12:
case bfd_mach_z80full << 12:
case bfd_mach_r800 << 12:
+ case bfd_mach_gbz80 << 12:
+ case bfd_mach_z180 << 12:
+ case bfd_mach_ez80_z80 << 12:
+ case bfd_mach_ez80_adl << 12:
machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
break;
default:
- return FALSE;
+ return false;
}
break;
#endif
machine = bfd_mach_z8002;
break;
default:
- return FALSE;
- }
- break;
-#endif
-#ifdef I860
- case I860MAGIC:
- arch = bfd_arch_i860;
- break;
-#endif
-#ifdef I960
-#ifdef I960ROMAGIC
- case I960ROMAGIC:
- case I960RWMAGIC:
- arch = bfd_arch_i960;
- switch (F_I960TYPE & internal_f->f_flags)
- {
- default:
- case F_I960CORE:
- machine = bfd_mach_i960_core;
- break;
- case F_I960KB:
- machine = bfd_mach_i960_kb_sb;
- break;
- case F_I960MC:
- machine = bfd_mach_i960_mc;
- break;
- case F_I960XA:
- machine = bfd_mach_i960_xa;
- break;
- case F_I960CA:
- machine = bfd_mach_i960_ca;
- break;
- case F_I960KA:
- machine = bfd_mach_i960_ka_sa;
- break;
- case F_I960JX:
- machine = bfd_mach_i960_jx;
- break;
- case F_I960HX:
- machine = bfd_mach_i960_hx;
- break;
+ return false;
}
break;
#endif
-#endif
#ifdef RS6000COFF_C
#ifdef XCOFF64
struct internal_syment sym;
bfd_size_type amt = bfd_coff_symesz (abfd);
- buf = bfd_malloc (amt);
- if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
- || bfd_bread (buf, amt, abfd) != amt)
- {
- free (buf);
- return FALSE;
- }
+ if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
+ return false;
+ buf = _bfd_malloc_and_read (abfd, amt, amt);
+ if (buf == NULL)
+ return false;
bfd_coff_swap_sym_in (abfd, buf, & sym);
if (sym.n_sclass == C_FILE)
cputype = sym.n_type & 0xff;
break;
#endif
-#ifdef WE32KMAGIC
- case WE32KMAGIC:
- arch = bfd_arch_we32k;
- break;
-#endif
-
-#ifdef H8300MAGIC
- case H8300MAGIC:
- arch = bfd_arch_h8300;
- machine = bfd_mach_h8300;
- /* !! FIXME this probably isn't the right place for this. */
- abfd->flags |= BFD_IS_RELAXABLE;
- break;
-#endif
-
-#ifdef H8300HMAGIC
- case H8300HMAGIC:
- arch = bfd_arch_h8300;
- machine = bfd_mach_h8300h;
- /* !! FIXME this probably isn't the right place for this. */
- abfd->flags |= BFD_IS_RELAXABLE;
- break;
-#endif
-
-#ifdef H8300SMAGIC
- case H8300SMAGIC:
- arch = bfd_arch_h8300;
- machine = bfd_mach_h8300s;
- /* !! FIXME this probably isn't the right place for this. */
- abfd->flags |= BFD_IS_RELAXABLE;
- break;
-#endif
-
-#ifdef H8300HNMAGIC
- case H8300HNMAGIC:
- arch = bfd_arch_h8300;
- machine = bfd_mach_h8300hn;
- /* !! FIXME this probably isn't the right place for this. */
- abfd->flags |= BFD_IS_RELAXABLE;
- break;
-#endif
-
-#ifdef H8300SNMAGIC
- case H8300SNMAGIC:
- arch = bfd_arch_h8300;
- machine = bfd_mach_h8300sn;
- /* !! FIXME this probably isn't the right place for this. */
- abfd->flags |= BFD_IS_RELAXABLE;
- break;
-#endif
-
#ifdef SH_ARCH_MAGIC_BIG
case SH_ARCH_MAGIC_BIG:
case SH_ARCH_MAGIC_LITTLE:
break;
#endif
-#ifdef H8500MAGIC
- case H8500MAGIC:
- arch = bfd_arch_h8500;
- break;
-#endif
-
#ifdef SPARCMAGIC
case SPARCMAGIC:
#ifdef LYNXCOFFMAGIC
#endif
default:
arch = bfd_arch_obscure;
- (*_bfd_error_handler)
- (_("Unrecognized TI COFF target id '0x%x'"),
+ _bfd_error_handler
+ (_("unrecognized TI COFF target id '0x%x'"),
internal_f->f_target_id);
break;
}
break;
#endif
-#ifdef TIC80_ARCH_MAGIC
- case TIC80_ARCH_MAGIC:
- arch = bfd_arch_tic80;
- break;
-#endif
-
#ifdef MCOREMAGIC
case MCOREMAGIC:
arch = bfd_arch_mcore;
break;
#endif
-#ifdef W65MAGIC
- case W65MAGIC:
- arch = bfd_arch_w65;
- break;
-#endif
-
default: /* Unreadable input file type. */
arch = bfd_arch_obscure;
break;
}
bfd_default_set_arch_mach (abfd, arch, machine);
- return TRUE;
+ return true;
}
-#ifdef SYMNAME_IN_DEBUG
-
-static bfd_boolean
-symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
+static bool
+symname_in_debug_hook (bfd *abfd ATTRIBUTE_UNUSED,
+ struct internal_syment *sym ATTRIBUTE_UNUSED)
{
+#ifdef SYMNAME_IN_DEBUG
return SYMNAME_IN_DEBUG (sym) != 0;
-}
-
#else
-
-#define symname_in_debug_hook \
- (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
-
+ return false;
#endif
+}
#ifdef RS6000COFF_C
/* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
-static bfd_boolean
+static bool
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
combined_entry_type *table_base,
combined_entry_type *symbol,
unsigned int indaux,
combined_entry_type *aux)
{
+ BFD_ASSERT (symbol->is_sym);
int n_sclass = symbol->u.syment.n_sclass;
if (CSECT_SYM_P (n_sclass)
&& indaux + 1 == symbol->u.syment.n_numaux)
{
+ BFD_ASSERT (! aux->is_sym);
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
{
aux->u.auxent.x_csect.x_scnlen.p =
/* Return TRUE to indicate that the caller should not do any
further work on this auxent. */
- return TRUE;
+ return true;
}
/* Return FALSE to indicate that this auxent should be handled by
the caller. */
- return FALSE;
+ return false;
}
#else
-#ifdef I960
-
-/* We don't want to pointerize bal entries. */
-
-static bfd_boolean
-coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
- combined_entry_type *table_base ATTRIBUTE_UNUSED,
- combined_entry_type *symbol,
- unsigned int indaux,
- combined_entry_type *aux ATTRIBUTE_UNUSED)
-{
- /* Return TRUE if we don't want to pointerize this aux entry, which
- is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
- return (indaux == 1
- && (symbol->u.syment.n_sclass == C_LEAFPROC
- || symbol->u.syment.n_sclass == C_LEAFSTAT
- || symbol->u.syment.n_sclass == C_LEAFEXT));
-}
-
-#else /* ! I960 */
-
#define coff_pointerize_aux_hook 0
-
-#endif /* ! I960 */
#endif /* ! RS6000COFF_C */
/* Print an aux entry. This returns TRUE if it has printed it. */
-static bfd_boolean
+static bool
coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
FILE *file ATTRIBUTE_UNUSED,
combined_entry_type *table_base ATTRIBUTE_UNUSED,
combined_entry_type *aux ATTRIBUTE_UNUSED,
unsigned int indaux ATTRIBUTE_UNUSED)
{
+ BFD_ASSERT (symbol->is_sym);
+ BFD_ASSERT (! aux->is_sym);
#ifdef RS6000COFF_C
if (CSECT_SYM_P (symbol->u.syment.n_sclass)
&& indaux + 1 == symbol->u.syment.n_numaux)
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
{
BFD_ASSERT (! aux->fix_scnlen);
-#ifdef XCOFF64
- fprintf (file, "val %5lld",
- (long long) aux->u.auxent.x_csect.x_scnlen.l);
-#else
- fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
-#endif
+ fprintf (file, "val %5" BFD_VMA_FMT "d",
+ aux->u.auxent.x_csect.x_scnlen.l);
}
else
{
fprintf (file, "indx ");
if (! aux->fix_scnlen)
-#ifdef XCOFF64
- fprintf (file, "%4lld",
- (long long) aux->u.auxent.x_csect.x_scnlen.l);
-#else
- fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
-#endif
+ fprintf (file, "%4" BFD_VMA_FMT "d",
+ aux->u.auxent.x_csect.x_scnlen.l);
else
fprintf (file, "%4ld",
(long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
(unsigned int) aux->u.auxent.x_csect.x_smclas,
aux->u.auxent.x_csect.x_stab,
(unsigned int) aux->u.auxent.x_csect.x_snstab);
- return TRUE;
+ return true;
}
#endif
/* Return FALSE to indicate that no special action was taken. */
- return FALSE;
+ return false;
}
/*
#endif /* TARG_AUX */
-static bfd_boolean
+static bool
coff_write_relocs (bfd * abfd, int first_undef)
{
asection *s;
amt = s->reloc_count;
amt *= sizeof (arelent *);
p = bfd_malloc (amt);
- if (p == NULL && s->reloc_count > 0)
- return FALSE;
- memcpy (p, s->orelocation, (size_t) amt);
- qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
+ if (p == NULL)
+ {
+ if (s->reloc_count > 0)
+ return false;
+ }
+ else
+ {
+ memcpy (p, s->orelocation, (size_t) amt);
+ qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
+ }
}
#endif
if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
- return FALSE;
+ return false;
-#ifdef COFF_WITH_PE
- if (obj_pe (abfd) && s->reloc_count >= 0xffff)
+#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
+ if ((obj_pe (abfd) || obj_go32 (abfd)) && s->reloc_count >= 0xffff)
{
/* Encode real count here as first reloc. */
struct internal_reloc n;
coff_swap_reloc_out (abfd, &n, &dst);
if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
abfd) != bfd_coff_relsz (abfd))
- return FALSE;
+ return false;
}
#endif
if (n.r_symndx > obj_conv_table_size (abfd))
{
bfd_set_error (bfd_error_bad_value);
- _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: reloc against a non-existent"
+ " symbol index: %ld"),
abfd, n.r_symndx);
- return FALSE;
+ return false;
}
}
}
if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
abfd) != bfd_coff_relsz (abfd))
- return FALSE;
+ return false;
}
#ifdef TARG_AUX
- if (p != NULL)
- free (p);
+ free (p);
#endif
}
- return TRUE;
+ return true;
}
/* Set flags and magic number of a coff file from architecture and machine
type. Result is TRUE if we can represent the arch&type, FALSE if not. */
-static bfd_boolean
+static bool
coff_set_flags (bfd * abfd,
unsigned int *magicp ATTRIBUTE_UNUSED,
unsigned short *flagsp ATTRIBUTE_UNUSED)
*magicp = Z80MAGIC;
switch (bfd_get_mach (abfd))
{
- case 0:
case bfd_mach_z80strict:
case bfd_mach_z80:
+ case bfd_mach_z80n:
case bfd_mach_z80full:
case bfd_mach_r800:
+ case bfd_mach_gbz80:
+ case bfd_mach_z180:
+ case bfd_mach_ez80_z80:
+ case bfd_mach_ez80_adl:
*flagsp = bfd_get_mach (abfd) << 12;
break;
default:
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
#endif
#ifdef Z8KMAGIC
{
case bfd_mach_z8001: *flagsp = F_Z8001; break;
case bfd_mach_z8002: *flagsp = F_Z8002; break;
- default: return FALSE;
+ default: return false;
}
- return TRUE;
-#endif
-
-#ifdef I960ROMAGIC
- case bfd_arch_i960:
-
- {
- unsigned flags;
-
- *magicp = I960ROMAGIC;
-
- switch (bfd_get_mach (abfd))
- {
- case bfd_mach_i960_core: flags = F_I960CORE; break;
- case bfd_mach_i960_kb_sb: flags = F_I960KB; break;
- case bfd_mach_i960_mc: flags = F_I960MC; break;
- case bfd_mach_i960_xa: flags = F_I960XA; break;
- case bfd_mach_i960_ca: flags = F_I960CA; break;
- 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;
- }
- *flagsp = flags;
- return TRUE;
- }
- break;
+ return true;
#endif
#ifdef TIC30MAGIC
case bfd_arch_tic30:
*magicp = TIC30MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef TICOFF_DEFAULT_MAGIC
*magicp = TICOFF2MAGIC;
break;
default:
- return FALSE;
+ return false;
}
}
TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
- return TRUE;
-#endif
-
-#ifdef TIC80_ARCH_MAGIC
- case bfd_arch_tic80:
- *magicp = TIC80_ARCH_MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef ARMMAGIC
case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
}
- return TRUE;
-#endif
-
-#ifdef PPCMAGIC
- case bfd_arch_powerpc:
- *magicp = PPCMAGIC;
- return TRUE;
+ return true;
#endif
#if defined(I386MAGIC) || defined(AMD64MAGIC)
#if defined AMD64MAGIC
*magicp = AMD64MAGIC;
#endif
- return TRUE;
-#endif
-
-#ifdef I860MAGIC
- case bfd_arch_i860:
- *magicp = I860MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef IA64MAGIC
case bfd_arch_ia64:
*magicp = IA64MAGIC;
- return TRUE;
-#endif
-
-#ifdef MC68MAGIC
- case bfd_arch_m68k:
-#ifdef APOLLOM68KMAGIC
- *magicp = APOLLO_COFF_VERSION_NUMBER;
-#else
- /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
-#ifdef NAMES_HAVE_UNDERSCORE
- *magicp = MC68KBCSMAGIC;
-#else
- *magicp = MC68MAGIC;
-#endif
-#endif
-#ifdef LYNXOS
- /* Just overwrite the usual value if we're doing Lynx. */
- *magicp = LYNXCOFFMAGIC;
-#endif
- return TRUE;
-#endif
-
-#ifdef MC88MAGIC
- case bfd_arch_m88k:
- *magicp = MC88OMAGIC;
- return TRUE;
-#endif
-
-#ifdef H8300MAGIC
- case bfd_arch_h8300:
- switch (bfd_get_mach (abfd))
- {
- case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE;
- case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE;
- case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE;
- case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
- case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
- default: break;
- }
- break;
+ return true;
#endif
#ifdef SH_ARCH_MAGIC_BIG
else
*magicp = SH_ARCH_MAGIC_LITTLE;
#endif
- return TRUE;
+ return true;
#endif
#ifdef MIPS_ARCH_MAGIC_WINCE
case bfd_arch_mips:
*magicp = MIPS_ARCH_MAGIC_WINCE;
- return TRUE;
+ return true;
#endif
#ifdef SPARCMAGIC
/* Just overwrite the usual value if we're doing Lynx. */
*magicp = LYNXCOFFMAGIC;
#endif
- return TRUE;
-#endif
-
-#ifdef H8500MAGIC
- case bfd_arch_h8500:
- *magicp = H8500MAGIC;
- return TRUE;
- break;
-#endif
-
-#ifdef WE32KMAGIC
- case bfd_arch_we32k:
- *magicp = WE32KMAGIC;
- return TRUE;
+ return true;
#endif
#ifdef RS6000COFF_C
case bfd_arch_rs6000:
-#ifndef PPCMAGIC
case bfd_arch_powerpc:
-#endif
BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
*magicp = bfd_xcoff_magic_number (abfd);
- return TRUE;
+ return true;
#endif
#ifdef MCOREMAGIC
case bfd_arch_mcore:
* magicp = MCOREMAGIC;
- return TRUE;
-#endif
-
-#ifdef W65MAGIC
- case bfd_arch_w65:
- *magicp = W65MAGIC;
- return TRUE;
-#endif
-
-#ifdef OR32_MAGIC_BIG
- case bfd_arch_or32:
- if (bfd_big_endian (abfd))
- * magicp = OR32_MAGIC_BIG;
- else
- * magicp = OR32_MAGIC_LITTLE;
- return TRUE;
+ return true;
#endif
default: /* Unknown architecture. */
- /* Fall through to "return FALSE" below, to avoid
- "statement never reached" errors on the one below. */
break;
}
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
coff_set_arch_mach (bfd * abfd,
enum bfd_architecture arch,
unsigned long machine)
unsigned short dummy2;
if (! bfd_default_set_arch_mach (abfd, arch, machine))
- return FALSE;
+ return false;
if (arch != bfd_arch_unknown
&& ! coff_set_flags (abfd, &dummy1, &dummy2))
- return FALSE; /* We can't represent this type. */
+ return false; /* We can't represent this type. */
- return TRUE; /* We're easy... */
+ return true; /* We're easy... */
}
#ifdef COFF_IMAGE_WITH_PE
/* Calculate the file position for each section. */
-#ifndef I960
#define ALIGN_SECTIONS_IN_FILE
-#endif
-#if defined(TIC80COFF) || defined(TICOFF)
+#ifdef TICOFF
#undef ALIGN_SECTIONS_IN_FILE
#endif
-static bfd_boolean
+static bool
coff_compute_section_file_positions (bfd * abfd)
{
asection *current;
file_ptr sofar = bfd_coff_filhsz (abfd);
- bfd_boolean align_adjust;
+ bool align_adjust;
unsigned int target_index;
#ifdef ALIGN_SECTIONS_IN_FILE
asection *previous = NULL;
#ifdef COFF_IMAGE_WITH_PE
int page_size;
- if (coff_data (abfd)->link_info)
+ if (coff_data (abfd)->link_info
+ || (pe_data (abfd) && pe_data (abfd)->pe_opthdr.FileAlignment))
{
page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
This repairs 'ld -r' for arm-wince-pe target. */
if (page_size == 0)
page_size = 1;
+
+ /* PR 17512: file: 0ac816d3. */
+ if (page_size < 0)
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: page size is too large (0x%x)"), abfd, page_size);
+ return false;
+ }
}
else
page_size = PE_DEF_FILE_ALIGNMENT;
{
coff_symbol_type *cf;
- cf = coff_symbol_from (abfd, *symp);
+ cf = coff_symbol_from (*symp);
if (cf != NULL
&& cf->native != NULL
+ && cf->native->is_sym
&& SYMNAME_IN_DEBUG (&cf->native->u.syment))
{
size_t len;
amt = sizeof (struct asection *) * (count + 1);
section_list = (asection **) bfd_malloc (amt);
if (section_list == NULL)
- return FALSE;
+ return false;
i = 0;
for (current = abfd->sections; current != NULL; current = current->next)
if (target_index >= bfd_coff_max_nscns (abfd))
{
bfd_set_error (bfd_error_file_too_big);
- (*_bfd_error_handler)
- (_("%B: too many sections (%d)"), abfd, target_index);
- return FALSE;
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: too many sections (%d)"), abfd, target_index);
+ return false;
}
- align_adjust = FALSE;
+ align_adjust = false;
for (current = abfd->sections;
current != NULL;
current = current->next)
page size too, and remember both sizes. */
if (coff_section_data (abfd, current) == NULL)
{
- bfd_size_type amt = sizeof (struct coff_section_tdata);
+ size_t amt = sizeof (struct coff_section_tdata);
current->used_by_bfd = bfd_zalloc (abfd, amt);
if (current->used_by_bfd == NULL)
- return FALSE;
+ return false;
}
if (pei_section_data (abfd, current) == NULL)
{
- bfd_size_type amt = sizeof (struct pei_section_tdata);
+ size_t amt = sizeof (struct pei_section_tdata);
coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
if (coff_section_data (abfd, current)->tdata == NULL)
- return FALSE;
+ return false;
}
if (pei_section_data (abfd, current)->virt_size == 0)
pei_section_data (abfd, current)->virt_size = current->size;
#endif
/* Align the sections in the file to the same boundary on
- which they are aligned in virtual memory. I960 doesn't
- do this (FIXME) so we can stay in sync with Intel. 960
- doesn't yet page from files... */
+ which they are aligned in virtual memory. */
#ifdef ALIGN_SECTIONS_IN_FILE
if ((abfd->flags & EXEC_P) != 0)
{
and the native linker doesn't try to align the text sections.
For example:
- 0 .text 000054cc 10000128 10000128 00000128 2**5
- CONTENTS, ALLOC, LOAD, CODE
+ 0 .text 000054cc 10000128 10000128 00000128 2**5
+ CONTENTS, ALLOC, LOAD, CODE
+
+ Don't perform the above tweak if the previous one is .tdata,
+ as it will increase the memory allocated for every threads
+ created and not just improve performances with gdb.
*/
- if (!strcmp (current->name, _TEXT)
- || !strcmp (current->name, _DATA))
+ if ((!strcmp (current->name, _TEXT)
+ || !strcmp (current->name, _DATA))
+ && (previous == NULL || strcmp(previous->name, _TDATA)))
{
bfd_vma align = 4096;
bfd_vma sofar_off = sofar % align;
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;
+ align_adjust = true;
#endif
#ifdef _LIB
incremented in coff_set_section_contents. This is right for
SVR3.2. */
if (strcmp (current->name, _LIB) == 0)
- (void) bfd_set_section_vma (abfd, current, 0);
+ bfd_set_section_vma (current, 0);
#endif
#ifdef ALIGN_SECTIONS_IN_FILE
b = 0;
if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
|| bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
- return FALSE;
+ return false;
}
/* Make sure the relocations are aligned. We don't need to make
sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
obj_relocbase (abfd) = sofar;
- abfd->output_has_begun = TRUE;
+ abfd->output_has_begun = true;
- return TRUE;
+ return true;
}
#ifdef COFF_IMAGE_WITH_PE
-static unsigned int pelength;
-static unsigned int peheader;
-
-static bfd_boolean
-coff_read_word (bfd *abfd, unsigned int *value)
+static bool
+coff_read_word (bfd *abfd, unsigned int *value, unsigned int *pelength)
{
unsigned char b[2];
int status;
if (status < 1)
{
*value = 0;
- return FALSE;
+ return false;
}
if (status == 1)
else
*value = (unsigned int) (b[0] + (b[1] << 8));
- pelength += (unsigned int) status;
+ *pelength += status;
- return TRUE;
+ return true;
}
static unsigned int
-coff_compute_checksum (bfd *abfd)
+coff_compute_checksum (bfd *abfd, unsigned int *pelength)
{
- bfd_boolean more_data;
+ bool more_data;
file_ptr filepos;
unsigned int value;
unsigned int total;
total = 0;
- pelength = 0;
+ *pelength = 0;
filepos = (file_ptr) 0;
do
if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
return 0;
- more_data = coff_read_word (abfd, &value);
+ more_data = coff_read_word (abfd, &value, pelength);
total += value;
total = 0xffff & (total + (total >> 0x10));
filepos += 2;
return (0xffff & (total + (total >> 0x10)));
}
-static bfd_boolean
+static bool
coff_apply_checksum (bfd *abfd)
{
unsigned int computed;
unsigned int checksum = 0;
+ unsigned int peheader;
+ unsigned int pelength;
if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
- return FALSE;
+ return false;
- if (!coff_read_word (abfd, &peheader))
- return FALSE;
+ if (!coff_read_word (abfd, &peheader, &pelength))
+ return false;
if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
- return FALSE;
+ return false;
checksum = 0;
bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
- return FALSE;
+ return false;
- computed = coff_compute_checksum (abfd);
+ computed = coff_compute_checksum (abfd, &pelength);
checksum = computed + pelength;
if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
- return FALSE;
+ return false;
bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
- return TRUE;
+ return true;
}
#endif /* COFF_IMAGE_WITH_PE */
-static bfd_boolean
+static bool
coff_write_object_contents (bfd * abfd)
{
asection *current;
- bfd_boolean hasrelocs = FALSE;
- bfd_boolean haslinno = FALSE;
+ bool hasrelocs = false;
+ bool haslinno = false;
#ifdef COFF_IMAGE_WITH_PE
- bfd_boolean hasdebug = FALSE;
+ bool hasdebug = false;
#endif
file_ptr scn_base;
file_ptr reloc_base;
file_ptr sym_base;
unsigned long reloc_size = 0, reloc_count = 0;
unsigned long lnno_size = 0;
- bfd_boolean long_section_names;
+ bool long_section_names;
asection *text_sec = NULL;
asection *data_sec = NULL;
asection *bss_sec = NULL;
+#ifdef RS6000COFF_C
+ asection *tdata_sec = NULL;
+ asection *tbss_sec = NULL;
+#endif
struct internal_filehdr internal_f;
struct internal_aouthdr internal_a;
#ifdef COFF_LONG_SECTION_NAMES
if (! abfd->output_has_begun)
{
if (! coff_compute_section_file_positions (abfd))
- return FALSE;
+ return false;
}
reloc_base = obj_relocbase (abfd);
for (current = abfd->sections; current != NULL; current =
current->next)
{
-#ifdef COFF_WITH_PE
+#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
/* We store the actual reloc count in the first reloc's addr. */
- if (obj_pe (abfd) && current->reloc_count >= 0xffff)
+ if ((obj_pe (abfd) || obj_go32 (abfd)) && current->reloc_count >= 0xffff)
reloc_count ++;
#endif
reloc_count += current->reloc_count;
{
current->rel_filepos = reloc_base;
reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
-#ifdef COFF_WITH_PE
+#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
/* Extra reloc to hold real count. */
- if (obj_pe (abfd) && current->reloc_count >= 0xffff)
+ if ((obj_pe (abfd) || obj_go32 (abfd)) && current->reloc_count >= 0xffff)
reloc_base += bfd_coff_relsz (abfd);
#endif
}
}
if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
- return FALSE;
+ return false;
- long_section_names = FALSE;
+ long_section_names = false;
for (current = abfd->sections;
current != NULL;
current = current->next)
{
struct internal_scnhdr section;
#ifdef COFF_IMAGE_WITH_PE
- bfd_boolean is_reloc_section = FALSE;
+ bool is_reloc_section = false;
if (strcmp (current->name, DOT_RELOC) == 0)
{
- is_reloc_section = TRUE;
- hasrelocs = TRUE;
+ is_reloc_section = true;
+ hasrelocs = true;
pe_data (abfd)->has_reloc_section = 1;
}
#endif
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];
+ /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
+ a possible buffer overflow. */
+ char s_name_buf[SCNNMLEN + 1 + 20];
/* An inherent limitation of the /nnnnnnn notation used to indicate
the offset of the long name in the string table is that we
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;
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: section %pA: string table overflow at offset %ld"),
+ abfd, current, (unsigned long) 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);
+ /* We do not need to use snprintf here as we have already verfied
+ that string_size is not too big, plus we have an overlarge
+ buffer, just in case. */
+ sprintf (s_name_buf, "/%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;
+ long_section_names = true;
}
}
#endif
#ifndef COFF_IMAGE_WITH_PE
/* In PEI, relocs come in the .reloc section. */
if (current->reloc_count != 0)
- hasrelocs = TRUE;
+ hasrelocs = true;
#endif
if (current->lineno_count != 0)
- haslinno = TRUE;
+ haslinno = true;
#ifdef COFF_IMAGE_WITH_PE
if ((current->flags & SEC_DEBUGGING) != 0
&& ! is_reloc_section)
- hasdebug = TRUE;
+ hasdebug = true;
#endif
#ifdef RS6000COFF_C
data_sec = current;
else if (!strcmp (current->name, _BSS))
bss_sec = current;
-
-#ifdef I960
- section.s_align = (current->alignment_power
- ? 1 << current->alignment_power
- : 0);
-#endif
-#ifdef TIC80COFF
- /* TI COFF puts the alignment power in bits 8-11 of the flags. */
- section.s_flags |= (current->alignment_power & 0xF) << 8;
+#ifdef RS6000COFF_C
+ else if (!strcmp (current->name, _TDATA))
+ tdata_sec = current;
+ else if (!strcmp (current->name, _TBSS))
+ tbss_sec = current;
#endif
+
+
#ifdef COFF_ENCODE_ALIGNMENT
- COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
+ if (COFF_ENCODE_ALIGNMENT (abfd, section, current->alignment_power)
+ && (COFF_DECODE_ALIGNMENT (section.s_flags)
+ != current->alignment_power))
+ {
+ bool warn = (coff_data (abfd)->link_info
+ && !bfd_link_relocatable (coff_data (abfd)->link_info));
+
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB:%s section %s: alignment 2**%u not representable"),
+ abfd, warn ? " warning:" : "", current->name,
+ current->alignment_power);
+ if (!warn)
+ {
+ bfd_set_error (bfd_error_nonrepresentable_section);
+ return false;
+ }
+ }
#endif
#ifdef COFF_IMAGE_WITH_PE
SCNHDR buff;
bfd_size_type amt = bfd_coff_scnhsz (abfd);
- if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
+ if (bfd_coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
|| bfd_bwrite (& buff, amt, abfd) != amt)
- return FALSE;
+ return false;
}
#ifdef COFF_WITH_PE
/* See if this is the section symbol. */
if (strcmp ((*psym)->name, current->name) == 0)
{
- csym = coff_symbol_from (abfd, *psym);
+ csym = coff_symbol_from (*psym);
if (csym == NULL
|| csym->native == NULL
+ || ! csym->native->is_sym
|| csym->native->u.syment.n_numaux < 1
|| csym->native->u.syment.n_sclass != C_STAT
|| csym->native->u.syment.n_type != T_NULL)
x_associated field is not currently supported. */
aux = csym->native + 1;
+ BFD_ASSERT (! aux->is_sym);
switch (current->flags & SEC_LINK_DUPLICATES)
{
case SEC_LINK_DUPLICATES_DISCARD:
scnhdr.s_nlnno = current->target_index;
scnhdr.s_flags = STYP_OVRFLO;
amt = bfd_coff_scnhsz (abfd);
- if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
+ if (bfd_coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
|| bfd_bwrite (& buff, amt, abfd) != amt)
- return FALSE;
+ return false;
}
}
#endif
#endif
+#if defined (COFF_GO32_EXE) || defined (COFF_GO32)
+ /* Pad section headers. */
+ if ((abfd->flags & EXEC_P) && abfd->sections != NULL)
+ {
+ file_ptr cur_ptr = scn_base
+ + abfd->section_count * bfd_coff_scnhsz (abfd);
+ long fill_size = (abfd->sections->filepos - cur_ptr);
+ bfd_byte *b = bfd_zmalloc (fill_size);
+ if (b)
+ {
+ bfd_bwrite ((PTR)b, fill_size, abfd);
+ free (b);
+ }
+ }
+#endif
+
/* OK, now set up the filehdr... */
/* Don't include the internal abs section in the section count */
but it doesn't hurt to set it internally. */
internal_f.f_target_id = TI_TARGET_ID;
#endif
-#ifdef TIC80_TARGET_ID
- internal_f.f_target_id = TIC80_TARGET_ID;
-#endif
/* FIXME, should do something about the other byte orders and
architectures. */
internal_a.magic = TICOFF_AOUT_MAGIC;
#define __A_MAGIC_SET__
#endif
-#ifdef TIC80COFF
- internal_a.magic = TIC80_ARCH_MAGIC;
-#define __A_MAGIC_SET__
-#endif /* TIC80 */
-#ifdef I860
- /* FIXME: What are the a.out magic numbers for the i860? */
- internal_a.magic = 0;
-#define __A_MAGIC_SET__
-#endif /* I860 */
-#ifdef I960
- internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
-#define __A_MAGIC_SET__
-#endif /* I960 */
-#if M88
-#define __A_MAGIC_SET__
- internal_a.magic = PAGEMAGICBCS;
-#endif /* M88 */
-
-#if APOLLO_M68
-#define __A_MAGIC_SET__
- internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
-#endif
-
-#if defined(M68) || defined(WE32K) || defined(M68K)
-#define __A_MAGIC_SET__
-#if defined(LYNXOS)
- internal_a.magic = LYNXCOFFMAGIC;
-#else
-#if defined(TARG_AUX)
- internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
- abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
- PAGEMAGICEXECSWAPPED);
-#else
-#if defined (PAGEMAGICPEXECPAGED)
- internal_a.magic = PAGEMAGICPEXECPAGED;
-#endif
-#endif /* TARG_AUX */
-#endif /* LYNXOS */
-#endif /* M68 || WE32K || M68K */
#if defined(ARM)
#define __A_MAGIC_SET__
internal_a.magic = ZMAGIC;
#endif
-#if defined(PPC_PE)
-#define __A_MAGIC_SET__
- internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
-#endif
-
#if defined MCORE_PE
#define __A_MAGIC_SET__
internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
internal_a.magic = MIPS_PE_MAGIC;
#endif
-#ifdef OR32
-#define __A_MAGIC_SET__
- internal_a.magic = NMAGIC; /* Assume separate i/d. */
-#endif
-
#ifndef __A_MAGIC_SET__
#include "Your aouthdr magic number is not being set!"
#else
int firstundef;
if (!coff_renumber_symbols (abfd, &firstundef))
- return FALSE;
+ return false;
coff_mangle_symbols (abfd);
if (! coff_write_symbols (abfd))
- return FALSE;
+ return false;
if (! coff_write_linenumbers (abfd))
- return FALSE;
+ return false;
if (! coff_write_relocs (abfd, firstundef))
- return FALSE;
+ return false;
}
#ifdef COFF_LONG_SECTION_NAMES
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. */
if (! coff_write_symbols (abfd))
- return FALSE;
+ return false;
}
#endif
-#ifdef COFF_IMAGE_WITH_PE
-#ifdef PPC_PE
- else if ((abfd->flags & EXEC_P) != 0)
- {
- bfd_byte b;
-
- /* PowerPC PE appears to require that all executable files be
- rounded up to the page size. */
- b = 0;
- if (bfd_seek (abfd,
- (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
- SEEK_SET) != 0
- || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
- return FALSE;
- }
-#endif
-#endif
-
/* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
backend linker, and obj_raw_syment_count is not valid until after
coff_write_symbols is called. */
if (text_sec != NULL)
{
internal_a.o_sntext = text_sec->target_index;
- internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
+ internal_a.o_algntext = bfd_section_alignment (text_sec);
}
else
{
if (data_sec != NULL)
{
internal_a.o_sndata = data_sec->target_index;
- internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
+ internal_a.o_algndata = bfd_section_alignment (data_sec);
}
else
{
else
internal_a.o_snbss = 0;
+ if (tdata_sec != NULL)
+ {
+ internal_a.o_sntdata = tdata_sec->target_index;
+ /* TODO: o_flags should be set to RS6K_AOUTHDR_TLS_LE
+ if there is at least one R_TLS_LE relocations. */
+ internal_a.o_flags = 0;
+#ifdef XCOFF64
+ internal_a.o_x64flags = 0;
+#endif
+ }
+ else
+ {
+ internal_a.o_sntdata = 0;
+ internal_a.o_flags = 0;
+#ifdef XCOFF64
+ internal_a.o_x64flags = 0;
+#endif
+ }
+ if (tbss_sec != NULL)
+ internal_a.o_sntbss = tbss_sec->target_index;
+ else
+ internal_a.o_sntbss = 0;
+
toc = xcoff_data (abfd)->toc;
internal_a.o_toc = toc;
internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
case bfd_arch_powerpc:
if (bfd_get_mach (abfd) == bfd_mach_ppc)
internal_a.o_cputype = 3;
+ else if (bfd_get_mach (abfd) == bfd_mach_ppc_620)
+ internal_a.o_cputype = 2;
else
internal_a.o_cputype = 1;
break;
}
#endif
- /* Now write them. */
+#ifdef COFF_WITH_PE
+ {
+ /* After object contents are finalized so we can compute a reasonable hash,
+ but before header is written so we can update it to point to debug directory. */
+ struct pe_tdata *pe = pe_data (abfd);
+
+ if (pe->build_id.after_write_object_contents != NULL)
+ (*pe->build_id.after_write_object_contents) (abfd);
+ }
+#endif
+
+ /* Now write header. */
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
- return FALSE;
+ return false;
{
char * buff;
buff = (char *) bfd_malloc (amount);
if (buff == NULL)
- return FALSE;
+ return false;
bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
amount = bfd_bwrite (buff, amount, abfd);
free (buff);
if (amount != bfd_coff_filhsz (abfd))
- return FALSE;
+ return false;
}
if (abfd->flags & EXEC_P)
buff = (char *) bfd_malloc (amount);
if (buff == NULL)
- return FALSE;
+ return false;
coff_swap_aouthdr_out (abfd, & internal_a, buff);
amount = bfd_bwrite (buff, amount, abfd);
free (buff);
if (amount != bfd_coff_aoutsz (abfd))
- return FALSE;
+ return false;
#ifdef COFF_IMAGE_WITH_PE
if (! coff_apply_checksum (abfd))
- return FALSE;
+ return false;
#endif
}
#ifdef RS6000COFF_C
+#ifndef XCOFF64
else
{
AOUTHDR buff;
size_t size;
- /* XCOFF seems to always write at least a small a.out header. */
+ /* XCOFF32 seems to always write at least a small a.out header. */
coff_swap_aouthdr_out (abfd, & internal_a, & buff);
if (xcoff_data (abfd)->full_aouthdr)
size = bfd_coff_aoutsz (abfd);
else
size = SMALL_AOUTSZ;
if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
- return FALSE;
+ return false;
}
+#endif
#endif
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
coff_set_section_contents (bfd * abfd,
sec_ptr section,
const void * location,
if (! abfd->output_has_begun) /* Set by bfd.c handler. */
{
if (! coff_compute_section_file_positions (abfd))
- return FALSE;
+ return false;
}
#if defined(_LIB) && !defined(TARG_AUX)
- a (four byte) word holding the length of this record, in words,
- a word that always seems to be set to "2",
- the path to a shared library, null-terminated and then padded
- to a whole word boundary.
+ to a whole word boundary.
bfd_assert calls have been added to alert if an attempt is made
to write a section which doesn't follow these assumptions. The
/* Don't write out bss sections - one way to do this is to
see if the filepos has not been set. */
if (section->filepos == 0)
- return TRUE;
+ return true;
if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
- return FALSE;
+ return false;
if (count == 0)
- return TRUE;
+ return true;
return bfd_bwrite (location, count, abfd) == count;
}
static void *
-buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
+buy_and_read (bfd *abfd, file_ptr where,
+ bfd_size_type nmemb, bfd_size_type size)
{
- void * area = bfd_alloc (abfd, size);
-
- if (!area)
- return (NULL);
- if (bfd_seek (abfd, where, SEEK_SET) != 0
- || bfd_bread (area, size, abfd) != size)
- return (NULL);
- return (area);
+ size_t amt;
+
+ if (_bfd_mul_overflow (nmemb, size, &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return NULL;
+ }
+ if (bfd_seek (abfd, where, SEEK_SET) != 0)
+ return NULL;
+ return _bfd_alloc_and_read (abfd, amt, amt);
}
/*
const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
+ if (s1 == NULL || s2 == NULL)
+ return 0;
if (s1->symbol.value < s2->symbol.value)
return -1;
else if (s1->symbol.value > s2->symbol.value)
return 0;
}
-static bfd_boolean
+static bool
coff_slurp_line_table (bfd *abfd, asection *asect)
{
LINENO *native_lineno;
alent *lineno_cache;
- bfd_size_type amt;
unsigned int counter;
alent *cache_ptr;
bfd_vma prev_offset = 0;
- int ordered = 1;
+ bool ordered = true;
unsigned int nbr_func;
LINENO *src;
+ bool have_func;
+ bool ret = true;
+ size_t amt;
+
+ if (asect->lineno_count == 0)
+ return true;
BFD_ASSERT (asect->lineno == NULL);
- amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
+ if (asect->lineno_count > asect->size)
+ {
+ _bfd_error_handler
+ (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
+ abfd, (unsigned long) asect->lineno_count, (unsigned long) asect->size);
+ return false;
+ }
+
+ if (_bfd_mul_overflow (asect->lineno_count + 1, sizeof (alent), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return false;
+ }
lineno_cache = (alent *) bfd_alloc (abfd, amt);
if (lineno_cache == NULL)
- return FALSE;
+ return false;
- 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,
+ asect->lineno_count,
+ bfd_coff_linesz (abfd));
if (native_lineno == NULL)
{
- (*_bfd_error_handler)
- (_("%B: warning: line number table read failed"), abfd);
+ _bfd_error_handler
+ (_("%pB: warning: line number table read failed"), abfd);
bfd_release (abfd, lineno_cache);
- return FALSE;
+ return false;
}
cache_ptr = lineno_cache;
asect->lineno = lineno_cache;
src = native_lineno;
nbr_func = 0;
+ have_func = false;
- for (counter = 0; counter < asect->lineno_count; counter++)
+ for (counter = 0; counter < asect->lineno_count; counter++, src++)
{
struct internal_lineno dst;
bfd_coff_swap_lineno_in (abfd, src, &dst);
cache_ptr->line_number = dst.l_lnno;
+ /* Appease memory checkers that get all excited about
+ uninitialised memory when copying alents if u.offset is
+ larger than u.sym. (64-bit BFD on 32-bit host.) */
+ memset (&cache_ptr->u, 0, sizeof (cache_ptr->u));
if (cache_ptr->line_number == 0)
{
- bfd_boolean warned;
- bfd_signed_vma symndx;
+ combined_entry_type * ent;
+ unsigned long symndx;
coff_symbol_type *sym;
- nbr_func++;
- warned = FALSE;
+ have_func = false;
symndx = dst.l_addr.l_symndx;
- if (symndx < 0
- || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
+ if (symndx >= obj_raw_syment_count (abfd))
{
- (*_bfd_error_handler)
- (_("%B: warning: illegal symbol index %ld in line numbers"),
- abfd, (long) symndx);
- symndx = 0;
- warned = TRUE;
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
+ abfd, symndx, counter);
+ cache_ptr->line_number = -1;
+ ret = false;
+ continue;
}
+ ent = obj_raw_syments (abfd) + symndx;
/* FIXME: We should not be casting between ints and
pointers like this. */
- sym = ((coff_symbol_type *)
- ((symndx + obj_raw_syments (abfd))
- ->u.syment._n._n_n._n_zeroes));
+ if (! ent->is_sym)
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
+ abfd, symndx, counter);
+ cache_ptr->line_number = -1;
+ ret = false;
+ continue;
+ }
+ sym = (coff_symbol_type *) (ent->u.syment._n._n_n._n_zeroes);
+
+ /* PR 17512 file: 078-10659-0.004 */
+ if (sym < obj_symbols (abfd)
+ || sym >= obj_symbols (abfd) + bfd_get_symcount (abfd))
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: warning: illegal symbol in line number entry %d"),
+ abfd, counter);
+ cache_ptr->line_number = -1;
+ ret = false;
+ continue;
+ }
+
+ have_func = true;
+ nbr_func++;
cache_ptr->u.sym = (asymbol *) sym;
- if (sym->lineno != NULL && ! warned)
- (*_bfd_error_handler)
- (_("%B: warning: duplicate line number information for `%s'"),
+ if (sym->lineno != NULL)
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: warning: duplicate line number information for `%s'"),
abfd, bfd_asymbol_name (&sym->symbol));
sym->lineno = cache_ptr;
if (sym->symbol.value < prev_offset)
- ordered = 0;
+ ordered = false;
prev_offset = sym->symbol.value;
}
+ else if (!have_func)
+ /* Drop line information that has no associated function.
+ PR 17521: file: 078-10659-0.004. */
+ continue;
else
- cache_ptr->u.offset = dst.l_addr.l_paddr
- - bfd_section_vma (abfd, asect);
-
+ cache_ptr->u.offset = dst.l_addr.l_paddr - bfd_section_vma (asect);
cache_ptr++;
- src++;
}
- cache_ptr->line_number = 0;
+
+ asect->lineno_count = cache_ptr - lineno_cache;
+ memset (cache_ptr, 0, sizeof (*cache_ptr));
bfd_release (abfd, native_lineno);
/* On some systems (eg AIX5.3) the lineno table may not be sorted. */
alent *n_lineno_cache;
/* Create a table of functions. */
- func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *));
- if (func_table != NULL)
+ if (_bfd_mul_overflow (nbr_func, sizeof (alent *), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ ret = false;
+ }
+ else if ((func_table = (alent **) bfd_alloc (abfd, amt)) != NULL)
{
alent **p = func_table;
unsigned int i;
- for (i = 0; i < counter; i++)
+ for (i = 0; i < asect->lineno_count; i++)
if (lineno_cache[i].line_number == 0)
*p++ = &lineno_cache[i];
+ BFD_ASSERT ((unsigned int) (p - func_table) == nbr_func);
+
/* Sort by functions. */
qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
/* Create the new sorted table. */
- amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
- n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
- if (n_lineno_cache != NULL)
+ if (_bfd_mul_overflow (asect->lineno_count, sizeof (alent), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ ret = false;
+ }
+ else if ((n_lineno_cache = (alent *) bfd_alloc (abfd, amt)) != NULL)
{
alent *n_cache_ptr = n_lineno_cache;
coff_symbol_type *sym;
alent *old_ptr = func_table[i];
- /* Copy the function entry and update it. */
- *n_cache_ptr = *old_ptr;
- sym = (coff_symbol_type *)n_cache_ptr->u.sym;
- sym->lineno = n_cache_ptr;
- n_cache_ptr++;
- old_ptr++;
-
- /* Copy the line number entries. */
- while (old_ptr->line_number != 0)
+ /* Update the function entry. */
+ sym = (coff_symbol_type *) old_ptr->u.sym;
+ /* PR binutils/17512: Point the lineno to where
+ this entry will be after the memcpy below. */
+ sym->lineno = lineno_cache + (n_cache_ptr - n_lineno_cache);
+ /* Copy the function and line number entries. */
+ do
*n_cache_ptr++ = *old_ptr++;
+ while (old_ptr->line_number != 0);
}
- n_cache_ptr->line_number = 0;
- memcpy (lineno_cache, n_lineno_cache, amt);
+
+ memcpy (lineno_cache, n_lineno_cache,
+ asect->lineno_count * sizeof (alent));
}
+ else
+ ret = false;
bfd_release (abfd, func_table);
}
+ else
+ ret = false;
}
- return TRUE;
+ return ret;
}
/* Slurp in the symbol table, converting it to generic form. Note
that if coff_relocate_section is defined, the linker will read
symbols via coff_link_add_symbols, rather than via this routine. */
-static bfd_boolean
+static bool
coff_slurp_symbol_table (bfd * abfd)
{
combined_entry_type *native_symbols;
coff_symbol_type *cached_area;
unsigned int *table_ptr;
- bfd_size_type amt;
unsigned int number_of_symbols = 0;
+ bool ret = true;
+ size_t amt;
if (obj_symbols (abfd))
- return TRUE;
+ return true;
/* Read in the symbol table. */
if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
- return FALSE;
+ return false;
/* Allocate enough room for all the symbols in cached form. */
- amt = obj_raw_syment_count (abfd);
- amt *= sizeof (coff_symbol_type);
+ if (_bfd_mul_overflow (obj_raw_syment_count (abfd),
+ sizeof (*cached_area), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return false;
+ }
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 = (unsigned int *) bfd_alloc (abfd, amt);
+ return false;
+ if (_bfd_mul_overflow (obj_raw_syment_count (abfd),
+ sizeof (*table_ptr), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return false;
+ }
+ table_ptr = (unsigned int *) bfd_zalloc (abfd, amt);
if (table_ptr == NULL)
- return FALSE;
+ return false;
else
{
coff_symbol_type *dst = cached_area;
{
combined_entry_type *src = native_symbols + this_index;
table_ptr[this_index] = number_of_symbols;
- dst->symbol.the_bfd = abfd;
+ dst->symbol.the_bfd = abfd;
+ BFD_ASSERT (src->is_sym);
dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
/* We use the native name field to point to the cached field. */
src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
dst->symbol.section = coff_section_from_bfd_index (abfd,
src->u.syment.n_scnum);
dst->symbol.flags = 0;
- dst->done_lineno = FALSE;
+ /* PR 17512: file: 079-7098-0.001:0.1. */
+ dst->symbol.value = 0;
+ dst->done_lineno = false;
switch (src->u.syment.n_sclass)
{
-#ifdef I960
- case C_LEAFEXT:
- /* Fall through to next case. */
-#endif
-
case C_EXT:
case C_WEAKEXT:
#if defined ARM
#endif
#ifdef RS6000COFF_C
case C_HIDEXT:
+#if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
+ case C_AIX_WEAKEXT:
+#endif
#endif
#ifdef C_SYSTEM
case C_SYSTEM: /* System Wide variable. */
&& src->u.syment.n_scnum > 0)
dst->symbol.flags = BSF_LOCAL;
#endif
- if (src->u.syment.n_sclass == C_WEAKEXT)
+ if (src->u.syment.n_sclass == C_WEAKEXT
+#ifdef RS6000COFF_C
+ || src->u.syment.n_sclass == C_AIX_WEAKEXT
+#endif
+ )
dst->symbol.flags |= BSF_WEAK;
break;
case C_STAT: /* Static. */
-#ifdef I960
- 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. */
#endif
#ifdef RS6000COFF_C
- case C_DWARF: /* A label in a dwarf section. */
- case C_INFO: /* A label in a comment section. */
+ case C_DWARF: /* A label in a dwarf section. */
+ case C_INFO: /* A label in a comment section. */
#endif
case C_LABEL: /* Label. */
if (src->u.syment.n_scnum == N_DEBUG)
case C_REGPARM: /* Register parameter. */
case C_REG: /* register variable. */
/* C_AUTOARG conflicts with TI COFF C_UEXT. */
-#if !defined (TIC80COFF) && !defined (TICOFF)
-#ifdef C_AUTOARG
- case C_AUTOARG: /* 960-specific storage class. */
-#endif
-#endif
case C_TPDEF: /* Type definition. */
case C_ARG:
case C_AUTO: /* Automatic variable. */
&& src->u.syment.n_scnum == 0)
break;
#ifdef RS6000COFF_C
- /* XCOFF specific: deleted entry. */
- if (src->u.syment.n_value == C_NULL_VALUE)
- break;
+ /* XCOFF specific: deleted entry. */
+ if (src->u.syment.n_value == C_NULL_VALUE)
+ break;
#endif
/* Fall through. */
case C_EXTDEF: /* External definition. */
case C_ALIAS: /* Duplicate tag. */
#endif
/* New storage classes for TI COFF. */
-#if defined(TIC80COFF) || defined(TICOFF)
+#ifdef TICOFF
case C_UEXT: /* Tentative external definition. */
#endif
case C_EXTLAB: /* External load time label. */
- case C_HIDDEN: /* Ext symbol in dmert public lib. */
default:
- (*_bfd_error_handler)
- (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
abfd, src->u.syment.n_sclass,
dst->symbol.section->name, dst->symbol.name);
+ ret = false;
+ /* Fall through. */
+ case C_HIDDEN: /* Ext symbol in dmert public lib. */
+ /* PR 20722: These symbols can also be generated by
+ building DLLs with --gc-sections enabled. */
dst->symbol.flags = BSF_DEBUGGING;
dst->symbol.value = (src->u.syment.n_value);
break;
}
dst->native = src;
-
dst->symbol.udata.i = 0;
dst->lineno = NULL;
+
this_index += (src->u.syment.n_numaux) + 1;
dst++;
number_of_symbols++;
obj_symbols (abfd) = cached_area;
obj_raw_syments (abfd) = native_symbols;
- bfd_get_symcount (abfd) = number_of_symbols;
+ abfd->symcount = number_of_symbols;
obj_convert (abfd) = table_ptr;
/* Slurp the line tables for each section too. */
{
p = abfd->sections;
while (p)
{
- coff_slurp_line_table (abfd, p);
+ if (! coff_slurp_line_table (abfd, p))
+ return false;
p = p->next;
}
}
- return TRUE;
+ return ret;
}
/* Classify a COFF symbol. A couple of targets have globally visible
{
case C_EXT:
case C_WEAKEXT:
-#ifdef I960
- case C_LEAFEXT:
-#endif
#ifdef ARM
case C_THUMBEXT:
case C_THUMBEXTFUNC:
#endif
+#ifdef RS6000COFF_C
+ case C_HIDEXT:
+#if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
+ case C_AIX_WEAKEXT:
+#endif
+#endif
#ifdef C_SYSTEM
case C_SYSTEM:
#endif
else
return COFF_SYMBOL_COMMON;
}
+#ifdef RS6000COFF_C
+ if (syment->n_sclass == C_HIDEXT)
+ return COFF_SYMBOL_LOCAL;
+#endif
return COFF_SYMBOL_GLOBAL;
default:
if (syment->n_value == 0)
{
asection *sec;
+ char * name;
char buf[SYMNMLEN + 1];
+ name = _bfd_coff_internal_syment_name (abfd, syment, buf)
sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
- if (sec != NULL
- && (strcmp (bfd_get_section_name (abfd, sec),
- _bfd_coff_internal_syment_name (abfd, syment, buf))
- == 0))
+ if (sec != NULL && name != NULL
+ && (strcmp (bfd_section_name (sec), name) == 0))
return COFF_SYMBOL_PE_SECTION;
}
#endif
{
char buf[SYMNMLEN + 1];
- (*_bfd_error_handler)
- (_("warning: %B: local symbol `%s' has no section"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("warning: %pB: local symbol `%s' has no section"),
abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
}
o The reloc index is turned into a pointer to a howto
structure, in a back end specific way. For instance, the 386
- and 960 use the @code{r_type} to directly produce an index
- into a howto table vector; the 88k subtracts a number from the
- @code{r_type} field and creates an addend field.
+ uses the @code{r_type} to directly produce an index
+ into a howto table vector.
*/
#ifndef CALC_ADDEND
coffsym = (obj_symbols (abfd) \
+ (cache_ptr->sym_ptr_ptr - symbols)); \
else if (ptr) \
- coffsym = coff_symbol_from (abfd, ptr); \
+ coffsym = coff_symbol_from (ptr); \
if (coffsym != NULL \
+ && coffsym->native->is_sym \
&& coffsym->native->u.syment.n_scnum == 0) \
cache_ptr->addend = 0; \
else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
}
#endif
-static bfd_boolean
+static bool
coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
{
RELOC *native_relocs;
arelent *reloc_cache;
arelent *cache_ptr;
unsigned int idx;
- bfd_size_type amt;
+ size_t amt;
if (asect->relocation)
- return TRUE;
+ return true;
if (asect->reloc_count == 0)
- return TRUE;
+ return true;
if (asect->flags & SEC_CONSTRUCTOR)
- return TRUE;
+ return true;
if (!coff_slurp_symbol_table (abfd))
- return FALSE;
+ return false;
- 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);
+ native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos,
+ asect->reloc_count,
+ bfd_coff_relsz (abfd));
+ if (_bfd_mul_overflow (asect->reloc_count, sizeof (arelent), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return false;
+ }
reloc_cache = (arelent *) bfd_alloc (abfd, amt);
-
if (reloc_cache == NULL || native_relocs == NULL)
- return FALSE;
+ return false;
for (idx = 0; idx < asect->reloc_count; idx++)
{
#else
cache_ptr->address = dst.r_vaddr;
- if (dst.r_symndx != -1)
+ if (dst.r_symndx != -1 && symbols != NULL)
{
if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
{
- (*_bfd_error_handler)
- (_("%B: warning: illegal symbol index %ld in relocs"),
- abfd, (long) dst.r_symndx);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: warning: illegal symbol index %ld in relocs"),
+ abfd, dst.r_symndx);
cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
ptr = NULL;
}
if (cache_ptr->howto == NULL)
{
- (*_bfd_error_handler)
- (_("%B: illegal relocation type %d at address 0x%lx"),
- abfd, dst.r_type, (long) dst.r_vaddr);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: illegal relocation type %d at address %#" PRIx64),
+ abfd, dst.r_type, (uint64_t) dst.r_vaddr);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
asect->relocation = reloc_cache;
- return TRUE;
+ return true;
}
#ifndef coff_rtype_to_howto
static reloc_howto_type *
coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
asection *sec ATTRIBUTE_UNUSED,
- struct internal_reloc *rel,
+ struct internal_reloc *rel ATTRIBUTE_UNUSED,
struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
struct internal_syment *sym ATTRIBUTE_UNUSED,
bfd_vma *addendp ATTRIBUTE_UNUSED)
return section->reloc_count;
}
+#ifndef coff_set_reloc
+#define coff_set_reloc _bfd_generic_set_reloc
+#endif
+
#ifndef coff_reloc16_estimate
#define coff_reloc16_estimate dummy_reloc16_estimate
}
#endif
-#ifndef coff_bfd_link_hash_table_free
-#define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
-#endif
-
/* If coff_relocate_section is defined, we can use the optimized COFF
backend linker. Otherwise we must continue to use the old linker. */
_bfd_generic_copy_link_hash_symbol_type
#define coff_bfd_link_split_section _bfd_generic_link_split_section
+#define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
+
#ifndef coff_start_final_link
#define coff_start_final_link NULL
#endif
#ifndef coff_link_output_has_begun
-static bfd_boolean
+static bool
coff_link_output_has_begun (bfd * abfd,
struct coff_final_link_info * info ATTRIBUTE_UNUSED)
{
#ifndef coff_final_link_postscript
-static bfd_boolean
+static bool
coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
#endif
coff_SWAP_scnhdr_out,
FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
coff_SWAP_scnhdr_out,
FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
coff_SWAP_scnhdr_out,
FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
#endif
#ifdef COFF_WITH_PE_BIGOBJ
-/* The UUID for bigobj files. */
+/* The UID for bigobj files. */
static const char header_bigobj_classid[16] =
{
}
in->n_value = H_GET_32 (abfd, ext->e_value);
+ BFD_ASSERT (sizeof (in->n_scnum) >= 4);
in->n_scnum = H_GET_32 (abfd, ext->e_scnum);
in->n_type = H_GET_16 (abfd, ext->e_type);
in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) ext1;
union internal_auxent *in = (union internal_auxent *) in1;
+ /* Make sure that all fields in the aux structure are
+ initialised. */
+ memset (in, 0, sizeof * in);
switch (in_class)
{
case C_FILE:
coff_SWAP_scnhdr_out,
FILHSZ_BIGOBJ, AOUTSZ, SCNHSZ, SYMESZ_BIGOBJ, AUXESZ_BIGOBJ,
RELSZ, LINESZ, FILNMLEN_BIGOBJ,
- TRUE,
+ true,
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
- FALSE,
+ false,
2,
1U << 31,
coff_bigobj_swap_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
#endif /* COFF_WITH_PE_BIGOBJ */
#ifndef coff_close_and_cleanup
-#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
+#define coff_close_and_cleanup _bfd_coff_close_and_cleanup
#endif
#ifndef coff_bfd_free_cached_info
#endif
#ifndef coff_bfd_is_target_special_symbol
-#define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
+#define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
#endif
#ifndef coff_read_minisymbols
#endif
#ifndef coff_bfd_gc_sections
-#define coff_bfd_gc_sections bfd_generic_gc_sections
+#define coff_bfd_gc_sections bfd_coff_gc_sections
#endif
#ifndef coff_bfd_lookup_section_flags
#define coff_bfd_is_group_section bfd_generic_is_group_section
#endif
+#ifndef coff_bfd_group_name
+#define coff_bfd_group_name bfd_coff_group_name
+#endif
+
#ifndef coff_bfd_discard_group
#define coff_bfd_discard_group bfd_generic_discard_group
#endif
#define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
#endif
+#ifndef coff_bfd_link_hide_symbol
+#define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
+#endif
+
+#ifndef coff_bfd_define_start_stop
+#define coff_bfd_define_start_stop bfd_generic_define_start_stop
+#endif
+
#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
const bfd_target VAR = \
{ \
'/', /* AR_pad_char. */ \
15, /* AR_max_namelen. */ \
0, /* match priority. */ \
+ TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
\
/* 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, \
\
- /* bfd_check_format. */ \
- { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
- _bfd_dummy_target }, \
- /* bfd_set_format. */ \
- { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
- /* bfd_write_contents. */ \
- { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
- bfd_false }, \
+ { /* bfd_check_format. */ \
+ _bfd_dummy_target, \
+ coff_object_p, \
+ bfd_generic_archive_p, \
+ _bfd_dummy_target \
+ }, \
+ { /* bfd_set_format. */ \
+ _bfd_bool_bfd_false_error, \
+ coff_mkobject, \
+ _bfd_generic_mkarchive, \
+ _bfd_bool_bfd_false_error \
+ }, \
+ { /* bfd_write_contents. */ \
+ _bfd_bool_bfd_false_error, \
+ coff_write_object_contents, \
+ _bfd_write_archive_contents, \
+ _bfd_bool_bfd_false_error \
+ }, \
\
BFD_JUMP_TABLE_GENERIC (coff), \
BFD_JUMP_TABLE_COPY (coff), \
'/', /* AR_pad_char. */ \
15, /* AR_max_namelen. */ \
0, /* match priority. */ \
+ TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
\
/* 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, \
\
- /* bfd_check_format. */ \
- { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
- _bfd_dummy_target }, \
- /* bfd_set_format. */ \
- { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
- /* bfd_write_contents. */ \
- { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
- bfd_false }, \
+ { /* bfd_check_format. */ \
+ _bfd_dummy_target, \
+ coff_object_p, \
+ bfd_generic_archive_p, \
+ _bfd_dummy_target \
+ }, \
+ { /* bfd_set_format. */ \
+ _bfd_bool_bfd_false_error, \
+ coff_mkobject, \
+ _bfd_generic_mkarchive, \
+ _bfd_bool_bfd_false_error \
+ }, \
+ { /* bfd_write_contents. */ \
+ _bfd_bool_bfd_false_error, \
+ coff_write_object_contents, \
+ _bfd_write_archive_contents, \
+ _bfd_bool_bfd_false_error \
+ }, \
\
BFD_JUMP_TABLE_GENERIC (coff), \
BFD_JUMP_TABLE_COPY (coff), \
'/', /* AR_pad_char. */ \
15, /* AR_max_namelen. */ \
0, /* match priority. */ \
+ TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
\
/* Data conversion functions. */ \
bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
- /* bfd_check_format. */ \
- { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
- _bfd_dummy_target }, \
- /* bfd_set_format. */ \
- { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
- /* bfd_write_contents. */ \
- { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
- bfd_false }, \
+ \
+ { /* bfd_check_format. */ \
+ _bfd_dummy_target, \
+ coff_object_p, \
+ bfd_generic_archive_p, \
+ _bfd_dummy_target \
+ }, \
+ { /* bfd_set_format. */ \
+ _bfd_bool_bfd_false_error, \
+ coff_mkobject, \
+ _bfd_generic_mkarchive, \
+ _bfd_bool_bfd_false_error \
+ }, \
+ { /* bfd_write_contents. */ \
+ _bfd_bool_bfd_false_error, \
+ coff_write_object_contents, \
+ _bfd_write_archive_contents, \
+ _bfd_bool_bfd_false_error \
+ }, \
\
BFD_JUMP_TABLE_GENERIC (coff), \
BFD_JUMP_TABLE_COPY (coff), \