? bfd_elf32_swap_reloc_out \
: bfd_elf32_swap_reloca_out)
-#define elf_info_to_howto 0
+#define elf_info_to_howto NULL
#define elf_info_to_howto_rel elf32_arm_info_to_howto
#define ARM_ELF_ABI_VERSION 0
return NULL;
}
-static void
-elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
+static bfd_boolean
+elf32_arm_info_to_howto (bfd * abfd, arelent * bfd_reloc,
Elf_Internal_Rela * elf_reloc)
{
unsigned int r_type;
r_type = ELF32_R_TYPE (elf_reloc->r_info);
- bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
+ if ((bfd_reloc->howto = elf32_arm_howto_from_type (r_type)) == NULL)
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+ return TRUE;
}
struct elf32_arm_reloc_map
int nacl_p;
/* True if the target uses REL relocations. */
- int use_rel;
+ bfd_boolean use_rel;
/* Nonzero if import library must be a secure gateway import library
as per ARMv8-M Security Extensions. */
ret->plt_header_size = 20;
ret->plt_entry_size = elf32_arm_use_long_plt_entry ? 16 : 12;
#endif
- ret->use_rel = 1;
+ ret->use_rel = TRUE;
ret->obfd = abfd;
if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
{
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."),
+ " targets that implement the movw instruction"),
input_bfd, input_sec);
stub_type = (bfd_link_pic (info) | globals->pic_veneer)
{
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."),
+ " targets that implement the movw instruction"),
input_bfd, input_sec);
stub_type = (bfd_link_pic (info) | globals->pic_veneer)
{
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."),
+ " targets that implement the movw instruction"),
input_bfd, input_sec);
/* Thumb to arm. */
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: Thumb call to ARM"),
- sym_sec->owner, name, input_bfd);
+ (_("%pB(%s): warning: interworking not enabled;"
+ " first occurrence: %pB: %s call to %s"),
+ sym_sec->owner, name, input_bfd, "Thumb", "ARM");
}
stub_type =
{
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."),
+ " targets that implement the movw instruction"),
input_bfd, input_sec);
if (branch_type == ST_BRANCH_TO_THUMB)
{
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: ARM call to Thumb"),
- sym_sec->owner, name, input_bfd);
+ (_("%pB(%s): warning: interworking not enabled;"
+ " first occurrence: %pB: %s call to %s"),
+ sym_sec->owner, name, input_bfd, "ARM", "Thumb");
}
/* We have an extra 2-bytes reach because of
out_sec = bfd_get_section_by_name (output_bfd, out_sec_name);
if (out_sec == NULL)
{
- _bfd_error_handler (_("No address assigned to the veneers output "
+ _bfd_error_handler (_("no address assigned to the veneers output "
"section %s"), out_sec_name);
return NULL;
}
{
if (section == NULL)
section = stub_sec;
- _bfd_error_handler (_("%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 "
- "ARMv8-M architecture or later."),
+ _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. */
ret = FALSE;
if (cmse_invalid)
{
- _bfd_error_handler (_("%B: invalid special symbol `%s'."),
+ _bfd_error_handler (_("%pB: invalid special symbol `%s'; it must be"
+ " a global or weak function symbol"),
input_bfd, sym_name);
- _bfd_error_handler (_("It must be a global or weak function "
- "symbol."));
ret = FALSE;
if (i < ext_start)
continue;
if (hash || j < ext_start)
{
_bfd_error_handler
- (_("%B: invalid standard symbol `%s'."), input_bfd, sym_name);
- _bfd_error_handler
- (_("It must be a global or weak function symbol."));
+ (_("%pB: invalid standard symbol `%s'; it must be "
+ "a global or weak function symbol"),
+ input_bfd, sym_name);
}
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 "
- "Gateway import libraries."), in_implib_bfd);
+ _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'; "
+ "symbol should be absolute, global and "
+ "refer to Thumb functions"),
in_implib_bfd, sym_name);
- _bfd_error_handler (_("Symbol should be absolute, global and "
- "refer to Thumb functions."));
ret = FALSE;
continue;
}
bfd_boolean new_stub;
_bfd_error_handler
- (_("Entry function `%s' disappeared from secure code."), sym_name);
+ (_("entry function `%s' disappeared from secure code"), sym_name);
hash = (struct elf32_arm_link_hash_entry *)
elf_link_hash_lookup (&(htab)->root, sym_name, TRUE, TRUE, TRUE);
stub_entry
{
if (!cmse_entry_fct_p (hash))
{
- _bfd_error_handler (_("`%s' refers to a non entry function."),
+ _bfd_error_handler (_("`%s' refers to a non entry function"),
sym_name);
ret = FALSE;
}
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;
}
if (stub_offset % cmse_stub_size)
{
_bfd_error_handler
- (_("Offset of veneer for entry function `%s' not a multiple of "
- "its size."), sym_name);
+ (_("offset of veneer for entry function `%s' not a multiple of "
+ "its size"), sym_name);
ret = FALSE;
}
if (cmse_stub_array_start != cmse_stub_sec_vma)
{
_bfd_error_handler
- (_("Start address of `%s' is different from previous link."),
+ (_("start address of `%s' is different from previous link"),
out_sec_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;
}
(&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
if (hash == NULL
- && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
- tmp_name, name) == -1)
+ && asprintf (error_message, _("unable to find %s glue '%s' for '%s'"),
+ "Thumb", tmp_name, name) == -1)
*error_message = (char *) bfd_errmsg (bfd_error_system_call);
free (tmp_name);
(&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL
- && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
- tmp_name, name) == -1)
+ && asprintf (error_message, _("unable to find %s glue '%s' for '%s'"),
+ "ARM", tmp_name, name) == -1)
*error_message = (char *) bfd_errmsg (bfd_error_system_call);
free (tmp_name);
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 "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%pB: unable to find %s veneer `%s'"),
+ abfd, "VFP11", tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- _bfd_error_handler (_("%B: unable to find VFP11 veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%pB: unable to find %s veneer `%s'"),
+ abfd, "VFP11", tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- _bfd_error_handler (_("%B: unable to find STM32L4XX veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%pB: unable to find %s veneer `%s'"),
+ abfd, "STM32L4XX", tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
(&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
if (myh == NULL)
- _bfd_error_handler (_("%B: unable to find STM32L4XX veneer "
- "`%s'"), abfd, tmp_name);
+ _bfd_error_handler (_("%pB: unable to find %s veneer `%s'"),
+ abfd, "STM32L4XX", tmp_name);
vma = myh->root.u.def.section->output_section->vma
+ myh->root.u.def.section->output_offset
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#x): error: multiple load detected"
- " in non-last IT block instruction :"
- " STM32L4XX veneer cannot be generated.\n"
- "Use gcc option -mrestrict-it to generate"
- " only one instruction per IT block.\n"),
+ (_("%pB(%pA+%#x): error: multiple load detected"
+ " in non-last IT block instruction:"
+ " STM32L4XX veneer cannot be generated; "
+ "use gcc option -mrestrict-it to generate"
+ " only one instruction per IT block"),
abfd, sec, i);
}
else
globals->target2_reloc = R_ARM_GOT_PREL;
else
{
- _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
+ _bfd_error_handler (_("invalid TARGET2 relocation type '%s'"),
params->target2_type);
}
globals->fix_v4bx = params->fix_v4bx;
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: Thumb call to ARM"),
- sym_sec->owner, name, input_bfd);
+ (_("%pB(%s): warning: interworking not enabled;"
+ " first occurrence: %pB: %s call to %s"),
+ sym_sec->owner, name, input_bfd, "Thumb", "ARM");
return FALSE;
}
&& !INTERWORK_FLAG (sym_sec->owner))
{
_bfd_error_handler
- (_("%B(%s): warning: interworking not enabled.\n"
- " first occurrence: %B: arm call to thumb"),
- sym_sec->owner, name, input_bfd);
+ (_("%pB(%s): warning: interworking not enabled;"
+ " first occurrence: %pB: %s call to %s"),
+ sym_sec->owner, name, input_bfd, "ARM", "Thumb");
}
--my_offset;
{
/* 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"),
- input_bfd, input_sec, rel->r_offset, insn);
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unexpected %s instruction '%#lx' in TLS trampoline"),
+ input_bfd, input_sec, (uint64_t) rel->r_offset,
+ "Thumb", insn);
return bfd_reloc_notsupported;
}
break;
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected ARM instruction '%#lx' in TLS trampoline"),
- input_bfd, input_sec, rel->r_offset, insn);
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unexpected %s instruction '%#lx' in TLS trampoline"),
+ input_bfd, input_sec, (uint64_t) rel->r_offset,
+ "ARM", insn);
return bfd_reloc_notsupported;
}
break;
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'."),
- input_bfd,
- h ? h->root.root.string : "(local)");
+ (_("\%pB: warning: %s BLX instruction targets"
+ " %s function '%s'"),
+ input_bfd, "ARM",
+ "ARM", h ? h->root.root.string : "(local)");
}
else if (r_type == R_ARM_PC24)
{
instruction instead ? */
if (branch_type == ST_BRANCH_TO_THUMB)
_bfd_error_handler
- (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
- input_bfd,
- h ? h->root.root.string : "(local)");
+ (_("%pB: warning: %s BLX instruction targets"
+ " %s function '%s'"),
+ input_bfd, "Thumb",
+ "Thumb", h ? h->root.root.string : "(local)");
}
else
{
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected Thumb instruction '%#lx' referenced by TLS_GOTDESC"),
- input_bfd, input_section, rel->r_offset, insn);
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unexpected %s instruction '%#lx' "
+ "referenced by TLS_GOTDESC"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ "Thumb", insn);
return bfd_reloc_notsupported;
}
}
default:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unexpected ARM instruction '%#lx' referenced by TLS_GOTDESC"),
- input_bfd, input_section, rel->r_offset, insn);
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unexpected %s instruction '%#lx' "
+ "referenced by TLS_GOTDESC"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ "ARM", insn);
return bfd_reloc_notsupported;
}
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s relocation not permitted in shared object"),
- input_bfd, input_section, rel->r_offset, howto->name);
+ (_("%pB(%pA+%#" PRIx64 "): %s relocation not permitted "
+ "in shared object"),
+ input_bfd, input_section, (uint64_t) rel->r_offset, howto->name);
return bfd_reloc_notsupported;
}
else
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
- input_bfd, input_section, rel->r_offset);
+ (_("%pB(%pA+%#" PRIx64 "): only ADD or SUB instructions "
+ "are allowed for ALU group relocations"),
+ input_bfd, input_section, (uint64_t) rel->r_offset);
return bfd_reloc_overflow;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#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);
+ (_("%pB(%pA+%#" PRIx64 "): overflow whilst "
+ "splitting %#" PRIx64 " for group relocation %s"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ (uint64_t) (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"),
- input_bfd, input_section, rel->r_offset,
- signed_value < 0 ? -signed_value : signed_value, howto->name);
+ (_("%pB(%pA+%#" PRIx64 "): overflow whilst "
+ "splitting %#" PRIx64 " for group relocation %s"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ (uint64_t) (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"),
- input_bfd, input_section, rel->r_offset,
- signed_value < 0 ? -signed_value : signed_value, howto->name);
+ (_("%pB(%pA+%#" PRIx64 "): overflow whilst "
+ "splitting %#" PRIx64 " for group relocation %s"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ (uint64_t) (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"),
- input_bfd, input_section, rel->r_offset,
- signed_value < 0 ? -signed_value : signed_value, howto->name);
+ (_("%pB(%pA+%#" PRIx64 "): overflow whilst "
+ "splitting %#" PRIx64 " for group relocation %s"),
+ input_bfd, input_section, (uint64_t) rel->r_offset,
+ (uint64_t) (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+%#" PRIx64 "): "
+ "%s relocation against SEC_MERGE section"),
input_bfd, input_section,
- rel->r_offset, howto->name);
+ (uint64_t) 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+%#" PRIx64 "): %s used with TLS symbol %s")
/* xgettext:c-format */
- : _("%B(%A+%#Lx): %s used with non-TLS symbol %s")),
+ : _("%pB(%pA+%#" PRIx64 "): %s used with non-TLS symbol %s")),
input_bfd,
input_section,
- rel->r_offset,
+ (uint64_t) rel->r_offset,
howto->name,
name);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
- rel->r_offset,
+ (uint64_t) rel->r_offset,
howto->name,
h->root.root.string);
return FALSE;
{
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 `%pT' 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. "
- "Jump out of range by %Ld bytes. "
- "Cannot encode branch instruction. "),
+ (_("%pB(%#" PRIx64 "): error: "
+ "cannot create STM32L4XX veneer; "
+ "jump out of range by %" PRId64 " bytes; "
+ "cannot encode branch instruction"),
output_bfd,
- stm32l4xx_errnode->vma - 4,
- out_of_range);
+ (uint64_t) (stm32l4xx_errnode->vma - 4),
+ (int64_t) out_of_range);
continue;
}
STM32L4XX_ERRATUM_LDM_VENEER_SIZE) < -(1 << 24)
|| (signed) (veneer_r - veneer) >= (1 << 24))
{
- _bfd_error_handler (_("%B: error: Cannot create STM32L4XX "
- "veneer."), output_bfd);
+ _bfd_error_handler (_("%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"),
- ibfd, obfd);
+ (_("error: %pB uses %s instructions, whereas %pB does not"),
+ ibfd, "VFP", obfd);
else
_bfd_error_handler
- (_("error: %B uses FPA instructions, whereas %B does not"),
- ibfd, obfd);
+ (_("error: %pB uses %s instructions, whereas %pB does not"),
+ ibfd, "FPA", obfd);
flags_compatible = FALSE;
}
{
if (in_flags & EF_ARM_MAVERICK_FLOAT)
_bfd_error_handler
- (_("error: %B uses Maverick instructions, whereas %B does not"),
- ibfd, obfd);
+ (_("error: %pB uses %s instructions, whereas %pB does not"),
+ ibfd, "Maverick", obfd);
else
_bfd_error_handler
- (_("error: %B does not use Maverick instructions, whereas %B does"),
- ibfd, obfd);
+ (_("error: %pB does not use %s instructions, whereas %pB does"),
+ ibfd, "Maverick", 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);
}
}
projects / deliverable / binutils-gdb.git / blobdiff