+2018-02-19 Alan Modra <amodra@gmail.com>
+
+ * bfd.c (_bfd_doprnt, _bfd_doprnt_scan): Handle %pA and %pB in place
+ of %A and %B.
+ * aout-adobe.c: Update all messages using %A and %B.
+ * aout-cris.c: Likewise.
+ * aoutx.h: Likewise.
+ * archive.c: Likewise.
+ * binary.c: Likewise.
+ * cache.c: Likewise.
+ * coff-alpha.c: Likewise.
+ * coff-arm.c: Likewise.
+ * coff-i860.c: Likewise.
+ * coff-mcore.c: Likewise.
+ * coff-ppc.c: Likewise.
+ * coff-rs6000.c: Likewise.
+ * coff-sh.c: Likewise.
+ * coff-tic4x.c: Likewise.
+ * coff-tic54x.c: Likewise.
+ * coff-tic80.c: Likewise.
+ * coff64-rs6000.c: Likewise.
+ * coffcode.h: Likewise.
+ * coffgen.c: Likewise.
+ * cofflink.c: Likewise.
+ * coffswap.h: Likewise.
+ * compress.c: Likewise.
+ * cpu-arm.c: Likewise.
+ * ecoff.c: Likewise.
+ * elf-attrs.c: Likewise.
+ * elf-eh-frame.c: Likewise.
+ * elf-ifunc.c: Likewise.
+ * elf-m10300.c: Likewise.
+ * elf-properties.c: Likewise.
+ * elf-s390-common.c: Likewise.
+ * elf.c: Likewise.
+ * elf32-arc.c: Likewise.
+ * elf32-arm.c: Likewise.
+ * elf32-avr.c: Likewise.
+ * elf32-bfin.c: Likewise.
+ * elf32-cr16.c: Likewise.
+ * elf32-cr16c.c: Likewise.
+ * elf32-cris.c: Likewise.
+ * elf32-crx.c: Likewise.
+ * elf32-d10v.c: Likewise.
+ * elf32-d30v.c: Likewise.
+ * elf32-epiphany.c: Likewise.
+ * elf32-fr30.c: Likewise.
+ * elf32-frv.c: Likewise.
+ * elf32-gen.c: Likewise.
+ * elf32-hppa.c: Likewise.
+ * elf32-i370.c: Likewise.
+ * elf32-i386.c: Likewise.
+ * elf32-i960.c: Likewise.
+ * elf32-ip2k.c: Likewise.
+ * elf32-iq2000.c: Likewise.
+ * elf32-lm32.c: Likewise.
+ * elf32-m32c.c: Likewise.
+ * elf32-m32r.c: Likewise.
+ * elf32-m68hc11.c: Likewise.
+ * elf32-m68hc12.c: Likewise.
+ * elf32-m68hc1x.c: Likewise.
+ * elf32-m68k.c: Likewise.
+ * elf32-mcore.c: Likewise.
+ * elf32-mep.c: Likewise.
+ * elf32-metag.c: Likewise.
+ * elf32-microblaze.c: Likewise.
+ * elf32-moxie.c: Likewise.
+ * elf32-msp430.c: Likewise.
+ * elf32-mt.c: Likewise.
+ * elf32-nds32.c: Likewise.
+ * elf32-nios2.c: Likewise.
+ * elf32-or1k.c: Likewise.
+ * elf32-pj.c: Likewise.
+ * elf32-ppc.c: Likewise.
+ * elf32-rl78.c: Likewise.
+ * elf32-rx.c: Likewise.
+ * elf32-s390.c: Likewise.
+ * elf32-score.c: Likewise.
+ * elf32-score7.c: Likewise.
+ * elf32-sh-symbian.c: Likewise.
+ * elf32-sh.c: Likewise.
+ * elf32-sh64.c: Likewise.
+ * elf32-sparc.c: Likewise.
+ * elf32-spu.c: Likewise.
+ * elf32-tic6x.c: Likewise.
+ * elf32-tilepro.c: Likewise.
+ * elf32-v850.c: Likewise.
+ * elf32-vax.c: Likewise.
+ * elf32-visium.c: Likewise.
+ * elf32-wasm32.c: Likewise.
+ * elf32-xgate.c: Likewise.
+ * elf32-xtensa.c: Likewise.
+ * elf64-alpha.c: Likewise.
+ * elf64-gen.c: Likewise.
+ * elf64-hppa.c: Likewise.
+ * elf64-ia64-vms.c: Likewise.
+ * elf64-mmix.c: Likewise.
+ * elf64-ppc.c: Likewise.
+ * elf64-s390.c: Likewise.
+ * elf64-sh64.c: Likewise.
+ * elf64-sparc.c: Likewise.
+ * elf64-x86-64.c: Likewise.
+ * elfcode.h: Likewise.
+ * elfcore.h: Likewise.
+ * elflink.c: Likewise.
+ * elfnn-aarch64.c: Likewise.
+ * elfnn-ia64.c: Likewise.
+ * elfnn-riscv.c: Likewise.
+ * elfxx-mips.c: Likewise.
+ * elfxx-sparc.c: Likewise.
+ * elfxx-tilegx.c: Likewise.
+ * elfxx-x86.c: Likewise.
+ * hpux-core.c: Likewise.
+ * ieee.c: Likewise.
+ * ihex.c: Likewise.
+ * libbfd.c: Likewise.
+ * linker.c: Likewise.
+ * mach-o.c: Likewise.
+ * merge.c: Likewise.
+ * mmo.c: Likewise.
+ * oasys.c: Likewise.
+ * pdp11.c: Likewise.
+ * pe-mips.c: Likewise.
+ * peXXigen.c: Likewise.
+ * peicode.h: Likewise.
+ * reloc.c: Likewise.
+ * rs6000-core.c: Likewise.
+ * srec.c: Likewise.
+ * stabs.c: Likewise.
+ * vms-alpha.c: Likewise.
+ * xcofflink.c: Likewise.
+
2018-02-19 Alan Modra <amodra@gmail.com>
PR 22845
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Unknown section type in a.out.adobe file: %x\n"),
+ (_("%pB: Unknown section type in a.out.adobe file: %x\n"),
abfd, ext->e_type[0]);
goto no_more_sections;
}
if (r_type > 2)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Invalid relocation type exported: %d"),
+ _bfd_error_handler (_("%pB: Invalid relocation type exported: %d"),
abfd, r_type);
bfd_set_error (bfd_error_wrong_format);
if (r_type > 2)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Invalid relocation type imported: %d"),
+ _bfd_error_handler (_("%pB: Invalid relocation type imported: %d"),
abfd, r_type);
bfd_set_error (bfd_error_wrong_format);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Bad relocation record imported: %d"), abfd, r_index);
+ (_("%pB: Bad relocation record imported: %d"), abfd, r_index);
bfd_set_error (bfd_error_wrong_format);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section `%A' in a.out object file format"),
+ (_("%pB: can not represent section `%pA' in a.out object file format"),
abfd, section);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
file. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section for symbol `%s' in a.out "
+ (_("%pB: can not represent section for symbol `%s' in a.out "
"object file format"),
abfd,
cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*"));
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section `%A' in a.out object file format"),
+ (_("%pB: can not represent section `%pA' in a.out object file format"),
abfd, sec);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
{
bfd_set_error (bfd_error_invalid_operation);
_bfd_error_handler (_("\
-%B: attempt to write out unknown reloc type"), abfd);
+%pB: attempt to write out unknown reloc type"), abfd);
return FALSE;
}
MY_swap_ext_reloc_out (abfd, *generic,
{
bfd_set_error (bfd_error_invalid_operation);
_bfd_error_handler (_("\
-%B: attempt to write out unknown reloc type"), abfd);
+%pB: attempt to write out unknown reloc type"), abfd);
return FALSE;
}
MY_swap_std_reloc_out (abfd, *generic,
if (howto == NULL)
{
(*flaginfo->info->callbacks->einfo)
- (_("%P: %B: unexpected relocation type\n"), input_bfd);
+ (_("%P: %pB: unexpected relocation type\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (r_type >= TABLE_SIZE (howto_table_ext))
{
(*flaginfo->info->callbacks->einfo)
- (_("%P: %B: unexpected relocation type\n"), input_bfd);
+ (_("%P: %pB: unexpected relocation type\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
by the reloc size. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocatable link from %s to %s not supported"),
+ (_("%pB: relocatable link from %s to %s not supported"),
abfd, sub->xvec->name, abfd->xvec->name);
bfd_set_error (bfd_error_invalid_operation);
goto error_return;
+ (syms[src_count]->name[2] == '_'),
"__gnu_lto_slim") == 0)
_bfd_error_handler
- (_("%B: plugin needed to handle lto object"),
+ (_("%pB: plugin needed to handle lto object"),
current);
namelen = strlen (syms[src_count]->name);
amt = sizeof (char *);
};
/* This macro and _bfd_doprnt taken from libiberty _doprnt.c, tidied a
- little and extended to handle '%A', '%B' and positional parameters.
+ little and extended to handle '%pA', '%pB' and positional parameters.
'L' as a modifer for integer formats is used for bfd_vma and
bfd_size_type args, which vary in size depending on BFD
configuration. */
PRINT_TYPE (char *, p);
break;
case 'p':
- PRINT_TYPE (void *, p);
- break;
- case 'A':
- {
- asection *sec;
- bfd *abfd;
- const char *group = NULL;
- struct coff_comdat_info *ci;
-
- sec = (asection *) args[arg_no].p;
- if (sec == NULL)
- /* Invoking %A with a null section pointer is an
- internal error. */
- abort ();
- abfd = sec->owner;
- if (abfd != NULL
- && bfd_get_flavour (abfd) == bfd_target_elf_flavour
- && elf_next_in_group (sec) != NULL
- && (sec->flags & SEC_GROUP) == 0)
- group = elf_group_name (sec);
- else if (abfd != NULL
- && bfd_get_flavour (abfd) == bfd_target_coff_flavour
- && (ci = bfd_coff_get_comdat_section (sec->owner,
- sec)) != NULL)
- group = ci->name;
- if (group != NULL)
- result = fprintf (stream, "%s[%s]", sec->name, group);
- else
- result = fprintf (stream, "%s", sec->name);
- }
- break;
- case 'B':
- {
- bfd *abfd;
-
- abfd = (bfd *) args[arg_no].p;
- if (abfd == NULL)
- /* Invoking %B with a null bfd pointer is an
- internal error. */
- abort ();
- else if (abfd->my_archive
- && !bfd_is_thin_archive (abfd->my_archive))
- result = fprintf (stream, "%s(%s)",
- abfd->my_archive->filename, abfd->filename);
- else
- result = fprintf (stream, "%s", abfd->filename);
- }
+ if (*ptr == 'A')
+ {
+ asection *sec;
+ bfd *abfd;
+ const char *group = NULL;
+ struct coff_comdat_info *ci;
+
+ ptr++;
+ sec = (asection *) args[arg_no].p;
+ if (sec == NULL)
+ /* Invoking %pA with a null section pointer is an
+ internal error. */
+ abort ();
+ abfd = sec->owner;
+ if (abfd != NULL
+ && bfd_get_flavour (abfd) == bfd_target_elf_flavour
+ && elf_next_in_group (sec) != NULL
+ && (sec->flags & SEC_GROUP) == 0)
+ group = elf_group_name (sec);
+ else if (abfd != NULL
+ && bfd_get_flavour (abfd) == bfd_target_coff_flavour
+ && (ci = bfd_coff_get_comdat_section (sec->owner,
+ sec)) != NULL)
+ group = ci->name;
+ if (group != NULL)
+ result = fprintf (stream, "%s[%s]", sec->name, group);
+ else
+ result = fprintf (stream, "%s", sec->name);
+ }
+ else if (*ptr == 'B')
+ {
+ bfd *abfd;
+
+ ptr++;
+ abfd = (bfd *) args[arg_no].p;
+ if (abfd == NULL)
+ /* Invoking %pB with a null bfd pointer is an
+ internal error. */
+ abort ();
+ else if (abfd->my_archive
+ && !bfd_is_thin_archive (abfd->my_archive))
+ result = fprintf (stream, "%s(%s)",
+ abfd->my_archive->filename,
+ abfd->filename);
+ else
+ result = fprintf (stream, "%s", abfd->filename);
+ }
+ else
+ PRINT_TYPE (void *, p);
break;
default:
abort();
}
break;
case 's':
+ arg_type = Ptr;
+ break;
case 'p':
- case 'A':
- case 'B':
+ if (*ptr == 'A' || *ptr == 'B')
+ ptr++;
arg_type = Ptr;
break;
default:
/* This is the default routine to handle BFD error messages.
Like fprintf (stderr, ...), but also handles some extra format specifiers.
- %A section name from section. For group components, prints group name too.
- %B file name from bfd. For archive components, prints archive too.
+ %pA section name from section. For group components, prints group name too.
+ %pB file name from bfd. For archive components, prints archive too.
Beware: Only supports a maximum of 9 format arguments. */
if (s->filepos < 0)
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: writing section `%A' at huge (ie negative) "
+ (_("warning: writing section `%pA' at huge (ie negative) "
"file offset"),
s);
}
return (FILE *) abfd->iostream;
/* xgettext:c-format */
- _bfd_error_handler (_("reopening %B: %s\n"),
+ _bfd_error_handler (_("reopening %pB: %s\n"),
orig_bfd, bfd_errmsg (bfd_get_error ()));
return NULL;
}
if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f))
_bfd_error_handler
- (_("%B: Cannot handle compressed Alpha binaries.\n"
+ (_("%pB: Cannot handle compressed Alpha binaries.\n"
" Use compiler flags, or objZ, to generate uncompressed binaries."),
abfd);
{
/* xgettext:c-format */
_bfd_error_handler
- (_("%B: unknown/unsupported relocation type %d"),
+ (_("%pB: unknown/unsupported relocation type %d"),
abfd, intern->r_type);
bfd_set_error (bfd_error_bad_value);
rptr->addend = 0;
{
case ALPHA_R_GPRELHIGH:
_bfd_error_handler
- (_("%B: unsupported relocation: ALPHA_R_GPRELHIGH"),
+ (_("%pB: unsupported relocation: ALPHA_R_GPRELHIGH"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
continue;
case ALPHA_R_GPRELLOW:
_bfd_error_handler
- (_("%B: unsupported relocation: ALPHA_R_GPRELLOW"),
+ (_("%pB: unsupported relocation: ALPHA_R_GPRELLOW"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
continue;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown relocation type %d"),
+ (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
continue;
if (myh == NULL)
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unable to find THUMB glue '%s' for `%s'"),
+ _bfd_error_handler (_("%pB: unable to find THUMB glue '%s' for `%s'"),
input_bfd, tmp_name, name);
free (tmp_name);
if (myh == NULL)
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unable to find ARM glue '%s' for `%s'"),
+ _bfd_error_handler (_("%pB: unable to find ARM glue '%s' for `%s'"),
input_bfd, tmp_name, name);
free (tmp_name);
&& ! INTERWORK_FLAG (h_sec->owner))
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: arm call to thumb"),
+ (_("%pB(%s): warning: interworking not enabled.\n"
+ " first occurrence: %pB: arm call to thumb"),
h_sec->owner, name, input_bfd);
--my_offset;
&& ! globals->support_old_code)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: thumb call to arm\n"
+ (_("%pB(%s): warning: interworking not enabled.\n"
+ " first occurrence: %pB: thumb call to arm\n"
" consider relinking with --support-old-code enabled"),
h_sec->owner, name, input_bfd);
case bfd_reloc_outofrange:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: bad reloc address %#Lx in section `%A'"),
+ (_("%pB: bad reloc address %#Lx in section `%pA'"),
input_bfd, rel->r_vaddr, input_section);
return FALSE;
case bfd_reloc_overflow:
if (symndx >= obj_conv_table_size (abfd))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: illegal symbol index in reloc: %ld"),
+ _bfd_error_handler (_("%pB: illegal symbol index in reloc: %ld"),
abfd, symndx);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("error: %B is compiled for APCS-%d, whereas %B is compiled for APCS-%d"),
+ (_("error: %pB is compiled for APCS-%d, whereas %pB is compiled for APCS-%d"),
ibfd, APCS_26_FLAG (ibfd) ? 26 : 32,
obfd, APCS_26_FLAG (obfd) ? 26 : 32
);
if (APCS_FLOAT_FLAG (ibfd))
/* xgettext: c-format */
_bfd_error_handler (_("\
-error: %B passes floats in float registers, whereas %B passes them in integer registers"),
+error: %pB passes floats in float registers, whereas %pB passes them in integer registers"),
ibfd, obfd);
else
/* xgettext: c-format */
_bfd_error_handler (_("\
-error: %B passes floats in integer registers, whereas %B passes them in float registers"),
+error: %pB passes floats in integer registers, whereas %pB passes them in float registers"),
ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
if (PIC_FLAG (ibfd))
/* xgettext: c-format */
_bfd_error_handler (_("\
-error: %B is compiled as position independent code, whereas target %B is absolute position"),
+error: %pB is compiled as position independent code, whereas target %pB is absolute position"),
ibfd, obfd);
else
/* xgettext: c-format */
_bfd_error_handler (_("\
-error: %B is compiled as absolute position code, whereas target %B is position independent"),
+error: %pB is compiled as absolute position code, whereas target %pB is position independent"),
ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
if (INTERWORK_FLAG (ibfd))
/* xgettext: c-format */
_bfd_error_handler (_("\
-Warning: %B supports interworking, whereas %B does not"),
+Warning: %pB supports interworking, whereas %pB does not"),
ibfd, obfd);
else
/* xgettext: c-format */
_bfd_error_handler (_("\
-Warning: %B does not support interworking, whereas %B does"),
+Warning: %pB does not support interworking, whereas %pB does"),
ibfd, obfd);
}
}
if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
{
if (flag)
- _bfd_error_handler (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
+ _bfd_error_handler (_("Warning: Not setting interworking flag of %pB since it has already been specified as non-interworking"),
abfd);
else
- _bfd_error_handler (_("Warning: Clearing the interworking flag of %B due to outside request"),
+ _bfd_error_handler (_("Warning: Clearing the interworking flag of %pB due to outside request"),
abfd);
flag = 0;
}
{
/* xgettext:c-format */
_bfd_error_handler (_("\
-Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
+Warning: Clearing the interworking flag of %pB because non-interworking code in %pB has been linked with it"),
dest, src);
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: warning: illegal symbol index %ld in relocs"),
+ (_("%pB: warning: illegal symbol index %ld in relocs"),
abfd, dst->r_symndx);
cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
ptr = NULL;
BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
/* xgettext: c-format */
- _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
+ _bfd_error_handler (_("%pB: Relocation %s (%d) is not currently supported.\n"),
abfd,
reloc_entry->howto->name,
reloc_entry->howto->type);
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: compiled for a %s system and target is %s.\n"),
+ (_("%pB: compiled for a %s system and target is %s.\n"),
input_bfd,
bfd_big_endian (input_bfd) ? _("big endian") : _("little endian"),
bfd_big_endian (output_bfd) ? _("big endian") : _("little endian"));
{
default:
/* xgettext: c-format */
- _bfd_error_handler (_("%B: unsupported relocation type 0x%02x"),
+ _bfd_error_handler (_("%pB: unsupported relocation type 0x%02x"),
input_bfd, r_type);
bfd_set_error (bfd_error_bad_value);
return FALSE;
case IMAGE_REL_MCORE_ABSOLUTE:
_bfd_error_handler
/* xgettext: c-format */
- (_("Warning: unsupported reloc %s <file %B, section %A>\n"
+ (_("Warning: unsupported reloc %s <file %pB, section %pA>\n"
"sym %ld (%s), r_vaddr %Ld (%#Lx)"),
howto->name, input_bfd, input_section,
rel->r_symndx, my_name, rel->r_vaddr, rel->r_vaddr);
default:
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
+ (_("%pB: unsupported relocation type 0x%02x"), input_bfd, r_type);
bfd_set_error (bfd_error_bad_value);
return FALSE;
case IMAGE_REL_PPC_TOCREL16:
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: Relocation for %s of %#Lx exceeds "
+ (_("%pB: Relocation for %s of %#Lx exceeds "
"Toc size limit"),
input_bfd, name, our_toc_offset);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: Relocation exceeds allocated TOC (%#Lx)"),
+ (_("%pB: Relocation exceeds allocated TOC (%#Lx)"),
input_bfd, toc_section->size);
bfd_set_error (bfd_error_bad_value);
return FALSE;
_bfd_error_handler
/* xgettext: c-format */
- (_("Warning: unsupported reloc %s <file %B, section %A>\n"
+ (_("Warning: unsupported reloc %s <file %pB, section %pA>\n"
"sym %ld (%s), r_vaddr %Ld (%#Lx)"),
howto->name, input_bfd, input_section,
rel->r_symndx, my_name, rel->r_vaddr, rel->r_vaddr);
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
+ (_("%pB: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: unsupported relocation type 0x%02x"),
+ (_("%pB: unsupported relocation type 0x%02x"),
input_bfd, (unsigned int) rel->r_type);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: TOC reloc at %#Lx to symbol `%s' with no TOC entry"),
+ (_("%pB: TOC reloc at %#Lx to symbol `%s' with no TOC entry"),
input_bfd, rel->r_vaddr, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: symbol `%s' has unrecognized smclas %d"),
+ (_("%pB: symbol `%s' has unrecognized smclas %d"),
abfd, symbol_name, aux->x_csect.x_smclas);
bfd_set_error (bfd_error_bad_value);
}
if (laddr >= sec->size)
{
/* xgettext: c-format */
- _bfd_error_handler (_("%B: %#Lx: warning: bad R_SH_USES offset"),
+ _bfd_error_handler (_("%pB: %#Lx: warning: bad R_SH_USES offset"),
abfd, irel->r_vaddr);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: warning: R_SH_USES points to unrecognized insn %#x"),
+ (_("%pB: %#Lx: warning: R_SH_USES points to unrecognized insn %#x"),
abfd, irel->r_vaddr, insn);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: warning: bad R_SH_USES load offset"),
+ (_("%pB: %#Lx: warning: bad R_SH_USES load offset"),
abfd, irel->r_vaddr);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: warning: could not find expected reloc"),
+ (_("%pB: %#Lx: warning: could not find expected reloc"),
abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: warning: symbol in unexpected section"),
+ (_("%pB: %#Lx: warning: symbol in unexpected section"),
abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: warning: could not find expected COUNT reloc"),
+ (_("%pB: %#Lx: warning: could not find expected COUNT reloc"),
abfd, paddr);
continue;
}
if (irelcount->r_offset == 0)
{
/* xgettext: c-format */
- _bfd_error_handler (_("%B: %#Lx: warning: bad count"),
+ _bfd_error_handler (_("%pB: %#Lx: warning: bad count"),
abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
+ (_("%pB: %#Lx: fatal: reloc overflow while relaxing"),
abfd, irel->r_vaddr);
bfd_set_error (bfd_error_bad_value);
return FALSE;
|| obj_raw_syments (abfd) != NULL)
{
_bfd_error_handler
- (_("%B: fatal: generic symbols retrieved before relaxing"), abfd);
+ (_("%pB: fatal: generic symbols retrieved before relaxing"), abfd);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
+ (_("%pB: %#Lx: fatal: reloc overflow while relaxing"),
abfd, irel->r_vaddr);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: illegal symbol index %ld in relocs"),
+ (_("%pB: illegal symbol index %ld in relocs"),
input_bfd, symndx);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: warning: illegal symbol index %ld in relocs"),
+ (_("%pB: warning: illegal symbol index %ld in relocs"),
abfd, reloc->r_symndx);
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
ptr = NULL;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: warning: illegal symbol index %ld in relocs"),
+ (_("%pB: warning: illegal symbol index %ld in relocs"),
abfd, reloc->r_symndx);
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
ptr = NULL;
case bfd_reloc_outofrange:
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: bad reloc address %#Lx in section `%A'"),
+ (_("%pB: bad reloc address %#Lx in section `%pA'"),
input_bfd, rel->r_vaddr, input_section);
return FALSE;
case bfd_reloc_overflow:
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: symbol `%s' has unrecognized smclas %d"),
+ (_("%pB: symbol `%s' has unrecognized smclas %d"),
abfd, symbol_name, aux->x_csect.x_smclas);
bfd_set_error (bfd_error_bad_value);
}
/* PR 17512 file: 078-11867-0.004 */
if (symname == NULL)
{
- _bfd_error_handler (_("%B: unable to load COMDAT section name"),
+ _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
abfd);
break;
}
{
/* Malformed input files can trigger this test.
cf PR 21781. */
- _bfd_error_handler (_("%B: error: unexpected symbol '%s' in COMDAT section"),
+ _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
abfd, symname);
goto breakloop;
}
if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
/* xgettext:c-format */
- _bfd_error_handler (_("%B: warning: COMDAT symbol '%s'"
+ _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
" does not match section name '%s'"),
abfd, symname, name);
if (esym + bfd_coff_symesz (abfd) >= esymend)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: warning: No symbol for"
+ _bfd_error_handler (_("%pB: warning: No symbol for"
" section '%s' found"),
abfd, symname);
break;
variable as this will allow some .sys files generate by
other toolchains to be processed. See bugzilla issue 196. */
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Warning: Ignoring section flag"
+ _bfd_error_handler (_("%pB: Warning: Ignoring section flag"
" IMAGE_SCN_MEM_NOT_PAGED in section %s"),
abfd, name);
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B (%s): Section flag %s (%#lx) ignored"),
+ (_("%pB (%s): Section flag %s (%#lx) ignored"),
abfd, name, unhandled, flag);
result = FALSE;
}
}
else if (hdr->s_nreloc == 0xffff)
_bfd_error_handler
- (_("%B: warning: claims to have 0xffff relocs, without overflow"),
+ (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
abfd);
}
#undef ALIGN_SET
{
bfd_set_error (bfd_error_bad_value);
/* xgettext:c-format */
- _bfd_error_handler (_("%B: reloc against a non-existent"
+ _bfd_error_handler (_("%pB: reloc against a non-existent"
" symbol index: %ld"),
abfd, n.r_symndx);
return FALSE;
bfd_set_error (bfd_error_file_too_big);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: page size is too large (0x%x)"), abfd, page_size);
+ (_("%pB: page size is too large (0x%x)"), abfd, page_size);
return FALSE;
}
}
bfd_set_error (bfd_error_file_too_big);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: too many sections (%d)"), abfd, target_index);
+ (_("%pB: too many sections (%d)"), abfd, target_index);
return FALSE;
}
bfd_set_error (bfd_error_file_too_big);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: section %A: string table overflow at offset %ld"),
+ (_("%pB: section %pA: string table overflow at offset %ld"),
abfd, current, (unsigned long) string_size);
return FALSE;
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%s section %s: alignment 2**%u not representable"),
+ (_("%pB:%s section %s: alignment 2**%u not representable"),
abfd, warn ? " warning:" : "", current->name,
current->alignment_power);
if (!warn)
if (asect->lineno_count > asect->size)
{
_bfd_error_handler
- (_("%B: warning: line number count (%#lx) exceeds section size (%#lx)"),
+ (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
abfd, (unsigned long) asect->lineno_count, (unsigned long) asect->size);
return FALSE;
}
if (native_lineno == NULL)
{
_bfd_error_handler
- (_("%B: warning: line number table read failed"), abfd);
+ (_("%pB: warning: line number table read failed"), abfd);
bfd_release (abfd, lineno_cache);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
+ (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, symndx, counter);
cache_ptr->line_number = -1;
ret = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
+ (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, symndx, counter);
cache_ptr->line_number = -1;
ret = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: illegal symbol in line number entry %d"),
+ (_("%pB: warning: illegal symbol in line number entry %d"),
abfd, counter);
cache_ptr->line_number = -1;
ret = FALSE;
if (sym->lineno != NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: duplicate line number information for `%s'"),
+ (_("%pB: warning: duplicate line number information for `%s'"),
abfd, bfd_asymbol_name (&sym->symbol));
sym->lineno = cache_ptr;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
+ (_("%pB: Unrecognized storage class %d for %s symbol `%s'"),
abfd, src->u.syment.n_sclass,
dst->symbol.section->name, dst->symbol.name);
ret = FALSE;
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: %B: local symbol `%s' has no section"),
+ (_("warning: %pB: local symbol `%s' has no section"),
abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: illegal symbol index %ld in relocs"),
+ (_("%pB: warning: illegal symbol index %ld in relocs"),
abfd, dst.r_symndx);
cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
ptr = NULL;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: illegal relocation type %d at address %#Lx"),
+ (_("%pB: illegal relocation type %d at address %#Lx"),
abfd, dst.r_type, dst.r_vaddr);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: unable to initialize compress status for section %s"),
+ (_("%pB: unable to initialize compress status for section %s"),
abfd, name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: unable to initialize decompress status for section %s"),
+ (_("%pB: unable to initialize decompress status for section %s"),
abfd, name);
return FALSE;
}
&& size > bfd_get_file_size (abfd)))
{
- _bfd_error_handler (_("%B: corrupt symbol count: %#Lx"),
+ _bfd_error_handler (_("%pB: corrupt symbol count: %#Lx"),
abfd, obj_raw_syment_count (abfd));
return FALSE;
}
if (syms == NULL)
{
/* PR 21013: Provide an error message when the alloc fails. */
- _bfd_error_handler (_("%B: not enough memory to allocate space for %#Lx symbols of size %#Lx"),
+ _bfd_error_handler (_("%pB: not enough memory to allocate space for %#Lx symbols of size %#Lx"),
abfd, obj_raw_syment_count (abfd), symesz);
return FALSE;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: bad string table size %Lu"), abfd, strsize);
+ (_("%pB: bad string table size %Lu"), abfd, strsize);
bfd_set_error (bfd_error_bad_value);
return NULL;
}
if (info->print_gc_sections && o->size != 0)
/* xgettext: c-format */
- _bfd_error_handler (_("Removing unused section '%A' in file '%B'"),
+ _bfd_error_handler (_("Removing unused section '%pA' in file '%pB'"),
o, sub);
#if 0
_bfd_error_handler
/* xgettext: c-format */
(_("Warning: type of symbol `%s' changed"
- " from %d to %d in %B"),
+ " from %d to %d in %pB"),
name, (*sym_hash)->type, sym.n_type, abfd);
/* We don't want to change from a meaningful
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: relocs in section `%A', but it has no contents"),
+ (_("%pB: relocs in section `%pA', but it has no contents"),
input_bfd, o);
bfd_set_error (bfd_error_no_contents);
return FALSE;
if (ps->flags & SEC_EXCLUDE)
(*flaginfo->info->callbacks->einfo)
/* xgettext: c-format */
- (_("%X`%s' referenced in section `%A' of %B: "
- "defined in discarded section `%A' of %B\n"),
+ (_("%X`%s' referenced in section `%pA' of %pB: "
+ "defined in discarded section `%pA' of %pB\n"),
h->root.root.string, o, input_bfd, ps, ps->owner);
}
|| bfd_link_relocatable (flaginfo->info)))
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: %A: reloc overflow: %#x > 0xffff"),
+ (_("%pB: %pA: reloc overflow: %#x > 0xffff"),
output_bfd, sec, sec->reloc_count);
if (sec->lineno_count > 0xffff
|| bfd_link_relocatable (flaginfo->info)))
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: warning: %A: line number overflow: %#x > 0xffff"),
+ (_("%pB: warning: %pA: line number overflow: %#x > 0xffff"),
output_bfd, sec, sec->lineno_count);
auxp->x_scn.x_nreloc = sec->reloc_count;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: illegal symbol index %ld in relocs"), input_bfd, symndx);
+ (_("%pB: illegal symbol index %ld in relocs"), input_bfd, symndx);
return FALSE;
}
else
case bfd_reloc_outofrange:
_bfd_error_handler
/* xgettext: c-format */
- (_("%B: bad reloc address %#Lx in section `%A'"),
+ (_("%pB: bad reloc address %#Lx in section `%pA'"),
input_bfd, rel->r_vaddr, input_section);
return FALSE;
case bfd_reloc_overflow:
buf[sizeof (scnhdr_int->s_name)] = '\0';
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: %s: line number overflow: 0x%lx > 0xffff"),
+ (_("%pB: warning: %s: line number overflow: 0x%lx > 0xffff"),
abfd, buf, scnhdr_int->s_nlnno);
PUT_SCNHDR_NLNNO (abfd, 0xffff, scnhdr_ext->s_nlnno);
}
memcpy (buf, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
buf[sizeof (scnhdr_int->s_name)] = '\0';
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %s: reloc overflow: 0x%lx > 0xffff"),
+ _bfd_error_handler (_("%pB: %s: reloc overflow: 0x%lx > 0xffff"),
abfd, buf, scnhdr_int->s_nreloc);
bfd_set_error (bfd_error_file_truncated);
PUT_SCNHDR_NRELOC (abfd, 0xffff, scnhdr_ext->s_nreloc);
if (bfd_get_error () == bfd_error_no_memory)
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B(%A) is too large (%#Lx bytes)"),
+ (_("error: %pB(%pA) is too large (%#Lx bytes)"),
abfd, sec, sz);
return FALSE;
}
{
/* xgettext: c-format */
_bfd_error_handler (_("\
-error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
+error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
{
/* xgettext: c-format */
_bfd_error_handler (_("\
-error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
+error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
obfd, ibfd);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
{
_bfd_error_handler
/* xgettext: c-format */
- (_("warning: unable to update contents of %s section in %B"),
+ (_("warning: unable to update contents of %s section in %pB"),
note_section, abfd);
goto FAIL;
}
bfd_get_symcount (abfd) = internal_ptr - internal;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
+ (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"),
abfd, ecoff_data (abfd)->debug_info.symbolic_header.isymMax,
ecoff_data (abfd)->debug_info.symbolic_header.ifdMax);
}
len -= section_len;
if (section_len <= 4)
{
- _bfd_error_handler (_("%B: error: attribute section length too small: %ld"),
+ _bfd_error_handler (_("%pB: error: attribute section length too small: %ld"),
abfd, section_len);
break;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B: Object has vendor-specific contents that "
+ (_("error: %pB: Object has vendor-specific contents that "
"must be processed by the '%s' toolchain"),
ibfd, in_attr->s);
return FALSE;
|| (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
{
/* xgettext:c-format */
- _bfd_error_handler (_("error: %B: Object tag '%d, %s' is "
+ _bfd_error_handler (_("error: %pB: Object tag '%d, %s' is "
"incompatible with tag '%d, %s'"),
ibfd,
in_attr->i, in_attr->s ? in_attr->s : "",
{
(*info->callbacks->minfo)
/* xgettext:c-format */
- (_("discarding zero address range FDE in %B(%A).\n"),
+ (_("discarding zero address range FDE in %pB(%pA).\n"),
abfd, sec);
this_inf->u.fde.cie_inf = NULL;
}
free_no_table:
(*info->callbacks->einfo)
/* xgettext:c-format */
- (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
+ (_("%P: error in %pB(%pA); no .eh_frame_hdr table will be created.\n"),
abfd, sec);
hdr_info->u.dwarf.table = FALSE;
if (sec_info)
{
(*info->callbacks->einfo)
/* xgettext:c-format */
- (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
+ (_("%P: FDE encoding in %pB(%pA) prevents .eh_frame_hdr"
" table being created.\n"), abfd, sec);
num_warnings_issued ++;
}
if (addr <= last_addr)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %A not in order"), sec->owner, sec);
+ _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec);
return FALSE;
}
if (addr & 1)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %A invalid input section size"),
+ _bfd_error_handler (_("%pB: %pA invalid input section size"),
sec->owner, sec);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (last_addr >= addr + sec->rawsize)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %A points past end of text section"),
+ _bfd_error_handler (_("%pB: %pA points past end of text section"),
sec->owner, sec);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (sec->output_section != osec)
{
_bfd_error_handler
- (_("Invalid output section for .eh_frame_entry: %A"),
+ (_("Invalid output section for .eh_frame_entry: %pA"),
sec->output_section);
return FALSE;
}
if (i != 0)
{
_bfd_error_handler
- (_("Invalid contents in %A section"), osec);
+ (_("Invalid contents in %pA section"), osec);
return FALSE;
}
info->callbacks->einfo
/* xgettext:c-format */
(_("%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer "
- "equality in `%B' can not be used when making an "
+ "equality in `%pB' can not be used when making an "
"executable; recompile with -fPIE and relink with -pie\n"),
h->root.root.string,
h->root.u.def.section->owner);
if (r_type >= R_MN10300_MAX)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised MN10300 reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised MN10300 reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MN10300_NONE;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Unsupported transition from %s to %s"),
+ (_("%pB: Unsupported transition from %s to %s"),
input_bfd,
elf_mn10300_howto_table[r_type].name,
elf_mn10300_howto_table[tls_r_type].name);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %s' accessed both as normal and thread local symbol"),
+ (_("%pB: %s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
" library (did you forget -fpic?)");
else if (r_type == R_MN10300_GOT32)
/* xgettext:c-format */
- msg = _("%B: taking the address of protected function"
+ msg = _("%pB: taking the address of protected function"
" '%s' cannot be done when making a shared library");
else
msg = _("internal error: suspicious relocation type used"
p = (elf_property_list *) bfd_alloc (abfd, sizeof (*p));
if (p == NULL)
{
- _bfd_error_handler (_("%B: out of memory in _bfd_elf_get_property"),
+ _bfd_error_handler (_("%pB: out of memory in _bfd_elf_get_property"),
abfd);
_exit (EXIT_FAILURE);
}
{
bad_size:
_bfd_error_handler
- (_("warning: %B: corrupt GNU_PROPERTY_TYPE (%ld) size: %#lx"),
+ (_("warning: %pB: corrupt GNU_PROPERTY_TYPE (%ld) size: %#lx"),
abfd, note->type, note->descsz);
return FALSE;
}
if (datasz > (size_t) (ptr_end - ptr))
{
_bfd_error_handler
- (_("warning: %B: corrupt GNU_PROPERTY_TYPE (%ld) type (0x%x) datasz: 0x%x"),
+ (_("warning: %pB: corrupt GNU_PROPERTY_TYPE (%ld) type (0x%x) datasz: 0x%x"),
abfd, note->type, type, datasz);
/* Clear all properties. */
elf_properties (abfd) = NULL;
if (datasz != align_size)
{
_bfd_error_handler
- (_("warning: %B: corrupt stack size: 0x%x"),
+ (_("warning: %pB: corrupt stack size: 0x%x"),
abfd, datasz);
/* Clear all properties. */
elf_properties (abfd) = NULL;
if (datasz != 0)
{
_bfd_error_handler
- (_("warning: %B: corrupt no copy on protected size: 0x%x"),
+ (_("warning: %pB: corrupt no copy on protected size: 0x%x"),
abfd, datasz);
/* Clear all properties. */
elf_properties (abfd) = NULL;
}
_bfd_error_handler
- (_("warning: %B: unsupported GNU_PROPERTY_TYPE (%ld) type: 0x%x"),
+ (_("warning: %pB: unsupported GNU_PROPERTY_TYPE (%ld) type: 0x%x"),
abfd, note->type, type);
next:
if (in_attr->i > 2)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses unknown vector ABI %d"), ibfd,
+ (_("Warning: %pB uses unknown vector ABI %d"), ibfd,
in_attr->i);
else if (out_attr->i > 2)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses unknown vector ABI %d"), obfd,
+ (_("Warning: %pB uses unknown vector ABI %d"), obfd,
out_attr->i);
else if (in_attr->i != out_attr->i)
{
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses vector %s ABI, %B uses %s ABI"),
+ (_("Warning: %pB uses vector %s ABI, %pB uses %s ABI"),
ibfd, abi_str[in_attr->i], obfd, abi_str[out_attr->i]);
}
if (in_attr->i > out_attr->i)
{
/* PR 17512: file: f057ec89. */
/* xgettext:c-format */
- _bfd_error_handler (_("%B: attempt to load strings from"
+ _bfd_error_handler (_("%pB: attempt to load strings from"
" a non-string section (number %d)"),
abfd, shindex);
return NULL;
unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid string offset %u >= %Lu for section `%s'"),
+ (_("%pB: invalid string offset %u >= %Lu for section `%s'"),
abfd, strindex, hdr->sh_size,
(shindex == shstrndx && strindex == hdr->sh_name
? ".shstrtab"
{
symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
/* xgettext:c-format */
- _bfd_error_handler (_("%B symbol number %lu references"
+ _bfd_error_handler (_("%pB symbol number %lu references"
" nonexistent SHT_SYMTAB_SHNDX section"),
ibfd, (unsigned long) symoffset);
if (alloc_intsym != NULL)
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: corrupt size field in group section"
+ (_("%pB: corrupt size field in group section"
" header: %#Lx"), abfd, shdr->sh_size);
bfd_set_error (bfd_error_bad_value);
-- num_group;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid size field in group section"
+ (_("%pB: invalid size field in group section"
" header: %#Lx"), abfd, shdr->sh_size);
bfd_set_error (bfd_error_bad_value);
-- num_group;
if (idx >= shnum)
{
_bfd_error_handler
- (_("%B: invalid SHT_GROUP entry"), abfd);
+ (_("%pB: 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);
+ (_("%pB: no valid group sections found"), abfd);
bfd_set_error (bfd_error_bad_value);
}
}
{
/* See PR 21957 for a reproducer. */
/* xgettext:c-format */
- _bfd_error_handler (_("%B: group section '%A' has no contents"),
+ _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
abfd, shdr->bfd_section);
elf_tdata (abfd)->group_sect_ptr[i] = NULL;
bfd_set_error (bfd_error_bad_value);
if (elf_group_name (newsect) == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: no group info for section '%A'"),
+ _bfd_error_handler (_("%pB: no group info for section '%pA'"),
abfd, newsect);
return FALSE;
}
if (bed->link_order_error_handler)
bed->link_order_error_handler
/* xgettext:c-format */
- (_("%B: warning: sh_link not set for section `%A'"),
+ (_("%pB: warning: sh_link not set for section `%pA'"),
abfd, s);
}
else
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: sh_link [%d] in section `%A' is incorrect"),
+ (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
s->owner, elfsec, s);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
+ (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
abfd, elf_section_data (s)->this_idx);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: section group entry number %u is corrupt"),
+ (_("%pB: section group entry number %u is corrupt"),
abfd, i);
result = FALSE;
continue;
/* There are some unknown sections in the group. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown type [%#x] section `%s' in group [%A]"),
+ (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
abfd,
idx->shdr->sh_type,
bfd_elf_string_from_elf_section (abfd,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unable to initialize compress status for section %s"),
+ (_("%pB: unable to initialize compress status for section %s"),
abfd, name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unable to initialize decompress status for section %s"),
+ (_("%pB: unable to initialize decompress status for section %s"),
abfd, name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Invalid sh_link field (%d) in section number %d"),
+ (_("%pB: Invalid sh_link field (%d) in section number %d"),
ibfd, iheader->sh_link, secnum);
return FALSE;
}
if we could not find a match ? */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Failed to find link section for section %d"), obfd, secnum);
+ (_("%pB: Failed to find link section for section %d"), obfd, secnum);
}
if (iheader->sh_info)
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Failed to find info section for section %d"), obfd, secnum);
+ (_("%pB: Failed to find info section for section %d"), obfd, secnum);
}
return changed;
if (sections_being_created [shindex])
{
_bfd_error_handler
- (_("%B: warning: loop in section dependencies detected"), abfd);
+ (_("%pB: warning: loop in section dependencies detected"), abfd);
return FALSE;
}
sections_being_created [shindex] = TRUE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: multiple symbol tables detected"
+ (_("%pB: warning: multiple symbol tables detected"
" - ignoring the table in section %u"),
abfd, shindex);
goto success;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: multiple dynamic symbol tables detected"
+ (_("%pB: warning: multiple dynamic symbol tables detected"
" - ignoring the table in section %u"),
abfd, shindex);
goto success;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid link %u for reloc section %s (index %u)"),
+ (_("%pB: invalid link %u for reloc section %s (index %u)"),
abfd, hdr->sh_link, name, shindex);
ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
shindex);
for applications? */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown type [%#x] section `%s'"),
+ (_("%pB: unknown type [%#x] section `%s'"),
abfd, hdr->sh_type, name);
else
{
/* FIXME: We should handle this section. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown type [%#x] section `%s'"),
+ (_("%pB: unknown type [%#x] section `%s'"),
abfd, hdr->sh_type, name);
else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
{
be rejected with an error message. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown type [%#x] section `%s'"),
+ (_("%pB: unknown type [%#x] section `%s'"),
abfd, hdr->sh_type, name);
else
{
/* FIXME: We should handle this section. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown type [%#x] section `%s'"),
+ (_("%pB: unknown type [%#x] section `%s'"),
abfd, hdr->sh_type, name);
goto fail;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: error: Alignment power %d of section `%A' is too big"),
+ (_("%pB: error: Alignment power %d of section `%pA' is too big"),
abfd, asect->alignment_power, asect);
arg->failed = TRUE;
return;
non-bss input sections to bss output sections, or emit data
to a bss output section via a linker script. */
_bfd_error_handler
- (_("warning: section `%A' type changed to PROGBITS"), asect);
+ (_("warning: section `%pA' type changed to PROGBITS"), asect);
this_hdr->sh_type = sh_type;
}
if (section_number >= SHN_LORESERVE)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: too many sections: %u"),
+ _bfd_error_handler (_("%pB: too many sections: %u"),
abfd, section_number);
return FALSE;
}
asection *kept;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: sh_link of section `%A' points to"
- " discarded section `%A' of `%B'"),
+ (_("%pB: sh_link of section `%pA' points to"
+ " discarded section `%pA' of `%pB'"),
abfd, d->this_hdr.bfd_section,
s, s->owner);
/* Point to the kept section if it has the same
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: sh_link of section `%A' points to"
- " removed section `%A' of `%B'"),
+ (_("%pB: sh_link of section `%pA' points to"
+ " removed section `%pA' of `%pB'"),
abfd, d->this_hdr.bfd_section, s, s->owner);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (bed->link_order_error_handler)
bed->link_order_error_handler
/* xgettext:c-format */
- (_("%B: warning: sh_link not set for section `%A'"),
+ (_("%pB: warning: sh_link not set for section `%pA'"),
abfd, sec);
}
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: GNU_MBIN section `%A' has invalid sh_info field: %d"),
+ (_("%pB: GNU_MBIN section `%pA' has invalid sh_info field: %d"),
abfd, s, elf_section_data (s)->this_hdr.sh_info);
continue;
}
if ((s->flags & SEC_THREAD_LOCAL) == 0)
{
_bfd_error_handler
- (_("%B: TLS sections are not adjacent:"), abfd);
+ (_("%pB: TLS sections are not adjacent:"), abfd);
s = first_tls;
i = 0;
while (i < (unsigned int) tls_count)
{
if ((s->flags & SEC_THREAD_LOCAL) != 0)
{
- _bfd_error_handler (_(" TLS: %A"), s);
+ _bfd_error_handler (_(" TLS: %pA"), s);
i++;
}
else
- _bfd_error_handler (_(" non-TLS: %A"), s);
+ _bfd_error_handler (_(" non-TLS: %pA"), s);
s = s->next;
}
bfd_set_error (bfd_error_bad_value);
&& strcmp (m->sections[0]->name, ".dynamic") != 0)
{
_bfd_error_handler
- (_("%B: The first section in the PT_DYNAMIC segment"
+ (_("%pB: The first section in the PT_DYNAMIC segment"
" is not the .dynamic section"),
abfd);
bfd_set_error (bfd_error_bad_value);
&& p->p_paddr < (bfd_vma) off))
{
_bfd_error_handler
- (_("%B: Not enough room for program headers,"
+ (_("%pB: Not enough room for program headers,"
" try linking with -N"),
abfd);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: section %A lma %#Lx adjusted to %#Lx"),
+ (_("%pB: section %pA lma %#Lx adjusted to %#Lx"),
abfd, sec, s_start, p_end);
adjust = 0;
sec->lma = p_end;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: section `%A' can't be allocated in segment %d"),
+ (_("%pB: section `%pA' can't be allocated in segment %d"),
abfd, sec, j);
print_segment_map (m);
}
if (hdr->sh_size != 0)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: allocated section `%s' not in segment"),
+ (_("%pB: warning: allocated section `%s' not in segment"),
abfd,
(hdr->bfd_section == NULL
? "*unknown*"
{
/* PR 17512: file: 2195325e. */
_bfd_error_handler
- (_("%B: error: non-load segment %d includes file header "
+ (_("%pB: error: non-load segment %d includes file header "
"and/or program header"),
abfd, (int) (p - phdrs));
return FALSE;
used and set up the program headers manually. Either that or
leave room for the headers at the start of the SECTIONS. */
_bfd_error_handler (_("\
-%B: error: PHDR segment not covered by LOAD segment"),
+%pB: error: PHDR segment not covered by LOAD segment"),
abfd);
return FALSE;
}
which is used in a relocation entry. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: symbol `%s' required but not present"),
+ (_("%pB: symbol `%s' required but not present"),
abfd, bfd_asymbol_name (asym_ptr));
bfd_set_error (bfd_error_no_symbols);
return -1;
if (segment->p_type == PT_LOAD
&& (segment->p_filesz > 0 || segment->p_memsz == 0))
/* xgettext:c-format */
- _bfd_error_handler (_("%B: warning: Empty loadable segment detected"
+ _bfd_error_handler (_("%pB: warning: Empty loadable segment detected"
" at vaddr=%#Lx, is this intentional?"),
ibfd, segment->p_vaddr);
/* PR 17512: file: f17299af. */
if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
/* xgettext:c-format */
- _bfd_error_handler (_("%B: warning: segment alignment of %#Lx"
+ _bfd_error_handler (_("%pB: warning: segment alignment of %#Lx"
" is too large"),
ibfd, segment->p_align);
else
{
error_return_bad_verref:
_bfd_error_handler
- (_("%B: .gnu.version_r invalid entry"), abfd);
+ (_("%pB: .gnu.version_r invalid entry"), abfd);
bfd_set_error (bfd_error_bad_value);
error_return_verref:
elf_tdata (abfd)->verref = NULL;
{
error_return_bad_verdef:
_bfd_error_handler
- (_("%B: .gnu.version_d invalid entry"), abfd);
+ (_("%pB: .gnu.version_d invalid entry"), abfd);
bfd_set_error (bfd_error_bad_value);
error_return_verdef:
elf_tdata (abfd)->verdef = NULL;
fail:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unsupported relocation type %s"),
+ (_("%pB: unsupported relocation type %s"),
abfd, areloc->howto->name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
/* It's sometimes ok to mix different configs, so this is only
a warning. */
_bfd_error_handler
- (_("Warning: %B: Conflicting platform configuration "
+ (_("Warning: %pB: Conflicting platform configuration "
"%s with %s.\n"), ibfd,
tagval[in_attr[i].i],
tagval[out_attr[i].i]);
BFD_ASSERT (out_attr[i].i < 5);
/* We cannot mix code for different CPUs. */
_bfd_error_handler
- (_("error: %B: unable to merge CPU base attributes "
+ (_("error: %pB: unable to merge CPU base attributes "
"%s with %s.\n"),
obfd,
tagval[in_attr[i].i],
&& (!(cpu_out & bfd_feature_list[j].cpus)))
{
_bfd_error_handler
- (_("error: %B: unable to merge ISA extension attributes "
+ (_("error: %pB: unable to merge ISA extension attributes "
"%s.\n"),
obfd, bfd_feature_list[j].name);
result = FALSE;
p2 = (char *) bfd_feature_list[k].name;
}
_bfd_error_handler
- (_("error: %B: conflicting ISA extension attributes "
+ (_("error: %pB: conflicting ISA extension attributes "
"%s with %s.\n"),
obfd, p1, p2);
result = FALSE;
{
/* We cannot mix code with rf16 and without. */
_bfd_error_handler
- (_("error: %B: cannot mix rf16 with full register set %B.\n"),
+ (_("error: %pB: cannot mix rf16 with full register set %pB.\n"),
obfd, ibfd);
result = FALSE;
}
&& out_attr[i].i != in_attr[i].i)
{
_bfd_error_handler
- (_("error: %B: conflicting attributes %s: %s with %s.\n"),
+ (_("error: %pB: conflicting attributes %s: %s with %s.\n"),
obfd, tagname,
tagval[in_attr[i].i],
tagval[out_attr[i].i]);
&& out_attr[i].i != in_attr[i].i)
{
_bfd_error_handler
- (_("error: %B: conflicting attributes %s.\n"),
+ (_("error: %pB: conflicting attributes %s.\n"),
obfd, tagname);
result = FALSE;
}
if (mach_ibfd != mach_obfd)
{
/* xgettext:c-format */
- _bfd_error_handler (_("ERROR: Attempting to link %B "
- "with a binary %B of different architecture"),
+ _bfd_error_handler (_("ERROR: Attempting to link %pB "
+ "with a binary %pB of different architecture"),
ibfd, obfd);
return FALSE;
}
/* Warn if different flags. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields than "
+ (_("%pB: uses different e_flags (%#x) fields than "
"previous modules (%#x)"),
ibfd, in_flags, out_flags);
if (in_flags && out_flags)
if (reloc_data.reloc_addend == 0)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): CMEM relocation to `%s' is invalid, "
+ (_("%pB(%pA+%#Lx): CMEM relocation to `%s' is invalid, "
"16 MSB should be %#x (value is %#Lx)"),
reloc_data.input_section->owner,
reloc_data.input_section,
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): CMEM relocation to `%s+%#Lx' is invalid, "
+ (_("%pB(%pA+%#Lx): CMEM relocation to `%s+%#Lx' is invalid, "
"16 MSB should be %#x (value is %#Lx)"),
reloc_data.input_section->owner,
reloc_data.input_section,
case bfd_reloc_other:
/* xgettext:c-format */
- msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
+ msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
break;
case bfd_reloc_outofrange:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: out of range error");
+ msg = _("%pB(%pA): internal error: out of range error");
break;
case bfd_reloc_notsupported:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: unsupported relocation error");
+ msg = _("%pB(%pA): internal error: unsupported relocation error");
break;
case bfd_reloc_dangerous:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: dangerous relocation");
+ msg = _("%pB(%pA): internal error: dangerous relocation");
break;
default:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: unknown error");
+ msg = _("%pB(%pA): internal error: unknown error");
break;
}
_bfd_error_handler
/* xgettext:c-format */
(_("\
-%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
+%pB: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
abfd,
arc_elf_howto (r_type)->name,
name);
if ((tag & 127) < (Tag_ARC_ISA_mpy_option + 1))
{
_bfd_error_handler
- (_("%B: Unknown mandatory ARC object attribute %d."),
+ (_("%pB: Unknown mandatory ARC object attribute %d."),
abfd, tag);
bfd_set_error (bfd_error_bad_value);
return FALSE;
else
{
_bfd_error_handler
- (_("Warning: %B: Unknown ARC object attribute %d."),
+ (_("Warning: %pB: Unknown ARC object attribute %d."),
abfd, tag);
return TRUE;
}
{
if (input_sec->flags & SEC_ELF_PURECODE)
_bfd_error_handler
- (_("%B(%A): warning: long branch veneers used in"
+ (_("%pB(%pA): 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 (input_sec->flags & SEC_ELF_PURECODE)
_bfd_error_handler
- (_("%B(%A): warning: long branch veneers used in"
+ (_("%pB(%pA): 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 (input_sec->flags & SEC_ELF_PURECODE)
_bfd_error_handler
- (_("%B(%A): warning: long branch veneers used in"
+ (_("%pB(%pA): 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."),
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: Thumb call to ARM"),
+ (_("%pB(%s): warning: interworking not enabled.\n"
+ " first occurrence: %pB: Thumb call to ARM"),
sym_sec->owner, name, input_bfd);
}
{
if (input_sec->flags & SEC_ELF_PURECODE)
_bfd_error_handler
- (_("%B(%A): warning: long branch veneers used in"
+ (_("%pB(%pA): 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."),
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: ARM call to Thumb"),
+ (_("%pB(%s): warning: interworking not enabled.\n"
+ " first occurrence: %pB: ARM call to Thumb"),
sym_sec->owner, name, input_bfd);
}
{
if (section == NULL)
section = stub_sec;
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return NULL;
}
if (!is_v8m)
{
- _bfd_error_handler (_("%B: Special symbol `%s' only allowed for "
+ _bfd_error_handler (_("%pB: Special symbol `%s' only allowed for "
"ARMv8-M architecture or later."),
input_bfd, sym_name);
is_v8m = TRUE; /* Avoid multiple warning. */
if (cmse_invalid)
{
- _bfd_error_handler (_("%B: invalid special symbol `%s'."),
+ _bfd_error_handler (_("%pB: invalid special symbol `%s'."),
input_bfd, sym_name);
_bfd_error_handler (_("It must be a global or weak function "
"symbol."));
if (hash || j < ext_start)
{
_bfd_error_handler
- (_("%B: invalid standard symbol `%s'."), input_bfd, sym_name);
+ (_("%pB: invalid standard symbol `%s'."), input_bfd, sym_name);
_bfd_error_handler
(_("It must be a global or weak function symbol."));
}
else
_bfd_error_handler
- (_("%B: absent standard symbol `%s'."), input_bfd, sym_name);
+ (_("%pB: absent standard symbol `%s'."), input_bfd, sym_name);
ret = FALSE;
if (!hash)
continue;
if (cmse_hash->root.root.u.def.section != section)
{
_bfd_error_handler
- (_("%B: `%s' and its special symbol are in different sections."),
+ (_("%pB: `%s' and its special symbol are in different sections."),
input_bfd, sym_name);
ret = FALSE;
}
if (section->output_section == NULL)
{
_bfd_error_handler
- (_("%B: entry function `%s' not output."), input_bfd, sym_name);
+ (_("%pB: entry function `%s' not output."), input_bfd, sym_name);
continue;
}
if (hash->root.size == 0)
{
_bfd_error_handler
- (_("%B: entry function `%s' is empty."), input_bfd, sym_name);
+ (_("%pB: entry function `%s' is empty."), input_bfd, sym_name);
ret = FALSE;
}
in_implib_bfd = htab->in_implib_bfd;
if (!htab->cmse_implib)
{
- _bfd_error_handler (_("%B: --in-implib only supported for Secure "
+ _bfd_error_handler (_("%pB: --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'."),
+ _bfd_error_handler (_("%pB: invalid import library entry: `%s'."),
in_implib_bfd, sym_name);
_bfd_error_handler (_("Symbol should be absolute, global and "
"refer to Thumb functions."));
if (!!(flags & BSF_GLOBAL)
!= (hash->root.root.type == bfd_link_hash_defined))
_bfd_error_handler
- (_("%B: visibility of symbol `%s' has changed."), in_implib_bfd,
+ (_("%pB: visibility of symbol `%s' has changed."), in_implib_bfd,
sym_name);
stub_entry->stub_offset = stub_offset;
/* Size should match that of a SG veneer. */
if (intsym->st_size != cmse_stub_size)
{
- _bfd_error_handler (_("%B: incorrect size for symbol `%s'."),
+ _bfd_error_handler (_("%pB: incorrect size for symbol `%s'."),
in_implib_bfd, sym_name);
ret = FALSE;
}
TRUE, FALSE);
if (stub_entry == NULL)
{
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return FALSE;
}
if (globals->byteswap_code && !bfd_big_endian (abfd))
{
- _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
+ _bfd_error_handler (_("%pB: BE8 images only valid in big-endian mode."),
abfd);
return FALSE;
}
default:
/* Give a warning, but do as the user requests anyway. */
- _bfd_error_handler (_("%B: warning: selected VFP11 erratum "
+ _bfd_error_handler (_("%pB: 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
- (_("%B: warning: selected STM32L4XX erratum "
+ (_("%pB: 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 "
+ _bfd_error_handler (_("%pB: unable to find VFP11 veneer "
"`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- _bfd_error_handler (_("%B: unable to find VFP11 veneer "
+ _bfd_error_handler (_("%pB: unable to find VFP11 veneer "
"`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- _bfd_error_handler (_("%B: unable to find STM32L4XX veneer "
+ _bfd_error_handler (_("%pB: unable to find STM32L4XX veneer "
"`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- _bfd_error_handler (_("%B: unable to find STM32L4XX veneer "
+ _bfd_error_handler (_("%pB: unable to find STM32L4XX veneer "
"`%s'"), abfd, tmp_name);
vma = myh->root.u.def.section->output_section->vma
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#x): error: multiple load detected"
+ (_("%pB(%pA+%#x): error: multiple load detected"
" in non-last IT block instruction :"
" STM32L4XX veneer cannot be generated.\n"
"Use gcc option -mrestrict-it to generate"
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: Thumb call to ARM"),
+ (_("%pB(%s): warning: interworking not enabled.\n"
+ " first occurrence: %pB: Thumb call to ARM"),
sym_sec->owner, name, input_bfd);
return FALSE;
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: arm call to thumb"),
+ (_("%pB(%s): warning: interworking not enabled.\n"
+ " first occurrence: %pB: arm call to thumb"),
sym_sec->owner, name, input_bfd);
}
{
/* FIXME: We ought to be able to generate thumb-1 PLT
instructions... */
- _bfd_error_handler (_("%B: Warning: thumb-1 mode PLT generation not currently supported"),
+ _bfd_error_handler (_("%pB: Warning: thumb-1 mode PLT generation not currently supported"),
output_bfd);
return FALSE;
}
| bfd_get_16 (input_bfd, contents + rel->r_offset + 2);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected Thumb instruction '%#lx' in TLS trampoline"),
+ (_("%pB(%pA+%#Lx): unexpected Thumb instruction '%#lx' in TLS trampoline"),
input_bfd, input_sec, rel->r_offset, insn);
return bfd_reloc_notsupported;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected ARM instruction '%#lx' in TLS trampoline"),
+ (_("%pB(%pA+%#Lx): unexpected ARM instruction '%#lx' in TLS trampoline"),
input_bfd, input_sec, rel->r_offset, insn);
return bfd_reloc_notsupported;
}
v = _("PIE executable");
_bfd_error_handler
- (_("%B: relocation %s against external or undefined symbol `%s'"
+ (_("%pB: 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);
return bfd_reloc_notsupported;
instruction instead ? */
if (branch_type != ST_BRANCH_TO_THUMB)
_bfd_error_handler
- (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
+ (_("\%pB: Warning: Arm BLX instruction targets Arm function '%s'."),
input_bfd,
h ? h->root.root.string : "(local)");
}
instruction instead ? */
if (branch_type == ST_BRANCH_TO_THUMB)
_bfd_error_handler
- (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
+ (_("%pB: Warning: Thumb BLX instruction targets thumb function '%s'."),
input_bfd,
h ? h->root.root.string : "(local)");
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected Thumb instruction '%#lx' referenced by TLS_GOTDESC"),
+ (_("%pB(%pA+%#Lx): unexpected Thumb instruction '%#lx' referenced by TLS_GOTDESC"),
input_bfd, input_section, rel->r_offset, insn);
return bfd_reloc_notsupported;
}
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected ARM instruction '%#lx' referenced by TLS_GOTDESC"),
+ (_("%pB(%pA+%#Lx): unexpected ARM instruction '%#lx' referenced by TLS_GOTDESC"),
input_bfd, input_section, rel->r_offset, insn);
return bfd_reloc_notsupported;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation not permitted in shared object"),
+ (_("%pB(%pA+%#Lx): %s relocation not permitted in shared object"),
input_bfd, input_section, rel->r_offset, howto->name);
return bfd_reloc_notsupported;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
+ (_("%pB(%pA+%#Lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
input_bfd, input_section, rel->r_offset);
return bfd_reloc_overflow;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
+ (_("%pB(%pA+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
input_bfd, input_section, rel->r_offset,
signed_value < 0 ? -signed_value : signed_value, howto->name);
return bfd_reloc_overflow;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
+ (_("%pB(%pA+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
input_bfd, input_section, rel->r_offset,
signed_value < 0 ? -signed_value : signed_value, howto->name);
return bfd_reloc_overflow;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
+ (_("%pB(%pA+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
input_bfd, input_section, rel->r_offset,
signed_value < 0 ? -signed_value : signed_value, howto->name);
return bfd_reloc_overflow;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
+ (_("%pB(%pA+%#Lx): Overflow whilst splitting %#Lx for group relocation %s"),
input_bfd, input_section, rel->r_offset,
signed_value < 0 ? -signed_value : signed_value, howto->name);
return bfd_reloc_overflow;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation against SEC_MERGE section"),
+ (_("%pB(%pA+%#Lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
rel->r_offset, howto->name);
return FALSE;
_bfd_error_handler
((sym_type == STT_TLS
/* xgettext:c-format */
- ? _("%B(%A+%#Lx): %s used with TLS symbol %s")
+ ? _("%pB(%pA+%#Lx): %s used with TLS symbol %s")
/* xgettext:c-format */
- : _("%B(%A+%#Lx): %s used with non-TLS symbol %s")),
+ : _("%pB(%pA+%#Lx): %s used with non-TLS symbol %s")),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
if (flags & EF_ARM_INTERWORK)
_bfd_error_handler
- (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
+ (_("Warning: Not setting interworking flag of %pB since it has already been specified as non-interworking"),
abfd);
else
_bfd_error_handler
- (_("Warning: Clearing the interworking flag of %B due to outside request"),
+ (_("Warning: Clearing the interworking flag of %pB due to outside request"),
abfd);
}
}
{
if (out_flags & EF_ARM_INTERWORK)
_bfd_error_handler
- (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
+ (_("Warning: Clearing the interworking flag of %pB because non-interworking code in %pB has been linked with it"),
obfd, ibfd);
in_flags &= ~EF_ARM_INTERWORK;
if ((tag & 127) < 64)
{
_bfd_error_handler
- (_("%B: Unknown mandatory EABI object attribute %d"),
+ (_("%pB: Unknown mandatory EABI object attribute %d"),
abfd, tag);
bfd_set_error (bfd_error_bad_value);
return FALSE;
else
{
_bfd_error_handler
- (_("Warning: %B: Unknown EABI object attribute %d"),
+ (_("Warning: %pB: Unknown EABI object attribute %d"),
abfd, tag);
return TRUE;
}
if (oldtag > MAX_TAG_CPU_ARCH || newtag > MAX_TAG_CPU_ARCH)
{
- _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
+ _bfd_error_handler (_("error: %pB: Unknown CPU architecture"), ibfd);
return -1;
}
if (result == -1)
{
- _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
+ _bfd_error_handler (_("error: %pB: Conflicting CPU architectures %d/%d"),
ibfd, oldtag, newtag);
return -1;
}
!= out_attr[Tag_MPextension_use].i)
{
_bfd_error_handler
- (_("Error: %B has both the current and legacy "
+ (_("Error: %pB has both the current and legacy "
"Tag_MPextension_use attributes"), ibfd);
result = FALSE;
}
&& in_attr[Tag_ABI_VFP_args].i != AEABI_VFP_args_compatible)
{
_bfd_error_handler
- (_("error: %B uses VFP register arguments, %B does not"),
+ (_("error: %pB uses VFP register arguments, %pB does not"),
in_attr[Tag_ABI_VFP_args].i ? ibfd : obfd,
in_attr[Tag_ABI_VFP_args].i ? obfd : ibfd);
result = FALSE;
binaries in the toolchain have had the attributes set
properly.
_bfd_error_handler
- (_("error: %B: 8-byte data alignment conflicts with %B"),
+ (_("error: %pB: 8-byte data alignment conflicts with %pB"),
obfd, ibfd);
result = FALSE; */
}
else
{
_bfd_error_handler
- (_("error: %B: unable to merge virtualization attributes "
- "with %B"),
+ (_("error: %pB: unable to merge virtualization attributes "
+ "with %pB"),
obfd, ibfd);
result = FALSE;
}
else
{
_bfd_error_handler
- (_("error: %B: Conflicting architecture profiles %c/%c"),
+ (_("error: %pB: Conflicting architecture profiles %c/%c"),
ibfd,
in_attr[i].i ? in_attr[i].i : '0',
out_attr[i].i ? out_attr[i].i : '0');
/* It's sometimes ok to mix different configs, so this is only
a warning. */
_bfd_error_handler
- (_("Warning: %B: Conflicting platform configuration"), ibfd);
+ (_("Warning: %pB: Conflicting platform configuration"), ibfd);
}
break;
case Tag_ABI_PCS_R9_use:
&& in_attr[i].i != AEABI_R9_unused)
{
_bfd_error_handler
- (_("error: %B: Conflicting use of R9"), ibfd);
+ (_("error: %pB: Conflicting use of R9"), ibfd);
result = FALSE;
}
if (out_attr[i].i == AEABI_R9_unused)
&& out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
{
_bfd_error_handler
- (_("error: %B: SB relative addressing conflicts with use of R9"),
+ (_("error: %pB: SB relative addressing conflicts with use of R9"),
ibfd);
result = FALSE;
}
&& !elf_arm_tdata (obfd)->no_wchar_size_warning)
{
_bfd_error_handler
- (_("warning: %B uses %u-byte wchar_t yet the output is to use %u-byte wchar_t; use of wchar_t values across objects may fail"),
+ (_("warning: %pB uses %u-byte wchar_t yet the output is to use %u-byte wchar_t; use of wchar_t values across objects may fail"),
ibfd, in_attr[i].i, out_attr[i].i);
}
else if (in_attr[i].i && !out_attr[i].i)
? aeabi_enum_names[out_attr[i].i]
: "<unknown>";
_bfd_error_handler
- (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
+ (_("warning: %pB uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
ibfd, in_name, out_name);
}
}
if (in_attr[i].i != out_attr[i].i)
{
_bfd_error_handler
- (_("error: %B uses iWMMXt register arguments, %B does not"),
+ (_("error: %pB uses iWMMXt register arguments, %pB does not"),
ibfd, obfd);
result = FALSE;
}
if (in_attr[i].i != out_attr[i].i)
{
_bfd_error_handler
- (_("error: fp16 format mismatch between %B and %B"),
+ (_("error: fp16 format mismatch between %pB and %pB"),
ibfd, obfd);
result = FALSE;
}
if (in_attr[Tag_MPextension_use].i != in_attr[i].i)
{
_bfd_error_handler
- (_("%B has both the current and legacy "
+ (_("%pB has both the current and legacy "
"Tag_MPextension_use attributes"),
ibfd);
result = FALSE;
object file containing relocations but no symbol table. */
&& (r_symndx > STN_UNDEF || nsyms > 0))
{
- _bfd_error_handler (_("%B: bad symbol index: %d"), abfd,
+ _bfd_error_handler (_("%pB: bad symbol index: %d"), abfd,
r_symndx);
return FALSE;
}
if (bfd_link_pic (info))
{
_bfd_error_handler
- (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
+ (_("%pB: 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");
bfd_set_error (bfd_error_bad_value);
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
|| !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info)
|| !bfd_elf32_arm_stm32l4xx_erratum_scan (ibfd, info))
- _bfd_error_handler (_("Errors encountered processing file %B"), ibfd);
+ _bfd_error_handler (_("Errors encountered processing file %pB"), ibfd);
}
/* Allocate space for the glue sections now that we've sized them. */
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 "
+ _bfd_error_handler (_("%pB: 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 "
+ _bfd_error_handler (_("%pB: 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 "
+ _bfd_error_handler (_("%pB: error: VFP11 veneer out of "
"range"), output_bfd);
insn |= (branch_to_veneer >> 2) & 0xffffff;
if ((signed) branch_from_veneer < -(1 << 25)
|| (signed) branch_from_veneer >= (1 << 25))
- _bfd_error_handler (_("%B: error: VFP11 veneer out of "
+ _bfd_error_handler (_("%pB: error: VFP11 veneer out of "
"range"), output_bfd);
/* Original instruction. */
branch_to_veneer - (1 << 24) : 0;
_bfd_error_handler
- (_("%B(%#Lx): error: Cannot create STM32L4XX veneer. "
+ (_("%pB(%#Lx): error: Cannot create STM32L4XX veneer. "
"Jump out of range by %Ld bytes. "
"Cannot encode branch instruction. "),
output_bfd,
STM32L4XX_ERRATUM_LDM_VENEER_SIZE) < -(1 << 24)
|| (signed) (veneer_r - veneer) >= (1 << 24))
{
- _bfd_error_handler (_("%B: error: Cannot create STM32L4XX "
+ _bfd_error_handler (_("%pB: error: Cannot create STM32L4XX "
"veneer."), output_bfd);
continue;
}
&& !(ibfd->flags & DYNAMIC)
&& (in_flags & EF_ARM_BE8))
{
- _bfd_error_handler (_("error: %B is already in final BE8 format"),
+ _bfd_error_handler (_("error: %pB is already in final BE8 format"),
ibfd);
return FALSE;
}
EF_ARM_EABI_VERSION (out_flags)))
{
_bfd_error_handler
- (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
+ (_("error: Source object %pB has EABI version %d, but target %pB has EABI version %d"),
ibfd, (in_flags & EF_ARM_EABIMASK) >> 24,
obfd, (out_flags & EF_ARM_EABIMASK) >> 24);
return FALSE;
if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
{
_bfd_error_handler
- (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
+ (_("error: %pB is compiled for APCS-%d, whereas target %pB uses APCS-%d"),
ibfd, in_flags & EF_ARM_APCS_26 ? 26 : 32,
obfd, out_flags & EF_ARM_APCS_26 ? 26 : 32);
flags_compatible = FALSE;
{
if (in_flags & EF_ARM_APCS_FLOAT)
_bfd_error_handler
- (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
+ (_("error: %pB passes floats in float registers, whereas %pB passes them in integer registers"),
ibfd, obfd);
else
_bfd_error_handler
- (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
+ (_("error: %pB passes floats in integer registers, whereas %pB passes them in float registers"),
ibfd, obfd);
flags_compatible = FALSE;
{
if (in_flags & EF_ARM_VFP_FLOAT)
_bfd_error_handler
- (_("error: %B uses VFP instructions, whereas %B does not"),
+ (_("error: %pB uses VFP instructions, whereas %pB does not"),
ibfd, obfd);
else
_bfd_error_handler
- (_("error: %B uses FPA instructions, whereas %B does not"),
+ (_("error: %pB uses FPA instructions, whereas %pB does not"),
ibfd, obfd);
flags_compatible = FALSE;
{
if (in_flags & EF_ARM_MAVERICK_FLOAT)
_bfd_error_handler
- (_("error: %B uses Maverick instructions, whereas %B does not"),
+ (_("error: %pB uses Maverick instructions, whereas %pB does not"),
ibfd, obfd);
else
_bfd_error_handler
- (_("error: %B does not use Maverick instructions, whereas %B does"),
+ (_("error: %pB does not use Maverick instructions, whereas %pB does"),
ibfd, obfd);
flags_compatible = FALSE;
{
if (in_flags & EF_ARM_SOFT_FLOAT)
_bfd_error_handler
- (_("error: %B uses software FP, whereas %B uses hardware FP"),
+ (_("error: %pB uses software FP, whereas %pB uses hardware FP"),
ibfd, obfd);
else
_bfd_error_handler
- (_("error: %B uses hardware FP, whereas %B uses software FP"),
+ (_("error: %pB uses hardware FP, whereas %pB uses software FP"),
ibfd, obfd);
flags_compatible = FALSE;
if (in_flags & EF_ARM_INTERWORK)
{
_bfd_error_handler
- (_("Warning: %B supports interworking, whereas %B does not"),
+ (_("Warning: %pB supports interworking, whereas %pB does not"),
ibfd, obfd);
}
else
{
_bfd_error_handler
- (_("Warning: %B does not support interworking, whereas %B does"),
+ (_("Warning: %pB does not support interworking, whereas %pB does"),
ibfd, obfd);
}
}
if (r_type >= (unsigned int) R_AVR_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid AVR reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid AVR reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_avr_howto_table[r_type];
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable relocation against symbol `%s'"),
input_bfd,
input_section, rel->r_offset, h->root.root.string);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): reloc against `%s': error %d"),
+ (_("%pB(%pA+%#Lx): reloc against `%s': error %d"),
input_bfd, input_section, rel->r_offset, name, (int) r);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation at `%A+%#Lx' references symbol `%s' with nonzero addend"),
+ (_("%pB: relocation at `%pA+%#Lx' references symbol `%s' with nonzero addend"),
input_bfd, input_section, rel->r_offset, name);
return FALSE;
bad_reloc:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unsupported relocation type %d"),
+ (_("%pB: unsupported relocation type %d"),
abfd, (int) ELF32_R_TYPE (rel->r_info));
return FALSE;
}
if (0)
#endif
_bfd_error_handler
- ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %B",
+ ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %pB",
old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no", ibfd);
if (!elf_flags_init (obfd)) /* First call, no flags set. */
error = TRUE;
if (IS_FDPIC (obfd))
_bfd_error_handler
- (_("%B: cannot link non-fdpic object file into fdpic executable"),
+ (_("%pB: cannot link non-fdpic object file into fdpic executable"),
ibfd);
else
_bfd_error_handler
- (_("%B: cannot link fdpic object file into non-fdpic executable"),
+ (_("%pB: cannot link fdpic object file into non-fdpic executable"),
ibfd);
}
if (r_type >= R_CR16_MAX)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised CR16 reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised CR16 reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_CR16_NONE;
if (r_type >= RINDEX_16C_MAX)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid CR16C reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid CR16C reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_howto_table[r_type];
if (r_type >= R_CRIS_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid CRIS reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid CRIS reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & cris_elf_howto_table [r_type];
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: unresolvable relocation %s against symbol `%s'"),
+ (_("%pB, section %pA: unresolvable relocation %s against symbol `%s'"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
_bfd_error_handler
((h->got.offset == (bfd_vma) -1)
/* xgettext:c-format */
- ? _("%B, section %A: No PLT nor GOT for relocation %s"
+ ? _("%pB, section %pA: No PLT nor GOT for relocation %s"
" against symbol `%s'")
/* xgettext:c-format */
- : _("%B, section %A: No PLT for relocation %s"
+ : _("%pB, section %pA: No PLT for relocation %s"
" against symbol `%s'"),
input_bfd,
input_section,
if (h == NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
+ (_("%pB, section %pA: relocation %s with non-zero addend %Ld"
" against local symbol"),
input_bfd,
input_section,
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
+ (_("%pB, section %pA: relocation %s with non-zero addend %Ld"
" against symbol `%s'"),
input_bfd,
input_section,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s is"
+ (_("%pB, section %pA: relocation %s is"
" not allowed for global symbol: `%s'"),
input_bfd,
input_section,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with no GOT created"),
+ (_("%pB, section %pA: relocation %s with no GOT created"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name);
((h->root.type == bfd_link_hash_undefined)
/* We shouldn't get here for GCC-emitted code. */
/* xgettext:c-format */
- ? _("%B, section %A: relocation %s has an undefined"
+ ? _("%pB, section %pA: relocation %s has an undefined"
" reference to `%s', perhaps a declaration mixup?")
/* xgettext:c-format */
- : _("%B, section %A: relocation %s is"
+ : _("%pB, section %pA: relocation %s is"
" not allowed for `%s', a global symbol with default"
" visibility, perhaps a declaration mixup?"),
input_bfd,
to pass us these kinds of things. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
+ (_("%pB, section %pA: relocation %s with non-zero addend %Ld"
" against symbol `%s'"),
input_bfd,
input_section,
things. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
+ (_("%pB, section %pA: relocation %s with non-zero addend %Ld"
" against symbol `%s'"),
input_bfd,
input_section,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s is"
+ (_("%pB, section %pA: relocation %s is"
" not allowed for symbol: `%s'"
" which is defined outside the program,"
" perhaps a declaration mixup?"),
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A:\n v10/v32 compatible object"
+ (_("%pB, section %pA:\n v10/v32 compatible object"
" must not contain a PIC relocation"),
abfd, sec);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A:\n relocation %s not valid"
+ (_("%pB, section %pA:\n relocation %s not valid"
" in a shared object;"
" typically an option mixup, recompile with -fPIC"),
abfd,
/* FIXME: How do we make this optionally a warning only? */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A:\n relocation %s should not"
+ (_("%pB, section %pA:\n relocation %s should not"
" be used in a shared object; recompile with -fPIC"),
abfd,
sec,
/* FIXME: How do we make this optionally a warning only? */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section `%A', to symbol `%s':\n"
+ (_("%pB, section `%pA', to symbol `%s':\n"
" relocation %s should not be used"
" in a shared object; recompile with -fPIC"),
s->section->owner,
{
_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"),
+ ? _("%pB: uses _-prefixed symbols, but writing file with non-prefixed symbols")
+ : _("%pB: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
((imach == bfd_mach_cris_v32)
- ? _("%B contains CRIS v32 code, incompatible"
+ ? _("%pB contains CRIS v32 code, incompatible"
" with previous objects")
- : _("%B contains non-CRIS-v32 code, incompatible"
+ : _("%pB contains non-CRIS-v32 code, incompatible"
" with previous objects"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if (r_type >= R_CRX_MAX)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised CRX reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised CRX reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_CRX_NONE;
if (r_type >= (unsigned int) R_D10V_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid D10V reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid D10V reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_d10v_howto_table[r_type];
if (r_type >= (unsigned int) R_D30V_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid D30V reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid D30V reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_d30v_howto_table[r_type];
if (r_type >= (unsigned int) R_D30V_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid D30V reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid D30V reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_d30v_howto_table[r_type];
if (r_type >= (unsigned int) R_EPIPHANY_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid Epiphany reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid Epiphany reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & epiphany_elf_howto_table [r_type];
if (r_type >= (unsigned int) R_FR30_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid FR30 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid FR30 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & fr30_elf_howto_table [r_type];
if (r_type >= (unsigned int) R_FRV_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid FRV reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid FRV reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & elf32_frv_howto_table [r_type];
bad_reloc:
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: unsupported relocation type %i\n"),
+ (_("%pB: unsupported relocation type %i\n"),
abfd, ELF32_R_TYPE (rel->r_info));
return FALSE;
}
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: compiled with %s and linked with modules"
+ (_("%pB: compiled with %s and linked with modules"
" that use non-pic relocations"),
ibfd, (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
#endif
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: compiled with %s and linked with modules compiled with %s"),
+ (_("%pB: compiled with %s and linked with modules compiled with %s"),
ibfd, new_opt, old_opt);
}
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different unknown e_flags (%#x) fields"
+ (_("%pB: uses different unknown e_flags (%#x) fields"
" than previous modules (%#x)"),
ibfd, new_partial, old_partial);
}
error = TRUE;
if (IS_FDPIC (obfd))
_bfd_error_handler
- (_("%B: cannot link non-fdpic object file into fdpic executable"),
+ (_("%pB: cannot link non-fdpic object file into fdpic executable"),
ibfd);
else
_bfd_error_handler
- (_("%B: cannot link fdpic object file into non-fdpic executable"),
+ (_("%pB: cannot link fdpic object file into non-fdpic executable"),
ibfd);
}
ehdrp = elf_elfheader (abfd);
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Relocations in generic ELF (EM: %d)"),
+ _bfd_error_handler (_("%pB: Relocations in generic ELF (EM: %d)"),
abfd, ehdrp->e_machine);
bfd_set_error (bfd_error_wrong_format);
if (hsh == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return NULL;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
+ (_("%pB(%pA+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
hsh->target_section->owner,
stub_sec,
hsh->stub_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
+ (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),
abfd,
elf_hppa_howto_table[r_type].name);
bfd_set_error (bfd_error_bad_value);
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, eh->root.root.string, sec);
/* Not an error, just cut short the traversal. */
else
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: duplicate export stub %s"),
+ _bfd_error_handler (_("%pB: duplicate export stub %s"),
input_bfd, stub_name);
}
}
error. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s fixup for insn %#x is not supported in a non-shared link"),
+ (_("%pB(%pA+%#Lx): %s fixup for insn %#x is not supported in a non-shared link"),
input_bfd,
input_section,
offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
+ (_("%pB(%pA+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
input_bfd,
input_section,
offset,
if (*sym_name == '\0')
sym_name = bfd_section_name (input_bfd, sym_sec);
_bfd_error_handler
- (_("%B:%s has both normal and TLS relocs"),
+ (_("%pB:%s has both normal and TLS relocs"),
input_bfd, sym_name);
}
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot handle %s for %s"),
+ (_("%pB(%pA+%#Lx): cannot handle %s for %s"),
input_bfd,
input_section,
rela->r_offset,
if (r_type >= R_I370_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised I370 reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised I370 reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_I370_NONE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields than previous modules (%#x)"),
+ (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
ibfd, new_flags, old_flags);
bfd_set_error (bfd_error_bad_value);
return TRUE;
#ifdef DEBUG
- _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
+ _bfd_error_handler ("i370_elf_check_relocs called for section %pA in %pB",
sec, abfd);
#endif
bfd_boolean ret = TRUE;
#ifdef DEBUG
- _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %u relocations%s",
+ _bfd_error_handler ("i370_elf_relocate_section called for %pB section %pA, %u relocations%s",
input_bfd, input_section,
input_section->reloc_count,
(bfd_link_relocatable (info)) ? " (relocatable)" : "");
|| !i370_elf_howto_table[(int)r_type])
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unknown relocation type %d"),
+ _bfd_error_handler (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
{
default:
_bfd_error_handler
- (_("%B: unknown relocation type %d for symbol %s"),
+ (_("%pB: unknown relocation type %d for symbol %s"),
input_bfd, (int) r_type, sym_name);
bfd_set_error (bfd_error_bad_value);
case (int) R_I370_RELATIVE:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Relocation %s is not yet supported for symbol %s."),
+ (_("%pB: Relocation %s is not yet supported for symbol %s."),
input_bfd,
i370_elf_howto_table[(int) r_type]->name,
sym_name);
>= R_386_vt - R_386_ext2))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) r_type);
indx = R_386_NONE;
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
- "in section `%A' failed"),
+ (_("%pB: TLS transition from %s to %s against `%s' at %#Lx "
+ "in section `%pA' failed"),
abfd, from->name, to->name, name,
rel->r_offset, sec);
bfd_set_error (bfd_error_bad_value);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base"
+ (_("%pB: 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))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
goto error_return;
}
NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and "
+ (_("%pB: `%s' accessed both as normal and "
"thread local symbol"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unsupported non-PIC call to IFUNC `%s'"),
+ (_("%pB: unsupported non-PIC call to IFUNC `%s'"),
abfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
goto error_return;
NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against STT_GNU_IFUNC "
+ (_("%pB: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't supported"), input_bfd,
howto->name, name);
bfd_set_error (bfd_error_bad_value);
if (POINTER_LOCAL_IFUNC_P (info, h))
{
- info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
+ info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
h->root.root.string,
h->root.u.def.section->owner);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: direct GOT relocation %s against `%s'"
+ (_("%pB: direct GOT relocation %s against `%s'"
" without base register can not be used"
" when making a shared object"),
input_bfd, howto->name, name);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation R_386_GOTOFF against undefined %s"
+ (_("%pB: 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);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation R_386_GOTOFF against protected %s"
+ (_("%pB: 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_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): reloc against `%s': error %d"),
+ (_("%pB(%pA+%#Lx): reloc against `%s': error %d"),
input_bfd, input_section,
rel->r_offset, name, (int) r);
return FALSE;
+ got_offset);
if (PLT_LOCAL_IFUNC_P (info, h))
{
- info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
+ info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
h->root.root.string,
h->root.u.def.section->owner);
}
if (SYMBOL_REFERENCES_LOCAL_P (info, h))
{
- info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
+ info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
h->root.root.string,
h->root.u.def.section->owner);
if (type >= R_960_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid i960 reloc number: %d"), abfd, type);
+ _bfd_error_handler (_("%pB: invalid i960 reloc number: %d"), abfd, type);
type = 0;
}
if (r_type >= (unsigned int) R_IP2K_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid IP2K reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid IP2K reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & ip2k_elf_howto_table [r_type];
if (r_type >= (unsigned int) R_IQ2000_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid IQ2000 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid IQ2000 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & iq2000_elf_howto_table [r_type];
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: compiled with %s and linked with modules compiled with %s"),
+ (_("%pB: compiled with %s and linked with modules compiled with %s"),
ibfd, new_opt, old_opt);
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields than previous modules (%#x)"),
+ (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
ibfd, new_flags, old_flags);
}
}
if (r_type >= (unsigned int) R_LM32_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid LM32 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid LM32 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &lm32_elf_howto_table[r_type];
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if (r_type >= (unsigned int) R_M32C_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid M32C reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid M32C reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & m32c_elf_howto_table [r_type];
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: compiled with %s and linked with modules compiled with %s"),
+ (_("%pB: compiled with %s and linked with modules compiled with %s"),
ibfd, new_opt, old_opt);
}
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields"
+ (_("%pB: uses different e_flags (%#x) fields"
" than previous modules (%#x)"),
ibfd, new_flags, old_flags);
}
if (r_type > (unsigned int) R_M32R_GNU_VTENTRY)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid M32R reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid M32R reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &m32r_elf_howto_table[r_type];
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if (r_type < 0 || r_type >= (int) R_M32R_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unknown relocation type %d"),
+ _bfd_error_handler (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation "
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation "
"against symbol `%s'"),
input_bfd,
input_section,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
+ (_("%pB: The target (%s) of an %s relocation is in the wrong section (%pA)"),
input_bfd,
sym_name,
m32r_elf_howto_table[(int) r_type].name,
|| ((in_flags & EF_M32R_ARCH) == E_M32R2_ARCH))
{
_bfd_error_handler
- (_("%B: Instruction set mismatch with previous modules"), ibfd);
+ (_("%pB: Instruction set mismatch with previous modules"), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (r_type >= (unsigned int) R_M68HC11_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid M68HC11 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid M68HC11 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_m68hc11_howto_table[r_type];
if (r_type >= (unsigned int) R_M68HC11_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid M68HC12 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid M68HC12 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_m68hc11_howto_table[r_type];
if (stub_entry == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return NULL;
}
if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
{
_bfd_error_handler
- (_("%B: linking files compiled for 16-bit integers (-mshort) "
+ (_("%pB: 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
- (_("%B: linking files compiled for 32-bit double (-fshort-double) "
+ (_("%pB: linking files compiled for 32-bit double (-fshort-double) "
"and others for 64-bit double"), ibfd);
ok = FALSE;
}
if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
{
_bfd_error_handler
- (_("%B: linking files compiled for HCS12 with "
+ (_("%pB: linking files compiled for HCS12 with "
"others compiled for HC12"), ibfd);
ok = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields than previous modules (%#x)"),
+ (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
ibfd, new_flags, old_flags);
ok = FALSE;
}
if (indx >= (unsigned int) R_68K_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) indx);
indx = R_68K_NONE;
}
{
if (got->n_slots[R_8] > ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info))
/* xgettext:c-format */
- _bfd_error_handler (_("%B: GOT overflow: "
+ _bfd_error_handler (_("%pB: GOT overflow: "
"Number of relocations with 8-bit "
"offset > %d"),
abfd,
ELF_M68K_R_8_MAX_N_SLOTS_IN_GOT (info));
else
/* xgettext:c-format */
- _bfd_error_handler (_("%B: GOT overflow: "
+ _bfd_error_handler (_("%pB: GOT overflow: "
"Number of relocations with 8- or 16-bit "
"offset > %d"),
abfd,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation not permitted in shared object"),
+ (_("%pB(%pA+%#Lx): %s relocation not permitted in shared object"),
input_bfd, input_section, rel->r_offset, howto->name);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
_bfd_error_handler
((sym_type == STT_TLS
/* xgettext:c-format */
- ? _("%B(%A+%#Lx): %s used with TLS symbol %s")
+ ? _("%pB(%pA+%#Lx): %s used with TLS symbol %s")
/* xgettext:c-format */
- : _("%B(%A+%#Lx): %s used with non-TLS symbol %s")),
+ : _("%pB(%pA+%#Lx): %s used with non-TLS symbol %s")),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): reloc against `%s': error %d"),
+ (_("%pB(%pA+%#Lx): reloc against `%s': error %d"),
input_bfd, input_section,
rel->r_offset, name, (int) r);
return FALSE;
BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
+ _bfd_error_handler (_("%pB: Relocation %s (%d) is not currently supported.\n"),
abfd,
reloc_entry->howto->name,
reloc_entry->howto->type);
if (r_type >= R_MCORE_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised MCore reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised MCore reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_MCORE_NONE;
#ifdef DEBUG
_bfd_error_handler
- ("mcore_elf_relocate_section called for %B section %A, %u relocations%s",
+ ("mcore_elf_relocate_section called for %pB section %pA, %u relocations%s",
input_bfd,
input_section,
input_section->reloc_count,
|| ! mcore_elf_howto_table [(int)r_type])
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Unknown relocation type %d\n"),
+ _bfd_error_handler (_("%pB: Unknown relocation type %d\n"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
if (howto->special_function == mcore_elf_unsupported_reloc)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Relocation %s (%d) is not currently supported.\n"),
+ _bfd_error_handler (_("%pB: Relocation %s (%d) is not currently supported.\n"),
input_bfd,
howto->name,
(int)r_type);
if (r_type >= R_MEP_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid MEP reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid MEP reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & mep_elf_howto_table [r_type];
old_flags = elf_elfheader (obfd)->e_flags;
#ifdef DEBUG
- _bfd_error_handler ("%B: old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s",
+ _bfd_error_handler ("%pB: old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s",
ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
#endif
else
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B and %B are for different cores"),
+ _bfd_error_handler (_("%pB and %pB are for different cores"),
last_ibfd, ibfd);
bfd_set_error (bfd_error_invalid_target);
return FALSE;
else
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B and %B are for different configurations"),
+ _bfd_error_handler (_("%pB and %pB are for different configurations"),
last_ibfd, ibfd);
bfd_set_error (bfd_error_invalid_target);
return FALSE;
if (r_type >= (unsigned int) R_METAG_MAX)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid METAG reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid METAG reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & elf_metag_howto_table [r_type];
if (hsh == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return NULL;
}
/* We don't support changing the TLS model. */
/* PR 20675 */
if (bfd_link_pic (info))
- _bfd_error_handler (_("%B(%A): multiple TLS models are not supported"),
+ _bfd_error_handler (_("%pB(%pA): multiple TLS models are not supported"),
input_bfd, input_section);
else
- _bfd_error_handler (_("%B(%A): shared library symbol %s encountered whilst performing a static link"),
+ _bfd_error_handler (_("%pB(%pA): shared library symbol %s encountered whilst performing a static link"),
input_bfd, input_section, name);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation not permitted in shared object"),
+ (_("%pB(%pA+%#Lx): %s relocation not permitted in shared object"),
input_bfd, input_section, rel->r_offset, howto->name);
return FALSE;
}
name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
+ (_("%pB: 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);
return FALSE;
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if (r_type >= R_MICROBLAZE_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised MicroBlaze reloc number: %d"),
+ _bfd_error_handler (_("%pB: 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)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unknown relocation type %d"),
+ _bfd_error_handler (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: The target (%s) of an %s relocation"
- " is in the wrong section (%A)"),
+ (_("%pB: The target (%s) of an %s relocation"
+ " is in the wrong section (%pA)"),
input_bfd,
sym_name,
microblaze_elf_howto_table[(int) r_type]->name,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: The target (%s) of an %s relocation"
- " is in the wrong section (%A)"),
+ (_("%pB: The target (%s) of an %s relocation"
+ " is in the wrong section (%pA)"),
input_bfd,
sym_name,
microblaze_elf_howto_table[(int) r_type]->name,
{
BFD_FAIL ();
_bfd_error_handler
- (_("%B: probably compiled without -fPIC?"),
+ (_("%pB: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (r_type >= (unsigned int) R_MOXIE_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid Moxie reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid Moxie reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & moxie_elf_howto_table [r_type];
if (r_type >= (unsigned int) R_MSP430x_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid MSP430X reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid MSP430X reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = elf_msp430x_howto_table + r_type;
if (r_type >= (unsigned int) R_MSP430_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid MSP430 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid MSP430 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_msp430_howto_table[r_type];
{
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B: Unknown MSPABI object attribute %d"),
+ (_("Warning: %pB: Unknown MSPABI object attribute %d"),
abfd, tag);
return TRUE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses %s instructions but %B uses %s"),
+ (_("error: %pB uses %s instructions but %pB uses %s"),
ibfd, isa_type (in_attr[OFBA_MSPABI_Tag_ISA].i),
first_input_bfd, isa_type (out_attr[OFBA_MSPABI_Tag_ISA].i));
result = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses the %s code model whereas %B uses the %s code model"),
+ (_("error: %pB uses the %s code model whereas %pB uses the %s code model"),
ibfd, code_model (in_attr[OFBA_MSPABI_Tag_Code_Model].i),
first_input_bfd, code_model (out_attr[OFBA_MSPABI_Tag_Code_Model].i));
result = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses the large code model but %B uses MSP430 instructions"),
+ (_("error: %pB uses the large code model but %pB uses MSP430 instructions"),
ibfd, first_input_bfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses the %s data model whereas %B uses the %s data model"),
+ (_("error: %pB uses the %s data model whereas %pB uses the %s data model"),
ibfd, data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i),
first_input_bfd, data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
result = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses the small code model but %B uses the %s data model"),
+ (_("error: %pB uses the small code model but %pB uses the %s data model"),
ibfd, first_input_bfd,
data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
result = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses the %s data model but %B only uses MSP430 instructions"),
+ (_("error: %pB uses the %s data model but %pB only uses MSP430 instructions"),
ibfd, data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i),
first_input_bfd);
result = FALSE;
if (r_type >= (unsigned int) R_MT_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid MT reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid MT reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & mt_elf_howto_table [r_type];
old_flags = elf_elfheader (obfd)->e_flags;
#ifdef DEBUG
- _bfd_error_handler ("%B: old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s",
+ _bfd_error_handler ("%pB: old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s",
ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
#endif
if (r_type > R_NDS32_GNU_VTENTRY)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid NDS32 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid NDS32 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
/* Set the _ITB_BASE_. */
if (!nds32_elf_ex9_itb_base (info))
{
- _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"),
+ _bfd_error_handler (_("%pB: error: Cannot set _ITB_BASE_"),
output_bfd);
bfd_set_error (bfd_error_bad_value);
}
if (r_type >= R_NDS32_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: error: unknown relocation type %d."),
+ _bfd_error_handler (_("%pB: error: unknown relocation type %d."),
input_bfd, r_type);
bfd_set_error (bfd_error_bad_value);
ret = FALSE;
if (bfd_link_pic (info))
{
_bfd_error_handler
- (_("%B: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
+ (_("%pB: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
"mode."), input_bfd);
return FALSE;
}
{
/* Incorrect alignment. */
_bfd_error_handler
- (_("%B: warning: unaligned access to GOT entry."), input_bfd);
+ (_("%pB: warning: unaligned access to GOT entry."), input_bfd);
ret = FALSE;
r = bfd_reloc_dangerous;
goto check_reloc;
if (r != bfd_reloc_ok)
{
_bfd_error_handler
- (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
+ (_("%pB: warning: relocate SDA_BASE failed."), input_bfd);
ret = FALSE;
goto check_reloc;
}
/* Incorrect alignment. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A): warning: unaligned small data access of type %d."),
+ (_("%pB(%pA): warning: unaligned small data access of type %d."),
input_bfd, input_section, r_type);
ret = FALSE;
goto check_reloc;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: ISR vector size mismatch"
+ (_("%pB: 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,
if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
{
_bfd_error_handler
- (_("%B: warning: Endian mismatch with previous modules."), ibfd);
+ (_("%pB: warning: Endian mismatch with previous modules."), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (in_version == E_NDS32_ELF_VER_1_2)
{
_bfd_error_handler
- (_("%B: warning: Older version of object file encountered, "
+ (_("%pB: warning: Older version of object file encountered, "
"Please recompile with current tool chain."), ibfd);
}
if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
{
_bfd_error_handler
- (_("%B: error: ABI mismatch with previous modules."), ibfd);
+ (_("%pB: error: ABI mismatch with previous modules."), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
{
_bfd_error_handler
- (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
+ (_("%pB: error: Instruction set mismatch with previous modules."), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (in_version != out_version)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: Incompatible elf-versions %s and %s."),
+ (_("%pB: warning: Incompatible elf-versions %s and %s."),
ibfd, nds32_elfver_strtab[out_version],
nds32_elfver_strtab[in_version]);
&& (blank_t2->offset > raddr
|| blank_t2->next->offset <= raddr))
_bfd_error_handler
- (_("%B: Error: search_nds32_elf_blank reports wrong node\n"), abfd);
+ (_("%pB: Error: search_nds32_elf_blank reports wrong node\n"), abfd);
/* Mark reloc in deleted portion as NONE.
For some relocs like R_NDS32_LABEL that doesn't modify the
static const char * unrecognized_reloc_msg =
/* xgettext:c-format */
- N_("%B: warning: %s points to unrecognized reloc at %#Lx");
+ N_("%pB: warning: %s points to unrecognized reloc at %#Lx");
/* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
/* 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 (_("%pB: error: Cannot set _ITB_BASE_"), abfd);
bfd_set_error (bfd_error_bad_value);
}
}
/* Begin of the region. */
if (begin_rel)
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Nested OMIT_FP in %A."), abfd, sec);
+ _bfd_error_handler (_("%pB: Nested OMIT_FP in %pA."), abfd, sec);
begin_rel = irel;
nds32_fag_init (&fag_head);
if (begin_rel == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
+ _bfd_error_handler (_("%pB: Unmatched OMIT_FP in %pA."), abfd, sec);
continue;
}
message instead. */
link_info->callbacks->einfo
/* xgettext:c-format */
- (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
+ (_("%X%P: %pB(%pA): relocation \"%R\" goes out of range\n"),
abfd, input_section, * parent);
goto error_return;
/* Incorrect alignment. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: unaligned small data access "
+ (_("%pB: warning: unaligned small data access "
"for entry: {%Ld, %Ld, %Ld}, addr = %#Lx, align = %#x"),
abfd, irel->r_offset,
irel->r_info, irel->r_addend, relocation, align);
if (hsh == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner,
stub_name);
return NULL;
if (bfd_big_endian (ibfd))
{
_bfd_error_handler
- (_("error: %B: Big-endian R2 is not supported."), ibfd);
+ (_("error: %pB: Big-endian R2 is not supported."), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
architectures. */
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B: Conflicting CPU architectures %d/%d"),
+ (_("error: %pB: Conflicting CPU architectures %d/%d"),
ibfd, new_flags, old_flags);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation not "
+ (_("%pB(%pA+%#Lx): %s relocation not "
"permitted in shared object"),
input_bfd, input_section,
rel->r_offset, howto->name);
if (r_type >= (unsigned int) R_OR1K_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid OR1K reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid OR1K reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = & or1k_elf_howto_table[r_type];
{
BFD_FAIL ();
_bfd_error_handler
- (_("%B: probably compiled without -fPIC?"),
+ (_("%pB: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
/* TODO: implement support for local dynamic. */
BFD_FAIL ();
_bfd_error_handler
- (_("%B: support for local dynamic not implemented"),
+ (_("%pB: support for local dynamic not implemented"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
be used as linker input. */
BFD_FAIL ();
_bfd_error_handler
- (_("%B: will not resolve runtime TLS relocation"),
+ (_("%pB: will not resolve runtime TLS relocation"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: bad relocation section name `%s\'"),
+ (_("%pB: bad relocation section name `%s\'"),
abfd, name);
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if ((in_flags & EF_OR1K_NODELAY) != (out_flags & EF_OR1K_NODELAY))
{
_bfd_error_handler
- (_("%B: EF_OR1K_NODELAY flag mismatch with previous modules"), ibfd);
+ (_("%pB: EF_OR1K_NODELAY flag mismatch with previous modules"), ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (r >= R_PJ_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised PicoJava reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised PicoJava reloc number: %d"),
abfd, r);
bfd_set_error (bfd_error_bad_value);
r = R_PJ_NONE;
if (r_type >= R_PPC_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised PPC reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised PPC reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_PPC_NONE;
if (!cache_ptr->howto)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
continue;
/* xgettext:c-format */
- error_message = _("corrupt %s section in %B");
+ error_message = _("corrupt %s section in %pB");
length = asec->size;
if (length < 20)
goto fail;
|| (bfd_bread (buffer, length, ibfd) != length))
{
/* xgettext:c-format */
- error_message = _("unable to read in %s section from %B");
+ error_message = _("unable to read in %s section from %pB");
goto fail;
}
{
ibfd = abfd;
/* xgettext:c-format */
- error_message = _("warning: unable to set size of %s section in %B");
+ error_message = _("warning: unable to set size of %s section in %pB");
}
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s cannot be used when making a shared object"),
+ (_("%pB: relocation %s cannot be used when making a shared object"),
abfd,
ppc_elf_howto_table[r_type]->name);
bfd_set_error (bfd_error_bad_value);
return TRUE;
#ifdef DEBUG
- _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B",
+ _bfd_error_handler ("ppc_elf_check_relocs called for section %pA in %pB",
sec, abfd);
#endif
else if (out_fp != 2 && in_fp == 2)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
+ (_("Warning: %pB uses hard float, %pB uses soft float"), obfd, ibfd);
else if (out_fp == 2 && in_fp != 2)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
+ (_("Warning: %pB uses hard float, %pB uses soft float"), ibfd, obfd);
else if (out_fp == 1 && in_fp == 3)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses double-precision hard float, "
- "%B uses single-precision hard float"), obfd, ibfd);
+ (_("Warning: %pB uses double-precision hard float, "
+ "%pB uses single-precision hard float"), obfd, ibfd);
else if (out_fp == 3 && in_fp == 1)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses double-precision hard float, "
- "%B uses single-precision hard float"), ibfd, obfd);
+ (_("Warning: %pB uses double-precision hard float, "
+ "%pB uses single-precision hard float"), ibfd, obfd);
in_fp = in_attr->i & 0xc;
out_fp = out_attr->i & 0xc;
else if (out_fp != 2 * 4 && in_fp == 2 * 4)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses 64-bit long double, "
- "%B uses 128-bit long double"), ibfd, obfd);
+ (_("Warning: %pB uses 64-bit long double, "
+ "%pB uses 128-bit long double"), ibfd, obfd);
else if (in_fp != 2 * 4 && out_fp == 2 * 4)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses 64-bit long double, "
- "%B uses 128-bit long double"), obfd, ibfd);
+ (_("Warning: %pB uses 64-bit long double, "
+ "%pB uses 128-bit long double"), obfd, ibfd);
else if (out_fp == 1 * 4 && in_fp == 3 * 4)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses IBM long double, "
- "%B uses IEEE long double"), ibfd, obfd);
+ (_("Warning: %pB uses IBM long double, "
+ "%pB uses IEEE long double"), ibfd, obfd);
else if (out_fp == 3 * 4 && in_fp == 1 * 4)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses IBM long double, "
- "%B uses IEEE long double"), obfd, ibfd);
+ (_("Warning: %pB uses IBM long double, "
+ "%pB uses IEEE long double"), obfd, ibfd);
}
}
else if (out_vec < in_vec)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses AltiVec vector ABI, %B uses SPE vector ABI"),
+ (_("Warning: %pB uses AltiVec vector ABI, %pB uses SPE vector ABI"),
obfd, ibfd);
else if (out_vec > in_vec)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses AltiVec vector ABI, %B uses SPE vector ABI"),
+ (_("Warning: %pB uses AltiVec vector ABI, %pB uses SPE vector ABI"),
ibfd, obfd);
}
else if (out_struct < in_struct)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses r3/r4 for small structure returns, "
- "%B uses memory"), obfd, ibfd);
+ (_("Warning: %pB uses r3/r4 for small structure returns, "
+ "%pB uses memory"), obfd, ibfd);
else if (out_struct > in_struct)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses r3/r4 for small structure returns, "
- "%B uses memory"), ibfd, obfd);
+ (_("Warning: %pB uses r3/r4 for small structure returns, "
+ "%pB uses memory"), ibfd, obfd);
}
/* Merge Tag_compatibility attributes and any common GNU ones. */
{
error = TRUE;
_bfd_error_handler
- (_("%B: compiled with -mrelocatable and linked with "
+ (_("%pB: compiled with -mrelocatable and linked with "
"modules compiled normally"), ibfd);
}
else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
{
error = TRUE;
_bfd_error_handler
- (_("%B: compiled normally and linked with "
+ (_("%pB: compiled normally and linked with "
"modules compiled with -mrelocatable"), ibfd);
}
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields "
+ (_("%pB: uses different e_flags (%#x) fields "
"than previous modules (%#x)"),
ibfd, new_flags, old_flags);
}
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): expected 16A style relocation on 0x%08x insn"),
+ (_("%pB(%pA+0x%lx): expected 16A style relocation on 0x%08x insn"),
input_bfd, input_section, offset, opcode);
}
}
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): expected 16D style relocation on 0x%08x insn"),
+ (_("%pB(%pA+0x%lx): expected 16D style relocation on 0x%08x insn"),
input_bfd, input_section, offset, opcode);
}
}
if (htab->plt_type == PLT_OLD && htab->params->plt_style == PLT_NEW)
{
if (htab->old_bfd != NULL)
- info->callbacks->einfo (_("%P: bss-plt forced due to %B\n"),
+ info->callbacks->einfo (_("%P: bss-plt forced due to %pB\n"),
htab->old_bfd);
else
info->callbacks->einfo (_("%P: bss-plt forced by profiling\n"));
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
== (SEC_READONLY | SEC_ALLOC))
{
info->flags |= DF_TEXTREL;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
}
struct ppc_elf_relax_info *relax_info = NULL;
#ifdef DEBUG
- _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, "
+ _bfd_error_handler ("ppc_elf_relocate_section called for %pB section %pA, "
"%ld relocations%s",
input_bfd, input_section,
(long) input_section->reloc_count,
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): error: %s with unexpected instruction %#x"),
+ (_("%pB(%pA+%#Lx): error: %s with unexpected instruction %#x"),
input_bfd, input_section, rel->r_offset,
"R_PPC_ADDR16_HA", insn);
}
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): error: %s with unexpected instruction %#x"),
+ (_("%pB(%pA+%#Lx): error: %s with unexpected instruction %#x"),
input_bfd, input_section, rel->r_offset,
"R_PPC_ADDR16_LO", insn);
}
default:
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: unknown relocation type %d for symbol %s\n"),
+ (_("%P: %pB: unknown relocation type %d for symbol %s\n"),
input_bfd, (int) r_type, sym_name);
bfd_set_error (bfd_error_bad_value);
{
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: the target (%s) of a %s relocation is "
+ (_("%P: %pB: the target (%s) of a %s relocation is "
"in the wrong output section (%s)\n"),
input_bfd,
sym_name,
{
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: the target (%s) of a %s relocation is "
+ (_("%P: %pB: the target (%s) of a %s relocation is "
"in the wrong output section (%s)\n"),
input_bfd,
sym_name,
{
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: the target (%s) of a %s relocation is "
+ (_("%P: %pB: the target (%s) of a %s relocation is "
"in the wrong output section (%s)\n"),
input_bfd,
sym_name,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: the target (%s) of a %s relocation is "
+ (_("%pB: the target (%s) of a %s relocation is "
"in the wrong output section (%s)"),
input_bfd,
sym_name,
case R_PPC_EMB_BIT_FLD:
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: relocation %s is not yet supported for symbol %s\n"),
+ (_("%P: %pB: relocation %s is not yet supported for symbol %s\n"),
input_bfd,
howto->name,
sym_name);
if (r_type >= (unsigned int) R_RL78_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid RL78 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid RL78 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = rl78_elf_howto_table + r_type;
and emit a more helpful error message. */
if (r_type == R_RL78_DIR24S_PCREL)
/* xgettext:c-format */
- msg = _("%B(%A): error: call to undefined function '%s'");
+ msg = _("%pB(%pA): error: call to undefined function '%s'");
else
(*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
case bfd_reloc_other:
/* xgettext:c-format */
- msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
+ msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
break;
case bfd_reloc_outofrange:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: out of range error");
+ msg = _("%pB(%pA): internal error: out of range error");
break;
case bfd_reloc_notsupported:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: unsupported relocation error");
+ msg = _("%pB(%pA): internal error: unsupported relocation error");
break;
case bfd_reloc_dangerous:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: dangerous relocation");
+ msg = _("%pB(%pA): internal error: dangerous relocation");
break;
default:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: unknown error");
+ msg = _("%pB(%pA): internal error: unknown error");
break;
}
_bfd_error_handler
/* xgettext:c-format */
- (_("RL78 ABI conflict: G10 file %B cannot be linked"
- " with %s file %B"),
+ (_("RL78 ABI conflict: G10 file %pB cannot be linked"
+ " with %s file %pB"),
ibfd, rl78_cpu_name (out_cpu), obfd);
}
else
_bfd_error_handler
/* xgettext:c-format */
- (_("RL78 ABI conflict: cannot link %s file %B with %s file %B"),
+ (_("RL78 ABI conflict: cannot link %s file %pB with %s file %pB"),
rl78_cpu_name (in_cpu), ibfd,
rl78_cpu_name (out_cpu), obfd);
}
if (old_flags & E_FLAG_RL78_64BIT_DOUBLES)
/* xgettext:c-format */
- _bfd_error_handler (_("- %B is 64-bit, %B is not"),
+ _bfd_error_handler (_("- %pB is 64-bit, %pB is not"),
obfd, ibfd);
else
/* xgettext:c-format */
- _bfd_error_handler (_("- %B is 64-bit, %B is not"),
+ _bfd_error_handler (_("- %pB is 64-bit, %pB is not"),
ibfd, obfd);
error = TRUE;
}
if (r_type >= (unsigned int) R_RX_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid RX reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid RX reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = rx_elf_howto_table + r_type;
if (table_end_cache <= entry_vma || entry_vma < table_start_cache)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B:%A: table entry %s outside table"),
+ _bfd_error_handler (_("%pB:%pA: table entry %s outside table"),
input_bfd, input_section,
name);
}
else if ((int) (entry_vma - table_start_cache) % 4)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B:%A: table entry %s not word-aligned within table"),
+ _bfd_error_handler (_("%pB:%pA: table entry %s not word-aligned within table"),
input_bfd, input_section,
name);
}
#define OP(i) (contents[rel->r_offset + (i)])
#define WARN_REDHAT(type) \
/* xgettext:c-format */ \
- _bfd_error_handler (_("%B:%A: Warning: deprecated Red Hat reloc " type " detected against: %s."), \
+ _bfd_error_handler (_("%pB:%pA: Warning: deprecated Red Hat reloc " type " detected against: %s."), \
input_bfd, input_section, name)
/* Check for unsafe relocs in PID mode. These are any relocs where
&& strcmp (name, "__romdatastart") != 0 \
&& !saw_subtract) \
/* xgettext:c-format */ \
- _bfd_error_handler (_("%B(%A): unsafe PID relocation %s at %#Lx (against %s in %s)"), \
+ _bfd_error_handler (_("%pB(%pA): unsafe PID relocation %s at %#Lx (against %s in %s)"), \
input_bfd, input_section, howto->name, \
input_section->output_section->vma + input_section->output_offset + rel->r_offset, \
name, sec->name); \
and emit a more helpful error message. */
if (r_type == R_RX_DIR24S_PCREL)
/* xgettext:c-format */
- msg = _("%B(%A): error: call to undefined function '%s'");
+ msg = _("%pB(%pA): error: call to undefined function '%s'");
else
(*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
case bfd_reloc_other:
/* xgettext:c-format */
- msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
+ msg = _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
break;
case bfd_reloc_outofrange:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: out of range error");
+ msg = _("%pB(%pA): internal error: out of range error");
break;
case bfd_reloc_notsupported:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: unsupported relocation error");
+ msg = _("%pB(%pA): internal error: unsupported relocation error");
break;
case bfd_reloc_dangerous:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: dangerous relocation");
+ msg = _("%pB(%pA): internal error: dangerous relocation");
break;
default:
/* xgettext:c-format */
- msg = _("%B(%A): internal error: unknown error");
+ msg = _("%pB(%pA): internal error: unknown error");
break;
}
else
{
_bfd_error_handler (_("There is a conflict merging the"
- " ELF header flags from %B"),
+ " ELF header flags from %pB"),
ibfd);
_bfd_error_handler (_(" the input file's flags: %s"),
describe_flags (new_flags));
&& h->type != bfd_link_hash_defweak))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B:%A: table %s missing corresponding %s"),
+ _bfd_error_handler (_("%pB:%pA: table %s missing corresponding %s"),
abfd, sec, name, buf);
return TRUE;
}
if (h->u.def.section != ent->u.def.section)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B:%A: %s and %s must be in the same input section"),
+ _bfd_error_handler (_("%pB:%pA: %s and %s must be in the same input section"),
h->u.def.section->owner, h->u.def.section,
name, buf);
return TRUE;
if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) r_type);
r_type = R_390_NONE;
}
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): invalid instruction for TLS relocation %s"),
+ (_("%pB(%pA+%#Lx): invalid instruction for TLS relocation %s"),
input_bfd,
input_section,
rel->r_offset,
rel->r_offset) != (bfd_vma) -1)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): reloc against `%s': error %d"),
+ (_("%pB(%pA+%#Lx): reloc against `%s': error %d"),
input_bfd, input_section,
rel->r_offset, name, (int) r);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Malformed reloc detected for section %A"), abfd, sec);
+ (_("%pB: Malformed reloc detected for section %pA"), abfd, sec);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: CALL15 reloc at %#Lx not against global symbol"),
+ (_("%pB: CALL15 reloc at %#Lx not against global symbol"),
abfd, rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
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);
+ (_("%pB: warning: linking PIC files with non-PIC files"), ibfd);
/* FIXME: Maybe dependency fix compatibility should be checked here. */
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Malformed reloc detected for section %A"), abfd, sec);
+ (_("%pB: Malformed reloc detected for section %pA"), abfd, sec);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: CALL15 reloc at %#Lx not against global symbol"),
+ (_("%pB: CALL15 reloc at %#Lx not against global symbol"),
abfd, rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
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 (_("%pB: warning: linking PIC files with non-PIC files"), ibfd);
}
/* Maybe dependency fix compatibility should be checked here. */
bfd_set_error (bfd_error_invalid_operation);
/* xgettext:c-format */
- _bfd_error_handler (_("%B: IMPORT AS directive for %s conceals previous IMPORT AS"),
+ _bfd_error_handler (_("%pB: IMPORT AS directive for %s conceals previous IMPORT AS"),
abfd, current_name);
return FALSE;
}
bfd_set_error (bfd_error_invalid_operation);
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Unrecognised .directive command: %s"),
+ _bfd_error_handler (_("%pB: Unrecognised .directive command: %s"),
abfd, directive);
break;
}
if (new_hash == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Failed to add renamed symbol %s"),
+ _bfd_error_handler (_("%pB: Failed to add renamed symbol %s"),
input_bfd, ptr->new_name);
continue;
}
|| (r >= R_SH_FIRST_INVALID_RELOC_6 && r <= R_SH_LAST_INVALID_RELOC_6))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised SH reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised SH reloc number: %d"),
abfd, r);
bfd_set_error (bfd_error_bad_value);
r = R_SH_NONE;
if (laddr >= sec->size)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %#Lx: warning: bad R_SH_USES offset"),
+ _bfd_error_handler (_("%pB: %#Lx: warning: bad R_SH_USES offset"),
abfd, irel->r_offset);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
+ (_("%pB: %#Lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
abfd, irel->r_offset, insn);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: bad R_SH_USES load offset"),
+ (_("%pB: %#Lx: warning: bad R_SH_USES load offset"),
abfd, irel->r_offset);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: could not find expected reloc"),
+ (_("%pB: %#Lx: warning: could not find expected reloc"),
abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: symbol in unexpected section"),
+ (_("%pB: %#Lx: warning: symbol in unexpected section"),
abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: could not find expected COUNT reloc"),
+ (_("%pB: %#Lx: warning: could not find expected COUNT reloc"),
abfd, paddr);
continue;
}
if (irelcount->r_addend == 0)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %#Lx: warning: bad count"),
+ _bfd_error_handler (_("%pB: %#Lx: warning: bad count"),
abfd, paddr);
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
+ (_("%pB: %#Lx: fatal: reloc overflow while relaxing"),
abfd, irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: reloc overflow while relaxing"),
+ (_("%pB: %#Lx: fatal: reloc overflow while relaxing"),
abfd, irel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
{
info->flags |= DF_TEXTREL;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation against SEC_MERGE section"),
+ (_("%pB(%pA+%#Lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
rel->r_offset, howto->name);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: unaligned branch target for relax-support relocation"),
+ (_("%pB: %#Lx: fatal: unaligned branch target for relax-support relocation"),
input_section->owner,
rel->r_offset);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
+ (_("%pB: %#Lx: fatal: unaligned %s relocation %#Lx"),
input_section->owner,
rel->r_offset, howto->name,
relocation);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: unaligned %s relocation %#Lx"),
+ (_("%pB: %#Lx: fatal: unaligned %s relocation %#Lx"),
input_section->owner,
rel->r_offset, howto->name,
relocation);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: R_SH_PSHA relocation %Ld not in range -32..32"),
+ (_("%pB: %#Lx: fatal: R_SH_PSHA relocation %Ld not in range -32..32"),
input_section->owner,
rel->r_offset,
relocation);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: fatal: R_SH_PSHL relocation %Ld not in range -32..32"),
+ (_("%pB: %#Lx: fatal: R_SH_PSHL relocation %Ld not in range -32..32"),
input_section->owner,
rel->r_offset,
relocation);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
+ (_("%pB(%pA+%#Lx): cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot emit fixup to `%s' in read-only section"),
+ (_("%pB(%pA+%#Lx): cannot emit fixup to `%s' in read-only section"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation against external symbol \"%s\""),
+ (_("%pB(%pA+%#Lx): %s relocation against external symbol \"%s\""),
input_bfd, input_section, rel->r_offset, howto->name,
h->root.root.string);
return FALSE;
&& (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL))
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and FDPIC symbol"),
+ (_("%pB: `%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
/* xgettext:c-format */
- (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
+ (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
return FALSE;
}
if (rel->r_addend)
{
_bfd_error_handler
- (_("%B: Function descriptor relocation with non-zero addend"),
+ (_("%pB: Function descriptor relocation with non-zero addend"),
abfd);
return FALSE;
}
if (old_got_type == GOT_NORMAL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and FDPIC symbol"),
+ (_("%pB: `%s' accessed both as normal and FDPIC symbol"),
abfd, h->root.root.string);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as FDPIC and thread local symbol"),
+ (_("%pB: `%s' accessed both as FDPIC and thread local symbol"),
abfd, h->root.root.string);
}
}
if (bfd_link_dll (info))
{
_bfd_error_handler
- (_("%B: TLS local exec code cannot be linked into shared objects"),
+ (_("%pB: TLS local exec code cannot be linked into shared objects"),
abfd);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses %s instructions while previous modules "
+ (_("%pB: uses %s instructions while previous modules "
"use %s instructions"),
ibfd,
SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point",
if (! sh_merge_bfd_arch (ibfd, info))
{
- _bfd_error_handler (_("%B: uses instructions which are incompatible "
+ _bfd_error_handler (_("%pB: uses instructions which are incompatible "
"with instructions used in previous modules"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if (fdpic_object_p (ibfd) != fdpic_object_p (obfd))
{
- _bfd_error_handler (_("%B: attempt to mix FDPIC and non-FDPIC objects"),
+ _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"),
ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (bfd_get_arch_size (ibfd) == 32
&& bfd_get_arch_size (obfd) == 64)
/* xgettext:c-format */
- msg = _("%B: compiled as 32-bit object and %B is 64-bit");
+ msg = _("%pB: compiled as 32-bit object and %pB is 64-bit");
else if (bfd_get_arch_size (ibfd) == 64
&& bfd_get_arch_size (obfd) == 32)
/* xgettext:c-format */
- msg = _("%B: compiled as 64-bit object and %B is 32-bit");
+ msg = _("%pB: compiled as 64-bit object and %pB is 32-bit");
else
/* xgettext:c-format */
- msg = _("%B: object size does not match that of target %B");
+ msg = _("%pB: object size does not match that of target %pB");
_bfd_error_handler (msg, ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
{
_bfd_error_handler
- ("%B: uses non-SH64 instructions while previous modules"
+ ("%pB: uses non-SH64 instructions while previous modules"
" use SH64 instructions",
ibfd);
bfd_set_error (bfd_error_bad_value);
{
/* Make sure we don't get confused on invalid input. */
_bfd_error_handler
- (_("%B: encountered datalabel symbol in input"), abfd);
+ (_("%pB: encountered datalabel symbol in input"), abfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if ((insn & SHMEDIA_PTB_BIT) != 0)
{
_bfd_error_handler
- (_("%B: GAS error: unexpected PTB insn with R_SH_PT_16"),
+ (_("%pB: GAS error: unexpected PTB insn with R_SH_PT_16"),
input_section->owner);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: error: unaligned relocation type %d at %#Lx reloc %#Lx"),
+ (_("%pB: error: unaligned relocation type %d at %#Lx reloc %#Lx"),
input_section->owner, (int) ELF32_R_TYPE (rel->r_info),
rel->r_offset, *relocation);
return FALSE;
{
bfd_set_error (bfd_error_file_truncated);
_bfd_error_handler
- (_("%B: could not write out added .cranges entries"), abfd);
+ (_("%pB: could not write out added .cranges entries"), abfd);
}
}
{
bfd_set_error (bfd_error_file_truncated);
_bfd_error_handler
- (_("%B: could not write out sorted .cranges entries"), abfd);
+ (_("%pB: could not write out sorted .cranges entries"), abfd);
}
}
}
{
error = TRUE;
_bfd_error_handler
- (_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
+ (_("%pB: compiled for a 64 bit system and target is 32 bit"), ibfd);
}
else if ((ibfd->flags & DYNAMIC) == 0)
{
&& previous_ibfd_e_flags != (unsigned long) -1)
{
_bfd_error_handler
- (_("%B: linking little endian files with big endian files"), ibfd);
+ (_("%pB: linking little endian files with big endian files"), ibfd);
error = TRUE;
}
previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
if (r_type >= R_SPU_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised SPU reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised SPU reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_SPU_NONE;
if ((s->vma - vma_start) & (htab->params->line_size - 1))
{
- info->callbacks->einfo (_("%X%P: overlay section %A "
+ info->callbacks->einfo (_("%X%P: overlay section %pA "
"does not start on a cache line.\n"),
s);
bfd_set_error (bfd_error_bad_value);
}
else if (s->size > htab->params->line_size)
{
- info->callbacks->einfo (_("%X%P: overlay section %A "
+ info->callbacks->einfo (_("%X%P: overlay section %pA "
"is larger than a cache line.\n"),
s);
bfd_set_error (bfd_error_bad_value);
s = alloc_sec[i];
if (s->vma < ovl_end)
{
- info->callbacks->einfo (_("%X%P: overlay section %A "
+ info->callbacks->einfo (_("%X%P: overlay section %pA "
"is not in cache area.\n"),
alloc_sec[i-1]);
bfd_set_error (bfd_error_bad_value);
if (s0->vma != s->vma)
{
/* xgettext:c-format */
- info->callbacks->einfo (_("%X%P: overlay sections %A "
- "and %A do not start at the "
+ info->callbacks->einfo (_("%X%P: overlay sections %pA "
+ "and %pA do not start at the "
"same address.\n"),
s0, s);
bfd_set_error (bfd_error_bad_value);
}
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: call to non-function symbol %s defined in %B"),
+ (_("warning: call to non-function symbol %s defined in %pB"),
sym_name, sym_sec->owner);
}
if (stub_type != br000_ovl_stub
&& lrlive != stub_type - br000_ovl_stub)
/* xgettext:c-format */
- info->callbacks->einfo (_("%A:0x%v lrlive .brinfo (%u) differs "
+ info->callbacks->einfo (_("%pA:0x%v lrlive .brinfo (%u) differs "
"from analysis (%u)\n"),
isec, irela->r_offset, lrlive,
stub_type - br000_ovl_stub);
else if (h->root.u.def.section->owner != NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B is not allowed to define %s"),
+ _bfd_error_handler (_("%pB is not allowed to define %s"),
h->root.u.def.section->owner,
h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return &sinfo->fun[mid];
}
/* xgettext:c-format */
- info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
+ info->callbacks->einfo (_("%pA:0x%v not found in function table\n"),
sec, offset);
bfd_set_error (bfd_error_bad_value);
return NULL;
if (!warned)
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B(%A+0x%v): call to non-code section"
- " %B(%A), analysis incomplete\n"),
+ (_("%pB(%pA+0x%v): call to non-code section"
+ " %pB(%pA), analysis incomplete\n"),
sec->owner, sec, irela->r_offset,
sym_sec->owner, sym_sec);
warned = TRUE;
if (i == base)
{
/* xgettext:c-format */
- info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
+ info->callbacks->einfo (_("%pB:%pA%s exceeds overlay size\n"),
ovly_sections[2 * i]->owner,
ovly_sections[2 * i],
ovly_sections[2 * i + 1] ? " + rodata" : "");
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%s+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%s+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
bfd_get_section_name (input_bfd, input_section),
rel->r_offset,
}
else
{
- _bfd_error_handler (_("%B: SB-relative relocation but "
+ _bfd_error_handler (_("%pB: SB-relative relocation but "
"__c6xabi_DSBT_BASE not defined"),
input_bfd);
ok = FALSE;
if (h == NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
+ (_("%pB, section %pA: relocation %s with non-zero addend %Ld"
" against local symbol"),
input_bfd,
input_section,
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B, section %A: relocation %s with non-zero addend %Ld"
+ (_("%pB, section %pA: relocation %s with non-zero addend %Ld"
" against symbol `%s'"),
input_bfd,
input_section,
default:
/* Unknown relocation. */
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
input_bfd, r_type);
ok = FALSE;
continue;
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: error: unknown mandatory EABI object attribute %d"),
+ (_("%pB: error: unknown mandatory EABI object attribute %d"),
abfd, tag);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: unknown EABI object attribute %d"),
+ (_("%pB: warning: unknown EABI object attribute %d"),
abfd, tag);
return TRUE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more stack alignment than %B preserves"),
+ (_("error: %pB requires more stack alignment than %pB preserves"),
ibfd, obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more stack alignment than %B preserves"),
+ (_("error: %pB requires more stack alignment than %pB preserves"),
obfd, ibfd);
result = FALSE;
}
if (array_align_in == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
+ (_("error: unknown Tag_ABI_array_object_alignment value in %pB"),
ibfd);
result = FALSE;
}
if (array_align_out == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_alignment value in %B"),
+ (_("error: unknown Tag_ABI_array_object_alignment value in %pB"),
obfd);
result = FALSE;
}
if (array_expect_in == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
+ (_("error: unknown Tag_ABI_array_object_align_expected value in %pB"),
ibfd);
result = FALSE;
}
if (array_expect_out == -1)
{
_bfd_error_handler
- (_("error: unknown Tag_ABI_array_object_align_expected value in %B"),
+ (_("error: unknown Tag_ABI_array_object_align_expected value in %pB"),
obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more array alignment than %B preserves"),
+ (_("error: %pB requires more array alignment than %pB preserves"),
ibfd, obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B requires more array alignment than %B preserves"),
+ (_("error: %pB requires more array alignment than %pB preserves"),
obfd, ibfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: %B and %B differ in wchar_t size"), obfd, ibfd);
+ (_("warning: %pB and %pB differ in wchar_t size"), obfd, ibfd);
}
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: %B and %B differ in whether code is "
+ (_("warning: %pB and %pB differ in whether code is "
"compiled for DSBT"),
obfd, ibfd);
}
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
{
info->flags |= DF_TEXTREL;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
}
{
BFD_FAIL ();
_bfd_error_handler
- (_("%B: probably compiled without -fPIC?"),
+ (_("%pB: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
rel->r_offset) != (bfd_vma) -1)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
_bfd_error_handler
- (_("discarded output section: `%A'"), htab->elf.sgotplt);
+ (_("discarded output section: `%pA'"), htab->elf.sgotplt);
return FALSE;
}
return TRUE;
#ifdef DEBUG
- _bfd_error_handler ("v850_elf_check_relocs called for section %A in %B",
+ _bfd_error_handler ("v850_elf_check_relocs called for section %pA in %pB",
sec, abfd);
#endif
{
default:
#ifdef DEBUG
- fprintf (stderr, "%B: reloc number %d not recognised\n", abfd, r_type);
+ fprintf (stderr, "%pB: reloc number %d not recognised\n", abfd, r_type);
#endif
return bfd_reloc_notsupported;
if (r_type >= (unsigned int) R_V850_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid V850 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid V850 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &v850_elf_howto_table[r_type];
if (r_type >= (unsigned int) R_V850_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid V850 reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid V850 reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &v850_elf_howto_table[r_type];
default:
#ifdef DEBUG
- fprintf (stderr, "%B: reloc number %d not recognised\n", input_bfd, r_type);
+ fprintf (stderr, "%pB: reloc number %d not recognised\n", input_bfd, r_type);
#endif
return bfd_reloc_notsupported;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B needs 8-byte alignment but %B is set for 4-byte alignment"),
+ (_("error: %pB needs 8-byte alignment but %pB is set for 4-byte alignment"),
ibfd, obfd);
result = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses 64-bit doubles but "
- "%B uses 32-bit doubles"), ibfd, obfd);
+ (_("error: %pB uses 64-bit doubles but "
+ "%pB uses 32-bit doubles"), ibfd, obfd);
result = FALSE;
}
else
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B uses FPU-3.0 but %B only supports FPU-2.0"),
+ (_("error: %pB uses FPU-3.0 but %pB only supports FPU-2.0"),
ibfd, obfd);
result = FALSE;
}
if ((in_flags & EF_V800_850E3) != (out_flags & EF_V800_850E3))
{
_bfd_error_handler
- (_("%B: Architecture mismatch with previous modules"), ibfd);
+ (_("%pB: Architecture mismatch with previous modules"), ibfd);
elf_elfheader (obfd)->e_flags |= EF_V800_850E3;
}
}
_bfd_error_handler
- (_("%B: Architecture mismatch with previous modules"), ibfd);
+ (_("%pB: Architecture mismatch with previous modules"), ibfd);
}
return result;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGCALL points to "
"unrecognized insns"),
abfd, irel->r_offset);
continue;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGCALL points to "
"unrecognized insn %#x"),
abfd,
irel->r_offset + no_match,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGCALL points to "
"unrecognized reloc"),
abfd, irel->r_offset);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGCALL points to "
"unrecognized reloc %#Lx"),
abfd, irel->r_offset,
irelcall->r_offset);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGJUMP points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGJUMP points to "
"unrecognized insns"),
abfd, irel->r_offset);
continue;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGJUMP points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGJUMP points to "
"unrecognized insn %#x"),
abfd,
irel->r_offset + no_match,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %#Lx: warning: R_V850_LONGJUMP points to "
+ (_("%pB: %#Lx: warning: R_V850_LONGJUMP points to "
"unrecognized reloc"),
abfd, irel->r_offset);
continue;
if (r_type >= R_VAX_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised VAX reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised VAX reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_VAX_NONE;
if (eh->got_addend != (bfd_vma) rel->r_addend)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: GOT addend of %Ld to `%s' does"
+ (_("%pB: warning: GOT addend of %Ld to `%s' does"
" not match previous GOT addend of %Ld"),
abfd, rel->r_addend, h->root.root.string,
eh->got_addend);
else if (rel->r_addend != 0)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: PLT addend of %Ld to `%s'"
- " from %A section ignored"),
+ (_("%pB: warning: PLT addend of %Ld to `%s'"
+ " from %pA section ignored"),
input_bfd, rel->r_addend, h->root.root.string, input_section);
rel->r_addend = 0;
if (h != NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: %s relocation against symbol `%s'"
- " from %A section"),
+ (_("%pB: warning: %s relocation against symbol `%s'"
+ " from %pA section"),
input_bfd, howto->name, h->root.root.string,
input_section);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: %s relocation to %#Lx from %A section"),
+ (_("%pB: warning: %s relocation to %#Lx from %pA section"),
input_bfd, howto->name, outrel.r_addend,
input_section);
}
if (r_type >= (unsigned int) R_VISIUM_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid Visium reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid Visium reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &visium_elf_howto_table[r_type];
if (mismatch)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: compiled %s -mtune=%s and linked with modules"
+ (_("%pB: compiled %s -mtune=%s and linked with modules"
" compiled %s -mtune=%s"),
ibfd, new_opt_with, opt_arch, old_opt_with, opt_arch);
}
if (i >= ARRAY_SIZE (elf32_wasm32_howto_table))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) r_type);
i = R_WASM32_NONE;
}
if (r_type >= (unsigned int) R_XGATE_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid XGate reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid XGate reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_xgate_howto_table[r_type];
if (r_type >= (unsigned int) R_XTENSA_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid XTENSA reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid XTENSA reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_howto_table[r_type];
blocks[blk - 1].size != 0)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B(%A): invalid property table"),
+ _bfd_error_handler (_("%pB(%pA): invalid property table"),
abfd, section);
bfd_set_error (bfd_error_bad_value);
free (blocks);
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd,
h ? h->root.root.string : "<local>");
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): relocation offset out of range (size=%#Lx)"),
+ (_("%pB(%pA+%#Lx): relocation offset out of range (size=%#Lx)"),
input_bfd, input_section, rel->r_offset, input_size);
bfd_set_error (bfd_error_bad_value);
return FALSE;
_bfd_error_handler
((sym_type == STT_TLS
/* xgettext:c-format */
- ? _("%B(%A+%#Lx): %s used with TLS symbol %s")
+ ? _("%pB(%pA+%#Lx): %s used with TLS symbol %s")
/* xgettext:c-format */
- : _("%B(%A+%#Lx): %s used with non-TLS symbol %s")),
+ : _("%pB(%pA+%#Lx): %s used with non-TLS symbol %s")),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
+ (_("%pB: incompatible machine type. Output is 0x%x. Input is 0x%x"),
ibfd, out_mach, in_mach);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): could not decode instruction; "
+ (_("%pB(%pA+%#Lx): could not decode instruction; "
"possible configuration mismatch"),
ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): could not decode instruction; "
+ (_("%pB(%pA+%#Lx): could not decode instruction; "
"possible configuration mismatch"),
ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): could not decode instruction for "
+ (_("%pB(%pA+%#Lx): could not decode instruction for "
"XTENSA_ASM_SIMPLIFY relocation; "
"possible configuration mismatch"),
sec->owner, sec, r_offset);
decode_error:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): could not decode instruction; "
+ (_("%pB(%pA+%#Lx): could not decode instruction; "
"possible configuration mismatch"),
ebb->sec->owner, ebb->sec, offset);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected fix for %s relocation"),
+ (_("%pB(%pA+%#Lx): unexpected fix for %s relocation"),
input_bfd, input_section, rel->r_offset,
elf_howto_table[r_type].name);
return FALSE;
if (r_type >= R_ALPHA_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognised Alpha reloc number: %d"),
+ _bfd_error_handler (_("%pB: unrecognised Alpha reloc number: %d"),
abfd, r_type);
bfd_set_error (bfd_error_bad_value);
r_type = R_ALPHA_NONE;
/* Yikes! A single object file has too many entries. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: .got subsegment exceeds 64K (size %d)"),
+ (_("%pB: .got subsegment exceeds 64K (size %d)"),
i, alpha_elf_tdata (this_got)->total_got_size);
return FALSE;
}
reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %A+%#Lx: warning: %s relocation against unexpected insn"),
+ (_("%pB: %pA+%#Lx: warning: %s relocation against unexpected insn"),
info->abfd, info->sec, irel->r_offset, howto->name);
return TRUE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %A+%#Lx: warning: LITERAL relocation against unexpected insn"),
+ (_("%pB: %pA+%#Lx: warning: LITERAL relocation against unexpected insn"),
abfd, info->sec, irel->r_offset);
return TRUE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown relocation type %d"),
+ (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret_val = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown relocation type %d"),
+ (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret_val = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: gp-relative relocation against dynamic symbol %s"),
+ (_("%pB: gp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: gp-relative relocation against dynamic symbol %s"),
+ (_("%pB: gp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: pc-relative relocation against dynamic symbol %s"),
+ (_("%pB: pc-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: change in gp: BRSGP %s"),
+ (_("%pB: change in gp: BRSGP %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: !samegp reloc against symbol without .prologue: %s"),
+ (_("%pB: !samegp reloc against symbol without .prologue: %s"),
input_bfd, name);
ret_val = FALSE;
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unhandled dynamic relocation against %s"),
+ (_("%pB: unhandled dynamic relocation against %s"),
input_bfd,
h->root.root.root.string);
ret_val = FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: pc-relative relocation against dynamic symbol %s"),
+ (_("%pB: pc-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: pc-relative relocation against undefined weak symbol %s"),
+ (_("%pB: pc-relative relocation against undefined weak symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: dtp-relative relocation against dynamic symbol %s"),
+ (_("%pB: dtp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: TLS local exec code cannot be linked into shared objects"),
+ (_("%pB: TLS local exec code cannot be linked into shared objects"),
input_bfd);
ret_val = FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: tp-relative relocation against dynamic symbol %s"),
+ (_("%pB: tp-relative relocation against dynamic symbol %s"),
input_bfd, h->root.root.root.string);
ret_val = FALSE;
}
ehdrp = elf_elfheader (abfd);
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Relocations in generic ELF (EM: %d)"),
+ _bfd_error_handler (_("%pB: Relocations in generic ELF (EM: %d)"),
abfd, ehdrp->e_machine);
bfd_set_error (bfd_error_wrong_format);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot reach %s"),
+ (_("%pB(%pA+%#Lx): cannot reach %s"),
input_bfd,
input_section,
offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't relax br at %#Lx in section `%A'."
+ (_("%pB: Can't relax br at %#Lx in section `%pA'."
" Please use brl or indirect branch."),
sec->owner, roff, sec);
bfd_set_error (bfd_error_bad_value);
overflow:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: short data segment overflowed (%#Lx >= 0x400000)"),
+ (_("%pB: short data segment overflowed (%#Lx >= 0x400000)"),
abfd, max_short_vma - min_short_vma);
return FALSE;
}
&& max_short_vma - gp_val >= 0x200000))
{
_bfd_error_handler
- (_("%B: __gp does not cover short data segment"), abfd);
+ (_("%pB: __gp does not cover short data segment"), abfd);
return FALSE;
}
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown relocation type %d"),
+ (_("%pB: unknown relocation type %d"),
input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret_val = FALSE;
shared libraries nor dynamic executables. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: non-pic code with imm relocation against"
+ (_("%pB: non-pic code with imm relocation against"
" dynamic symbol `%s'"),
input_bfd,
h ? h->root.root.string
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: @gprel relocation against dynamic symbol %s"),
+ (_("%pB: @gprel relocation against dynamic symbol %s"),
input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
/* ??? People shouldn't be doing non-pic code in
shared libraries. Hork. */
_bfd_error_handler
- (_("%B: linking non-pic code in a position independent executable"),
+ (_("%pB: linking non-pic code in a position independent executable"),
input_bfd);
ret_val = FALSE;
continue;
if (r_type == R_IA64_PCREL21BI)
/* xgettext:c-format */
- msg = _("%B: @internal branch to dynamic symbol %s");
+ msg = _("%pB: @internal branch to dynamic symbol %s");
else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
/* xgettext:c-format */
- msg = _("%B: speculation fixup to dynamic symbol %s");
+ msg = _("%pB: speculation fixup to dynamic symbol %s");
else
/* xgettext:c-format */
- msg = _("%B: @pcrel relocation against dynamic symbol %s");
+ msg = _("%pB: @pcrel relocation against dynamic symbol %s");
_bfd_error_handler (msg, input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd,
case R_IA64_LTOFF_DTPREL22:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: missing TLS section for relocation %s against `%s'"
- " at %#Lx in section `%A'."),
+ (_("%pB: missing TLS section for relocation %s against `%s'"
+ " at %#Lx in section `%pA'."),
input_bfd, howto->name, name,
rel->r_offset, input_section);
break;
that the section is too big to relax. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't relax br (%s) to `%s' at %#Lx in section"
- " `%A' with size %#Lx (> 0x1000000)."),
+ (_("%pB: Can't relax br (%s) to `%s' at %#Lx in section"
+ " `%pA' with size %#Lx (> 0x1000000)."),
input_bfd, howto->name, name, rel->r_offset,
input_section, input_section->size);
break;
if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
{
_bfd_error_handler
- (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
+ (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
{
_bfd_error_handler
- (_("%B: linking big-endian files with little-endian files"),
+ (_("%pB: linking big-endian files with little-endian files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
{
_bfd_error_handler
- (_("%B: linking 64-bit files with 32-bit files"),
+ (_("%pB: linking 64-bit files with 32-bit files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
{
_bfd_error_handler
- (_("%B: linking constant-gp files with non-constant-gp files"),
+ (_("%pB: linking constant-gp files with non-constant-gp files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
!= (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
{
_bfd_error_handler
- (_("%B: linking auto-pic files with non-auto-pic files"),
+ (_("%pB: linking auto-pic files with non-auto-pic files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if (normal_bfd == NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: alignment %u of common symbol `%s' in %B"
- " is greater than the alignment (%u) of its section %A"),
+ (_("Warning: alignment %u of common symbol `%s' in %pB"
+ " is greater than the alignment (%u) of its section %pA"),
1 << common_align, name, common_bfd,
1 << normal_align, h->root.u.def.section);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: alignment %u of symbol `%s' in %B"
- " is smaller than %u in %B"),
+ (_("Warning: alignment %u of symbol `%s' in %pB"
+ " is smaller than %u in %pB"),
1 << normal_align, name, normal_bfd,
1 << common_align, common_bfd);
}
_bfd_error_handler
/* xgettext:c-format */
(_("Warning: size of symbol `%s' changed"
- " from %Lu in %B to %Lu in %B"),
+ " from %Lu in %pB to %Lu in %pB"),
name, h->size, old_bfd, isym->st_size, abfd);
h->size = isym->st_size;
_bfd_error_handler
/* xgettext:c-format */
(_("Warning: type of symbol `%s' changed"
- " from %d to %d in %B"),
+ " from %d to %d in %pB"),
name, h->type, type, abfd);
h->type = type;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Internal inconsistency error for value for\n\
+ (_("%pB: Internal inconsistency error for value for\n\
linker-allocated global register: linked: %#Lx != relaxed: %#Lx"),
isec->owner,
value,
if (r_type >= (unsigned int) R_MMIX_max)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid MMIX reloc number: %d"), abfd, r_type);
+ _bfd_error_handler (_("%pB: invalid MMIX reloc number: %d"), abfd, r_type);
r_type = 0;
}
cache_ptr->howto = &elf_mmix_howto_table[r_type];
if (symname == NULL || *symname == 0)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: base-plus-offset relocation against register symbol:"
- " (unknown) in %A"),
+ (_("%pB: base-plus-offset relocation against register symbol:"
+ " (unknown) in %pA"),
input_section->owner, symsec);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: base-plus-offset relocation against register symbol:"
- " %s in %A"),
+ (_("%pB: base-plus-offset relocation against register symbol:"
+ " %s in %pA"),
input_section->owner, symname, symsec);
return bfd_reloc_overflow;
}
if (symname == NULL || *symname == 0)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: register relocation against non-register symbol:"
- " (unknown) in %A"),
+ (_("%pB: register relocation against non-register symbol:"
+ " (unknown) in %pA"),
input_section->owner, symsec);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: register relocation against non-register symbol:"
- " %s in %A"),
+ (_("%pB: register relocation against non-register symbol:"
+ " %s in %pA"),
input_section->owner, symname, symsec);
/* The bfd_reloc_outofrange return value, though intuitively a
MMIX_REG_SECTION_NAME) != 0)
{
_bfd_error_handler
- (_("%B: directive LOCAL valid only with a register or absolute value"),
+ (_("%pB: directive LOCAL valid only with a register or absolute value"),
input_section->owner);
return bfd_reloc_overflow;
/* FIXME: Better error message. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: LOCAL directive: Register $%Ld is not a local register."
+ (_("%pB: LOCAL directive: Register $%Ld is not a local register."
" First global register is $%Ld."),
input_section->owner, srel, first_global);
h->u.def.section->owner is NULL. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Error: multiple definition of `%s'; start of %s "
+ (_("%pB: Error: multiple definition of `%s'; start of %s "
"is set in a earlier linked file\n"),
abfd, *namep,
*namep + strlen (MMIX_LOC_SECTION_START_SYMBOL_PREFIX));
if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) type);
type = R_PPC64_NONE;
}
if (stub_entry == NULL)
{
/* xgettext:c-format */
- info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
+ info->callbacks->einfo (_("%P: %pB: cannot create stub entry %s\n"),
section->owner, stub_name);
return NULL;
}
else if (abiversion (ibfd) >= 2)
{
/* xgettext:c-format */
- info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
+ info->callbacks->einfo (_("%P: %pB .opd not allowed in ABI"
" version %d\n"),
ibfd, abiversion (ibfd));
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
+ (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
+ (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
ibfd, iflags, oflags);
bfd_set_error (bfd_error_bad_value);
return FALSE;
if (ent.sec == NULL || ent.sec->output_section == NULL)
{
_bfd_error_handler
- (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
+ (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
return NULL;
}
}
/* xgettext:c-format */
- info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
+ info->callbacks->einfo (_("%P: dynreloc miscount for %pB, section %pA\n"),
sec->owner, sec);
bfd_set_error (bfd_error_bad_value);
return FALSE;
optimization for them! */
broken_opd:
_bfd_error_handler
- (_("%B: .opd is not a regular array of opd entries"), ibfd);
+ (_("%pB: .opd is not a regular array of opd entries"), ibfd);
broken = TRUE;
break;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unexpected reloc type %u in .opd section"),
+ (_("%pB: unexpected reloc type %u in .opd section"),
ibfd, r_type);
broken = TRUE;
break;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: undefined sym `%s' in .opd section"),
+ (_("%pB: undefined sym `%s' in .opd section"),
ibfd, sym_name);
broken = TRUE;
break;
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
big_sec = total > group_size;
if (big_sec && !suppress_size_errors)
/* xgettext:c-format */
- _bfd_error_handler (_("%B section %A exceeds stub group size"),
+ _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
tail->owner, tail);
curr_toc = htab->sec_info[tail->id].toc_off;
default:
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: unknown relocation type %d for `%T'\n"),
+ (_("%P: %pB: unknown relocation type %d for `%T'\n"),
input_bfd, (int) r_type, sym_name);
bfd_set_error (bfd_error_bad_value);
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: %B: %s is not supported for `%T'\n"),
+ (_("%P: %pB: %s is not supported for `%T'\n"),
input_bfd,
ppc64_elf_howto_table[r_type]->name, sym_name);
if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) r_type);
r_type = R_390_NONE;
}
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h->root.root.string);
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): invalid instruction for TLS relocation %s"),
+ (_("%pB(%pA+%#Lx): invalid instruction for TLS relocation %s"),
input_bfd,
input_section,
rel->r_offset,
&& bfd_link_pie (info)
&& !h->def_regular)
{
- _bfd_error_handler (_("%B: `%s' non-PLT reloc for symbol defined "
+ _bfd_error_handler (_("%pB: `%s' non-PLT reloc for symbol defined "
"in shared library and accessed "
"from executable "
"(rebuild file with -fPIC ?)"),
rel->r_offset) != (bfd_vma) -1)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): reloc against `%s': error %d"),
+ (_("%pB(%pA+%#Lx): reloc against `%s': error %d"),
input_bfd, input_section,
rel->r_offset, name, (int) r);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation against SEC_MERGE section"),
+ (_("%pB(%pA+%#Lx): %s relocation against SEC_MERGE section"),
input_bfd, input_section,
rel->r_offset, howto->name);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: error: unaligned relocation type %d at %08Lx reloc %08Lx"),
+ (_("%pB: error: unaligned relocation type %d at %08Lx reloc %08Lx"),
input_bfd, (int) r_type, rel->r_offset,
relocation);
bfd_set_error (bfd_error_bad_value);
if (bfd_get_arch_size (ibfd) == 32
&& bfd_get_arch_size (obfd) == 64)
/* xgettext:c-format */
- msg = _("%B: compiled as 32-bit object and %B is 64-bit");
+ msg = _("%pB: compiled as 32-bit object and %pB is 64-bit");
else if (bfd_get_arch_size (ibfd) == 64
&& bfd_get_arch_size (obfd) == 32)
/* xgettext:c-format */
- msg = _("%B: compiled as 64-bit object and %B is 32-bit");
+ msg = _("%pB: compiled as 64-bit object and %pB is 32-bit");
else
/* xgettext:c-format */
- msg = _("%B: object size does not match that of target %B");
+ msg = _("%pB: object size does not match that of target %pB");
_bfd_error_handler (msg, ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
{
_bfd_error_handler
- ("%B: does not use the SH64 64-bit ABI as previous modules do", ibfd);
+ ("%pB: does not use the SH64 64-bit ABI as previous modules do", ibfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
/* Make sure we don't get confused on invalid input. */
_bfd_error_handler
- (_("%B: encountered datalabel symbol in input"), abfd);
+ (_("%pB: encountered datalabel symbol in input"), abfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case 6: reg -= 4; break;
default:
_bfd_error_handler
- (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
+ (_("%pB: Only registers %%g[2367] can be declared using STT_REGISTER"),
abfd);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("Register %%g%d used incompatibly: %s in %B,"
- " previously %s in %B"),
+ (_("Register %%g%d used incompatibly: %s in %pB,"
+ " previously %s in %pB"),
(int) sym->st_value, **namep ? *namep : "#scratch", abfd,
*p->name ? p->name : "#scratch", p->abfd);
return FALSE;
type = 0;
_bfd_error_handler
/* xgettext:c-format */
- (_("Symbol `%s' has differing types: REGISTER in %B,"
- " previously %s in %B"),
+ (_("Symbol `%s' has differing types: REGISTER in %pB,"
+ " previously %s in %pB"),
*namep, abfd, stt_types[type], p->abfd);
return FALSE;
}
type = 0;
_bfd_error_handler
/* xgettext:c-format */
- (_("Symbol `%s' has differing types: %s in %B,"
- " previously REGISTER in %B"),
+ (_("Symbol `%s' has differing types: %s in %pB,"
+ " previously REGISTER in %pB"),
*namep, stt_types[type], abfd, p->abfd);
return FALSE;
}
{
error = TRUE;
_bfd_error_handler
- (_("%B: linking UltraSPARC specific with HAL specific code"),
+ (_("%pB: linking UltraSPARC specific with HAL specific code"),
ibfd);
}
/* Choose the most restrictive memory ordering. */
error = TRUE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: uses different e_flags (%#x) fields than previous modules (%#x)"),
+ (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
ibfd, new_flags, old_flags);
}
if (r_type >= (unsigned int) R_X86_64_standard)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: invalid relocation type %d"),
+ _bfd_error_handler (_("%pB: invalid relocation type %d"),
abfd, (int) r_type);
r_type = R_X86_64_NONE;
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
- "in section `%A' failed"),
+ (_("%pB: TLS transition from %s to %s against `%s' at %#Lx "
+ "in section `%pA' failed"),
abfd, from->name, to->name, name, rel->r_offset, sec);
bfd_set_error (bfd_error_bad_value);
return FALSE;
object = _("a PDE object");
/* xgettext:c-format */
- _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
+ _bfd_error_handler (_("%pB: relocation %s against %s%s`%s' can "
"not be used when making %s%s"),
input_bfd, howto->name, und, v, name,
object, pic);
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
goto error_return;
}
NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against symbol `%s' isn't "
+ (_("%pB: relocation %s against symbol `%s' isn't "
"supported in x32 mode"), abfd,
x86_64_elf_howto_table[r_type].name, name);
bfd_set_error (bfd_error_bad_value);
isym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: '%s' accessed both as normal and"
+ (_("%pB: '%s' accessed both as normal and"
" thread local symbol"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against STT_GNU_IFUNC "
+ (_("%pB: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't supported"), input_bfd,
howto->name, name);
bfd_set_error (bfd_error_bad_value);
sym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against STT_GNU_IFUNC "
+ (_("%pB: relocation %s against STT_GNU_IFUNC "
"symbol `%s' has non-zero addend: %Ld"),
input_bfd, howto->name, name, rel->r_addend);
bfd_set_error (bfd_error_bad_value);
if (POINTER_LOCAL_IFUNC_P (info, h))
{
- info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
+ info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
h->root.root.string,
h->root.u.def.section->owner);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
+ (_("%pB: 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);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
+ (_("%pB: 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",
sym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: addend %s%#x in relocation %s against "
- "symbol `%s' at %#Lx in section `%A' is "
+ (_("%pB: addend %s%#x in relocation %s against "
+ "symbol `%s' at %#Lx in section `%pA' is "
"out of range"),
input_bfd, addend < 0 ? "-" : "", addend,
howto->name, name, rel->r_offset, input_section);
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): reloc against `%s': error %d"),
+ (_("%pB(%pA+%#Lx): reloc against `%s': error %d"),
input_bfd, input_section,
rel->r_offset, name, (int) r);
return FALSE;
/* Check PC-relative offset overflow in PLT entry. */
if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
/* xgettext:c-format */
- info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
+ info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in PLT entry for `%s'\n"),
output_bfd, h->root.root.string);
bfd_put_32 (output_bfd, plt_got_pcrel_offset,
+ got_offset);
if (PLT_LOCAL_IFUNC_P (info, h))
{
- info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
+ info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
h->root.root.string,
h->root.u.def.section->owner);
will overflow first. */
if (plt0_offset > 0x80000000)
/* xgettext:c-format */
- info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
+ info->callbacks->einfo (_("%F%pB: branch displacement overflow in PLT entry for `%s'\n"),
output_bfd, h->root.root.string);
bfd_put_32 (output_bfd, - plt0_offset,
(plt->contents + h->plt.offset
if ((got_after_plt && got_pcrel_offset < 0)
|| (!got_after_plt && got_pcrel_offset > 0))
/* xgettext:c-format */
- info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
+ info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
output_bfd, h->root.root.string);
bfd_put_32 (output_bfd, got_pcrel_offset,
}
if (SYMBOL_REFERENCES_LOCAL_P (info, h))
{
- info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
+ info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
h->root.root.string,
h->root.u.def.section->owner);
so that at least some processing can be done. */
i_ehdrp->e_shstrndx = SHN_UNDEF;
_bfd_error_handler
- (_("warning: %B has a corrupt string table index - ignoring"),
+ (_("warning: %pB has a corrupt string table index - ignoring"),
abfd);
}
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: version count (%Ld) does not match symbol count (%ld)"),
+ (_("%pB: version count (%Ld) does not match symbol count (%ld)"),
abfd,
verhdr->sh_size / sizeof (Elf_External_Versym),
symcount);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A): relocation %d has invalid symbol index %ld"),
+ (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
abfd, asect, i, (long) ELF_R_SYM (rela.r_info));
relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("warning: %B is truncated: expected core file "
+ (_("warning: %pB is truncated: expected core file "
"size >= %Lu, found: %llu"),
abfd, high, (unsigned long long) statbuf.st_size);
}
if (tdef && ntdef)
_bfd_error_handler
/* xgettext:c-format */
- (_("%s: TLS definition in %B section %A "
- "mismatches non-TLS definition in %B section %A"),
+ (_("%s: TLS definition in %pB section %pA "
+ "mismatches non-TLS definition in %pB section %pA"),
h->root.root.string, tbfd, tsec, ntbfd, ntsec);
else if (!tdef && !ntdef)
_bfd_error_handler
/* xgettext:c-format */
- (_("%s: TLS reference in %B "
- "mismatches non-TLS reference in %B"),
+ (_("%s: TLS reference in %pB "
+ "mismatches non-TLS reference in %pB"),
h->root.root.string, tbfd, ntbfd);
else if (tdef)
_bfd_error_handler
/* xgettext:c-format */
- (_("%s: TLS definition in %B section %A "
- "mismatches non-TLS reference in %B"),
+ (_("%s: TLS definition in %pB section %pA "
+ "mismatches non-TLS reference in %pB"),
h->root.root.string, tbfd, tsec, ntbfd);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%s: TLS reference in %B "
- "mismatches non-TLS definition in %B section %A"),
+ (_("%s: TLS reference in %pB "
+ "mismatches non-TLS definition in %pB section %pA"),
h->root.root.string, tbfd, ntbfd, ntsec);
bfd_set_error (bfd_error_bad_value);
&& hi->root.type != bfd_link_hash_defweak)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
+ (_("%pB: unexpected redefinition of indirect versioned symbol `%s'"),
abfd, shortname);
}
else
generating a shared archive. Return an error. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: version node not found for symbol %s"),
+ (_("%pB: version node not found for symbol %s"),
info->output_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
sinfo->failed = TRUE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: bad reloc symbol index (%#Lx >= %#lx)"
- " for offset %#Lx in section `%A'"),
+ (_("%pB: bad reloc symbol index (%#Lx >= %#lx)"
+ " for offset %#Lx in section `%pA'"),
abfd, r_symndx, (unsigned long) nsyms,
irela->r_offset, sec);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: non-zero symbol index (%#Lx)"
- " for offset %#Lx in section `%A'"
+ (_("%pB: non-zero symbol index (%#Lx)"
+ " for offset %#Lx in section `%pA'"
" when the object file has no symbol table"),
abfd, r_symndx,
irela->r_offset, sec);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation size mismatch in %B section %A"),
+ (_("%pB: relocation size mismatch in %pB section %pA"),
output_bfd, input_section->owner, input_section);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
&& ehdr->e_machine == bed->elf_machine_alt2)))
info->callbacks->einfo
/* xgettext:c-format */
- (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
+ (_("%P: alternate ELF machine code found (%d) in %pB, expecting %d\n"),
ehdr->e_machine, abfd, bed->elf_machine_code);
/* As a GNU extension, any input sections which are named
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %s: invalid version %u (max %d)"),
+ (_("%pB: %s: invalid version %u (max %d)"),
abfd, name, vernum,
elf_tdata (abfd)->cverdefs);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: %s: invalid needed version %d"),
+ (_("%pB: %s: invalid needed version %d"),
abfd, name, vernum);
bfd_set_error (bfd_error_bad_value);
goto error_free_vers;
if (normal_bfd == NULL)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: alignment %u of common symbol `%s' in %B is"
- " greater than the alignment (%u) of its section %A"),
+ (_("Warning: alignment %u of common symbol `%s' in %pB is"
+ " greater than the alignment (%u) of its section %pA"),
1 << common_align, name, common_bfd,
1 << normal_align, h->root.u.def.section);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: alignment %u of symbol `%s' in %B"
- " is smaller than %u in %B"),
+ (_("Warning: alignment %u of symbol `%s' in %pB"
+ " is smaller than %u in %pB"),
1 << normal_align, name, normal_bfd,
1 << common_align, common_bfd);
}
_bfd_error_handler
/* xgettext:c-format */
(_("Warning: size of symbol `%s' changed"
- " from %Lu in %B to %Lu in %B"),
+ " from %Lu in %pB to %Lu in %pB"),
name, h->size, old_bfd, isym->st_size, abfd);
h->size = isym->st_size;
/* xgettext:c-format */
_bfd_error_handler
(_("Warning: type of symbol `%s' changed"
- " from %d to %d in %B"),
+ " from %d to %d in %pB"),
name, h->type, type, abfd);
h->type = type;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: undefined reference to symbol '%s'"),
+ (_("%pB: undefined reference to symbol '%s'"),
old_bfd, name);
bfd_set_error (bfd_error_missing_dso);
goto error_free_vers;
h->type = STT_OBJECT;
if (info->stacksize)
/* xgettext:c-format */
- _bfd_error_handler (_("%B: stack size specified and %s set"),
+ _bfd_error_handler (_("%pB: stack size specified and %s set"),
output_bfd, legacy_symbol);
else if (h->root.u.def.section != bfd_abs_section_ptr)
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %s not absolute"),
+ _bfd_error_handler (_("%pB: %s not absolute"),
output_bfd, legacy_symbol);
else
info->stacksize = h->root.u.def.value;
== SHT_PREINIT_ARRAY)
{
_bfd_error_handler
- (_("%B: .preinit_array section is not allowed in DSO"),
+ (_("%pB: .preinit_array section is not allowed in DSO"),
sub);
break;
}
&& ! info->gc_keep_exported)
{
/* PR 21524: Let the user know if a symbol was removed by garbage collection. */
- _bfd_error_handler (_("%B:%A: error: relocation references symbol %s which was removed by garbage collection."),
+ _bfd_error_handler (_("%pB:%pA: error: relocation references symbol %s which was removed by garbage collection."),
abfd, sec,
(*rel_hash)->root.root.string);
- _bfd_error_handler (_("%B:%A: error: try relinking with --gc-keep-exported enabled."),
+ _bfd_error_handler (_("%pB:%pA: error: try relinking with --gc-keep-exported enabled."),
abfd, sec);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
/* Section size is only divisible by rela. */
if (use_rela_initialised && !use_rela)
{
- _bfd_error_handler (_("%B: Unable to sort relocs - "
+ _bfd_error_handler (_("%pB: Unable to sort relocs - "
"they are in more than one size"),
abfd);
bfd_set_error (bfd_error_invalid_operation);
/* Section size is only divisible by rel. */
if (use_rela_initialised && use_rela)
{
- _bfd_error_handler (_("%B: Unable to sort relocs - "
+ _bfd_error_handler (_("%pB: Unable to sort relocs - "
"they are in more than one size"),
abfd);
bfd_set_error (bfd_error_invalid_operation);
{
/* The section size is not divisible by either -
something is wrong. */
- _bfd_error_handler (_("%B: Unable to sort relocs - "
+ _bfd_error_handler (_("%pB: Unable to sort relocs - "
"they are of an unknown size"), abfd);
bfd_set_error (bfd_error_invalid_operation);
return 0;
/* Section size is only divisible by rela. */
if (use_rela_initialised && !use_rela)
{
- _bfd_error_handler (_("%B: Unable to sort relocs - "
+ _bfd_error_handler (_("%pB: Unable to sort relocs - "
"they are in more than one size"),
abfd);
bfd_set_error (bfd_error_invalid_operation);
/* Section size is only divisible by rel. */
if (use_rela_initialised && use_rela)
{
- _bfd_error_handler (_("%B: Unable to sort relocs - "
+ _bfd_error_handler (_("%pB: Unable to sort relocs - "
"they are in more than one size"),
abfd);
bfd_set_error (bfd_error_invalid_operation);
{
/* The section size is not divisible by either -
something is wrong. */
- _bfd_error_handler (_("%B: Unable to sort relocs - "
+ _bfd_error_handler (_("%pB: Unable to sort relocs - "
"they are of an unknown size"), abfd);
bfd_set_error (bfd_error_invalid_operation);
return 0;
beyond 64k. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Too many sections: %d (>= %d)"),
+ (_("%pB: Too many sections: %d (>= %d)"),
abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
/* xgettext:c-format */
- msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
+ msg = _("%pB: internal symbol `%s' in %pB is referenced by DSO");
else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
/* xgettext:c-format */
- msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
+ msg = _("%pB: hidden symbol `%s' in %pB is referenced by DSO");
else
/* xgettext:c-format */
- msg = _("%B: local symbol `%s' in %B is referenced by DSO");
+ msg = _("%pB: local symbol `%s' in %pB is referenced by DSO");
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
/* xgettext:c-format */
- (_("%B: could not find output section %A for input section %A"),
+ (_("%pB: could not find output section %pA for input section %pA"),
flinfo->output_bfd, input_sec->output_section, input_sec);
bfd_set_error (bfd_error_nonrepresentable_section);
eoinfo->failed = TRUE;
if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
/* xgettext:c-format */
- msg = _("%B: protected symbol `%s' isn't defined");
+ msg = _("%pB: protected symbol `%s' isn't defined");
else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
/* xgettext:c-format */
- msg = _("%B: internal symbol `%s' isn't defined");
+ msg = _("%pB: internal symbol `%s' isn't defined");
else
/* xgettext:c-format */
- msg = _("%B: hidden symbol `%s' isn't defined");
+ msg = _("%pB: hidden symbol `%s' isn't defined");
_bfd_error_handler (msg, flinfo->output_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
eoinfo->failed = TRUE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: No symbol version section for versioned symbol `%s'"),
+ (_("%pB: No symbol version section for versioned symbol `%s'"),
flinfo->output_bfd, h->root.root.string);
eoinfo->failed = TRUE;
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B: size of section %A is not "
+ (_("error: %pB: size of section %pA is not "
"multiple of address size"),
input_bfd, o);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("error: %B contains a reloc (%#Lx) for section %A "
+ (_("error: %pB contains a reloc (%#Lx) for section %pA "
"that references a non-existent global symbol"),
input_bfd, rel->r_info, o);
bfd_set_error (bfd_error_bad_value);
if (action_discarded & COMPLAIN)
(*flinfo->info->callbacks->einfo)
/* xgettext:c-format */
- (_("%X`%s' referenced in section `%A' of %B: "
- "defined in discarded section `%A' of %B\n"),
+ (_("%X`%s' referenced in section `%pA' of %pB: "
+ "defined in discarded section `%pA' of %pB\n"),
sym_name, o, input_bfd, sec, sec->owner);
/* Try to do the best we can to support buggy old
if (bed->link_order_error_handler)
bed->link_order_error_handler
/* xgettext:c-format */
- (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
+ (_("%pB: warning: sh_link not set for section `%pA'"), s->owner, s);
return 0;
}
else
if (other_sec && linkorder_sec)
_bfd_error_handler
/* xgettext:c-format */
- (_("%A has both ordered [`%A' in %B] "
- "and unordered [`%A' in %B] sections"),
+ (_("%pA has both ordered [`%pA' in %pB] "
+ "and unordered [`%pA' in %pB] sections"),
o, linkorder_sec, linkorder_sec->owner,
other_sec, other_sec->owner);
else
_bfd_error_handler
- (_("%A has both ordered and unordered sections"), o);
+ (_("%pA 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"),
+ _bfd_error_handler (_("%pB: no symbol found for import library"),
implib_bfd);
goto free_sym_buf;
}
bfd_set_error (bfd_error_wrong_format);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: file class %s incompatible with %s"),
+ (_("%pB: 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"),
+ _bfd_error_handler (_("%pB: failed to generate import library"),
info->out_implib_bfd);
return FALSE;
}
h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
if (h == NULL)
{
- info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
+ info->callbacks->einfo (_("%F%P: corrupt input: %pB\n"),
sec->owner);
return NULL;
}
if (info->print_gc_sections && o->size != 0)
/* xgettext:c-format */
- _bfd_error_handler (_("Removing unused section '%A' in file '%B'"),
+ _bfd_error_handler (_("Removing unused section '%pA' in file '%pB'"),
o, sub);
}
}
}
/* xgettext:c-format */
- _bfd_error_handler (_("%B: %A+%#Lx: No symbol found for INHERIT"),
+ _bfd_error_handler (_("%pB: %pA+%#Lx: No symbol found for INHERIT"),
abfd, sec, offset);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
if (stub_entry == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, 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 "
+ (_("%pB: error: Erratum 835769 stub out "
"of range (input file too large)"), abfd);
target = stub_entry->target_value;
abfd = stub_entry->target_section->owner;
if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc))
_bfd_error_handler
- (_("%B: error: Erratum 843419 stub out "
+ (_("%pB: error: Erratum 843419 stub out "
"of range (input file too large)"), abfd);
branch_insn = 0x14000000;
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd, input_section, rel->r_offset, howto->name, name);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against STT_GNU_IFUNC "
+ (_("%pB: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't handled by %s"), input_bfd,
howto->name, name, __FUNCTION__);
bfd_set_error (bfd_error_bad_value);
sym, NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against STT_GNU_IFUNC "
+ (_("%pB: relocation %s against STT_GNU_IFUNC "
"symbol `%s' has non-zero addend: %Ld"),
input_bfd, howto->name, name, rel->r_addend);
bfd_set_error (bfd_error_bad_value);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against symbol `%s' which may bind "
+ (_("%pB: relocation %s against symbol `%s' which may bind "
"externally can not be used when making a shared object; "
"recompile with -fPIC"),
input_bfd, elfNN_aarch64_howto_table[howto_index].name,
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Local symbol descriptor table be NULL when applying "
+ (_("%pB: Local symbol descriptor table be NULL when applying "
"relocation %s against local symbol"),
input_bfd, elfNN_aarch64_howto_table[howto_index].name);
abort ();
_bfd_error_handler
((sym_type == STT_TLS
/* xgettext:c-format */
- ? _("%B(%A+%#Lx): %s used with TLS symbol %s")
+ ? _("%pB(%pA+%#Lx): %s used with TLS symbol %s")
/* xgettext:c-format */
- : _("%B(%A+%#Lx): %s used with non-TLS symbol %s")),
+ : _("%pB(%pA+%#Lx): %s used with non-TLS symbol %s")),
input_bfd,
input_section, rel->r_offset, howto->name, name);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd, input_section, rel->r_offset, howto->name,
h->root.root.string);
return FALSE;
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"), abfd, r_symndx);
+ _bfd_error_handler (_("%pB: bad symbol index: %d"), abfd, r_symndx);
return FALSE;
}
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against `%s' can not be used when making "
+ (_("%pB: relocation %s against `%s' can not be used when making "
"a shared object"),
abfd, elfNN_aarch64_howto_table[howto_index].name,
(h) ? h->root.root.string : "a local symbol");
int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against `%s' can not be used when making "
+ (_("%pB: relocation %s against `%s' can not be used when making "
"a shared object; recompile with -fPIC"),
abfd, elfNN_aarch64_howto_table[howto_index].name,
(h) ? h->root.root.string : "a local symbol");
0, &sym))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B symbol number %lu references"
+ _bfd_error_handler (_("%pB symbol number %lu references"
" nonexistent SHT_SYMTAB_SHNDX section"),
abfd, r_symndx);
/* Ideally an error class should be returned here. */
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if (bfd_is_abs_section (htab->root.sgotplt->output_section))
{
_bfd_error_handler
- (_("discarded output section: `%A'"), htab->root.sgotplt);
+ (_("discarded output section: `%pA'"), htab->root.sgotplt);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't relax br at %#Lx in section `%A'."
+ (_("%pB: Can't relax br at %#Lx in section `%pA'."
" Please use brl or indirect branch."),
sec->owner, roff, sec);
bfd_set_error (bfd_error_bad_value);
overflow:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: short data segment overflowed (%#Lx >= 0x400000)"),
+ (_("%pB: short data segment overflowed (%#Lx >= 0x400000)"),
abfd, max_short_vma - min_short_vma);
return FALSE;
}
&& max_short_vma - gp_val >= 0x200000))
{
_bfd_error_handler
- (_("%B: __gp does not cover short data segment"), abfd);
+ (_("%pB: __gp does not cover short data segment"), abfd);
return FALSE;
}
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unknown relocation type %d"), input_bfd, (int) r_type);
+ (_("%pB: unknown relocation type %d"), input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret_val = FALSE;
continue;
shared libraries nor dynamic executables. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
+ (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: @gprel relocation against dynamic symbol %s"),
+ (_("%pB: @gprel relocation against dynamic symbol %s"),
input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
/* ??? People shouldn't be doing non-pic code in
shared libraries. Hork. */
_bfd_error_handler
- (_("%B: linking non-pic code in a position independent executable"),
+ (_("%pB: linking non-pic code in a position independent executable"),
input_bfd);
ret_val = FALSE;
continue;
if (r_type == R_IA64_PCREL21BI)
/* xgettext:c-format */
- msg = _("%B: @internal branch to dynamic symbol %s");
+ msg = _("%pB: @internal branch to dynamic symbol %s");
else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
/* xgettext:c-format */
- msg = _("%B: speculation fixup to dynamic symbol %s");
+ msg = _("%pB: speculation fixup to dynamic symbol %s");
else
/* xgettext:c-format */
- msg = _("%B: @pcrel relocation against dynamic symbol %s");
+ msg = _("%pB: @pcrel relocation against dynamic symbol %s");
_bfd_error_handler (msg, input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd,
case R_IA64_LTOFF_DTPREL22:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: missing TLS section for relocation %s against `%s'"
- " at %#Lx in section `%A'."),
+ (_("%pB: missing TLS section for relocation %s against `%s'"
+ " at %#Lx in section `%pA'."),
input_bfd, howto->name, name,
rel->r_offset, input_section);
break;
that the section is too big to relax. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't relax br (%s) to `%s' at %#Lx"
- " in section `%A' with size %#Lx (> 0x1000000)."),
+ (_("%pB: Can't relax br (%s) to `%s' at %#Lx"
+ " in section `%pA' with size %#Lx (> 0x1000000)."),
input_bfd, howto->name, name, rel->r_offset,
input_section, input_section->size);
break;
if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
{
_bfd_error_handler
- (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
+ (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
{
_bfd_error_handler
- (_("%B: linking big-endian files with little-endian files"),
+ (_("%pB: linking big-endian files with little-endian files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
{
_bfd_error_handler
- (_("%B: linking 64-bit files with 32-bit files"),
+ (_("%pB: linking 64-bit files with 32-bit files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
{
_bfd_error_handler
- (_("%B: linking constant-gp files with non-constant-gp files"),
+ (_("%pB: linking constant-gp files with non-constant-gp files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
!= (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
{
_bfd_error_handler
- (_("%B: linking auto-pic files with non-auto-pic files"),
+ (_("%pB: linking auto-pic files with non-auto-pic files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))
{
(*_bfd_error_handler)
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
}
bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h)
{
(*_bfd_error_handler)
- (_("%B: relocation %s against `%s' can not be used when making a shared "
+ (_("%pB: relocation %s against `%s' can not be used when making a shared "
"object; recompile with -fPIC"),
abfd, riscv_elf_rtype_to_howto (r_type)->name,
h != NULL ? h->root.root.string : "a local symbol");
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
+ (*_bfd_error_handler) (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
rel->r_offset) != (bfd_vma) -1)
{
(*_bfd_error_handler)
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
if (bfd_is_abs_section (output_section))
{
(*_bfd_error_handler)
- (_("discarded output section: `%A'"), htab->elf.sgotplt);
+ (_("discarded output section: `%pA'"), htab->elf.sgotplt);
return FALSE;
}
if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
{
(*_bfd_error_handler)
- (_("%B: ABI is incompatible with that of the selected emulation:\n"
+ (_("%pB: ABI is incompatible with that of the selected emulation:\n"
" target emulation `%s' does not match `%s'"),
ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
return FALSE;
if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
{
(*_bfd_error_handler)
- (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
+ (_("%pB: can't link hard-float modules with soft-float modules"), ibfd);
goto fail;
}
if (rel->r_addend < nop_bytes)
{
(*_bfd_error_handler)
- (_("%B(%A+0x%lx): %d bytes required for alignment "
+ (_("%pB(%pA+0x%lx): %d bytes required for alignment "
"to %d-byte boundary, but only %d present"),
abfd, sym_sec, rel->r_offset, nop_bytes, alignment, rel->r_addend);
bfd_set_error (bfd_error_bad_value);
sym_sec = hi_reloc.sym_sec;
if (!riscv_use_pcgp_hi_reloc(pcgp_relocs, hi->hi_sec_off))
(*_bfd_error_handler)
- (_("%B(%A+0x%lx): Unable to clear RISCV_PCREL_HI20 reloc"
+ (_("%pB(%pA+0x%lx): Unable to clear RISCV_PCREL_HI20 reloc"
"for cooresponding RISCV_PCREL_LO12 reloc"),
abfd, sec, rel->r_offset);
}
if (hdr->sh_size != sizeof (Elf32_External_RegInfo))
{
_bfd_error_handler
- (_("%B: Incorrect `.reginfo' section size; expected %Lu, got %Lu"),
+ (_("%pB: Incorrect `.reginfo' section size; expected %Lu, got %Lu"),
abfd, (bfd_size_type) sizeof (Elf32_External_RegInfo),
hdr->sh_size);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Warning: bad `%s' option size %u smaller than"
+ (_("%pB: Warning: bad `%s' option size %u smaller than"
" its header"),
abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Warning: bad `%s' option size %u smaller than"
+ (_("%pB: Warning: bad `%s' option size %u smaller than"
" its header"),
abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Warning: cannot determine the target function for"
+ (_("%pB: Warning: cannot determine the target function for"
" stub section `%s'"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Warning: cannot determine the target function for"
+ (_("%pB: Warning: cannot determine the target function for"
" stub section `%s'"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Malformed reloc detected for section %s"),
+ (_("%pB: Malformed reloc detected for section %s"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: GOT reloc at %#Lx not expected in executables"),
+ (_("%pB: GOT reloc at %#Lx not expected in executables"),
abfd, rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: CALL16 reloc at %#Lx not against global symbol"),
+ (_("%pB: CALL16 reloc at %#Lx not against global symbol"),
abfd, rel->r_offset);
bfd_set_error (bfd_error_bad_value);
return FALSE;
howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against `%s' can not be used"
+ (_("%pB: 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");
sec);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't find matching LO16 reloc against `%s'"
- " for %s at %#Lx in section `%A'"),
+ (_("%pB: Can't find matching LO16 reloc against `%s'"
+ " for %s at %#Lx in section `%pA'"),
input_bfd, name,
howto->name, rel->r_offset, input_section);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%A' offset of %Ld from `%A' "
+ (_("%pB: `%pA' offset of %Ld from `%pA' "
"beyond the range of ADDIUPC"),
output_bfd,
htab->root.sgotplt->output_section,
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%A' offset of %Ld from `%A' beyond the range of ADDIUPC"),
+ (_("%pB: `%pA' offset of %Ld from `%pA' beyond the range of ADDIUPC"),
output_bfd,
htab->root.sgotplt->output_section,
gotpc_offset,
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Unknown architecture %s"),
+ (_("%pB: Unknown architecture %s"),
abfd, bfd_printable_name (abfd));
}
if (o->size != sizeof (Elf32_External_RegInfo))
{
_bfd_error_handler
- (_("%B: .reginfo section size should be %d bytes, "
+ (_("%pB: .reginfo section size should be %d bytes, "
"actual size is %d"),
abfd, sizeof (Elf32_External_RegInfo), o->size);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: illegal section name `%A'"), abfd, o);
+ (_("%pB: illegal section name `%pA'"), abfd, o);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
}
!= ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
{
_bfd_error_handler
- (_("%B: warning: linking abicalls files with non-abicalls files"),
+ (_("%pB: warning: linking abicalls files with non-abicalls files"),
ibfd);
ok = TRUE;
}
if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
{
_bfd_error_handler
- (_("%B: linking 32-bit code with 64-bit code"),
+ (_("%pB: linking 32-bit code with 64-bit code"),
ibfd);
ok = FALSE;
}
/* The ISAs aren't compatible. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: linking %s module with previous %s modules"),
+ (_("%pB: linking %s module with previous %s modules"),
ibfd,
bfd_printable_name (ibfd),
bfd_printable_name (obfd));
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: ABI mismatch: linking %s module with previous %s modules"),
+ (_("%pB: ABI mismatch: linking %s module with previous %s modules"),
ibfd,
elf_mips_abi_name (ibfd),
elf_mips_abi_name (obfd));
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: ASE mismatch: linking %s module with previous %s modules"),
+ (_("%pB: ASE mismatch: linking %s module with previous %s modules"),
ibfd,
m16_mis ? "MIPS16" : "microMIPS",
m16_mis ? "microMIPS" : "MIPS16");
if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
+ _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
ibfd,
(new_flags & EF_MIPS_NAN2008
? "-mnan=2008" : "-mnan=legacy"),
if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
+ _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
ibfd,
(new_flags & EF_MIPS_FP64
? "-mfp64" : "-mfp32"),
{
/* xgettext:c-format */
_bfd_error_handler
- (_("%B: uses different e_flags (%#x) fields than previous modules "
+ (_("%pB: uses different e_flags (%#x) fields than previous modules "
"(%#x)"),
ibfd, new_flags, old_flags);
ok = FALSE;
if (!out_string && !in_string)
/* xgettext:c-format */
_bfd_error_handler
- (_("Warning: %B uses unknown floating point ABI %d "
- "(set by %B), %B uses unknown floating point ABI %d"),
+ (_("Warning: %pB uses unknown floating point ABI %d "
+ "(set by %pB), %pB uses unknown floating point ABI %d"),
obfd, out_fp, abi_fp_bfd, ibfd, in_fp);
else if (!out_string)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses unknown floating point ABI %d "
- "(set by %B), %B uses %s"),
+ (_("Warning: %pB uses unknown floating point ABI %d "
+ "(set by %pB), %pB uses %s"),
obfd, out_fp, abi_fp_bfd, ibfd, in_string);
else if (!in_string)
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses %s (set by %B), "
- "%B uses unknown floating point ABI %d"),
+ (_("Warning: %pB uses %s (set by %pB), "
+ "%pB uses unknown floating point ABI %d"),
obfd, out_string, abi_fp_bfd, ibfd, in_fp);
else
{
in_string = "-mhard-float";
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses %s (set by %B), %B uses %s"),
+ (_("Warning: %pB uses %s (set by %pB), %pB uses %s"),
obfd, out_string, abi_fp_bfd, ibfd, in_string);
}
}
case Val_GNU_MIPS_ABI_MSA_128:
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses %s (set by %B), "
- "%B uses unknown MSA ABI %d"),
+ (_("Warning: %pB uses %s (set by %pB), "
+ "%pB uses unknown MSA ABI %d"),
obfd, "-mmsa", abi_msa_bfd,
ibfd, in_attr[Tag_GNU_MIPS_ABI_MSA].i);
break;
case Val_GNU_MIPS_ABI_MSA_128:
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses unknown MSA ABI %d "
- "(set by %B), %B uses %s"),
+ (_("Warning: %pB uses unknown MSA ABI %d "
+ "(set by %pB), %pB uses %s"),
obfd, out_attr[Tag_GNU_MIPS_ABI_MSA].i,
abi_msa_bfd, ibfd, "-mmsa");
break;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("Warning: %B uses unknown MSA ABI %d "
- "(set by %B), %B uses unknown MSA ABI %d"),
+ (_("Warning: %pB uses unknown MSA ABI %d "
+ "(set by %pB), %pB uses unknown MSA ABI %d"),
obfd, out_attr[Tag_GNU_MIPS_ABI_MSA].i,
abi_msa_bfd, ibfd, in_attr[Tag_GNU_MIPS_ABI_MSA].i);
break;
if (! _bfd_generic_verify_endian_match (ibfd, info))
{
_bfd_error_handler
- (_("%B: endianness incompatible with that of the selected emulation"),
+ (_("%pB: 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
- (_("%B: ABI is incompatible with that of the selected emulation"),
+ (_("%pB: 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
- (_("%B: warning: Inconsistent ISA between e_flags and "
+ (_("%pB: 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
- (_("%B: warning: Inconsistent FP ABI between .gnu.attributes and "
+ (_("%pB: warning: Inconsistent FP ABI between .gnu.attributes and "
".MIPS.abiflags"), ibfd);
if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
_bfd_error_handler
- (_("%B: warning: Inconsistent ASEs between e_flags and "
+ (_("%pB: 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
- (_("%B: warning: Inconsistent ISA extensions between e_flags and "
+ (_("%pB: warning: Inconsistent ISA extensions between e_flags and "
".MIPS.abiflags"), ibfd);
if (in_abiflags.flags2 != 0)
_bfd_error_handler
- (_("%B: warning: Unexpected flag in the flags2 field of "
+ (_("%pB: warning: Unexpected flag in the flags2 field of "
".MIPS.abiflags (0x%lx)"), ibfd,
in_abiflags.flags2);
}
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"), abfd, r_symndx);
+ _bfd_error_handler (_("%pB: bad symbol index: %d"), abfd, r_symndx);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
{
info->flags |= DF_TEXTREL;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
}
NULL);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s against STT_GNU_IFUNC "
+ (_("%pB: relocation %s against STT_GNU_IFUNC "
"symbol `%s' isn't handled by %s"), input_bfd,
_bfd_sparc_elf_howto_table[r_type].name,
name, __FUNCTION__);
{
BFD_FAIL ();
_bfd_error_handler
- (_("%B: probably compiled without -fPIC?"),
+ (_("%pB: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
rel->r_offset) != (bfd_vma) -1)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: bad symbol index: %d"),
+ _bfd_error_handler (_("%pB: bad symbol index: %d"),
abfd, r_symndx);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' accessed both as normal and thread local symbol"),
+ (_("%pB: `%s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
return FALSE;
}
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ (_("%pB: dynamic relocation against `%T' in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
{
info->flags |= DF_TEXTREL;
- info->callbacks->minfo (_("%B: dynamic relocation in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
}
{
BFD_FAIL ();
_bfd_error_handler
- (_("%B: probably compiled without -fPIC?"),
+ (_("%pB: probably compiled without -fPIC?"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
rel->r_offset) != (bfd_vma) -1)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#Lx): unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
rel->r_offset,
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
_bfd_error_handler
- (_("discarded output section: `%A'"), htab->elf.sgotplt);
+ (_("discarded output section: `%pA'"), htab->elf.sgotplt);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Cannot link together %s and %s objects."),
+ (_("%pB: Cannot link together %s and %s objects."),
ibfd, targ1, targ2);
bfd_set_error (bfd_error_bad_value);
return FALSE;
info->flags |= DF_TEXTREL;
/* xgettext:c-format */
- info->callbacks->minfo (_("%B: dynamic relocation against `%T' "
- "in read-only section `%A'\n"),
+ info->callbacks->minfo (_("%pB: dynamic relocation against `%T' "
+ "in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
if ((info->warn_shared_textrel && bfd_link_pic (info))
|| info->error_textrel)
/* xgettext:c-format */
- info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' "
- "in read-only section `%A'\n"),
+ info->callbacks->einfo (_("%P: %pB: warning: relocation against `%s' "
+ "in read-only section `%pA'\n"),
sec->owner, h->root.root.string, sec);
/* Not an error, just cut short the traversal. */
|| info->error_textrel)
/* xgettext:c-format */
info->callbacks->einfo
- (_("%P: %B: warning: relocation "
- "in read-only section `%A'\n"),
+ (_("%P: %pB: warning: relocation "
+ "in read-only section `%pA'\n"),
p->sec->owner, p->sec);
}
}
if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
{
_bfd_error_handler
- (_("discarded output section: `%A'"), htab->elf.sgotplt);
+ (_("discarded output section: `%pA'"), htab->elf.sgotplt);
return NULL;
}
{
_bfd_error_handler
((type == GNU_PROPERTY_X86_ISA_1_USED
- ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
+ ? _("error: %pB: <corrupt x86 ISA used size: 0x%x>")
: (type == GNU_PROPERTY_X86_ISA_1_NEEDED
- ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
- : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
+ ? _("error: %pB: <corrupt x86 ISA needed size: 0x%x>")
+ : _("error: %pB: <corrupt x86 feature size: 0x%x>"))),
abfd, datasz);
return property_corrupt;
}
if (!bfd_set_section_alignment (ebfd, sec, class_align))
{
error_alignment:
- info->callbacks->einfo (_("%F%A: failed to align section\n"),
+ info->callbacks->einfo (_("%F%pA: failed to align section\n"),
sec);
}
*/
if ((unknown_sections > 0) && (good_sections > 0))
_bfd_error_handler
- ("%B appears to be a core file,\nbut contains unknown sections."
+ ("%pB 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);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: string too long (%ld chars, max 65535)"), abfd, (long) length);
+ (_("%pB: string too long (%ld chars, max 65535)"), abfd, (long) length);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unrecognized symbol `%s' flags 0x%x"),
+ (_("%pB: unrecognized symbol `%s' flags 0x%x"),
abfd, bfd_asymbol_name (symbol), symbol->flags);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unimplemented ATI record %u for symbol %u"),
+ (_("%pB: unimplemented ATI record %u for symbol %u"),
abfd, symbol_attribute_def, symbol_name_index);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unexpected ATN type %Ld in external part"),
+ (_("%pB: unexpected ATN type %Ld in external part"),
abfd, value);
bfd_set_error (bfd_error_bad_value);
return FALSE;
default:
_bfd_error_handler
- (_("%B: unexpected type after ATN"), abfd);
+ (_("%pB: unexpected type after ATN"), abfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%d: unexpected character `%s' in Intel Hex file"),
+ (_("%pB:%d: unexpected character `%s' in Intel Hex file"),
abfd, lineno, buf);
bfd_set_error (bfd_error_bad_value);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
+ (_("%pB:%u: bad checksum in Intel Hex file (expected %u, found %u)"),
abfd, lineno,
(- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i));
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%u: bad extended address record length in Intel Hex file"),
+ (_("%pB:%u: bad extended address record length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%u: bad extended start address length in Intel Hex file"),
+ (_("%pB:%u: bad extended start address length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%u: bad extended linear address record length in Intel Hex file"),
+ (_("%pB:%u: bad extended linear address record length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%u: bad extended linear start address length in Intel Hex file"),
+ (_("%pB:%u: bad extended linear start address length in Intel Hex file"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%u: unrecognized ihex type %u in Intel Hex file"),
+ (_("%pB:%u: unrecognized ihex type %u in Intel Hex file"),
abfd, lineno, type);
bfd_set_error (bfd_error_bad_value);
goto error_return;
if (type != 0)
{
_bfd_error_handler
- (_("%B: internal error in ihex_read_section"), abfd);
+ (_("%pB: 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
- (_("%B: bad section length in ihex_read_section"), abfd);
+ (_("%pB: bad section length in ihex_read_section"), abfd);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: address %#Lx out of range for Intel Hex file"),
+ (_("%pB: address %#Lx out of range for Intel Hex file"),
abfd, where);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unable to get decompressed section %A"),
+ (_("%pB: unable to get decompressed section %pA"),
abfd, section);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
&& name[1] == '_'
&& strcmp (name + (name[2] == '_'), "__gnu_lto_slim") == 0)
_bfd_error_handler
- (_("%B: plugin needed to handle lto object"), abfd);
+ (_("%pB: plugin needed to handle lto object"), abfd);
}
else
row = DEF_ROW;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: indirect symbol `%s' to `%s' is a loop"),
+ (_("%pB: indirect symbol `%s' to `%s' is a loop"),
abfd, name, string);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
case SEC_LINK_DUPLICATES_ONE_ONLY:
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: ignoring duplicate section `%A'\n"),
+ (_("%pB: ignoring duplicate section `%pA'\n"),
sec->owner, sec);
break;
else if (sec->size != l->sec->size)
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: duplicate section `%A' has different size\n"),
+ (_("%pB: duplicate section `%pA' has different size\n"),
sec->owner, sec);
break;
else if (sec->size != l->sec->size)
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: duplicate section `%A' has different size\n"),
+ (_("%pB: duplicate section `%pA' has different size\n"),
sec->owner, sec);
else if (sec->size != 0)
{
if (!bfd_malloc_and_get_section (sec->owner, sec, &sec_contents))
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: could not read contents of section `%A'\n"),
+ (_("%pB: could not read contents of section `%pA'\n"),
sec->owner, sec);
else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec,
&l_sec_contents))
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: could not read contents of section `%A'\n"),
+ (_("%pB: could not read contents of section `%pA'\n"),
l->sec->owner, l->sec);
else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0)
info->callbacks->einfo
/* xgettext:c-format */
- (_("%B: duplicate section `%A' has different contents\n"),
+ (_("%pB: duplicate section `%pA' has different contents\n"),
sec->owner, sec);
if (sec_contents)
&& obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
{
if (bfd_big_endian (ibfd))
- _bfd_error_handler (_("%B: compiled for a big endian system "
+ _bfd_error_handler (_("%pB: compiled for a big endian system "
"and target is little endian"), ibfd);
else
- _bfd_error_handler (_("%B: compiled for a little endian system "
+ _bfd_error_handler (_("%pB: compiled for a little endian system "
"and target is big endian"), ibfd);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
break;
default:
command->len = 0;
- _bfd_error_handler (_("%B: unknown load command %#x"),
+ _bfd_error_handler (_("%pB: unknown load command %#x"),
abfd, command->type);
return FALSE;
}
if (offset > sec->rawsize)
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: access beyond end of merged section (%Ld)"),
+ (_("%pB: access beyond end of merged section (%Ld)"),
sec->owner, offset);
return secinfo->first_str ? sec->size : 0;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: No core to allocate section name %s\n"),
+ (_("%pB: No core to allocate section name %s\n"),
abfd, secname);
bfd_set_error (bfd_error_system_call);
return NULL;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: No core to allocate a symbol %d bytes long\n"),
+ (_("%pB: No core to allocate a symbol %d bytes long\n"),
abfd, abfd->tdata.mmo_data->max_symbol_length);
goto bad_final;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: attempt to emit contents at non-multiple-of-4"
+ (_("%pB: attempt to emit contents at non-multiple-of-4"
" address %#Lx"),
abfd, vma);
bfd_set_error (bfd_error_bad_value);
&& !mmo_ignore_symbol_consistency (abfd))
{
_bfd_error_handler
- (_("%B: invalid mmo file: initialization value for $255"
+ (_("%pB: invalid mmo file: initialization value for $255"
" is not `Main'\n"),
abfd);
bfd_set_error (bfd_error_bad_value);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: unsupported wide character sequence"
+ (_("%pB: unsupported wide character sequence"
" 0x%02X 0x%02X after symbol name starting with `%s'\n"),
abfd, c, c2, abfd->tdata.mmo_data->lop_stab_symbol);
bfd_set_error (bfd_error_bad_value);
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: unsupported lopcode `%d'\n"),
+ (_("%pB: invalid mmo file: unsupported lopcode `%d'\n"),
abfd, buf[1]);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: expected YZ = 1"
+ (_("%pB: invalid mmo file: expected YZ = 1"
" got YZ = %d for lop_quote\n"),
abfd, y*256+z);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: expected z = 1 or z = 2,"
+ (_("%pB: invalid mmo file: expected z = 1 or z = 2,"
" got z = %d for lop_loc\n"),
abfd, z);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: expected z = 1 or z = 2,"
+ (_("%pB: invalid mmo file: expected z = 1 or z = 2,"
" got z = %d for lop_fixo\n"),
abfd, z);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: expected y = 0,"
+ (_("%pB: invalid mmo file: expected y = 0,"
" got y = %d for lop_fixrx\n"),
abfd, y);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: expected z = 16 or z = 24,"
+ (_("%pB: invalid mmo file: expected z = 16 or z = 24,"
" got z = %d for lop_fixrx\n"),
abfd, z);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: leading byte of operand word"
+ (_("%pB: invalid mmo file: leading byte of operand word"
" must be 0 or 1, got %d for lop_fixrx\n"),
abfd, buf[0]);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: cannot allocate file name for file number %d,"
+ (_("%pB: cannot allocate file name for file number %d,"
" %d bytes\n"),
abfd, y, z * 4 + 1);
bfd_set_error (bfd_error_system_call);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: file number %d `%s',"
+ (_("%pB: invalid mmo file: file number %d `%s',"
" was already entered as `%s'\n"),
abfd, y, fname, file_names[y]);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: file name for number %d"
+ (_("%pB: invalid mmo file: file name for number %d"
" was not specified before use\n"),
abfd, y);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: fields y and z of lop_stab"
+ (_("%pB: invalid mmo file: fields y and z of lop_stab"
" non-zero, y: %d, z: %d\n"),
abfd, y, z);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: lop_end not last item in"
+ (_("%pB: invalid mmo file: lop_end not last item in"
" file\n"),
abfd);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid mmo file: YZ of lop_end (%ld)"
+ (_("%pB: invalid mmo file: YZ of lop_end (%ld)"
" not equal to the number of tetras to the preceding"
" lop_stab (%ld)\n"),
abfd, (long) (y * 256 + z),
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid symbol table: duplicate symbol `%s'\n"),
+ (_("%pB: invalid symbol table: duplicate symbol `%s'\n"),
abfd, trie->sym.name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Bad symbol definition: `Main' set to %s rather"
+ (_("%pB: Bad symbol definition: `Main' set to %s rather"
" than the start address %s\n"),
abfd, vmas_main, vmas_start);
bfd_set_error (bfd_error_bad_value);
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: warning: symbol table too large for mmo, larger than 65535"
+ (_("%pB: warning: symbol table too large for mmo, larger than 65535"
" 32-bit words: %d. Only `Main' will be emitted.\n"),
abfd, trie_len);
diagnostic and fail "normally". */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: internal error, symbol table changed size from %d to %d"
+ (_("%pB: internal error, symbol table changed size from %d to %d"
" words\n"),
abfd, trie_len,
(abfd->tdata.mmo_data->byte_no + 3)/4);
this. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: internal error, internal register section %A had"
+ (_("%pB: internal error, internal register section %pA had"
" contents\n"),
abfd, sec);
bfd_set_error (bfd_error_bad_value);
if (sec->size == 0)
/* There must always be at least one such register. */
_bfd_error_handler
- (_("%B: no initialized registers; section length 0\n"),
+ (_("%pB: no initialized registers; section length 0\n"),
abfd);
else if (sec->vma > (256 - 32) * 8)
/* Provide better error message for the case of too many
global registers. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: too many initialized registers; section length %Ld"),
+ (_("%pB: too many initialized registers; section length %Ld"),
abfd, sec->size);
else
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: invalid start address for initialized registers of"
+ (_("%pB: invalid start address for initialized registers of"
" length %Ld: %#Lx"),
abfd, sec->size, sec->vma);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section `%A' in oasys"), abfd, s);
+ (_("%pB: can not represent section `%pA' in oasys"), abfd, s);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section `%A' in a.out object file format"),
+ (_("%pB: can not represent section `%pA' in a.out object file format"),
abfd, section);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
file. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section for symbol `%s' in a.out object file format"),
+ (_("%pB: 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);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: can not represent section `%A' in a.out object file format"),
+ (_("%pB: can not represent section `%pA' in a.out object file format"),
abfd, sec);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
by the reloc size. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocatable link from %s to %s not supported"),
+ (_("%pB: relocatable link from %s to %s not supported"),
abfd, sub->xvec->name, abfd->xvec->name);
bfd_set_error (bfd_error_invalid_operation);
goto error_return;
if (bfd_link_relocatable (info))
{
_bfd_error_handler
- (_("%B: `ld -r' not supported with PE MIPS objects\n"), input_bfd);
+ (_("%pB: `ld -r' not supported with PE MIPS objects\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
#define UI(x) \
/* xgettext:c-format */ \
- _bfd_error_handler (_("%B: unimplemented %s\n"), \
+ _bfd_error_handler (_("%pB: unimplemented %s\n"), \
input_bfd, x); \
bfd_set_error (bfd_error_bad_value);
targ = val + (tmp & 0x03ffffff) * 4;
if ((src & 0xf0000000) != (targ & 0xf0000000))
{
- _bfd_error_handler (_("%B: jump too far away\n"), input_bfd);
+ _bfd_error_handler (_("%pB: 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"),
+ _bfd_error_handler (_("%pB: bad pair/reflo after refhi\n"),
input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
if (name == NULL)
{
- _bfd_error_handler (_("%B: unable to find name for empty section"),
+ _bfd_error_handler (_("%pB: unable to find name for empty section"),
abfd);
bfd_set_error (bfd_error_invalid_target);
return;
name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
if (name == NULL)
{
- _bfd_error_handler (_("%B: out of memory creating name for empty section"),
+ _bfd_error_handler (_("%pB: out of memory creating name for empty section"),
abfd);
return;
}
sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
if (sec == NULL)
{
- _bfd_error_handler (_("%B: unable to create fake empty section"),
+ _bfd_error_handler (_("%pB: unable to create fake empty section"),
abfd);
return;
}
{
/* xgettext:c-format */
_bfd_error_handler
- (_("%B: aout header specifies an invalid number of data-directory entries: %ld"),
+ (_("%pB: aout header specifies an invalid number of data-directory entries: %ld"),
abfd, a->NumberOfRvaAndSizes);
bfd_set_error (bfd_error_bad_value);
else
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: line number overflow: 0x%lx > 0xffff"),
+ _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
abfd, scnhdr_int->s_nlnno);
bfd_set_error (bfd_error_file_truncated);
H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
> bfd_get_section_size (section))
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Data Directory size (%lx) exceeds space left in section (%Lx)"),
+ _bfd_error_handler (_("%pB: Data Directory size (%lx) exceeds space left in section (%Lx)"),
obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
bfd_get_section_size (section) - (addr - section->vma));
return FALSE;
}
else if (section)
{
- _bfd_error_handler (_("%B: Failed to read debug data section"), obfd);
+ _bfd_error_handler (_("%pB: Failed to read debug data section"), obfd);
return FALSE;
}
}
if (data > dataend)
{
/* Corrupted .rsrc section - cannot merge. */
- _bfd_error_handler (_("%B: .rsrc merge failure: corrupt .rsrc section"),
+ _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
abfd);
bfd_set_error (bfd_error_file_truncated);
goto end;
if ((data - p) > rsrc_sizes [num_resource_sets])
{
- _bfd_error_handler (_("%B: .rsrc merge failure: unexpected .rsrc size"),
+ _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
abfd);
bfd_set_error (bfd_error_file_truncated);
goto end;
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
+ (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
abfd);
result = FALSE;
}
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
+ (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
abfd);
result = FALSE;
}
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
+ (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
abfd);
result = FALSE;
}
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
+ (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
abfd);
result = FALSE;
}
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
+ (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
" because .idata$6 is missing"), abfd);
result = FALSE;
}
else
{
_bfd_error_handler
- (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
+ (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
abfd);
result = FALSE;
}
case IMPORT_CONST:
/* XXX code yet to be written. */
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Unhandled import type; %x"),
+ _bfd_error_handler (_("%pB: Unhandled import type; %x"),
abfd, import_type);
return FALSE;
default:
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Unrecognised import type; %x"),
+ _bfd_error_handler (_("%pB: Unrecognised import type; %x"),
abfd, import_type);
return FALSE;
}
default:
/* xgettext:c-format */
- _bfd_error_handler (_("%B: Unrecognised import name type; %x"),
+ _bfd_error_handler (_("%pB: Unrecognised import name type; %x"),
abfd, import_name_type);
return FALSE;
}
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Unrecognised machine type (0x%x)"
+ (_("%pB: Unrecognised machine type (0x%x)"
" in Import Library Format archive"),
abfd, machine);
bfd_set_error (bfd_error_malformed_archive);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Recognised but unhandled machine type (0x%x)"
+ (_("%pB: Recognised but unhandled machine type (0x%x)"
" in Import Library Format archive"),
abfd, machine);
bfd_set_error (bfd_error_wrong_format);
if (size == 0)
{
_bfd_error_handler
- (_("%B: size field is zero in Import Library Format header"), abfd);
+ (_("%pB: size field is zero in Import Library Format header"), abfd);
bfd_set_error (bfd_error_malformed_archive);
return NULL;
|| (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size)
{
_bfd_error_handler
- (_("%B: string not null terminated in ILF object file."), abfd);
+ (_("%pB: string not null terminated in ILF object file."), abfd);
bfd_set_error (bfd_error_malformed_archive);
bfd_release (abfd, ptr);
return NULL;
if (dataoff >= section->size
|| size > section->size - dataoff)
{
- _bfd_error_handler (_("%B: Error: Debug Data ends beyond end of debug directory."),
+ _bfd_error_handler (_("%pB: Error: Debug Data ends beyond end of debug directory."),
abfd);
return;
}
{
link_info->callbacks->einfo
/* xgettext:c-format */
- (_("%X%P: %B(%A): error: relocation for offset %V has no value\n"),
+ (_("%X%P: %pB(%pA): error: relocation for offset %V has no value\n"),
abfd, input_section, (* parent)->address);
goto error_return;
}
message instead. */
link_info->callbacks->einfo
/* xgettext:c-format */
- (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
+ (_("%X%P: %pB(%pA): relocation \"%R\" goes out of range\n"),
abfd, input_section, * parent);
goto error_return;
Do not abort. Issue an error message instead. */
link_info->callbacks->einfo
/* xgettext:c-format */
- (_("%X%P: %B(%A): relocation \"%R\" is not supported\n"),
+ (_("%X%P: %pB(%pA): relocation \"%R\" is not supported\n"),
abfd, input_section, * parent);
goto error_return;
Report unexpected results, without aborting. */
link_info->callbacks->einfo
/* xgettext:c-format */
- (_("%X%P: %B(%A): relocation \"%R\" returns an unrecognized value %x\n"),
+ (_("%X%P: %pB(%pA): relocation \"%R\" returns an unrecognized value %x\n"),
abfd, input_section, * parent, r);
break;
}
_bfd_unrecognized_reloc (bfd * abfd, sec_ptr section, unsigned int r_type)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: unrecognized relocation (%#x) in section `%A'"),
+ _bfd_error_handler (_("%pB: unrecognized relocation (%#x) in section `%pA'"),
abfd, r_type, section);
/* PR 21803: Suggest the most likely cause of this error. */
/* Issue warning if the core file was truncated during writing. */
if (c_flag & CORE_TRUNC)
- _bfd_error_handler (_("%B: warning core file truncated"), abfd);
+ _bfd_error_handler (_("%pB: warning core file truncated"), abfd);
/* Allocate core file header. */
#ifndef BFD64
}
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%d: Unexpected character `%s' in S-record file\n"),
+ (_("%pB:%d: Unexpected character `%s' in S-record file\n"),
abfd, lineno, buf);
bfd_set_error (bfd_error_bad_value);
}
if (bytes < min_bytes)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B:%d: byte count %d too small\n"),
+ _bfd_error_handler (_("%pB:%d: byte count %d too small\n"),
abfd, lineno, bytes);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%d: Bad checksum in S-record file\n"),
+ (_("%pB:%d: Bad checksum in S-record file\n"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B:%d: Bad checksum in S-record file\n"),
+ (_("%pB:%d: Bad checksum in S-record file\n"),
abfd, lineno);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#lx): Stabs entry has invalid string index."),
+ (_("%pB(%pA+%#lx): Stabs entry has invalid string index."),
abfd, stabsec, (long) (sym - stabbuf));
bfd_set_error (bfd_error_bad_value);
goto error_return;
if (section->reloc_count == 0)
_bfd_error_handler
- (_("SEC_RELOC with no relocs in section %A"), section);
+ (_("SEC_RELOC with no relocs in section %pA"), section);
#if VMS_DEBUG
else
/* Regular relocs are intertwined with binary data. */
if (curr_addr > addr)
- _bfd_error_handler (_("Size error in section %A"),
+ _bfd_error_handler (_("Size error in section %pA"),
section);
size = addr - curr_addr;
sto_imm (abfd, section, size, curr_data, curr_addr);
{
/* Output rest of section. */
if (curr_addr > section->size)
- _bfd_error_handler (_("Size error in section %A"), section);
+ _bfd_error_handler (_("Size error in section %pA"), section);
size = section->size - curr_addr;
sto_imm (abfd, section, size, curr_data, curr_addr);
curr_data += size;
{
(*info->callbacks->einfo)
/* xgettext:c-format */
- (_("%P: multiple entry points: in modules %B and %B\n"),
+ (_("%P: multiple entry points: in modules %pB and %pB\n"),
startbfd, sub);
continue;
}
if (info->output_bfd->xvec != abfd->xvec)
{
_bfd_error_handler
- (_("%B: XCOFF shared object when not producing XCOFF output"),
+ (_("%pB: XCOFF shared object when not producing XCOFF output"),
abfd);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
if (lsec == NULL)
{
_bfd_error_handler
- (_("%B: dynamic object with no .loader section"),
+ (_("%pB: dynamic object with no .loader section"),
abfd);
bfd_set_error (bfd_error_no_symbols);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' has line numbers but no enclosing section"),
+ (_("%pB: `%s' has line numbers but no enclosing section"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: class %d symbol `%s' has no aux entries"),
+ (_("%pB: class %d symbol `%s' has no aux entries"),
abfd, sym.n_sclass, name);
bfd_set_error (bfd_error_bad_value);
goto error_return;
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: symbol `%s' has unrecognized csect type %d"),
+ (_("%pB: symbol `%s' has unrecognized csect type %d"),
abfd, name, smtyp);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: bad XTY_ER symbol `%s': class %d scnum %d scnlen %Ld"),
+ (_("%pB: bad XTY_ER symbol `%s': class %d scnum %d scnlen %Ld"),
abfd, name, sym.n_sclass, sym.n_scnum,
aux.x_csect.x_scnlen.l);
bfd_set_error (bfd_error_bad_value);
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: XMC_TC0 symbol `%s' is class %d scnlen %Ld"),
+ (_("%pB: XMC_TC0 symbol `%s' is class %d scnlen %Ld"),
abfd, name, sym.n_sclass, aux.x_csect.x_scnlen.l);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: csect `%s' not in enclosing section"),
+ (_("%pB: csect `%s' not in enclosing section"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: misplaced XTY_LD `%s'"),
+ (_("%pB: misplaced XTY_LD `%s'"),
abfd, name);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: reloc %s:%Ld not in csect"),
+ (_("%pB: reloc %s:%Ld not in csect"),
abfd, o->name, i);
bfd_set_error (bfd_error_bad_value);
goto error_return;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: loader reloc in unrecognized section `%s'"),
+ (_("%pB: loader reloc in unrecognized section `%s'"),
reference_bfd, secname);
bfd_set_error (bfd_error_nonrepresentable_section);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: `%s' in loader reloc but not loader sym"),
+ (_("%pB: `%s' in loader reloc but not loader sym"),
reference_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: loader reloc in read-only section %A"),
+ (_("%pB: loader reloc in read-only section %pA"),
reference_bfd, output_section);
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
+2018-02-19 Alan Modra <amodra@gmail.com>
+
+ * ldmisc.c (vfinfo): Handle %pA and %pB in place of %A and %B.
+ * ldcref.c: Update all messages using %A and %B.
+ * ldexp.c: Likewise.
+ * ldlang.c: Likewise.
+ * ldmain.c: Likewise.
+ * ldmisc.c: Likewise.
+ * pe-dll.c: Likewise.
+ * plugin.c: Likewise.
+ * emultempl/beos.em: Likewise.
+ * emultempl/cr16elf.em: Likewise.
+ * emultempl/elf32.em: Likewise.
+ * emultempl/m68kcoff.em: Likewise.
+ * emultempl/m68kelf.em: Likewise.
+ * emultempl/mmo.em: Likewise.
+ * emultempl/nds32elf.em: Likewise.
+ * emultempl/pe.em: Likewise.
+ * emultempl/pep.em: Likewise.
+ * emultempl/spuelf.em: Likewise.
+ * emultempl/sunos.em: Likewise.
+ * emultempl/xtensaelf.em: Likewise.
+
2018-02-19 H.J. Lu <hongjiu.lu@intel.com>
PR ld/22845
(*ra)->input_section.section, &a_sec,
(file_ptr) 0,
(bfd_size_type) sizeof(a_sec)))
- einfo (_("%F%B: Can't read contents of section .idata: %E\n"),
+ einfo (_("%F%pB: Can't read contents of section .idata: %E\n"),
(*ra)->input_section.section->owner);
if (!bfd_get_section_contents ((*rb)->input_section.section->owner,
(*rb)->input_section.section, &b_sec,
(file_ptr) 0,
(bfd_size_type) sizeof(b_sec)))
- einfo (_("%F%B: Can't read contents of section .idata: %E\n"),
+ einfo (_("%F%pB: Can't read contents of section .idata: %E\n"),
(*rb)->input_section.section->owner);
i = a_sec < b_sec ? -1 : 0;
COFF and ELF. */
if (bfd_get_flavour (abfd) != bfd_target_coff_flavour
&& bfd_get_flavour (abfd) != bfd_target_elf_flavour)
- einfo (_("%F%B: all input objects must be COFF or ELF "
+ einfo (_("%F%pB: all input objects must be COFF or ELF "
"for --embedded-relocs\n"));
datasec = bfd_get_section_by_name (abfd, ".data.rel");
|| ! bfd_set_section_alignment (abfd, relsec, 2)
|| ! bfd_set_section_size (abfd, relsec,
datasec->reloc_count * 8))
- einfo (_("%F%B: can not create .emreloc section: %E\n"));
+ einfo (_("%F%pB: can not create .emreloc section: %E\n"));
}
/* Double check that all other data sections are empty, as is
if ((strncmp (bfd_get_section_name (abfd, sec), ".data.rel", 9) == 0)
&& sec != datasec
&& sec->reloc_count == 0 )
- einfo (_("%B%X: section %s has relocs; can not use --embedded-relocs\n"),
+ einfo (_("%pB%X: section %s has relocs; can not use --embedded-relocs\n"),
abfd, bfd_get_section_name (abfd, sec));
}
&errmsg))
{
if (errmsg == NULL)
- einfo (_("%B%X: can not create runtime reloc information: %E\n"),
+ einfo (_("%pB%X: can not create runtime reloc information: %E\n"),
abfd);
else
- einfo (_("%X%B: can not create runtime reloc information: %s\n"),
+ einfo (_("%X%pB: can not create runtime reloc information: %s\n"),
abfd, errmsg);
}
}
if (entry->flags.just_syms
&& (bfd_get_file_flags (entry->the_bfd) & DYNAMIC) != 0)
- einfo (_("%P%F: --just-symbols may not be used on DSO: %B\n"),
+ einfo (_("%P%F: --just-symbols may not be used on DSO: %pB\n"),
entry->the_bfd);
if (link_class == 0
if (bfd_stat (s->the_bfd, &st) != 0)
{
- einfo (_("%P:%B: bfd_stat failed: %E\n"), s->the_bfd);
+ einfo (_("%P:%pB: bfd_stat failed: %E\n"), s->the_bfd);
return;
}
soname = lbasename (s->filename);
if (filename_ncmp (soname, global_needed->name, suffix - global_needed->name) == 0)
- einfo (_("%P: warning: %s, needed by %B, may conflict with %s\n"),
+ einfo (_("%P: warning: %s, needed by %pB, may conflict with %s\n"),
global_needed->name, global_needed->by, soname);
}
struct bfd_link_needed_list *needs;
if (! bfd_elf_get_bfd_needed_list (abfd, &needs))
- einfo (_("%F%P:%B: bfd_elf_get_bfd_needed_list failed: %E\n"), abfd);
+ einfo (_("%F%P:%pB: bfd_elf_get_bfd_needed_list failed: %E\n"), abfd);
if (needs != NULL)
{
can only check that using stat. */
if (bfd_stat (abfd, &global_stat) != 0)
- einfo (_("%F%P:%B: bfd_stat failed: %E\n"), abfd);
+ einfo (_("%F%P:%pB: bfd_stat failed: %E\n"), abfd);
/* First strip off everything before the last '/'. */
soname = lbasename (abfd->filename);
/* Add this file into the symbol table. */
if (! bfd_link_add_symbols (abfd, &link_info))
- einfo (_("%F%B: error adding symbols: %E\n"), abfd);
+ einfo (_("%F%pB: error adding symbols: %E\n"), abfd);
return TRUE;
}
else if (seen_type != type)
{
einfo (_("%P%F: compact frame descriptions incompatible with"
- " DWARF2 .eh_frame from %B\n"),
+ " DWARF2 .eh_frame from %pB\n"),
type == DWARF2_EH_HDR ? abfd : elfbfd);
break;
}
n.name = l->name;
nn.by = l->by;
if (verbose)
- info_msg (_("%s needed by %B\n"), l->name, l->by);
+ info_msg (_("%s needed by %pB\n"), l->name, l->by);
/* As-needed libs specified on the command line (or linker script)
take priority over libs found in search dirs. */
if (force < 2)
continue;
- einfo (_("%P: warning: %s, needed by %B, not found "
+ einfo (_("%P: warning: %s, needed by %pB, not found "
"(try using -rpath or -rpath-link)\n"),
l->name, l->by);
}
msg = (char *) xmalloc ((size_t) (sz + 1));
if (! bfd_get_section_contents (is->the_bfd, s, msg,
(file_ptr) 0, sz))
- einfo (_("%F%B: Can't read contents of section .gnu.warning: %E\n"),
+ einfo (_("%F%pB: Can't read contents of section .gnu.warning: %E\n"),
is->the_bfd);
msg[sz] = '\0';
(*link_info.callbacks->warning) (&link_info, msg,
/* As first-order business, make sure that each input BFD is COFF. It
better be, as we are directly calling a COFF backend function. */
if (bfd_get_flavour (abfd) != bfd_target_coff_flavour)
- einfo (_("%F%B: all input objects must be COFF "
+ einfo (_("%F%pB: all input objects must be COFF "
"for --embedded-relocs\n"));
datasec = bfd_get_section_by_name (abfd, ".data");
|| ! bfd_set_section_alignment (abfd, relsec, 2)
|| ! bfd_set_section_size (abfd, relsec,
datasec->reloc_count * 12))
- einfo (_("%F%B: can not create .emreloc section: %E\n"));
+ einfo (_("%F%pB: can not create .emreloc section: %E\n"));
}
/* Double check that all other data sections are empty, as is
if ((bfd_get_section_flags (abfd, sec) & SEC_DATA)
&& sec != datasec
&& sec->reloc_count != 0)
- einfo (_("%B%X: section %s has relocs; can not use --embedded-relocs\n"),
+ einfo (_("%pB%X: section %s has relocs; can not use --embedded-relocs\n"),
abfd, bfd_get_section_name (abfd, sec));
}
&errmsg))
{
if (errmsg == NULL)
- einfo (_("%B%X: can not create runtime reloc information: %E\n"),
+ einfo (_("%pB%X: can not create runtime reloc information: %E\n"),
abfd);
else
- einfo (_("%X%B: can not create runtime reloc information: %s\n"),
+ einfo (_("%X%pB: can not create runtime reloc information: %s\n"),
abfd, errmsg);
}
}
COFF and ELF. */
if (bfd_get_flavour (abfd) != bfd_target_coff_flavour
&& bfd_get_flavour (abfd) != bfd_target_elf_flavour)
- einfo (_("%F%B: all input objects must be COFF or ELF "
+ einfo (_("%F%pB: all input objects must be COFF or ELF "
"for --embedded-relocs\n"));
datasec = bfd_get_section_by_name (abfd, ".data");
|| ! bfd_set_section_alignment (abfd, relsec, 2)
|| ! bfd_set_section_size (abfd, relsec,
datasec->reloc_count * 12))
- einfo (_("%F%B: can not create .emreloc section: %E\n"));
+ einfo (_("%F%pB: can not create .emreloc section: %E\n"));
}
/* Double check that all other data sections are empty, as is
if ((bfd_get_section_flags (abfd, sec) & SEC_DATA)
&& sec != datasec
&& sec->reloc_count != 0)
- einfo (_("%B%X: section %s has relocs; can not use --embedded-relocs\n"),
+ einfo (_("%pB%X: section %s has relocs; can not use --embedded-relocs\n"),
abfd, bfd_get_section_name (abfd, sec));
}
&errmsg))
{
if (errmsg == NULL)
- einfo (_("%B%X: can not create "
+ einfo (_("%pB%X: can not create "
"runtime reloc information: %E\n"),
abfd);
else
- einfo (_("%X%B: can not create "
+ einfo (_("%X%pB: can not create "
"runtime reloc information: %s\n"),
abfd, errmsg);
}
&errmsg))
{
if (errmsg == NULL)
- einfo (_("%B%X: can not create "
+ einfo (_("%pB%X: can not create "
"runtime reloc information: %E\n"),
abfd);
else
- einfo (_("%X%B: can not create "
+ einfo (_("%X%pB: can not create "
"runtime reloc information: %s\n"),
abfd, errmsg);
}
{
if (bfd_get_flavour (is->the_bfd) == bfd_target_elf_flavour
&& !_bfd_mmix_check_all_relocs (is->the_bfd, &link_info))
- einfo (_("%X%P: Internal problems scanning %B after opening it"),
+ einfo (_("%X%P: Internal problems scanning %pB after opening it"),
is->the_bfd);
}
}
&& abi_ver != (elf_elfheader (abfd)->e_flags & EF_NDS_ABI))
{
/* Incompatible objects. */
- einfo (_("%F%B: ABI version of object files mismatched\n"), abfd);
+ einfo (_("%F%pB: ABI version of object files mismatched\n"), abfd);
}
#if defined NDS32_EX9_EXT
if (bfd_link_pic (&link_info))
{
/* For PIE or shared object, all input must be PIC. */
- einfo (_("%B: must use -fpic to compile this file "
+ einfo (_("%pB: must use -fpic to compile this file "
"for shared object or PIE\n"), abfd);
}
else
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%pB%F: could not read symbols: %E\n"), b);
return;
}
if (coff_data (link_info.output_bfd) == NULL
|| coff_data (link_info.output_bfd)->pe == 0)
- einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
+ einfo (_("%F%P: cannot perform PE operations on non PE output file '%pB'.\n"),
link_info.output_bfd);
pe_data (link_info.output_bfd)->pe_opthdr = pe;
if (!bfd_generic_link_read_symbols (is->the_bfd))
{
- einfo (_("%B%F: could not read symbols: %E\n"),
+ einfo (_("%pB%F: could not read symbols: %E\n"),
is->the_bfd);
return;
}
if (!bfd_generic_link_read_symbols (is->the_bfd))
{
- einfo (_("%B%F: could not read symbols: %E\n"),
+ einfo (_("%pB%F: could not read symbols: %E\n"),
is->the_bfd);
return;
}
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%pB%F: could not read symbols: %E\n"), b);
return;
}
if (coff_data (link_info.output_bfd) == NULL
|| coff_data (link_info.output_bfd)->pe == 0)
- einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
+ einfo (_("%F%P: cannot perform PE operations on non PE output file '%pB'.\n"),
link_info.output_bfd);
pe_data (link_info.output_bfd)->pe_opthdr = pep;
if (!bfd_generic_link_read_symbols (is->the_bfd))
{
- einfo (_("%B%F: could not read symbols: %E\n"),
+ einfo (_("%pB%F: could not read symbols: %E\n"),
is->the_bfd);
return;
}
s = spu_elf_check_vma (&link_info);
if (s != NULL && !params.auto_overlay)
- einfo (_("%X%P: %A exceeds local store range\n"), s);
+ einfo (_("%X%P: %pA exceeds local store range\n"), s);
}
else if (params.auto_overlay)
einfo (_("%P: --auto-overlay ignored with zero local store range\n"));
{
/* We've found the needed dynamic object. */
if (! bfd_link_add_symbols (abfd, &link_info))
- einfo (_("%F%B: error adding symbols: %E\n"), abfd);
+ einfo (_("%F%pB: error adding symbols: %E\n"), abfd);
}
else
{
- einfo (_("%P: warning: %s, needed by %B, not found\n"),
+ einfo (_("%P: warning: %s, needed by %pB, not found\n"),
lname, l->by);
}
continue;
}
- einfo (_("%P: warning: %s, needed by %B, not found\n"),
+ einfo (_("%P: warning: %s, needed by %pB, not found\n"),
l->name, l->by);
}
}
/* Add this file into the symbol table. */
if (! bfd_link_add_symbols (abfd, &link_info))
- einfo (_("%F%B: error adding symbols: %E\n"), abfd);
+ einfo (_("%F%pB: error adding symbols: %E\n"), abfd);
return TRUE;
}
if (! replace_insn_sec_with_prop_sec (abfd, insn_sec_name, prop_sec_name,
&message))
{
- einfo (_("%P: warning: failed to convert %s table in %B (%s); subsequent disassembly may be incomplete\n"),
+ einfo (_("%P: warning: failed to convert %s table in %pB (%s); subsequent disassembly may be incomplete\n"),
insn_sec_name, abfd, message);
}
}
data = xmalloc (info_sec->size);
if (! bfd_get_section_contents (abfd, info_sec, data, 0, info_sec->size))
- einfo (_("%F%P:%B: cannot read contents of section %A\n"), abfd, info_sec);
+ einfo (_("%F%P:%pB: cannot read contents of section %pA\n"), abfd, info_sec);
if (info_sec->size > 24
&& info_sec->size >= 24 + bfd_get_32 (abfd, data + 4)
&mismatch, &errmsg))
{
if (mismatch)
- einfo (_("%P:%B: warning: incompatible Xtensa configuration (%s)\n"),
+ einfo (_("%P:%pB: warning: incompatible Xtensa configuration (%s)\n"),
abfd, errmsg);
}
else
- einfo (_("%P:%B: warning: cannot parse .xtensa.info section\n"), abfd);
+ einfo (_("%P:%pB: warning: cannot parse .xtensa.info section\n"), abfd);
free (data);
}
cannot go any further if there are any mismatches. */
if ((is_big_endian && f->the_bfd->xvec->byteorder == BFD_ENDIAN_LITTLE)
|| (!is_big_endian && f->the_bfd->xvec->byteorder == BFD_ENDIAN_BIG))
- einfo (_("%F%P: cross-endian linking for %B not supported\n"),
+ einfo (_("%F%P: cross-endian linking for %pB not supported\n"),
f->the_bfd);
if (! first_bfd)
putc (' ', fp);
++len;
}
- lfinfo (fp, "%B\n", r->abfd);
+ lfinfo (fp, "%pB\n", r->abfd);
len = 0;
}
}
putc (' ', fp);
++len;
}
- lfinfo (fp, "%B\n", r->abfd);
+ lfinfo (fp, "%pB\n", r->abfd);
len = 0;
}
}
putc (' ', fp);
++len;
}
- lfinfo (fp, "%B\n", r->abfd);
+ lfinfo (fp, "%pB\n", r->abfd);
len = 0;
}
}
return;
if (!bfd_generic_link_read_symbols (abfd))
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
+ einfo (_("%pB%F: could not read symbols: %E\n"), abfd);
for (syms = bfd_get_outsymbols (abfd); *syms; ++syms)
{
BFD might contain a prohibited cross reference. */
if (!bfd_generic_link_read_symbols (abfd))
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
+ einfo (_("%pB%F: could not read symbols: %E\n"), abfd);
info.sym_name = name;
info.global = global;
relsize = bfd_get_reloc_upper_bound (abfd, sec);
if (relsize < 0)
- einfo (_("%B%F: could not read relocs: %E\n"), abfd);
+ einfo (_("%pB%F: could not read relocs: %E\n"), abfd);
if (relsize == 0)
return;
relpp = (arelent **) xmalloc (relsize);
relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
if (relcount < 0)
- einfo (_("%B%F: could not read relocs: %E\n"), abfd);
+ einfo (_("%pB%F: could not read relocs: %E\n"), abfd);
p = relpp;
pend = p + relcount;
return;
case etree_rel:
if (tree->rel.section->owner != NULL)
- minfo ("%B:", tree->rel.section->owner);
+ minfo ("%pB:", tree->rel.section->owner);
minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
return;
case etree_assign:
}
if (m->ref != NULL)
- minfo ("%B ", m->ref);
+ minfo ("%pB ", m->ref);
minfo ("(%T)\n", m->name);
}
}
{
char **p;
- einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
- einfo (_("%B: matching formats:"), entry->the_bfd);
+ einfo (_("%pB: file not recognized: %E\n"), entry->the_bfd);
+ einfo (_("%pB: matching formats:"), entry->the_bfd);
for (p = matching; *p != NULL; p++)
einfo (" %s", *p);
einfo ("%F\n");
}
else if (err != bfd_error_file_not_recognized
|| place == NULL)
- einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
+ einfo (_("%F%pB: file not recognized: %E\n"), entry->the_bfd);
bfd_close (entry->the_bfd);
entry->the_bfd = NULL;
if (!bfd_check_format (member, bfd_object))
{
- einfo (_("%F%B: member %B in archive is not an object\n"),
+ einfo (_("%F%pB: member %pB in archive is not an object\n"),
entry->the_bfd, member);
loaded = FALSE;
}
substitute BFD for us. */
if (!bfd_link_add_symbols (subsbfd, &link_info))
{
- einfo (_("%F%B: error adding symbols: %E\n"), member);
+ einfo (_("%F%pB: error adding symbols: %E\n"), member);
loaded = FALSE;
}
}
if (bfd_link_add_symbols (entry->the_bfd, &link_info))
entry->flags.loaded = TRUE;
else
- einfo (_("%F%B: error adding symbols: %E\n"), entry->the_bfd);
+ einfo (_("%F%pB: error adding symbols: %E\n"), entry->the_bfd);
return entry->flags.loaded;
}
size = 0;
}
- minfo ("0x%V %W %B\n", addr, size, i->owner);
+ minfo ("0x%V %W %pB\n", addr, size, i->owner);
if (size != i->rawsize && i->rawsize != 0)
{
{
if (tree != NULL)
{
- einfo (_("%X%P: address 0x%v of %B section `%s'"
+ einfo (_("%X%P: address 0x%v of %pB section `%s'"
" is not within region `%s'\n"),
region->current,
os->bfd_section->owner,
{
region->had_full_message = TRUE;
- einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
+ einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
os->bfd_section->owner,
os->bfd_section->name,
region->name_list.name);
&& (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
{
einfo (_("%P%F: Relocatable linking with relocations from"
- " format %s (%B) to format %s (%B) is not supported\n"),
+ " format %s (%pB) to format %s (%pB) is not supported\n"),
bfd_get_target (input_bfd), input_bfd,
bfd_get_target (link_info.output_bfd), link_info.output_bfd);
/* einfo with %F exits. */
if (compatible == NULL)
{
if (command_line.warn_mismatch)
- einfo (_("%P%X: %s architecture of input file `%B'"
+ einfo (_("%P%X: %s architecture of input file `%pB'"
" is incompatible with %s output\n"),
bfd_printable_name (input_bfd), input_bfd,
bfd_printable_name (link_info.output_bfd));
{
if (command_line.warn_mismatch)
einfo (_("%P%X: failed to merge target specific data"
- " of file %B\n"), input_bfd);
+ " of file %pB\n"), input_bfd);
}
if (!command_line.warn_mismatch)
bfd_set_error_handler (pfn);
++len;
}
- minfo ("%B\n", section->owner);
+ minfo ("%pB\n", section->owner);
}
return TRUE;
int constraint = 0;
if (config.orphan_handling == orphan_handling_error)
- einfo (_("%X%P: error: unplaced orphan section `%A' from `%B'.\n"),
+ einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'.\n"),
s, s->owner);
if (config.unique_orphan_sections || unique_section_p (s, NULL))
}
if (config.orphan_handling == orphan_handling_warn)
- einfo (_("%P: warning: orphan section `%A' from `%B' being "
+ einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
"placed in section `%s'.\n"),
s, s->owner, os->name);
}
else
{
if (!bfd_close (link_info.output_bfd))
- einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
+ einfo (_("%F%pB: final close failed: %E\n"), link_info.output_bfd);
/* If the --force-exe-suffix is enabled, and we're making an
executable file and it doesn't end in .exe, copy it to one
}
if (from != NULL)
- minfo ("%B ", from);
+ minfo ("%pB ", from);
if (h != NULL)
minfo ("(%T)\n", h->root.string);
else
|| ntype == bfd_link_hash_indirect)
{
ASSERT (otype == bfd_link_hash_common);
- einfo (_("%B: warning: definition of `%T' overriding common\n"),
+ einfo (_("%pB: warning: definition of `%T' overriding common\n"),
nbfd, name);
if (obfd != NULL)
- einfo (_("%B: warning: common is here\n"), obfd);
+ einfo (_("%pB: warning: common is here\n"), obfd);
}
else if (otype == bfd_link_hash_defined
|| otype == bfd_link_hash_defweak
|| otype == bfd_link_hash_indirect)
{
ASSERT (ntype == bfd_link_hash_common);
- einfo (_("%B: warning: common of `%T' overridden by definition\n"),
+ einfo (_("%pB: warning: common of `%T' overridden by definition\n"),
nbfd, name);
if (obfd != NULL)
- einfo (_("%B: warning: defined here\n"), obfd);
+ einfo (_("%pB: warning: defined here\n"), obfd);
}
else
{
ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
if (osize > nsize)
{
- einfo (_("%B: warning: common of `%T' overridden by larger common\n"),
+ einfo (_("%pB: warning: common of `%T' overridden by larger common\n"),
nbfd, name);
if (obfd != NULL)
- einfo (_("%B: warning: larger common is here\n"), obfd);
+ einfo (_("%pB: warning: larger common is here\n"), obfd);
}
else if (nsize > osize)
{
- einfo (_("%B: warning: common of `%T' overriding smaller common\n"),
+ einfo (_("%pB: warning: common of `%T' overriding smaller common\n"),
nbfd, name);
if (obfd != NULL)
- einfo (_("%B: warning: smaller common is here\n"), obfd);
+ einfo (_("%pB: warning: smaller common is here\n"), obfd);
}
else
{
- einfo (_("%B: warning: multiple common of `%T'\n"), nbfd, name);
+ einfo (_("%pB: warning: multiple common of `%T'\n"), nbfd, name);
if (obfd != NULL)
- einfo (_("%B: warning: previous common is here\n"), obfd);
+ einfo (_("%pB: warning: previous common is here\n"), obfd);
}
}
}
struct warning_callback_info cinfo;
if (!bfd_generic_link_read_symbols (abfd))
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
+ einfo (_("%pB%F: could not read symbols: %E\n"), abfd);
cinfo.found = FALSE;
cinfo.warning = warning;
else if (abfd == NULL)
einfo ("%P: %s%s\n", _("warning: "), warning);
else if (symbol == NULL)
- einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
+ einfo ("%pB: %s%s\n", abfd, _("warning: "), warning);
else if (!symbol_warning (warning, symbol, abfd))
{
bfd *b;
for (b = info->input_bfds; b; b = b->link.next)
if (b != abfd && symbol_warning (warning, symbol, b))
return;
- einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
+ einfo ("%pB: %s%s\n", abfd, _("warning: "), warning);
}
}
relsize = bfd_get_reloc_upper_bound (abfd, sec);
if (relsize < 0)
- einfo (_("%B%F: could not read relocs: %E\n"), abfd);
+ einfo (_("%pB%F: could not read relocs: %E\n"), abfd);
if (relsize == 0)
return;
relpp = (arelent **) xmalloc (relsize);
relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
if (relcount < 0)
- einfo (_("%B%F: could not read relocs: %E\n"), abfd);
+ einfo (_("%pB%F: could not read relocs: %E\n"), abfd);
p = relpp;
pend = p + relcount;
if (error_count < MAX_ERRORS_IN_A_ROW)
{
if (error)
- einfo (_("%X%B: undefined reference to `%T'\n"),
+ einfo (_("%X%pB: undefined reference to `%T'\n"),
abfd, name);
else
- einfo (_("%B: warning: undefined reference to `%T'\n"),
+ einfo (_("%pB: warning: undefined reference to `%T'\n"),
abfd, name);
}
else if (error_count == MAX_ERRORS_IN_A_ROW)
{
if (error)
- einfo (_("%X%B: more undefined references to `%T' follow\n"),
+ einfo (_("%X%pB: more undefined references to `%T' follow\n"),
abfd, name);
else
- einfo (_("%B: warning: more undefined references to `%T' follow\n"),
+ einfo (_("%pB: warning: more undefined references to `%T' follow\n"),
abfd, name);
}
else if (error)
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
einfo (_(" relocation truncated to fit: "
- "%s against symbol `%T' defined in %A section in %B"),
+ "%s against symbol `%T' defined in %pA section in %pB"),
reloc_name, entry->root.string,
entry->u.def.section,
entry->u.def.section == bfd_abs_section_ptr
&& bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)
{
if (bfd_is_und_section (section))
- einfo (_("%B: reference to %s\n"), abfd, name);
+ einfo (_("%pB: reference to %s\n"), abfd, name);
else
- einfo (_("%B: definition of %s\n"), abfd, name);
+ einfo (_("%pB: definition of %s\n"), abfd, name);
}
if (command_line.cref || nocrossref_list != NULL)
/*
%% literal %
- %A section name from a section
- %B filename from a bfd
%C clever filename:linenumber with function
%D like %C, but no function name
%E current bfd error or errno
%ld long, like printf
%lu unsigned long, like printf
%p native (host) void* pointer, like printf
+ %pA section name from a section
+ %pB filename from a bfd
%s arbitrary string, like printf
%u integer, like printf
%v hex bfd_vma, no leading zeros
break;
case 'T':
- case 'A':
- case 'B':
case 'I':
case 'S':
case 'R':
- case 'p':
case 's':
arg_type = Ptr;
break;
+ case 'p':
+ if (*scan == 'A' || *scan == 'B')
+ scan++;
+ arg_type = Ptr;
+ break;
+
case 'C':
case 'D':
case 'G':
}
break;
- case 'A':
- /* section name from a section */
- {
- asection *sec;
- bfd *abfd;
- const char *group = NULL;
- struct coff_comdat_info *ci;
-
- sec = (asection *) args[arg_no].p;
- ++arg_count;
- abfd = sec->owner;
- fprintf (fp, "%s", sec->name);
- if (abfd != NULL
- && bfd_get_flavour (abfd) == bfd_target_elf_flavour
- && elf_next_in_group (sec) != NULL
- && (sec->flags & SEC_GROUP) == 0)
- group = elf_group_name (sec);
- else if (abfd != NULL
- && bfd_get_flavour (abfd) == bfd_target_coff_flavour
- && (ci = bfd_coff_get_comdat_section (sec->owner,
- sec)) != NULL)
- group = ci->name;
- if (group != NULL)
- fprintf (fp, "[%s]", group);
- }
- break;
-
- case 'B':
- /* filename from a bfd */
- {
- bfd *abfd = (bfd *) args[arg_no].p;
- ++arg_count;
- if (abfd == NULL)
- fprintf (fp, "%s generated", program_name);
- else if (abfd->my_archive != NULL
- && !bfd_is_thin_archive (abfd->my_archive))
- fprintf (fp, "%s(%s)", abfd->my_archive->filename,
- abfd->filename);
- else
- fprintf (fp, "%s", abfd->filename);
- }
- break;
-
case 'F':
/* Error is fatal. */
fatal = TRUE;
if (abfd != NULL)
{
if (!bfd_generic_link_read_symbols (abfd))
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
+ einfo (_("%pB%F: could not read symbols: %E\n"), abfd);
asymbols = bfd_get_outsymbols (abfd);
}
&& filename_cmp (last_file, filename) != 0)
|| strcmp (last_function, functionname) != 0)
{
- lfinfo (fp, _("%B: In function `%T':\n"),
+ lfinfo (fp, _("%pB: In function `%T':\n"),
abfd, functionname);
last_bfd = abfd;
discard_last = FALSE;
}
else
- lfinfo (fp, "%B:", abfd);
+ lfinfo (fp, "%pB:", abfd);
if (filename != NULL)
fprintf (fp, "%s:", filename);
}
else
{
- lfinfo (fp, "%B:", abfd);
+ lfinfo (fp, "%pB:", abfd);
done = FALSE;
}
if (!done)
- lfinfo (fp, "(%A+0x%v)", section, offset);
+ lfinfo (fp, "(%pA+0x%v)", section, offset);
if (discard_last)
{
break;
case 'p':
- /* native (host) void* pointer, like printf */
- fprintf (fp, "%p", args[arg_no].p);
- ++arg_count;
+ if (*fmt == 'A')
+ {
+ /* section name from a section */
+ asection *sec;
+ bfd *abfd;
+ const char *group = NULL;
+ struct coff_comdat_info *ci;
+
+ fmt++;
+ sec = (asection *) args[arg_no].p;
+ ++arg_count;
+ abfd = sec->owner;
+ fprintf (fp, "%s", sec->name);
+ if (abfd != NULL
+ && bfd_get_flavour (abfd) == bfd_target_elf_flavour
+ && elf_next_in_group (sec) != NULL
+ && (sec->flags & SEC_GROUP) == 0)
+ group = elf_group_name (sec);
+ else if (abfd != NULL
+ && bfd_get_flavour (abfd) == bfd_target_coff_flavour
+ && (ci = bfd_coff_get_comdat_section (sec->owner,
+ sec)) != NULL)
+ group = ci->name;
+ if (group != NULL)
+ fprintf (fp, "[%s]", group);
+ }
+ else if (*fmt == 'B')
+ {
+ /* filename from a bfd */
+ bfd *abfd = (bfd *) args[arg_no].p;
+
+ fmt++;
+ ++arg_count;
+ if (abfd == NULL)
+ fprintf (fp, "%s generated", program_name);
+ else if (abfd->my_archive != NULL
+ && !bfd_is_thin_archive (abfd->my_archive))
+ fprintf (fp, "%s(%s)", abfd->my_archive->filename,
+ abfd->filename);
+ else
+ fprintf (fp, "%s", abfd->filename);
+ }
+ else
+ {
+ /* native (host) void* pointer, like printf */
+ fprintf (fp, "%p", args[arg_no].p);
+ ++arg_count;
+ }
break;
case 's':
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%pB%F: could not read symbols: %E\n"), b);
return;
}
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%pB%F: could not read symbols: %E\n"), b);
return;
}
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%pB%F: could not read symbols: %E\n"), b);
return;
}
report_symbol:
syms[n].resolution = res;
if (report_plugin_symbols)
- einfo (_("%P: %B: symbol `%s' "
+ einfo (_("%P: %pB: symbol `%s' "
"definition: %d, visibility: %d, resolution: %d\n"),
abfd, syms[n].name,
syms[n].def, syms[n].visibility, res);
projects / deliverable / binutils-gdb.git / commitdiff
