OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

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",

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.