URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/gnu-src/gdb-7.2
- from Rev 399 to Rev 404
- ↔ Reverse comparison
Rev 399 → Rev 404
/sim/or32/Makefile.in
33,3 → 33,4
|
## COMMON_POST_CONFIG_FRAG |
|
wrapper.o: targ-vals.h |
/sim/or32/ChangeLog
1,3 → 1,7
2010-11-02 Joern Rennecke <joern.rennecke@embecosm.com> |
|
* Makefile.in (wrapper.o): Depend on targ-vals.h . |
|
2010-09-20 Jeremy Bennett <jeremy.bennett@embecosm.com> |
|
* wrapper.c (sim_read, sim_write). Corrected pointer print format. |
/bfd/elf32-or32.c
1,6 → 1,10
/* OR32-specific support for 32-bit ELF |
Copyright 2002, 2004, 2005, 2007 Free Software Foundation, Inc. |
Copyright (C) 2010 Embecosm Limited |
Contributed by Ivan Guzvinec <ivang@opencores.org> |
Modified by Gyorgy Jeney <nog@sdf.lonestar.org> and |
Balint Cristian <rezso@rdsor.ro> |
Changed from Rel to Rela by Joern Rennecke <joern.rennecke@embecosm.com>. |
|
This file is part of BFD, the Binary File Descriptor library. |
|
24,11 → 28,16
#include "libbfd.h" |
#include "elf-bfd.h" |
#include "elf/or32.h" |
#include "elf/common.h" |
#include "libiberty.h" |
|
/* We need RELA in order to handle highpart relocations independent of |
the presence and/or location and/or value of a lowpart relocation. */ |
#if 0 |
/* Try to minimize the amount of space occupied by relocation tables |
on the ROM (not that the ROM won't be swamped by other ELF overhead). */ |
#define USE_REL 1 |
#endif |
|
/* Set the right machine number for an OR32 ELF file. */ |
|
46,11 → 55,19
or32_elf_final_write_processing (bfd *abfd, |
bfd_boolean linker ATTRIBUTE_UNUSED) |
{ |
/* Pad the output file so that the aligned reloc section addresses aren't |
* outside the file */ |
unsigned long zero = 0; |
if (bfd_seek (abfd, elf_tdata (abfd)->next_file_pos, SEEK_SET) != 0 |
|| bfd_bwrite (&zero, sizeof(zero), abfd) != sizeof(zero)) |
(*_bfd_error_handler) (_("%B: failed to ensure that reloc sections aren't outside file"), abfd); |
|
elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH; |
} |
|
#if 0 /* Not needed for RELA. */ |
static bfd_reloc_status_type |
or32_elf_32_reloc (bfd *abfd, |
or32_elf_generic_reloc (bfd *abfd, |
arelent *reloc_entry, |
asymbol *symbol, |
void * data, |
58,81 → 75,64
bfd *output_bfd, |
char **error_message ATTRIBUTE_UNUSED) |
{ |
if (output_bfd != NULL) |
{ |
unsigned long insn; |
bfd_size_type addr = reloc_entry->address; |
bfd_signed_vma val; |
bfd_reloc_status_type status; |
bfd_boolean relocatable; |
|
reloc_entry->address += input_section->output_offset; |
if (bfd_is_und_section (symbol->section) /*RGD fix linker undefined miss*/ |
&& output_bfd == (bfd *) NULL) |
return bfd_reloc_undefined; |
|
insn = bfd_get_32 (abfd, (bfd_byte *) data + addr); |
insn += symbol->section->output_section->vma; |
insn += symbol->section->output_offset; |
insn += symbol->value; |
bfd_put_32 (abfd, insn, (bfd_byte *) data + addr); |
relocatable = (output_bfd != NULL); |
|
return bfd_reloc_ok; |
} |
if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
return bfd_reloc_outofrange; |
|
return bfd_reloc_continue; |
} |
/* Build up the field adjustment in VAL. */ |
val = 0; |
if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0) |
{ |
/* Either we're calculating the final field value or we have a |
relocation against a section symbol. Add in the section's |
offset or address. */ |
val += symbol->section->output_section->vma; |
val += symbol->section->output_offset; |
} |
|
if (!relocatable) |
{ |
/* We're calculating the final field value. Add in the symbol's value |
and, if pc-relative, subtract the address of the field itself. */ |
val += symbol->value; |
if (reloc_entry->howto->pc_relative) |
val -= input_section->output_section->vma; |
} |
|
static bfd_reloc_status_type |
or32_elf_16_reloc (bfd *abfd, |
arelent *reloc_entry, |
asymbol *symbol, |
void * data, |
asection *input_section, |
bfd *output_bfd, |
char **error_message ATTRIBUTE_UNUSED) |
{ |
if (output_bfd != NULL) |
{ |
unsigned short insn; |
bfd_size_type addr = reloc_entry->address; |
if (reloc_entry->howto->pc_relative) |
val -= input_section->output_offset; |
/* VAL is now the final adjustment. If we're keeping this relocation |
in the output file, and if the relocation uses a separate addend, |
we just need to add VAL to that addend. Otherwise we need to add |
VAL to the relocation field itself. */ |
if (relocatable && !reloc_entry->howto->partial_inplace) |
reloc_entry->addend += val; |
else |
{ |
/* Add in the separate addend, if any. */ |
val += reloc_entry->addend; |
/* Add VAL to the relocation field. */ |
status = _bfd_relocate_contents (reloc_entry->howto, abfd, val, |
(bfd_byte *) data |
+ reloc_entry->address); |
if (status != bfd_reloc_ok) |
return status; |
} |
if (relocatable) |
reloc_entry->address += input_section->output_offset; |
|
reloc_entry->address += input_section->output_offset; |
|
insn = bfd_get_16 (abfd, (bfd_byte *) data + addr); |
insn += symbol->section->output_section->vma; |
insn += symbol->section->output_offset; |
insn += symbol->value; |
bfd_put_16 (abfd, insn, (bfd_byte *) data + addr); |
|
return bfd_reloc_ok; |
} |
|
return bfd_reloc_continue; |
return bfd_reloc_ok; |
} |
|
static bfd_reloc_status_type |
or32_elf_8_reloc (bfd *abfd ATTRIBUTE_UNUSED, |
arelent *reloc_entry, |
asymbol *symbol, |
void * data, |
asection *input_section, |
bfd *output_bfd, |
char **error_message ATTRIBUTE_UNUSED) |
{ |
if (output_bfd != NULL) |
{ |
unsigned char insn; |
bfd_size_type addr = reloc_entry->address; |
|
reloc_entry->address += input_section->output_offset; |
|
insn = bfd_get_8 (abfd, (bfd_byte *) data + addr); |
insn += symbol->section->output_section->vma; |
insn += symbol->section->output_offset; |
insn += symbol->value; |
bfd_put_8 (abfd, insn, (bfd_byte *) data + addr); |
|
return bfd_reloc_ok; |
} |
|
return bfd_reloc_continue; |
} |
|
/* Do a R_OR32_CONSTH relocation. This has to be done in combination |
with a R_OR32_CONST reloc, because there is a carry from the LO16 to |
the HI16. Here we just save the information we need; we do the |
145,8 → 145,9
struct or32_consth |
{ |
struct or32_consth *next; |
bfd_byte *addr; |
bfd_vma addend; |
bfd_byte *data; |
asection *input_section; |
arelent rel; |
}; |
|
/* FIXME: This should not be a static variable. */ |
156,31 → 157,14
static bfd_reloc_status_type |
or32_elf_consth_reloc (bfd *abfd ATTRIBUTE_UNUSED, |
arelent *reloc_entry, |
asymbol *symbol, |
asymbol *symbol ATTRIBUTE_UNUSED, |
void * data, |
asection *input_section, |
bfd *output_bfd, |
char **error_message ATTRIBUTE_UNUSED) |
{ |
bfd_reloc_status_type ret; |
bfd_vma relocation; |
struct or32_consth *n; |
|
ret = bfd_reloc_ok; |
|
if (bfd_is_und_section (symbol->section) |
&& output_bfd == NULL) |
ret = bfd_reloc_undefined; |
|
if (bfd_is_com_section (symbol->section)) |
relocation = 0; |
else |
relocation = symbol->value; |
|
relocation += symbol->section->output_section->vma; |
relocation += symbol->section->output_offset; |
relocation += reloc_entry->addend; |
|
if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
return bfd_reloc_outofrange; |
|
188,15 → 172,18
n = bfd_malloc (sizeof *n); |
if (n == NULL) |
return bfd_reloc_outofrange; |
n->addr = (bfd_byte *) data + reloc_entry->address; |
n->addend = relocation; |
|
/* Push this reloc on the list of pending relocations */ |
n->next = or32_consth_list; |
n->data = data; |
n->input_section = input_section; |
n->rel = *reloc_entry; |
or32_consth_list = n; |
|
if (output_bfd != NULL) |
reloc_entry->address += input_section->output_offset; |
|
return ret; |
return bfd_reloc_ok; |
} |
|
/* Do a R_OR32_CONST relocation. This is a straightforward 16 bit |
212,89 → 199,37
bfd *output_bfd, |
char **error_message) |
{ |
if (or32_consth_list != NULL) |
{ |
struct or32_consth *l; |
bfd_vma vallo; |
if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
return bfd_reloc_outofrange; |
vallo = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address) & 0xffff; |
while (or32_consth_list != NULL) |
{ |
bfd_reloc_status_type ret; |
struct or32_consth *hi; |
|
l = or32_consth_list; |
while (l != NULL) |
{ |
unsigned long insn; |
unsigned long val; |
unsigned long vallo; |
struct or32_consth *next; |
hi = or32_consth_list; |
|
/* Do the HI16 relocation. Note that we actually don't need |
to know anything about the LO16 itself, except where to |
find the low 16 bits of the addend needed by the LO16. */ |
insn = bfd_get_32 (abfd, l->addr); |
vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address) |
& 0xffff); |
val = ((insn & 0xffff) << 16) + vallo; |
val += l->addend; |
/* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any |
carry or borrow will induce a change of +1 or -1 in the high part. */ |
hi->rel.addend += vallo; |
|
insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff); |
bfd_put_32 (abfd, insn, l->addr); |
ret = or32_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data, |
hi->input_section, output_bfd, |
error_message); |
if (ret != bfd_reloc_ok) |
return ret; |
|
next = l->next; |
free (l); |
l = next; |
} |
|
or32_consth_list = NULL; |
} |
|
if (output_bfd != NULL) |
{ |
unsigned long insn, tmp; |
bfd_size_type addr = reloc_entry->address; |
|
reloc_entry->address += input_section->output_offset; |
|
insn = bfd_get_32 (abfd, (bfd_byte *) data + addr); |
tmp = insn & 0x0000ffff; |
tmp += symbol->section->output_section->vma; |
tmp += symbol->section->output_offset; |
tmp += symbol->value; |
insn = (insn & 0xffff0000) | (tmp & 0x0000ffff); |
bfd_put_32 (abfd, insn, (bfd_byte *) data + addr); |
|
return bfd_reloc_ok; |
} |
|
/* Now do the LO16 reloc in the usual way. */ |
return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, |
input_section, output_bfd, error_message); |
or32_consth_list = hi->next; |
free (hi); |
} |
return or32_elf_generic_reloc (abfd, reloc_entry, symbol, data, |
input_section, output_bfd, |
error_message); |
} |
#endif |
|
static bfd_reloc_status_type |
or32_elf_jumptarg_reloc (bfd *abfd, |
arelent *reloc_entry, |
asymbol *symbol ATTRIBUTE_UNUSED, |
void * data, |
asection *input_section, |
bfd *output_bfd, |
char **error_message ATTRIBUTE_UNUSED) |
{ |
if (output_bfd != NULL) |
{ |
unsigned long insn, tmp; |
bfd_size_type addr = reloc_entry->address; |
|
reloc_entry->address += input_section->output_offset; |
|
insn = bfd_get_32 (abfd, (bfd_byte *) data + addr); |
tmp = insn | 0xfc000000; |
tmp -= (input_section->output_offset >> 2); |
insn = (insn & 0xfc000000) | (tmp & 0x03ffffff); |
bfd_put_32 (abfd, insn, (bfd_byte *) data + addr); |
|
return bfd_reloc_ok; |
} |
|
return bfd_reloc_continue; |
} |
|
static reloc_howto_type elf_or32_howto_table[] = |
{ |
/* This reloc does nothing. */ |
320,10 → 255,10
FALSE, /* pc_relative */ |
0, /* bitpos */ |
complain_overflow_bitfield, /* complain_on_overflow */ |
or32_elf_32_reloc, /* special_function */ |
bfd_elf_generic_reloc, /* special_function */ |
"R_OR32_32", /* name */ |
FALSE, /* partial_inplace */ |
0xffffffff, /* src_mask */ |
FALSE, /* partial_inplace */ |
0, /* src_mask */ |
0xffffffff, /* dst_mask */ |
FALSE), /* pcrel_offset */ |
|
335,10 → 270,10
FALSE, /* pc_relative */ |
0, /* bitpos */ |
complain_overflow_bitfield, /* complain_on_overflow */ |
or32_elf_16_reloc, /* special_function */ |
bfd_elf_generic_reloc, /* special_function */ |
"R_OR32_16", /* name */ |
FALSE, /* partial_inplace */ |
0x0000ffff, /* src_mask */ |
FALSE, /* partial_inplace */ |
0, /* src_mask */ |
0x0000ffff, /* dst_mask */ |
FALSE), /* pcrel_offset */ |
|
350,10 → 285,10
FALSE, /* pc_relative */ |
0, /* bitpos */ |
complain_overflow_bitfield, /* complain_on_overflow */ |
or32_elf_8_reloc, /* special_function */ |
bfd_elf_generic_reloc, /* special_function */ |
"R_OR32_8", /* name */ |
FALSE, /* partial_inplace */ |
0x000000ff, /* src_mask */ |
FALSE, /* partial_inplace */ |
0, /* src_mask */ |
0x000000ff, /* dst_mask */ |
FALSE), /* pcrel_offset */ |
|
365,10 → 300,10
FALSE, /* pc_relative */ |
0, /* bitpos */ |
complain_overflow_dont, /* complain_on_overflow */ |
or32_elf_const_reloc, /* special_function */ |
bfd_elf_generic_reloc, /* special_function */ |
"R_OR32_CONST", /* name */ |
FALSE, /* partial_inplace */ |
0x0000ffff, /* src_mask */ |
0, /* src_mask */ |
0x0000ffff, /* dst_mask */ |
FALSE), /* pcrel_offset */ |
|
377,13 → 312,13
16, /* rightshift */ |
2, /* size (0 = byte, 1 = short, 2 = long) */ |
16, /* bitsize */ |
TRUE, /* pc_relative */ |
FALSE, /* pc_relative */ |
0, /* bitpos */ |
complain_overflow_dont, /* complain_on_overflow */ |
or32_elf_consth_reloc, /* special_function */ |
bfd_elf_generic_reloc, /* special_function */ |
"R_OR32_CONSTH", /* name */ |
FALSE, /* partial_inplace */ |
0xffff0000, /* src_mask */ |
0, /* src_mask */ |
0x0000ffff, /* dst_mask */ |
FALSE), /* pcrel_offset */ |
|
394,13 → 329,13
28, /* bitsize */ |
TRUE, /* pc_relative */ |
0, /* bitpos */ |
complain_overflow_signed, /* complain_on_overflow */ |
or32_elf_jumptarg_reloc,/* special_function */ |
complain_overflow_dont, /* complain_on_overflow */ |
bfd_elf_generic_reloc, /* special_function */ |
"R_OR32_JUMPTARG", /* name */ |
FALSE, /* partial_inplace */ |
0, /* src_mask */ |
0x03ffffff, /* dst_mask */ |
TRUE), /* pcrel_offset */ |
FALSE), /* pcrel_offset */ |
|
/* GNU extension to record C++ vtable hierarchy. */ |
HOWTO (R_OR32_GNU_VTINHERIT, /* type */ |
433,6 → 368,104
FALSE), /* pcrel_offset */ |
}; |
|
static bfd_boolean |
or32_relocate_section (bfd * output_bfd, |
struct bfd_link_info *info, |
bfd * input_bfd, |
asection * input_section, |
bfd_byte * contents, |
Elf_Internal_Rela * relocs, |
Elf_Internal_Sym * local_syms, |
asection ** local_sections) |
{ |
Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; |
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); |
Elf_Internal_Rela *rel= rel = relocs; |
Elf_Internal_Rela *relend = relocs + input_section->reloc_count; |
|
for (; rel < relend; rel++) |
{ |
int r_type = ELF32_R_TYPE (rel->r_info); |
reloc_howto_type *howto; |
unsigned long r_symndx; |
struct elf_link_hash_entry *h = NULL; |
Elf_Internal_Sym *sym = NULL; |
asection *sec = NULL; |
bfd_vma relocation = 0; |
bfd_reloc_status_type r; |
const char *name = NULL; |
|
if ((unsigned) r_type >= ARRAY_SIZE (elf_or32_howto_table)) |
{ |
bfd_set_error (bfd_error_bad_value); |
return FALSE; |
} |
|
if (r_type == R_OR32_GNU_VTENTRY |
|| r_type == R_OR32_GNU_VTINHERIT) |
continue; |
|
howto = &elf_or32_howto_table[r_type]; |
r_symndx = ELF32_R_SYM (rel->r_info); |
|
if (r_symndx < symtab_hdr->sh_info) |
{ |
sym = local_syms + r_symndx; |
sec = local_sections[r_symndx]; |
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); |
|
name = bfd_elf_string_from_elf_section |
(input_bfd, symtab_hdr->sh_link, sym->st_name); |
name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; |
} |
else |
{ |
bfd_boolean unresolved_reloc, warned; |
|
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, |
r_symndx, symtab_hdr, sym_hashes, |
h, sec, relocation, |
unresolved_reloc, warned); |
} |
|
if (sec != NULL && elf_discarded_section (sec)) |
{ |
/* For relocs against symbols from removed linkonce sections, |
or sections discarded by a linker script, we just want the |
section contents zeroed. Avoid any special processing. */ |
_bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); |
rel->r_info = 0; |
rel->r_addend = 0; |
continue; |
} |
|
if (info->relocatable) |
continue; |
|
r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents, |
rel->r_offset, relocation, rel->r_addend); |
if (r != bfd_reloc_ok) |
{ |
const char *msg = NULL; |
|
switch (r) |
{ |
/* FIXME: give useful messages for possible errors. */ |
default: |
msg = _("internal error: unknown error"); |
break; |
} |
if (msg) |
r = info->callbacks->warning |
(info, msg, name, input_bfd, input_section, rel->r_offset); |
|
if (!r) |
return FALSE; |
} |
} |
return TRUE; |
} |
|
/* Map BFD reloc types to OR32 ELF reloc types. */ |
|
struct or32_reloc_map |
449,7 → 482,7
{ BFD_RELOC_8, R_OR32_8 }, |
{ BFD_RELOC_LO16, R_OR32_CONST }, |
{ BFD_RELOC_HI16, R_OR32_CONSTH }, |
{ BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG }, |
{ BFD_RELOC_28_PCREL_S2, R_OR32_JUMPTARG }, |
{ BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT }, |
{ BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY }, |
}; |
495,6 → 528,10
r_type = ELF32_R_TYPE (dst->r_info); |
BFD_ASSERT (r_type < (unsigned int) R_OR32_max); |
cache_ptr->howto = &elf_or32_howto_table[r_type]; |
|
asymbol *s = *(cache_ptr->sym_ptr_ptr); |
if (ELF32_R_SYM(dst->r_info) && (s->flags & BSF_SECTION_SYM)) |
cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr; |
} |
|
#define TARGET_LITTLE_SYM bfd_elf32_or32_little_vec |
502,8 → 539,9
#define TARGET_BIG_SYM bfd_elf32_or32_big_vec |
#define TARGET_BIG_NAME "elf32-or32" |
#define ELF_ARCH bfd_arch_or32 |
#define ELF_MACHINE_CODE EM_OR32 |
#define ELF_MAXPAGESIZE 0x1000 |
#define ELF_MACHINE_CODE EM_OPENRISC |
#define ELF_MACHINE_ALT1 EM_OR32 |
#define ELF_MAXPAGESIZE 0x2000 |
|
#define elf_info_to_howto 0 |
#define elf_info_to_howto_rel or32_info_to_howto_rel |
510,5 → 548,7
#define elf_backend_object_p or32_elf_object_p |
#define elf_backend_final_write_processing \ |
or32_elf_final_write_processing |
#define elf_backend_rela_normal 1 |
#define elf_backend_relocate_section or32_relocate_section |
|
#include "elf32-target.h" |
/bfd/config.bfd
1057,7 → 1057,7
targ_underscore=yes |
;; |
|
or32-*-elf) |
or32-*-elf| or32-*-*linux* | or32-*-rtems) |
targ_defvec=bfd_elf32_or32_big_vec |
;; |
|
/bfd/ChangeLog.or32
0,0 → 1,18
2010-11-02 Jeremy Bennett <jeremy.bennett@embecosm.com> |
|
* reloc.c: Add BFD_RELOC_28_PCREL_S2. |
* config.bfd: Also match or32-*-*linux* and or32-*-rtems. |
|
2010-10-29 Joern Rennecke <joern.rennecke@embecosm.com> |
|
* elf32-or32.c: Add Embecosm Copyright notice. |
|
2010-10-28 Joern Rennecke <joern.rennecke@embecosm.com> |
|
* elf32-or32.c (USE_REL): Don't define. |
(or32_elf_generic_reloc, struct or32_consth): Enclose in #if 0. |
(or32_elf_consth_reloc, or32_elf_const_reloc): Likewise. |
(elf_or32_howto_table): Change entries to reflect switch to RELA. |
|
* elf32-or32.c (or32_relocate_section): New function. |
(elf_backend_rela_normal, elf_backend_relocate_section): Define. |
/bfd/bfd-in2.h
2451,6 → 2451,7
BFD_RELOC_32_PCREL_S2, |
BFD_RELOC_16_PCREL_S2, |
BFD_RELOC_23_PCREL_S2, |
BFD_RELOC_28_PCREL_S2, |
|
/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of |
the target word. These are used on the SPARC. */ |
/bfd/reloc.c
1794,6 → 1794,8
BFD_RELOC_16_PCREL_S2 |
ENUMX |
BFD_RELOC_23_PCREL_S2 |
ENUMX |
BFD_RELOC_28_PCREL_S2 |
ENUMDOC |
These PC-relative relocations are stored as word displacements -- |
i.e., byte displacements shifted right two bits. The 30-bit word |
/bfd/libbfd.h
931,6 → 931,7
"BFD_RELOC_32_PCREL_S2", |
"BFD_RELOC_16_PCREL_S2", |
"BFD_RELOC_23_PCREL_S2", |
"BFD_RELOC_28_PCREL_S2", |
"BFD_RELOC_HI22", |
"BFD_RELOC_LO10", |
"BFD_RELOC_GPREL16", |