/* Support for the generic parts of most COFF variants, for BFD.
- Copyright (C) 1990-2015 Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
/* All 3 branches use this. */
symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
- /* PR 17512 file: 078-11867-0.004 */
+ /* PR 17512 file: 078-11867-0.004 */
if (symname == NULL)
{
- _bfd_error_handler (_("%B: unable to load COMDAT section name"), abfd);
+ _bfd_error_handler (_("%B: unable to load COMDAT section name"),
+ abfd);
break;
}
|| 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 (_("%B: 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 (_("%B: 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 (_("%B: 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,
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;
/* 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"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%B: Warning: Ignoring section flag"
+ " IMAGE_SCN_MEM_NOT_PAGED in section %s"),
abfd, name);
break;
case IMAGE_SCN_MEM_EXECUTE:
/* 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 */
+ (_("%B (%s): Section flag %s (%#lx) ignored"),
abfd, name, unhandled, flag);
result = FALSE;
}
. 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
.{
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
+ (_("%B: warning: claims to have 0xffff relocs, without overflow"),
+ abfd);
}
#undef ALIGN_SET
#undef ELIFALIGN_SET
#endif
if ((internal_f->f_flags & F_GO32STUB) != 0)
- coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
+ {
+ 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);
bfd_size_type amt = bfd_coff_symesz (abfd);
buf = bfd_malloc (amt);
+ if (buf == NULL)
+ return FALSE;
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
|| bfd_bread (buf, amt, abfd) != amt)
{
#endif
default:
arch = bfd_arch_obscure;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Unrecognized TI COFF target id '0x%x'"),
internal_f->f_target_id);
break;
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));
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 (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 (_("%B: reloc against a non-existent"
+ " symbol index: %ld"),
abfd, n.r_symndx);
return FALSE;
}
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 */
+ (_("%B: page size is too large (0x%x)"), abfd, page_size);
+ return FALSE;
+ }
}
else
page_size = PE_DEF_FILE_ALIGNMENT;
if (target_index >= bfd_coff_max_nscns (abfd))
{
bfd_set_error (bfd_error_file_too_big);
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: too many sections (%d)"), abfd, target_index);
return FALSE;
}
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);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: section %A: 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;
internal_f.f_flags |= F_DYNLOAD;
#endif
+ memset (&internal_a, 0, sizeof internal_a);
+
/* Set up architecture-dependent stuff. */
{
unsigned int magic = 0;
unsigned int nbr_func;
LINENO *src;
bfd_boolean have_func;
+ bfd_boolean ret = TRUE;
BFD_ASSERT (asect->lineno == NULL);
+ if (asect->lineno_count > asect->size)
+ {
+ _bfd_error_handler
+ (_("%B: warning: line number count (%#lx) exceeds section size (%#lx)"),
+ abfd, (unsigned long) asect->lineno_count, (unsigned long) asect->size);
+ return FALSE;
+ }
+
amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
lineno_cache = (alent *) bfd_alloc (abfd, amt);
if (lineno_cache == NULL)
native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
if (native_lineno == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: line number table read failed"), abfd);
bfd_release (abfd, lineno_cache);
return FALSE;
if (cache_ptr->line_number == 0)
{
combined_entry_type * ent;
- bfd_vma symndx;
+ unsigned long symndx;
coff_symbol_type *sym;
have_func = FALSE;
symndx = dst.l_addr.l_symndx;
if (symndx >= obj_raw_syment_count (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
- abfd, (long) symndx, counter);
+ abfd, symndx, counter);
cache_ptr->line_number = -1;
+ ret = FALSE;
continue;
}
pointers like this. */
if (! ent->is_sym)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
- abfd, (long) symndx, counter);
+ abfd, symndx, counter);
cache_ptr->line_number = -1;
+ ret = FALSE;
continue;
}
sym = (coff_symbol_type *) (ent->u.syment._n._n_n._n_zeroes);
if (sym < obj_symbols (abfd)
|| sym >= obj_symbols (abfd) + bfd_get_symcount (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: warning: illegal symbol in line number entry %d"),
abfd, counter);
cache_ptr->line_number = -1;
+ ret = FALSE;
continue;
}
nbr_func++;
cache_ptr->u.sym = (asymbol *) sym;
if (sym->lineno != NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: warning: duplicate line number information for `%s'"),
abfd, bfd_asymbol_name (&sym->symbol));
*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);
memcpy (lineno_cache, n_lineno_cache, amt);
}
+ 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
unsigned int *table_ptr;
bfd_size_type amt;
unsigned int number_of_symbols = 0;
+ bfd_boolean ret = TRUE;
if (obj_symbols (abfd))
return TRUE;
#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_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)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: 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;
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
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 && name != NULL
{
char buf[SYMNMLEN + 1];
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("warning: %B: local symbol `%s' has no section"),
abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
}
{
if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: warning: illegal symbol index %ld in relocs"),
- abfd, (long) dst.r_symndx);
+ 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 */
+ (_("%B: illegal relocation type %d at address %#Lx"),
+ abfd, dst.r_type, dst.r_vaddr);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
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
_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
}
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);
#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_define_common_symbol bfd_generic_define_common_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 = \
{ \
projects / deliverable / binutils-gdb.git / blobdiff