OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update soruces to make alpha, arc and arm targets compile cleanly 

with -Wc++-compat:
        * config/tc-alpha.c: Add casts.
        (extended_bfd_reloc_code_real_type): New type. Used to avoid
        enumeration conversion warnings.
        (struct alpha_fixup, void assemble_insn, assemble_insn)
        (assemble_tokens): Use new type.
        * ecoff.c: Add casts. (mark_stabs): Use enumeration names.
        * config/obj-elf.c: Add cast
        * config/tc-arc.c: Add casts.
        * config/obj-aout.h (text_section,data_section,bss_section):
        Make extern.
        * config/obj-elf.c: Add cast.
        * config/tc-arm.c: Add casts.
        (X, TxCE, TxCE, TxC3, TxC3w, TxCM_, TxCM, TUE, TUF, CE, CL, cCE)
        (cCL, C3E, xCM_, nUF, nCE_tag): Change input format to avoid the
        need for keywords as arguments.
        * ecoff.c: Add casts.
        * ecofflink.c: Add casts.
        * elf64-alpha.c: Add casts.
        (struct alpha_elf_got_entry, struct alpha_elf_reloc_entry): Move
        to top level.
        (SKIP_HOWTO): Use enum name.
        * elf32-arm.c: Add casts.
        (elf32_arm_vxworks_bed): Update code to avoid multiple
        declarations.
        (struct map_stub): Move to top level.
        * arc-dis.c Fix casts.
        * arc-ext.c: Add casts.
        * arm-dis.c (enum opcode_sentinel_enum): Gave name to anonymous
        enum.
        * emultempl/armelf.em: Add casts.
This commit is contained in:
Nick Clifton 2009-09-25 19:13:27 +00:00
parent fa9efd0fbc
commit 21d799b5c4
18 changed files with 1841 additions and 1733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
bfd/ChangeLog
View File

@ -1,3 +1,18 @@
2009-09-25 Martin Thuresson <martint@google.com>
Update soruces to make alpha and arm targets compile cleanly with
-Wc++-compat:
* ecoff.c: Add casts.
* ecofflink.c: Add casts.
* elf64-alpha.c: Add casts.
(struct alpha_elf_got_entry, struct alpha_elf_reloc_entry): Move
to top level.
(SKIP_HOWTO): Use enum name.
* elf32-arm.c: Add casts.
(elf32_arm_vxworks_bed): Update code to avoid multiple
declarations.
(struct map_stub): Move to top level.
2009-09-24 H.J. Lu <hongjiu.lu@intel.com>
PR ld/10630

39
bfd/ecoff.c
View File

@ -89,7 +89,7 @@ _bfd_ecoff_mkobject (bfd *abfd)
{
bfd_size_type amt = sizeof (ecoff_data_type);
abfd->tdata.ecoff_obj_data = bfd_zalloc (abfd, amt);
abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt);
if (abfd->tdata.ecoff_obj_data == NULL)
return FALSE;
@ -193,7 +193,7 @@ _bfd_ecoff_new_section_hook (bfd *abfd, asection *section)
bfd_boolean
_bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr)
{
struct internal_filehdr *internal_f = filehdr;
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
enum bfd_architecture arch;
unsigned long mach;
@ -366,7 +366,7 @@ _bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
asection *section ATTRIBUTE_UNUSED,
flagword * flags_ptr)
{
struct internal_scnhdr *internal_s = hdr;
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
long styp_flags = internal_s->s_flags;
flagword sec_flags = 0;
@ -614,7 +614,7 @@ _bfd_ecoff_slurp_symbolic_info (bfd *abfd,
the symbols, so we swap them here. */
amt = internal_symhdr->ifdMax;
amt *= sizeof (struct fdr);
debug->fdr = bfd_alloc (abfd, amt);
debug->fdr = (FDR *) bfd_alloc (abfd, amt);
if (debug->fdr == NULL)
return FALSE;
external_fdr_size = backend->debug_swap.external_fdr_size;
@ -882,7 +882,7 @@ _bfd_ecoff_slurp_symbol_table (bfd *abfd)
internal_size = bfd_get_symcount (abfd);
internal_size *= sizeof (ecoff_symbol_type);
internal = bfd_alloc (abfd, internal_size);
internal = (ecoff_symbol_type *) bfd_alloc (abfd, internal_size);
if (internal == NULL)
return FALSE;
@ -1580,11 +1580,11 @@ ecoff_slurp_reloc_table (bfd *abfd,
amt = section->reloc_count;
amt *= sizeof (arelent);
internal_relocs = bfd_alloc (abfd, amt);
internal_relocs = (arelent *) bfd_alloc (abfd, amt);
external_reloc_size = backend->external_reloc_size;
amt = external_reloc_size * section->reloc_count;
external_relocs = bfd_alloc (abfd, amt);
external_relocs = (char *) bfd_alloc (abfd, amt);
if (internal_relocs == NULL || external_relocs == NULL)
return FALSE;
if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0)
@ -1730,7 +1730,8 @@ _bfd_ecoff_find_nearest_line (bfd *abfd,
{
bfd_size_type amt = sizeof (struct ecoff_find_line);
ecoff_data (abfd)->find_line_info = bfd_zalloc (abfd, amt);
ecoff_data (abfd)->find_line_info =
(struct ecoff_find_line *) bfd_zalloc (abfd, amt);
if (ecoff_data (abfd)->find_line_info == NULL)
return FALSE;
}
@ -1955,7 +1956,7 @@ ecoff_compute_section_file_positions (bfd *abfd)
/* Sort the sections by VMA. */
amt = abfd->section_count;
amt *= sizeof (asection *);
sorted_hdrs = bfd_malloc (amt);
sorted_hdrs = (asection **) bfd_malloc (amt);
if (sorted_hdrs == NULL)
return FALSE;
for (current = abfd->sections, i = 0;
@ -2908,7 +2909,7 @@ _bfd_ecoff_slurp_armap (bfd *abfd)
parsed_size = mapdata->parsed_size;
bfd_release (abfd, (void *) mapdata);
raw_armap = bfd_alloc (abfd, parsed_size);
raw_armap = (char *) bfd_alloc (abfd, parsed_size);
if (raw_armap == NULL)
return FALSE;
@ -2975,7 +2976,7 @@ _bfd_ecoff_slurp_armap (bfd *abfd)
amt = ardata->symdef_count;
amt *= sizeof (struct symdef);
symdef_ptr = bfd_alloc (abfd, amt);
symdef_ptr = (struct symdef *) bfd_alloc (abfd, amt);
if (!symdef_ptr)
return FALSE;
@ -3091,7 +3092,7 @@ _bfd_ecoff_write_armap (bfd *abfd,
if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4)
return FALSE;
hashtable = bfd_zalloc (abfd, symdefsize);
hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
if (!hashtable)
return FALSE;
@ -3211,7 +3212,7 @@ _bfd_ecoff_bfd_link_hash_table_create (bfd *abfd)
struct ecoff_link_hash_table *ret;
bfd_size_type amt = sizeof (struct ecoff_link_hash_table);
ret = bfd_malloc (amt);
ret = (struct ecoff_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
return NULL;
if (!_bfd_link_hash_table_init (&ret->root, abfd,
@ -3269,7 +3270,7 @@ ecoff_link_add_externals (bfd *abfd,
amt = ext_count;
amt *= sizeof (struct bfd_link_hash_entry *);
sym_hash = bfd_alloc (abfd, amt);
sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt);
if (!sym_hash)
return FALSE;
ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash;
@ -3483,7 +3484,7 @@ ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
|| bfd_bread (external_ext, esize, abfd) != esize)
goto error_return;
ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
if (ssext == NULL && symhdr->issExtMax != 0)
goto error_return;
@ -3549,7 +3550,7 @@ ecoff_link_check_archive_element (bfd *abfd,
|| bfd_bread (external_ext, esize, abfd) != esize)
goto error_return;
ssext = bfd_malloc ((bfd_size_type) symhdr->issExtMax);
ssext = (char *) bfd_malloc ((bfd_size_type) symhdr->issExtMax);
if (ssext == NULL && symhdr->issExtMax != 0)
goto error_return;
@ -3838,7 +3839,7 @@ ecoff_final_link_debug_accumulate (bfd *output_bfd,
else \
{ \
bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
debug->ptr = bfd_malloc (amt); \
debug->ptr = (type) bfd_malloc (amt); \
if (debug->ptr == NULL) \
{ \
ret = FALSE; \
@ -4083,7 +4084,7 @@ ecoff_reloc_link_order (bfd *output_bfd,
bfd_byte *buf;
size = bfd_get_reloc_size (rel.howto);
buf = bfd_zmalloc (size);
buf = (bfd_byte *) bfd_zmalloc (size);
if (buf == NULL)
return FALSE;
rstat = _bfd_relocate_contents (rel.howto, output_bfd,
@ -4192,7 +4193,7 @@ ecoff_reloc_link_order (bfd *output_bfd,
/* Get some memory and swap out the reloc. */
external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size;
rbuf = bfd_malloc (external_reloc_size);
rbuf = (bfd_byte *) bfd_malloc (external_reloc_size);
if (rbuf == NULL)
return FALSE;

16
bfd/ecofflink.c
View File

@ -1,6 +1,6 @@
/* Routines to link ECOFF debugging information.
Copyright 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003,
2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
This file is part of BFD, the Binary File Descriptor library.
@ -1084,8 +1084,8 @@ ecoff_add_string (ainfo, info, debug, fdr, string)
len = strlen (string);
if (info->relocatable)
{
if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end, (PTR) string,
len + 1))
if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
(bfd_byte *) string, len + 1))
return -1;
ret = symhdr->issMax;
symhdr->issMax += len + 1;
@ -1207,7 +1207,7 @@ bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
}
(*swap_sym_out) (output_bfd, &internal_sym, external_sym);
add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end,
external_sym,
(bfd_byte *) external_sym,
(unsigned long) output_swap->external_sym_size);
++fdr.csym;
++output_symhdr->isymMax;
@ -1228,7 +1228,7 @@ bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
}
(*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr);
add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end,
external_fdr,
(bfd_byte *) external_fdr,
(unsigned long) output_swap->external_fdr_size);
++output_symhdr->ifdMax;
@ -1338,8 +1338,8 @@ bfd_ecoff_debug_one_external (abfd, debug, swap, name, esym)
- (char *) debug->external_ext)
< (symhdr->iextMax + 1) * external_ext_size)
{
char *external_ext = debug->external_ext;
char *external_ext_end = debug->external_ext_end;
char *external_ext = (char *) debug->external_ext;
char *external_ext_end = (char *) debug->external_ext_end;
if (! ecoff_add_bytes ((char **) &external_ext,
(char **) &external_ext_end,
(symhdr->iextMax + 1) * (size_t) external_ext_size))
@ -1503,7 +1503,7 @@ ecoff_write_symhdr (abfd, debug, swap, where)
SET (cbExtOffset, iextMax, swap->external_ext_size);
#undef SET
buff = (PTR) bfd_malloc (swap->external_hdr_size);
buff = (char *) bfd_malloc (swap->external_hdr_size);
if (buff == NULL && swap->external_hdr_size != 0)
goto error_return;

592
bfd/elf32-arm.c
View File

@ -61,8 +61,6 @@
#define ARM_ELF_ABI_VERSION 0
#define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
static struct elf_backend_data elf32_arm_vxworks_bed;
static bfd_boolean elf32_arm_write_section (bfd *output_bfd,
struct bfd_link_info *link_info,
asection *sec,
@ -2523,6 +2521,17 @@ struct elf32_arm_link_hash_entry
((struct elf32_arm_stub_hash_entry *) \
bfd_hash_lookup ((table), (string), (create), (copy)))
/* Array to keep track of which stub sections have been created, and
information on stub grouping. */
struct map_stub
{
/* This is the section to which stubs in the group will be
attached. */
asection *link_sec;
/* The stub section. */
asection *stub_sec;
};
/* ARM ELF linker hash table. */
struct elf32_arm_link_hash_table
{
@ -2638,14 +2647,7 @@ struct elf32_arm_link_hash_table
/* Array to keep track of which stub sections have been created, and
information on stub grouping. */
struct map_stub
{
/* This is the section to which stubs in the group will be
attached. */
asection *link_sec;
/* The stub section. */
asection *stub_sec;
} *stub_group;
struct map_stub *stub_group;
/* Assorted information used by elf32_arm_size_stubs. */
unsigned int bfd_count;
@ -2666,7 +2668,8 @@ elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
/* Allocate the structure if it has not already been allocated by a
subclass. */
if (ret == NULL)
ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
ret = (struct elf32_arm_link_hash_entry *)
bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
if (ret == NULL)
return (struct bfd_hash_entry *) ret;
@ -2700,8 +2703,8 @@ stub_hash_newfunc (struct bfd_hash_entry *entry,
subclass. */
if (entry == NULL)
{
entry = bfd_hash_allocate (table,
sizeof (struct elf32_arm_stub_hash_entry));
entry = (struct bfd_hash_entry *)
bfd_hash_allocate (table, sizeof (struct elf32_arm_stub_hash_entry));
if (entry == NULL)
return entry;
}
@ -2882,7 +2885,7 @@ elf32_arm_link_hash_table_create (bfd *abfd)
struct elf32_arm_link_hash_table *ret;
bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
ret = bfd_malloc (amt);
ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
return NULL;
@ -3248,7 +3251,7 @@ elf32_arm_stub_name (const asection *input_section,
if (hash)
{
len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1;
stub_name = bfd_malloc (len);
stub_name = (char *) bfd_malloc (len);
if (stub_name != NULL)
sprintf (stub_name, "%08x_%s+%x",
input_section->id & 0xffffffff,
@ -3258,7 +3261,7 @@ elf32_arm_stub_name (const asection *input_section,
else
{
len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
stub_name = bfd_malloc (len);
stub_name = (char *) bfd_malloc (len);
if (stub_name != NULL)
sprintf (stub_name, "%08x_%x:%x+%x",
input_section->id & 0xffffffff,
@ -3343,7 +3346,7 @@ elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
namelen = strlen (link_sec->name);
len = namelen + sizeof (STUB_SUFFIX);
s_name = bfd_alloc (htab->stub_bfd, len);
s_name = (char *) bfd_alloc (htab->stub_bfd, len);
if (s_name == NULL)
return NULL;
@ -3725,7 +3728,7 @@ elf32_arm_setup_section_lists (bfd *output_bfd,
htab->bfd_count = bfd_count;
amt = sizeof (struct map_stub) * (top_id + 1);
htab->stub_group = bfd_zmalloc (amt);
htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
if (htab->stub_group == NULL)
return -1;
@ -3742,7 +3745,7 @@ elf32_arm_setup_section_lists (bfd *output_bfd,
htab->top_index = top_index;
amt = sizeof (asection *) * (top_index + 1);
input_list = bfd_malloc (amt);
input_list = (asection **) bfd_malloc (amt);
htab->input_list = input_list;
if (input_list == NULL)
return -1;
@ -3899,7 +3902,8 @@ group_sections (struct elf32_arm_link_hash_table *htab,
static int
a8_reloc_compare (const void *a, const void *b)
{
const struct a8_erratum_reloc *ra = a, *rb = b;
const struct a8_erratum_reloc *ra = (const struct a8_erratum_reloc *) a;
const struct a8_erratum_reloc *rb = (const struct a8_erratum_reloc *) b;
if (ra->from < rb->from)
return -1;
@ -4024,9 +4028,10 @@ cortex_a8_erratum_scan (bfd *input_bfd,
struct a8_erratum_reloc key, *found;
key.from = base_vma + i;
found = bsearch (&key, a8_relocs, num_a8_relocs,
sizeof (struct a8_erratum_reloc),
&a8_reloc_compare);
found = (struct a8_erratum_reloc *)
bsearch (&key, a8_relocs, num_a8_relocs,
sizeof (struct a8_erratum_reloc),
&a8_reloc_compare);
if (found)
{
@ -4143,9 +4148,10 @@ cortex_a8_erratum_scan (bfd *input_bfd,
if (num_a8_fixes == a8_fix_table_size)
{
a8_fix_table_size *= 2;
a8_fixes = bfd_realloc (a8_fixes,
sizeof (struct a8_erratum_fix)
* a8_fix_table_size);
a8_fixes = (struct a8_erratum_fix *)
bfd_realloc (a8_fixes,
sizeof (struct a8_erratum_fix)
* a8_fix_table_size);
}
if (num_a8_fixes < prev_num_a8_fixes)
@ -4166,7 +4172,7 @@ cortex_a8_erratum_scan (bfd *input_bfd,
if (!stub_name)
{
stub_name = bfd_malloc (8 + 1 + 8 + 1);
stub_name = (char *) bfd_malloc (8 + 1 + 8 + 1);
if (stub_name != NULL)
sprintf (stub_name, "%x:%x", section->id, i);
}
@ -4225,10 +4231,10 @@ elf32_arm_size_stubs (bfd *output_bfd,
if (htab->fix_cortex_a8)
{
a8_fixes = bfd_zmalloc (sizeof (struct a8_erratum_fix)
* a8_fix_table_size);
a8_relocs = bfd_zmalloc (sizeof (struct a8_erratum_reloc)
* a8_reloc_table_size);
a8_fixes = (struct a8_erratum_fix *)
bfd_zmalloc (sizeof (struct a8_erratum_fix) * a8_fix_table_size);
a8_relocs = (struct a8_erratum_reloc *)
bfd_zmalloc (sizeof (struct a8_erratum_reloc) * a8_reloc_table_size);
}
/* Propagate mach to stub bfd, because it may not have been
@ -4539,8 +4545,8 @@ elf32_arm_size_stubs (bfd *output_bfd,
if (sym_name == NULL)
sym_name = "unnamed";
stub_entry->output_name
= bfd_alloc (htab->stub_bfd,
stub_entry->output_name = (char *)
bfd_alloc (htab->stub_bfd,
sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
+ strlen (sym_name));
if (stub_entry->output_name == NULL)
@ -4591,9 +4597,10 @@ elf32_arm_size_stubs (bfd *output_bfd,
if (num_a8_relocs == a8_reloc_table_size)
{
a8_reloc_table_size *= 2;
a8_relocs = bfd_realloc (a8_relocs,
sizeof (struct a8_erratum_reloc)
* a8_reloc_table_size);
a8_relocs = (struct a8_erratum_reloc *)
bfd_realloc (a8_relocs,
sizeof (struct a8_erratum_reloc)
* a8_reloc_table_size);
}
a8_relocs[num_a8_relocs].from = from;
@ -4757,7 +4764,7 @@ elf32_arm_build_stubs (struct bfd_link_info *info)
/* Allocate memory to hold the linker stubs. */
size = stub_sec->size;
stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
if (stub_sec->contents == NULL && size != 0)
return FALSE;
stub_sec->size = 0;
@ -4790,8 +4797,8 @@ find_thumb_glue (struct bfd_link_info *link_info,
/* We need a pointer to the armelf specific hash table. */
hash_table = elf32_arm_hash_table (link_info);
tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
+ strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
+ strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
BFD_ASSERT (tmp_name);
@ -4824,8 +4831,8 @@ find_arm_glue (struct bfd_link_info *link_info,
/* We need a pointer to the elfarm specific hash table. */
hash_table = elf32_arm_hash_table (link_info);
tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
+ strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
+ strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
BFD_ASSERT (tmp_name);
@ -4935,7 +4942,7 @@ arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * na
s = bfd_get_section_by_name (abfd, name);
BFD_ASSERT (s != NULL);
contents = bfd_alloc (abfd, size);
contents = (bfd_byte *) bfd_alloc (abfd, size);
BFD_ASSERT (s->size == size);
s->contents = contents;
@ -4994,7 +5001,8 @@ record_arm_to_thumb_glue (struct bfd_link_info * link_info,
BFD_ASSERT (s != NULL);
tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
+ strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
BFD_ASSERT (tmp_name);
@ -5071,7 +5079,8 @@ record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
BFD_ASSERT (s != NULL);
/* Add symbol for veneer. */
tmp_name = bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
tmp_name = (char *)
bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
BFD_ASSERT (tmp_name);
@ -5108,7 +5117,8 @@ elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
if (sec_data->map == NULL)
{
sec_data->map = bfd_malloc (sizeof (elf32_arm_section_map));
sec_data->map = (elf32_arm_section_map *)
bfd_malloc (sizeof (elf32_arm_section_map));
sec_data->mapcount = 0;
sec_data->mapsize = 1;
}
@ -5118,8 +5128,9 @@ elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
if (sec_data->mapcount > sec_data->mapsize)
{
sec_data->mapsize *= 2;
sec_data->map = bfd_realloc_or_free (sec_data->map, sec_data->mapsize
* sizeof (elf32_arm_section_map));
sec_data->map = (elf32_arm_section_map *)
bfd_realloc_or_free (sec_data->map, sec_data->mapsize
* sizeof (elf32_arm_section_map));
}
if (sec_data->map)
@ -5162,8 +5173,8 @@ record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
BFD_ASSERT (s != NULL);
tmp_name = bfd_malloc ((bfd_size_type) strlen
(VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
(VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
BFD_ASSERT (tmp_name);
@ -5187,7 +5198,8 @@ record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
/* Link veneer back to calling location. */
errcount = ++(sec_data->erratumcount);
newerr = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
newerr = (elf32_vfp11_erratum_list *)
bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
newerr->type = VFP11_ERRATUM_ARM_VENEER;
newerr->vma = -1;
@ -6033,8 +6045,8 @@ bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
if (state == 3)
{
elf32_vfp11_erratum_list *newerr
= bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
elf32_vfp11_erratum_list *newerr =(elf32_vfp11_erratum_list *)
bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
int errcount;
errcount = ++(elf32_arm_section_data (sec)->erratumcount);
@ -6102,8 +6114,8 @@ bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
globals = elf32_arm_hash_table (link_info);
tmp_name = bfd_malloc ((bfd_size_type) strlen
(VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
(VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
for (sec = abfd->sections; sec != NULL; sec = sec->next)
{
@ -8092,7 +8104,7 @@ elf32_arm_final_link_relocate (reloc_howto_type * howto,
(_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
input_bfd, input_section,
(long) rel->r_offset, howto->name);
return FALSE;
return (bfd_reloc_status_type) FALSE;
}
else
value = tpoff (info, value);
@ -9042,7 +9054,8 @@ add_unwind_table_edit (arm_unwind_table_edit **head,
asection *linked_section,
unsigned int index)
{
arm_unwind_table_edit *new_edit = xmalloc (sizeof (arm_unwind_table_edit));
arm_unwind_table_edit *new_edit = (arm_unwind_table_edit *)
xmalloc (sizeof (arm_unwind_table_edit));
new_edit->type = type;
new_edit->linked_section = linked_section;
@ -9539,7 +9552,7 @@ set_secondary_compatible_arch (bfd *abfd, int arch)
/* Note: the tag and its argument below are uleb128 values, though
currently-defined values fit in one byte for each. */
if (!attr->s)
attr->s = bfd_alloc (abfd, 3);
attr->s = (char *) bfd_alloc (abfd, 3);
attr->s[0] = Tag_CPU_arch;
attr->s[1] = arch;
attr->s[2] = '\0';
@ -10195,225 +10208,7 @@ elf32_arm_versions_compatible (unsigned iver, unsigned over)
object file when linking. */
static bfd_boolean
elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
{
flagword out_flags;
flagword in_flags;
bfd_boolean flags_compatible = TRUE;
asection *sec;
/* Check if we have the same endianess. */
if (! _bfd_generic_verify_endian_match (ibfd, obfd))
return FALSE;
if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
return TRUE;
if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
return FALSE;
/* The input BFD must have had its flags initialised. */
/* The following seems bogus to me -- The flags are initialized in
the assembler but I don't think an elf_flags_init field is
written into the object. */
/* BFD_ASSERT (elf_flags_init (ibfd)); */
in_flags = elf_elfheader (ibfd)->e_flags;
out_flags = elf_elfheader (obfd)->e_flags;
/* In theory there is no reason why we couldn't handle this. However
in practice it isn't even close to working and there is no real
reason to want it. */
if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
&& !(ibfd->flags & DYNAMIC)
&& (in_flags & EF_ARM_BE8))
{
_bfd_error_handler (_("error: %B is already in final BE8 format"),
ibfd);
return FALSE;
}
if (!elf_flags_init (obfd))
{
/* If the input is the default architecture and had the default
flags then do not bother setting the flags for the output
architecture, instead allow future merges to do this. If no
future merges ever set these flags then they will retain their
uninitialised values, which surprise surprise, correspond
to the default values. */
if (bfd_get_arch_info (ibfd)->the_default
&& elf_elfheader (ibfd)->e_flags == 0)
return TRUE;
elf_flags_init (obfd) = TRUE;
elf_elfheader (obfd)->e_flags = in_flags;
if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
&& bfd_get_arch_info (obfd)->the_default)
return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
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;
/* Identical flags must be compatible. */
if (in_flags == out_flags)
return TRUE;
/* Check to see if the input BFD actually contains any sections. If
not, its flags may not have been initialised either, but it
cannot actually cause any incompatiblity. Do not short-circuit
dynamic objects; their section list may be emptied by
elf_link_add_object_symbols.
Also check to see if there are no code sections in the input.
In this case there is no need to check for code specific flags.
XXX - do we need to worry about floating-point format compatability
in data sections ? */
if (!(ibfd->flags & DYNAMIC))
{
bfd_boolean null_input_bfd = TRUE;
bfd_boolean only_data_sections = TRUE;
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
{
/* Ignore synthetic glue sections. */
if (strcmp (sec->name, ".glue_7")
&& strcmp (sec->name, ".glue_7t"))
{
if ((bfd_get_section_flags (ibfd, sec)
& (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
== (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
only_data_sections = FALSE;
null_input_bfd = FALSE;
break;
}
}
if (null_input_bfd || only_data_sections)
return TRUE;
}
/* Complain about various flag mismatches. */
if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
EF_ARM_EABI_VERSION (out_flags)))
{
_bfd_error_handler
(_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
ibfd, obfd,
(in_flags & EF_ARM_EABIMASK) >> 24,
(out_flags & EF_ARM_EABIMASK) >> 24);
return FALSE;
}
/* Not sure what needs to be checked for EABI versions >= 1. */
/* VxWorks libraries do not use these flags. */
if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
&& get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
&& EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
{
if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
{
_bfd_error_handler
(_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
ibfd, obfd,
in_flags & EF_ARM_APCS_26 ? 26 : 32,
out_flags & EF_ARM_APCS_26 ? 26 : 32);
flags_compatible = FALSE;
}
if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
{
if (in_flags & EF_ARM_APCS_FLOAT)
_bfd_error_handler
(_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
ibfd, obfd);
flags_compatible = FALSE;
}
if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
{
if (in_flags & EF_ARM_VFP_FLOAT)
_bfd_error_handler
(_("error: %B uses VFP instructions, whereas %B does not"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B uses FPA instructions, whereas %B does not"),
ibfd, obfd);
flags_compatible = FALSE;
}
if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
{
if (in_flags & EF_ARM_MAVERICK_FLOAT)
_bfd_error_handler
(_("error: %B uses Maverick instructions, whereas %B does not"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B does not use Maverick instructions, whereas %B does"),
ibfd, obfd);
flags_compatible = FALSE;
}
#ifdef EF_ARM_SOFT_FLOAT
if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
{
/* We can allow interworking between code that is VFP format
layout, and uses either soft float or integer regs for
passing floating point arguments and results. We already
know that the APCS_FLOAT flags match; similarly for VFP
flags. */
if ((in_flags & EF_ARM_APCS_FLOAT) != 0
|| (in_flags & EF_ARM_VFP_FLOAT) == 0)
{
if (in_flags & EF_ARM_SOFT_FLOAT)
_bfd_error_handler
(_("error: %B uses software FP, whereas %B uses hardware FP"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B uses hardware FP, whereas %B uses software FP"),
ibfd, obfd);
flags_compatible = FALSE;
}
}
#endif
/* Interworking mismatch is only a warning. */
if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
{
if (in_flags & EF_ARM_INTERWORK)
{
_bfd_error_handler
(_("Warning: %B supports interworking, whereas %B does not"),
ibfd, obfd);
}
else
{
_bfd_error_handler
(_("Warning: %B does not support interworking, whereas %B does"),
ibfd, obfd);
}
}
}
return flags_compatible;
}
elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd);
/* Display the flags field. */
@ -10838,7 +10633,8 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
size = symtab_hdr->sh_info;
size *= (sizeof (bfd_signed_vma) + sizeof (char));
local_got_refcounts = bfd_zalloc (abfd, size);
local_got_refcounts = (bfd_signed_vma *)
bfd_zalloc (abfd, size);
if (local_got_refcounts == NULL)
return FALSE;
elf_local_got_refcounts (abfd) = local_got_refcounts;
@ -11037,7 +10833,8 @@ elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
{
bfd_size_type amt = sizeof *p;
p = bfd_alloc (htab->root.dynobj, amt);
p = (struct elf32_arm_relocs_copied *)
bfd_alloc (htab->root.dynobj, amt);
if (p == NULL)
return FALSE;
p->next = *head;
@ -11811,7 +11608,8 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
{
struct elf32_arm_relocs_copied *p;
for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
for (p = (struct elf32_arm_relocs_copied *)
elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
{
if (!bfd_is_abs_section (p->section)
&& bfd_is_abs_section (p->section->output_section))
@ -11965,7 +11763,7 @@ elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
continue;
/* Allocate memory for the section contents. */
s->contents = bfd_zalloc (dynobj, s->size);
s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
if (s->contents == NULL)
return FALSE;
}
@ -12760,7 +12558,7 @@ record_section_with_arm_elf_section_data (asection * sec)
{
struct section_list * entry;
entry = bfd_malloc (sizeof (* entry));
entry = (struct section_list *) bfd_malloc (sizeof (* entry));
if (entry == NULL)
return;
entry->sec = sec;
@ -13224,7 +13022,7 @@ elf32_arm_new_section_hook (bfd *abfd, asection *sec)
_arm_elf_section_data *sdata;
bfd_size_type amt = sizeof (*sdata);
sdata = bfd_zalloc (abfd, amt);
sdata = (_arm_elf_section_data *) bfd_zalloc (abfd, amt);
if (sdata == NULL)
return FALSE;
sec->used_by_bfd = sdata;
@ -13516,7 +13314,7 @@ elf32_arm_write_section (bfd *output_bfd,
size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
markers) was sec->rawsize. (This isn't the case if we perform no
edits, then rawsize will be zero and we should use size). */
bfd_byte *edited_contents = bfd_malloc (sec->size);
bfd_byte *edited_contents = (bfd_byte *) bfd_malloc (sec->size);
unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
unsigned int in_index, out_index;
bfd_vma add_to_offsets = 0;
@ -13789,7 +13587,8 @@ elf32_arm_modify_segment_map (bfd *abfd,
m = m->next;
if (!m)
{
m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
m = (struct elf_segment_map *)
bfd_zalloc (abfd, sizeof (struct elf_segment_map));
if (m == NULL)
return FALSE;
m->p_type = PT_ARM_EXIDX;
@ -14001,6 +13800,231 @@ elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
#include "elf32-target.h"
/* Merge backend specific data from an object file to the output
object file when linking. */
static bfd_boolean
elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
{
flagword out_flags;
flagword in_flags;
bfd_boolean flags_compatible = TRUE;
asection *sec;
/* Check if we have the same endianess. */
if (! _bfd_generic_verify_endian_match (ibfd, obfd))
return FALSE;
if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
return TRUE;
if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
return FALSE;
/* The input BFD must have had its flags initialised. */
/* The following seems bogus to me -- The flags are initialized in
the assembler but I don't think an elf_flags_init field is
written into the object. */
/* BFD_ASSERT (elf_flags_init (ibfd)); */
in_flags = elf_elfheader (ibfd)->e_flags;
out_flags = elf_elfheader (obfd)->e_flags;
/* In theory there is no reason why we couldn't handle this. However
in practice it isn't even close to working and there is no real
reason to want it. */
if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
&& !(ibfd->flags & DYNAMIC)
&& (in_flags & EF_ARM_BE8))
{
_bfd_error_handler (_("error: %B is already in final BE8 format"),
ibfd);
return FALSE;
}
if (!elf_flags_init (obfd))
{
/* If the input is the default architecture and had the default
flags then do not bother setting the flags for the output
architecture, instead allow future merges to do this. If no
future merges ever set these flags then they will retain their
uninitialised values, which surprise surprise, correspond
to the default values. */
if (bfd_get_arch_info (ibfd)->the_default
&& elf_elfheader (ibfd)->e_flags == 0)
return TRUE;
elf_flags_init (obfd) = TRUE;
elf_elfheader (obfd)->e_flags = in_flags;
if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
&& bfd_get_arch_info (obfd)->the_default)
return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
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;
/* Identical flags must be compatible. */
if (in_flags == out_flags)
return TRUE;
/* Check to see if the input BFD actually contains any sections. If
not, its flags may not have been initialised either, but it
cannot actually cause any incompatiblity. Do not short-circuit
dynamic objects; their section list may be emptied by
elf_link_add_object_symbols.
Also check to see if there are no code sections in the input.
In this case there is no need to check for code specific flags.
XXX - do we need to worry about floating-point format compatability
in data sections ? */
if (!(ibfd->flags & DYNAMIC))
{
bfd_boolean null_input_bfd = TRUE;
bfd_boolean only_data_sections = TRUE;
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
{
/* Ignore synthetic glue sections. */
if (strcmp (sec->name, ".glue_7")
&& strcmp (sec->name, ".glue_7t"))
{
if ((bfd_get_section_flags (ibfd, sec)
& (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
== (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
only_data_sections = FALSE;
null_input_bfd = FALSE;
break;
}
}
if (null_input_bfd || only_data_sections)
return TRUE;
}
/* Complain about various flag mismatches. */
if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
EF_ARM_EABI_VERSION (out_flags)))
{
_bfd_error_handler
(_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
ibfd, obfd,
(in_flags & EF_ARM_EABIMASK) >> 24,
(out_flags & EF_ARM_EABIMASK) >> 24);
return FALSE;
}
/* Not sure what needs to be checked for EABI versions >= 1. */
/* VxWorks libraries do not use these flags. */
if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
&& get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
&& EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
{
if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
{
_bfd_error_handler
(_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
ibfd, obfd,
in_flags & EF_ARM_APCS_26 ? 26 : 32,
out_flags & EF_ARM_APCS_26 ? 26 : 32);
flags_compatible = FALSE;
}
if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
{
if (in_flags & EF_ARM_APCS_FLOAT)
_bfd_error_handler
(_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
ibfd, obfd);
flags_compatible = FALSE;
}
if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
{
if (in_flags & EF_ARM_VFP_FLOAT)
_bfd_error_handler
(_("error: %B uses VFP instructions, whereas %B does not"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B uses FPA instructions, whereas %B does not"),
ibfd, obfd);
flags_compatible = FALSE;
}
if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
{
if (in_flags & EF_ARM_MAVERICK_FLOAT)
_bfd_error_handler
(_("error: %B uses Maverick instructions, whereas %B does not"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B does not use Maverick instructions, whereas %B does"),
ibfd, obfd);
flags_compatible = FALSE;
}
#ifdef EF_ARM_SOFT_FLOAT
if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
{
/* We can allow interworking between code that is VFP format
layout, and uses either soft float or integer regs for
passing floating point arguments and results. We already
know that the APCS_FLOAT flags match; similarly for VFP
flags. */
if ((in_flags & EF_ARM_APCS_FLOAT) != 0
|| (in_flags & EF_ARM_VFP_FLOAT) == 0)
{
if (in_flags & EF_ARM_SOFT_FLOAT)
_bfd_error_handler
(_("error: %B uses software FP, whereas %B uses hardware FP"),
ibfd, obfd);
else
_bfd_error_handler
(_("error: %B uses hardware FP, whereas %B uses software FP"),
ibfd, obfd);
flags_compatible = FALSE;
}
}
#endif
/* Interworking mismatch is only a warning. */
if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
{
if (in_flags & EF_ARM_INTERWORK)
{
_bfd_error_handler
(_("Warning: %B supports interworking, whereas %B does not"),
ibfd, obfd);
}
else
{
_bfd_error_handler
(_("Warning: %B does not support interworking, whereas %B does"),
ibfd, obfd);
}
}
}
return flags_compatible;
}
/* Symbian OS Targets. */
#undef TARGET_LITTLE_SYM

107
bfd/elf64-alpha.c
View File

@ -1,6 +1,6 @@
/* Alpha specific support for 64-bit ELF
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008 Free Software Foundation, Inc.
2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Richard Henderson <rth@tamu.edu>.
This file is part of BFD, the Binary File Descriptor library.
@ -103,6 +103,57 @@ bfd_boolean elf64_alpha_use_secureplt = FALSE;
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
/* Used to implement multiple .got subsections. */
struct alpha_elf_got_entry
{
struct alpha_elf_got_entry *next;
/* Which .got subsection? */
bfd *gotobj;
/* The addend in effect for this entry. */
bfd_vma addend;
/* The .got offset for this entry. */
int got_offset;
/* The .plt offset for this entry. */
int plt_offset;
/* How many references to this entry? */
int use_count;
/* The relocation type of this entry. */
unsigned char reloc_type;
/* How a LITERAL is used. */
unsigned char flags;
/* Have we initialized the dynamic relocation for this entry? */
unsigned char reloc_done;
/* Have we adjusted this entry for SEC_MERGE? */
unsigned char reloc_xlated;
};
struct alpha_elf_reloc_entry
{
struct alpha_elf_reloc_entry *next;
/* Which .reloc section? */
asection *srel;
/* What kind of relocation? */
unsigned int rtype;
/* Is this against read-only section? */
unsigned int reltext : 1;
/* How many did we find? */
unsigned long count;
};
struct alpha_elf_link_hash_entry
{
struct elf_link_hash_entry root;
@ -125,56 +176,11 @@ struct alpha_elf_link_hash_entry
#define ALPHA_ELF_LINK_HASH_TLS_IE 0x80
/* Used to implement multiple .got subsections. */
struct alpha_elf_got_entry
{
struct alpha_elf_got_entry *next;
/* Which .got subsection? */
bfd *gotobj;
/* The addend in effect for this entry. */
bfd_vma addend;
/* The .got offset for this entry. */
int got_offset;
/* The .plt offset for this entry. */
int plt_offset;
/* How many references to this entry? */
int use_count;
/* The relocation type of this entry. */
unsigned char reloc_type;
/* How a LITERAL is used. */
unsigned char flags;
/* Have we initialized the dynamic relocation for this entry? */
unsigned char reloc_done;
/* Have we adjusted this entry for SEC_MERGE? */
unsigned char reloc_xlated;
} *got_entries;
struct alpha_elf_got_entry *got_entries;
/* Used to count non-got, non-plt relocations for delayed sizing
of relocation sections. */
struct alpha_elf_reloc_entry
{
struct alpha_elf_reloc_entry *next;
/* Which .reloc section? */
asection *srel;
/* What kind of relocation? */
unsigned int rtype;
/* Is this against read-only section? */
unsigned int reltext : 1;
/* How many did we find? */
unsigned long count;
} *reloc_entries;
struct alpha_elf_reloc_entry *reloc_entries;
};
/* Alpha ELF linker hash table. */
@ -458,8 +464,9 @@ elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry,
from smaller values. Start with zero, widen, *then* decrement. */
#define MINUS_ONE (((bfd_vma)0) - 1)
#define SKIP_HOWTO(N) \
HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
static reloc_howto_type elf64_alpha_howto_table[] =
{
@ -5062,7 +5069,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
interesting information, try to find the symbol in
the linker global hash table and save the information
for the output external symbols. */
eraw_src = input_debug.external_ext;
eraw_src = (char *) input_debug.external_ext;
eraw_end = (eraw_src
+ (input_debug.symbolic_header.iextMax
* input_swap->external_ext_size));

24
gas/ChangeLog
View File

@ -1,9 +1,27 @@
2009-09-25 Martin Thuresson <martint@google.com>
Update soruces to make alpha, arc and arm targets compile cleanly
with -Wc++-compat:
* config/tc-alpha.c: Add casts.
(extended_bfd_reloc_code_real_type): New type. Used to avoid
enumeration conversion warnings.
(struct alpha_fixup, void assemble_insn, assemble_insn)
(assemble_tokens): Use new type.
* ecoff.c: Add casts. (mark_stabs): Use enumeration names.
* config/obj-elf.c: Add cast
* config/tc-arc.c: Add casts.
* config/obj-aout.h (text_section,data_section,bss_section):
Make extern.
* config/obj-elf.c: Add cast.
* config/tc-arm.c: Add casts.
(X, TxCE, TxCE, TxC3, TxC3w, TxCM_, TxCM, TUE, TUF, CE, CL, cCE)
(cCL, C3E, xCM_, nUF, nCE_tag): Change input format to avoid the
need for keywords as arguments.
2009-09-25 Nick Hudson <nick.hudson@gmx.co.uk>
* doc/c-mips.texi: Fix the singlefloat and doublefloat kindex
entries.
2009-09-24 H.J. Lu <hongjiu.lu@intel.com>
entries2009-09-24 H.J. Lu <hongjiu.lu@intel.com>
* config/tc-i386.c (build_vex_prefix): Check vex == 2 instead
of vex256.

4
gas/config/obj-aout.h
View File

@ -1,6 +1,6 @@
/* obj-aout.h, a.out object file format for gas, the assembler.
Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000,
2002, 2003, 2005, 2007 Free Software Foundation, Inc.
2002, 2003, 2005, 2007, 2009 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
@ -53,7 +53,7 @@ typedef struct nlist obj_symbol_type; /* Symbol table entry. */
#define S_GET_DESC(S) \
(aout_symbol (symbol_get_bfdsym (S))->desc)
asection *text_section, *data_section, *bss_section;
extern asection *text_section, *data_section, *bss_section;
#define obj_frob_symbol(S,PUNT) obj_aout_frob_symbol (S, &PUNT)
#define obj_frob_file_before_fix() obj_aout_frob_file_before_fix ()

2
gas/config/obj-elf.c
View File

@ -2054,7 +2054,7 @@ build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
list->num_group += 1;
/* Add index to hash. */
idx_ptr = xmalloc (sizeof (unsigned int));
idx_ptr = (unsigned int *) xmalloc (sizeof (unsigned int));
*idx_ptr = i;
hash_insert (list->indexes, group_name, idx_ptr);
}

45
gas/config/tc-alpha.c
View File

@ -75,10 +75,15 @@
#define MAX_INSN_FIXUPS 2
#define MAX_INSN_ARGS 5
/* Used since new relocation types are introduced in this
file (DUMMY_RELOC_LITUSE_*) */
typedef int extended_bfd_reloc_code_real_type;
struct alpha_fixup
{
expressionS exp;
bfd_reloc_code_real_type reloc;
/* bfd_reloc_code_real_type reloc; */
extended_bfd_reloc_code_real_type reloc;
#ifdef OBJ_EVAX
symbolS *xtrasym, *procsym;
#endif
@ -444,7 +449,7 @@ static const struct alpha_reloc_op_tag
const char *name; /* String to lookup. */
size_t length; /* Size of the string. */
operatorT op; /* Which operator to use. */
bfd_reloc_code_real_type reloc; /* Relocation before frob. */
extended_bfd_reloc_code_real_type reloc;
unsigned int require_seq : 1; /* Require a sequence number. */
unsigned int allow_seq : 1; /* Allow a sequence number. */
}
@ -565,7 +570,7 @@ static const char * const mskXh_op[] = { NULL, "mskwh", "msklh", "mskqh" };
static const char * const stX_op[] = { "stb", "stw", "stl", "stq" };
static const char * const ldXu_op[] = { "ldbu", "ldwu", NULL, NULL };
static void assemble_insn (const struct alpha_opcode *, const expressionS *, int, struct alpha_insn *, bfd_reloc_code_real_type);
static void assemble_insn (const struct alpha_opcode *, const expressionS *, int, struct alpha_insn *, extended_bfd_reloc_code_real_type);
static void emit_insn (struct alpha_insn *);
static void assemble_tokens (const char *, const expressionS *, int, int);
#ifdef OBJ_EVAX
@ -587,7 +592,8 @@ get_alpha_reloc_tag (long sequence)
size_t len = strlen (buffer);
const char *errmsg;
info = xcalloc (sizeof (struct alpha_reloc_tag) + len, 1);
info = (struct alpha_reloc_tag *)
xcalloc (sizeof (struct alpha_reloc_tag) + len, 1);
info->segment = now_seg;
info->sequence = sequence;
@ -1764,8 +1770,9 @@ emit_insn (struct alpha_insn *insn)
}
else
{
reloc_howto_type *reloc_howto
= bfd_reloc_type_lookup (stdoutput, fixup->reloc);
reloc_howto_type *reloc_howto =
bfd_reloc_type_lookup (stdoutput,
(bfd_reloc_code_real_type) fixup->reloc);
gas_assert (reloc_howto);
size = bfd_get_reloc_size (reloc_howto);
@ -1787,7 +1794,7 @@ emit_insn (struct alpha_insn *insn)
}
fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
&fixup->exp, pcrel, fixup->reloc);
&fixup->exp, pcrel, (bfd_reloc_code_real_type) fixup->reloc);
/* Turn off complaints that the addend is too large for some fixups,
and copy in the sequence number for the explicit relocations. */
@ -2002,7 +2009,7 @@ assemble_insn (const struct alpha_opcode *opcode,
const expressionS *tok,
int ntok,
struct alpha_insn *insn,
bfd_reloc_code_real_type reloc)
extended_bfd_reloc_code_real_type reloc)
{
const struct alpha_operand *reloc_operand = NULL;
const expressionS *reloc_exp = NULL;
@ -2125,7 +2132,8 @@ assemble_insn (const struct alpha_opcode *opcode,
else if (reloc < BFD_RELOC_UNUSED && reloc > 0)
{
reloc_howto_type *reloc_howto
= bfd_reloc_type_lookup (stdoutput, reloc);
= bfd_reloc_type_lookup (stdoutput,
(bfd_reloc_code_real_type) reloc);
if (reloc_operand == NULL
|| reloc_howto->bitsize != reloc_operand->bits)
{
@ -2168,7 +2176,7 @@ emit_ir_load (const expressionS *tok,
basereg = tok[2].X_add_number;
lituse = load_expression (tok[0].X_add_number, &tok[1],
&basereg, &newtok[1], opname);
&basereg, &newtok[1], (const char *) opname);
if (basereg == alpha_gp_register &&
(symlen > 4 && strcmp (&symname [symlen - 4], "..lk") == 0))
@ -2215,7 +2223,7 @@ emit_loadstore (const expressionS *tok,
as_bad (_("macro requires $at register while noat in effect"));
lituse = load_expression (AXP_REG_AT, &tok[1],
&basereg, &newtok[1], opname);
&basereg, &newtok[1], (const char *) opname);
}
else
{
@ -3290,7 +3298,7 @@ assemble_tokens (const char *opname,
const struct alpha_opcode *opcode;
const struct alpha_macro *macro;
int cpumatch = 1;
bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
extended_bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
#ifdef RELOC_OP_P
/* If a user-specified relocation is present, this is not a macro. */
@ -3723,7 +3731,8 @@ s_alpha_ent (int dummy ATTRIBUTE_UNUSED)
sym = symbol_find_or_make (name);
symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
cur_frame_data = calloc (1, sizeof (*cur_frame_data));
cur_frame_data = (struct alpha_elf_frame_data *)
calloc (1, sizeof (*cur_frame_data));
cur_frame_data->func_sym = sym;
/* Provide sensible defaults. */
@ -3779,7 +3788,7 @@ s_alpha_end (int dummy ATTRIBUTE_UNUSED)
if (sym && cur_frame_data)
{
OBJ_SYMFIELD_TYPE *obj = symbol_get_obj (sym);
expressionS *exp = xmalloc (sizeof (expressionS));
expressionS *exp = (expressionS *) xmalloc (sizeof (expressionS));
obj->size = exp;
exp->X_op = O_subtract;
@ -3947,7 +3956,7 @@ s_alpha_file (int ignore ATTRIBUTE_UNUSED)
discard_rest_of_line ();
len = input_line_pointer - start;
first_file_directive = xmalloc (len + 1);
first_file_directive = (char *) xmalloc (len + 1);
memcpy (first_file_directive, start, len);
first_file_directive[len] = '\0';
@ -5425,7 +5434,7 @@ md_begin (void)
if ((slash = strchr (name, '/')) != NULL)
{
char *p = xmalloc (strlen (name));
char *p = (char *) xmalloc (strlen (name));
memcpy (p, name, slash - name);
strcpy (p + (slash - name), slash + 1);
@ -6207,8 +6216,8 @@ tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED,
{
arelent *reloc;
reloc = xmalloc (sizeof (* reloc));
reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
reloc = (arelent *) xmalloc (sizeof (* reloc));
reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;

15
gas/config/tc-arc.c
View File

@ -540,7 +540,8 @@ arc_extoper (int opertype)
return;
}
ext_oper = xmalloc (sizeof (struct arc_ext_operand_value));
ext_oper = (struct arc_ext_operand_value *)
xmalloc (sizeof (struct arc_ext_operand_value));
if (opertype)
{
@ -802,7 +803,7 @@ arc_extinst (int ignore ATTRIBUTE_UNUSED)
strcat (syntax, "%F");
strcat (syntax, "%S%L");
ext_op = xmalloc (sizeof (struct arc_opcode));
ext_op = (struct arc_opcode *) xmalloc (sizeof (struct arc_opcode));
ext_op->syntax = xstrdup (syntax);
ext_op->mask = I (-1) | ((0x3 == opcode) ? C (-1) : 0);
@ -1196,7 +1197,8 @@ arc_cons_fix_new (fragS *frag,
/* This may be a special ARC reloc (eg: %st()). */
reloc_type = get_arc_exp_reloc_type (1, BFD_RELOC_32, exp, &exptmp);
fix_new_exp (frag, where, nbytes, &exptmp, 0, reloc_type);
fix_new_exp (frag, where, nbytes, &exptmp, 0,
(enum bfd_reloc_code_real) reloc_type);
}
else
{
@ -1350,8 +1352,8 @@ tc_gen_reloc (asection *section ATTRIBUTE_UNUSED,
{
arelent *reloc;
reloc = xmalloc (sizeof (arelent));
reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
reloc = (arelent *) xmalloc (sizeof (arelent));
reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
@ -1568,7 +1570,8 @@ md_assemble (char *str)
if ((suf = get_ext_suffix (s)))
ext_suffix_p = 1;
else
suf = hash_find (arc_suffix_hash, s);
suf = (const struct arc_operand_value *)
hash_find (arc_suffix_hash, s);
if (!suf)
{
/* This can happen in "blle foo" and we're currently using

2671
gas/config/tc-arm.c
View File

File diff suppressed because it is too large Load Diff

8
gas/ecoff.c
View File

@ -3323,7 +3323,7 @@ mark_stabs (int ignore ATTRIBUTE_UNUSED)
{
/* Add a dummy @stabs dymbol. */
stabs_seen = 1;
(void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
(void) add_ecoff_symbol (stabs_symbol, st_Nil, sc_Info,
(symbolS *) NULL,
(bfd_vma) 0, (symint_t) -1,
ECOFF_MARK_STAB (0));
@ -3616,7 +3616,7 @@ ecoff_add_bytes (char **buf,
if (need < PAGE_SIZE)
need = PAGE_SIZE;
want = (*bufend - *buf) + need;
*buf = xrealloc (*buf, want);
*buf = (char *) xrealloc (*buf, want);
*bufend = *buf + want;
return *buf + at;
}
@ -4129,7 +4129,7 @@ ecoff_build_symbols (const struct ecoff_debug_swap *backend,
sym_ptr->ecoff_sym.asym.iss =
begin_ptr->ecoff_sym.asym.iss;
begin_type = begin_ptr->ecoff_sym.asym.st;
begin_type = (st_t) begin_ptr->ecoff_sym.asym.st;
if (begin_type == st_File
|| begin_type == st_Block)
{
@ -4697,7 +4697,7 @@ ecoff_build_debug (HDRR *hdr,
/* Build the symbolic information. */
offset = 0;
buf = xmalloc (PAGE_SIZE);
buf = (char *) xmalloc (PAGE_SIZE);
bufend = buf + PAGE_SIZE;
/* Build the line number information. */

6
ld/ChangeLog
View File

@ -1,3 +1,9 @@
2009-09-25 Martin Thuresson <martint@google.com>
Update soruces to make arm targets compile cleanly with
-Wc++-compat:
* emultempl/armelf.em: Add casts.
2009-09-23 Matt Rice <ratmice@gmail.com>
* emultempl/elf32.em (gld${EMULATION_NAME}_add_options): Add --audit,

7
ld/emultempl/armelf.em
View File

@ -276,7 +276,8 @@ gld${EMULATION_NAME}_after_allocation (void)
/* Build a sorted list of input text sections, then use that to process
the unwind table index. */
unsigned int list_size = 10;
asection **sec_list = xmalloc (list_size * sizeof (asection *));
asection **sec_list = (asection **)
xmalloc (list_size * sizeof (asection *));
unsigned int sec_count = 0;
LANG_FOR_EACH_INPUT_STATEMENT (is)
@ -302,8 +303,8 @@ gld${EMULATION_NAME}_after_allocation (void)
if (sec_count == list_size)
{
list_size *= 2;
sec_list = xrealloc (sec_list,
list_size * sizeof (asection *));
sec_list = (asection **)
xrealloc (sec_list, list_size * sizeof (asection *));
}
sec_list[sec_count++] = sec;

9
opcodes/ChangeLog
View File

@ -1,3 +1,12 @@
2009-09-25 Martin Thuresson <martint@google.com>
Update soruces to make arc and arm targets compile cleanly with
-Wc++-compat:
* arc-dis.c Fix casts.
* arc-ext.c: Add casts.
* arm-dis.c (enum opcode_sentinel_enum): Gave name to anonymous
enum.
2009-09-24 H.J. Lu <hongjiu.lu@intel.com>
* i386-gen.c (opcode_modifiers): Remove Vex256.

6
opcodes/arc-dis.c
View File

@ -1,5 +1,5 @@
/* Instruction printing code for the ARC.
Copyright 1994, 1995, 1997, 1998, 2000, 2001, 2002, 2005, 2007
Copyright 1994, 1995, 1997, 1998, 2000, 2001, 2002, 2005, 2007, 2009
Free Software Foundation, Inc.
Contributed by Doug Evans (dje@cygnus.com).
@ -1201,7 +1201,7 @@ decodeInstr (bfd_vma address, /* Address of this instruction. */
s.instName = _instName;
/* Disassemble. */
bytes = dsmOneArcInst (address, (void *)& s);
bytes = dsmOneArcInst (address, & s);
/* Display the disassembly instruction. */
(*func) (stream, "%08lx ", s.words[0]);
@ -1228,6 +1228,6 @@ disassembler_ftype
arc_get_disassembler (void *ptr)
{
if (ptr)
build_ARC_extmap (ptr);
build_ARC_extmap ((struct bfd *) ptr);
return decodeInstr;
}

6
opcodes/arc-ext.c
View File

@ -1,5 +1,5 @@
/* ARC target-dependent stuff. Extension structure access functions
Copyright 1995, 1997, 2000, 2001, 2004, 2005, 2007
Copyright 1995, 1997, 2000, 2001, 2004, 2005, 2007, 2009
Free Software Foundation, Inc.
This file is part of libopcodes.
@ -148,8 +148,8 @@ cleanup_ext_map(void)
int
arcExtMap_add(void *base, unsigned long length)
{
unsigned char *block = base;
unsigned char *p = block;
unsigned char *block = (unsigned char *) base;
unsigned char *p = (unsigned char *) block;
/* Clean up and reset everything if needed. */
cleanup_ext_map();

2
opcodes/arm-dis.c
View File

@ -106,7 +106,7 @@ struct opcode16
(print "32" when 0)
%r print register offset address for wldt/wstr instruction. */
enum
enum opcode_sentinel_enum
{
SENTINEL_IWMMXT_START = 1,
SENTINEL_IWMMXT_END,