/* Support for the generic parts of most COFF variants, for BFD.
- Copyright (C) 1990-2018 Free Software Foundation, Inc.
+ Copyright (C) 1990-2020 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
#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
(bfd *) ATTRIBUTE_UNUSED;
static bfd_boolean 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
(bfd *, asection *);
static bfd_boolean coff_slurp_symbol_table
#ifndef COFF_WITH_PE
static bfd_boolean
-styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
+styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
asection *section ATTRIBUTE_UNUSED,
sec_flags = (SEC_LOAD | SEC_ALLOC);
#endif /* STYP_SDATA */
+ if ((bfd_applicable_section_flags (abfd) & SEC_SMALL_DATA) != 0
+ && (CONST_STRNEQ (name, ".sbss")
+ || CONST_STRNEQ (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
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.
#ifdef COFF_LONG_SECTION_NAMES
|| CONST_STRNEQ (name, GNU_LINKONCE_WI)
|| CONST_STRNEQ (name, GNU_LINKONCE_WT)
+ /* FIXME: These definitions ought to be in a header file. */
+#define GNU_DEBUGLINK ".gnu_debuglink"
+#define GNU_DEBUGALTLINK ".gnu_debugaltlink"
+ || CONST_STRNEQ (name, GNU_DEBUGLINK)
+ || CONST_STRNEQ (name, GNU_DEBUGALTLINK)
#endif
|| CONST_STRNEQ (name, ".stab"))
is_dbg = TRUE;
}
}
+ if ((bfd_applicable_section_flags (abfd) & SEC_SMALL_DATA) != 0
+ && (CONST_STRNEQ (name, ".sbss")
+ || CONST_STRNEQ (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
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
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),
+ if (strcmp (bfd_section_name (section),
xcoff_dwsect_names[i].name) == 0)
{
section->alignment_power = 0;
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;
}
#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 */
static void
coff_set_alignment_hook (bfd *abfd ATTRIBUTE_UNUSED,
{
}
+#endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
#endif /* ! RS6000COFF_C */
#endif /* ! COFF_WITH_PE */
#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
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)
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)
- return NULL;
- }
- if (coff->go32stub != NULL)
- memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE);
-
return coff;
}
#endif
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 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:
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)
+ return FALSE;
+ buf = _bfd_malloc_and_read (abfd, amt, amt);
if (buf == NULL)
return FALSE;
- if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
- || bfd_bread (buf, amt, abfd) != amt)
- {
- free (buf);
- return FALSE;
- }
bfd_coff_swap_sym_in (abfd, buf, & sym);
if (sym.n_sclass == C_FILE)
cputype = sym.n_type & 0xff;
break;
#endif
-#ifdef TIC80_ARCH_MAGIC
- case TIC80_ARCH_MAGIC:
- arch = bfd_arch_tic80;
- break;
-#endif
-
#ifdef MCOREMAGIC
case MCOREMAGIC:
arch = bfd_arch_mcore;
if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
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;
}
#ifdef TARG_AUX
- if (p != NULL)
- free (p);
+ free (p);
#endif
}
*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 TRUE;
#endif
-#ifdef TIC80_ARCH_MAGIC
- case bfd_arch_tic80:
- *magicp = TIC80_ARCH_MAGIC;
- return TRUE;
-#endif
-
#ifdef ARMMAGIC
case bfd_arch_arm:
#ifdef ARM_WINCE
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 SH_ARCH_MAGIC_BIG
case bfd_arch_sh:
#ifdef COFF_IMAGE_WITH_PE
/* Calculate the file position for each section. */
#define ALIGN_SECTIONS_IN_FILE
-#if defined(TIC80COFF) || defined(TICOFF)
+#ifdef TICOFF
#undef ALIGN_SECTIONS_IN_FILE
#endif
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)
}
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)
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
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
}
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;
}
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;
}
#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 */
-
-#if APOLLO_M68
-#define __A_MAGIC_SET__
- internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
-#endif
-
-#if defined(M68) || 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 || M68K */
#if defined(ARM)
#define __A_MAGIC_SET__
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
{
}
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);
+ size_t amt;
- if (!area)
- return NULL;
- if (bfd_seek (abfd, where, SEEK_SET) != 0
- || bfd_bread (area, size, abfd) != size)
+ 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 area;
+ return _bfd_alloc_and_read (abfd, amt, amt);
}
/*
{
LINENO *native_lineno;
alent *lineno_cache;
- bfd_size_type amt;
unsigned int counter;
alent *cache_ptr;
bfd_vma prev_offset = 0;
LINENO *src;
bfd_boolean have_func;
bfd_boolean ret = TRUE;
+ size_t amt;
+
+ if (asect->lineno_count == 0)
+ return TRUE;
BFD_ASSERT (asect->lineno == NULL);
return FALSE;
}
- amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
+ 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;
- 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
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++;
}
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;
qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
/* Create the new sorted table. */
- amt = (bfd_size_type) asect->lineno_count * 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;
*n_cache_ptr++ = *old_ptr++;
while (old_ptr->line_number != 0);
}
- BFD_ASSERT ((bfd_size_type) (n_cache_ptr - n_lineno_cache) == (amt / sizeof (alent)));
- memcpy (lineno_cache, n_lineno_cache, amt);
+ memcpy (lineno_cache, n_lineno_cache,
+ asect->lineno_count * sizeof (alent));
}
else
ret = FALSE;
combined_entry_type *native_symbols;
coff_symbol_type *cached_area;
unsigned int *table_ptr;
- bfd_size_type amt;
unsigned int number_of_symbols = 0;
bfd_boolean ret = TRUE;
+ size_t amt;
if (obj_symbols (abfd))
return TRUE;
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);
+ 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;
else
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. */
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. */
{
name = _bfd_coff_internal_syment_name (abfd, syment, buf)
sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
if (sec != NULL && name != NULL
- && (strcmp (bfd_get_section_name (abfd, sec), name) == 0))
+ && (strcmp (bfd_section_name (sec), name) == 0))
return COFF_SYMBOL_PE_SECTION;
}
#endif
arelent *reloc_cache;
arelent *cache_ptr;
unsigned int idx;
- bfd_size_type amt;
+ size_t amt;
if (asect->relocation)
return TRUE;
if (!coff_slurp_symbol_table (abfd))
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;
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:
#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
#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
projects / deliverable / binutils-gdb.git / blobdiff