/* BFD back-end for ARM COFF files.
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001
+ 2000, 2001, 2002
Free Software Foundation, Inc.
Written by Cygnus Support.
/* Macros for manipulation the bits in the flags field of the coff data
structure. */
-#define APCS_26_FLAG( abfd ) (coff_data (abfd)->flags & F_APCS_26)
-#define APCS_FLOAT_FLAG( abfd ) (coff_data (abfd)->flags & F_APCS_FLOAT)
-#define PIC_FLAG( abfd ) (coff_data (abfd)->flags & F_PIC)
-#define APCS_SET( abfd ) (coff_data (abfd)->flags & F_APCS_SET)
-#define SET_APCS_FLAGS( abfd, flgs) (coff_data (abfd)->flags = \
- (coff_data (abfd)->flags & ~ (F_APCS_26 | F_APCS_FLOAT | F_PIC)) \
- | (flgs | F_APCS_SET))
-#define INTERWORK_FLAG( abfd ) (coff_data (abfd)->flags & F_INTERWORK)
-#define INTERWORK_SET( abfd ) (coff_data (abfd)->flags & F_INTERWORK_SET)
-#define SET_INTERWORK_FLAG( abfd, flg ) (coff_data (abfd)->flags = \
- (coff_data (abfd)->flags & ~ F_INTERWORK) \
- | (flg | F_INTERWORK_SET))
+#define APCS_26_FLAG(abfd) \
+ (coff_data (abfd)->flags & F_APCS_26)
+
+#define APCS_FLOAT_FLAG(abfd) \
+ (coff_data (abfd)->flags & F_APCS_FLOAT)
+
+#define PIC_FLAG(abfd) \
+ (coff_data (abfd)->flags & F_PIC)
+
+#define APCS_SET(abfd) \
+ (coff_data (abfd)->flags & F_APCS_SET)
+
+#define SET_APCS_FLAGS(abfd, flgs) \
+ do \
+ { \
+ coff_data (abfd)->flags &= ~(F_APCS_26 | F_APCS_FLOAT | F_PIC); \
+ coff_data (abfd)->flags |= (flgs) | F_APCS_SET; \
+ } \
+ while (0)
+
+#define INTERWORK_FLAG(abfd) \
+ (coff_data (abfd)->flags & F_INTERWORK)
+
+#define INTERWORK_SET(abfd) \
+ (coff_data (abfd)->flags & F_INTERWORK_SET)
+
+#define SET_INTERWORK_FLAG(abfd, flg) \
+ do \
+ { \
+ coff_data (abfd)->flags &= ~F_INTERWORK; \
+ coff_data (abfd)->flags |= (flg) | F_INTERWORK_SET; \
+ } \
+ while (0)
#ifndef NUM_ELEM
#define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type aoutarm_fix_pcrel_26
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+#ifndef ARM_WINCE
static bfd_reloc_status_type coff_thumb_pcrel_23
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
-static bfd_reloc_status_type coff_thumb_pcrel_12
- PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type coff_thumb_pcrel_9
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static insn32 insert_thumb_branch
+ PARAMS ((insn32, int));
+#endif
+static bfd_reloc_status_type coff_thumb_pcrel_12
+ 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
asection *, struct internal_reloc *, boolean *));
static reloc_howto_type * coff_arm_rtype_to_howto
PARAMS ((bfd *, asection *, struct internal_reloc *,
- struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
+ struct coff_link_hash_entry *, struct internal_syment *,
+ bfd_vma *));
static bfd_reloc_status_type coff_thumb_pcrel_common
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **,
thumb_pcrel_branchtype));
-static CONST struct reloc_howto_struct * coff_arm_reloc_type_lookup
+static const struct reloc_howto_struct * coff_arm_reloc_type_lookup
PARAMS ((bfd *, bfd_reloc_code_real_type));
static struct bfd_link_hash_table * coff_arm_link_hash_table_create
PARAMS ((bfd *));
-static insn32 insert_thumb_branch
- PARAMS ((insn32, int));
static struct coff_link_hash_entry * find_thumb_glue
- PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
+ PARAMS ((struct bfd_link_info *, const char *, bfd *));
static struct coff_link_hash_entry * find_arm_glue
- PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
+ PARAMS ((struct bfd_link_info *, const char *, bfd *));
#ifndef COFF_IMAGE_WITH_PE
static void record_arm_to_thumb_glue
PARAMS ((struct bfd_link_info *, struct coff_link_hash_entry *));
+#ifndef ARM_WINCE
static void record_thumb_to_arm_glue
PARAMS ((struct bfd_link_info *, struct coff_link_hash_entry *));
#endif
+#endif
static boolean coff_arm_merge_private_bfd_data
PARAMS ((bfd *, bfd *));
static boolean coff_arm_print_private_bfd_data
diff = reloc_entry->addend;
-#define DOIT(x) \
- x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
+#define DOIT(x) \
+ x = ((x & ~howto->dst_mask) \
+ | (((x & howto->src_mask) + diff) & howto->dst_mask))
if (diff != 0)
{
{
short x = bfd_get_16 (abfd, addr);
DOIT (x);
- bfd_put_16 (abfd, x, addr);
+ bfd_put_16 (abfd, (bfd_vma) x, addr);
}
break;
{
long x = bfd_get_32 (abfd, addr);
DOIT (x);
- bfd_put_32 (abfd, x, addr);
+ bfd_put_32 (abfd, (bfd_vma) x, addr);
}
break;
if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
flag = bfd_reloc_overflow;
}
- else if (relocation & ~0x03ffffff)
+ else if (relocation & ~(bfd_vma) 0x03ffffff)
flag = bfd_reloc_overflow;
target &= ~0x00ffffff;
target |= (relocation >> 2) & 0x00ffffff;
- bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
+ bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
/* Now the ARM magic... Change the reloc type so that it is marked as done.
Strictly this is only necessary if we are doing a partial relocation. */
case b23:
if (bfd_big_endian (abfd))
- target |= ((relocation & 0xfff) >> 1) | ((relocation << 4) & 0x07ff0000);
+ target |= (((relocation & 0xfff) >> 1)
+ | ((relocation << 4) & 0x07ff0000));
else
- target |= ((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff);
+ target |= (((relocation & 0xffe) << 15)
+ | ((relocation >> 12) & 0x7ff));
break;
default:
abort ();
}
- bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
+ bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
/* Now the ARM magic... Change the reloc type so that it is marked as done.
Strictly this is only necessary if we are doing a partial relocation. */
return flag;
}
+#ifndef ARM_WINCE
static bfd_reloc_status_type
coff_thumb_pcrel_23 (abfd, reloc_entry, symbol, data, input_section,
output_bfd, error_message)
char **error_message;
{
return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
- input_section, output_bfd, error_message, b23);
+ input_section, output_bfd, error_message,
+ b23);
}
static bfd_reloc_status_type
-coff_thumb_pcrel_12 (abfd, reloc_entry, symbol, data, input_section,
+coff_thumb_pcrel_9 (abfd, reloc_entry, symbol, data, input_section,
output_bfd, error_message)
bfd *abfd;
arelent *reloc_entry;
char **error_message;
{
return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
- input_section, output_bfd, error_message, b12);
+ input_section, output_bfd, error_message,
+ b9);
}
+#endif /* not ARM_WINCE */
static bfd_reloc_status_type
-coff_thumb_pcrel_9 (abfd, reloc_entry, symbol, data, input_section,
+coff_thumb_pcrel_12 (abfd, reloc_entry, symbol, data, input_section,
output_bfd, error_message)
bfd *abfd;
arelent *reloc_entry;
char **error_message;
{
return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
- input_section, output_bfd, error_message, b9);
+ input_section, output_bfd, error_message,
+ b12);
}
-static CONST struct reloc_howto_struct *
+static const struct reloc_howto_struct *
coff_arm_reloc_type_lookup (abfd, code)
bfd * abfd;
bfd_reloc_code_real_type code;
code = BFD_RELOC_32;
break;
default:
- return (CONST struct reloc_howto_struct *) 0;
+ return (const struct reloc_howto_struct *) 0;
}
switch (code)
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
ASTD (BFD_RELOC_THUMB_PCREL_BLX, ARM_THUMB23);
#endif
- default: return (CONST struct reloc_howto_struct *) 0;
+ default: return (const struct reloc_howto_struct *) 0;
}
}
#define BADMAG(x) ARMBADMAG(x)
#define ARM 1 /* Customize coffcode.h */
+#ifndef ARM_WINCE
+/* Make sure that the 'r_offset' field is copied properly
+ so that identical binaries will compare the same. */
+#define SWAP_IN_RELOC_OFFSET H_GET_32
+#define SWAP_OUT_RELOC_OFFSET H_PUT_32
+#endif
+
/* Extend the coff_link_hash_table structure with a few ARM specific fields.
This allows us to store global data here without actually creating any
global variables, which is a no-no in the BFD world. */
struct coff_link_hash_table root;
/* The size in bytes of the section containg the Thumb-to-ARM glue. */
- long int thumb_glue_size;
+ bfd_size_type thumb_glue_size;
/* The size in bytes of the section containg the ARM-to-Thumb glue. */
- long int arm_glue_size;
+ bfd_size_type arm_glue_size;
/* An arbitary input BFD chosen to hold the glue sections. */
bfd * bfd_of_glue_owner;
bfd * abfd;
{
struct coff_arm_link_hash_table * ret;
+ bfd_size_type amt = sizeof (struct coff_arm_link_hash_table);
- ret = ((struct coff_arm_link_hash_table *)
- bfd_alloc (abfd, sizeof (struct coff_arm_link_hash_table)));
+ ret = (struct coff_arm_link_hash_table *) bfd_malloc (amt);
if (ret == (struct coff_arm_link_hash_table *) NULL)
return NULL;
if (! _bfd_coff_link_hash_table_init
(& ret->root, abfd, _bfd_coff_link_hash_newfunc))
{
- bfd_release (abfd, ret);
+ free (ret);
return (struct bfd_link_hash_table *) NULL;
}
}
\f
+#ifndef ARM_WINCE
/* The thumb form of a long branch is a bit finicky, because the offset
encoding is split over two fields, each in it's own instruction. They
can occur in any order. So given a thumb form of long branch, and an
else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
else
- /* FIXME: the BFD library should never abort - it should return an error status. */
+ /* FIXME: the BFD library should never abort except for internal errors
+ - it should return an error status. */
abort (); /* Error - not a valid branch instruction form. */
return br_insn;
}
+
\f
static struct coff_link_hash_entry *
find_thumb_glue (info, name, input_bfd)
- struct bfd_link_info * info;
- CONST char * name;
- bfd * input_bfd;
+ struct bfd_link_info *info;
+ const char *name;
+ bfd *input_bfd;
{
- char * tmp_name;
- struct coff_link_hash_entry * myh;
+ char *tmp_name;
+ struct coff_link_hash_entry *myh;
+ bfd_size_type amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
- tmp_name = ((char *)
- bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1));
+ tmp_name = (char *) bfd_malloc (amt);
BFD_ASSERT (tmp_name);
if (myh == NULL)
/* xgettext:c-format */
_bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
- bfd_get_filename (input_bfd), tmp_name, name);
+ bfd_archive_filename (input_bfd), tmp_name, name);
free (tmp_name);
return myh;
}
+#endif /* not ARM_WINCE */
static struct coff_link_hash_entry *
find_arm_glue (info, name, input_bfd)
- struct bfd_link_info * info;
- CONST char * name;
- bfd * input_bfd;
+ struct bfd_link_info *info;
+ const char *name;
+ bfd *input_bfd;
{
- char * tmp_name;
+ char *tmp_name;
struct coff_link_hash_entry * myh;
+ bfd_size_type amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
- tmp_name = ((char *)
- bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
+ tmp_name = (char *) bfd_malloc (amt);
BFD_ASSERT (tmp_name);
if (myh == NULL)
/* xgettext:c-format */
_bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
- bfd_get_filename (input_bfd), tmp_name, name);
+ bfd_archive_filename (input_bfd), tmp_name, name);
free (tmp_name);
&& info->relocateable
&& (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
- && h->root.u.def.section->output_section == input_section->output_section)
+ && (h->root.u.def.section->output_section
+ == input_section->output_section))
{
static reloc_howto_type fake_arm26_reloc =
HOWTO (ARM_26,
{
/* Arm code calling a Thumb function. */
unsigned long int tmp;
- long int my_offset;
+ bfd_vma my_offset;
asection * s;
long int ret_offset;
struct coff_link_hash_entry * myh;
_bfd_error_handler
/* xgettext:c-format */
(_("%s(%s): warning: interworking not enabled."),
- bfd_get_filename (h_sec->owner), name);
+ bfd_archive_filename (h_sec->owner), name);
_bfd_error_handler
/* xgettext:c-format */
(_(" first occurrence: %s: arm call to thumb"),
- bfd_get_filename (input_bfd));
+ bfd_archive_filename (input_bfd));
}
--my_offset;
myh->root.u.def.value = my_offset;
- bfd_put_32 (output_bfd, a2t1_ldr_insn,
+ bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
s->contents + my_offset);
- bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
+ bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
s->contents + my_offset + 4);
/* It's a thumb address. Add the low order bit. */
if (info->base_file)
arm_emit_base_file_entry (info, output_bfd, s,
- my_offset + 8);
+ my_offset + 8);
}
tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
- bfd_put_32 (output_bfd, tmp, contents + rel->r_vaddr
- - input_section->vma);
+ bfd_put_32 (output_bfd, (bfd_vma) tmp,
+ contents + rel->r_vaddr - input_section->vma);
done = 1;
}
}
{
/* Thumb code calling an ARM function */
asection * s = 0;
- long int my_offset;
+ bfd_vma my_offset;
unsigned long int tmp;
long int ret_offset;
struct coff_link_hash_entry * myh;
_bfd_error_handler
/* xgettext:c-format */
(_("%s(%s): warning: interworking not enabled."),
- bfd_get_filename (h_sec->owner), name);
+ bfd_archive_filename (h_sec->owner), name);
_bfd_error_handler
/* xgettext:c-format */
(_(" first occurrence: %s: thumb call to arm"),
- bfd_get_filename (input_bfd));
+ bfd_archive_filename (input_bfd));
_bfd_error_handler
(_(" consider relinking with --support-old-code enabled"));
}
if (globals->support_old_code)
{
- bfd_put_16 (output_bfd, t2a1_push_insn,
+ bfd_put_16 (output_bfd, (bfd_vma) t2a1_push_insn,
s->contents + my_offset);
- bfd_put_16 (output_bfd, t2a2_ldr_insn,
+ bfd_put_16 (output_bfd, (bfd_vma) t2a2_ldr_insn,
s->contents + my_offset + 2);
- bfd_put_16 (output_bfd, t2a3_mov_insn,
+ bfd_put_16 (output_bfd, (bfd_vma) t2a3_mov_insn,
s->contents + my_offset + 4);
- bfd_put_16 (output_bfd, t2a4_bx_insn,
+ bfd_put_16 (output_bfd, (bfd_vma) t2a4_bx_insn,
s->contents + my_offset + 6);
- bfd_put_32 (output_bfd, t2a5_pop_insn,
+ bfd_put_32 (output_bfd, (bfd_vma) t2a5_pop_insn,
s->contents + my_offset + 8);
- bfd_put_32 (output_bfd, t2a6_bx_insn,
+ bfd_put_32 (output_bfd, (bfd_vma) t2a6_bx_insn,
s->contents + my_offset + 12);
/* Store the address of the function in the last word of the stub. */
s->contents + my_offset + 16);
if (info->base_file)
- arm_emit_base_file_entry (info, output_bfd, s, my_offset + 16);
+ arm_emit_base_file_entry (info, output_bfd, s,
+ my_offset + 16);
}
else
{
- bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
+ bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
s->contents + my_offset);
- bfd_put_16 (output_bfd, t2a2_noop_insn,
+ bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
s->contents + my_offset + 2);
ret_offset =
+ 8); /* ARM branches work from the pc of the instruction + 8. */
bfd_put_32 (output_bfd,
- t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
+ (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
s->contents + my_offset + 4);
}
- input_section->vma);
bfd_put_32 (output_bfd,
- insert_thumb_branch (tmp, ret_offset),
- contents + rel->r_vaddr
- - input_section->vma);
+ (bfd_vma) insert_thumb_branch (tmp,
+ ret_offset),
+ contents + rel->r_vaddr - input_section->vma);
done = 1;
}
{
/* 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);
+ arm_emit_base_file_entry (info, output_bfd, input_section,
+ rel->r_vaddr);
}
#if 1 /* THUMBEXTENSION */
case bfd_reloc_outofrange:
(*_bfd_error_handler)
(_("%s: bad reloc address 0x%lx in section `%s'"),
- bfd_get_filename (input_bfd),
+ bfd_archive_filename (input_bfd),
(unsigned long) rel->r_vaddr,
bfd_get_section_name (input_bfd, input_section));
return false;
BFD_ASSERT (s != NULL);
- foo = (bfd_byte *) bfd_alloc
- (globals->bfd_of_glue_owner, globals->arm_glue_size);
+ foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
+ globals->arm_glue_size);
#if 0
- memset (foo, test_char, globals->arm_glue_size);
+ memset (foo, test_char, (size_t) globals->arm_glue_size);
#endif
s->_raw_size = s->_cooked_size = globals->arm_glue_size;
BFD_ASSERT (s != NULL);
- foo = (bfd_byte *) bfd_alloc
- (globals->bfd_of_glue_owner, globals->thumb_glue_size);
+ foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
+ globals->thumb_glue_size);
#if 0
- memset (foo, test_char, globals->thumb_glue_size);
+ memset (foo, test_char, (size_t) globals->thumb_glue_size);
#endif
s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
char * tmp_name;
struct coff_link_hash_entry * myh;
struct coff_arm_link_hash_table * globals;
+ bfd_vma val;
+ bfd_size_type amt;
globals = coff_arm_hash_table (info);
BFD_ASSERT (s != NULL);
- tmp_name = ((char *)
- bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
+ amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
+ tmp_name = (char *) bfd_malloc (amt);
BFD_ASSERT (tmp_name);
though the section isn't allocated yet, this is where we will be putting
it. */
+ val = globals->arm_glue_size + 1;
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
- BSF_GLOBAL,
- s, globals->arm_glue_size + 1,
- NULL, true, false,
+ BSF_GLOBAL, s, val, NULL, true, false,
(struct bfd_link_hash_entry **) & myh);
free (tmp_name);
return;
}
+#ifndef ARM_WINCE
static void
record_thumb_to_arm_glue (info, h)
struct bfd_link_info * info;
char * tmp_name;
struct coff_link_hash_entry * myh;
struct coff_arm_link_hash_table * globals;
+ bfd_vma val;
+ bfd_size_type amt;
globals = coff_arm_hash_table (info);
BFD_ASSERT (s != NULL);
- tmp_name = (char *) bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
+ amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
+ tmp_name = (char *) bfd_malloc (amt);
BFD_ASSERT (tmp_name);
return; /* we've already seen this guy */
}
+ val = globals->thumb_glue_size + 1;
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
- BSF_GLOBAL, s, globals->thumb_glue_size + 1,
- NULL, true, false,
- (struct bfd_link_hash_entry **) & myh);
+ BSF_GLOBAL, s, val, NULL, true, false,
+ (struct bfd_link_hash_entry **) &myh);
/* If we mark it 'thumb', the disassembler will do a better job. */
myh->class = C_THUMBEXTFUNC;
#define CHANGE_TO_ARM "__%s_change_to_arm"
#define BACK_FROM_ARM "__%s_back_from_arm"
- tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
+ amt = strlen (name) + strlen (CHANGE_TO_ARM) + 1;
+ tmp_name = (char *) bfd_malloc (amt);
BFD_ASSERT (tmp_name);
sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
myh = 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, globals->thumb_glue_size
- + (globals->support_old_code ? 8 : 4),
- NULL, true, false,
+ BSF_LOCAL, s, val, NULL, true, false,
(struct bfd_link_hash_entry **) & myh);
free (tmp_name);
return;
}
+#endif /* not ARM_WINCE */
/* Select a BFD to be used to hold the sections used by the glue code.
This function is called from the linker scripts in ld/emultempl/
if (symndx >= obj_conv_table_size (abfd))
{
_bfd_error_handler (_("%s: illegal symbol index in reloc: %d"),
- bfd_get_filename (abfd), symndx);
+ bfd_archive_filename (abfd), symndx);
continue;
}
{
_bfd_error_handler
/* xgettext: c-format */
- (_("%s: ERROR: compiled for APCS-%d whereas target %s uses APCS-%d"),
- bfd_get_filename (ibfd), APCS_26_FLAG (ibfd) ? 26 : 32,
+ (_("ERROR: %s is compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
+ bfd_archive_filename (ibfd), APCS_26_FLAG (ibfd) ? 26 : 32,
bfd_get_filename (obfd), APCS_26_FLAG (obfd) ? 26 : 32
);
if (APCS_FLOAT_FLAG (ibfd))
/* xgettext: c-format */
- msg = _("%s: ERROR: passes floats in float registers whereas target %s uses integer registers");
+ msg = _("ERROR: %s passes floats in float registers, whereas %s passes them in integer registers");
else
/* xgettext: c-format */
- msg = _("%s: ERROR: passes floats in integer registers whereas target %s uses float registers");
+ msg = _("ERROR: %s passes floats in integer registers, whereas %s passes them in float registers");
- _bfd_error_handler (msg, bfd_get_filename (ibfd),
+ _bfd_error_handler (msg, bfd_archive_filename (ibfd),
bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
if (PIC_FLAG (ibfd))
/* xgettext: c-format */
- msg = _("%s: ERROR: compiled as position independent code, whereas target %s is absolute position");
+ msg = _("ERROR: %s is compiled as position independent code, whereas target %s is absolute position");
else
/* xgettext: c-format */
- msg = _("%s: ERROR: compiled as absolute position code, whereas target %s is position independent");
- _bfd_error_handler (msg, bfd_get_filename (ibfd),
+ msg = _("ERROR: %s is compiled as absolute position code, whereas target %s is position independent");
+ _bfd_error_handler (msg, bfd_archive_filename (ibfd),
bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
if (INTERWORK_FLAG (ibfd))
/* xgettext: c-format */
- msg = _("Warning: input file %s supports interworking, whereas %s does not.");
+ msg = _("Warning: %s supports interworking, whereas %s does not");
else
/* xgettext: c-format */
- msg = _("Warning: input file %s does not support interworking, whereas %s does.");
+ msg = _("Warning: %s does not support interworking, whereas %s does");
- _bfd_error_handler (msg, bfd_get_filename (ibfd),
+ _bfd_error_handler (msg, bfd_archive_filename (ibfd),
bfd_get_filename (obfd));
}
}
{
if (flag)
/* xgettext: c-format */
- _bfd_error_handler (_("Warning: Not setting interworking flag of %s, since it has already been specified as non-interworking"),
- bfd_get_filename (abfd));
+ _bfd_error_handler (_("Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
+ bfd_archive_filename (abfd));
else
/* xgettext: c-format */
_bfd_error_handler (_("Warning: Clearing the interworking flag of %s due to outside request"),
- bfd_get_filename (abfd));
+ bfd_archive_filename (abfd));
flag = 0;
}
if (INTERWORK_FLAG (dest))
{
/* xgettext:c-format */
- _bfd_error_handler (("Warning: Clearing the interworking bit of %s, because the non-interworking code in %s has been copied into it"),
+ _bfd_error_handler (("\
+Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
bfd_get_filename (dest),
- bfd_get_filename (src));
+ bfd_archive_filename (src));
}
SET_INTERWORK_FLAG (dest, 0);
if (LOCAL_LABEL_PREFIX[0] != 0)
{
- int len = strlen (LOCAL_LABEL_PREFIX);
+ size_t len = strlen (LOCAL_LABEL_PREFIX);
if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
return false;
projects / deliverable / binutils-gdb.git / blobdiff