{
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);
}
}