/* BFD back-end for ARM COFF files.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2020 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#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;
#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
complain_overflow_dont,
aoutarm_fix_pcrel_26_done,
"ARM_26D",
- TRUE, /* partial_inplace. */
+ TRUE, /* partial_inplace. */
0x00ffffff,
0x0,
PCRELOFFSET),
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_32",
- TRUE, /* partial_inplace. */
+ TRUE, /* partial_inplace. */
0xffffffff,
0xffffffff,
PCRELOFFSET),
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_RVA32",
- TRUE, /* partial_inplace. */
+ TRUE, /* partial_inplace. */
0xffffffff,
0xffffffff,
PCRELOFFSET),
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_SECTION",
- TRUE, /* partial_inplace. */
+ TRUE, /* partial_inplace. */
0x0000ffff,
0x0000ffff,
PCRELOFFSET),
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_SECREL",
- TRUE, /* partial_inplace. */
+ TRUE, /* partial_inplace. */
0xffffffff,
0xffffffff,
PCRELOFFSET),
osect_vma = h->root.u.def.section->output_section->vma;
else
{
- asection *sec;
int i;
/* Sigh, the only way to get the section to offset against
bfd_reloc_status_type flag = bfd_reloc_ok;
/* If this is an undefined symbol, return error. */
- if (symbol->section == &bfd_und_section
+ if (bfd_is_und_section (symbol->section)
&& (symbol->flags & BSF_WEAK) == 0)
return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
}
/* If this is an undefined symbol, return error. */
- if (symbol->section == &bfd_und_section
+ if (bfd_is_und_section (symbol->section)
&& (symbol->flags & BSF_WEAK) == 0)
return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
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
if (code == BFD_RELOC_CTOR)
- switch (bfd_get_arch_info (abfd)->bits_per_address)
+ 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;
}
}
+static reloc_howto_type *
+coff_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+ const char *r_name)
+{
+ unsigned int i;
+
+ for (i = 0;
+ i < (sizeof (aoutarm_std_reloc_howto)
+ / sizeof (aoutarm_std_reloc_howto[0]));
+ i++)
+ if (aoutarm_std_reloc_howto[i].name != NULL
+ && strcasecmp (aoutarm_std_reloc_howto[i].name, r_name) == 0)
+ return &aoutarm_std_reloc_howto[i];
+
+ 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_malloc (amt);
+ ret = bfd_zmalloc (amt);
if (ret == NULL)
return NULL;
return NULL;
}
- ret->thumb_glue_size = 0;
- ret->arm_glue_size = 0;
- ret->bfd_of_glue_owner = NULL;
-
return & ret->root.root;
}
-static void
+static bfd_boolean
arm_emit_base_file_entry (struct bfd_link_info *info,
bfd *output_bfd,
asection *input_section,
bfd_vma reloc_offset)
{
- bfd_vma addr = reloc_offset
- - input_section->vma
- + input_section->output_offset
- + input_section->output_section->vma;
+ bfd_vma addr = (reloc_offset
+ - input_section->vma
+ + input_section->output_offset
+ + input_section->output_section->vma);
if (coff_data (output_bfd)->pe)
addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
- fwrite (& addr, 1, sizeof (addr), (FILE *) info->base_file);
+ if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
+ return TRUE;
+ bfd_set_error (bfd_error_system_call);
+ 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);
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);
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:
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;
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
- && info->relocatable
- && (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
the next opcode's pc, so is off by one. */
- if (howto->pc_relative && !info->relocatable)
+ if (howto->pc_relative && !bfd_link_relocatable (info))
addend -= 8;
#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 (info->relocatable)
- 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 (! info->relocatable
+ 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->class == C_THUMBSTATFUNC
- || h->class == C_THUMBEXTFUNC)
+ 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);
&& ! 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)
- arm_emit_base_file_entry (info, output_bfd, s,
- my_offset + 8);
-
+ if (info->base_file
+ && !arm_emit_base_file_entry (info, output_bfd,
+ s, my_offset + 8))
+ 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->class == C_EXT
- || h->class == C_STAT
- || h->class == C_LABEL)
+ 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)
&& ! 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)
- arm_emit_base_file_entry (info, output_bfd, s,
- my_offset + 16);
+ if (info->base_file
+ && !arm_emit_base_file_entry (info,
+ output_bfd, s,
+ my_offset + 16))
+ 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;
+ sec->output_offset);
}
- 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;
- }
+ 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);
}
- if (info->base_file)
- {
- /* Emit a reloc if the backend thinks it needs it. */
- if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
- arm_emit_base_file_entry (info, output_bfd, input_section,
- rel->r_vaddr);
- }
+ /* Emit a reloc if the backend thinks it needs it. */
+ if (info->base_file
+ && sym
+ && 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;
if (done)
rstat = bfd_reloc_ok;
#ifndef ARM_WINCE
/* Only perform this fix during the final link, not a relocatable link. */
- else if (! info->relocatable
+ 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;
bfd_byte *location = contents + address;
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. */
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 (info->relocatable && ! 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,
val, addend);
/* Only perform this fix during the final link, not a relocatable link. */
- if (! info->relocatable
+ if (! bfd_link_relocatable (info)
&& (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
{
/* Determine if we need to set the bottom bit of a relocated address
int patchit = FALSE;
if (h != NULL
- && ( h->class == C_THUMBSTATFUNC
- || h->class == C_THUMBEXTFUNC))
+ && ( h->symbol_class == C_THUMBSTATFUNC
+ || h->symbol_class == C_THUMBEXTFUNC))
{
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);
+ _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:
{
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);
}
}
}
bfd_boolean
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);
}
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);
#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);
/* If we mark it 'thumb', the disassembler will do a better job. */
myh = (struct coff_link_hash_entry *) bh;
- myh->class = C_THUMBEXTFUNC;
+ myh->symbol_class = C_THUMBEXTFUNC;
free (tmp_name);
{armcoff/pe}.em */
bfd_boolean
-bfd_arm_get_bfd_for_interworking (bfd * abfd,
+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 (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
globals = coff_arm_hash_table (info);
sec = bfd_make_section_with_flags (abfd, ARM2THUMB_GLUE_SECTION_NAME,
flags);
if (sec == NULL
- || ! bfd_set_section_alignment (abfd, sec, 2))
+ || !bfd_set_section_alignment (sec, 2))
return FALSE;
}
flags);
if (sec == NULL
- || ! bfd_set_section_alignment (abfd, sec, 2))
+ || !bfd_set_section_alignment (sec, 2))
return FALSE;
}
}
bfd_boolean
-bfd_arm_process_before_allocation (bfd * abfd,
+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 (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
/* Here we have a bfd that is to be included on the link. We have a hook
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;
}
the target of the call. If it is a thumb target, we
insert glue. */
- if (h->class == C_THUMBEXTFUNC)
+ if (h->symbol_class == C_THUMBEXTFUNC)
record_arm_to_thumb_glue (info, h);
break;
for it. This is not really a problem, since the link
is doomed anyway. */
- switch (h->class)
+ switch (h->symbol_class)
{
case C_EXT:
case C_STAT:
#endif /* ! defined (COFF_IMAGE_WITH_PE) */
-#define coff_bfd_reloc_type_lookup coff_arm_reloc_type_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
targets, eg different CPUs or different APCS's. */
static bfd_boolean
-coff_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
+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)
{
_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);
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;
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;
/* 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
BFD_ASSERT (abfd != NULL && ptr != NULL);
- /* xgettext:c-format */
fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
if (APCS_SET (abfd))
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;
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;
}
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);
labels of the form Lxxx to be stripped. */
static bfd_boolean
-coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
+coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
const char * name)
{
#ifdef USER_LABEL_PREFIX
return bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
}
+#ifndef bfd_pe_print_pdata
+#define bfd_pe_print_pdata NULL
+#endif
+
#include "coffcode.h"
#ifndef TARGET_LITTLE_SYM
-#define TARGET_LITTLE_SYM armcoff_little_vec
+#define TARGET_LITTLE_SYM arm_coff_le_vec
#endif
#ifndef TARGET_LITTLE_NAME
#define TARGET_LITTLE_NAME "coff-arm-little"
#endif
#ifndef TARGET_BIG_SYM
-#define TARGET_BIG_SYM armcoff_big_vec
+#define TARGET_BIG_SYM arm_coff_be_vec
#endif
#ifndef TARGET_BIG_NAME
#define TARGET_BIG_NAME "coff-arm-big"
projects / deliverable / binutils-gdb.git / blobdiff