darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-25 05:00:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

2000-12-08 Kazu Hirata <kazu@hxi.com>

Browse Source 
* coffgen.c: Fix formatting.
	* elf32-i386.c: Likewise.
	* elf32-i960.c: Likewise.
	* elf32-m68k.c: Likewise.
	* elf32-mcore.c: Likewise.
	* elf32-ppc.c: Likewise.
	* elf32-sh.c: Likewise.
	* elf32-sparc.c: Likewise.
	* elf32-v850.c: Likewise.
	* elf64-sparc.c: Likewise.
	* elf-m10300.c: Likewise.
This commit is contained in:
Kazu Hirata 2000-12-08 18:34:32 +00:00
parent a98cc2b2fd
commit 435b1e90b1
12 changed files with 285 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
bfd/ChangeLog
View File

@ -1,3 +1,17 @@
2000-12-08 Kazu Hirata <kazu@hxi.com>
* coffgen.c: Fix formatting.
* elf32-i386.c: Likewise.
* elf32-i960.c: Likewise.
* elf32-m68k.c: Likewise.
* elf32-mcore.c: Likewise.
* elf32-ppc.c: Likewise.
* elf32-sh.c: Likewise.
* elf32-sparc.c: Likewise.
* elf32-v850.c: Likewise.
* elf64-sparc.c: Likewise.
* elf-m10300.c: Likewise.
2000-12-07 Kazu Hirata <kazu@hxi.com>
* elf32-ppc.c: Fix formatting.

5
bfd/coffgen.c
View File

@ -557,7 +557,6 @@ coff_count_linenumbers (abfd)
/* Takes a bfd and a symbol, returns a pointer to the coff specific
area of the symbol if there is one. */
/*ARGSUSED*/
coff_symbol_type *
coff_symbol_from (ignore_abfd, symbol)
bfd *ignore_abfd ATTRIBUTE_UNUSED;
@ -1375,7 +1374,6 @@ coff_write_linenumbers (abfd)
return true;
}
/*ARGSUSED */
alent *
coff_get_lineno (ignore_abfd, symbol)
bfd *ignore_abfd ATTRIBUTE_UNUSED;
@ -1908,7 +1906,6 @@ coff_bfd_make_debug_symbol (abfd, ptr, sz)
return &new->symbol;
}
/*ARGSUSED */
void
coff_get_symbol_info (abfd, symbol, ret)
bfd *abfd;
@ -2161,7 +2158,7 @@ _bfd_coff_is_local_label_name (abfd, name)
/* Provided a BFD, a section and an offset (in bytes, not octets) into the
section, calculate and return the name of the source file and the line
nearest to the wanted location. */
/*ARGSUSED*/
boolean
coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
functionname_ptr, line_ptr)

1
bfd/elf-m10300.c
View File

@ -2886,7 +2886,6 @@ elf_mn10300_mach (flags)
file. This gets the MN10300 architecture right based on the machine
number. */
/*ARGSUSED*/
void
_bfd_mn10300_elf_final_write_processing (abfd, linker)
bfd *abfd;

1
bfd/elf32-i386.c
View File

@ -1257,7 +1257,6 @@ elf_i386_size_dynamic_sections (output_bfd, info)
check_relocs routine, but we won't fill them in in the
relocate_section routine. */
/*ARGSUSED*/
static boolean
elf_i386_discard_copies (h, inf)
struct elf_i386_link_hash_entry *h;

1
bfd/elf32-i960.c
View File

@ -102,7 +102,6 @@ elf32_i960_info_to_howto_rel (abfd, cache_ptr, dst)
function. It just short circuits the reloc if producing
relocateable output against an external symbol. */
/*ARGSUSED*/
bfd_reloc_status_type
elf32_i960_relocate (abfd,
reloc_entry,

1
bfd/elf32-m68k.c
View File

@ -1324,7 +1324,6 @@ elf_m68k_size_dynamic_sections (output_bfd, info)
in regular objects. We allocated space for them in the check_relocs
routine, but we won't fill them in in the relocate_section routine. */
/*ARGSUSED*/
static boolean
elf_m68k_discard_copies (h, ignore)
struct elf_m68k_link_hash_entry *h;

1
bfd/elf32-mcore.c
View File

@ -350,7 +350,6 @@ mcore_elf_merge_private_bfd_data (ibfd, obfd)
/* Don't pretend we can deal with unsupported relocs. */
/*ARGSUSED*/
static bfd_reloc_status_type
mcore_elf_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
output_bfd, error_message)

1
bfd/elf32-ppc.c
View File

@ -2566,7 +2566,6 @@ ppc_elf_gc_sweep_hook (abfd, info, sec, relocs)
/* Hook called by the linker routine which adds symbols from an object
file. We use it to put .comm items in .sbss, and not .bss. */
/*ARGSUSED*/
static boolean
ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
bfd *abfd;

215
bfd/elf32-sh.c
View File

@ -77,8 +77,7 @@ static boolean sh_elf_finish_dynamic_sections
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
static reloc_howto_type sh_elf_howto_table[] =
{
static reloc_howto_type sh_elf_howto_table[] = {
/* No relocation. */
HOWTO (R_SH_NONE, /* type */
0, /* rightshift */
@ -710,7 +709,7 @@ static reloc_howto_type sh_elf_howto_table[] =
static bfd_reloc_status_type
sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
symbol_section, start, end)
symbol_section, start, end)
int r_type ATTRIBUTE_UNUSED;
bfd *input_bfd;
asection *input_section;
@ -821,7 +820,7 @@ sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
static bfd_reloc_status_type
sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
error_message)
error_message)
bfd *abfd;
arelent *reloc_entry;
asymbol *symbol_in;
@ -855,8 +854,8 @@ sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
return bfd_reloc_undefined;
if (bfd_is_com_section (symbol_in->section))
sym_value = 0;
else
sym_value = 0;
else
sym_value = (symbol_in->value +
symbol_in->section->output_section->vma +
symbol_in->section->output_offset);
@ -912,16 +911,14 @@ sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
/* This structure is used to map BFD reloc codes to SH ELF relocs. */
struct elf_reloc_map
{
struct elf_reloc_map {
bfd_reloc_code_real_type bfd_reloc_val;
unsigned char elf_reloc_val;
};
/* An array mapping BFD reloc codes to SH ELF relocs. */
static const struct elf_reloc_map sh_reloc_map[] =
{
static const struct elf_reloc_map sh_reloc_map[] = {
{ BFD_RELOC_NONE, R_SH_NONE },
{ BFD_RELOC_32, R_SH_DIR32 },
{ BFD_RELOC_CTOR, R_SH_DIR32 },
@ -1001,7 +998,7 @@ sh_elf_info_to_howto (abfd, cache_ptr, dst)
values; in coff-sh.c they come from include/coff/sh.h, whereas here
they come from enum elf_sh_reloc_type in include/elf/sh.h. */
static boolean
static boolean
sh_elf_relax_section (abfd, sec, link_info, again)
bfd *abfd;
asection *sec;
@ -1106,7 +1103,7 @@ sh_elf_relax_section (abfd, sec, link_info, again)
on a four byte boundary. */
paddr = insn & 0xff;
paddr *= 4;
paddr += (laddr + 4) &~ 3;
paddr += (laddr + 4) & ~3;
if (paddr >= sec->_raw_size)
{
((*_bfd_error_handler)
@ -1564,7 +1561,7 @@ sh_elf_relax_delete_bytes (abfd, sec, addr, count)
case R_SH_DIR8WPL:
off = insn & 0xff;
stop = (start &~ (bfd_vma) 3) + 4 + off * 4;
stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
break;
case R_SH_SWITCH8:
@ -2090,8 +2087,7 @@ sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
/* First entry in an absolute procedure linkage table look like this. */
static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
{
static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] = {
0xd0, 0x04, /* mov.l 1f,r0 */
0xd2, 0x05, /* mov.l 2f,r2 */
0x60, 0x02, /* mov.l @r0,r0 */
@ -2106,8 +2102,7 @@ static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
};
static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
{
static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] = {
0x04, 0xd0, /* mov.l 1f,r0 */
0x05, 0xd2, /* mov.l 2f,r2 */
0x02, 0x60, /* mov.l @r0,r0 */
@ -2125,8 +2120,7 @@ static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
/* Sebsequent entries in an absolute procedure linkage table look like
this. */
static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
{
static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] = {
0xd0, 0x04, /* mov.l 1f,r0 */
0x60, 0x02, /* mov.l @r0,r0 */
0xd2, 0x02, /* mov.l 0f,r2 */
@ -2140,8 +2134,7 @@ static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
};
static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
{
static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] = {
0x04, 0xd0, /* mov.l 1f,r0 */
0x02, 0x60, /* mov.l @r0,r0 */
0x02, 0xd2, /* mov.l 0f,r2 */
@ -2157,8 +2150,7 @@ static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
/* Entries in a PIC procedure linkage table look like this. */
static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
{
static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] = {
0xd0, 0x04, /* mov.l 1f,r0 */
0x00, 0xce, /* mov.l @(r0,r12),r0 */
0x40, 0x2b, /* jmp @r0 */
@ -2173,8 +2165,7 @@ static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
};
static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
{
static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] = {
0x04, 0xd0, /* mov.l 1f,r0 */
0xce, 0x00, /* mov.l @(r0,r12),r0 */
0x2b, 0x40, /* jmp @r0 */
@ -2223,8 +2214,7 @@ static const bfd_byte *elf_sh_pic_plt_entry;
/* This structure keeps track of the number of PC relative relocs we
have copied for a given symbol. */
struct elf_sh_pcrel_relocs_copied
{
struct elf_sh_pcrel_relocs_copied {
/* Next section. */
struct elf_sh_pcrel_relocs_copied *next;
/* A section in dynobj. */
@ -2235,8 +2225,7 @@ struct elf_sh_pcrel_relocs_copied
/* sh ELF linker hash entry. */
struct elf_sh_link_hash_entry
{
struct elf_sh_link_hash_entry {
struct elf_link_hash_entry root;
/* Number of PC relative relocs copied for this symbol. */
@ -2245,8 +2234,7 @@ struct elf_sh_link_hash_entry
/* sh ELF linker hash table. */
struct elf_sh_link_hash_table
{
struct elf_sh_link_hash_table {
struct elf_link_hash_table root;
};
@ -2388,7 +2376,7 @@ sh_elf_create_dynamic_sections (abfd, info)
return false;
}
s = bfd_make_section (abfd,
s = bfd_make_section (abfd,
bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
@ -2448,9 +2436,9 @@ sh_elf_create_dynamic_sections (abfd, info)
copy relocs. */
if (! info->shared)
{
s = bfd_make_section (abfd,
(bed->default_use_rela_p
? ".rela.bss" : ".rel.bss"));
s = bfd_make_section (abfd,
(bed->default_use_rela_p
? ".rela.bss" : ".rel.bss"));
if (s == NULL
|| ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
|| ! bfd_set_section_alignment (abfd, s, ptralign))
@ -2461,7 +2449,6 @@ sh_elf_create_dynamic_sections (abfd, info)
return true;
}
/* Adjust a symbol defined by a dynamic object and referenced by a
regular object. The current definition is in some section of the
dynamic object, but we're not including those sections. We have to
@ -2830,7 +2817,6 @@ sh_elf_size_dynamic_sections (output_bfd, info)
check_relocs routine, but we won't fill them in in the
relocate_section routine. */
/*ARGSUSED*/
static boolean
sh_elf_discard_copies (h, ignore)
struct elf_sh_link_hash_entry *h;
@ -2892,7 +2878,7 @@ sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
asection *sec;
struct elf_link_hash_entry *h;
bfd_vma relocation;
bfd_vma addend = (bfd_vma)0;
bfd_vma addend = (bfd_vma) 0;
bfd_reloc_status_type r;
r_symndx = ELF32_R_SYM (rel->r_info);
@ -2963,7 +2949,7 @@ sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
sec = h->root.u.def.section;
/* In these cases, we don't need the relocation value.
We check specially because in some obscure cases
sec->output_section will be NULL. */
sec->output_section will be NULL. */
if (r_type == R_SH_GOTPC
|| (r_type == R_SH_PLT32
&& h->plt.offset != (bfd_vma) -1)
@ -3020,11 +3006,11 @@ sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
}
}
switch ((int)r_type)
switch ((int) r_type)
{
final_link_relocate:
/* COFF relocs don't use the addend. The addend is used for
R_SH_DIR32 to be compatible with other compilers. */
R_SH_DIR32 to be compatible with other compilers. */
r = _bfd_final_link_relocate (howto, input_bfd, input_section,
contents, rel->r_offset,
relocation, addend);
@ -3138,9 +3124,9 @@ sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
}
bfd_elf32_swap_reloca_out (output_bfd, &outrel,
(((Elf32_External_Rela *)
sreloc->contents)
+ sreloc->reloc_count));
(((Elf32_External_Rela *)
sreloc->contents)
+ sreloc->reloc_count));
++sreloc->reloc_count;
/* If this reloc is against an external symbol, we do
@ -3371,7 +3357,7 @@ sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
static bfd_byte *
sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
data, relocateable, symbols)
data, relocateable, symbols)
bfd *output_bfd;
struct bfd_link_info *link_info;
struct bfd_link_order *link_order;
@ -3503,45 +3489,45 @@ sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
}
static asection *
sh_elf_gc_mark_hook (abfd, info, rel, h, sym)
bfd *abfd;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
Elf_Internal_Rela *rel;
struct elf_link_hash_entry *h;
Elf_Internal_Sym *sym;
bfd *abfd;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
Elf_Internal_Rela *rel;
struct elf_link_hash_entry *h;
Elf_Internal_Sym *sym;
{
if (h != NULL)
{
switch (ELF32_R_TYPE (rel->r_info))
{
case R_SH_GNU_VTINHERIT:
case R_SH_GNU_VTENTRY:
break;
{
case R_SH_GNU_VTINHERIT:
case R_SH_GNU_VTENTRY:
break;
default:
switch (h->root.type)
{
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
return h->root.u.def.section;
default:
switch (h->root.type)
{
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
return h->root.u.def.section;
case bfd_link_hash_common:
return h->root.u.c.p->section;
case bfd_link_hash_common:
return h->root.u.c.p->section;
default:
break;
}
}
}
else
{
if (!(elf_bad_symtab (abfd)
&& ELF_ST_BIND (sym->st_info) != STB_LOCAL)
&& ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
default:
break;
}
}
}
else
{
if (!(elf_bad_symtab (abfd)
&& ELF_ST_BIND (sym->st_info) != STB_LOCAL)
&& ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
&& sym->st_shndx != SHN_COMMON))
{
return bfd_section_from_elf_index (abfd, sym->st_shndx);
}
}
{
return bfd_section_from_elf_index (abfd, sym->st_shndx);
}
}
return NULL;
}
@ -3557,14 +3543,14 @@ sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
/* We use got and plt entries for sh, but it would seem that the
existing SH code does no sort of reference counting or whatnot on
its GOT and PLT entries, so it is not possible to garbage collect
them at this time. */
them at this time. */
return true;
}
/* Look through the relocs for a section during the first phase.
Since we don't do .gots or .plts, we just need to consider the
virtual table relocs for gc. */
static boolean
sh_elf_check_relocs (abfd, info, sec, relocs)
bfd *abfd;
@ -3581,21 +3567,20 @@ sh_elf_check_relocs (abfd, info, sec, relocs)
asection *sgot;
asection *srelgot;
asection *sreloc;
sgot = NULL;
srelgot = NULL;
sreloc = NULL;
if (info->relocateable)
return true;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
if (!elf_bad_symtab (abfd))
sym_hashes_end -= symtab_hdr->sh_info;
dynobj = elf_hash_table (info)->dynobj;
local_got_offsets = elf_local_got_offsets (abfd);
@ -3604,13 +3589,13 @@ sh_elf_check_relocs (abfd, info, sec, relocs)
{
struct elf_link_hash_entry *h;
unsigned long r_symndx;
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
h = NULL;
h = NULL;
else
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
/* Some relocs require a global offset table. */
if (dynobj == NULL)
{
@ -3633,17 +3618,17 @@ sh_elf_check_relocs (abfd, info, sec, relocs)
{
/* This relocation describes the C++ object vtable hierarchy.
Reconstruct it for later use during GC. */
case R_SH_GNU_VTINHERIT:
if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
return false;
break;
case R_SH_GNU_VTINHERIT:
if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
return false;
break;
/* This relocation describes which C++ vtable entries are actually
used. Record for later use during GC. */
case R_SH_GNU_VTENTRY:
if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
return false;
break;
case R_SH_GNU_VTENTRY:
if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
return false;
break;
case R_SH_GOT32:
/* This symbol requires a global offset table entry. */
@ -3694,8 +3679,8 @@ sh_elf_check_relocs (abfd, info, sec, relocs)
}
else
{
/* This is a global offset table entry for a local
symbol. */
/* This is a global offset table entry for a local
symbol. */
if (local_got_offsets == NULL)
{
size_t size;
@ -3849,15 +3834,15 @@ sh_elf_check_relocs (abfd, info, sec, relocs)
}
break;
}
}
}
return true;
}
static boolean
sh_elf_set_mach_from_flags (abfd)
bfd * abfd;
bfd *abfd;
{
flagword flags = elf_elfheader (abfd)->e_flags;
@ -3891,10 +3876,11 @@ sh_elf_set_mach_from_flags (abfd)
return true;
}
/* Function to keep SH specific file flags. */
/* Function to keep SH specific file flags. */
static boolean
sh_elf_set_private_flags (abfd, flags)
bfd * abfd;
bfd *abfd;
flagword flags;
{
BFD_ASSERT (! elf_flags_init (abfd)
@ -3906,12 +3892,13 @@ sh_elf_set_private_flags (abfd, flags)
}
/* Copy backend specific data from one object module to another */
static boolean
sh_elf_copy_private_data (ibfd, obfd)
bfd * ibfd;
bfd * obfd;
bfd *ibfd;
bfd *obfd;
{
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return true;
@ -4009,7 +3996,7 @@ sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
{
if (elf_sh_plt_entry == NULL)
{
elf_sh_plt_entry = (bfd_big_endian (output_bfd)?
elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
elf_sh_plt_entry_be : elf_sh_plt_entry_le);
}
memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
@ -4030,7 +4017,7 @@ sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
{
if (elf_sh_pic_plt_entry == NULL)
{
elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd)?
elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
elf_sh_pic_plt_entry_be :
elf_sh_pic_plt_entry_le);
}
@ -4110,8 +4097,8 @@ sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
}
bfd_elf32_swap_reloca_out (output_bfd, &rel,
((Elf32_External_Rela *) srel->contents
+ srel->reloc_count));
((Elf32_External_Rela *) srel->contents
+ srel->reloc_count));
++srel->reloc_count;
}
@ -4136,8 +4123,8 @@ sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
rel.r_addend = 0;
bfd_elf32_swap_reloca_out (output_bfd, &rel,
((Elf32_External_Rela *) s->contents
+ s->reloc_count));
((Elf32_External_Rela *) s->contents
+ s->reloc_count));
++s->reloc_count;
}
@ -4242,7 +4229,7 @@ sh_elf_finish_dynamic_sections (output_bfd, info)
{
if (elf_sh_pic_plt_entry == NULL)
{
elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd)?
elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
elf_sh_pic_plt_entry_be :
elf_sh_pic_plt_entry_le);
}
@ -4253,7 +4240,7 @@ sh_elf_finish_dynamic_sections (output_bfd, info)
{
if (elf_sh_plt0_entry == NULL)
{
elf_sh_plt0_entry = (bfd_big_endian (output_bfd)?
elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
elf_sh_plt0_entry_be :
elf_sh_plt0_entry_le);
}

10
bfd/elf32-sparc.c
View File

@ -129,7 +129,6 @@ static reloc_howto_type elf32_sparc_vtinherit_howto =
static reloc_howto_type elf32_sparc_vtentry_howto =
HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", false,0,0, false);
struct elf_reloc_map {
bfd_reloc_code_real_type bfd_reloc_val;
unsigned char elf_reloc_val;
@ -188,7 +187,7 @@ elf32_sparc_reloc_type_lookup (abfd, code)
bfd_reloc_code_real_type code;
{
unsigned int i;
switch (code)
{
case BFD_RELOC_VTABLE_INHERIT:
@ -1068,11 +1067,9 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
return true;
}
#define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
#define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
/*ARGSUSED*/
static boolean
elf32_sparc_relax_section (abfd, section, link_info, again)
bfd *abfd ATTRIBUTE_UNUSED;
@ -1139,7 +1136,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
r_type = ELF32_R_TYPE (rel->r_info);
if (r_type == R_SPARC_GNU_VTINHERIT
if (r_type == R_SPARC_GNU_VTINHERIT
|| r_type == R_SPARC_GNU_VTENTRY)
continue;
@ -1621,7 +1618,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
|| ((reloc | 0x7fffff) == ~(bfd_vma)0)))
{
reloc >>= 2;
/* Check whether it fits into simm19 on v9. */
if (((reloc & 0x3c0000) == 0
|| (reloc & 0x3c0000) == 0x3c0000)
@ -1671,7 +1668,6 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
contents, rel->r_offset,
relocation, rel->r_addend);
if (r != bfd_reloc_ok)
{
switch (r)

285
bfd/elf32-v850.c
View File

@ -17,12 +17,9 @@ 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
dependencies. As is the gas & simulator code or the v850. */
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
@ -32,7 +29,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* sign-extend a 24-bit number */
#define SEXT24(x) ((((x) & 0xffffff) ^ (~ 0x7fffff)) + 0x800000)
static reloc_howto_type *v850_elf_reloc_type_lookup
PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
static void v850_elf_info_to_howto_rel
@ -103,7 +100,7 @@ static reloc_howto_type v850_elf_howto_table[] =
0, /* dst_mask */
false), /* pcrel_offset */
/* A PC relative 9 bit branch. */
/* A PC relative 9 bit branch. */
HOWTO (R_V850_9_PCREL, /* type */
2, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
@ -118,7 +115,7 @@ static reloc_howto_type v850_elf_howto_table[] =
0x00ffffff, /* dst_mask */
true), /* pcrel_offset */
/* A PC relative 22 bit branch. */
/* A PC relative 22 bit branch. */
HOWTO (R_V850_22_PCREL, /* type */
2, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
@ -312,7 +309,7 @@ static reloc_howto_type v850_elf_howto_table[] =
0x7f, /* src_mask */
0x7f, /* dst_mask */
false), /* pcrel_offset */
/* 7 bit offset from the tiny data area pointer. */
HOWTO (R_V850_TDA_7_7_OFFSET, /* type */
0, /* rightshift */
@ -462,7 +459,7 @@ static reloc_howto_type v850_elf_howto_table[] =
0, /* src_mask */
0, /* dst_mask */
false), /* pcrel_offset */
};
/* Map BFD reloc types to V850 ELF reloc types. */
@ -521,7 +518,7 @@ v850_elf_reloc_type_lookup (abfd, code)
if (v850_elf_reloc_map[i].bfd_reloc_val == code)
{
BFD_ASSERT (v850_elf_howto_table[v850_elf_reloc_map[i].elf_reloc_val].type == v850_elf_reloc_map[i].elf_reloc_val);
return & v850_elf_howto_table[v850_elf_reloc_map[i].elf_reloc_val];
}
}
@ -544,7 +541,7 @@ v850_elf_info_to_howto_rel (abfd, cache_ptr, dst)
cache_ptr->howto = &v850_elf_howto_table[r_type];
}
/* Set the howto pointer for a V850 ELF reloc (type RELA). */
/* Set the howto pointer for a V850 ELF reloc (type RELA). */
static void
v850_elf_info_to_howto_rela (abfd, cache_ptr, dst)
bfd * abfd ATTRIBUTE_UNUSED;
@ -644,14 +641,14 @@ v850_elf_check_relocs (abfd, info, sec, relocs)
other = V850_OTHER_SDA;
common = ".scommon";
goto small_data_common;
case R_V850_ZDA_16_16_SPLIT_OFFSET:
case R_V850_ZDA_16_16_OFFSET:
case R_V850_ZDA_15_16_OFFSET:
other = V850_OTHER_ZDA;
common = ".zcommon";
goto small_data_common;
case R_V850_TDA_4_5_OFFSET:
case R_V850_TDA_4_4_OFFSET:
case R_V850_TDA_6_8_OFFSET:
@ -760,21 +757,21 @@ remember_hi16s_reloc (abfd, addend, address)
bfd_byte * address;
{
hi16s_location * entry = NULL;
/* Find a free structure. */
if (free_hi16s == NULL)
free_hi16s = (hi16s_location *) bfd_zalloc (abfd, sizeof (* free_hi16s));
entry = free_hi16s;
free_hi16s = free_hi16s->next;
entry->addend = addend;
entry->address = address;
entry->counter = hi16s_counter ++;
entry->found = false;
entry->next = previous_hi16s;
previous_hi16s = entry;
/* Cope with wrap around of our counter. */
if (hi16s_counter == 0)
{
@ -784,7 +781,7 @@ remember_hi16s_reloc (abfd, addend, address)
hi16s_counter = 0x10000;
}
return;
}
@ -798,7 +795,7 @@ find_remembered_hi16s_reloc (addend, already_found)
hi16s_location * previous = NULL;
hi16s_location * prev;
bfd_byte * addr;
/* Search the table. Record the most recent entry that matches. */
for (entry = previous_hi16s; entry; entry = entry->next)
{
@ -808,7 +805,7 @@ find_remembered_hi16s_reloc (addend, already_found)
previous = prev;
match = entry;
}
prev = entry;
}
@ -824,9 +821,9 @@ find_remembered_hi16s_reloc (addend, already_found)
/* Note that this entry has now been used. */
match->found = true;
return addr;
}
}
/* FIXME: The code here probably ought to be removed and the code in reloc.c
allowed to do its stuff instead. At least for most of the relocs, anwyay. */
@ -839,62 +836,62 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
{
unsigned long insn;
bfd_signed_vma saddend = (bfd_signed_vma) addend;
switch (r_type)
{
default:
/* fprintf (stderr, "reloc type %d not SUPPORTED\n", r_type ); */
return bfd_reloc_notsupported;
case R_V850_32:
bfd_put_32 (abfd, addend, address);
return bfd_reloc_ok;
case R_V850_22_PCREL:
if (saddend > 0x1fffff || saddend < -0x200000)
return bfd_reloc_overflow;
if ((addend % 2) != 0)
return bfd_reloc_dangerous;
insn = bfd_get_32 (abfd, address);
insn &= ~0xfffe003f;
insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
bfd_put_32 (abfd, insn, address);
return bfd_reloc_ok;
case R_V850_9_PCREL:
if (saddend > 0xff || saddend < -0x100)
return bfd_reloc_overflow;
if ((addend % 2) != 0)
return bfd_reloc_dangerous;
insn = bfd_get_16 (abfd, address);
insn &= ~ 0xf870;
insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
break;
case R_V850_HI16:
addend += (bfd_get_16 (abfd, address) << 16);
addend = (addend >> 16);
insn = addend;
break;
case R_V850_HI16_S:
/* Remember where this relocation took place. */
remember_hi16s_reloc (abfd, addend, address);
addend += (bfd_get_16 (abfd, address) << 16);
addend = (addend >> 16) + ((addend & 0x8000) != 0);
/* This relocation cannot overflow. */
/* This relocation cannot overflow. */
if (addend > 0x7fff)
addend = 0;
insn = addend;
break;
case R_V850_LO16:
/* Calculate the sum of the value stored in the instruction and the
addend and check for overflow from the low 16 bits into the high
@ -972,7 +969,6 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
------------
0x00116fff = fred + 0x10ffff = 0x7000 + 0x10ffff
Overflow can also occur if the computation carries into the 16th bit
and it also results in the 15th bit having the same value as the 15th
bit of the original value. What happens is that the HI16S reloc
@ -1007,7 +1003,7 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
+ 0x00006fff
------------
0x00006fff but 'fred + 0x7000' = 0x00016fff
Note - there is no need to change anything if a carry occurs, and the
15th bit changes its value from being set to being clear, as the HI16S
reloc will have already added in 1 to the high part for us:
@ -1046,7 +1042,7 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
#define BIT15_SET(x) ((x) & 0x8000)
#define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
if ((BIT15_SET (result) && ! BIT15_SET (addend))
|| (OVERFLOWS (addend, insn)
&& ((! BIT15_SET (insn)) || (BIT15_SET (addend)))))
@ -1054,7 +1050,7 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
boolean already_updated;
bfd_byte * hi16s_address = find_remembered_hi16s_reloc
(addend, & already_updated);
/* Amend the matching HI16_S relocation. */
if (hi16s_address != NULL)
{
@ -1071,7 +1067,7 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
return bfd_reloc_overflow;
}
}
/* Do not complain if value has top bit set, as this has been anticipated. */
insn = result & 0xffff;
break;
@ -1081,7 +1077,7 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
addend += (char) bfd_get_8 (abfd, address);
saddend = (bfd_signed_vma) addend;
if (saddend > 0x7f || saddend < -0x80)
return bfd_reloc_overflow;
@ -1090,150 +1086,150 @@ v850_elf_perform_relocation (abfd, r_type, addend, address)
case R_V850_CALLT_16_16_OFFSET:
addend += bfd_get_16 (abfd, address);
saddend = (bfd_signed_vma) addend;
if (saddend > 0xffff || saddend < 0)
return bfd_reloc_overflow;
insn = addend;
break;
case R_V850_16:
/* drop through */
/* drop through */
case R_V850_SDA_16_16_OFFSET:
case R_V850_ZDA_16_16_OFFSET:
case R_V850_TDA_16_16_OFFSET:
addend += bfd_get_16 (abfd, address);
saddend = (bfd_signed_vma) addend;
if (saddend > 0x7fff || saddend < -0x8000)
return bfd_reloc_overflow;
insn = addend;
break;
case R_V850_SDA_15_16_OFFSET:
case R_V850_ZDA_15_16_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += (insn & 0xfffe);
saddend = (bfd_signed_vma) addend;
if (saddend > 0x7ffe || saddend < -0x8000)
return bfd_reloc_overflow;
if (addend & 1)
return bfd_reloc_dangerous;
insn = (addend & ~1) | (insn & 1);
break;
case R_V850_TDA_6_8_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += ((insn & 0x7e) << 1);
saddend = (bfd_signed_vma) addend;
if (saddend > 0xfc || saddend < 0)
return bfd_reloc_overflow;
if (addend & 3)
return bfd_reloc_dangerous;
insn &= 0xff81;
insn |= (addend >> 1);
break;
case R_V850_TDA_7_8_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += ((insn & 0x7f) << 1);
saddend = (bfd_signed_vma) addend;
if (saddend > 0xfe || saddend < 0)
return bfd_reloc_overflow;
if (addend & 1)
return bfd_reloc_dangerous;
insn &= 0xff80;
insn |= (addend >> 1);
break;
case R_V850_TDA_7_7_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += insn & 0x7f;
saddend = (bfd_signed_vma) addend;
if (saddend > 0x7f || saddend < 0)
return bfd_reloc_overflow;
insn &= 0xff80;
insn |= addend;
break;
case R_V850_TDA_4_5_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += ((insn & 0xf) << 1);
saddend = (bfd_signed_vma) addend;
if (saddend > 0x1e || saddend < 0)
return bfd_reloc_overflow;
if (addend & 1)
return bfd_reloc_dangerous;
insn &= 0xfff0;
insn |= (addend >> 1);
break;
case R_V850_TDA_4_4_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += insn & 0xf;
saddend = (bfd_signed_vma) addend;
if (saddend > 0xf || saddend < 0)
return bfd_reloc_overflow;
insn &= 0xfff0;
insn |= addend;
break;
case R_V850_ZDA_16_16_SPLIT_OFFSET:
case R_V850_SDA_16_16_SPLIT_OFFSET:
insn = bfd_get_32 (abfd, address);
addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
saddend = (bfd_signed_vma) addend;
if (saddend > 0x7fff || saddend < -0x8000)
return bfd_reloc_overflow;
insn &= 0x0001ffdf;
insn |= (addend & 1) << 5;
insn |= (addend & ~1) << 16;
bfd_put_32 (abfd, insn, address);
return bfd_reloc_ok;
case R_V850_CALLT_6_7_OFFSET:
insn = bfd_get_16 (abfd, address);
addend += ((insn & 0x3f) << 1);
saddend = (bfd_signed_vma) addend;
if (saddend > 0x7e || saddend < 0)
return bfd_reloc_overflow;
if (addend & 1)
return bfd_reloc_dangerous;
insn &= 0xff80;
insn |= (addend >> 1);
break;
@ -1261,7 +1257,7 @@ v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
char ** err ATTRIBUTE_UNUSED;
{
long relocation;
/* If there is an output BFD,
and the symbol is not a section name (which is only defined at final link time),
and either we are not putting the addend into the instruction
@ -1275,13 +1271,13 @@ v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
reloc->address += isection->output_offset;
return bfd_reloc_ok;
}
#if 0
#if 0
else if (obfd != NULL)
{
return bfd_reloc_continue;
}
#endif
/* Catch relocs involving undefined symbols. */
if (bfd_is_und_section (symbol->section)
&& (symbol->flags & BSF_WEAK) == 0
@ -1293,37 +1289,36 @@ v850_elf_reloc (abfd, reloc, symbol, data, isection, obfd, err)
/* Is the address of the relocation really within the section? */
if (reloc->address > isection->_cooked_size)
return bfd_reloc_outofrange;
/* Work out which section the relocation is targetted at and the
initial relocation command value. */
/* Get symbol value. (Common symbols are special.) */
if (bfd_is_com_section (symbol->section))
relocation = 0;
else
relocation = symbol->value;
/* Convert input-section-relative symbol value to absolute + addend. */
relocation += symbol->section->output_section->vma;
relocation += symbol->section->output_offset;
relocation += reloc->addend;
if (reloc->howto->pc_relative == true)
{
/* Here the variable relocation holds the final address of the
symbol we are relocating against, plus any addend. */
relocation -= isection->output_section->vma + isection->output_offset;
/* Deal with pcrel_offset */
relocation -= reloc->address;
}
reloc->addend = relocation;
reloc->addend = relocation;
return bfd_reloc_ok;
}
/*ARGSUSED*/
static boolean
v850_elf_is_local_label_name (abfd, name)
bfd * abfd ATTRIBUTE_UNUSED;
@ -1362,7 +1357,7 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
+ input_section->output_offset);
value -= offset;
break;
case R_V850_22_PCREL:
value -= (input_section->output_section->vma
+ input_section->output_offset
@ -1371,10 +1366,10 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
/* If the sign extension will corrupt the value then we have overflowed. */
if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
return bfd_reloc_overflow;
value = SEXT24 (value); /* Only the bottom 24 bits of the PC are valid */
break;
case R_V850_HI16_S:
case R_V850_HI16:
case R_V850_LO16:
@ -1383,12 +1378,12 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
case R_V850_8:
break;
case R_V850_ZDA_15_16_OFFSET:
case R_V850_ZDA_15_16_OFFSET:
case R_V850_ZDA_16_16_OFFSET:
case R_V850_ZDA_16_16_SPLIT_OFFSET:
if (sym_sec == NULL)
return bfd_reloc_undefined;
value -= sym_sec->output_section->vma;
break;
@ -1401,7 +1396,7 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
if (sym_sec == NULL)
return bfd_reloc_undefined;
/* Get the value of __gp. */
h = bfd_link_hash_lookup (info->hash, "__gp", false, false, true);
if (h == (struct bfd_link_hash_entry *) NULL
@ -1426,12 +1421,12 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
{
unsigned long ep;
struct bfd_link_hash_entry * h;
/* Get the value of __ep. */
h = bfd_link_hash_lookup (info->hash, "__ep", false, false, true);
if (h == (struct bfd_link_hash_entry *) NULL
|| h->type != bfd_link_hash_defined)
return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
return bfd_reloc_continue; /* Actually this indicates that __ep could not be found. */
ep = (h->u.def.value
+ h->u.def.section->output_section->vma
@ -1440,17 +1435,17 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
value -= ep;
}
break;
case R_V850_CALLT_6_7_OFFSET:
{
unsigned long ctbp;
struct bfd_link_hash_entry * h;
/* Get the value of __ctbp. */
h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
if (h == (struct bfd_link_hash_entry *) NULL
|| h->type != bfd_link_hash_defined)
return (bfd_reloc_dangerous + 1); /* Actually this indicates that __ctbp could not be found. */
return (bfd_reloc_dangerous + 1); /* Actually this indicates that __ctbp could not be found. */
ctbp = (h->u.def.value
+ h->u.def.section->output_section->vma
@ -1458,7 +1453,7 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
value -= ctbp;
}
break;
case R_V850_CALLT_16_16_OFFSET:
{
unsigned long ctbp;
@ -1466,7 +1461,7 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
if (sym_sec == NULL)
return bfd_reloc_undefined;
/* Get the value of __ctbp. */
h = bfd_link_hash_lookup (info->hash, "__ctbp", false, false, true);
if (h == (struct bfd_link_hash_entry *) NULL
@ -1481,7 +1476,7 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
value -= (ctbp - sym_sec->output_section->vma);
}
break;
case R_V850_NONE:
case R_V850_GNU_VTINHERIT:
case R_V850_GNU_VTENTRY:
@ -1492,7 +1487,7 @@ v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
}
/* Perform the relocation. */
return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
}
@ -1524,12 +1519,12 @@ v850_elf_relocate_section (output_bfd, info, input_bfd, input_section,
return false;
}
/* Reset the list of remembered HI16S relocs to empty. */
free_hi16s = previous_hi16s;
previous_hi16s = NULL;
hi16s_counter = 0;
rel = relocs;
relend = relocs + input_section->reloc_count;
for (; rel < relend; rel++)
@ -1596,11 +1591,11 @@ fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n"
else
{
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
if (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
{
@ -1696,7 +1691,7 @@ fprintf (stderr, "unknown: name: %s\n", h->root.root.string);
case (bfd_reloc_dangerous + 1):
msg = _("could not locate special linker symbol __ctbp");
goto common_error;
default:
msg = _("internal error: unknown error");
/* fall through */
@ -1803,7 +1798,7 @@ v850_elf_final_write_processing (abfd, linker)
elf_elfheader (abfd)->e_flags |= val;
}
/* Function to keep V850 specific file flags. */
/* Function to keep V850 specific file flags. */
static boolean
v850_elf_set_private_flags (abfd, flags)
bfd * abfd;
@ -1864,7 +1859,7 @@ v850_elf_merge_private_bfd_data (ibfd, obfd)
to the default values. */
if (bfd_get_arch_info (ibfd)->the_default)
return true;
elf_flags_init (obfd) = true;
elf_elfheader (obfd)->e_flags = in_flags;
@ -1896,14 +1891,14 @@ v850_elf_print_private_bfd_data (abfd, ptr)
PTR ptr;
{
FILE * file = (FILE *) ptr;
BFD_ASSERT (abfd != NULL && ptr != NULL);
_bfd_elf_print_private_bfd_data (abfd, ptr);
/* xgettext:c-format */
fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
{
default:
@ -1911,9 +1906,9 @@ v850_elf_print_private_bfd_data (abfd, ptr)
case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break;
case E_V850EA_ARCH: fprintf (file, _("v850ea architecture")); break;
}
fputc ('\n', file);
return true;
}
@ -1934,7 +1929,6 @@ static asection v850_elf_zcom_section;
static asymbol v850_elf_zcom_symbol;
static asymbol * v850_elf_zcom_symbol_ptr;
/* Given a BFD section, try to locate the corresponding ELF section
index. */
@ -1953,7 +1947,7 @@ v850_elf_section_from_bfd_section (abfd, hdr, sec, retval)
*retval = SHN_V850_ZCOMMON;
else
return false;
return true;
}
@ -1966,34 +1960,34 @@ v850_elf_symbol_processing (abfd, asym)
{
elf_symbol_type * elfsym = (elf_symbol_type *) asym;
unsigned short index;
index = elfsym->internal_elf_sym.st_shndx;
/* If the section index is an "ordinary" index, then it may
refer to a v850 specific section created by the assembler.
Check the section's type and change the index it matches.
FIXME: Should we alter the st_shndx field as well ? */
if (index < elf_elfheader(abfd)[0].e_shnum)
switch (elf_elfsections(abfd)[index]->sh_type)
{
case SHT_V850_SCOMMON:
index = SHN_V850_SCOMMON;
break;
case SHT_V850_TCOMMON:
index = SHN_V850_TCOMMON;
break;
case SHT_V850_ZCOMMON:
index = SHN_V850_ZCOMMON;
break;
default:
break;
}
switch (index)
{
case SHN_V850_SCOMMON:
@ -2013,7 +2007,7 @@ v850_elf_symbol_processing (abfd, asym)
asym->section = & v850_elf_scom_section;
asym->value = elfsym->internal_elf_sym.st_size;
break;
case SHN_V850_TCOMMON:
if (v850_elf_tcom_section.name == NULL)
{
@ -2055,7 +2049,6 @@ v850_elf_symbol_processing (abfd, asym)
/* Hook called by the linker routine which adds symbols from an object
file. We must handle the special v850 section numbers here. */
/*ARGSUSED*/
static boolean
v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
bfd * abfd;
@ -2067,32 +2060,32 @@ v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
bfd_vma * valp;
{
int index = sym->st_shndx;
/* If the section index is an "ordinary" index, then it may
refer to a v850 specific section created by the assembler.
Check the section's type and change the index it matches.
FIXME: Should we alter the st_shndx field as well ? */
if (index < elf_elfheader(abfd)[0].e_shnum)
switch (elf_elfsections(abfd)[index]->sh_type)
{
case SHT_V850_SCOMMON:
index = SHN_V850_SCOMMON;
break;
case SHT_V850_TCOMMON:
index = SHN_V850_TCOMMON;
break;
case SHT_V850_ZCOMMON:
index = SHN_V850_ZCOMMON;
break;
default:
break;
}
switch (index)
{
case SHN_V850_SCOMMON:
@ -2100,13 +2093,13 @@ v850_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
(*secp)->flags |= SEC_IS_COMMON;
*valp = sym->st_size;
break;
case SHN_V850_TCOMMON:
*secp = bfd_make_section_old_way (abfd, ".tcommon");
(*secp)->flags |= SEC_IS_COMMON;
*valp = sym->st_size;
break;
case SHN_V850_ZCOMMON:
*secp = bfd_make_section_old_way (abfd, ".zcommon");
(*secp)->flags |= SEC_IS_COMMON;
@ -2129,7 +2122,7 @@ v850_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
/* If we see a common symbol, which implies a relocatable link, then
if a symbol was in a special common section in an input file, mark
it as a special common in the output file. */
if (sym->st_shndx == SHN_COMMON)
{
if (strcmp (input_sec->name, ".scommon") == 0)
@ -2193,18 +2186,17 @@ v850_elf_fake_sections (abfd, hdr, sec)
}
else if (strcmp (name, ".zcommon") == 0)
hdr->sh_type = SHT_V850_ZCOMMON;
return true;
}
#define TARGET_LITTLE_SYM bfd_elf32_v850_vec
#define TARGET_LITTLE_NAME "elf32-v850"
#define ELF_ARCH bfd_arch_v850
#define ELF_MACHINE_CODE EM_CYGNUS_V850
#define ELF_MAXPAGESIZE 0x1000
#define elf_info_to_howto v850_elf_info_to_howto_rela
#define elf_info_to_howto_rel v850_elf_info_to_howto_rel
@ -2223,7 +2215,6 @@ v850_elf_fake_sections (abfd, hdr, sec)
#define elf_backend_can_gc_sections 1
#define bfd_elf32_bfd_is_local_label_name v850_elf_is_local_label_name
#define bfd_elf32_bfd_reloc_type_lookup v850_elf_reloc_type_lookup
#define bfd_elf32_bfd_copy_private_bfd_data v850_elf_copy_private_bfd_data

59
bfd/elf64-sparc.c
View File

@ -240,7 +240,7 @@ sparc64_elf_info_to_howto (abfd, cache_ptr, dst)
/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
section can represent up to two relocs, we must tell the user to allocate
more space. */
static long
sparc64_elf_get_reloc_upper_bound (abfd, sec)
bfd *abfd ATTRIBUTE_UNUSED;
@ -256,7 +256,7 @@ sparc64_elf_get_dynamic_reloc_upper_bound (abfd)
return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
}
/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
them. We cannot use generic elf routines for this, because R_SPARC_OLO10
has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
for the same location, R_SPARC_LO10 and R_SPARC_13. */
@ -292,7 +292,7 @@ sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic)
entsize = rel_hdr->sh_entsize;
BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
count = rel_hdr->sh_size / entsize;
for (i = 0, relent = relents; i < count;
@ -398,20 +398,20 @@ sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
rel_hdr2 = NULL;
}
asect->relocation = ((arelent *)
bfd_alloc (abfd,
asect->relocation = ((arelent *)
bfd_alloc (abfd,
asect->reloc_count * 2 * sizeof (arelent)));
if (asect->relocation == NULL)
return false;
/* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */
asect->reloc_count = 0;
if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
dynamic))
return false;
if (rel_hdr2
if (rel_hdr2
&& !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
dynamic))
return false;
@ -534,7 +534,7 @@ sparc64_elf_write_relocs (abfd, sec, data)
if (rela_hdr->sh_type != SHT_RELA)
abort ();
/* orelocation has the data, reloc_count has the count... */
/* orelocation has the data, reloc_count has the count... */
outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
src_rela = outbound_relocas;
@ -628,7 +628,7 @@ struct sparc64_elf_link_hash_table
#define sparc64_elf_hash_table(p) \
((struct sparc64_elf_link_hash_table *) ((p)->hash))
/* Create a Sparc64 ELF linker hash table. */
static struct bfd_link_hash_table *
@ -848,7 +848,6 @@ sparc_elf_lox10_reloc (abfd,
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
/* Fill in the .plt section. */
static void
@ -859,7 +858,7 @@ sparc64_elf_build_plt (output_bfd, contents, nentries)
{
const unsigned int nop = 0x01000000;
int i, j;
/* The first four entries are reserved, and are initially undefined.
We fill them with `illtrap 0' to force ld.so to do something. */
@ -893,7 +892,7 @@ sparc64_elf_build_plt (output_bfd, contents, nentries)
/* Now the tricky bit. Entries 32768 and higher are grouped in blocks of
160: 160 entries and 160 pointers. This is to separate code from data,
which is much friendlier on the cache. */
for (; i < nentries; i += 160)
{
int block = (i + 160 <= nentries ? 160 : nentries - i);
@ -936,7 +935,7 @@ sparc64_elf_plt_entry_offset (index)
block = (index - LARGE_PLT_THRESHOLD) / 160;
ofs = (index - LARGE_PLT_THRESHOLD) % 160;
return ((bfd_vma)(LARGE_PLT_THRESHOLD + block*160) * PLT_ENTRY_SIZE
return ((bfd_vma) (LARGE_PLT_THRESHOLD + block*160) * PLT_ENTRY_SIZE
+ ofs * 6*4);
}
@ -963,7 +962,6 @@ sparc64_elf_plt_ptr_offset (index, max)
+ ofs * 8);
}
/* Look through the relocs for a section during the first phase, and
allocate space in the global offset table or procedure linkage
@ -1198,7 +1196,7 @@ sparc64_elf_check_relocs (abfd, info, sec, relocs)
case R_SPARC_UA16:
/* When creating a shared object, we must copy these relocs
into the output file. We create a reloc section in
dynobj and make room for the reloc.
dynobj and make room for the reloc.
But don't do this for debugging sections -- this shows up
with DWARF2 -- first because they are not loaded, and
@ -1247,7 +1245,7 @@ sparc64_elf_check_relocs (abfd, info, sec, relocs)
break;
default:
(*_bfd_error_handler)(_("%s: check_relocs: unhandled reloc type %d"),
(*_bfd_error_handler) (_("%s: check_relocs: unhandled reloc type %d"),
bfd_get_filename(abfd),
ELF64_R_TYPE_ID (rel->r_info));
return false;
@ -1276,7 +1274,7 @@ sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
{
int reg;
struct sparc64_elf_app_reg *p;
reg = (int)sym->st_value;
switch (reg & ~1)
{
@ -1317,7 +1315,7 @@ sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
if (**namep)
{
struct elf_link_hash_entry *h;
h = (struct elf_link_hash_entry *)
bfd_link_hash_lookup (info->hash, *namep, false, false, false);
@ -1809,7 +1807,7 @@ sparc64_elf_size_dynamic_sections (output_bfd, info)
if (app_regs [reg].name != NULL)
{
struct elf_link_local_dynamic_entry *entry, *e;
if (! bfd_elf64_add_dynamic_entry (info, DT_SPARC_REGISTER, 0))
return false;
@ -1854,7 +1852,6 @@ sparc64_elf_size_dynamic_sections (output_bfd, info)
#define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
#define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
/*ARGSUSED*/
static boolean
sparc64_elf_relax_section (abfd, section, link_info, again)
bfd *abfd ATTRIBUTE_UNUSED;
@ -2371,7 +2368,7 @@ sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
32-bit linker, which both adds the contents
and ignores the addend. So clear the location. */
bfd_put_64 (output_bfd, 0, sgot->contents + off);
/* We need to generate a R_SPARC_RELATIVE reloc
for the dynamic linker. */
srelgot = bfd_get_section_by_name(dynobj, ".rela.got");
@ -2620,12 +2617,12 @@ sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
{
/* Assume this is a call protected by other code that
detect the symbol is undefined. If this is the case,
we can safely ignore the overflow. If not, the
we can safely ignore the overflow. If not, the
program is hosed anyway, and a little warning isn't
going to help. */
break;
}
name = h->root.root.string;
}
else
@ -2671,7 +2668,7 @@ sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
asection *srela;
Elf_Internal_Rela rela;
/* This symbol has an entry in the PLT. Set it up. */
/* This symbol has an entry in the PLT. Set it up. */
BFD_ASSERT (h->dynindx != -1);
@ -2896,7 +2893,7 @@ sparc64_elf_finish_dynamic_sections (output_bfd, info)
return true;
}
/* Functions for dealing with the e_flags field. */
/* Functions for dealing with the e_flags field. */
/* Merge backend specific data from an object file to the output
object file when linking. */
@ -2922,10 +2919,10 @@ sparc64_elf_merge_private_bfd_data (ibfd, obfd)
elf_flags_init (obfd) = true;
elf_elfheader (obfd)->e_flags = new_flags;
}
else if (new_flags == old_flags) /* Compatible flags are ok */
;
else /* Incompatible flags */
{
error = false;
@ -2996,7 +2993,7 @@ sparc64_elf_print_symbol_all (abfd, filep, symbol)
{
FILE *file = (FILE *) filep;
int reg, type;
if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
!= STT_REGISTER)
return NULL;
@ -3048,7 +3045,7 @@ const struct elf_size_info sparc64_elf_size_info =
/* internal relocations per external relocations.
For link purposes we use just 1 internal per
1 external, for assembly and slurp symbol table
we use 2. */
we use 2. */
1,
64, /* arch_size */
8, /* file_align */
@ -3081,7 +3078,7 @@ const struct elf_size_info sparc64_elf_size_info =
#define bfd_elf64_bfd_link_hash_table_create \
sparc64_elf_bfd_link_hash_table_create
#define elf_info_to_howto \
sparc64_elf_info_to_howto
#define bfd_elf64_get_reloc_upper_bound \