Now that _bfd_error_handler is not a function pointer.
* aout-adobe.c: Replace (*_bfd_error_handler) (...) with
_bfd_error_handler (...) throughout.
* aout-cris.c, * aoutx.h, * archive.c, * bfd.c, * binary.c,
* cache.c, * coff-alpha.c, * coff-arm.c, * coff-h8300.c,
* coff-i860.c, * coff-mcore.c, * coff-ppc.c, * coff-rs6000.c,
* coff-sh.c, * coff-tic4x.c, * coff-tic54x.c, * coff-tic80.c,
* coff64-rs6000.c, * coffcode.h, * coffgen.c, * cofflink.c,
* coffswap.h, * cpu-arm.c, * cpu-m68k.c, * cpu-sh.c, * dwarf2.c,
* ecoff.c, * elf-eh-frame.c, * elf-m10300.c, * elf.c, * elf32-arc.c,
* elf32-arm.c, * elf32-avr.c, * elf32-bfin.c, * elf32-cr16.c,
* elf32-cris.c, * elf32-crx.c, * elf32-dlx.c, * elf32-frv.c,
* elf32-hppa.c, * elf32-i370.c, * elf32-i386.c, * elf32-lm32.c,
* elf32-m32c.c, * elf32-m32r.c, * elf32-m68hc1x.c, * elf32-m68k.c,
* elf32-mcore.c, * elf32-mep.c, * elf32-metag.c, * elf32-microblaze.c,
* elf32-mips.c, * elf32-nds32.c, * elf32-nios2.c, * elf32-or1k.c,
* elf32-pj.c, * elf32-ppc.c, * elf32-rl78.c, * elf32-s390.c,
* elf32-score.c, * elf32-score7.c, * elf32-sh.c, * elf32-sh64.c,
* elf32-sparc.c, * elf32-spu.c, * elf32-tic6x.c, * elf32-tilepro.c,
* elf32-v850.c, * elf32-vax.c, * elf32-xtensa.c, * elf64-alpha.c,
* elf64-hppa.c, * elf64-ia64-vms.c, * elf64-mips.c, * elf64-mmix.c,
* elf64-ppc.c, * elf64-s390.c, * elf64-sh64.c, * elf64-sparc.c,
* elf64-x86-64.c, * elfcode.h, * elfcore.h, * elflink.c,
* elfn32-mips.c, * elfnn-aarch64.c, * elfnn-ia64.c, * elfxx-mips.c,
* elfxx-sparc.c, * elfxx-tilegx.c, * hpux-core.c, * i386linux.c,
* ieee.c, * ihex.c, * libbfd.c, * linker.c, * m68klinux.c,
* mach-o.c, * merge.c, * mmo.c, * oasys.c, * osf-core.c, * pdp11.c,
* pe-mips.c, * peXXigen.c, * pef.c, * plugin.c, * reloc.c,
* rs6000-core.c, * sco5-core.c, * som.c, * sparclinux.c, * srec.c,
* stabs.c, * syms.c, * vms-alpha.c, * vms-lib.c, * vms-misc.c,
* xcofflink.c: Likewise.
2016-09-30 Alan Modra <amodra@gmail.com>
+ * aout-adobe.c: Replace (*_bfd_error_handler) (...) with
+ _bfd_error_handler (...) throughout.
+ * aout-cris.c, * aoutx.h, * archive.c, * bfd.c, * binary.c,
+ * cache.c, * coff-alpha.c, * coff-arm.c, * coff-h8300.c,
+ * coff-i860.c, * coff-mcore.c, * coff-ppc.c, * coff-rs6000.c,
+ * coff-sh.c, * coff-tic4x.c, * coff-tic54x.c, * coff-tic80.c,
+ * coff64-rs6000.c, * coffcode.h, * coffgen.c, * cofflink.c,
+ * coffswap.h, * cpu-arm.c, * cpu-m68k.c, * cpu-sh.c, * dwarf2.c,
+ * ecoff.c, * elf-eh-frame.c, * elf-m10300.c, * elf.c, * elf32-arc.c,
+ * elf32-arm.c, * elf32-avr.c, * elf32-bfin.c, * elf32-cr16.c,
+ * elf32-cris.c, * elf32-crx.c, * elf32-dlx.c, * elf32-frv.c,
+ * elf32-hppa.c, * elf32-i370.c, * elf32-i386.c, * elf32-lm32.c,
+ * elf32-m32c.c, * elf32-m32r.c, * elf32-m68hc1x.c, * elf32-m68k.c,
+ * elf32-mcore.c, * elf32-mep.c, * elf32-metag.c, * elf32-microblaze.c,
+ * elf32-mips.c, * elf32-nds32.c, * elf32-nios2.c, * elf32-or1k.c,
+ * elf32-pj.c, * elf32-ppc.c, * elf32-rl78.c, * elf32-s390.c,
+ * elf32-score.c, * elf32-score7.c, * elf32-sh.c, * elf32-sh64.c,
+ * elf32-sparc.c, * elf32-spu.c, * elf32-tic6x.c, * elf32-tilepro.c,
+ * elf32-v850.c, * elf32-vax.c, * elf32-xtensa.c, * elf64-alpha.c,
+ * elf64-hppa.c, * elf64-ia64-vms.c, * elf64-mips.c, * elf64-mmix.c,
+ * elf64-ppc.c, * elf64-s390.c, * elf64-sh64.c, * elf64-sparc.c,
+ * elf64-x86-64.c, * elfcode.h, * elfcore.h, * elflink.c,
+ * elfn32-mips.c, * elfnn-aarch64.c, * elfnn-ia64.c, * elfxx-mips.c,
+ * elfxx-sparc.c, * elfxx-tilegx.c, * hpux-core.c, * i386linux.c,
+ * ieee.c, * ihex.c, * libbfd.c, * linker.c, * m68klinux.c,
+ * mach-o.c, * merge.c, * mmo.c, * oasys.c, * osf-core.c, * pdp11.c,
+ * pe-mips.c, * peXXigen.c, * pef.c, * plugin.c, * reloc.c,
+ * rs6000-core.c, * sco5-core.c, * som.c, * sparclinux.c, * srec.c,
+ * stabs.c, * syms.c, * vms-alpha.c, * vms-lib.c, * vms-misc.c,
+ * xcofflink.c: Likewise.
+
+2016-09-30 Alan Modra <amodra@gmail.com>
+
* bfd-in.h: Include stdarg.h.
* bfd.c (bfd_error_handler_type): Make like vprintf.
(_bfd_error_internal): Rename from _bfd_error_handler. Make static.
goto no_more_sections;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Unknown section type in a.out.adobe file: %x\n"),
abfd, ext->e_type[0]);
goto no_more_sections;
We may change this later, but assert this for the moment. */
if (r_type > 2)
{
- (*_bfd_error_handler) (_("%s: Invalid relocation type exported: %d"),
- bfd_get_filename (abfd), r_type);
+ _bfd_error_handler (_("%s: Invalid relocation type exported: %d"),
+ bfd_get_filename (abfd), r_type);
bfd_set_error (bfd_error_wrong_format);
}
if (r_type > 2)
{
- (*_bfd_error_handler) (_("%B: Invalid relocation type imported: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: Invalid relocation type imported: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_wrong_format);
}
if (r_extern && r_index > symcount)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Bad relocation record imported: %d"), abfd, r_index);
bfd_set_error (bfd_error_wrong_format);
(section->vma - obj_textsec (abfd)->vma);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: can not represent section `%s' in a.out object file format"),
bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
bfd_set_error (bfd_error_nonrepresentable_section);
{
/* This case occurs, e.g., for the *DEBUG* section of a COFF
file. */
- (*_bfd_error_handler)
- (_("%s: can not represent section for symbol `%s' in a.out object file format"),
+ _bfd_error_handler
+ (_("%s: can not represent section for symbol `%s' in a.out "
+ "object file format"),
bfd_get_filename (abfd),
cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*"));
bfd_set_error (bfd_error_nonrepresentable_section);
sym_pointer->e_type[0] |= N_TEXT;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: can not represent section `%s' in a.out object file format"),
bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
bfd_set_error (bfd_error_nonrepresentable_section);
and call get_reloc_upper_bound and canonicalize_reloc to
work out the number of relocs needed, and then multiply
by the reloc size. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: relocatable link from %s to %s not supported"),
bfd_get_filename (abfd),
sub->xvec->name, abfd->xvec->name);
{
if (bfd_update_armap_timestamp (arch))
break;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: writing archive was slow: rewriting timestamp\n"));
}
while (++tries < 6);
}
if (strcmp (syms[src_count]->name, "__gnu_lto_slim") == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: plugin needed to handle lto object"),
bfd_get_filename (current));
namelen = strlen (syms[src_count]->name);
int bfd_line)
{
- (*_bfd_error_handler) (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
+ _bfd_error_handler (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
}
/* Similar to _bfd_error_handler, a program can decide to exit on an
_bfd_abort (const char *file, int line, const char *fn)
{
if (fn != NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("BFD %s internal error, aborting at %s:%d in %s\n"),
BFD_VERSION_STRING, file, line, fn);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("BFD %s internal error, aborting at %s:%d\n"),
BFD_VERSION_STRING, file, line);
- (*_bfd_error_handler) (_("Please report this bug.\n"));
+ _bfd_error_handler (_("Please report this bug.\n"));
_exit (EXIT_FAILURE);
}
have. */
if (s->filepos < 0)
- (*_bfd_error_handler)
- (_("Warning: Writing section `%s' at huge (ie negative) file offset 0x%lx."),
+ _bfd_error_handler
+ (_("Warning: Writing section `%s' at huge (ie negative) "
+ "file offset 0x%lx."),
bfd_get_section_name (abfd, s),
(unsigned long) s->filepos);
}
else
return (FILE *) abfd->iostream;
- (*_bfd_error_handler) (_("reopening %B: %s\n"),
- orig_bfd, bfd_errmsg (bfd_get_error ()));
+ _bfd_error_handler (_("reopening %B: %s\n"),
+ orig_bfd, bfd_errmsg (bfd_get_error ()));
return NULL;
}
return TRUE;
if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Cannot handle compressed Alpha binaries.\n"
" Use compiler flags, or objZ, to generate uncompressed binaries."),
abfd);
{
if (intern->r_type > ALPHA_R_GPVALUE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown/unsupported relocation type %d"),
abfd, intern->r_type);
bfd_set_error (bfd_error_bad_value);
switch (r_type)
{
case ALPHA_R_GPRELHIGH:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unsupported relocation: ALPHA_R_GPRELHIGH"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
continue;
case ALPHA_R_GPRELLOW:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unsupported relocation: ALPHA_R_GPRELLOW"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
continue;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
case bfd_reloc_ok:
break;
case bfd_reloc_outofrange:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad reloc address 0x%lx in section `%A'"),
input_bfd, input_section, (unsigned long) rel->r_vaddr);
return FALSE;
if (link_info->output_bfd->xvec != abfd->xvec)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("cannot handle R_MEM_INDIRECT reloc when using %s output"),
link_info->output_bfd->xvec->name);
char **error_message ATTRIBUTE_UNUSED)
{
reloc_howto_type *howto = reloc_entry->howto;
- (*_bfd_error_handler) (_("relocation `%s' not yet implemented"), howto->name);
+ _bfd_error_handler (_("relocation `%s' not yet implemented"), howto->name);
return bfd_reloc_notsupported;
}
{
if (dst->r_symndx < 0 || dst->r_symndx >= obj_conv_table_size (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: illegal symbol index %ld in relocs"),
abfd, dst->r_symndx);
cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
if ( input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
&& output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: compiled for a %s system and target is %s.\n"),
input_bfd,
bfd_big_endian (input_bfd) ? _("big endian") : _("little endian"),
/* The size must fit in a 16-bit displacement. */
if (global_toc_size > 65535)
{
- (*_bfd_error_handler) (_("TOC overflow"));
+ _bfd_error_handler (_("TOC overflow"));
bfd_set_error (bfd_error_file_too_big);
return FALSE;
}
/* The size must fit in a 16-bit displacement. */
if (global_toc_size >= 65535)
{
- (*_bfd_error_handler) (_("TOC overflow"));
+ _bfd_error_handler (_("TOC overflow"));
bfd_set_error (bfd_error_file_too_big);
return FALSE;
}
switch (r_type)
{
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
bfd_set_error (bfd_error_bad_value);
return FALSE;
/* The size must still fit in a 16-bit displacement. */
if ((bfd_vma) our_toc_offset >= 65535)
{
- (*_bfd_error_handler)
- (_("%B: Relocation for %s of %lx exceeds Toc size limit"),
+ _bfd_error_handler
+ (_("%B: Relocation for %s of %lx exceeds "
+ "Toc size limit"),
input_bfd, name,
(unsigned long) our_toc_offset);
bfd_set_error (bfd_error_bad_value);
if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
&& (bfd_vma) our_toc_offset > toc_section->size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Relocation exceeds allocated TOC (%lx)"),
input_bfd, (unsigned long) toc_section->size);
bfd_set_error (bfd_error_bad_value);
else
my_name = h->root.root.root.string;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: unsupported reloc %s <file %B, section %A>\n"
"sym %ld (%s), r_vaddr %ld (%lx)"),
input_bfd, input_section, howto->name,
break;
my_name = h->root.root.root.string;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
break;
default:
- (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"),
- ppc_coff_howto_table[r_type].name,
- r_type);
+ _bfd_error_handler
+ (_("warning: unsupported reloc %s [%d] used -- it may not work"),
+ ppc_coff_howto_table[r_type].name, r_type);
howto = ppc_coff_howto_table + r_type;
break;
}
howto = ppc_coff_howto_table + r_type;
break;
default:
- (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"),
- ppc_coff_howto_table[r_type].name,
- r_type);
+ _bfd_error_handler
+ (_("warning: unsupported reloc %s [%d] used -- it may not work"),
+ ppc_coff_howto_table[r_type].name, r_type);
howto = ppc_coff_howto_table + r_type;
break;
}
bfd_vma *relocation ATTRIBUTE_UNUSED,
bfd_byte *contents ATTRIBUTE_UNUSED)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: unsupported relocation type 0x%02x"),
bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
bfd_set_error (bfd_error_bad_value);
{
if (h->toc_section == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"),
bfd_get_filename (input_bfd), rel->r_vaddr,
h->root.root.string);
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: symbol `%s' has unrecognized smclas %d"),
abfd, symbol_name, aux->x_csect.x_smclas);
bfd_set_error (bfd_error_bad_value);
if (sh_reloc_map[i].bfd_reloc_val == code)
return &sh_coff_howtos[(int) sh_reloc_map[i].shcoff_reloc_val];
- (*_bfd_error_handler) (_("SH Error: unknown reloc type %d"), code);
+ _bfd_error_handler (_("SH Error: unknown reloc type %d"), code);
return NULL;
}
laddr += ((irel->r_offset & 0xffffffff) ^ 0x80000000) - 0x80000000;
if (laddr >= sec->size)
{
- (*_bfd_error_handler) ("%B: 0x%lx: warning: bad R_SH_USES offset",
- abfd, (unsigned long) irel->r_vaddr);
+ _bfd_error_handler ("%B: 0x%lx: warning: bad R_SH_USES offset",
+ abfd, (unsigned long) irel->r_vaddr);
continue;
}
insn = bfd_get_16 (abfd, contents + laddr);
/* If the instruction is not mov.l NN,rN, we don't know what to do. */
if ((insn & 0xf000) != 0xd000)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
- abfd, (unsigned long) irel->r_vaddr, insn));
+ _bfd_error_handler
+ ("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x",
+ abfd, (unsigned long) irel->r_vaddr, insn);
continue;
}
paddr += (laddr + 4) &~ (bfd_vma) 3;
if (paddr >= sec->size)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: warning: bad R_SH_USES load offset",
- abfd, (unsigned long) irel->r_vaddr));
+ _bfd_error_handler
+ ("%B: 0x%lx: warning: bad R_SH_USES load offset",
+ abfd, (unsigned long) irel->r_vaddr);
continue;
}
break;
if (irelfn >= irelend)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: warning: could not find expected reloc",
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ ("%B: 0x%lx: warning: could not find expected reloc",
+ abfd, (unsigned long) paddr);
continue;
}
&sym);
if (sym.n_scnum != 0 && sym.n_scnum != sec->target_index)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: warning: symbol in unexpected section",
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ ("%B: 0x%lx: warning: symbol in unexpected section",
+ abfd, (unsigned long) paddr);
continue;
}
/* Now check whether we got a COUNT reloc. */
if (irelcount >= irelend)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: warning: could not find expected COUNT reloc",
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ ("%B: 0x%lx: warning: could not find expected COUNT reloc",
+ abfd, (unsigned long) paddr);
continue;
}
just deleted one. */
if (irelcount->r_offset == 0)
{
- ((*_bfd_error_handler) ("%B: 0x%lx: warning: bad count",
- abfd, (unsigned long) paddr));
+ _bfd_error_handler ("%B: 0x%lx: warning: bad count",
+ abfd, (unsigned long) paddr);
continue;
}
if (overflow)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: fatal: reloc overflow while relaxing",
- abfd, (unsigned long) irel->r_vaddr));
+ _bfd_error_handler
+ ("%B: 0x%lx: fatal: reloc overflow while relaxing",
+ abfd, (unsigned long) irel->r_vaddr);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (obj_symbols (abfd) != NULL
|| obj_raw_syments (abfd) != NULL)
{
- ((*_bfd_error_handler)
- ("%B: fatal: generic symbols retrieved before relaxing", abfd));
+ _bfd_error_handler
+ ("%B: fatal: generic symbols retrieved before relaxing", abfd);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
}
if (overflow)
{
- ((*_bfd_error_handler)
- ("%B: 0x%lx: fatal: reloc overflow while relaxing",
- abfd, (unsigned long) irel->r_vaddr));
+ _bfd_error_handler
+ ("%B: 0x%lx: fatal: reloc overflow while relaxing",
+ abfd, (unsigned long) irel->r_vaddr);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (symndx < 0
|| (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: illegal symbol index %ld in relocs",
input_bfd, symndx);
bfd_set_error (bfd_error_bad_value);
}
}
- (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
- (unsigned int) dst->r_type);
+ _bfd_error_handler (_("Unrecognized reloc type 0x%x"),
+ (unsigned int) dst->r_type);
abort();
}
{
if (reloc->r_symndx < 0 || reloc->r_symndx >= obj_conv_table_size (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: illegal symbol index %ld in relocs"),
bfd_get_filename (abfd), reloc->r_symndx);
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
}
}
- (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
- (unsigned int) dst->r_type);
+ _bfd_error_handler (_("Unrecognized reloc type 0x%x"),
+ (unsigned int) dst->r_type);
abort ();
}
{
if (reloc->r_symndx < 0 || reloc->r_symndx >= obj_conv_table_size (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: illegal symbol index %ld in relocs"),
abfd, reloc->r_symndx);
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
}
}
- (*_bfd_error_handler) (_("Unrecognized reloc type 0x%x"),
- (unsigned int) dst->r_type);
+ _bfd_error_handler (_("Unrecognized reloc type 0x%x"),
+ (unsigned int) dst->r_type);
cache_ptr->howto = tic80_howto_table + 0;
}
case bfd_reloc_ok:
break;
case bfd_reloc_outofrange:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad reloc address 0x%lx in section `%A'"),
input_bfd, input_section, (unsigned long) rel->r_vaddr);
return FALSE;
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: symbol `%s' has unrecognized smclas %d"),
abfd, symbol_name, aux->x_csect.x_smclas);
bfd_set_error (bfd_error_bad_value);
/* If the section flag was not handled, report it here. */
if (unhandled != NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B (%s): Section flag %s (0x%x) ignored"),
abfd, name, unhandled, flag);
result = FALSE;
section->rel_filepos += relsz;
}
else if (hdr->s_nreloc == 0xffff)
- (*_bfd_error_handler)
+ _bfd_error_handler
("%s: warning: claims to have 0xffff relocs, without overflow",
bfd_get_filename (abfd));
}
#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 (page_size < 0)
{
bfd_set_error (bfd_error_file_too_big);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: page size is too large (0x%x)"), abfd, page_size);
return FALSE;
}
if (target_index >= bfd_coff_max_nscns (abfd))
{
bfd_set_error (bfd_error_file_too_big);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: too many sections (%d)"), abfd, target_index);
return FALSE;
}
if (string_size >= 10000000)
{
bfd_set_error (bfd_error_file_too_big);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: section %s: string table overflow at offset %ld"),
abfd, current->name, string_size);
return FALSE;
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;
symndx = dst.l_addr.l_symndx;
if (symndx >= obj_raw_syment_count (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, (long) symndx, counter);
cache_ptr->line_number = -1;
pointers like this. */
if (! ent->is_sym)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, (long) symndx, counter);
cache_ptr->line_number = -1;
if (sym < obj_symbols (abfd)
|| sym >= obj_symbols (abfd) + bfd_get_symcount (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: illegal symbol in line number entry %d"),
abfd, counter);
cache_ptr->line_number = -1;
nbr_func++;
cache_ptr->u.sym = (asymbol *) sym;
if (sym->lineno != NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: duplicate line number information for `%s'"),
abfd, bfd_asymbol_name (&sym->symbol));
case C_UEXT: /* Tentative external definition. */
#endif
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Unrecognized storage class %d for %s symbol `%s'"),
abfd, src->u.syment.n_sclass,
dst->symbol.section->name, dst->symbol.name);
{
char buf[SYMNMLEN + 1];
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("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
(_("%B: warning: illegal symbol index %ld in relocs"),
abfd, (long) dst.r_symndx);
cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
if (cache_ptr->howto == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: illegal relocation type %d at address 0x%lx"),
abfd, dst.r_type, (long) dst.r_vaddr);
bfd_set_error (bfd_error_bad_value);
case compress:
if (!bfd_init_section_compress_status (abfd, return_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unable to initialize compress status for section %s"),
abfd, name);
return FALSE;
case decompress:
if (!bfd_init_section_decompress_status (abfd, return_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unable to initialize decompress status for section %s"),
abfd, name);
return FALSE;
if (strsize < STRING_SIZE_SIZE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad string table size %lu"), abfd, (unsigned long) strsize);
bfd_set_error (bfd_error_bad_value);
return NULL;
if (!bed->can_gc_sections
|| !is_coff_hash_table (info->hash))
{
- (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
+ _bfd_error_handler(_("Warning: gc-sections option ignored"));
return TRUE;
}
#endif
& COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
&& (*sym_hash)->root.type != bfd_link_hash_undefined
&& (*sym_hash)->root.type != bfd_link_hash_undefweak)
- (*_bfd_error_handler)
+ _bfd_error_handler
("Warning: symbol `%s' is both section and non-section",
name);
&& !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
&& (BTYPE ((*sym_hash)->type) == T_NULL
|| BTYPE (sym.n_type) == T_NULL)))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: type of symbol `%s' changed from %d to %d in %B"),
abfd, name, (*sym_hash)->type, sym.n_type);
if ((o->flags & SEC_RELOC) != 0
&& o->reloc_count != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocs in section `%A', but it has no contents"),
input_bfd, o);
bfd_set_error (bfd_error_no_contents);
if (sec->reloc_count > 0xffff
&& (! obj_pe (output_bfd)
|| bfd_link_relocatable (flaginfo->info)))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
bfd_get_filename (output_bfd),
bfd_get_section_name (output_bfd, sec),
if (sec->lineno_count > 0xffff
&& (! obj_pe (output_bfd)
|| bfd_link_relocatable (flaginfo->info)))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
bfd_get_filename (output_bfd),
bfd_get_section_name (output_bfd, sec),
else if (symndx < 0
|| (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
return FALSE;
}
case bfd_reloc_ok:
break;
case bfd_reloc_outofrange:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad reloc address 0x%lx in section `%A'"),
input_bfd, input_section, (unsigned long) rel->r_vaddr);
return FALSE;
memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
buf[sizeof (scnhdr_int->s_name)] = '\0';
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
bfd_get_filename (abfd),
buf, scnhdr_int->s_nlnno);
memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
buf[sizeof (scnhdr_int->s_name)] = '\0';
- (*_bfd_error_handler) (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
- bfd_get_filename (abfd),
- buf, scnhdr_int->s_nreloc);
+ _bfd_error_handler (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
+ bfd_get_filename (abfd),
+ buf, scnhdr_int->s_nreloc);
bfd_set_error (bfd_error_file_truncated);
PUT_SCNHDR_NRELOC (abfd, 0xffff, scnhdr_ext->s_nreloc);
ret = 0;
if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
(file_ptr) 0, buffer_size))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("warning: unable to update contents of %s section in %s"),
note_section, bfd_get_filename (abfd));
goto FAIL;
if (!cpu32_fido_mix_warning)
{
cpu32_fido_mix_warning = 1;
- (*_bfd_error_handler) ("warning: linking CPU32 objects with fido objects");
+ _bfd_error_handler ("warning: linking CPU32 objects with fido objects");
}
return bfd_lookup_arch (a->arch,
bfd_m68k_features_to_mach (fido_a | m68881));
if (!SH_VALID_CO_ARCH_SET (merged_arch))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: uses %s instructions while previous modules use %s instructions",
ibfd,
SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
}
else if (!SH_VALID_ARCH_SET (merged_arch))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("internal error: merge of architecture '%s' with architecture '%s' produced unknown architecture\n",
bfd_printable_name (obfd),
bfd_printable_name (ibfd));
}
if (! msec)
{
- (*_bfd_error_handler) (_("Dwarf Error: Can't find %s section."),
- sec->uncompressed_name);
+ _bfd_error_handler (_("Dwarf Error: Can't find %s section."),
+ sec->uncompressed_name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
that the client wants. Validate it here to avoid trouble later. */
if (offset != 0 && offset >= *section_size)
{
- (*_bfd_error_handler) (_("Dwarf Error: Offset (%lu)"
- " greater than or equal to %s size (%lu)."),
- (long) offset, section_name, *section_size);
+ _bfd_error_handler (_("Dwarf Error: Offset (%lu)"
+ " greater than or equal to %s size (%lu)."),
+ (long) offset, section_name, *section_size);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (info_ptr >= info_ptr_end && form != DW_FORM_flag_present)
{
- (*_bfd_error_handler) (_("Dwarf Error: Info pointer extends beyond end of attributes"));
+ _bfd_error_handler (_("Dwarf Error: Info pointer extends beyond end of attributes"));
bfd_set_error (bfd_error_bad_value);
return info_ptr;
}
info_ptr = read_attribute_value (attr, form, unit, info_ptr, info_ptr_end);
break;
default:
- (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
- form);
+ _bfd_error_handler (_("Dwarf Error: Invalid or unhandled FORM value: %#x."),
+ form);
bfd_set_error (bfd_error_bad_value);
return NULL;
}
{
/* FILE == 0 means unknown. */
if (file)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: mangled line number section (bad file number)."));
return strdup ("<unknown>");
}
if (stash->dwarf_line_size < 16)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Line info section is too small (%ld)"),
(long) stash->dwarf_line_size);
bfd_set_error (bfd_error_bad_value);
if (lh.total_length > stash->dwarf_line_size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Line info data is bigger (0x%lx) than the section (0x%lx)"),
(long) lh.total_length, (long) stash->dwarf_line_size);
bfd_set_error (bfd_error_bad_value);
lh.version = read_2_bytes (abfd, line_ptr, line_end);
if (lh.version < 2 || lh.version > 4)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Unhandled .debug_line version %d."), lh.version);
bfd_set_error (bfd_error_bad_value);
return NULL;
if (line_ptr + offset_size + (lh.version >=4 ? 6 : 5) >= line_end)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Ran out of room reading prologue"));
bfd_set_error (bfd_error_bad_value);
return NULL;
if (lh.maximum_ops_per_insn == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Invalid maximum operations per instruction."));
bfd_set_error (bfd_error_bad_value);
return NULL;
if (line_ptr + (lh.opcode_base - 1) >= line_end)
{
- (*_bfd_error_handler) (_("Dwarf Error: Ran out of room reading opcodes"));
+ _bfd_error_handler (_("Dwarf Error: Ran out of room reading opcodes"));
bfd_set_error (bfd_error_bad_value);
return NULL;
}
line_ptr += exop_len - 1;
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: mangled line number section."));
bfd_set_error (bfd_error_bad_value);
line_fail:
info_ptr = read_alt_indirect_ref (unit, die_ref);
if (info_ptr == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Unable to read alt ref %u."), die_ref);
bfd_set_error (bfd_error_bad_value);
return NULL;
abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
if (! abbrev)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Could not find abbrev number %u."), abbrev_number);
bfd_set_error (bfd_error_bad_value);
}
abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
if (! abbrev)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: Could not find abbrev number %u."),
abbrev_number);
bfd_set_error (bfd_error_bad_value);
an error, just return a NULL. */
if (version)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: found dwarf version '%u', this reader"
" only handles version 2, 3 and 4 information."), version);
bfd_set_error (bfd_error_bad_value);
if (addr_size > sizeof (bfd_vma))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: found address size '%u', this reader"
" can not handle sizes greater than '%u'."),
addr_size,
if (addr_size != 2 && addr_size != 4 && addr_size != 8)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("Dwarf Error: found address size '%u', this reader"
" can only handle address sizes '2', '4' and '8'.", addr_size);
bfd_set_error (bfd_error_bad_value);
abbrev = lookup_abbrev (abbrev_number, abbrevs);
if (! abbrev)
{
- (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
- abbrev_number);
+ _bfd_error_handler (_("Dwarf Error: Could not find abbrev number %u."),
+ abbrev_number);
bfd_set_error (bfd_error_bad_value);
return NULL;
}
/* PR 17512: file: 1fe726be. */
if (! is_str_attr (attr.form))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Dwarf Error: DW_AT_comp_dir attribute encountered with a non-string form."));
comp_dir = NULL;
}
if (internal_ptr - internal < (ptrdiff_t) bfd_get_symcount (abfd))
{
bfd_get_symcount (abfd) = internal_ptr - internal;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: isymMax (%ld) is greater than ifdMax (%d)\n"),
abfd, ecoff_data (abfd)->debug_info.symbolic_header.isymMax,
ecoff_data (abfd)->debug_info.symbolic_header.ifdMax);
addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
if (addr <= last_addr)
{
- (*_bfd_error_handler) (_("%B: %s not in order"), sec->owner, sec->name);
+ _bfd_error_handler (_("%B: %s not in order"), sec->owner, sec->name);
return FALSE;
}
addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
if (addr & 1)
{
- (*_bfd_error_handler) (_("%B: %s invalid input section size"),
- sec->owner, sec->name);
+ _bfd_error_handler (_("%B: %s invalid input section size"),
+ sec->owner, sec->name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (last_addr >= addr + sec->rawsize)
{
- (*_bfd_error_handler) (_("%B: %s points past end of text section"),
- sec->owner, sec->name);
+ _bfd_error_handler (_("%B: %s points past end of text section"),
+ sec->owner, sec->name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
sec = hdr_info->u.compact.entries[i];
if (sec->output_section != osec)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Invalid output section for .eh_frame_entry: %s"),
sec->output_section->name);
return FALSE;
if (i != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Invalid contents in %s section"), osec->name);
return FALSE;
}
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_MN10300_MAX)
{
- (*_bfd_error_handler) (_("%B: unrecognised MN10300 reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised MN10300 reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MN10300_NONE;
}
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: Unsupported transition from %s to %s"),
bfd_get_filename (input_bfd),
elf_mn10300_howto_table[r_type].name,
/* Transition GD->IE. */
tls_type = GOT_TLS_IE;
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: %s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
}
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
if (strindex >= hdr->sh_size)
{
unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: invalid string offset %u >= %lu for section `%s'"),
abfd, strindex, (unsigned long) hdr->sh_size,
(shindex == shstrndx && strindex == hdr->sh_name
if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
{
symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
- (*_bfd_error_handler) (_("%B symbol number %lu references "
- "nonexistent SHT_SYMTAB_SHNDX section"),
- ibfd, (unsigned long) symoffset);
+ _bfd_error_handler (_("%B symbol number %lu references "
+ "nonexistent SHT_SYMTAB_SHNDX section"),
+ ibfd, (unsigned long) symoffset);
if (alloc_intsym != NULL)
free (alloc_intsym);
intsym_buf = NULL;
}
if (idx >= shnum)
{
- ((*_bfd_error_handler)
- (_("%B: invalid SHT_GROUP entry"), abfd));
+ _bfd_error_handler
+ (_("%B: invalid SHT_GROUP entry"), abfd);
idx = 0;
}
dest->shdr = elf_elfsections (abfd)[idx];
{
elf_tdata (abfd)->group_sect_ptr = NULL;
elf_tdata (abfd)->num_group = num_group = -1;
- (*_bfd_error_handler) (_("%B: no valid group sections found"), abfd);
+ _bfd_error_handler
+ (_("%B: no valid group sections found"), abfd);
bfd_set_error (bfd_error_bad_value);
}
}
if (elf_group_name (newsect) == NULL)
{
- (*_bfd_error_handler) (_("%B: no group info for section %A"),
- abfd, newsect);
+ _bfd_error_handler (_("%B: no group info for section %A"),
+ abfd, newsect);
return FALSE;
}
return TRUE;
sh_link. We don't want to proceed. */
if (linksec == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: sh_link [%d] in section `%A' is incorrect"),
s->owner, s, elfsec);
result = FALSE;
else if (this_hdr->sh_type == SHT_GROUP
&& elf_next_in_group (s) == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
abfd, elf_section_data (s)->this_idx);
result = FALSE;
/* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: section group entry number %u is corrupt"),
abfd, i);
result = FALSE;
else
{
/* There are some unknown sections in the group. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown [%d] section `%s' in group [%s]"),
abfd,
(unsigned int) idx->shdr->sh_type,
{
if (!bfd_init_section_compress_status (abfd, newsect))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unable to initialize compress status for section %s"),
abfd, name);
return FALSE;
{
if (!bfd_init_section_decompress_status (abfd, newsect))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unable to initialize decompress status for section %s"),
abfd, name);
return FALSE;
}
if (sections_being_created [shindex])
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: loop in section dependencies detected"), abfd);
return FALSE;
}
Unusual, but possible. Warn, but continue. */
if (elf_onesymtab (abfd) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: multiple symbol tables detected - ignoring the table in section %u"),
abfd, shindex);
goto success;
Unusual, but possible. Warn, but continue. */
if (elf_dynsymtab (abfd) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: multiple dynamic symbol tables detected - ignoring the table in section %u"),
abfd, shindex);
goto success;
/* Check for a bogus link to avoid crashing. */
if (hdr->sh_link >= num_sec)
{
- ((*_bfd_error_handler)
- (_("%B: invalid link %lu for reloc section %s (index %u)"),
- abfd, hdr->sh_link, name, shindex));
+ _bfd_error_handler
+ (_("%B: invalid link %lu for reloc section %s (index %u)"),
+ abfd, hdr->sh_link, name, shindex);
ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
shindex);
goto success;
if ((hdr->sh_flags & SHF_ALLOC) != 0)
/* FIXME: How to properly handle allocated section reserved
for applications? */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: don't know how to handle allocated, application "
"specific section `%s' [0x%8x]"),
abfd, name, hdr->sh_type);
else if (hdr->sh_type >= SHT_LOPROC
&& hdr->sh_type <= SHT_HIPROC)
/* FIXME: We should handle this section. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: don't know how to handle processor specific section "
"`%s' [0x%8x]"),
abfd, name, hdr->sh_type);
/* SHF_OS_NONCONFORMING indicates that special knowledge is
required to correctly process the section and the file should
be rejected with an error message. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: don't know how to handle OS specific section "
"`%s' [0x%8x]"),
abfd, name, hdr->sh_type);
}
else
/* FIXME: We should handle this section. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: don't know how to handle section `%s' [0x%8x]"),
abfd, name, hdr->sh_type);
/* PR 17512: file: 0eb809fe, 8b0535ee. */
if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: error: Alignment power %d of section `%A' is too big"),
abfd, asect, asect->alignment_power);
arg->failed = TRUE;
allow the link to proceed. This can happen when users link
non-bss input sections to bss output sections, or emit data
to a bss output section via a linker script. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("warning: section `%A' type changed to PROGBITS"), asect);
this_hdr->sh_type = sh_type;
}
if (discarded_section (s))
{
asection *kept;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
abfd, d->this_hdr.bfd_section,
s, s->owner);
/* Handle objcopy. */
if (s->output_section == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
abfd, d->this_hdr.bfd_section, s, s->owner);
bfd_set_error (bfd_error_bad_value);
|| (!m->p_paddr_valid
&& p->p_paddr < (bfd_vma) off))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Not enough room for program headers, try linking with -N"),
abfd);
bfd_set_error (bfd_error_bad_value);
&& (s_start < p_end
|| p_end < p_start))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
(unsigned long) s_start, (unsigned long) p_end);
adjust = 0;
if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
&& !ELF_TBSS_SPECIAL (this_hdr, p))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: section `%A' can't be allocated in segment %d"),
abfd, sec, j);
print_segment_map (m);
else if ((hdr->sh_flags & SHF_ALLOC) != 0)
{
if (hdr->sh_size != 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: allocated section `%s' not in segment"),
abfd,
(hdr->bfd_section == NULL
if (m->includes_filehdr || m->includes_phdrs)
{
/* PR 17512: file: 2195325e. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: non-load segment includes file header and/or program header"),
abfd);
return FALSE;
{
/* This case can occur when using --strip-symbol on a symbol
which is used in a relocation entry. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: symbol `%s' required but not present"),
abfd, bfd_asymbol_name (asym_ptr));
bfd_set_error (bfd_error_no_symbols);
something. They are allowed by the ELF spec however, so only
a warning is produced. */
if (segment->p_type == PT_LOAD)
- (*_bfd_error_handler) (_("\
+ _bfd_error_handler (_("\
%B: warning: Empty loadable segment detected, is this intentional ?"),
- ibfd);
+ ibfd);
map->count = 0;
*pointer_to_map = map;
{
/* PR 17512: file: f17299af. */
if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
- (*_bfd_error_handler) (_("\
+ _bfd_error_handler (_("\
%B: warning: segment alignment of 0x%llx is too large"),
- ibfd, (long long) segment->p_align);
+ ibfd, (long long) segment->p_align);
else
maxpagesize = segment->p_align;
}
if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verneed))
{
error_return_bad_verref:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: .gnu.version_r invalid entry"), abfd);
bfd_set_error (bfd_error_bad_value);
error_return_verref:
if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
{
error_return_bad_verdef:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: .gnu.version_d invalid entry"), abfd);
bfd_set_error (bfd_error_bad_value);
error_return_verdef:
return TRUE;
fail:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unsupported relocation type %s"),
abfd, areloc->howto->name);
bfd_set_error (bfd_error_bad_value);
else if (in_flags != out_flags)
{
/* Warn if different flags. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: uses different e_flags (0x%lx) fields than "
"previous modules (0x%lx)"),
bfd_get_filename (ibfd), (long)in_flags, (long)out_flags);
{
if (e_machine == EM_ARC)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Error: The ARC4 architecture is no longer supported.\n"));
return FALSE;
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: unset or old architecture flags. \n"
" Use default machine.\n"));
}
if (((relocation >> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE)
{
if (reloc_data.reloc_addend == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, "
"16 MSB should be 0x%04x (value is 0x%lx)"),
reloc_data.input_section->owner,
NPS_CMEM_HIGH_VALUE,
(relocation));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, "
"16 MSB should be 0x%04x (value is 0x%lx)"),
reloc_data.input_section->owner,
if (is_reloc_SDA_relative (howto)
&& (reloc_data.sdata_begin_symbol_vma_set == FALSE))
{
- (*_bfd_error_handler)
- ("Error: Linker symbol __SDATA_BEGIN__ not found");
+ _bfd_error_handler
+ ("Error: Linker symbol __SDATA_BEGIN__ not found");
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((is_reloc_for_GOT (howto) || is_reloc_for_PLT (howto))
&& reloc_data.sym_section == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("GOT and PLT relocations cannot be fixed with a non dynamic linker."));
bfd_set_error (bfd_error_bad_value);
return FALSE;
else
/* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */
name = "UNKNOWN";
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("\
%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd,
if (!thumb_only)
{
if (input_sec->flags & SEC_ELF_PURECODE)
- (*_bfd_error_handler) (_("%B(%s): warning: long branch "
- " veneers used in section with "
- "SHF_ARM_PURECODE section "
- "attribute is only supported"
- " for M-profile targets that "
- "implement the movw "
- "instruction."));
+ _bfd_error_handler (_("%B(%s): warning: long branch "
+ " veneers used in section with "
+ "SHF_ARM_PURECODE section "
+ "attribute is only supported"
+ " for M-profile targets that "
+ "implement the movw "
+ "instruction."));
stub_type = (bfd_link_pic (info) | globals->pic_veneer)
/* PIC stubs. */
else
{
if (input_sec->flags & SEC_ELF_PURECODE)
- (*_bfd_error_handler) (_("%B(%s): warning: long branch "
- " veneers used in section with "
- "SHF_ARM_PURECODE section "
- "attribute is only supported"
- " for M-profile targets that "
- "implement the movw "
- "instruction."));
+ _bfd_error_handler (_("%B(%s): warning: long branch "
+ " veneers used in section with "
+ "SHF_ARM_PURECODE section "
+ "attribute is only supported"
+ " for M-profile targets that "
+ "implement the movw "
+ "instruction."));
stub_type = (bfd_link_pic (info) | globals->pic_veneer)
/* PIC stub. */
else
{
if (input_sec->flags & SEC_ELF_PURECODE)
- (*_bfd_error_handler) (_("%B(%s): warning: long branch "
- " veneers used in section with "
- "SHF_ARM_PURECODE section "
- "attribute is only supported"
- " for M-profile targets that "
- "implement the movw "
- "instruction."));
+ _bfd_error_handler (_("%B(%s): warning: long branch "
+ " veneers used in section with "
+ "SHF_ARM_PURECODE section "
+ "attribute is only supported"
+ " for M-profile targets that "
+ "implement the movw "
+ "instruction."));
/* Thumb to arm. */
if (sym_sec != NULL
&& sym_sec->owner != NULL
&& !INTERWORK_FLAG (sym_sec->owner))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%s): warning: interworking not enabled.\n"
" first occurrence: %B: Thumb call to ARM"),
sym_sec->owner, input_bfd, name);
|| r_type == R_ARM_TLS_CALL)
{
if (input_sec->flags & SEC_ELF_PURECODE)
- (*_bfd_error_handler) (_("%B(%s): warning: long branch "
- " veneers used in section with "
- "SHF_ARM_PURECODE section "
- "attribute is only supported"
- " for M-profile targets that "
- "implement the movw "
- "instruction."));
+ _bfd_error_handler (_("%B(%s): warning: long branch "
+ " veneers used in section with "
+ "SHF_ARM_PURECODE section "
+ "attribute is only supported"
+ " for M-profile targets that "
+ "implement the movw "
+ "instruction."));
if (branch_type == ST_BRANCH_TO_THUMB)
{
/* Arm to thumb. */
&& sym_sec->owner != NULL
&& !INTERWORK_FLAG (sym_sec->owner))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%s): warning: interworking not enabled.\n"
" first occurrence: %B: ARM call to Thumb"),
sym_sec->owner, input_bfd, name);
out_sec = bfd_get_section_by_name (output_bfd, out_sec_name);
if (out_sec == NULL)
{
- (*_bfd_error_handler) (_("No address assigned to the veneers output "
- "section %s"), out_sec_name);
+ _bfd_error_handler (_("No address assigned to the veneers output "
+ "section %s"), out_sec_name);
return NULL;
}
}
{
if (section == NULL)
section = stub_sec;
- (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
- section->owner,
- stub_name);
+ _bfd_error_handler (_("%s: cannot create stub entry %s"),
+ section->owner, stub_name);
return NULL;
}
if (!is_v8m)
{
- (*_bfd_error_handler) (_("%B: Special symbol `%s' only allowed for "
- "ARMv8-M architecture or later."),
- input_bfd, sym_name);
+ _bfd_error_handler (_("%B: Special symbol `%s' only allowed for "
+ "ARMv8-M architecture or later."),
+ input_bfd, sym_name);
is_v8m = TRUE; /* Avoid multiple warning. */
ret = FALSE;
}
if (cmse_invalid)
{
- (*_bfd_error_handler) (_("%B: invalid special symbol `%s'."),
- input_bfd, sym_name);
- (*_bfd_error_handler) (_("It must be a global or weak function "
- "symbol."));
+ _bfd_error_handler (_("%B: invalid special symbol `%s'."),
+ input_bfd, sym_name);
+ _bfd_error_handler (_("It must be a global or weak function "
+ "symbol."));
ret = FALSE;
if (i < ext_start)
continue;
if (hash || j < ext_start)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: invalid standard symbol `%s'."), input_bfd, sym_name);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("It must be a global or weak function symbol."));
}
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: absent standard symbol `%s'."), input_bfd, sym_name);
ret = FALSE;
if (!hash)
if (cmse_hash->root.root.u.def.section != section)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' and its special symbol are in different sections."),
input_bfd, sym_name);
ret = FALSE;
don't create any stubs. */
if (section->output_section == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: entry function `%s' not output."), input_bfd, sym_name);
continue;
}
if (hash->root.size == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: entry function `%s' is empty."), input_bfd, sym_name);
ret = FALSE;
}
return TRUE;
if (stub_entry->stub_offset == (bfd_vma) -1)
- (*_bfd_error_handler) (" %s", stub_entry->output_name);
+ _bfd_error_handler (" %s", stub_entry->output_name);
return TRUE;
}
in_implib_bfd = htab->in_implib_bfd;
if (!htab->cmse_implib)
{
- (*_bfd_error_handler) (_("%B: --in-implib only supported for Secure "
- "Gateway import libraries."), in_implib_bfd);
+ _bfd_error_handler (_("%B: --in-implib only supported for Secure "
+ "Gateway import libraries."), in_implib_bfd);
return FALSE;
}
|| (ARM_GET_SYM_BRANCH_TYPE (intsym->st_target_internal)
!= ST_BRANCH_TO_THUMB))
{
- (*_bfd_error_handler) (_("%B: invalid import library entry: `%s'."),
- in_implib_bfd, sym_name);
- (*_bfd_error_handler) (_("Symbol should be absolute, global and "
- "refer to Thumb functions."));
+ _bfd_error_handler (_("%B: invalid import library entry: `%s'."),
+ in_implib_bfd, sym_name);
+ _bfd_error_handler (_("Symbol should be absolute, global and "
+ "refer to Thumb functions."));
ret = FALSE;
continue;
}
{
bfd_boolean new_stub;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Entry function `%s' disappeared from secure code."), sym_name);
hash = (struct elf32_arm_link_hash_entry *)
elf_link_hash_lookup (&(htab)->root, sym_name, TRUE, TRUE, TRUE);
{
if (!cmse_entry_fct_p (hash))
{
- (*_bfd_error_handler) (_("`%s' refers to a non entry function."),
- sym_name);
+ _bfd_error_handler (_("`%s' refers to a non entry function."),
+ sym_name);
ret = FALSE;
}
continue;
/* Check visibility hasn't changed. */
if (!!(flags & BSF_GLOBAL)
!= (hash->root.root.type == bfd_link_hash_defined))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: visibility of symbol `%s' has changed."), in_implib_bfd,
sym_name);
/* Size should match that of a SG veneer. */
if (intsym->st_size != cmse_stub_size)
{
- (*_bfd_error_handler) (_("%B: incorrect size for symbol `%s'."),
- in_implib_bfd, sym_name);
+ _bfd_error_handler (_("%B: incorrect size for symbol `%s'."),
+ in_implib_bfd, sym_name);
ret = FALSE;
}
/* Complain if stub offset not a multiple of stub size. */
if (stub_offset % cmse_stub_size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Offset of veneer for entry function `%s' not a multiple of "
"its size."), sym_name);
ret = FALSE;
if (!info->out_implib_bfd && new_cmse_stubs_created != 0)
{
BFD_ASSERT (new_cmse_stubs_created > 0);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("new entry function(s) introduced but no output import library "
"specified:"));
bfd_hash_traverse (&htab->stub_hash_table, arm_list_new_cmse_stub, info);
if (cmse_stub_array_start != cmse_stub_sec_vma)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Start address of `%s' is different from previous link."),
out_sec_name);
ret = FALSE;
TRUE, FALSE);
if (stub_entry == NULL)
{
- (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
- section->owner,
- stub_name);
+ _bfd_error_handler (_("%s: cannot create stub entry %s"),
+ section->owner, stub_name);
return FALSE;
}
default:
/* Give a warning, but do as the user requests anyway. */
- (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
+ _bfd_error_handler (_("%B: warning: selected VFP11 erratum "
"workaround is not necessary for target architecture"), obfd);
}
}
{
if (globals->stm32l4xx_fix != BFD_ARM_STM32L4XX_FIX_NONE)
/* Give a warning, but do as the user requests anyway. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: selected STM32L4XX erratum "
"workaround is not necessary for target architecture"), obfd);
}
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%B: unable to find VFP11 veneer "
+ "`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%B: unable to find VFP11 veneer "
+ "`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- (*_bfd_error_handler) (_("%B: unable to find STM32L4XX veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%B: unable to find STM32L4XX veneer "
+ "`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- (*_bfd_error_handler) (_("%B: unable to find STM32L4XX veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%B: unable to find STM32L4XX veneer "
+ "`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
{
if (is_not_last_in_it_block)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
/* Note - overlong line used here to allow for translation. */
(_("\
%B(%A+0x%lx): error: multiple load detected in non-last IT block instruction : STM32L4XX veneer cannot be generated.\n"
&& sym_sec->owner != NULL
&& !INTERWORK_FLAG (sym_sec->owner))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%s): warning: interworking not enabled.\n"
" first occurrence: %B: Thumb call to ARM"),
sym_sec->owner, input_bfd, name);
&& sym_sec->owner != NULL
&& !INTERWORK_FLAG (sym_sec->owner))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%s): warning: interworking not enabled.\n"
" first occurrence: %B: arm call to thumb"),
sym_sec->owner, input_bfd, name);
error generation. */
insn = (insn << 16)
| bfd_get_16 (input_bfd, contents + rel->r_offset + 2);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' in TLS trampoline"),
input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
return bfd_reloc_notsupported;
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' in TLS trampoline"),
input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
return bfd_reloc_notsupported;
if (bfd_link_executable (info))
v = _("PIE executable");
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against external or undefined symbol `%s'"
" can not be used when making a %s; recompile with -fPIC"), input_bfd,
elf32_arm_howto_table_1[r_type].name, h->root.root.string, v);
/* FIXME: Should we translate the instruction into a BL
instruction instead ? */
if (branch_type != ST_BRANCH_TO_THUMB)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
input_bfd,
h ? h->root.root.string : "(local)");
/* FIXME: Should we translate the instruction into a BL
instruction instead ? */
if (branch_type == ST_BRANCH_TO_THUMB)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
input_bfd,
h ? h->root.root.string : "(local)");
value = -5;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' referenced by TLS_GOTDESC"),
input_bfd, input_section,
(unsigned long)rel->r_offset, insn);
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' referenced by TLS_GOTDESC"),
input_bfd, input_section,
(unsigned long)rel->r_offset, insn);
case R_ARM_TLS_LE32:
if (bfd_link_dll (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
negative = identify_add_or_sub (insn);
if (negative == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
|| r_type == R_ARM_ALU_SB_G1
|| r_type == R_ARM_ALU_SB_G2) && residual != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
input_bfd, input_section,
(long) rel->r_offset, signed_value < 0 ? - signed_value : signed_value,
/* Check for overflow. */
if (residual >= 0x1000)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
input_bfd, input_section,
(long) rel->r_offset, labs (signed_value), howto->name);
/* Check for overflow. */
if (residual >= 0x100)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
input_bfd, input_section,
(long) rel->r_offset, labs (signed_value), howto->name);
fit in eight bits.) */
if ((residual & 0x3) != 0 || residual >= 0x400)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
input_bfd, input_section,
(long) rel->r_offset, labs (signed_value), howto->name);
if (howto->rightshift
|| (howto->src_mask & (howto->src_mask + 1)))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
|| h->root.type == bfd_link_hash_defweak)
&& IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((sym_type == STT_TLS
? _("%B(%A+0x%lx): %s used with TLS symbol %s")
: _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
{
if (flags & EF_ARM_INTERWORK)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
abfd);
else
object file containing relocations but no symbol table. */
&& (r_symndx > STN_UNDEF || nsyms > 0))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
- r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"), abfd,
+ r_symndx);
return FALSE;
}
case R_ARM_THM_MOVT_ABS:
if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd, elf32_arm_howto_table_1[r_type].name,
(h) ? h->root.root.string : "a local symbol");
s = bfd_get_linker_section (dynobj, name);
if (s == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("could not find section %s"), name);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
This check is just to be on the safe side... */
if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
{
- (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
- "allocated in unsafe location"), abfd);
+ _bfd_error_handler (_("%B: error: Cortex-A8 erratum stub is "
+ "allocated in unsafe location"), abfd);
return FALSE;
}
{
/* There's not much we can do apart from complain if this
happens. */
- (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
- "of range (input file too large)"), abfd);
+ _bfd_error_handler (_("%B: error: Cortex-A8 erratum stub out "
+ "of range (input file too large)"), abfd);
return FALSE;
}
if ((signed) branch_to_veneer < -(1 << 25)
|| (signed) branch_to_veneer >= (1 << 25))
- (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
- "range"), output_bfd);
+ _bfd_error_handler (_("%B: error: VFP11 veneer out of "
+ "range"), output_bfd);
insn |= (branch_to_veneer >> 2) & 0xffffff;
contents[endianflip ^ target] = insn & 0xff;
if ((signed) branch_from_veneer < -(1 << 25)
|| (signed) branch_from_veneer >= (1 << 25))
- (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
- "range"), output_bfd);
+ _bfd_error_handler (_("%B: error: VFP11 veneer out of "
+ "range"), output_bfd);
/* Original instruction. */
insn = errnode->u.v.branch->u.b.vfp_insn;
((signed) branch_to_veneer >= (1 << 24)) ?
branch_to_veneer - (1 << 24) : 0;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%#x): error: Cannot create STM32L4XX veneer. "
"Jump out of range by %ld bytes. "
"Cannot encode branch instruction. "),
STM32L4XX_ERRATUM_LDM_VENEER_SIZE) < -(1 << 24)
|| (signed) (veneer_r - veneer) >= (1 << 24))
{
- (*_bfd_error_handler) (_("%B: error: Cannot create STM32L4XX "
- "veneer."), output_bfd);
+ _bfd_error_handler (_("%B: error: Cannot create STM32L4XX "
+ "veneer."), output_bfd);
continue;
}
if (hsh == NULL)
{
- (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
- NULL, stub_name);
+ _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ NULL, stub_name);
return NULL;
}
/* if rightshift is 1 and the number odd, return error. */
if (howto->rightshift && (relocation & 0x01))
{
- (*_bfd_error_handler) (_("relocation should be even number"));
+ _bfd_error_handler (_("relocation should be even number"));
return bfd_reloc_overflow;
}
/* If rightshift is 1 and the number odd, return error. */
if (howto->rightshift && (relocation & 0x01))
{
- (*_bfd_error_handler) (_("relocation should be even number"));
+ _bfd_error_handler (_("relocation should be even number"));
return bfd_reloc_overflow;
}
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
input_bfd,
input_section, (long) rel->r_offset, h->root.root.string);
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): reloc against `%s': error %d"),
input_bfd, input_section,
(long) rel->r_offset, name, (int) r);
osec, sym,
rel->r_addend))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
input_bfd, input_section, rel->r_offset, name);
return FALSE;
if (bfinfdpic_gotfixup_section (info)->size
!= (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("LINKER BUG: .rofixup section size mismatch");
return FALSE;
}
default:
bad_reloc:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unsupported relocation type %i"),
abfd, ELF32_R_TYPE (rel->r_info));
return FALSE;
#ifndef DEBUG
if (0)
#endif
- (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
- old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
- bfd_get_filename (ibfd));
+ _bfd_error_handler
+ ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
+ old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
+ bfd_get_filename (ibfd));
if (!elf_flags_init (obfd)) /* First call, no flags set. */
{
{
error = TRUE;
if (IS_FDPIC (obfd))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: cannot link non-fdpic object file into fdpic executable"),
bfd_get_filename (ibfd));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: cannot link fdpic object file into non-fdpic executable"),
bfd_get_filename (ibfd));
}
&& (info->symbolic
|| h->dynindx == -1 || h->forced_local) && h->def_regular)
{
- (*_bfd_error_handler) (_("*** check this relocation %s"),
- __FUNCTION__);
+ _bfd_error_handler (_("*** check this relocation %s"),
+ __FUNCTION__);
rela.r_info = ELF32_R_INFO (0, R_BFIN_PCREL24);
rela.r_addend = bfd_get_signed_32 (output_bfd,
(sgot->contents
#else
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
{
- (*_bfd_error_handler) (_("the bfin target does not currently support the generation of copy relocations"));
+ _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
return FALSE;
}
#endif
if (r_type >= R_CR16_MAX)
{
- (*_bfd_error_handler) (_("%B: unrecognised CR16 reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised CR16 reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_CR16_NONE;
}
|| (!h->def_dynamic
&& h->root.type == bfd_link_hash_undefweak)))))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((h->got.offset == (bfd_vma) -1)
? _("%B, section %A: No PLT nor GOT for relocation %s"
" against symbol `%s'")
symbols. Make this an error; the compiler isn't
allowed to pass us these kinds of things. */
if (h == NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with non-zero addend %d"
" against local symbol"),
input_bfd,
cris_elf_howto_table[r_type].name,
rel->r_addend);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with non-zero addend %d"
" against symbol `%s'"),
input_bfd,
|| (!h->def_dynamic
&& h->root.type == bfd_link_hash_undefweak))))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s is"
" not allowed for global symbol: `%s'"),
input_bfd,
it's noticed if it happens elsewhere. */
if (sgot == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with no GOT created"),
input_bfd,
input_section,
|| (!h->def_regular
&& h->root.type != bfd_link_hash_undefined)))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((h->root.type == bfd_link_hash_undefined)
/* We shouldn't get here for GCC-emitted code. */
? _("%B, section %A: relocation %s has an undefined"
symbol *plus offset*. The GOT holds relocations for
symbols. Make this an error; the compiler isn't allowed
to pass us these kinds of things. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with non-zero addend %d"
" against symbol `%s'"),
input_bfd,
relocations for symbols. Make this an error; the
compiler isn't allowed to pass us these kinds of
things. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with non-zero addend %d"
" against symbol `%s'"),
input_bfd,
been emitted. */
&& h->root.type != bfd_link_hash_undefined)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s is"
" not allowed for symbol: `%s'"
" which is defined outside the program,"
only. */
case R_CRIS_16_GOT_TPREL:
case R_CRIS_16_GOT_GD:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("(too many global variables for -fpic:"
" recompile with -fPIC)"));
break;
case R_CRIS_16_TPREL:
case R_CRIS_16_DTPREL:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("(thread-local data too big for -fpic or"
" -msmall-tls: recompile with -fPIC or"
" -mno-small-tls)"));
that, we must insist on dynobj being a specific mach. */
if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A:\n v10/v32 compatible object %s"
" must not contain a PIC relocation"),
abfd, sec);
case R_CRIS_32_GD:
if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A:\n relocation %s not valid"
" in a shared object;"
" typically an option mixup, recompile with -fPIC"),
&& (sec->flags & SEC_READONLY) != 0)
{
/* FIXME: How do we make this optionally a warning only? */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A:\n relocation %s should not"
" be used in a shared object; recompile with -fPIC"),
abfd,
if ((s->section->flags & SEC_READONLY) != 0)
{
/* FIXME: How do we make this optionally a warning only? */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section `%A', to symbol `%s':\n"
" relocation %s should not be used"
" in a shared object; recompile with -fPIC"),
if (bfd_get_symbol_leading_char (ibfd)
!= bfd_get_symbol_leading_char (obfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(bfd_get_symbol_leading_char (ibfd) == '_'
? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols")
: _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
|| (omach == bfd_mach_cris_v32
&& imach != bfd_mach_cris_v10_v32))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((imach == bfd_mach_cris_v32)
? _("%B contains CRIS v32 code, incompatible"
" with previous objects")
unsigned int r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_CRX_MAX)
{
- (*_bfd_error_handler) (_("%B: unrecognised CRX reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised CRX reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_CRX_NONE;
}
/* Can not support a long jump to sections other then .text. */
if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
{
- (*_bfd_error_handler) (_("BFD Link Error: branch (PC rel16) to section (%s) not supported"),
- symbol->section->output_section->name);
+ _bfd_error_handler
+ (_("BFD Link Error: branch (PC rel16) to section (%s) not supported"),
+ symbol->section->output_section->name);
return bfd_reloc_undefined;
}
/* Can not support a long jump to sections other then .text */
if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
{
- (*_bfd_error_handler) (_("BFD Link Error: jump (PC rel26) to section (%s) not supported"),
- symbol->section->output_section->name);
+ _bfd_error_handler
+ (_("BFD Link Error: jump (PC rel26) to section (%s) not supported"),
+ symbol->section->output_section->name);
return bfd_reloc_undefined;
}
new_flags &= ~EF_FRV_PIC;
#ifdef DEBUG
- (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
- old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
- bfd_get_filename (ibfd));
+ _bfd_error_handler
+ ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
+ old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
+ bfd_get_filename (ibfd));
#endif
if (!elf_flags_init (obfd)) /* First call, no flags set. */
old_flags &= ~ EF_FRV_PIC_FLAGS;
#ifndef FRV_NO_PIC_ERROR
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: compiled with %s and linked with modules that use non-pic relocations"),
bfd_get_filename (ibfd),
(new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
if (new_opt[0])
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: compiled with %s and linked with modules compiled with %s"),
bfd_get_filename (ibfd), new_opt, old_opt);
}
{
old_flags |= new_partial;
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
}
{
error = TRUE;
if (IS_FDPIC (obfd))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: cannot link non-fdpic object file into fdpic executable"),
bfd_get_filename (ibfd));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: cannot link fdpic object file into non-fdpic executable"),
bfd_get_filename (ibfd));
}
TRUE, FALSE);
if (hsh == NULL)
{
- (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
- section->owner,
- stub_name);
+ _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ section->owner, stub_name);
return NULL;
}
&& (!htab->has_22bit_branch
|| sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
hsh->target_section->owner,
stub_sec,
case R_PARISC_DPREL21L:
if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
abfd,
elf_hppa_howto_table[r_type].name);
}
else
{
- (*_bfd_error_handler) (_("%B: duplicate export stub %s"),
- input_bfd,
- stub_name);
+ _bfd_error_handler (_("%B: duplicate export stub %s"),
+ input_bfd, stub_name);
}
}
}
/* We must have a ldil instruction. It's too hard to find
and convert the associated add instruction, so issue an
error. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
input_bfd,
input_section,
if (max_branch_offset != 0
&& value + addend + max_branch_offset >= 2*max_branch_offset)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
input_bfd,
input_section,
{
if (rstatus == bfd_reloc_notsupported || !warned_undef)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): cannot handle %s for %s"),
input_bfd,
input_section,
!= (sgot->output_offset
+ sgot->output_section->vma))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_(".got section not immediately after .plt section"));
return FALSE;
}
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_I370_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised I370 reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised I370 reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_I370_NONE;
}
else /* Incompatible flags. */
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
ibfd, (long) new_flags, (long) old_flags);
if ((unsigned) r_type >= (unsigned) R_I370_max
|| !i370_elf_howto_table[(int)r_type])
{
- (*_bfd_error_handler) ("%B: unknown relocation type %d",
- input_bfd,
- (int) r_type);
+ _bfd_error_handler ("%B: unknown relocation type %d",
+ input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
switch ((int) r_type)
{
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: unknown relocation type %d for symbol %s",
input_bfd, (int) r_type, sym_name);
case (int) R_I370_COPY:
case (int) R_I370_RELATIVE:
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: Relocation %s is not yet supported for symbol %s.",
input_bfd,
i370_elf_howto_table[(int) r_type]->name,
&& ((indx = r_type - R_386_vt_offset) - R_386_ext2
>= R_386_vt - R_386_ext2))
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, (int) r_type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, (int) r_type);
indx = R_386_NONE;
}
/* PR 17512: file: 0f67f69d. */
}
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
"in section `%A' failed"),
abfd, sec, from->name, to->name, name,
else
name = h->root.root.string;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
abfd, name);
return FALSE;
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd,
- r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
goto error_return;
}
else
name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and "
"thread local symbol"),
abfd, name);
else
name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unsupported non-PIC call to IFUNC `%s'"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
&& ((indx = r_type - R_386_tls_offset) - R_386_ext
>= R_386_ext2 - R_386_ext))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unrecognized relocation (0x%x) in section `%A'"),
input_bfd, input_section, r_type);
bfd_set_error (bfd_error_bad_value);
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't supported"), input_bfd,
howto->name, name);
else
name = h->root.root.string;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: direct GOT relocation %s against `%s' without base register can not be used when making a shared object"),
input_bfd, howto->name, name);
bfd_set_error (bfd_error_bad_value);
break;
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
input_bfd, v, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
|| h->type == STT_OBJECT)
&& ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
input_bfd,
h->type == STT_FUNC ? "function" : "data",
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): reloc against `%s': error %d"),
input_bfd, input_section,
(long) rel->r_offset, name, (int) r);
{
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("discarded output section: `%A'"), htab->elf.sgotplt);
return FALSE;
}
/* Addend should be zero. */
if (rel->r_addend != 0)
- (*_bfd_error_handler) (_("internal error: addend should be zero for R_LM32_16_GOT"));
+ _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
r = _bfd_final_link_relocate (howto,
input_bfd,
if (lm32fdpic_fixup32_section (info)->size
!= (lm32fdpic_fixup32_section (info)->reloc_count * 4))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
lm32fdpic_fixup32_section (info)->size/4,
lm32fdpic_fixup32_section (info)->reloc_count);
BFD_ASSERT (hend->u.def.value == value);
if (hend->u.def.value != value)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
return FALSE;
}
old_flags = elf_elfheader (obfd)->e_flags;
#ifdef DEBUG
- (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
- old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
- bfd_get_filename (ibfd));
+ _bfd_error_handler
+ ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
+ old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
+ bfd_get_filename (ibfd));
#endif
if (!elf_flags_init (obfd))
if (new_opt[0])
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: compiled with %s and linked with modules compiled with %s"),
bfd_get_filename (ibfd), new_opt, old_opt);
}
if (new_flags != old_flags)
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
}
r_type = ELF32_R_TYPE (rel->r_info);
if (r_type < 0 || r_type >= (int) R_M32R_max)
{
- (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
- input_bfd,
- (int) r_type);
+ _bfd_error_handler (_("%B: unknown relocation type %d"),
+ input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
continue;
rel->r_offset)
!= (bfd_vma) -1))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
input_bfd,
sec,
|| ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
|| ((in_flags & EF_M32R_ARCH) == E_M32R2_ARCH))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Instruction set mismatch with previous modules"), ibfd);
bfd_set_error (bfd_error_bad_value);
TRUE, FALSE);
if (stub_entry == NULL)
{
- (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
- section->owner, stub_name);
+ _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ section->owner, stub_name);
return NULL;
}
/* Check ABI compatibility. */
if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking files compiled for 16-bit integers (-mshort) "
"and others for 32-bit integers"), ibfd);
ok = FALSE;
}
if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking files compiled for 32-bit double (-fshort-double) "
"and others for 64-bit double"), ibfd);
ok = FALSE;
/* Processor compatibility. */
if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking files compiled for HCS12 with "
"others compiled for HC12"), ibfd);
ok = FALSE;
/* Warn about any other mismatches */
if (new_flags != old_flags)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
ok = FALSE;
if (indx >= (unsigned int) R_68K_max)
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, (int) indx);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, (int) indx);
indx = R_68K_NONE;
}
cache_ptr->howto = &howto_table[indx];
/* This BFD has too many relocation. */
{
if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
- (*_bfd_error_handler) (_("%B: GOT overflow: "
- "Number of relocations with 8-bit "
- "offset > %d"),
- abfd,
- ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
+ _bfd_error_handler (_("%B: GOT overflow: "
+ "Number of relocations with 8-bit "
+ "offset > %d"),
+ abfd,
+ ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
else
- (*_bfd_error_handler) (_("%B: GOT overflow: "
- "Number of relocations with 8- or 16-bit "
- "offset > %d"),
- abfd,
- ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
+ _bfd_error_handler (_("%B: GOT overflow: "
+ "Number of relocations with 8- or 16-bit "
+ "offset > %d"),
+ abfd,
+ ELF_M68K_R_8_16_MAX_N_SLOTS_IN_GOT (info));
return NULL;
}
case R_68K_TLS_LE8:
if (bfd_link_dll (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted "
"in shared object"),
input_bfd, input_section, (long) rel->r_offset, howto->name);
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
name = bfd_section_name (input_bfd, sec);
}
- (*_bfd_error_handler)
+ _bfd_error_handler
((sym_type == STT_TLS
? _("%B(%A+0x%lx): %s used with TLS symbol %s")
: _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): reloc against `%s': error %d"),
input_bfd, input_section,
(long) rel->r_offset, name, (int) r);
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_MCORE_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised MCore reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised MCore reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MCORE_NONE;
}
default:
/* Pacify gcc -Wall. */
- (*_bfd_error_handler) (_("mep: no reloc for code %d"), code);
+ _bfd_error_handler (_("mep: no reloc for code %d"), code);
return NULL;
}
if (mep_elf_howto_table[type].type != type)
{
- (*_bfd_error_handler) (_("MeP: howto %d has type %d"),
- type, mep_elf_howto_table[type].type);
+ _bfd_error_handler (_("MeP: howto %d has type %d"),
+ type, mep_elf_howto_table[type].type);
abort ();
}
TRUE, FALSE);
if (hsh == NULL)
{
- (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
- section->owner,
- stub_name);
+ _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ section->owner, stub_name);
return NULL;
}
case R_METAG_TLS_LE_LO16:
if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): R_METAG_TLS_LE/IENONPIC relocation not permitted in shared object"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
name = hh->eh.root.root.string;
else
name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd, elf_metag_howto_table[r_type].name, name);
bfd_set_error (bfd_error_bad_value);
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_MICROBLAZE_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised MicroBlaze reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised MicroBlaze reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MICROBLAZE_NONE;
}
if (r_type < 0 || r_type >= (int) R_MICROBLAZE_max)
{
- (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
- bfd_get_filename (input_bfd), (int) r_type);
+ _bfd_error_handler (_("%s: unknown relocation type %d"),
+ bfd_get_filename (input_bfd), (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
continue;
}
else
{
- (*_bfd_error_handler) (_("%s: The target (%s) of an %s relocation is in the wrong section (%s)"),
- bfd_get_filename (input_bfd),
- sym_name,
- microblaze_elf_howto_table[(int) r_type]->name,
- bfd_get_section_name (sec->owner, sec));
+ _bfd_error_handler
+ (_("%s: The target (%s) of an %s relocation "
+ "is in the wrong section (%s)"),
+ bfd_get_filename (input_bfd),
+ sym_name,
+ microblaze_elf_howto_table[(int) r_type]->name,
+ bfd_get_section_name (sec->owner, sec));
/*bfd_set_error (bfd_error_bad_value); ??? why? */
ret = FALSE;
continue;
}
else
{
- (*_bfd_error_handler) (_("%s: The target (%s) of an %s relocation is in the wrong section (%s)"),
- bfd_get_filename (input_bfd),
- sym_name,
- microblaze_elf_howto_table[(int) r_type]->name,
- bfd_get_section_name (sec->owner, sec));
+ _bfd_error_handler
+ (_("%s: The target (%s) of an %s relocation "
+ "is in the wrong section (%s)"),
+ bfd_get_filename (input_bfd),
+ sym_name,
+ microblaze_elf_howto_table[(int) r_type]->name,
+ bfd_get_section_name (sec->owner, sec));
/*bfd_set_error (bfd_error_bad_value); ??? why? */
ret = FALSE;
continue;
else
{
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return &elf_mips16_howto_table_rel[r_type - R_MIPS16_min];
if (r_type >= (unsigned int) R_MIPS_max)
{
- (*_bfd_error_handler) (_("Unrecognised MIPS reloc number: %d"), r_type);
+ _bfd_error_handler (_("Unrecognised MIPS reloc number: %d"), r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MIPS_NONE;
}
}
else
{
- (*_bfd_error_handler) (_("error: Can't find symbol: _SDA_BASE_."));
+ _bfd_error_handler (_("error: Can't find symbol: _SDA_BASE_."));
return bfd_reloc_dangerous;
}
}
/* Set the _ITB_BASE_. */
if (!nds32_elf_ex9_itb_base (info))
{
- (*_bfd_error_handler) (_("%B: error: Cannot set _ITB_BASE_"),
- output_bfd);
+ _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"),
+ output_bfd);
bfd_set_error (bfd_error_bad_value);
}
}
if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
if (!nds32_elf_ifc_reloc ())
- (*_bfd_error_handler) (_("error: IFC relocation error."));
+ _bfd_error_handler (_("error: IFC relocation error."));
/* Relocation for .ex9.itable. */
if (table->target_optimize & NDS32_RELAX_EX9_ON
r_type = ELF32_R_TYPE (rel->r_info);
if (r_type >= R_NDS32_max)
{
- (*_bfd_error_handler) (_("%B: error: unknown relocation type %d."),
- input_bfd, r_type);
+ _bfd_error_handler (_("%B: error: unknown relocation type %d."),
+ input_bfd, r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
continue;
case R_NDS32_25_ABS_RELA:
if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
"mode."), bfd_get_filename (input_bfd));
return FALSE;
if (relocation & align)
{
/* Incorrect alignment. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: unaligned access to GOT entry."), input_bfd);
ret = FALSE;
r = bfd_reloc_dangerous;
r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
if (r != bfd_reloc_ok)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: relocate SDA_BASE failed."), input_bfd);
ret = FALSE;
goto check_reloc;
if (relocation & align)
{
/* Incorrect alignment. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A): warning: unaligned small data access of type %d."),
input_bfd, input_section, r_type);
ret = FALSE;
nds32_vec_size = (flag_t & 0x3);
else if (nds32_vec_size != (flag_t & 0x3))
{
- (*_bfd_error_handler) (_("%B: ISR vector size mismatch"
- " with previous modules, previous %u-byte, current %u-byte"),
- ibfd,
- nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
- (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
+ _bfd_error_handler
+ (_("%B: ISR vector size mismatch"
+ " with previous modules, previous %u-byte, current %u-byte"),
+ ibfd,
+ nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
+ (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
return FALSE;
}
else
if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Endian mismatch with previous modules."), ibfd);
bfd_set_error (bfd_error_bad_value);
in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
if (in_version == E_NDS32_ELF_VER_1_2)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Older version of object file encountered, "
"Please recompile with current tool chain."), ibfd);
}
/* Check flag compatibility. */
if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: error: ABI mismatch with previous modules."), ibfd);
bfd_set_error (bfd_error_bad_value);
{
if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: error: Instruction set mismatch with previous modules."), ibfd);
bfd_set_error (bfd_error_bad_value);
else
{
if (in_version != out_version)
- (*_bfd_error_handler) (_("%B: warning: Incompatible elf-versions %s and %s."),
- ibfd, nds32_elfver_strtab[out_version],
- nds32_elfver_strtab[in_version]);
+ _bfd_error_handler
+ (_("%B: warning: Incompatible elf-versions %s and %s."),
+ ibfd, nds32_elfver_strtab[out_version],
+ nds32_elfver_strtab[in_version]);
elf_elfheader (obfd)->e_flags = in_flags | out_flags
| (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
if (blank_t2 && blank_t2->next
&& (blank_t2->offset > raddr
|| blank_t2->next->offset <= raddr))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: %s\n"), abfd,
"Error: search_nds32_elf_blank reports wrong node");
if (hi_irelfn == irelend || lo_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL1 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (i1_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL2 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (hi_irelfn == irelend || lo_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL3 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
R_NDS32_LO12S0_ORI_RELA, laddr + 4);
if (hi_irelfn == irelend || lo_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP1 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (i2_irelfn == irelend || cond_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP2 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP3 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (hi_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (ptr_irel == irelend || em_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
R_NDS32_25_PCREL_RELA, irel->r_addend);
if (cond_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL5 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (em_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
R_NDS32_PTR_RESOLVED, irel->r_addend);
if (cond_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
R_NDS32_PTR_RESOLVED, irel->r_addend);
if (cond_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (hi_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (ptr_irel == irelend || em_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
R_NDS32_25_PCREL_RELA, irel->r_addend);
if (cond_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP5 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (em_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP6 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
R_NDS32_15_PCREL_RELA, irel->r_addend);
if (cond_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LONGJUMP7 points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (hi_irelfn == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_LOADSTORE points to unrecognized"
"reloc at 0x%lx.", abfd, (long) irel->r_offset);
return FALSE;
if (re_irel == irelend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: warning: R_NDS32_PTR points to unrecognized reloc at 0x%lx.",
abfd, (long) irel->r_offset);
return FALSE;
break;
case NDS32_RELAX_JUMP_IFC_ROUND:
if (!nds32_elf_ifc_finish (link_info))
- (*_bfd_error_handler) (_("error: Jump IFC Fail."));
+ _bfd_error_handler (_("error: Jump IFC Fail."));
if (table->target_optimize & NDS32_RELAX_EX9_ON)
{
pass++;
{
/* Do jump IFC optimization again. */
if (!nds32_elf_ifc_finish (link_info))
- (*_bfd_error_handler) (_("error: Jump IFC Fail."));
+ _bfd_error_handler (_("error: Jump IFC Fail."));
}
break;
default:
/* Set the _ITB_BASE_. */
if (!nds32_elf_ex9_itb_base (link_info))
{
- (*_bfd_error_handler) (_("%B: error: Cannot set _ITB_BASE_"), abfd);
+ _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"), abfd);
bfd_set_error (bfd_error_bad_value);
}
}
{
/* Begin of the region. */
if (begin_rel)
- (*_bfd_error_handler) (_("%B: Nested OMIT_FP in %A."), abfd, sec);
+ _bfd_error_handler (_("%B: Nested OMIT_FP in %A."), abfd, sec);
begin_rel = irel;
nds32_fag_init (&fag_head);
if (begin_rel == NULL)
{
- (*_bfd_error_handler) (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
+ _bfd_error_handler (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
continue;
}
sizeof (struct elf_nds32_code_hash_entry),
1023))
{
- (*_bfd_error_handler) (_("Linker: cannot init ex9 hash table error \n"));
+ _bfd_error_handler (_("Linker: cannot init ex9 hash table error \n"));
return FALSE;
}
return TRUE;
if (!nds32_get_section_contents
(fix_ptr->sec->owner, fix_ptr->sec,
&source_contents, TRUE))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Linker: error cannot fixed ex9 relocation \n"));
if (temp_ptr->order < 32)
insn_ex9 = INSN_EX9_IT_2;
else
{
if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Linker: error cannot fixed ex9 relocation \n"));
else
temp_ptr = temp_ptr->next;
if (relocation & align)
{
/* Incorrect alignment. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: unaligned small data access. "
"For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
bfd_get_filename (abfd), irel->r_offset,
bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
if (entry == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
return FALSE;
}
TRUE, FALSE);
if (hsh == NULL)
{
- (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
- section->owner,
- stub_name);
+ _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ section->owner,
+ stub_name);
return NULL;
}
case EF_NIOS2_ARCH_R2:
if (bfd_big_endian (ibfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("error: %B: Big-endian R2 is not supported."), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
/* So far, the only incompatible flags denote incompatible
architectures. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("error: %B: Conflicting CPU architectures %d/%d"),
ibfd, new_flags, old_flags);
bfd_set_error (bfd_error_bad_value);
case R_NIOS2_TLS_LE16:
if (bfd_link_dll (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): R_NIOS2_TLS_LE16 relocation not "
"permitted in shared object"),
input_bfd, input_section,
if (h->size == 0)
{
- (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
- h->root.root.string);
+ _bfd_error_handler (_("dynamic variable `%s' is zero size"),
+ h->root.root.string);
return TRUE;
}
/* Addend should be zero. */
if (rel->r_addend != 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("internal error: addend should be zero for R_OR1K_GOT16"));
break;
else
{
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
case R_OR1K_TLS_LDO_LO16:
/* TODO: implement support for local dynamic. */
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: support for local dynamic not implemented"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
/* These are resolved dynamically on load and shouldn't
be used as linker input. */
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: will not resolve runtime TLS relocation"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
|| strcmp (bfd_get_section_name (abfd, sec),
name + 5) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad relocation section name `%s\'"),
abfd, name);
}
if ((in_flags & EF_OR1K_NODELAY) != (out_flags & EF_OR1K_NODELAY))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: EF_OR1K_NODELAY flag mismatch with previous modules"), ibfd);
bfd_set_error (bfd_error_bad_value);
if (r >= R_PJ_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised PicoJava reloc number: %d"),
- abfd, r);
+ _bfd_error_handler (_("%B: unrecognised PicoJava reloc number: %d"),
+ abfd, r);
bfd_set_error (bfd_error_bad_value);
r = R_PJ_NONE;
}
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_PPC_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised PPC reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised PPC reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_PPC_NONE;
}
ELF32_R_TYPE (dst->r_info) is necessarily a valid relocation. */
if (!cache_ptr->howto)
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
cache_ptr->howto = ppc_elf_howto_table[R_PPC_NONE];
free (buffer);
if (error_message)
- (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME);
+ _bfd_error_handler (error_message, ibfd, APUINFO_SECTION_NAME);
}
/* Prevent the output section from accumulating the input sections'
buffer = bfd_malloc (length);
if (buffer == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("failed to allocate space for new APUinfo section."));
return;
}
}
if (length != asec->size)
- (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
+ _bfd_error_handler (_("failed to compute new APUinfo section."));
if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
- (*_bfd_error_handler) (_("failed to install new APUinfo section."));
+ _bfd_error_handler (_("failed to install new APUinfo section."));
free (buffer);
static void
bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s cannot be used when making a shared object"),
abfd,
ppc_elf_howto_table[r_type]->name);
&& (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: compiled with -mrelocatable and linked with "
"modules compiled normally"), ibfd);
}
&& (old_flags & EF_PPC_RELOCATABLE) != 0)
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: compiled normally and linked with "
"modules compiled with -mrelocatable"), ibfd);
}
if (new_flags != old_flags)
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: uses different e_flags (0x%lx) fields "
"than previous modules (0x%lx)"),
ibfd, (long) new_flags, (long) old_flags);
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: the target (%s) of a %s relocation is "
"in the wrong output section (%s)"),
input_bfd,
but that is still incompatible with the G10 ABI. */
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("RL78 ABI conflict: G10 file %s cannot be linked with %s file %s"),
bfd_get_filename (ibfd),
rl78_cpu_name (out_cpu), bfd_get_filename (obfd));
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("RL78 ABI conflict: cannot link %s file %s with %s file %s"),
rl78_cpu_name (in_cpu), bfd_get_filename (ibfd),
rl78_cpu_name (out_cpu), bfd_get_filename (obfd));
if (changed_flags & E_FLAG_RL78_64BIT_DOUBLES)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("RL78 merge conflict: cannot link 32-bit and 64-bit objects together"));
if (old_flags & E_FLAG_RL78_64BIT_DOUBLES)
- (*_bfd_error_handler) (_("- %s is 64-bit, %s is not"),
- bfd_get_filename (obfd), bfd_get_filename (ibfd));
+ _bfd_error_handler (_("- %s is 64-bit, %s is not"),
+ bfd_get_filename (obfd), bfd_get_filename (ibfd));
else
- (*_bfd_error_handler) (_("- %s is 64-bit, %s is not"),
- bfd_get_filename (ibfd), bfd_get_filename (obfd));
+ _bfd_error_handler (_("- %s is 64-bit, %s is not"),
+ bfd_get_filename (ibfd), bfd_get_filename (obfd));
error = TRUE;
}
}
default:
if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, (int) r_type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, (int) r_type);
r_type = R_390_NONE;
}
cache_ptr->howto = &elf_howto_table[r_type];
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
{
if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
return FALSE;
reloc_howto_type *howto;
howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
input_bfd,
input_section,
&& h->def_dynamic)
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): reloc against `%s': error %d"),
input_bfd, input_section,
(long) rel->r_offset, name, (int) r);
{
(*loc)->gotidx = -1;
/* We didn't allocate enough space in the GOT. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("not enough GOT space for local GOT entries"));
bfd_set_error (bfd_error_bad_value);
return NULL;
}
else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%s: Malformed reloc detected for section %s"), abfd, name);
+ _bfd_error_handler
+ (_("%s: Malformed reloc detected for section %s"), abfd, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_SCORE_CALL15:
if (h == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: CALL15 reloc at 0x%lx not against global symbol"),
abfd, (unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
}
if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0))
- {
- (*_bfd_error_handler) (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
- }
+ _bfd_error_handler
+ (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
/* FIXME: Maybe dependency fix compatibility should be checked here. */
{
(*loc)->gotidx = -1;
/* We didn't allocate enough space in the GOT. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("not enough GOT space for local GOT entries"));
bfd_set_error (bfd_error_bad_value);
return NULL;
}
else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%s: Malformed reloc detected for section %s"), abfd, name);
+ _bfd_error_handler
+ (_("%s: Malformed reloc detected for section %s"), abfd, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_SCORE_CALL15:
if (h == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: CALL15 reloc at 0x%lx not against global symbol"),
abfd, (unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0))
{
- (*_bfd_error_handler) (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
+ _bfd_error_handler (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
}
/* Maybe dependency fix compatibility should be checked here. */
|| (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5)
|| (r >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
{
- (*_bfd_error_handler) (_("%B: unrecognised SH reloc number: %d"),
- abfd, r);
+ _bfd_error_handler (_("%B: unrecognised SH reloc number: %d"),
+ abfd, r);
bfd_set_error (bfd_error_bad_value);
r = R_SH_NONE;
}
laddr = irel->r_offset + 4 + irel->r_addend;
if (laddr >= sec->size)
{
- (*_bfd_error_handler) (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
- abfd,
- (unsigned long) irel->r_offset);
+ _bfd_error_handler (_("%B: 0x%lx: warning: bad R_SH_USES offset"),
+ abfd, (unsigned long) irel->r_offset);
continue;
}
insn = bfd_get_16 (abfd, contents + laddr);
do. */
if ((insn & 0xf000) != 0xd000)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
- abfd, (unsigned long) irel->r_offset, insn));
+ _bfd_error_handler
+ (_("%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
+ abfd, (unsigned long) irel->r_offset, insn);
continue;
}
paddr += (laddr + 4) &~ (bfd_vma) 3;
if (paddr >= sec->size)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
- abfd, (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ (_("%B: 0x%lx: warning: bad R_SH_USES load offset"),
+ abfd, (unsigned long) irel->r_offset);
continue;
}
break;
if (irelfn >= irelend)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: could not find expected reloc"),
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ (_("%B: 0x%lx: warning: could not find expected reloc"),
+ abfd, (unsigned long) paddr);
continue;
}
if (isym->st_shndx
!= (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: symbol in unexpected section"),
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ (_("%B: 0x%lx: warning: symbol in unexpected section"),
+ abfd, (unsigned long) paddr);
continue;
}
/* Now check whether we got a COUNT reloc. */
if (irelcount >= irelend)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
- abfd, (unsigned long) paddr));
+ _bfd_error_handler
+ (_("%B: 0x%lx: warning: could not find expected COUNT reloc"),
+ abfd, (unsigned long) paddr);
continue;
}
just deleted one. */
if (irelcount->r_addend == 0)
{
- ((*_bfd_error_handler) (_("%B: 0x%lx: warning: bad count"),
- abfd,
- (unsigned long) paddr));
+ _bfd_error_handler (_("%B: 0x%lx: warning: bad count"),
+ abfd, (unsigned long) paddr);
continue;
}
if (overflow)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
- abfd, (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
+ abfd, (unsigned long) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (overflow)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
- abfd, (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: reloc overflow while relaxing"),
+ abfd, (unsigned long) irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (howto->rightshift || howto->src_mask != 0xffffffff)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
rel->r_offset)
!= (bfd_vma) -1))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
}
if (disp & mask)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
- input_section->owner,
- (unsigned long) rel->r_offset));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
+ input_section->owner,
+ (unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_SH_DIR4UL:
if (relocation & 3)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
- input_section->owner,
- (unsigned long) rel->r_offset, howto->name,
- (unsigned long) relocation));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
+ input_section->owner,
+ (unsigned long) rel->r_offset, howto->name,
+ (unsigned long) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_SH_DIR4UW:
if (relocation & 1)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
- input_section->owner,
- (unsigned long) rel->r_offset, howto->name,
- (unsigned long) relocation));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"),
+ input_section->owner,
+ (unsigned long) rel->r_offset, howto->name,
+ (unsigned long) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((signed int)relocation < -32
|| (signed int)relocation > 32)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
- input_section->owner,
- (unsigned long) rel->r_offset,
- (unsigned long) relocation));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"),
+ input_section->owner,
+ (unsigned long) rel->r_offset,
+ (unsigned long) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((signed int)relocation < -16
|| (signed int)relocation > 16)
{
- ((*_bfd_error_handler)
- (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
- input_section->owner,
- (unsigned long) rel->r_offset,
- (unsigned long) relocation));
+ _bfd_error_handler
+ (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"),
+ input_section->owner,
+ (unsigned long) rel->r_offset,
+ (unsigned long) relocation);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (sh_elf_osec_readonly_p (output_bfd,
input_section->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
if (sh_elf_osec_readonly_p (output_bfd,
reloc_section->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
{
if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC)
&& (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and FDPIC symbol"),
abfd, h->root.root.string);
else if (old_got_type == GOT_FUNCDESC
|| got_type == GOT_FUNCDESC)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
else
- (*_bfd_error_handler)
- (_("%B: `%s' accessed both as normal and thread local symbol"),
- abfd, h->root.root.string);
+ _bfd_error_handler
+ (_("%B: `%s' accessed both as normal and thread local symbol"),
+ abfd, h->root.root.string);
return FALSE;
}
}
case R_SH_GOTOFFFUNCDESC20:
if (rel->r_addend)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Function descriptor relocation with non-zero addend"),
abfd);
return FALSE;
if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN)
{
if (old_got_type == GOT_NORMAL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and FDPIC symbol"),
abfd, h->root.root.string);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
}
case R_SH_TLS_LE_32:
if (bfd_link_dll (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: TLS local exec code cannot be linked into shared objects"),
abfd);
return FALSE;
else
msg = _("%s: object size does not match that of target %s");
- (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
- bfd_get_filename (obfd));
+ _bfd_error_handler (msg, bfd_get_filename (ibfd),
+ bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
/* We don't allow linking in non-SH64 code. */
else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%s: uses non-SH64 instructions while previous modules use SH64 instructions",
bfd_get_filename (ibfd));
bfd_set_error (bfd_error_bad_value);
&& h->root.type != bfd_link_hash_indirect))
{
/* Make sure we don't get confused on invalid input. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: encountered datalabel symbol in input"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_bad_value);
unknown destination (or when relaxing) will get us here. */
if ((insn & SHMEDIA_PTB_BIT) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: GAS error: unexpected PTB insn with R_SH_PT_16"),
bfd_get_filename (input_section->owner));
return FALSE;
}
if (dropped != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: error: unaligned relocation type %d at %08x reloc %p\n"),
input_section->owner, ELF32_R_TYPE (rel->r_info),
(unsigned) rel->r_offset, relocation);
ld_generated_cranges_size))
{
bfd_set_error (bfd_error_file_truncated);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: could not write out added .cranges entries"),
bfd_get_filename (abfd));
}
cranges_size))
{
bfd_set_error (bfd_error_file_truncated);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: could not write out sorted .cranges entries"),
bfd_get_filename (abfd));
}
if (bfd_mach_sparc_64bit_p (ibfd_mach))
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
}
else if ((ibfd->flags & DYNAMIC) == 0)
!= previous_ibfd_e_flags)
&& previous_ibfd_e_flags != (unsigned long) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking little endian files with big endian files"), ibfd);
error = TRUE;
}
/* PR 17512: file: 90c2a92e. */
if (r_type >= R_SPU_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised SPU reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised SPU reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_SPU_NONE;
}
sym,
sym_sec);
}
- (*_bfd_error_handler) (_("warning: call to non-function"
- " symbol %s defined in %B"),
- sym_sec->owner, sym_name);
+ _bfd_error_handler
+ (_("warning: call to non-function symbol %s defined in %B"),
+ sym_sec->owner, sym_name);
}
}
}
else if (h->root.u.def.section->owner != NULL)
{
- (*_bfd_error_handler) (_("%B is not allowed to define %s"),
- h->root.u.def.section->owner,
- h->root.root.string);
+ _bfd_error_handler (_("%B is not allowed to define %s"),
+ h->root.u.def.section->owner,
+ h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return NULL;
}
else
{
- (*_bfd_error_handler) (_("you are not allowed to define %s in a script"),
- h->root.root.string);
+ _bfd_error_handler (_("you are not allowed to define %s in a script"),
+ h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return NULL;
}
s = h->root.u.def.section->output_section;
if (spu_elf_section_data (s)->u.o.ovl_index)
{
- (*_bfd_error_handler) (_("%s in overlay section"),
- h->root.root.string);
+ _bfd_error_handler (_("%s in overlay section"),
+ h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (htab->stub_err)
{
- (*_bfd_error_handler) (_("overlay stub relocation overflow"));
+ _bfd_error_handler (_("overlay stub relocation overflow"));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
if (htab->stub_sec[i]->size != htab->stub_sec[i]->rawsize)
{
- (*_bfd_error_handler) (_("stubs don't match calculated size"));
+ _bfd_error_handler (_("stubs don't match calculated size"));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (qaddr != (base & ~(bfd_vma) 15))
{
if ((sfixup->reloc_count + 1) * FIXUP_RECORD_SIZE > sfixup->size)
- (*_bfd_error_handler) (_("fatal error while creating .fixup"));
+ _bfd_error_handler (_("fatal error while creating .fixup"));
FIXUP_PUT (output_bfd, htab, sfixup->reloc_count, qaddr | bit);
sfixup->reloc_count++;
}
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
bfd_get_section_name (input_bfd, input_section),
}
else
{
- (*_bfd_error_handler) (_("%B: SB-relative relocation but "
- "__c6xabi_DSBT_BASE not defined"),
- input_bfd);
+ _bfd_error_handler (_("%B: SB-relative relocation but "
+ "__c6xabi_DSBT_BASE not defined"),
+ input_bfd);
ok = FALSE;
continue;
}
symbols. Make this an error; the compiler isn't
allowed to pass us these kinds of things. */
if (h == NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with non-zero addend %d"
" against local symbol"),
input_bfd,
elf32_tic6x_howto_table[r_type].name,
rel->r_addend);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B, section %A: relocation %s with non-zero addend %d"
" against symbol `%s'"),
input_bfd,
/* Invalid in relocatable object. */
default:
/* Unknown relocation. */
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- input_bfd, r_type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ input_bfd, r_type);
ok = FALSE;
continue;
}
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd,
- r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
tls_type = old_tls_type;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
if ((unsigned int)r_type >= NELEMS(tilepro_elf_howto_table))
{
/* Not clear if we need to check here, but just be paranoid. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unrecognized relocation (0x%x) in section `%A'"),
input_bfd, r_type, input_section);
bfd_set_error (bfd_error_bad_value);
if (indx == 0)
{
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
&& h->def_dynamic)
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
{
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("discarded output section: `%A'"), htab->elf.sgotplt);
return FALSE;
}
}
else
{
- (*_bfd_error_handler) (_("FAILED to find previous HI16 reloc"));
+ _bfd_error_handler (_("FAILED to find previous HI16 reloc"));
return FALSE;
}
}
case V850_NOTE_DATA_SIZE:
if (oval == EF_RH850_DOUBLE32)
{
- _bfd_error_handler (_("error: %B uses 64-bit doubles but %B uses 32-bit doubles"),
- ibfd, obfd);
+ _bfd_error_handler
+ (_("error: %B uses 64-bit doubles but "
+ "%B uses 32-bit doubles"), ibfd, obfd);
result = FALSE;
}
else
case V850_NOTE_FPU_INFO:
if (oval == EF_RH850_FPU20)
{
- _bfd_error_handler (_("error: %B uses FPU-3.0 but %B only supports FPU-2.0"),
- ibfd, obfd);
+ _bfd_error_handler
+ (_("error: %B uses FPU-3.0 but %B only supports FPU-2.0"),
+ ibfd, obfd);
result = FALSE;
}
else
{
if ((in_flags & EF_V800_850E3) != (out_flags & EF_V800_850E3))
{
- _bfd_error_handler (_("%B: Architecture mismatch with previous modules"),
- ibfd);
+ _bfd_error_handler
+ (_("%B: Architecture mismatch with previous modules"), ibfd);
elf_elfheader (obfd)->e_flags |= EF_V800_850E3;
}
return result;
}
- _bfd_error_handler (_("%B: Architecture mismatch with previous modules"),
- ibfd);
+ _bfd_error_handler
+ (_("%B: Architecture mismatch with previous modules"), ibfd);
}
return result;
}
else
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insns",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset));
-
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGCALL points to "
+ "unrecognized insns",
+ bfd_get_filename (abfd), (unsigned long) irel->r_offset);
continue;
}
if (no_match >= 0)
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insn 0x%x",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
-
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGCALL points to "
+ "unrecognized insn 0x%x",
+ bfd_get_filename (abfd),
+ (unsigned long) irel->r_offset + no_match,
+ insn[no_match]);
continue;
}
|| lo_irelfn == irelend
|| irelcall == irelend)
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGCALL points to "
+ "unrecognized reloc",
+ bfd_get_filename (abfd), (unsigned long) irel->r_offset);
continue;
}
if (symval + irelcall->r_addend != irelcall->r_offset + 4)
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc 0x%lx",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset, irelcall->r_offset ));
-
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGCALL points to "
+ "unrecognized reloc 0x%lx",
+ bfd_get_filename (abfd), (unsigned long) irel->r_offset,
+ irelcall->r_offset);
continue;
}
}
else
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insns",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset));
-
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGJUMP points to "
+ "unrecognized insns",
+ bfd_get_filename (abfd), (unsigned long) irel->r_offset);
continue;
}
if (no_match >= 0)
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insn 0x%x",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
-
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGJUMP points to "
+ "unrecognized insn 0x%x",
+ bfd_get_filename (abfd),
+ (unsigned long) irel->r_offset + no_match,
+ insn[no_match]);
continue;
}
if ( hi_irelfn == irelend
|| lo_irelfn == irelend)
{
- ((*_bfd_error_handler)
- ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized reloc",
- bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
-
+ _bfd_error_handler
+ ("%s: 0x%lx: warning: R_V850_LONGJUMP points to "
+ "unrecognized reloc",
+ bfd_get_filename (abfd), (unsigned long) irel->r_offset);
continue;
}
r_type = ELF32_R_TYPE (dst->r_info);
if (r_type >= R_VAX_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised VAX reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised VAX reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_VAX_NONE;
}
{
h->got.refcount++;
if (eh->got_addend != (bfd_vma) rel->r_addend)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: GOT addend of %ld to `%s' does"
" not match previous GOT addend of %ld"),
bfd_get_filename (abfd), rel->r_addend,
h->plt.offset |= 1;
}
else if (rel->r_addend != 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: PLT addend of %d to `%s' from %s section ignored"),
bfd_get_filename (input_bfd), rel->r_addend,
h->root.root.string,
&& ELF32_R_TYPE (outrel.r_info) != R_VAX_GLOB_DAT))
{
if (h != NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: %s relocation against symbol `%s' from %s section"),
bfd_get_filename (input_bfd), howto->name,
h->root.root.string,
bfd_get_section_name (input_bfd, input_section));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: %s relocation to 0x%x from %s section"),
bfd_get_filename (input_bfd), howto->name,
outrel.r_addend,
if (blocks[blk - 1].address == blocks[blk].address &&
blocks[blk - 1].size != 0)
{
- (*_bfd_error_handler) (_("%B(%A): invalid property table"),
- abfd, section);
+ _bfd_error_handler (_("%B(%A): invalid property table"),
+ abfd, section);
bfd_set_error (bfd_error_bad_value);
free (blocks);
return -1;
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
tls_type |= old_tls_type;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd,
h ? h->root.root.string : "<local>");
if (rel->r_offset >= input_size
&& ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
input_bfd, input_section, rel->r_offset, input_size);
bfd_set_error (bfd_error_bad_value);
|| h->root.type == bfd_link_hash_defweak)
&& IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((sym_type == STT_TLS
? _("%B(%A+0x%lx): %s used with TLS symbol %s")
: _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
sgotloc_size = sgotloc->size;
if (sgotloc_size != section_size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("internal inconsistency in size of .got.loc section"));
return -1;
}
in_mach = in_flag & EF_XTENSA_MACH;
if (out_mach != in_mach)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
ibfd, out_mach, in_mach);
bfd_set_error (bfd_error_wrong_format);
entry_end - ebb->end_offset);
if (insn_block_len != (entry_end - ebb->end_offset))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
return FALSE;
ebb->start_offset - block_begin);
if (insn_block_len != ebb->start_offset - block_begin)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
return FALSE;
simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
if (simplify_size == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
sec->owner, sec, r_offset);
continue;
return TRUE;
decode_error:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
ebb->sec->owner, ebb->sec, offset);
return FALSE;
{
if (r_type != R_XTENSA_ASM_EXPAND)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unexpected fix for %s relocation"),
input_bfd, input_section, rel->r_offset,
elf_howto_table[r_type].name);
if (r_type >= R_ALPHA_max)
{
- (*_bfd_error_handler) (_("%B: unrecognised Alpha reloc number: %d"),
- abfd, r_type);
+ _bfd_error_handler (_("%B: unrecognised Alpha reloc number: %d"),
+ abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_ALPHA_NONE;
}
if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
{
/* Yikes! A single object file has too many entries. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: .got subsegment exceeds 64K (size %d)"),
i, alpha_elf_tdata (this_got)->total_got_size);
return FALSE;
if (insn >> 26 != OP_LDQ)
{
reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
- ((*_bfd_error_handler)
- ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
- info->abfd, info->sec,
- (unsigned long) irel->r_offset, howto->name));
+ _bfd_error_handler
+ ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
+ info->abfd, info->sec,
+ (unsigned long) irel->r_offset, howto->name);
return TRUE;
}
lit_insn = bfd_get_32 (abfd, contents + irel->r_offset);
if (lit_insn >> 26 != OP_LDQ)
{
- ((*_bfd_error_handler)
- ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
- abfd, info->sec,
- (unsigned long) irel->r_offset));
+ _bfd_error_handler
+ ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
+ abfd, info->sec,
+ (unsigned long) irel->r_offset);
return TRUE;
}
r_type = ELF64_R_TYPE (rel->r_info);
if (r_type >= R_ALPHA_max)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
r_type = ELF64_R_TYPE(rel->r_info);
if (r_type >= R_ALPHA_max)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
case R_ALPHA_GPRELLOW:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: gp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
case R_ALPHA_GPRELHIGH:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: gp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
case R_ALPHA_BRADDR:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: pc-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
&& alpha_elf_tdata (sec->owner)->gotobj
&& gotobj != alpha_elf_tdata (sec->owner)->gotobj)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: change in gp: BRSGP %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
else if (name[0] == 0)
name = bfd_section_name (input_bfd, sec);
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: !samegp reloc against symbol without .prologue: %s"),
input_bfd, name);
ret_val = FALSE;
{
if (r_type == R_ALPHA_REFLONG)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unhandled dynamic relocation against %s"),
input_bfd,
h->root.root.root.string);
case R_ALPHA_SREL64:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: pc-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
else if (bfd_link_pic (info)
&& undef_weak_ref)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: pc-relative relocation against undefined weak symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
case R_ALPHA_DTPREL16:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: dtp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
case R_ALPHA_TPREL16:
if (bfd_link_dll (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: TLS local exec code cannot be linked into shared objects"),
input_bfd);
ret_val = FALSE;
}
else if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: tp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
if ((value & 7) || value + max_offset >= 2*max_offset - 8)
{
- (*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"),
- hh->eh.root.root.string,
- (long) value);
+ _bfd_error_handler
+ (_("stub entry for %s cannot load .plt, dp offset = %ld"),
+ hh->eh.root.root.string, (long) value);
return FALSE;
}
if (max_branch_offset != 0
&& value + addend + max_branch_offset >= 2*max_branch_offset)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%" BFD_VMA_FMT "x): cannot reach %s"),
input_bfd,
input_section,
if (strcmp (sec->output_section->name, ".init") == 0
|| strcmp (sec->output_section->name, ".fini") == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
sec->owner, sec, (unsigned long) roff);
bfd_set_error (bfd_error_bad_value);
if (max_short_vma - min_short_vma >= 0x400000)
{
overflow:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
bfd_get_filename (abfd),
(unsigned long) (max_short_vma - min_short_vma));
|| (gp_val < max_short_vma
&& max_short_vma - gp_val >= 0x200000))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: __gp does not cover short data segment"),
bfd_get_filename (abfd));
return FALSE;
r_type = ELF64_R_TYPE (rel->r_info);
if (r_type > R_IA64_MAX_RELOC_CODE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
case R_IA64_IMM64:
/* ??? People shouldn't be doing non-pic code in
shared libraries nor dynamic executables. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
input_bfd,
h ? h->root.root.string
case R_IA64_GPREL64LSB:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: @gprel relocation against dynamic symbol %s"),
input_bfd,
h ? h->root.root.string
dynamic symbol table. */
/* ??? People shouldn't be doing non-pic code in
shared libraries. Hork. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking non-pic code in a position independent executable"),
input_bfd);
ret_val = FALSE;
msg = _("%B: speculation fixup to dynamic symbol %s");
else
msg = _("%B: @pcrel relocation against dynamic symbol %s");
- (*_bfd_error_handler) (msg, input_bfd,
- h ? h->root.root.string
- : bfd_elf_sym_name (input_bfd,
- symtab_hdr,
- sym,
- sym_sec));
+ _bfd_error_handler (msg, input_bfd,
+ h ? h->root.root.string
+ : bfd_elf_sym_name (input_bfd,
+ symtab_hdr,
+ sym,
+ sym_sec));
ret_val = FALSE;
continue;
}
case R_IA64_LTOFF_TPREL22:
case R_IA64_LTOFF_DTPMOD22:
case R_IA64_LTOFF_DTPREL22:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
input_bfd, input_section, howto->name, name,
rel->r_offset);
/* Relaxtion is always performed for ELF output.
Overflow failures for those relocations mean
that the section is too big to relax. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
input_bfd, input_section, howto->name, name,
rel->r_offset, input_section->size);
if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking trap-on-NULL-dereference with non-trapping files"),
ibfd);
}
if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking big-endian files with little-endian files"),
ibfd);
}
if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking 64-bit files with 32-bit files"),
ibfd);
}
if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking constant-gp files with non-constant-gp files"),
ibfd);
if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
!= (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking auto-pic files with non-auto-pic files"),
ibfd);
{
/* PR binutils/2735 */
if (normal_bfd == NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: alignment %u of common symbol `%s' in %B"
" is greater than the alignment (%u) of its section %A"),
common_bfd, h->root.u.def.section,
1 << common_align, name, 1 << normal_align);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: alignment %u of symbol `%s' in %B"
" is smaller than %u in %B"),
normal_bfd, common_bfd,
if (h->size != 0
&& h->size != isym->st_size
&& ! size_change_ok)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: size of symbol `%s' changed"
" from %lu in %B to %lu in %B"),
old_bfd, abfd,
if (h->type != type)
{
if (h->type != STT_NOTYPE && ! type_change_ok)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: type of symbol `%s' changed"
" from %d to %d in %B"),
abfd, name, h->type, type);
}
if (r_type >= R_MIPS_max)
{
- (*_bfd_error_handler) (_("unrecognised MIPS reloc number: %d"), r_type);
+ _bfd_error_handler (_("unrecognised MIPS reloc number: %d"), r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MIPS_NONE;
}
doesn't cost much, so can be left in at all times. */
if (value != gregdata->reloc_request[bpo_index].value)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: Internal inconsistency error for value for\n\
linker-allocated global register: linked: 0x%lx%08lx != relaxed: 0x%lx%08lx\n"),
bfd_get_filename (isec->owner),
/* Note: This is separated out into two messages in order
to ease the translation into other languages. */
if (symname == NULL || *symname == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: base-plus-offset relocation against register symbol: (unknown) in %s"),
bfd_get_filename (input_section->owner),
bfd_get_section_name (symsec->owner, symsec));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: base-plus-offset relocation against register symbol: %s in %s"),
bfd_get_filename (input_section->owner), symname,
bfd_get_section_name (symsec->owner, symsec));
/* Note: This is separated out into two messages in order
to ease the translation into other languages. */
if (symname == NULL || *symname == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: register relocation against non-register symbol: (unknown) in %s"),
bfd_get_filename (input_section->owner),
bfd_get_section_name (symsec->owner, symsec));
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: register relocation against non-register symbol: %s in %s"),
bfd_get_filename (input_section->owner), symname,
bfd_get_section_name (symsec->owner, symsec));
&& strcmp (bfd_get_section_name (symsec->owner, symsec),
MMIX_REG_SECTION_NAME) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: directive LOCAL valid only with a register or absolute value"),
bfd_get_filename (input_section->owner));
if ((bfd_vma) srel >= first_global)
{
/* FIXME: Better error message. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: LOCAL directive: Register $%ld is not a local register. First global register is $%ld."),
bfd_get_filename (input_section->owner), (long) srel, (long) first_global);
{
/* How do we get the asymbol (or really: the filename) from h?
h->u.def.section->owner is NULL. */
- ((*_bfd_error_handler)
- (_("%s: Error: multiple definition of `%s'; start of %s is set in a earlier linked file\n"),
- bfd_get_filename (abfd), *namep,
- *namep + strlen (MMIX_LOC_SECTION_START_SYMBOL_PREFIX)));
+ _bfd_error_handler
+ (_("%s: Error: multiple definition of `%s'; start of %s "
+ "is set in a earlier linked file\n"),
+ bfd_get_filename (abfd), *namep,
+ *namep + strlen (MMIX_LOC_SECTION_START_SYMBOL_PREFIX));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (gregdata->n_remaining_bpo_relocs_this_relaxation_round
!= gregdata->n_bpo_relocs)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Internal inconsistency: remaining %u != max %u.\n\
Please report this bug."),
gregdata->n_remaining_bpo_relocs_this_relaxation_round,
type = ELF64_R_TYPE (dst->r_info);
if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, (int) type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, (int) type);
type = R_PPC64_NONE;
}
cache_ptr->howto = ppc64_elf_howto_table[type];
if (iflags & ~EF_PPC64_ABI)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
else if (iflags != oflags && iflags != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: ABI version %ld is not compatible with ABI version %ld output"),
ibfd, iflags, oflags);
bfd_set_error (bfd_error_bad_value);
return NULL;
if (ent.sec == NULL || ent.sec->output_section == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
return NULL;
}
something silly in .opd with the assembler. No .opd
optimization for them! */
broken_opd:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: .opd is not a regular array of opd entries"), ibfd);
broken = TRUE;
break;
if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
|| (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unexpected reloc type %u in .opd section"),
ibfd, r_type);
broken = TRUE;
sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
sym_sec);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: undefined sym `%s' in .opd section"),
ibfd, sym_name);
broken = TRUE;
if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s defined on removed toc entry"), eh->elf.root.root.string);
do
++i;
if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
{
if (local_toc_syms)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s defined on removed toc entry"),
bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
do
big_sec = total > group_size;
if (big_sec && !suppress_size_errors)
- (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
- tail->owner, tail);
+ _bfd_error_handler (_("%B section %A exceeds stub group size"),
+ tail->owner, tail);
curr_toc = htab->sec_info[tail->id].toc_off;
while ((prev = htab->sec_info[curr->id].u.list) != NULL
default:
if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, (int) r_type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, (int) r_type);
r_type = R_390_NONE;
}
cache_ptr->howto = &elf_howto_table[r_type];
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd,
- r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
{
if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
return FALSE;
reloc_howto_type *howto;
howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
input_bfd,
input_section,
&& h->def_dynamic)
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): reloc against `%s': error %d"),
input_bfd, input_section,
(long) rel->r_offset, name, (int) r);
if (howto->rightshift || howto->src_mask != 0xffffffff)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
rel->r_offset)
!= (bfd_vma) -1))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
}
if (dropped != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
bfd_get_filename (input_bfd), (int)r_type, (unsigned)rel->r_offset, (unsigned)relocation);
bfd_set_error (bfd_error_bad_value);
else
msg = _("%s: object size does not match that of target %s");
- (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
- bfd_get_filename (obfd));
+ _bfd_error_handler (msg, bfd_get_filename (ibfd),
+ bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
here as things change. */
else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%s: does not use the SH64 64-bit ABI as previous modules do",
bfd_get_filename (ibfd));
bfd_set_error (bfd_error_bad_value);
&& h->root.type != bfd_link_hash_indirect))
{
/* Make sure we don't get confused on invalid input. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: encountered datalabel symbol in input"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_bad_value);
case 2: reg -= 2; break;
case 6: reg -= 4; break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
abfd);
return FALSE;
if (p->name != NULL && strcmp (p->name, *namep))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
abfd, p->abfd, (int) sym->st_value,
**namep ? *namep : "#scratch",
if (type > STT_FUNC)
type = 0;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
abfd, p->abfd, *namep, stt_types[type]);
return FALSE;
if (type > STT_FUNC)
type = 0;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
abfd, p->abfd, *namep, stt_types[type]);
return FALSE;
&& (old_flags & EF_SPARC_HAL_R1))
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking UltraSPARC specific with HAL specific code"),
ibfd);
}
if (new_flags != old_flags)
{
error = TRUE;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
ibfd, (long) new_flags, (long) old_flags);
}
{
if (r_type >= (unsigned int) R_X86_64_standard)
{
- (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
- abfd, (int) r_type);
+ _bfd_error_handler (_("%B: invalid relocation type %d"),
+ abfd, (int) r_type);
r_type = R_X86_64_NONE;
}
i = r_type;
}
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
"in section `%A' failed"),
abfd, sec, from->name, to->name, name,
pic = _("; recompile with -fPIC");
}
- (*_bfd_error_handler) (_("%B: relocation %s against %s%s`%s' can "
- "not be used when making a shared object%s"),
- input_bfd, howto->name, und, v, name, pic);
+ _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
+ "not be used when making a shared object%s"),
+ input_bfd, howto->name, und, v, name, pic);
bfd_set_error (bfd_error_bad_value);
sec->check_relocs_failed = 1;
return FALSE;
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
goto error_return;
}
else
name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against symbol `%s' isn't "
"supported in x32 mode"), abfd,
x86_64_elf_howto_table[r_type].name, name);
else
name = bfd_elf_sym_name (abfd, symtab_hdr,
isym, NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: '%s' accessed both as normal and thread local symbol"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
if (r_type >= (int) R_X86_64_standard)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unrecognized relocation (0x%x) in section `%A'"),
input_bfd, input_section, r_type);
bfd_set_error (bfd_error_bad_value);
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't supported"), input_bfd,
howto->name, name);
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr,
sym, NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' has non-zero addend: %d"),
input_bfd, howto->name, name, rel->r_addend);
break;
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
input_bfd, v, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
|| h->type == STT_OBJECT)
&& ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
input_bfd,
h->type == STT_FUNC ? "function" : "data",
name = bfd_elf_sym_name (input_bfd, symtab_hdr,
sym, NULL);
if (addend < 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: addend -0x%x in relocation %s against "
"symbol `%s' at 0x%lx in section `%A' is "
"out of range"),
howto->name, name,
(unsigned long) rel->r_offset);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: addend 0x%x in relocation %s against "
"symbol `%s' at 0x%lx in section `%A' is "
"out of range"),
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): reloc against `%s': error %d"),
input_bfd, input_section,
(long) rel->r_offset, name, (int) r);
{
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("discarded output section: `%A'"), htab->elf.sgotplt);
return FALSE;
}
if (verhdr != NULL
&& verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: version count (%ld) does not match symbol count (%ld)"),
abfd->filename,
(long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
else if (ELF_R_SYM (rela.r_info) > symcount)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s(%s): relocation %d has invalid symbol index %ld"),
abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
{
if ((bfd_size_type) statbuf.st_size < high)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: %B is truncated: expected core file "
"size >= %lu, found: %lu."),
abfd, (unsigned long) high, (unsigned long) statbuf.st_size);
}
if (tdef && ntdef)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: TLS definition in %B section %A "
"mismatches non-TLS definition in %B section %A"),
tbfd, tsec, ntbfd, ntsec, h->root.root.string);
else if (!tdef && !ntdef)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: TLS reference in %B "
"mismatches non-TLS reference in %B"),
tbfd, ntbfd, h->root.root.string);
else if (tdef)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: TLS definition in %B section %A "
"mismatches non-TLS reference in %B"),
tbfd, tsec, ntbfd, h->root.root.string);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: TLS reference in %B "
"mismatches non-TLS definition in %B section %A"),
tbfd, ntbfd, ntsec, h->root.root.string);
overridden by a versioned definition. */
if (hi->root.type != bfd_link_hash_defined
&& hi->root.type != bfd_link_hash_defweak)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
abfd, shortname);
}
{
/* We could not find the version for a symbol when
generating a shared archive. Return an error. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: version node not found for symbol %s"),
info->output_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
{
if ((size_t) r_symndx >= nsyms)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
" for offset 0x%lx in section `%A'"),
abfd, sec,
}
else if (r_symndx != STN_UNDEF)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
" when the object file has no symbol table"),
abfd, sec,
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation size mismatch in %B section %A"),
output_bfd, input_section->owner, input_section);
bfd_set_error (bfd_error_wrong_format);
if (h->size == 0
&& h->type == STT_NOTYPE
&& !h->needs_plt)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("warning: type and size of dynamic symbol `%s' are not defined"),
h->root.root.string);
if (verstr == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: %s: invalid version %u (max %d)"),
abfd, name, vernum,
elf_tdata (abfd)->cverdefs);
}
if (verstr == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: %s: invalid needed version %d"),
abfd, name, vernum);
bfd_set_error (bfd_error_bad_value);
{
/* PR binutils/2735 */
if (normal_bfd == NULL)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: alignment %u of common symbol `%s' in %B is"
" greater than the alignment (%u) of its section %A"),
common_bfd, h->root.u.def.section,
1 << common_align, name, 1 << normal_align);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: alignment %u of symbol `%s' in %B"
" is smaller than %u in %B"),
normal_bfd, common_bfd,
if (h->size != 0
&& h->size != isym->st_size
&& ! size_change_ok)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: size of symbol `%s' changed"
" from %lu in %B to %lu in %B"),
old_bfd, abfd,
if (h->type != type)
{
if (h->type != STT_NOTYPE && ! type_change_ok)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Warning: type of symbol `%s' changed"
" from %d to %d in %B"),
abfd, name, h->type, type);
if (old_bfd != NULL
&& (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: undefined reference to symbol '%s'"),
old_bfd, name);
bfd_set_error (bfd_error_missing_dso);
/* The symbol has no type if specified on the command line. */
h->type = STT_OBJECT;
if (info->stacksize)
- (*_bfd_error_handler) (_("%B: stack size specified and %s set"),
- output_bfd, legacy_symbol);
+ _bfd_error_handler (_("%B: stack size specified and %s set"),
+ output_bfd, legacy_symbol);
else if (h->root.u.def.section != bfd_abs_section_ptr)
- (*_bfd_error_handler) (_("%B: %s not absolute"),
- output_bfd, legacy_symbol);
+ _bfd_error_handler (_("%B: %s not absolute"),
+ output_bfd, legacy_symbol);
else
info->stacksize = h->root.u.def.value;
}
for (d = t->globals.list; d != NULL; d = d->next)
if (d->literal && !d->symver && !d->script)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: undefined version: %s"),
d->pattern, t->name);
all_defined = FALSE;
if (elf_section_data (o)->this_hdr.sh_type
== SHT_PREINIT_ARRAY)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: .preinit_array section is not allowed in DSO"),
sub);
break;
{
/* The gABI doesn't support dynamic symbols in output sections
beyond 64k. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Too many sections: %d (>= %d)"),
abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
bfd_set_error (bfd_error_nonrepresentable_section);
def_bfd = flinfo->output_bfd;
if (hi->root.u.def.section != bfd_abs_section_ptr)
def_bfd = hi->root.u.def.section->owner;
- (*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
- h->root.root.string);
+ _bfd_error_handler (msg, flinfo->output_bfd, def_bfd,
+ h->root.root.string);
bfd_set_error (bfd_error_bad_value);
eoinfo->failed = TRUE;
return FALSE;
input_sec->output_section);
if (sym.st_shndx == SHN_BAD)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: could not find output section %A for input section %A"),
flinfo->output_bfd, input_sec->output_section, input_sec);
bfd_set_error (bfd_error_nonrepresentable_section);
msg = _("%B: internal symbol `%s' isn't defined");
else
msg = _("%B: hidden symbol `%s' isn't defined");
- (*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
+ _bfd_error_handler (msg, flinfo->output_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
eoinfo->failed = TRUE;
return FALSE;
if (p && p [1] != '\0')
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: No symbol version section for versioned symbol `%s'"),
flinfo->output_bfd, h->root.root.string);
eoinfo->failed = TRUE;
{
if (o->size != o->reloc_count * address_size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("error: %B: size of section %A is not "
"multiple of address size"),
input_bfd, o);
char buffer [32];
sprintf_vma (buffer, rel->r_info);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("error: %B contains a reloc (0x%s) for section %A "
"that references a non-existent global symbol"),
input_bfd, o, buffer);
if (seen_other && seen_linkorder)
{
if (other_sec && linkorder_sec)
- (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
- o, linkorder_sec,
- linkorder_sec->owner, other_sec,
- other_sec->owner);
+ _bfd_error_handler
+ (_("%A has both ordered [`%A' in %B] "
+ "and unordered [`%A' in %B] sections"),
+ o, linkorder_sec,
+ linkorder_sec->owner, other_sec,
+ other_sec->owner);
else
- (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
- o);
+ _bfd_error_handler
+ (_("%A has both ordered and unordered sections"), o);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (symcount == 0)
{
bfd_set_error (bfd_error_no_symbols);
- (*_bfd_error_handler) (_("%B: no symbol found for import library"),
- implib_bfd);
+ _bfd_error_handler (_("%B: no symbol found for import library"),
+ implib_bfd);
goto free_sym_buf;
}
}
bfd_set_error (bfd_error_wrong_format);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: file class %s incompatible with %s"),
sub, iclass, oclass);
}
if (info->out_implib_bfd && !elf_output_implib (abfd, info))
{
- (*_bfd_error_handler) (_("%B: failed to generate import library"),
- info->out_implib_bfd);
+ _bfd_error_handler (_("%B: failed to generate import library"),
+ info->out_implib_bfd);
return FALSE;
}
o = bfd_get_section_by_name (abfd, name);
if (o == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("could not find section %s"), name);
goto error_return;
}
if (o->size == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("warning: %s section has zero size"), name);
dyn.d_un.d_val = o->size;
break;
do_vma:
if (o == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("could not find section %s"), name);
goto error_return;
}
if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("warning: section '%s' is being made into a note"), name);
bfd_set_error (bfd_error_nonrepresentable_section);
goto error_return;
if (!bed->can_gc_sections
|| !is_elf_hash_table (info->hash))
{
- (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
+ _bfd_error_handler(_("Warning: gc-sections option ignored"));
return TRUE;
}
goto win;
}
- (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
- abfd, sec, (unsigned long) offset);
+ _bfd_error_handler ("%B: %A+%lu: No symbol found for INHERIT",
+ abfd, sec, (unsigned long) offset);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
}
if (r_type >= R_MIPS_max)
{
- (*_bfd_error_handler) (_("unrecognised MIPS reloc number: %d"), r_type);
+ _bfd_error_handler (_("unrecognised MIPS reloc number: %d"), r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MIPS_NONE;
}
TRUE, FALSE);
if (stub_entry == NULL)
{
- (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
- section->owner, stub_name);
+ _bfd_error_handler (_("%s: cannot create stub entry %s"),
+ section->owner, stub_name);
return NULL;
}
TRUE, FALSE);
if (stub_entry == NULL)
{
- (*_bfd_error_handler) (_("cannot create stub entry %s"), stub_name);
+ _bfd_error_handler (_("cannot create stub entry %s"), stub_name);
return NULL;
}
abfd = stub_entry->target_section->owner;
if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc))
- (*_bfd_error_handler)
- (_("%B: error: Erratum 835769 stub out "
- "of range (input file too large)"), abfd);
+ _bfd_error_handler
+ (_("%B: error: Erratum 835769 stub out "
+ "of range (input file too large)"), abfd);
target = stub_entry->target_value;
branch_insn = 0x14000000;
abfd = stub_entry->target_section->owner;
if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: error: Erratum 843419 stub out "
"of range (input file too large)"), abfd);
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't handled by %s"), input_bfd,
howto->name, name, __FUNCTION__);
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr,
sym, NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' has non-zero addend: %d"),
input_bfd, howto->name, name, rel->r_addend);
{
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against external symbol `%s' can not be used"
" when making a shared object; recompile with -fPIC"),
input_bfd, elfNN_aarch64_howto_table[howto_index].name,
if (locals == NULL)
{
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Local symbol descriptor table be NULL when applying "
"relocation %s against local symbol"),
input_bfd, elfNN_aarch64_howto_table[howto_index].name);
if (locals == NULL)
{
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Local symbol descriptor table be NULL when applying "
"relocation %s against local symbol"),
input_bfd, elfNN_aarch64_howto_table[howto_index].name);
if (howto == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unrecognized relocation (0x%x) in section `%A'"),
input_bfd, input_section, r_type);
return FALSE;
|| h->root.type == bfd_link_hash_defweak)
&& IS_AARCH64_TLS_RELOC (bfd_r_type) != (sym_type == STT_TLS))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((sym_type == STT_TLS
? _("%B(%A+0x%lx): %s used with TLS symbol %s")
: _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
&& _bfd_elf_section_offset (output_bfd, info, input_section,
+rel->r_offset) != (bfd_vma) - 1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_
("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd, input_section, (long) rel->r_offset, howto->name,
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
- r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"), abfd, r_symndx);
return FALSE;
}
if (bfd_link_pic (info))
{
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against `%s' can not be used when making "
"a shared object; recompile with -fPIC"),
abfd, elfNN_aarch64_howto_table[howto_index].name,
{
if (bfd_is_abs_section (htab->root.sgotplt->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("discarded output section: `%A'"), htab->root.sgotplt);
return FALSE;
}
if (strcmp (sec->output_section->name, ".init") == 0
|| strcmp (sec->output_section->name, ".fini") == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
sec->owner, sec, (unsigned long) roff);
bfd_set_error (bfd_error_bad_value);
if (max_short_vma - min_short_vma >= 0x400000)
{
overflow:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
bfd_get_filename (abfd),
(unsigned long) (max_short_vma - min_short_vma));
|| (gp_val < max_short_vma
&& max_short_vma - gp_val >= 0x200000))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: __gp does not cover short data segment"),
bfd_get_filename (abfd));
return FALSE;
r_type = ELFNN_R_TYPE (rel->r_info);
if (r_type > R_IA64_MAX_RELOC_CODE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
case R_IA64_IMM64:
/* ??? People shouldn't be doing non-pic code in
shared libraries nor dynamic executables. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
input_bfd,
h ? h->root.root.string
case R_IA64_GPREL64LSB:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: @gprel relocation against dynamic symbol %s"),
input_bfd,
h ? h->root.root.string
dynamic symbol table. */
/* ??? People shouldn't be doing non-pic code in
shared libraries. Hork. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking non-pic code in a position independent executable"),
input_bfd);
ret_val = FALSE;
msg = _("%B: speculation fixup to dynamic symbol %s");
else
msg = _("%B: @pcrel relocation against dynamic symbol %s");
- (*_bfd_error_handler) (msg, input_bfd,
- h ? h->root.root.string
- : bfd_elf_sym_name (input_bfd,
- symtab_hdr,
- sym,
- sym_sec));
+ _bfd_error_handler (msg, input_bfd,
+ h ? h->root.root.string
+ : bfd_elf_sym_name (input_bfd,
+ symtab_hdr,
+ sym,
+ sym_sec));
ret_val = FALSE;
continue;
}
case R_IA64_LTOFF_TPREL22:
case R_IA64_LTOFF_DTPMOD22:
case R_IA64_LTOFF_DTPREL22:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
input_bfd, input_section, howto->name, name,
rel->r_offset);
/* Relaxtion is always performed for ELF output.
Overflow failures for those relocations mean
that the section is too big to relax. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
input_bfd, input_section, howto->name, name,
rel->r_offset, input_section->size);
if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking trap-on-NULL-dereference with non-trapping files"),
ibfd);
}
if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking big-endian files with little-endian files"),
ibfd);
}
if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking 64-bit files with 32-bit files"),
ibfd);
}
if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking constant-gp files with non-constant-gp files"),
ibfd);
if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
!= (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking auto-pic files with non-auto-pic files"),
ibfd);
if (g->assigned_low_gotno > g->assigned_high_gotno)
{
/* We didn't allocate enough space in the GOT. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("not enough GOT space for local GOT entries"));
bfd_set_error (bfd_error_bad_value);
return NULL;
if ((mips16_branch_reloc_p (r_type) && target_is_micromips_code_p)
|| (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("MIPS16 and microMIPS functions cannot call each other"));
return bfd_reloc_notsupported;
}
&intopt);
if (intopt.size < sizeof (Elf_External_Options))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Warning: bad `%s' option size %u smaller than its header"),
abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
break;
&intopt);
if (intopt.size < sizeof (Elf_External_Options))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Warning: bad `%s' option size %u smaller than its header"),
abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
break;
r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
if (r_symndx == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Warning: cannot determine the target function for"
" stub section `%s'"),
abfd, name);
r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
if (r_symndx == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Warning: cannot determine the target function for"
" stub section `%s'"),
abfd, name);
h = NULL;
else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Malformed reloc detected for section %s"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (htab->is_vxworks && !bfd_link_pic (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: GOT reloc at 0x%lx not expected in executables"),
abfd, (unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
case R_MICROMIPS_CALL16:
if (h == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: CALL16 reloc at 0x%lx not against global symbol"),
abfd, (unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
case R_MIPS_26:
case R_MICROMIPS_26_S1:
howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd, howto->name,
(h) ? h->root.root.string : "a local symbol");
some that we can't convert. */
if (!htab->use_plts_and_copy_relocs || bfd_link_pic (info))
{
- (*_bfd_error_handler) (_("non-dynamic relocations refer to "
- "dynamic symbol %s"),
- h->root.root.string);
+ _bfd_error_handler (_("non-dynamic relocations refer to "
+ "dynamic symbol %s"),
+ h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
name = bfd_elf_sym_name (input_bfd, symtab_hdr,
local_syms + r_symndx,
sec);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
input_bfd, input_section, name, howto->name,
rel->r_offset);
/* ADDIUPC has a span of +/-16MB, check we're in range. */
if (gotpc_offset + 0x1000000 >= 0x2000000)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%A' offset of %ld from `%A' "
"beyond the range of ADDIUPC"),
output_bfd,
/* ADDIUPC has a span of +/-16MB, check we're in range. */
if (gotpc_offset + 0x1000000 >= 0x2000000)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%A' offset of %ld from `%A' beyond the range of ADDIUPC"),
output_bfd,
htab->sgotplt->output_section,
case E_MIPS_ARCH_64R2: new_isa = LEVEL_REV (64, 2); break;
case E_MIPS_ARCH_64R6: new_isa = LEVEL_REV (64, 6); break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Unknown architecture %s"),
abfd, bfd_printable_name (abfd));
}
gptab_bss_sec = o;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: illegal section name `%s'"),
bfd_get_filename (abfd), o->name);
bfd_set_error (bfd_error_nonrepresentable_section);
if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
!= ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: linking abicalls files with non-abicalls files"),
ibfd);
ok = TRUE;
/* Compare the ISAs. */
if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking 32-bit code with 64-bit code"),
ibfd);
ok = FALSE;
else
{
/* The ISAs aren't compatible. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking %s module with previous %s modules"),
ibfd,
bfd_printable_name (ibfd),
|| (elf_elfheader (ibfd)->e_ident[EI_CLASS]
!= elf_elfheader (obfd)->e_ident[EI_CLASS]))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: ABI mismatch: linking %s module with previous %s modules"),
ibfd,
elf_mips_abi_name (ibfd),
if (m16_mis || micro_mis)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: ASE mismatch: linking %s module with previous %s modules"),
ibfd,
m16_mis ? "MIPS16" : "microMIPS",
/* Warn about any other mismatches */
if (new_flags != old_flags)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: uses different e_flags (0x%lx) fields than previous modules "
"(0x%lx)"),
ibfd, (unsigned long) new_flags,
/* Check if we have the same endianness. */
if (! _bfd_generic_verify_endian_match (ibfd, obfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: endianness incompatible with that of the selected emulation"),
ibfd);
return FALSE;
if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: ABI is incompatible with that of the selected emulation"),
ibfd);
return FALSE;
if (LEVEL_REV (in_abiflags.isa_level, in_abiflags.isa_rev)
< LEVEL_REV (abiflags.isa_level, abiflags.isa_rev))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Inconsistent ISA between e_flags and "
".MIPS.abiflags"), ibfd);
if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY
&& in_abiflags.fp_abi != abiflags.fp_abi)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Inconsistent FP ABI between .gnu.attributes and "
".MIPS.abiflags"), ibfd);
if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Inconsistent ASEs between e_flags and "
".MIPS.abiflags"), ibfd);
/* The isa_ext is allowed to be an extension of what can be inferred
from e_flags. */
if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags.isa_ext),
bfd_mips_isa_ext_mach (in_abiflags.isa_ext)))
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Inconsistent ISA extensions between e_flags and "
".MIPS.abiflags"), ibfd);
if (in_abiflags.flags2 != 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: warning: Unexpected flag in the flags2 field of "
".MIPS.abiflags (0x%lx)"), ibfd,
(unsigned long) in_abiflags.flags2);
default:
if (r_type >= (unsigned int) R_SPARC_max_std)
{
- (*_bfd_error_handler) (_("invalid relocation type %d"),
- (int) r_type);
+ _bfd_error_handler (_("invalid relocation type %d"), (int) r_type);
r_type = R_SPARC_NONE;
}
return &_bfd_sparc_elf_howto_table[r_type];
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"), abfd, r_symndx);
return FALSE;
}
tls_type = old_tls_type;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
NULL);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't handled by %s"), input_bfd,
_bfd_sparc_elf_howto_table[r_type].name,
if (indx == 0)
{
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
&& h->def_dynamic)
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
- abfd, r_symndx);
+ _bfd_error_handler (_("%B: bad symbol index: %d"),
+ abfd, r_symndx);
return FALSE;
}
tls_type = old_tls_type;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
if ((unsigned int)r_type >= ARRAY_SIZE (tilegx_elf_howto_table))
{
/* Not clear if we need to check here, but just be paranoid. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unrecognized relocation (0x%x) in section `%A'"),
input_bfd, r_type, input_section);
bfd_set_error (bfd_error_bad_value);
if (indx == 0)
{
BFD_FAIL ();
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
&& h->def_dynamic)
&& _bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset) != (bfd_vma) -1)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
{
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("discarded output section: `%A'"), htab->elf.sgotplt);
return FALSE;
}
if (strcmp (targ1, targ2) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: Cannot link together %s and %s objects."),
ibfd, targ1, targ2);
bfd_set_error (bfd_error_bad_value);
built.
*/
if ((unknown_sections > 0) && (good_sections > 0))
- (*_bfd_error_handler)
+ _bfd_error_handler
("%s appears to be a core file,\nbut contains unknown sections. It may have been created on an incompatible\nversion of HP-UX. As a result, some information may be unavailable.\n",
abfd->filename);
alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
if (p == NULL || alloc == NULL)
- (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
- name);
+ _bfd_error_handler (_("Output file requires shared library `%s'\n"),
+ name);
else
{
strcpy (alloc, name);
p = strrchr (alloc, '_');
*p++ = '\0';
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Output file requires shared library `%s.so.%s'\n"),
alloc, p);
free (alloc);
if (f->h->root.root.type != bfd_link_hash_defined
&& f->h->root.root.type != bfd_link_hash_defweak)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol %s not defined for fixups\n"),
f->h->root.root.root.string);
continue;
if (f->h->root.root.type != bfd_link_hash_defined
&& f->h->root.root.type != bfd_link_hash_defweak)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol %s not defined for fixups\n"),
f->h->root.root.root.string);
continue;
if (linux_hash_table (info)->fixup_count != fixups_written)
{
- (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
+ _bfd_error_handler (_("Warning: fixup count mismatch\n"));
while (linux_hash_table (info)->fixup_count > fixups_written)
{
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: string too long (%d chars, max 65535)"),
bfd_get_filename (abfd), length);
bfd_set_error (bfd_error_invalid_operation);
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: unrecognized symbol `%s' flags 0x%x"),
bfd_get_filename (abfd), bfd_asymbol_name (symbol),
symbol->flags);
parse_int (&ieee->h, &value);
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unimplemented ATI record %u for symbol %u"),
abfd, symbol_attribute_def, symbol_name_index);
bfd_set_error (bfd_error_bad_value);
parse_int (&ieee->h, &value);
if (value != 0x3f)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unexpected ATN type %d in external part"),
abfd, (int) value);
bfd_set_error (bfd_error_bad_value);
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unexpected type after ATN"), abfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
buf[0] = c;
buf[1] = '\0';
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%d: unexpected character `%s' in Intel Hex file"),
abfd, lineno, buf);
bfd_set_error (bfd_error_bad_value);
chksum += HEX2 (buf + 2 * i);
if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
abfd, lineno,
(- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
/* An extended address record. */
if (len != 2)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%u: bad extended address record length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
/* An extended start address record. */
if (len != 4)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%u: bad extended start address length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
/* An extended linear address record. */
if (len != 2)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%u: bad extended linear address record length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
/* An extended linear start address record. */
if (len != 2 && len != 4)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%u: bad extended linear start address length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%u: unrecognized ihex type %u in Intel Hex file"),
abfd, lineno, type);
bfd_set_error (bfd_error_bad_value);
/* We should only see type 0 records here. */
if (type != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: internal error in ihex_read_section"), abfd);
bfd_set_error (bfd_error_bad_value);
goto error_return;
if ((bfd_size_type) (p - contents) < section->size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad section length in ihex_read_section"), abfd);
bfd_set_error (bfd_error_bad_value);
goto error_return;
char buf[20];
sprintf_vma (buf, where);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: address 0x%s out of range for Intel Hex file"),
bfd_get_filename (abfd), buf);
bfd_set_error (bfd_error_bad_value);
if (section->compress_status != COMPRESS_SECTION_NONE)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: unable to get decompressed section %A"),
abfd, section);
bfd_set_error (bfd_error_invalid_operation);
else
msg = _("%B: compiled for a little endian system and target is big endian");
- (*_bfd_error_handler) (msg, ibfd);
+ _bfd_error_handler (msg, ibfd);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
row = COMMON_ROW;
if (!bfd_link_relocatable (info)
&& strcmp (name, "__gnu_lto_slim") == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: plugin needed to handle lto object"),
bfd_get_filename (abfd));
}
if (inh->type == bfd_link_hash_indirect
&& inh->u.i.link == h)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: indirect symbol `%s' to `%s' is a loop"),
abfd, name, string);
bfd_set_error (bfd_error_invalid_operation);
because somebody is attempting to link together different
types of object files. Handling this case correctly is
difficult, and sometimes impossible. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Attempt to do relocatable link with %s input and %s output"),
bfd_get_target (input_bfd), bfd_get_target (output_bfd));
bfd_set_error (bfd_error_wrong_format);
alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
if (p == NULL || alloc == NULL)
- (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
- name);
+ _bfd_error_handler (_("Output file requires shared library `%s'\n"),
+ name);
else
{
strcpy (alloc, name);
p = strrchr (alloc, '_');
*p++ = '\0';
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Output file requires shared library `%s.so.%s'\n"),
alloc, p);
free (alloc);
if (f->h->root.root.type != bfd_link_hash_defined
&& f->h->root.root.type != bfd_link_hash_defweak)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol %s not defined for fixups\n"),
f->h->root.root.root.string);
continue;
if (f->h->root.root.type != bfd_link_hash_defined
&& f->h->root.root.type != bfd_link_hash_defweak)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol %s not defined for fixups\n"),
f->h->root.root.root.string);
continue;
if (linux_hash_table (info)->fixup_count != fixups_written)
{
- (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
+ _bfd_error_handler (_("Warning: fixup count mismatch\n"));
while (linux_hash_table (info)->fixup_count > fixups_written)
{
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
if (!bfd_mach_o_read_symtab_symbols (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
return 0;
}
|| cmd->ntoc != 0
|| cmd->nextrefsyms != 0)
{
- (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
- " implemented for dysymtab commands."));
+ _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
+ " implemented for dysymtab commands."));
return FALSE;
}
/* We need to check that this can be done... */
if (nsect > 255)
{
- (*_bfd_error_handler) (_("mach-o: there are too many sections (%u)"
- " maximum is 255,\n"), nsect);
+ _bfd_error_handler (_("mach-o: there are too many sections (%u)"
+ " maximum is 255,\n"), nsect);
return FALSE;
}
/* Nothing to do. */
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("unable to allocate data for load command 0x%lx"),
(unsigned long) cmd->type);
break;
return FALSE;
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("unable to write unknown load command 0x%lx"),
(unsigned long) cmd->type);
return FALSE;
if (s->addr < vma)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("section address (%lx) below start of segment (%lx)"),
(unsigned long) s->addr, (unsigned long) vma);
return FALSE;
+ BFD_MACH_O_LC_SIZE;
break;
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("unable to layout unknown load command 0x%lx"),
(unsigned long) cmd->type);
ret = FALSE;
/* PR 17512: file: 0017eb76. */
if (section->align > 64)
{
- (*_bfd_error_handler) (_("bfd_mach_o_read_section_32: overlarge alignment value: 0x%x, using 32 instead"),
- section->align);
+ _bfd_error_handler
+ (_("bfd_mach_o_read_section_32: overlarge alignment value: 0x%x, "
+ "using 32 instead"), section->align);
section->align = 32;
}
section->reloff = bfd_h_get_32 (abfd, raw.reloff);
section->align = bfd_h_get_32 (abfd, raw.align);
if (section->align > 64)
{
- (*_bfd_error_handler) (_("bfd_mach_o_read_section_64: overlarge alignment value: 0x%x, using 32 instead"),
- section->align);
+ _bfd_error_handler
+ (_("bfd_mach_o_read_section_64: overlarge alignment value: 0x%x, "
+ "using 32 instead"), section->align);
section->align = 32;
}
section->reloff = bfd_h_get_32 (abfd, raw.reloff);
if (bfd_seek (abfd, symoff, SEEK_SET) != 0
|| bfd_bread (&raw, symwidth, abfd) != symwidth)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
symwidth, (unsigned long) symoff);
return FALSE;
if (stroff >= sym->strsize)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
(unsigned long) stroff,
(unsigned long) sym->strsize);
/* Mach-O uses 0 to mean "no section"; not an error. */
if (section != 0)
{
- (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
- "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
- s->symbol.name, section, mdata->nsects);
+ _bfd_error_handler
+ (_("bfd_mach_o_read_symtab_symbol: "
+ "symbol \"%s\" specified invalid section %d (max %lu): "
+ "setting to undefined"),
+ s->symbol.name, section, mdata->nsects);
}
s->symbol.section = bfd_und_section_ptr;
}
s->symbol.value = 0;
break;
default:
- (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
- "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
- s->symbol.name, symtype);
+ _bfd_error_handler
+ (_("bfd_mach_o_read_symtab_symbol: "
+ "symbol \"%s\" specified invalid type field 0x%x: "
+ "setting to undefined"), s->symbol.name, symtype);
s->symbol.section = bfd_und_section_ptr;
break;
}
sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
if (sym->symbols == NULL)
{
- (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
+ _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
+ "unable to allocate memory for symbols"));
sym->nsyms = 0;
return FALSE;
}
break;
default:
command->len = 0;
- (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
- abfd, (unsigned long) command->type);
+ _bfd_error_handler (_("%B: unknown load command 0x%lx"),
+ abfd, (unsigned long) command->type);
return FALSE;
}
&cputype, &cpusubtype);
if (cputype == bfd_arch_unknown)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
header->cputype, header->cpusubtype);
return FALSE;
if (! (header.byteorder == BFD_ENDIAN_BIG
|| header.byteorder == BFD_ENDIAN_LITTLE))
{
- (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
- (unsigned long) header.byteorder);
+ _bfd_error_handler (_("unknown header byte-order value 0x%lx"),
+ (unsigned long) header.byteorder);
goto wrong;
}
if (offset >= sec->rawsize)
{
if (offset > sec->rawsize)
- {
- (*_bfd_error_handler)
- (_("%s: access beyond end of merged section (%ld)"),
- bfd_get_filename (sec->owner), (long) offset);
- }
+ _bfd_error_handler
+ (_("%s: access beyond end of merged section (%ld)"),
+ bfd_get_filename (sec->owner), (long) offset);
return secinfo->first_str ? sec->size : 0;
}
if (newsecname == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: No core to allocate section name %s\n"),
bfd_get_filename (abfd), secname);
bfd_set_error (bfd_error_system_call);
if (abfd->tdata.mmo_data->lop_stab_symbol == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: No core to allocate a symbol %d bytes long\n"),
bfd_get_filename (abfd), abfd->tdata.mmo_data->max_symbol_length);
goto bad_final;
group-wise aligned. */
if ((vma & 3) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: attempt to emit contents at non-multiple-of-4 address 0x%lx\n"),
bfd_get_filename (abfd), (unsigned long) vma);
bfd_set_error (bfd_error_bad_value);
&& bfd_get_start_address (abfd) != addr
&& !mmo_ignore_symbol_consistency (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: initialization value for $255 is not `Main'\n"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_bad_value);
abfd->tdata.mmo_data->lop_stab_symbol
[abfd->tdata.mmo_data->symbol_position] = 0;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: unsupported wide character sequence"
" 0x%02X 0x%02X after symbol name starting with `%s'\n"),
bfd_get_filename (abfd), c, c2,
switch (buf[1])
{
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: unsupported lopcode `%d'\n"),
bfd_get_filename (abfd), buf[1]);
bfd_set_error (bfd_error_bad_value);
/* Quote the next 32-bit word. */
if (y != 0 || z != 1)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: expected YZ = 1 got YZ = %d for lop_quote\n"),
bfd_get_filename (abfd), y*256+z);
bfd_set_error (bfd_error_bad_value);
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_loc\n"),
bfd_get_filename (abfd), z);
bfd_set_error (bfd_error_bad_value);
}
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_fixo\n"),
bfd_get_filename (abfd), z);
bfd_set_error (bfd_error_bad_value);
if (y != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: expected y = 0, got y = %d for lop_fixrx\n"),
bfd_get_filename (abfd), y);
bfd_set_error (bfd_error_bad_value);
if (z != 16 && z != 24)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: expected z = 16 or z = 24, got z = %d for lop_fixrx\n"),
bfd_get_filename (abfd), z);
bfd_set_error (bfd_error_bad_value);
p = vma - 4 * ((delta & 0xffffff) - (1 << z));
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: leading byte of operand word must be 0 or 1, got %d for lop_fixrx\n"),
bfd_get_filename (abfd), buf[0]);
bfd_set_error (bfd_error_bad_value);
if (fname == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: cannot allocate file name for file number %d, %d bytes\n"),
bfd_get_filename (abfd), y, z * 4 + 1);
bfd_set_error (bfd_error_system_call);
if (file_names[y] != NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: file number %d `%s',"
" was already entered as `%s'\n"),
bfd_get_filename (abfd), y, fname, file_names[y]);
if (file_names[y] == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: file name for number %d"
" was not specified before use\n"),
bfd_get_filename (abfd), y);
/* We read in the symbols now, not later. */
if (y != 0 || z != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: fields y and z of lop_stab"
" non-zero, y: %d, z: %d\n"),
bfd_get_filename (abfd), y, z);
if (statbuf.st_size != curpos)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: lop_end not last item in"
" file\n"),
bfd_get_filename (abfd));
it. */
if ((long) (y * 256 + z) * 4 != (curpos - stab_loc) - 4)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid mmo file: YZ of lop_end (%ld)"
" not equal to the number of tetras to the preceding"
" lop_stab (%ld)\n"),
we discover it and bail out. */
if (trie->sym.name != NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid symbol table: duplicate symbol `%s'\n"),
bfd_get_filename (abfd), trie->sym.name);
bfd_set_error (bfd_error_bad_value);
sprintf_vma (vmas_main, mainvalue);
sprintf_vma (vmas_start, vma_start);
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: Bad symbol definition: `Main' set to %s rather"
" than the start address %s\n"),
bfd_get_filename (abfd), vmas_main, vmas_start);
There's no specific test-case. */
struct mmo_symbol sym;
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: warning: symbol table too large for mmo, larger than 65535"
" 32-bit words: %d. Only `Main' will be emitted.\n"),
bfd_get_filename (abfd), trie_len);
/* I haven't seen this trig. It seems no use claiming this case
isn't debugged and abort if we get here. Instead emit a
diagnostic and fail "normally". */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: internal error, symbol table changed size from %d to %d"
" words\n"),
bfd_get_filename (abfd), trie_len,
/* Make sure it hasn't got contents. It seems impossible to
make it carry contents, so we don't have a test-case for
this. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: internal error, internal register section %s had"
" contents\n"),
bfd_get_filename (abfd), sec->name);
if (sec->size == 0)
/* There must always be at least one such register. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: no initialized registers; section length 0\n"),
bfd_get_filename (abfd));
else if (sec->vma > (256 - 32) * 8)
/* Provide better error message for the case of too many
global registers. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: too many initialized registers; section length %ld\n"),
bfd_get_filename (abfd),
(long) sec->size);
else
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: invalid start address for initialized registers of"
" length %ld: 0x%lx%08lx\n"),
bfd_get_filename (abfd),
{
if (!ISDIGIT (s->name[0]))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: can not represent section `%s' in oasys"),
bfd_get_filename (abfd), s->name);
bfd_set_error (bfd_error_nonrepresentable_section);
flags = SEC_HAS_CONTENTS;
break;
default:
- (*_bfd_error_handler) (_("Unhandled OSF/1 core file section type %d\n"),
- core_scnhdr.scntype);
+ _bfd_error_handler (_("Unhandled OSF/1 core file section type %d\n"),
+ core_scnhdr.scntype);
continue;
}
if (section != obj_textsec (abfd)
&& section != obj_datasec (abfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%s: can not represent section `%s' in a.out object file format",
bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
bfd_set_error (bfd_error_nonrepresentable_section);
{
/* This case occurs, e.g., for the *DEBUG* section of a COFF
file. */
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: can not represent section for symbol `%s' in a.out object file format",
abfd, cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
bfd_set_error (bfd_error_nonrepresentable_section);
sym_pointer->e_type[0] = N_UNDF | N_EXT;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
("%B: can not represent section `%A' in a.out object file format",
abfd, sec);
bfd_set_error (bfd_error_nonrepresentable_section);
and call get_reloc_upper_bound and canonicalize_reloc to
work out the number of relocs needed, and then multiply
by the reloc size. */
- (*_bfd_error_handler)
+ _bfd_error_handler
("%s: relocatable link from %s to %s not supported",
bfd_get_filename (abfd),
sub->xvec->name, abfd->xvec->name);
if (bfd_link_relocatable (info))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `ld -r' not supported with PE MIPS objects\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
mem = pointer to memory we're fixing up
val = VMA of what we need to refer to. */
-#define UI(x) (*_bfd_error_handler) (_("%B: unimplemented %s\n"), \
- input_bfd, x); \
+#define UI(x) _bfd_error_handler (_("%B: unimplemented %s\n"), \
+ input_bfd, x); \
bfd_set_error (bfd_error_bad_value);
switch (rel->r_type)
targ = val + (tmp & 0x03ffffff) * 4;
if ((src & 0xf0000000) != (targ & 0xf0000000))
{
- (*_bfd_error_handler) (_("%B: jump too far away\n"), input_bfd);
+ _bfd_error_handler (_("%B: jump too far away\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
targ = val + low + ((tmp & 0xffff) << 16);
break;
default:
- (*_bfd_error_handler) (_("%B: bad pair/reflo after refhi\n"),
- input_bfd);
+ _bfd_error_handler (_("%B: bad pair/reflo after refhi\n"),
+ input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
/* PR 17512: Corrupt PE binaries can cause seg-faults. */
if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: aout header specifies an invalid number of data-directory entries: %d"),
abfd, a->NumberOfRvaAndSizes);
bfd_set_error (bfd_error_bad_value);
H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
else
{
- (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
- bfd_get_filename (abfd),
- scnhdr_int->s_nlnno);
+ _bfd_error_handler (_("%s: line number overflow: 0x%lx > 0xffff"),
+ bfd_get_filename (abfd),
+ scnhdr_int->s_nlnno);
bfd_set_error (bfd_error_file_truncated);
H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
ret = 0;
bfd_pef_convert_architecture (header->architecture, &cputype, &cpusubtype);
if (cputype == bfd_arch_unknown)
{
- (*_bfd_error_handler) (_("bfd_pef_scan: unknown architecture 0x%lx"),
- header->architecture);
+ _bfd_error_handler (_("bfd_pef_scan: unknown architecture 0x%lx"),
+ header->architecture);
return -1;
}
bfd_set_arch_mach (abfd, cputype, cpusubtype);
plugin_handle = dlopen (pname, RTLD_NOW);
if (!plugin_handle)
{
- (*_bfd_error_handler)("%s\n", dlerror ());
+ _bfd_error_handler ("%s\n", dlerror ());
return 0;
}
{
if (flaginfo != NULL)
{
- (*_bfd_error_handler) (_("INPUT_SECTION_FLAGS are not supported.\n"));
+ _bfd_error_handler (_("INPUT_SECTION_FLAGS are not supported.\n"));
return FALSE;
}
return TRUE;
/* Issue warning if the core file was truncated during writing. */
if (c_flag & CORE_TRUNC)
- (*_bfd_error_handler) (_("%s: warning core file truncated"),
- bfd_get_filename (abfd));
+ _bfd_error_handler (_("%s: warning core file truncated"),
+ bfd_get_filename (abfd));
/* Allocate core file header. */
#ifndef BFD64
secname = NULL; /* Ignore these */
break;
default:
- (*_bfd_error_handler) ("Unhandled SCO core file section type %d\n",
- chead.cs_stype);
+ _bfd_error_handler ("Unhandled SCO core file section type %d\n",
+ chead.cs_stype);
continue;
}
som_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
- (*_bfd_error_handler) (_("som_sizeof_headers unimplemented"));
+ _bfd_error_handler (_("som_sizeof_headers unimplemented"));
abort ();
return 0;
}
alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
if (p == NULL || alloc == NULL)
- (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
- name);
+ _bfd_error_handler (_("Output file requires shared library `%s'\n"),
+ name);
else
{
strcpy (alloc, name);
p = strrchr (alloc, '_');
*p++ = '\0';
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Output file requires shared library `%s.so.%s'\n"),
alloc, p);
free (alloc);
if (f->h->root.root.type != bfd_link_hash_defined
&& f->h->root.root.type != bfd_link_hash_defweak)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol %s not defined for fixups\n"),
f->h->root.root.root.string);
continue;
if (f->h->root.root.type != bfd_link_hash_defined
&& f->h->root.root.type != bfd_link_hash_defweak)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Symbol %s not defined for fixups\n"),
f->h->root.root.root.string);
continue;
if (linux_hash_table (info)->fixup_count != fixups_written)
{
- (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
+ _bfd_error_handler (_("Warning: fixup count mismatch\n"));
while (linux_hash_table (info)->fixup_count > fixups_written)
{
bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
buf[0] = c;
buf[1] = '\0';
}
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%d: Unexpected character `%s' in S-record file\n"),
abfd, lineno, buf);
bfd_set_error (bfd_error_bad_value);
min_bytes = 5;
if (bytes < min_bytes)
{
- (*_bfd_error_handler) (_("%B:%d: byte count %d too small\n"),
- abfd, lineno, bytes);
+ _bfd_error_handler (_("%B:%d: byte count %d too small\n"),
+ abfd, lineno, bytes);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
check_sum = 255 - (check_sum & 0xff);
if (check_sum != HEX (data))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%d: Bad checksum in S-record file\n"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
check_sum = 255 - (check_sum & 0xff);
if (check_sum != HEX (data))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B:%d: Bad checksum in S-record file\n"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
symstroff = stroff + bfd_get_32 (abfd, sym + STRDXOFF);
if (symstroff >= stabstrsec->size)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B(%A+0x%lx): Stabs entry has invalid string index."),
abfd, stabsec, (long) (sym - stabbuf));
bfd_set_error (bfd_error_bad_value);
|| r->howto->bitpos != 0
|| r->howto->dst_mask != 0xffffffff)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Unsupported .stab relocation"));
bfd_set_error (bfd_error_invalid_operation);
if (reloc_vector != NULL)
case EGSD__C_SYMM:
case EGSD__C_SYMV:
default:
- (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
+ _bfd_error_handler (_("Unknown EGSD subtype %d"), gsd_type);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (PRIV (stackptr) >= STACKSIZE)
{
bfd_set_error (bfd_error_bad_value);
- (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
+ _bfd_error_handler (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
exit (1);
}
}
if (PRIV (stackptr) == 0)
{
bfd_set_error (bfd_error_bad_value);
- (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
+ _bfd_error_handler (_("Stack underflow in _bfd_vms_pop"));
exit (1);
}
PRIV (stackptr)--;
default:
/* These names have not yet been added to this switch statement. */
- (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
+ _bfd_error_handler (_("unknown ETIR command %d"), cmd);
}
return NULL;
psect = bfd_getl32 (ptr);
if ((unsigned int) psect >= PRIV (section_count))
{
- (*_bfd_error_handler) (_("bad section index in %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("bad section index in %s"),
+ _bfd_vms_etir_name (cmd));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case ETIR__C_STA_LI:
case ETIR__C_STA_MOD:
case ETIR__C_STA_CKARG:
- (*_bfd_error_handler) (_("unsupported STA cmd %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("unsupported STA cmd %s"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
case ETIR__C_STO_RB:
case ETIR__C_STO_AB:
case ETIR__C_STO_LP_PSB:
- (*_bfd_error_handler) (_("%s: not supported"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
case ETIR__C_STO_HINT_GBL:
case ETIR__C_STO_HINT_PS:
- (*_bfd_error_handler) (_("%s: not implemented"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not implemented"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
lw psect index
qw offset. */
case ETIR__C_STC_PS:
- (*_bfd_error_handler) (_("%s: not supported"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
/* 214 Store-conditional NOP, BSR or HINT at psect + offset
arg: none. */
case ETIR__C_STC_NBH_PS:
- (*_bfd_error_handler) ("%s: not supported",
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler ("%s: not supported",
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
{
bad_context:
- (*_bfd_error_handler) (_("invalid use of %s with contexts"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("invalid use of %s with contexts"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
}
if ((int)op2 < 0) /* Shift right. */
case ETIR__C_OPR_ROT: /* Rotate. */
case ETIR__C_OPR_REDEF: /* Redefine symbol to current location. */
case ETIR__C_OPR_DFLIT: /* Define a literal. */
- (*_bfd_error_handler) (_("%s: not supported"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
break;
default:
- (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
+ _bfd_error_handler (_("reserved cmd %d"), cmd);
return FALSE;
break;
}
PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
if (PRIV (eom_data).eom_w_comcod > 1)
{
- (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
+ _bfd_error_handler (_("Object module NOT error-free !\n"));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
unsigned int irel;
if (section->reloc_count == 0)
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("SEC_RELOC with no relocs in section %s"), section->name);
#if VMS_DEBUG
/* Regular relocs are intertwined with binary data. */
if (curr_addr > addr)
- (*_bfd_error_handler) (_("Size error in section %s"),
- section->name);
+ _bfd_error_handler (_("Size error in section %s"),
+ section->name);
size = addr - curr_addr;
sto_imm (abfd, section, size, curr_data, curr_addr);
curr_data += size;
break;
case ALPHA_R_BSR:
- (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
+ _bfd_error_handler (_("Spurious ALPHA_R_BSR reloc"));
break;
case ALPHA_R_LDA:
break;
default:
- (*_bfd_error_handler) (_("Unhandled relocation %s"),
- rptr->howto->name);
+ _bfd_error_handler (_("Unhandled relocation %s"),
+ rptr->howto->name);
break;
}
{
/* Output rest of section. */
if (curr_addr > section->size)
- (*_bfd_error_handler) (_("Size error in section %s"),
- section->name);
+ _bfd_error_handler (_("Size error in section %s"),
+ section->name);
size = section->size - curr_addr;
sto_imm (abfd, section, size, curr_data, curr_addr);
curr_data += size;
break;
default:
- (*_bfd_error_handler) (_("unknown source command %d"),
- cmd);
+ _bfd_error_handler (_("unknown source command %d"),
+ cmd);
cmd_length = 2;
break;
}
break;
case DST__K_SET_LINUM_INCR:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_LINUM_INCR not implemented"));
cmd_length = 2;
break;
case DST__K_SET_LINUM_INCR_W:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_LINUM_INCR_W not implemented"));
cmd_length = 3;
break;
case DST__K_RESET_LINUM_INCR:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_RESET_LINUM_INCR not implemented"));
cmd_length = 1;
break;
case DST__K_BEG_STMT_MODE:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_BEG_STMT_MODE not implemented"));
cmd_length = 1;
break;
case DST__K_END_STMT_MODE:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_END_STMT_MODE not implemented"));
cmd_length = 1;
break;
break;
case DST__K_SET_PC:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_PC not implemented"));
cmd_length = 2;
break;
case DST__K_SET_PC_W:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_PC_W not implemented"));
cmd_length = 3;
break;
case DST__K_SET_PC_L:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_PC_L not implemented"));
cmd_length = 5;
break;
case DST__K_SET_STMTNUM:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_STMTNUM not implemented"));
cmd_length = 2;
break;
}
else
{
- (*_bfd_error_handler) (_("unknown line command %d"),
- cmd);
+ _bfd_error_handler (_("unknown line command %d"), cmd);
cmd_length = 2;
}
break;
case ETIR__C_CTL_SETRB:
if (prev_cmd != ETIR__C_STA_PQ)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
_bfd_vms_etir_name (cmd));
return FALSE;
{
if (prev_cmd != ETIR__C_STA_GBL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
_bfd_vms_etir_name (ETIR__C_STA_LW));
return FALSE;
/* ALPHA_R_REFQUAD und_section, step 2 */
if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
_bfd_vms_etir_name (ETIR__C_STA_QW));
return FALSE;
&& prev_cmd != ETIR__C_STA_LW
&& prev_cmd != ETIR__C_STA_PQ)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_STO_LW));
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_STO_LW));
return FALSE;
}
reloc_code = BFD_RELOC_32;
/* ALPHA_R_REFQUAD abs_section, step 2 */
if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_STO_QW));
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_STO_QW));
return FALSE;
}
reloc_code = BFD_RELOC_64;
case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
if (prev_cmd != ETIR__C_STA_PQ)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_STO_OFF));
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_STO_OFF));
return FALSE;
}
reloc_code = BFD_RELOC_64;
/* ALPHA_R_REFQUAD und_section, step 3 */
if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_OPR_ADD));
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_OPR_ADD));
return FALSE;
}
prev_cmd = ETIR__C_OPR_ADD;
continue;
default:
- (*_bfd_error_handler) (_("Unknown reloc %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("Unknown reloc %s"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
}
/* Get section to which the relocation applies. */
if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
{
- (*_bfd_error_handler) (_("Invalid section index in ETIR"));
+ _bfd_error_handler (_("Invalid section index in ETIR"));
return FALSE;
}
sec = PRIV (sections)[cur_psect];
if (sec == bfd_abs_section_ptr)
{
- (*_bfd_error_handler) (_("Relocation for non-REL psect"));
+ _bfd_error_handler (_("Relocation for non-REL psect"));
return FALSE;
}
}
if (sym == NULL)
{
- (*_bfd_error_handler) (_("Unknown symbol in command %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("Unknown symbol in command %s"),
+ _bfd_vms_etir_name (cmd));
reloc->sym_ptr_ptr = NULL;
}
else
case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
default:
- (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
+ _bfd_error_handler ("reloc (%d) is *UNKNOWN*", code);
return NULL;
}
vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
if (res == NULL)
{
- (*_bfd_error_handler)(_("could not open shared image '%s' from '%s'"),
- filename, archive->filename);
+ _bfd_error_handler(_("could not open shared image '%s' from '%s'"),
+ filename, archive->filename);
bfd_release (archive, filename);
return NULL;
}
len = strlen (value);
if (len == 0)
{
- (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
+ _bfd_error_handler (_("_bfd_vms_output_counted called with zero bytes"));
return;
}
if (len > 255)
{
- (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
+ _bfd_error_handler (_("_bfd_vms_output_counted called with too many bytes"));
return;
}
_bfd_vms_output_byte (recwr, (unsigned int) len & 0xff);
output file. */
if (info->output_bfd->xvec != abfd->xvec)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: XCOFF shared object when not producing XCOFF output"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_invalid_operation);
lsec = bfd_get_section_by_name (abfd, ".loader");
if (lsec == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%s: dynamic object with no .loader section"),
bfd_get_filename (abfd));
bfd_set_error (bfd_error_no_symbols);
enclosing = xcoff_section_data (abfd, csect)->enclosing;
if (enclosing == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' has line numbers but no enclosing section"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
/* Pick up the csect auxiliary information. */
if (sym.n_numaux == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: class %d symbol `%s' has no aux entries"),
abfd, sym.n_sclass, name);
bfd_set_error (bfd_error_bad_value);
switch (smtyp)
{
default:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: symbol `%s' has unrecognized csect type %d"),
abfd, name, smtyp);
bfd_set_error (bfd_error_bad_value);
|| sym.n_scnum != N_UNDEF
|| aux.x_csect.x_scnlen.l != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"),
abfd, name, sym.n_sclass, sym.n_scnum,
aux.x_csect.x_scnlen.l);
if (sym.n_sclass != C_HIDEXT
|| aux.x_csect.x_scnlen.l != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: XMC_TC0 symbol `%s' is class %d scnlen %d"),
abfd, name, sym.n_sclass, aux.x_csect.x_scnlen.l);
bfd_set_error (bfd_error_bad_value);
|| ((bfd_vma) sym.n_value + aux.x_csect.x_scnlen.l
> enclosing->vma + enclosing->size)))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: csect `%s' not in enclosing section"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
}
if (bad)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: misplaced XTY_LD `%s'"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
{
if (*rel_csect == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: reloc %s:%d not in csect"),
abfd, o->name, i);
bfd_set_error (bfd_error_bad_value);
FALSE));
if (h == NULL)
{
- (*_bfd_error_handler) (_("%s: no such symbol"), name);
+ _bfd_error_handler (_("%s: no such symbol"), name);
bfd_set_error (bfd_error_no_symbols);
return FALSE;
}
if ((h->flags & XCOFF_EXPORT) != 0
&& (h->flags & XCOFF_WAS_UNDEFINED) != 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("warning: attempt to export undefined symbol `%s'"),
h->root.root.string);
return TRUE;
"__rtinit", FALSE, FALSE, TRUE);
if (hsym == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("error: undefined symbol __rtinit"));
return FALSE;
}
ldrel.l_symndx = 2;
else
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: loader reloc in unrecognized section `%s'"),
reference_bfd, secname);
bfd_set_error (bfd_error_nonrepresentable_section);
{
if (h->ldindx < 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: `%s' in loader reloc but not loader sym"),
reference_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
if (xcoff_hash_table (flinfo->info)->textro
&& strcmp (output_section->name, ".text") == 0)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: loader reloc in read-only section %A"),
reference_bfd, output_section);
bfd_set_error (bfd_error_invalid_operation);
/* Make sure that the start of the TOC is also within range. */
if (best_address > toc_start + 0x8000)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("TOC overflow: 0x%lx > 0x10000; try -mminimal-toc "
"when compiling"),
(unsigned long) (toc_end - toc_start));
projects / external / binutils.git / commitdiff