/* BFD back-end for ARM COFF files.
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002
+ 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
Written by Cygnus Support.
typedef unsigned short int insn16;
/* Forward declarations for stupid compilers. */
-static boolean coff_arm_relocate_section
+static bfd_boolean coff_arm_relocate_section
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
struct internal_reloc *, struct internal_syment *, asection **));
static bfd_reloc_status_type aoutarm_fix_pcrel_26_done
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type coff_arm_reloc
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
-static boolean coff_arm_adjust_symndx
+static bfd_boolean coff_arm_adjust_symndx
PARAMS ((bfd *, struct bfd_link_info *, bfd *,
- asection *, struct internal_reloc *, boolean *));
+ asection *, struct internal_reloc *, bfd_boolean *));
static reloc_howto_type * coff_arm_rtype_to_howto
PARAMS ((bfd *, asection *, struct internal_reloc *,
struct coff_link_hash_entry *, struct internal_syment *,
PARAMS ((struct bfd_link_info *, struct coff_link_hash_entry *));
#endif
#endif
-static boolean coff_arm_merge_private_bfd_data
+static bfd_boolean coff_arm_merge_private_bfd_data
PARAMS ((bfd *, bfd *));
-static boolean coff_arm_print_private_bfd_data
+static bfd_boolean coff_arm_print_private_bfd_data
PARAMS ((bfd *, PTR));
-static boolean _bfd_coff_arm_set_private_flags
+static bfd_boolean _bfd_coff_arm_set_private_flags
PARAMS ((bfd *, flagword));
-static boolean coff_arm_copy_private_bfd_data
+static bfd_boolean coff_arm_copy_private_bfd_data
PARAMS ((bfd *, bfd *));
-static boolean coff_arm_is_local_label_name
+static bfd_boolean coff_arm_is_local_label_name
PARAMS ((bfd *, const char *));
-static boolean coff_arm_link_output_has_begun
+static bfd_boolean coff_arm_link_output_has_begun
PARAMS ((bfd *, struct coff_final_link_info *));
-static boolean coff_arm_final_link_postscript
+static bfd_boolean coff_arm_final_link_postscript
PARAMS ((bfd *, struct coff_final_link_info *));
static void arm_emit_base_file_entry
PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_vma));
#endif
#ifndef PCRELOFFSET
-#define PCRELOFFSET true
+#define PCRELOFFSET TRUE
#endif
/* These most certainly belong somewhere else. Just had to get rid of
0,
2,
32,
- false,
+ FALSE,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_32",
- true,
+ TRUE,
0xffffffff,
0xffffffff,
PCRELOFFSET),
0,
2,
32,
- false,
+ FALSE,
0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_RVA32",
- 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),
1,
1,
11,
- true,
+ TRUE,
0,
complain_overflow_signed,
coff_thumb_pcrel_12 ,
"ARM_THUMB12",
- false,
+ FALSE,
0x000007ff,
0x000007ff,
PCRELOFFSET),
2,
2,
24,
- false,
+ FALSE,
0,
complain_overflow_dont,
aoutarm_fix_pcrel_26_done,
"ARM_26D",
- true,
+ TRUE,
0x00ffffff,
0x0,
- false),
+ FALSE),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
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),
#else /* not ARM_WINCE */
- HOWTO (ARM_8, /* type */
+ HOWTO (ARM_8, /* type */
0, /* rightshift */
0, /* size */
8, /* bitsize */
- false, /* pc_relative */
+ FALSE, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
- coff_arm_reloc, /* special_function */
+ coff_arm_reloc, /* special_function */
"ARM_8", /* name */
- true, /* partial_inplace */
+ TRUE, /* partial_inplace */
0x000000ff, /* src_mask */
0x000000ff, /* dst_mask */
PCRELOFFSET /* pcrel_offset */),
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)
#define NUM_RELOCS NUM_ELEM (aoutarm_std_reloc_howto)
#ifdef COFF_WITH_PE
-static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
-/* Return true if this relocation should
+static bfd_boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
+/* Return TRUE if this relocation should
appear in the output .reloc section. */
-static boolean
+static bfd_boolean
in_reloc_p (abfd, howto)
bfd * abfd ATTRIBUTE_UNUSED;
reloc_howto_type * howto;
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 */
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 */
ARM/Thumb builds. It is only the code marked THUMBEXTENSION that
is different from the original. */
-static boolean
+static bfd_boolean
coff_arm_relocate_section (output_bfd, info, input_bfd, input_section,
contents, relocs, syms, sections)
bfd *output_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 relocateable link. However, we want to convert
+ when doing a relocatable link. However, we want to convert
ARM26 to ARM26D relocs if possible. We return a fake howto in
this case without pcrel_offset set, and adjust the addend to
compensate. */
if (rel->r_type == ARM_26
&& h != NULL
- && info->relocateable
+ && info->relocatable
&& (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
&& (h->root.u.def.section->output_section
2,
2,
24,
- true,
+ TRUE,
0,
complain_overflow_signed,
aoutarm_fix_pcrel_26 ,
"ARM_26",
- false,
+ FALSE,
0x00ffffff,
0x00ffffff,
- false);
+ FALSE);
addend -= rel->r_vaddr - input_section->vma;
howto = &fake_arm26_reloc;
#ifdef ARM_WINCE
/* MS ARM-CE makes the reloc relative to the opcode's pc, not
the next opcode's pc, so is off by one. */
- if (howto->pc_relative && !info->relocateable)
+#if 0 /* This appears to have been true for WINCE 2.0, but it is not
+ true for WINCE 3.0. */
+ if (howto->pc_relative && !info->relocatable)
addend -= 8;
+#endif
#endif
- /* If we are doing a relocateable link, then we can just ignore
+ /* 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 relocateable link,
+ 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 (info->relocateable)
+ if (info->relocatable)
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
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 (! info->relocateable
+ if (! info->relocatable
&& ( h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak))
{
myh = find_arm_glue (info, name, input_bfd);
if (myh == NULL)
- return false;
+ return FALSE;
globals = coff_arm_hash_table (info);
myh = find_thumb_glue (info, name, input_bfd);
if (myh == NULL)
- return false;
+ return FALSE;
globals = coff_arm_hash_table (info);
+ sec->output_offset);
}
- else if (! info->relocateable)
+ else if (! info->relocatable)
{
if (! ((*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd, input_section,
- rel->r_vaddr - input_section->vma, true)))
- return false;
+ rel->r_vaddr - input_section->vma, TRUE)))
+ return FALSE;
}
}
rstat = bfd_reloc_ok;
#ifndef ARM_WINCE
/* Only perform this fix during the final link, not a relocatable link. nickc@cygnus.com */
- else if (! info->relocateable
+ else if (! info->relocatable
&& howto->type == ARM_THUMB23)
{
/* This is pretty much a copy of what the default
rstat = bfd_reloc_outofrange;
else
{
- bfd_vma relocation = val + addend;
- int size = bfd_get_reloc_size (howto);
- boolean overflow = false;
- bfd_byte * location = contents + address;
- bfd_vma x = bfd_get_32 (input_bfd, location);
- bfd_vma src_mask = 0x007FFFFE;
- bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
- bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
- bfd_vma check;
- bfd_signed_vma signed_check;
- bfd_vma add;
- bfd_signed_vma signed_add;
+ bfd_vma relocation = val + addend;
+ int size = bfd_get_reloc_size (howto);
+ bfd_boolean overflow = FALSE;
+ bfd_byte *location = contents + address;
+ bfd_vma x = bfd_get_32 (input_bfd, location);
+ bfd_vma src_mask = 0x007FFFFE;
+ bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
+ bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
+ bfd_vma check;
+ bfd_signed_vma signed_check;
+ bfd_vma add;
+ bfd_signed_vma signed_add;
BFD_ASSERT (size == 4);
/* 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
Is this the best way to fix up thumb addresses? krk@cygnus.com
Probably not, but it works, and if it works it don't need fixing! nickc@cygnus.com */
/* Only perform this fix during the final link, not a relocatable link. nickc@cygnus.com */
- if (! info->relocateable
+ if (! info->relocatable
&& (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
{
/* 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->class == C_THUMBSTATFUNC
|| h->class == C_THUMBEXTFUNC))
{
- patchit = true;
+ patchit = TRUE;
}
else if (sym != NULL
&& sym->n_scnum > N_UNDEF)
if ( sym->n_sclass == C_THUMBSTATFUNC
|| sym->n_sclass == C_THUMBEXTFUNC)
- patchit = true;
+ patchit = TRUE;
}
if (patchit)
bfd_archive_filename (input_bfd),
(unsigned long) rel->r_vaddr,
bfd_get_section_name (input_bfd, input_section));
- return false;
+ 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, name, howto->name, (bfd_vma) 0, input_bfd,
input_section, rel->r_vaddr - input_section->vma)))
- return false;
+ return FALSE;
}
}
}
- return true;
+ return TRUE;
}
#ifndef COFF_IMAGE_WITH_PE
-boolean
+bfd_boolean
bfd_arm_allocate_interworking_sections (info)
struct bfd_link_info * info;
{
s->contents = foo;
}
- return true;
+ return TRUE;
}
static void
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;
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)
{
though the section isn't allocated yet, this is where we will be putting
it. */
+ 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,
- (struct bfd_link_hash_entry **) & myh);
+ BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
free (tmp_name);
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;
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)
{
return; /* we've already seen this guy */
}
+ 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,
- (struct bfd_link_hash_entry **) &myh);
+ 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;
myh->class = C_THUMBEXTFUNC;
free (tmp_name);
sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
- myh = NULL;
+ 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,
- (struct bfd_link_hash_entry **) & myh);
+ 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 */
-boolean
+bfd_boolean
bfd_arm_get_bfd_for_interworking (abfd, info)
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 (info->relocateable)
- return true;
+ if (info->relocatable)
+ 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);
if (sec == NULL
|| ! bfd_set_section_flags (abfd, sec, flags)
|| ! bfd_set_section_alignment (abfd, sec, 2))
- return false;
+ return FALSE;
}
sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
if (sec == NULL
|| ! bfd_set_section_flags (abfd, sec, flags)
|| ! bfd_set_section_alignment (abfd, sec, 2))
- return false;
+ return FALSE;
}
/* Save the bfd for later use. */
globals->bfd_of_glue_owner = abfd;
- return true;
+ return TRUE;
}
-boolean
+bfd_boolean
bfd_arm_process_before_allocation (abfd, info, support_old_code)
bfd * abfd;
struct bfd_link_info * info;
/* If we are only performing a partial link do not bother
to construct any glue. */
- if (info->relocateable)
- return true;
+ if (info->relocatable)
+ 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) */
#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 relocateable link, we want to convert ARM26 relocs
+/* When doing a relocatable link, we want to convert ARM26 relocs
into ARM26D relocs. */
-static boolean
+static bfd_boolean
coff_arm_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
bfd *obfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
bfd *ibfd;
asection *sec;
struct internal_reloc *irel;
- boolean *adjustedp;
+ bfd_boolean *adjustedp;
{
if (irel->r_type == 3)
{
&& h->root.u.def.section->output_section == sec->output_section)
irel->r_type = 7;
}
- *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 differents APCS's. */
-static boolean
+static bfd_boolean
coff_arm_merge_private_bfd_data (ibfd, obfd)
bfd * ibfd;
bfd * obfd;
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;
- /* Verify that the APCS is the same for the two BFDs */
+ /* Verify that the APCS is the same for the two BFDs. */
if (APCS_SET (ibfd))
{
if (APCS_SET (obfd))
);
bfd_set_error (bfd_error_wrong_format);
- return false;
+ return FALSE;
}
if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
- return false;
+ return FALSE;
}
if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
- return false;
+ return FALSE;
}
}
else
}
}
- return true;
+ return TRUE;
}
/* Display the flags field. */
-static boolean
+static bfd_boolean
coff_arm_print_private_bfd_data (abfd, ptr)
bfd * abfd;
PTR 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 boolean
+static bfd_boolean
_bfd_coff_arm_set_private_flags (abfd, flags)
bfd * abfd;
flagword flags;
|| (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));
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 boolean
+static bfd_boolean
coff_arm_copy_private_bfd_data (src, dest)
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)
}
}
- return true;
+ return TRUE;
}
/* Note: the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
non-local.
b) Allow other prefixes than ".", e.g. an empty prefix would cause all
labels of the form Lxxx to be stripped. */
-static boolean
+static bfd_boolean
coff_arm_is_local_label_name (abfd, name)
bfd * abfd ATTRIBUTE_UNUSED;
const char * name;
if (USER_LABEL_PREFIX[0] != 0)
{
if (strncmp (name, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)) == 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;
krk@cygnus.com */
-static boolean
+static bfd_boolean
coff_arm_link_output_has_begun (sub, info)
bfd * sub;
struct coff_final_link_info * info;
|| sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
}
-static boolean
+static bfd_boolean
coff_arm_final_link_postscript (abfd, pfinfo)
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 true;
+ return bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
}
#include "coffcode.h"
extern const bfd_target TARGET_BIG_SYM ;
/* Target vectors. */
-CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM)
-CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM)
+CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM, COFF_SWAP_TABLE)
+CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE)