/* BFD back-end for ARM COFF files.
- Copyright (C) 1990-2016 Free Software Foundation, Inc.
+ Copyright (C) 1990-2021 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
#include "libbfd.h"
#include "coff/arm.h"
#include "coff/internal.h"
+#include "cpu-arm.h"
+#include "coff-arm.h"
#ifdef COFF_WITH_PE
#include "coff/pe.h"
#include "libcoff.h"
+/* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
+#define OCTETS_PER_BYTE(ABFD, SEC) 1
+
/* Macros for manipulation the bits in the flags field of the coff data
structure. */
#define APCS_26_FLAG(abfd) \
arelent *reloc_entry,
asymbol *symbol ATTRIBUTE_UNUSED,
void * data,
- asection *input_section ATTRIBUTE_UNUSED,
+ asection *input_section,
bfd *output_bfd,
char **error_message ATTRIBUTE_UNUSED)
{
x = ((x & ~howto->dst_mask) \
| (((x & howto->src_mask) + diff) & howto->dst_mask))
- if (diff != 0)
- {
- reloc_howto_type *howto = reloc_entry->howto;
- unsigned char *addr = (unsigned char *) data + reloc_entry->address;
+ if (diff != 0)
+ {
+ reloc_howto_type *howto = reloc_entry->howto;
+ bfd_size_type octets = (reloc_entry->address
+ * OCTETS_PER_BYTE (abfd, input_section));
+ unsigned char *addr = (unsigned char *) data + octets;
- switch (howto->size)
- {
- case 0:
- {
- char x = bfd_get_8 (abfd, addr);
- DOIT (x);
- bfd_put_8 (abfd, x, addr);
- }
- break;
+ if (!bfd_reloc_offset_in_range (howto, abfd, input_section, octets))
+ return bfd_reloc_outofrange;
- case 1:
- {
- short x = bfd_get_16 (abfd, addr);
- DOIT (x);
- bfd_put_16 (abfd, (bfd_vma) x, addr);
- }
- break;
+ switch (howto->size)
+ {
+ case 0:
+ {
+ char x = bfd_get_8 (abfd, addr);
+ DOIT (x);
+ bfd_put_8 (abfd, x, addr);
+ }
+ break;
- case 2:
- {
- long x = bfd_get_32 (abfd, addr);
- DOIT (x);
- bfd_put_32 (abfd, (bfd_vma) x, addr);
- }
- break;
+ case 1:
+ {
+ short x = bfd_get_16 (abfd, addr);
+ DOIT (x);
+ bfd_put_16 (abfd, (bfd_vma) x, addr);
+ }
+ break;
- default:
- abort ();
+ case 2:
+ {
+ long x = bfd_get_32 (abfd, addr);
+ DOIT (x);
+ bfd_put_32 (abfd, (bfd_vma) x, addr);
}
- }
+ break;
+
+ default:
+ abort ();
+ }
+ }
/* Now let bfd_perform_relocation finish everything up. */
return bfd_reloc_continue;
#endif
#ifndef PCRELOFFSET
-#define PCRELOFFSET TRUE
+#define PCRELOFFSET true
#endif
/* These most certainly belong somewhere else. Just had to get rid of
#else
-#define ARM_8 0
-#define ARM_16 1
-#define ARM_32 2
-#define ARM_26 3
+#define ARM_8 0
+#define ARM_16 1
+#define ARM_32 2
+#define ARM_26 3
#define ARM_DISP8 4
#define ARM_DISP16 5
#define ARM_DISP32 6
-#define ARM_26D 7
+#define ARM_26D 7
/* 8 is unused. */
#define ARM_NEG16 9
#define ARM_NEG32 10
2,
2,
24,
- TRUE,
+ true,
0,
complain_overflow_dont,
aoutarm_fix_pcrel_26_done,
"ARM_26D",
- TRUE, /* partial_inplace. */
+ true, /* partial_inplace. */
0x00ffffff,
0x0,
PCRELOFFSET),
0,
2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_32",
- TRUE, /* partial_inplace. */
+ true, /* partial_inplace. */
0xffffffff,
0xffffffff,
PCRELOFFSET),
0,
2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_RVA32",
- TRUE, /* partial_inplace. */
+ true, /* partial_inplace. */
0xffffffff,
0xffffffff,
PCRELOFFSET),
2,
2,
24,
- TRUE,
+ true,
0,
complain_overflow_signed,
aoutarm_fix_pcrel_26 ,
"ARM_26",
- FALSE,
+ false,
0x00ffffff,
0x00ffffff,
PCRELOFFSET),
1,
1,
11,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_thumb_pcrel_12 ,
"ARM_THUMB12",
- FALSE,
+ false,
0x000007ff,
0x000007ff,
PCRELOFFSET),
0,
1,
16,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_SECTION",
- TRUE, /* partial_inplace. */
+ true, /* partial_inplace. */
0x0000ffff,
0x0000ffff,
PCRELOFFSET),
0,
2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_SECREL",
- TRUE, /* partial_inplace. */
+ true, /* partial_inplace. */
0xffffffff,
0xffffffff,
PCRELOFFSET),
0,
0,
8,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_8",
- TRUE,
+ true,
0x000000ff,
0x000000ff,
PCRELOFFSET),
0,
1,
16,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_16",
- TRUE,
+ true,
0x0000ffff,
0x0000ffff,
PCRELOFFSET),
0,
2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_32",
- TRUE,
+ true,
0xffffffff,
0xffffffff,
PCRELOFFSET),
2,
2,
24,
- TRUE,
+ true,
0,
complain_overflow_signed,
aoutarm_fix_pcrel_26 ,
"ARM_26",
- FALSE,
+ false,
0x00ffffff,
0x00ffffff,
PCRELOFFSET),
0,
0,
8,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_arm_reloc,
"ARM_DISP8",
- TRUE,
+ true,
0x000000ff,
0x000000ff,
- TRUE),
+ true),
HOWTO (ARM_DISP16,
0,
1,
16,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_arm_reloc,
"ARM_DISP16",
- TRUE,
+ true,
0x0000ffff,
0x0000ffff,
- TRUE),
+ true),
HOWTO (ARM_DISP32,
0,
2,
32,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_arm_reloc,
"ARM_DISP32",
- TRUE,
+ true,
0xffffffff,
0xffffffff,
- TRUE),
+ true),
HOWTO (ARM_26D,
2,
2,
24,
- FALSE,
+ false,
0,
complain_overflow_dont,
aoutarm_fix_pcrel_26_done,
"ARM_26D",
- TRUE,
+ true,
0x00ffffff,
0x0,
- FALSE),
+ false),
/* 8 is unused */
EMPTY_HOWTO (-1),
HOWTO (ARM_NEG16,
0,
-1,
16,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_NEG16",
- TRUE,
+ true,
0x0000ffff,
0x0000ffff,
- FALSE),
+ false),
HOWTO (ARM_NEG32,
0,
-2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_NEG32",
- TRUE,
+ true,
0xffffffff,
0xffffffff,
- FALSE),
+ false),
HOWTO (ARM_RVA32,
0,
2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_RVA32",
- TRUE,
+ true,
0xffffffff,
0xffffffff,
PCRELOFFSET),
1,
1,
8,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_thumb_pcrel_9 ,
"ARM_THUMB9",
- FALSE,
+ false,
0x000000ff,
0x000000ff,
PCRELOFFSET),
1,
1,
11,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_thumb_pcrel_12 ,
"ARM_THUMB12",
- FALSE,
+ false,
0x000007ff,
0x000007ff,
PCRELOFFSET),
1,
2,
22,
- TRUE,
+ true,
0,
complain_overflow_signed,
coff_thumb_pcrel_23 ,
"ARM_THUMB23",
- FALSE,
+ false,
0x07ff07ff,
0x07ff07ff,
PCRELOFFSET)
/* Return TRUE if this relocation should
appear in the output .reloc section. */
-static bfd_boolean
+static bool
in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
reloc_howto_type * howto)
{
char **error_message)
{
return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
- input_section, output_bfd, error_message,
+ input_section, output_bfd, error_message,
b23);
}
char **error_message)
{
return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
- input_section, output_bfd, error_message,
+ input_section, output_bfd, error_message,
b9);
}
#endif /* not ARM_WINCE */
char **error_message)
{
return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
- input_section, output_bfd, error_message,
+ input_section, output_bfd, error_message,
b12);
}
-static const struct reloc_howto_struct *
+static reloc_howto_type *
coff_arm_reloc_type_lookup (bfd * abfd, bfd_reloc_code_real_type code)
{
#define ASTD(i,j) case i: return aoutarm_std_reloc_howto + j
switch (bfd_arch_bits_per_address (abfd))
{
case 32:
- code = BFD_RELOC_32;
- break;
+ code = BFD_RELOC_32;
+ break;
default:
return NULL;
}
switch (code)
{
#ifdef ARM_WINCE
- ASTD (BFD_RELOC_32, ARM_32);
- ASTD (BFD_RELOC_RVA, ARM_RVA32);
- ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
+ ASTD (BFD_RELOC_32, ARM_32);
+ ASTD (BFD_RELOC_RVA, ARM_RVA32);
+ ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
- ASTD (BFD_RELOC_32_SECREL, ARM_SECREL);
+ ASTD (BFD_RELOC_32_SECREL, ARM_SECREL);
#else
- ASTD (BFD_RELOC_8, ARM_8);
- ASTD (BFD_RELOC_16, ARM_16);
- ASTD (BFD_RELOC_32, ARM_32);
- ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
- ASTD (BFD_RELOC_ARM_PCREL_BLX, ARM_26);
- ASTD (BFD_RELOC_8_PCREL, ARM_DISP8);
- ASTD (BFD_RELOC_16_PCREL, ARM_DISP16);
- ASTD (BFD_RELOC_32_PCREL, ARM_DISP32);
- ASTD (BFD_RELOC_RVA, ARM_RVA32);
+ ASTD (BFD_RELOC_8, ARM_8);
+ ASTD (BFD_RELOC_16, ARM_16);
+ ASTD (BFD_RELOC_32, ARM_32);
+ ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
+ ASTD (BFD_RELOC_ARM_PCREL_BLX, ARM_26);
+ ASTD (BFD_RELOC_8_PCREL, ARM_DISP8);
+ ASTD (BFD_RELOC_16_PCREL, ARM_DISP16);
+ ASTD (BFD_RELOC_32_PCREL, ARM_DISP32);
+ ASTD (BFD_RELOC_RVA, ARM_RVA32);
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9, ARM_THUMB9);
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
- ASTD (BFD_RELOC_THUMB_PCREL_BLX, ARM_THUMB23);
+ ASTD (BFD_RELOC_THUMB_PCREL_BLX, ARM_THUMB23);
#endif
default: return NULL;
}
}
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
-#define COFF_PAGE_SIZE 0x1000
+#define COFF_PAGE_SIZE 0x1000
/* Turn a howto into a reloc nunmber. */
#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
-#define BADMAG(x) ARMBADMAG(x)
-#define ARM 1 /* Customize coffcode.h. */
+#define BADMAG(x) ARMBADMAG(x)
+#define ARM 1 /* Customize coffcode.h. */
#ifndef ARM_WINCE
/* Make sure that the 'r_offset' field is copied properly
bfd * bfd_of_glue_owner;
/* Support interworking with old, non-interworking aware ARM code. */
- int support_old_code;
+ int support_old_code;
};
/* Get the ARM coff linker hash table from a link_info structure. */
coff_arm_link_hash_table_create (bfd * abfd)
{
struct coff_arm_link_hash_table * ret;
- bfd_size_type amt = sizeof (struct coff_arm_link_hash_table);
+ size_t amt = sizeof (struct coff_arm_link_hash_table);
ret = bfd_zmalloc (amt);
if (ret == NULL)
return & ret->root.root;
}
-static bfd_boolean
+static bool
arm_emit_base_file_entry (struct bfd_link_info *info,
bfd *output_bfd,
asection *input_section,
if (coff_data (output_bfd)->pe)
addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
- return TRUE;
+ return true;
bfd_set_error (bfd_error_system_call);
- return FALSE;
+ return false;
}
\f
#ifndef ARM_WINCE
BFD_ASSERT ((rel_off & 1) != 1);
- rel_off >>= 1; /* Half word aligned address. */
- low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
+ rel_off >>= 1; /* Half word aligned address. */
+ low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
{
char *tmp_name;
struct coff_link_hash_entry *myh;
- bfd_size_type amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
+ size_t amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
tmp_name = bfd_malloc (amt);
sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
myh = coff_link_hash_lookup
- (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
+ (coff_hash_table (info), tmp_name, false, false, true);
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);
{
char *tmp_name;
struct coff_link_hash_entry * myh;
- bfd_size_type amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
+ size_t amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
tmp_name = bfd_malloc (amt);
sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
myh = coff_link_hash_lookup
- (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
+ (coff_hash_table (info), tmp_name, false, false, true);
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);
ldr r12, __func_addr
bx r12
__func_addr:
- .word func @ behave as if you saw a ARM_32 reloc
+ .word func @ behave as if you saw a ARM_32 reloc
*/
#define ARM2THUMB_GLUE_SIZE 12
nop ldr r6, __func_addr
.arm mov lr, pc
__func_change_to_arm: bx r6
- b func .arm
+ b func .arm
__func_back_to_thumb:
- ldmia r13! {r6, lr}
- bx lr
- __func_addr:
- .word func
+ ldmia r13! {r6, lr}
+ bx lr
+ __func_addr:
+ .word func
*/
#define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
/* The standard COFF backend linker does not cope with the special
Thumb BRANCH23 relocation. The alternative would be to split the
- BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
+ BRANCH23 into separate HI23 and LO23 relocations. However, it is a
bit simpler simply providing our own relocation driver. */
/* The reloc processing routine for the ARM/Thumb COFF linker. NOTE:
ARM/Thumb builds. It is only the code marked THUMBEXTENSION that
is different from the original. */
-static bfd_boolean
+static bool
coff_arm_relocate_section (bfd *output_bfd,
struct bfd_link_info *info,
bfd *input_bfd,
for (; rel < relend; rel++)
{
- int done = 0;
- long symndx;
+ int done = 0;
+ long symndx;
struct coff_link_hash_entry * h;
- struct internal_syment * sym;
- bfd_vma addend;
- bfd_vma val;
- reloc_howto_type * howto;
- bfd_reloc_status_type rstat;
- bfd_vma h_val;
+ struct internal_syment * sym;
+ bfd_vma addend;
+ bfd_vma val;
+ reloc_howto_type * howto;
+ bfd_reloc_status_type rstat;
+ bfd_vma h_val;
symndx = rel->r_symndx;
}
/* COFF treats common symbols in one of two ways. Either the
- size of the symbol is included in the section contents, or it
- is not. We assume that the size is not included, and force
- the rtype_to_howto function to adjust the addend as needed. */
+ size of the symbol is included in the section contents, or it
+ is not. We assume that the size is not included, and force
+ the rtype_to_howto function to adjust the addend as needed. */
if (sym != NULL && sym->n_scnum != 0)
addend = - sym->n_value;
howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
sym, &addend);
if (howto == NULL)
- return FALSE;
+ return false;
/* The relocation_section function will skip pcrel_offset relocs
- when doing a relocatable link. However, we want to convert
- ARM_26 to ARM_26D relocs if possible. We return a fake howto in
- this case without pcrel_offset set, and adjust the addend to
- compensate. 'partial_inplace' is also set, since we want 'done'
- relocations to be reflected in section's data. */
+ when doing a relocatable link. However, we want to convert
+ ARM_26 to ARM_26D relocs if possible. We return a fake howto in
+ this case without pcrel_offset set, and adjust the addend to
+ compensate. 'partial_inplace' is also set, since we want 'done'
+ relocations to be reflected in section's data. */
if (rel->r_type == ARM_26
- && h != NULL
- && bfd_link_relocatable (info)
- && (h->root.type == bfd_link_hash_defined
+ && h != NULL
+ && bfd_link_relocatable (info)
+ && (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
- && (h->root.u.def.section->output_section
+ && (h->root.u.def.section->output_section
== input_section->output_section))
- {
- static reloc_howto_type fake_arm26_reloc =
+ {
+ static reloc_howto_type fake_arm26_reloc =
HOWTO (ARM_26,
- 2,
- 2,
- 24,
- TRUE,
- 0,
- complain_overflow_signed,
- aoutarm_fix_pcrel_26 ,
- "ARM_26",
- TRUE,
- 0x00ffffff,
- 0x00ffffff,
- FALSE);
-
- addend -= rel->r_vaddr - input_section->vma;
+ 2,
+ 2,
+ 24,
+ true,
+ 0,
+ complain_overflow_signed,
+ aoutarm_fix_pcrel_26 ,
+ "ARM_26",
+ true,
+ 0x00ffffff,
+ 0x00ffffff,
+ false);
+
+ addend -= rel->r_vaddr - input_section->vma;
#ifdef ARM_WINCE
- /* FIXME: I don't know why, but the hack is necessary for correct
- generation of bl's instruction offset. */
- addend -= 8;
+ /* FIXME: I don't know why, but the hack is necessary for correct
+ generation of bl's instruction offset. */
+ addend -= 8;
#endif
- howto = & fake_arm26_reloc;
- }
+ howto = & fake_arm26_reloc;
+ }
#ifdef ARM_WINCE
/* MS ARM-CE makes the reloc relative to the opcode's pc, not
#endif
/* If we are doing a relocatable link, then we can just ignore
- a PC relative reloc that is pcrel_offset. It will already
- have the correct value. If this is not a relocatable link,
- then we should ignore the symbol value. */
+ a PC relative reloc that is pcrel_offset. It will already
+ have the correct value. If this is not a relocatable link,
+ then we should ignore the symbol value. */
if (howto->pc_relative && howto->pcrel_offset)
- {
- if (bfd_link_relocatable (info))
- continue;
+ {
+ if (bfd_link_relocatable (info))
+ continue;
/* FIXME - it is not clear which targets need this next test
and which do not. It is known that it is needed for the
- VxWorks and EPOC-PE targets, but it is also known that it
- was suppressed for other ARM targets. This ought to be
- sorted out one day. */
+ VxWorks targets but it is also known that it was suppressed
+ for other ARM targets. This ought to be sorted out one day. */
#ifdef ARM_COFF_BUGFIX
/* We must not ignore the symbol value. If the symbol is
within the same section, the relocation should have already
the beginning of the symbol's section, so we must not cancel
out the symbol's value, otherwise we'll be adding it in
twice. */
- if (sym != NULL && sym->n_scnum != 0)
- addend += sym->n_value;
+ if (sym != NULL && sym->n_scnum != 0)
+ addend += sym->n_value;
#endif
- }
+ }
val = 0;
else
{
sec = sections[symndx];
- val = (sec->output_section->vma
+ val = (sec->output_section->vma
+ sec->output_offset
+ sym->n_value
- sec->vma);
}
else
{
- /* We don't output the stubs if we are generating a
- relocatable output file, since we may as well leave the
- stub generation to the final linker pass. If we fail to
+ /* We don't output the stubs if we are generating a
+ relocatable output file, since we may as well leave the
+ stub generation to the final linker pass. If we fail to
verify that the name is defined, we'll try to build stubs
for an undefined name... */
- if (! bfd_link_relocatable (info)
+ if (! bfd_link_relocatable (info)
&& ( h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak))
- {
+ {
asection * h_sec = h->root.u.def.section;
const char * name = h->root.root.string;
+ h_sec->output_section->vma
+ h_sec->output_offset);
- if (howto->type == ARM_26)
- {
- if ( h->symbol_class == C_THUMBSTATFUNC
+ if (howto->type == ARM_26)
+ {
+ if ( h->symbol_class == C_THUMBSTATFUNC
|| h->symbol_class == C_THUMBEXTFUNC)
{
/* Arm code calling a Thumb function. */
- unsigned long int tmp;
- bfd_vma my_offset;
- asection * s;
- long int ret_offset;
- struct coff_link_hash_entry * myh;
+ unsigned long int tmp;
+ bfd_vma my_offset;
+ asection * s;
+ long int ret_offset;
+ struct coff_link_hash_entry * myh;
struct coff_arm_link_hash_table * globals;
myh = find_arm_glue (info, name, input_bfd);
if (myh == NULL)
- return FALSE;
+ return false;
globals = coff_arm_hash_table (info);
&& ! 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"),
- h_sec->owner, input_bfd, name);
+ (_("%pB(%s): warning: interworking not enabled; "
+ "first occurrence: %pB: arm call to thumb"),
+ h_sec->owner, name, input_bfd);
--my_offset;
myh->root.u.def.value = my_offset;
bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
s->contents + my_offset + 8);
- if (info->base_file
+ if (info->base_file
&& !arm_emit_base_file_entry (info, output_bfd,
s, my_offset + 8))
- return FALSE;
+ return false;
}
BFD_ASSERT (my_offset <= globals->arm_glue_size);
contents + rel->r_vaddr - input_section->vma);
done = 1;
}
- }
+ }
#ifndef ARM_WINCE
/* Note: We used to check for ARM_THUMB9 and ARM_THUMB12. */
- else if (howto->type == ARM_THUMB23)
- {
- if ( h->symbol_class == C_EXT
+ else if (howto->type == ARM_THUMB23)
+ {
+ if ( h->symbol_class == C_EXT
|| h->symbol_class == C_STAT
|| h->symbol_class == C_LABEL)
{
/* Thumb code calling an ARM function. */
- asection * s = 0;
- bfd_vma my_offset;
- unsigned long int tmp;
- long int ret_offset;
- struct coff_link_hash_entry * myh;
- struct coff_arm_link_hash_table * globals;
+ asection * s = 0;
+ bfd_vma my_offset;
+ unsigned long int tmp;
+ long int ret_offset;
+ struct coff_link_hash_entry * myh;
+ struct coff_arm_link_hash_table * globals;
myh = find_thumb_glue (info, name, input_bfd);
if (myh == NULL)
- return FALSE;
+ return false;
globals = coff_arm_hash_table (info);
&& ! 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"
- " consider relinking with --support-old-code enabled"),
- h_sec->owner, input_bfd, name);
+ (_("%pB(%s): warning: interworking not enabled; "
+ "first occurrence: %pB: thumb call to arm; "
+ "consider relinking with --support-old-code "
+ "enabled"),
+ h_sec->owner, name, input_bfd);
-- my_offset;
myh->root.u.def.value = my_offset;
bfd_put_32 (output_bfd, h_val,
s->contents + my_offset + 16);
- if (info->base_file
+ if (info->base_file
&& !arm_emit_base_file_entry (info,
output_bfd, s,
my_offset + 16))
- return FALSE;
+ return false;
}
else
{
contents + rel->r_vaddr - input_section->vma);
done = 1;
- }
- }
+ }
+ }
#endif
- }
+ }
- /* If the relocation type and destination symbol does not
- fall into one of the above categories, then we can just
- perform a direct link. */
+ /* If the relocation type and destination symbol does not
+ fall into one of the above categories, then we can just
+ perform a direct link. */
if (done)
rstat = bfd_reloc_ok;
}
else if (! bfd_link_relocatable (info))
- {
- if (! ((*info->callbacks->undefined_symbol)
- (info, h->root.root.string, input_bfd, input_section,
- rel->r_vaddr - input_section->vma, TRUE)))
- return FALSE;
- }
+ (*info->callbacks->undefined_symbol)
+ (info, h->root.root.string, input_bfd, input_section,
+ rel->r_vaddr - input_section->vma, true);
}
/* Emit a reloc if the backend thinks it needs it. */
&& pe_data(output_bfd)->in_reloc_p(output_bfd, howto)
&& !arm_emit_base_file_entry (info, output_bfd, input_section,
rel->r_vaddr))
- return FALSE;
+ return false;
if (done)
rstat = bfd_reloc_ok;
/* Only perform this fix during the final link, not a relocatable link. */
else if (! bfd_link_relocatable (info)
&& howto->type == ARM_THUMB23)
- {
- /* This is pretty much a copy of what the default
- _bfd_final_link_relocate and _bfd_relocate_contents
- routines do to perform a relocation, with special
- processing for the split addressing of the Thumb BL
- instruction. Again, it would probably be simpler adding a
- ThumbBRANCH23 specific macro expansion into the default
- code. */
+ {
+ /* This is pretty much a copy of what the default
+ _bfd_final_link_relocate and _bfd_relocate_contents
+ routines do to perform a relocation, with special
+ processing for the split addressing of the Thumb BL
+ instruction. Again, it would probably be simpler adding a
+ ThumbBRANCH23 specific macro expansion into the default
+ code. */
- bfd_vma address = rel->r_vaddr - input_section->vma;
+ bfd_vma address = rel->r_vaddr - input_section->vma;
if (address > high_address)
rstat = bfd_reloc_outofrange;
- else
- {
- bfd_vma relocation = val + addend;
+ else
+ {
+ bfd_vma relocation = val + addend;
int size = bfd_get_reloc_size (howto);
- bfd_boolean overflow = FALSE;
+ bool overflow = false;
bfd_byte *location = contents + address;
bfd_vma x = bfd_get_32 (input_bfd, location);
bfd_vma src_mask = 0x007FFFFE;
BFD_ASSERT (size == 4);
- /* howto->pc_relative should be TRUE for type 14 BRANCH23. */
- relocation -= (input_section->output_section->vma
- + input_section->output_offset);
+ /* howto->pc_relative should be TRUE for type 14 BRANCH23. */
+ relocation -= (input_section->output_section->vma
+ + input_section->output_offset);
- /* howto->pcrel_offset should be TRUE for type 14 BRANCH23. */
- relocation -= address;
+ /* howto->pcrel_offset should be TRUE for type 14 BRANCH23. */
+ relocation -= address;
/* No need to negate the relocation with BRANCH23. */
/* howto->complain_on_overflow == complain_overflow_signed for BRANCH23. */
/* Assumes two's complement. */
if ( signed_check > reloc_signed_max
|| signed_check < reloc_signed_min)
- overflow = TRUE;
+ overflow = true;
/* Put the relocation into the correct bits.
For a BLX instruction, make sure that the relocation is rounded up
which specifies that bit 1 of the target address will come from bit
1 of the base address. */
if (bfd_big_endian (input_bfd))
- {
+ {
if ((x & 0x1800) == 0x0800 && (relocation & 0x02))
relocation += 2;
relocation = (((relocation & 0xffe) >> 1) | ((relocation << 4) & 0x07ff0000));
}
else
- {
+ {
if ((x & 0x18000000) == 0x08000000 && (relocation & 0x02))
relocation += 2;
relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
bfd_put_32 (input_bfd, x, location);
rstat = overflow ? bfd_reloc_overflow : bfd_reloc_ok;
- }
- }
+ }
+ }
#endif
else
- if (bfd_link_relocatable (info) && ! howto->partial_inplace)
- rstat = bfd_reloc_ok;
- else
+ if (bfd_link_relocatable (info) && ! howto->partial_inplace)
+ rstat = bfd_reloc_ok;
+ else
rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
contents,
rel->r_vaddr - input_section->vma,
{
/* Determine if we need to set the bottom bit of a relocated address
because the address is the address of a Thumb code symbol. */
- int patchit = FALSE;
+ int patchit = false;
if (h != NULL
&& ( h->symbol_class == C_THUMBSTATFUNC
|| h->symbol_class == C_THUMBEXTFUNC))
{
- patchit = TRUE;
+ patchit = true;
}
else if (sym != NULL
&& sym->n_scnum > N_UNDEF)
/* No hash entry - use the symbol instead. */
if ( sym->n_sclass == C_THUMBSTATFUNC
|| sym->n_sclass == C_THUMBEXTFUNC)
- patchit = TRUE;
+ patchit = true;
}
if (patchit)
{
bfd_byte * location = contents + rel->r_vaddr - input_section->vma;
- bfd_vma x = bfd_get_32 (input_bfd, location);
+ bfd_vma x = bfd_get_32 (input_bfd, location);
bfd_put_32 (input_bfd, x | 1, location);
}
case bfd_reloc_ok:
break;
case bfd_reloc_outofrange:
- (*_bfd_error_handler)
- (_("%B: bad reloc address 0x%lx in section `%A'"),
- input_bfd, input_section, (unsigned long) rel->r_vaddr);
- return FALSE;
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: bad reloc address %#" PRIx64 " in section `%pA'"),
+ input_bfd, (uint64_t) rel->r_vaddr, input_section);
+ return false;
case bfd_reloc_overflow:
{
const char *name;
{
name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
if (name == NULL)
- return FALSE;
+ return false;
}
- if (! ((*info->callbacks->reloc_overflow)
- (info, (h ? &h->root : NULL), name, howto->name,
- (bfd_vma) 0, input_bfd, input_section,
- rel->r_vaddr - input_section->vma)))
- return FALSE;
+ (*info->callbacks->reloc_overflow)
+ (info, (h ? &h->root : NULL), name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section,
+ rel->r_vaddr - input_section->vma);
}
}
}
- return TRUE;
+ return true;
}
#ifndef COFF_IMAGE_WITH_PE
-bfd_boolean
+bool
bfd_arm_allocate_interworking_sections (struct bfd_link_info * info)
{
- asection * s;
- bfd_byte * foo;
+ asection * s;
+ bfd_byte * foo;
struct coff_arm_link_hash_table * globals;
globals = coff_arm_hash_table (info);
s->contents = foo;
}
- return TRUE;
+ return true;
}
static void
-record_arm_to_thumb_glue (struct bfd_link_info * info,
+record_arm_to_thumb_glue (struct bfd_link_info * info,
struct coff_link_hash_entry * h)
{
- const char * name = h->root.root.string;
- register asection * s;
- char * tmp_name;
- struct coff_link_hash_entry * myh;
- struct bfd_link_hash_entry * bh;
+ const char * name = h->root.root.string;
+ register asection * s;
+ char * tmp_name;
+ struct coff_link_hash_entry * myh;
+ struct bfd_link_hash_entry * bh;
struct coff_arm_link_hash_table * globals;
bfd_vma val;
- bfd_size_type amt;
+ size_t amt;
globals = coff_arm_hash_table (info);
sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
myh = coff_link_hash_lookup
- (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
+ (coff_hash_table (info), tmp_name, false, false, true);
if (myh != NULL)
{
bh = NULL;
val = globals->arm_glue_size + 1;
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
- BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
+ BSF_GLOBAL, s, val, NULL, true, false, &bh);
free (tmp_name);
#ifndef ARM_WINCE
static void
-record_thumb_to_arm_glue (struct bfd_link_info * info,
+record_thumb_to_arm_glue (struct bfd_link_info * info,
struct coff_link_hash_entry * h)
{
- const char * name = h->root.root.string;
- asection * s;
- char * tmp_name;
- struct coff_link_hash_entry * myh;
- struct bfd_link_hash_entry * bh;
+ const char * name = h->root.root.string;
+ asection * s;
+ char * tmp_name;
+ struct coff_link_hash_entry * myh;
+ struct bfd_link_hash_entry * bh;
struct coff_arm_link_hash_table * globals;
bfd_vma val;
- bfd_size_type amt;
+ size_t amt;
globals = coff_arm_hash_table (info);
sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
myh = coff_link_hash_lookup
- (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
+ (coff_hash_table (info), tmp_name, false, false, true);
if (myh != NULL)
{
bh = NULL;
val = globals->thumb_glue_size + 1;
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
- BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
+ BSF_GLOBAL, s, val, NULL, true, false, &bh);
/* If we mark it 'thumb', the disassembler will do a better job. */
myh = (struct coff_link_hash_entry *) bh;
bh = NULL;
val = globals->thumb_glue_size + (globals->support_old_code ? 8 : 4);
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
- BSF_LOCAL, s, val, NULL, TRUE, FALSE, &bh);
+ BSF_LOCAL, s, val, NULL, true, false, &bh);
free (tmp_name);
This function is called from the linker scripts in ld/emultempl/
{armcoff/pe}.em */
-bfd_boolean
-bfd_arm_get_bfd_for_interworking (bfd * abfd,
+bool
+bfd_arm_get_bfd_for_interworking (bfd * abfd,
struct bfd_link_info * info)
{
struct coff_arm_link_hash_table * globals;
- flagword flags;
- asection * sec;
+ flagword flags;
+ asection * sec;
/* If we are only performing a partial link do not bother
getting a bfd to hold the glue. */
if (bfd_link_relocatable (info))
- return TRUE;
+ return true;
globals = coff_arm_hash_table (info);
BFD_ASSERT (globals != NULL);
if (globals->bfd_of_glue_owner != NULL)
- return TRUE;
+ return true;
sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
sec = bfd_make_section_with_flags (abfd, ARM2THUMB_GLUE_SECTION_NAME,
flags);
if (sec == NULL
- || ! bfd_set_section_alignment (abfd, sec, 2))
- return FALSE;
+ || !bfd_set_section_alignment (sec, 2))
+ return false;
}
sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
flags);
if (sec == NULL
- || ! bfd_set_section_alignment (abfd, sec, 2))
- return FALSE;
+ || !bfd_set_section_alignment (sec, 2))
+ return false;
}
/* Save the bfd for later use. */
globals->bfd_of_glue_owner = abfd;
- return TRUE;
+ return true;
}
-bfd_boolean
-bfd_arm_process_before_allocation (bfd * abfd,
+bool
+bfd_arm_process_before_allocation (bfd * abfd,
struct bfd_link_info * info,
- int support_old_code)
+ int support_old_code)
{
asection * sec;
struct coff_arm_link_hash_table * globals;
/* If we are only performing a partial link do not bother
to construct any glue. */
if (bfd_link_relocatable (info))
- return TRUE;
+ return true;
/* Here we have a bfd that is to be included on the link. We have a hook
to do reloc rummaging, before section sizes are nailed down. */
sec = abfd->sections;
if (sec == NULL)
- return TRUE;
+ return true;
for (; sec != NULL; sec = sec->next)
{
for (rel = i; rel < i + sec->reloc_count; ++rel)
{
- unsigned short r_type = rel->r_type;
- long symndx;
- struct coff_link_hash_entry * h;
+ unsigned short r_type = rel->r_type;
+ long symndx;
+ struct coff_link_hash_entry * h;
symndx = rel->r_symndx;
/* If the index is outside of the range of our table, something has gone wrong. */
if (symndx >= obj_conv_table_size (abfd))
{
- _bfd_error_handler (_("%B: illegal symbol index in reloc: %d"),
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: illegal symbol index in reloc: %ld"),
abfd, symndx);
continue;
}
}
}
- return TRUE;
+ return true;
}
#endif /* ! defined (COFF_IMAGE_WITH_PE) */
-#define coff_bfd_reloc_type_lookup coff_arm_reloc_type_lookup
-#define coff_bfd_reloc_name_lookup coff_arm_reloc_name_lookup
-#define coff_relocate_section coff_arm_relocate_section
-#define coff_bfd_is_local_label_name coff_arm_is_local_label_name
+#define coff_bfd_reloc_type_lookup coff_arm_reloc_type_lookup
+#define coff_bfd_reloc_name_lookup coff_arm_reloc_name_lookup
+#define coff_relocate_section coff_arm_relocate_section
+#define coff_bfd_is_local_label_name coff_arm_is_local_label_name
#define coff_adjust_symndx coff_arm_adjust_symndx
-#define coff_link_output_has_begun coff_arm_link_output_has_begun
+#define coff_link_output_has_begun coff_arm_link_output_has_begun
#define coff_final_link_postscript coff_arm_final_link_postscript
#define coff_bfd_merge_private_bfd_data coff_arm_merge_private_bfd_data
#define coff_bfd_print_private_bfd_data coff_arm_print_private_bfd_data
-#define coff_bfd_set_private_flags _bfd_coff_arm_set_private_flags
-#define coff_bfd_copy_private_bfd_data coff_arm_copy_private_bfd_data
+#define coff_bfd_set_private_flags _bfd_coff_arm_set_private_flags
+#define coff_bfd_copy_private_bfd_data coff_arm_copy_private_bfd_data
#define coff_bfd_link_hash_table_create coff_arm_link_hash_table_create
/* When doing a relocatable link, we want to convert ARM_26 relocs
into ARM_26D relocs. */
-static bfd_boolean
+static bool
coff_arm_adjust_symndx (bfd *obfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info ATTRIBUTE_UNUSED,
bfd *ibfd,
asection *sec,
struct internal_reloc *irel,
- bfd_boolean *adjustedp)
+ bool *adjustedp)
{
if (irel->r_type == ARM_26)
{
&& h->root.u.def.section->output_section == sec->output_section)
irel->r_type = ARM_26D;
}
- *adjustedp = FALSE;
- return TRUE;
+ *adjustedp = false;
+ return true;
}
/* Called when merging the private data areas of two BFDs.
attempting to merge binaries compiled for different ARM
targets, eg different CPUs or different APCS's. */
-static bfd_boolean
-coff_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
+static bool
+coff_arm_merge_private_bfd_data (bfd * ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
BFD_ASSERT (ibfd != NULL && obfd != NULL);
if (ibfd == obfd)
- return TRUE;
+ return true;
/* If the two formats are different we cannot merge anything.
This is not an error, since it is permissable to change the
input and output formats. */
if ( ibfd->xvec->flavour != bfd_target_coff_flavour
|| obfd->xvec->flavour != bfd_target_coff_flavour)
- return TRUE;
+ return true;
/* Determine what should happen if the input ARM architecture
does not match the output ARM architecture. */
if (! bfd_arm_merge_machines (ibfd, obfd))
- return FALSE;
+ return false;
/* Verify that the APCS is the same for the two BFDs. */
if (APCS_SET (ibfd))
{
_bfd_error_handler
/* xgettext: c-format */
- (_("error: %B is compiled for APCS-%d, whereas %B is compiled for APCS-%d"),
- ibfd, obfd,
- APCS_26_FLAG (ibfd) ? 26 : 32,
- APCS_26_FLAG (obfd) ? 26 : 32
+ (_("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
);
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
}
if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
{
- const char *msg;
-
if (APCS_FLOAT_FLAG (ibfd))
/* xgettext: c-format */
- msg = _("error: %B passes floats in float registers, whereas %B passes them in integer registers");
+ _bfd_error_handler
+ (_("error: %pB passes floats in float registers, "
+ "whereas %pB passes them in integer registers"),
+ ibfd, obfd);
else
/* xgettext: c-format */
- msg = _("error: %B passes floats in integer registers, whereas %B passes them in float registers");
-
- _bfd_error_handler (msg, ibfd, obfd);
+ _bfd_error_handler
+ (_("error: %pB passes floats in integer registers, "
+ "whereas %pB passes them in float registers"),
+ ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
}
if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
{
- const char * msg;
-
if (PIC_FLAG (ibfd))
/* xgettext: c-format */
- msg = _("error: %B is compiled as position independent code, whereas target %B is absolute position");
+ _bfd_error_handler
+ (_("error: %pB is compiled as position independent code, "
+ "whereas target %pB is absolute position"),
+ ibfd, obfd);
else
/* xgettext: c-format */
- msg = _("error: %B is compiled as absolute position code, whereas target %B is position independent");
- _bfd_error_handler (msg, ibfd, obfd);
+ _bfd_error_handler
+ (_("error: %pB is compiled as absolute position code, "
+ "whereas target %pB is position independent"),
+ ibfd, obfd);
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
}
}
else
/* If the src and dest differ in their interworking issue a warning. */
if (INTERWORK_FLAG (obfd) != INTERWORK_FLAG (ibfd))
{
- const char * msg;
-
if (INTERWORK_FLAG (ibfd))
/* xgettext: c-format */
- msg = _("Warning: %B supports interworking, whereas %B does not");
+ _bfd_error_handler (_("warning: %pB supports interworking, "
+ "whereas %pB does not"),
+ ibfd, obfd);
else
/* xgettext: c-format */
- msg = _("Warning: %B does not support interworking, whereas %B does");
-
- _bfd_error_handler (msg, ibfd, obfd);
+ _bfd_error_handler
+ (_("warning: %pB does not support interworking, "
+ "whereas %pB does"),
+ ibfd, obfd);
}
}
else
}
}
- return TRUE;
+ return true;
}
/* Display the flags field. */
-static bfd_boolean
+static bool
coff_arm_print_private_bfd_data (bfd * abfd, void * ptr)
{
FILE * file = (FILE *) ptr;
BFD_ASSERT (abfd != NULL && ptr != NULL);
- /* xgettext:c-format */
fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
if (APCS_SET (abfd))
fputc ('\n', file);
- return TRUE;
+ return true;
}
/* Copies the given flags into the coff_tdata.flags field.
Note: Although this function is static, it is explicitly
called from both coffcode.h and peicode.h. */
-static bfd_boolean
+static bool
_bfd_coff_arm_set_private_flags (bfd * abfd, flagword flags)
{
flagword flag;
if (APCS_SET (abfd)
&& ( (APCS_26_FLAG (abfd) != flag)
|| (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
- || (PIC_FLAG (abfd) != (flags & F_PIC))
+ || (PIC_FLAG (abfd) != (flags & F_PIC))
))
- return FALSE;
+ return false;
flag |= (flags & (F_APCS_FLOAT | F_PIC));
if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
{
if (flag)
- /* xgettext: c-format */
- _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
- /* xgettext: c-format */
- _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;
}
SET_INTERWORK_FLAG (abfd, flag);
- return TRUE;
+ return true;
}
/* Copy the important parts of the target specific data
from one instance of a BFD to another. */
-static bfd_boolean
+static bool
coff_arm_copy_private_bfd_data (bfd * src, bfd * dest)
{
BFD_ASSERT (src != NULL && dest != NULL);
if (src == dest)
- return TRUE;
+ return true;
/* If the destination is not in the same format as the source, do not do
the copy. */
if (src->xvec != dest->xvec)
- return TRUE;
+ return true;
/* Copy the flags field. */
if (APCS_SET (src))
{
/* If the src and dest have different APCS flag bits set, fail. */
if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
- return FALSE;
+ return false;
if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
- return FALSE;
+ return false;
if (PIC_FLAG (dest) != PIC_FLAG (src))
- return FALSE;
+ return false;
}
else
SET_APCS_FLAGS (dest, APCS_26_FLAG (src) | APCS_FLOAT_FLAG (src)
if (INTERWORK_FLAG (dest))
{
/* xgettext:c-format */
- _bfd_error_handler (("\
-Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
- dest, src);
+ _bfd_error_handler
+ (_("warning: clearing the interworking flag of %pB "
+ "because non-interworking code in %pB has been "
+ "linked with it"),
+ dest, src);
}
SET_INTERWORK_FLAG (dest, 0);
}
}
- return TRUE;
+ return true;
}
/* Note: the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
b) Allow other prefixes than ".", e.g. an empty prefix would cause all
labels of the form Lxxx to be stripped. */
-static bfd_boolean
-coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
+static bool
+coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
const char * name)
{
#ifdef USER_LABEL_PREFIX
size_t len = strlen (USER_LABEL_PREFIX);
if (strncmp (name, USER_LABEL_PREFIX, len) == 0)
- return FALSE;
+ return false;
}
#endif
size_t len = strlen (LOCAL_LABEL_PREFIX);
if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
- return FALSE;
+ return false;
/* Perform the checks below for the rest of the name. */
name += len;
This does depend on bfd_make_section attaching a new section to the
end of the section list for the bfd. */
-static bfd_boolean
+static bool
coff_arm_link_output_has_begun (bfd * sub, struct coff_final_link_info * info)
{
return (sub->output_has_begun
|| sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
}
-static bfd_boolean
+static bool
coff_arm_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
struct coff_final_link_info * pfinfo)
{
if (globals->bfd_of_glue_owner != NULL)
{
if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
- return FALSE;
+ return false;
- globals->bfd_of_glue_owner->output_has_begun = TRUE;
+ globals->bfd_of_glue_owner->output_has_begun = true;
}
return bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
projects / deliverable / binutils-gdb.git / blobdiff