/* BFD back-end for ARM COFF files.
- Copyright (C) 1990-2018 Free Software Foundation, Inc.
+ Copyright (C) 1990-2022 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)
{
if (diff != 0)
{
reloc_howto_type *howto = reloc_entry->howto;
- unsigned char *addr = (unsigned char *) data + reloc_entry->address;
+ bfd_size_type octets = (reloc_entry->address
+ * OCTETS_PER_BYTE (abfd, input_section));
+ unsigned char *addr = (unsigned char *) data + octets;
- if (! bfd_reloc_offset_in_range (howto, abfd, input_section,
- reloc_entry->address
- * bfd_octets_per_byte (abfd)))
+ if (!bfd_reloc_offset_in_range (howto, abfd, input_section, octets))
return bfd_reloc_outofrange;
switch (howto->size)
#endif
#ifndef PCRELOFFSET
-#define PCRELOFFSET TRUE
+#define PCRELOFFSET true
#endif
/* These most certainly belong somewhere else. Just had to get rid of
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)
{
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
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
{
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 */
{
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 */
/* 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,
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
2,
2,
24,
- TRUE,
+ true,
0,
complain_overflow_signed,
aoutarm_fix_pcrel_26 ,
"ARM_26",
- TRUE,
+ true,
0x00ffffff,
0x00ffffff,
- FALSE);
+ false);
addend -= rel->r_vaddr - input_section->vma;
#ifdef ARM_WINCE
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
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 */
- (_("%pB(%s): warning: interworking not enabled.\n"
- " first occurrence: %pB: arm call to thumb"),
+ (_("%pB(%s): warning: interworking not enabled; "
+ "first occurrence: %pB: arm call to thumb"),
h_sec->owner, name, input_bfd);
--my_offset;
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);
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 */
- (_("%pB(%s): warning: interworking not enabled.\n"
- " first occurrence: %pB: thumb call to arm\n"
- " consider relinking with --support-old-code enabled"),
+ (_("%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;
&& !arm_emit_base_file_entry (info,
output_bfd, s,
my_offset + 16))
- return FALSE;
+ return false;
}
else
{
else if (! bfd_link_relocatable (info))
(*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd, input_section,
- rel->r_vaddr - input_section->vma, TRUE);
+ 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;
{
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;
/* 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
{
/* 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)
case bfd_reloc_outofrange:
_bfd_error_handler
/* xgettext:c-format */
- (_("%pB: bad reloc address %#Lx in section `%pA'"),
- input_bfd, rel->r_vaddr, input_section);
- return FALSE;
+ (_("%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;
}
(*info->callbacks->reloc_overflow)
}
}
- return TRUE;
+ return true;
}
#ifndef COFF_IMAGE_WITH_PE
-bfd_boolean
+bool
bfd_arm_allocate_interworking_sections (struct bfd_link_info * info)
{
asection * s;
s->contents = foo;
}
- return TRUE;
+ return true;
}
static void
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);
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
+bool
bfd_arm_get_bfd_for_interworking (bfd * abfd,
struct bfd_link_info * info)
{
/* 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
+bool
bfd_arm_process_before_allocation (bfd * abfd,
struct bfd_link_info * info,
int support_old_code)
/* 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)
{
}
}
- return TRUE;
+ return true;
}
#endif /* ! defined (COFF_IMAGE_WITH_PE) */
/* 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
+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: %pB is compiled for APCS-%d, whereas %pB is compiled for APCS-%d"),
+ (_("error: %pB is compiled for APCS-%d, "
+ "whereas %pB is compiled for APCS-%d"),
ibfd, APCS_26_FLAG (ibfd) ? 26 : 32,
obfd, APCS_26_FLAG (obfd) ? 26 : 32
);
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
}
if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
{
if (APCS_FLOAT_FLAG (ibfd))
/* xgettext: c-format */
- _bfd_error_handler (_("\
-error: %pB passes floats in float registers, whereas %pB passes them in integer registers"),
- ibfd, obfd);
+ _bfd_error_handler
+ (_("error: %pB passes floats in float registers, "
+ "whereas %pB passes them in integer registers"),
+ ibfd, obfd);
else
/* xgettext: c-format */
- _bfd_error_handler (_("\
-error: %pB passes floats in integer registers, whereas %pB passes them in float registers"),
- 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))
{
if (PIC_FLAG (ibfd))
/* xgettext: c-format */
- _bfd_error_handler (_("\
-error: %pB is compiled as position independent code, whereas target %pB is absolute position"),
- ibfd, obfd);
+ _bfd_error_handler
+ (_("error: %pB is compiled as position independent code, "
+ "whereas target %pB is absolute position"),
+ ibfd, obfd);
else
/* xgettext: c-format */
- _bfd_error_handler (_("\
-error: %pB is compiled as absolute position code, whereas target %pB is position independent"),
- 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 (INTERWORK_FLAG (ibfd))
/* xgettext: c-format */
- _bfd_error_handler (_("\
-Warning: %pB supports interworking, whereas %pB does not"),
+ _bfd_error_handler (_("warning: %pB supports interworking, "
+ "whereas %pB does not"),
ibfd, obfd);
else
/* xgettext: c-format */
- _bfd_error_handler (_("\
-Warning: %pB does not support interworking, whereas %pB does"),
- 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;
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;
|| (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
|| (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)
- _bfd_error_handler (_("Warning: Not setting interworking flag of %pB since it has already been specified as non-interworking"),
+ _bfd_error_handler (_("warning: not setting interworking flag of %pB since it has already been specified as non-interworking"),
abfd);
else
- _bfd_error_handler (_("Warning: Clearing the interworking flag of %pB 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 %pB because non-interworking code in %pB 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
+static bool
coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
const char * name)
{
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 / binutils-gdb.git / blobdiff