|
Message
From: Scott Furman <sfurman@r...>
Date: Wed, 12 Nov 2003 21:55:56 -0800
Subject: Re: [openrisc] gdb stub instead of JTAG?
Title:
Scott Furman wrote:
mid3FB1CE18.2060006@r...">
I have a bunch of linker fixes which cure the problems with linking
with the -r flag. I don't think they would fix problems of the sort you
describe, but it's worth a try. I'll submit my patches tomorrow.
Attached are my linker fixes. I have a fair degree of confidence in
this patch since the code has been in daily use at my company for
several months. Nonetheless, I would appreciate it if someone could
apply these changes to their linker and try to build uClinux and report
any problems. Once I get the green light, I'll check in.
-Scott
? bfd/elf32-or32.c.save
? bfd/reloc.c.noisy
? bfd/tmp
? ld/emultempl/or32elf.em
Index: bfd/elf32-or32.c
===================================================================
RCS file: /home/oc/cvs/or1k/binutils/bfd/elf32-or32.c,v
retrieving revision 1.10
diff -c -r1.10 elf32-or32.c
*** bfd/elf32-or32.c 19 May 2002 16:14:03 -0000 1.10
--- bfd/elf32-or32.c 13 Nov 2003 05:41:45 -0000
***************
*** 231,236 ****
--- 231,295 ----
cache_ptr->howto = &elf_or32_howto_table[r_type];
}
+ /* 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
+ or32_elf_check_relocs (abfd, info, sec, relocs)
+ bfd *abfd;
+ struct bfd_link_info *info;
+ asection *sec;
+ const Elf_Internal_Rela *relocs;
+ {
+ Elf_Internal_Shdr *symtab_hdr;
+ struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
+ const Elf_Internal_Rela *rel;
+ const Elf_Internal_Rela *rel_end;
+
+ 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);
+ if (!elf_bad_symtab (abfd))
+ sym_hashes_end -= symtab_hdr->sh_info;
+
+ rel_end = relocs + sec->reloc_count;
+ for (rel = relocs; rel < rel_end; rel++)
+ {
+ 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;
+ else
+ h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+
+ switch (ELF32_R_TYPE (rel->r_info))
+ {
+ /* This relocation describes the C++ object vtable hierarchy.
+ Reconstruct it for later use during GC. */
+ case R_OR32_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_OR32_GNU_VTENTRY:
+ if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ return false;
+ break;
+ }
+ }
+
+ return true;
+ }
+
/* Set the right machine number for an OR32 ELF file. */
static boolean
***************
*** 268,273 ****
--- 327,557 ----
elf_elfheader (abfd)->e_flags |= val;
}
+ /* Perform a single relocation. By default we use the standard BFD
+ routines, but a few relocs, we have to do them ourselves. */
+ /*
+ static bfd_reloc_status_type
+ or32_final_link_relocate (howto, input_bfd, input_section, contents, rel,
+ relocation)
+ reloc_howto_type *howto;
+ bfd *input_bfd;
+ asection *input_section;
+ bfd_byte *contents;
+ Elf_Internal_Rela *rel;
+ bfd_vma relocation;
+ {
+ bfd_reloc_status_type r = bfd_reloc_ok;
+
+ switch (howto->type)
+ {
+ case R_OR32_LO_16_IN_INSN:
+ relocation &= 0xffff;
+ r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+ contents, rel->r_offset,
+ relocation, rel->r_addend);
+ break;
+
+ default:
+ r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+ contents, rel->r_offset,
+ relocation, rel->r_addend);
+ }
+
+ return r;
+ }
+ */
+ /* Relocate an OpenRISC ELF section.
+ There is some attempt to make this function usable for many architectures,
+ both USE_REL and USE_RELA ['twould be nice if such a critter existed],
+ if only to serve as a learning tool.
+
+ The RELOCATE_SECTION function is called by the new ELF backend linker
+ to handle the relocations for a section.
+
+ The relocs are always passed as Rela structures; if the section
+ actually uses Rel structures, the r_addend field will always be
+ zero.
+
+ This function is responsible for adjusting the section contents as
+ necessary, and (if using Rela relocs and generating a relocateable
+ output file) adjusting the reloc addend as necessary.
+
+ This function does not have to worry about setting the reloc
+ address or the reloc symbol index.
+
+ LOCAL_SYMS is a pointer to the swapped in local symbols.
+
+ LOCAL_SECTIONS is an array giving the section in the input file
+ corresponding to the st_shndx field of each local symbol.
+
+ The global hash table entry for the global symbols can be found
+ via elf_sym_hashes (input_bfd).
+
+ When generating relocateable output, this function must handle
+ STB_LOCAL/STT_SECTION symbols specially. The output symbol is
+ going to be the section symbol corresponding to the output
+ section, which means that the addend must be adjusted
+ accordingly. */
+
+ /* static boolean */
+ /* or32_elf_relocate_section (output_bfd, info, input_bfd, input_section, */
+ /* contents, relocs, local_syms, local_sections) */
+ /* 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; */
+ /* struct elf_link_hash_entry **sym_hashes; */
+ /* Elf_Internal_Rela *rel; */
+ /* Elf_Internal_Rela *relend; */
+
+ /* symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; */
+ /* sym_hashes = elf_sym_hashes (input_bfd); */
+ /* relend = relocs + input_section->reloc_count; */
+
+ /* for (rel = relocs; rel < relend; rel++) */
+ /* { */
+ /* reloc_howto_type *howto; */
+ /* unsigned long r_symndx; */
+ /* Elf_Internal_Sym *sym; */
+ /* asection *sec; */
+ /* struct elf_link_hash_entry *h; */
+ /* bfd_vma relocation; */
+ /* bfd_reloc_status_type r; */
+ /* const char *name = NULL; */
+ /* int r_type; */
+
+ /* r_type = ELF32_R_TYPE (rel->r_info); */
+ /* r_symndx = ELF32_R_SYM (rel->r_info); */
+
+ /* if (r_type == R_OR32_GNU_VTINHERIT */
+ /* || r_type == R_OR32_GNU_VTENTRY) */
+ /* continue; */
+
+ /* if (info->relocateable) */
+ /* { */
+ /* /\* This is a relocateable link. We don't have to change */
+ /* anything, unless the reloc is against a section symbol, */
+ /* in which case we have to adjust according to where the */
+ /* section symbol winds up in the output section. *\/ */
+ /* if (r_symndx < symtab_hdr->sh_info) */
+ /* { */
+ /* sym = local_syms + r_symndx; */
+
+ /* if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) */
+ /* { */
+ /* sec = local_sections[r_symndx]; */
+ /* rel->r_addend += sec->output_offset + sym->st_value; */
+ /* } */
+ /* } */
+ /* continue; */
+ /* } */
+
+ /* if ((unsigned int) r_type > */
+ /* (sizeof or32_elf_howto_table / sizeof (reloc_howto_type))) */
+ /* abort (); */
+
+ /* /\* This is a final link. *\/ */
+ /* howto = or32_elf_howto_table + ELF32_R_TYPE (rel->r_info); */
+ /* h = NULL; */
+ /* sym = NULL; */
+ /* sec = NULL; */
+
+ /* 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 */
+ /* { */
+ /* 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; */
+
+ /* name = h->root.root.string; */
+
+ /* if (h->root.type == bfd_link_hash_defined */
+ /* || h->root.type == bfd_link_hash_defweak) */
+ /* { */
+ /* sec = h->root.u.def.section; */
+ /* relocation = (h->root.u.def.value */
+ /* + sec->output_section->vma + sec->output_offset); */
+ /* } */
+ /* else if (h->root.type == bfd_link_hash_undefweak) */
+ /* { */
+ /* relocation = 0; */
+ /* } */
+ /* else */
+ /* { */
+ /* if (!((*info->callbacks->undefined_symbol) */
+ /* (info, h->root.root.string, input_bfd, */
+ /* input_section, rel->r_offset, true))) */
+ /* return false; */
+ /* relocation = 0; */
+ /* } */
+ /* } */
+
+ /* r = or32_final_link_relocate (howto, input_bfd, input_section, */
+ /* contents, rel, relocation); */
+
+ /* if (r != bfd_reloc_ok) */
+ /* { */
+ /* const char *msg = (const char *) NULL; */
+
+ /* switch (r) */
+ /* { */
+ /* case bfd_reloc_overflow: */
+ /* r = info->callbacks->reloc_overflow */
+ /* (info, name, howto->name, (bfd_vma) 0, */
+ /* input_bfd, input_section, rel->r_offset); */
+ /* break; */
+
+ /* case bfd_reloc_undefined: */
+ /* r = info->callbacks->undefined_symbol */
+ /* (info, name, input_bfd, input_section, rel->r_offset, true); */
+ /* break; */
+
+ /* case bfd_reloc_outofrange: */
+ /* msg = _("internal error: out of range error"); */
+ /* break; */
+
+ /* case bfd_reloc_notsupported: */
+ /* msg = _("internal error: unsupported relocation error"); */
+ /* break; */
+
+ /* case bfd_reloc_dangerous: */
+ /* msg = _("internal error: dangerous relocation"); */
+ /* break; */
+
+ /* 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; */
+ /* } */
+
bfd_reloc_status_type
or32_elf_32_reloc (abfd, reloc_entry, symbol, data, input_section,
output_bfd, error_message)
***************
*** 377,383 ****
{
struct or32_consth *next;
bfd_byte *addr;
! bfd_vma addend;
};
/* FIXME: This should not be a static variable. */
--- 661,667 ----
{
struct or32_consth *next;
bfd_byte *addr;
! asymbol *symbol;
};
/* FIXME: This should not be a static variable. */
***************
*** 395,430 ****
bfd *output_bfd;
char **error_message ATTRIBUTE_UNUSED;
{
- bfd_reloc_status_type ret;
- bfd_vma relocation;
struct or32_consth *n;
-
- ret = bfd_reloc_ok;
! relocation = symbol->section->output_section->vma;
! relocation += symbol->section->output_offset;
! if (!bfd_is_com_section (symbol->section))
! relocation += symbol->value;
/* Save the information, and let LO16 do the actual relocation. */
n = (struct or32_consth *) bfd_malloc (sizeof *n);
if (n == NULL)
return bfd_reloc_outofrange;
n->addr = (bfd_byte *) data + reloc_entry->address;
- n->addend = relocation;
n->next = or32_consth_list;
or32_consth_list = n;
- reloc_entry->addend = 0;
! if (output_bfd != (bfd *) NULL
! && (symbol->flags & BSF_GLOBAL))
! {
! reloc_entry->address += input_section->output_offset;
! return bfd_reloc_ok;
! }
! else
! return bfd_reloc_continue;
}
/* Do a R_OR32_CONST relocation. This is a straightforward 16 bit
--- 679,710 ----
bfd *output_bfd;
char **error_message ATTRIBUTE_UNUSED;
{
struct or32_consth *n;
! if (output_bfd != (bfd *) NULL
! && !(symbol->flags & BSF_SECTION_SYM))
! {
! reloc_entry->address += input_section->output_offset;
! return bfd_reloc_ok;
! }
!
! if (bfd_is_und_section (symbol->section)
! && output_bfd == (bfd *) NULL)
! return bfd_reloc_undefined;
/* Save the information, and let LO16 do the actual relocation. */
n = (struct or32_consth *) bfd_malloc (sizeof *n);
if (n == NULL)
return bfd_reloc_outofrange;
+ /* Push this reloc on the list of pending relocations */
n->addr = (bfd_byte *) data + reloc_entry->address;
n->next = or32_consth_list;
+ n->symbol = symbol;
or32_consth_list = n;
! reloc_entry->address += input_section->output_offset;
! return bfd_reloc_ok;
}
/* Do a R_OR32_CONST relocation. This is a straightforward 16 bit
***************
*** 442,447 ****
--- 722,763 ----
bfd *output_bfd;
char **error_message;
{
+ unsigned long insn_hi, insn_lo;
+ bfd_reloc_status_type ret;
+ bfd_size_type insn_lo_addr;
+ bfd_vma relocation;
+ unsigned long val;
+
+ if (output_bfd != (bfd *) NULL
+ && !(symbol->flags & BSF_SECTION_SYM))
+ {
+ reloc_entry->address += input_section->output_offset;
+ return bfd_reloc_ok;
+ }
+
+ if (bfd_is_und_section (symbol->section)
+ && output_bfd == (bfd *) NULL)
+ return bfd_reloc_undefined;
+
+ relocation = symbol->section->output_section->vma;
+ relocation += symbol->section->output_offset;
+
+ if (!bfd_is_com_section (symbol->section))
+ relocation += symbol->value;
+
+ /* Retrieve the instruction containing the low 16 bits of the offset */
+ insn_lo_addr = reloc_entry->address;
+ reloc_entry->address += input_section->output_offset;
+ insn_lo = bfd_get_32 (abfd, (bfd_byte *) data + insn_lo_addr);
+
+ /* Add in the relocation and update LO16 the instruction in place */
+ relocation += insn_lo & 0xffff;
+ insn_lo = (insn_lo & 0xffff0000) | (relocation & 0x0000ffff);
+ bfd_put_32 (abfd, insn_lo, (bfd_byte *) data + insn_lo_addr);
+
+ ret = bfd_reloc_ok;
+
+ /* Iterate over the list of previously encountered HI16 relocations */
if (or32_consth_list != NULL)
{
struct or32_consth *l;
***************
*** 449,480 ****
l = or32_consth_list;
while (l != NULL)
{
- unsigned long insn;
- unsigned long val;
- unsigned long vallo;
struct or32_consth *next;
/* 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);
! if (output_bfd != (bfd *) NULL
! && !(symbol->flags & BSF_GLOBAL))
! {
! val = (insn << 16) | vallo;
! val += l->addend;
! insn = (insn &~ 0xffff) | (val >> 16);
! }
! else
! {
! val = vallo + (l->addend & 0xffff);
! val = (insn + (val >> 16)) & 0xffff;
! insn = (insn &~ 0xffff) | val;
! }
!
! bfd_put_32 (abfd, insn, l->addr);
next = l->next;
free (l);
l = next;
--- 765,788 ----
l = or32_consth_list;
while (l != NULL)
{
struct or32_consth *next;
+ if (l->symbol != symbol) {
+ *error_message =
+ (char *) _("Symbol for R_OR32_CONSTH reloc doesn't match symbol "
+ "in following R_OR32_CONST reloc");
+ ret = bfd_reloc_dangerous;
+ }
+
/* 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_hi = bfd_get_32 (abfd, l->addr);
! val = (insn_hi << 16) + relocation;
! insn_hi = (insn_hi & ~0xffff) | (val >> 16);
! bfd_put_32 (abfd, insn_hi, l->addr);
!
next = l->next;
free (l);
l = next;
***************
*** 483,508 ****
or32_consth_list = NULL;
}
- if (output_bfd != (bfd *) NULL
- && !(symbol->flags & BSF_GLOBAL))
- {
- unsigned long insn, tmp;
- bfd_size_type addr = reloc_entry->address;
- insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
- reloc_entry->address += input_section->output_offset;
-
- tmp = insn & 0x0000ffff;
- tmp += symbol->section->output_section->vma;
- tmp += symbol->section->output_offset;
- if (!bfd_is_com_section (symbol->section))
- tmp += symbol->value;
- insn = (insn & 0xffff0000) | (tmp & 0x0000ffff);
- bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
! return bfd_reloc_ok;
! }
!
! return bfd_reloc_continue;
}
bfd_reloc_status_type
--- 791,798 ----
or32_consth_list = NULL;
}
! return ret;
}
bfd_reloc_status_type
***************
*** 516,533 ****
bfd *output_bfd;
char **error_message ATTRIBUTE_UNUSED;
{
! if (output_bfd != (bfd *) NULL
! && (symbol->flags & BSF_SECTION_SYM) == 0)
{
! unsigned long insn, tmp;
bfd_size_type addr = reloc_entry->address;
insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
reloc_entry->address += input_section->output_offset;
reloc_entry->addend += input_section->output_offset;
tmp = insn | 0xfc000000;
! tmp -= (input_section->output_offset) >> 2;
insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);
bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
--- 806,828 ----
bfd *output_bfd;
char **error_message ATTRIBUTE_UNUSED;
{
! if (output_bfd != (bfd *) NULL)
{
! unsigned long insn, tmp, offset;
bfd_size_type addr = reloc_entry->address;
insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
reloc_entry->address += input_section->output_offset;
reloc_entry->addend += input_section->output_offset;
+ if (symbol->flags & BSF_SECTION_SYM)
+ offset = symbol->section->output_offset;
+ else
+ offset = 0;
+ offset -= input_section->output_offset;
+
tmp = insn | 0xfc000000;
! tmp += offset >> 2;
insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);
bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
***************
*** 548,553 ****
--- 843,851 ----
#define elf_info_to_howto 0
#define elf_info_to_howto_rel or32_info_to_howto_rel
+ #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
+ #define elf_backend_can_gc_sections 1
+ #define elf_backend_check_relocs or32_elf_check_relocs
#define elf_backend_object_p or32_elf_object_p
#define elf_backend_final_write_processing \
or32_elf_final_write_processing
Index: ld/emulparams/or32elf.sh
===================================================================
RCS file: /home/oc/cvs/or1k/binutils/ld/emulparams/or32elf.sh,v
retrieving revision 1.1
diff -c -r1.1 or32elf.sh
*** ld/emulparams/or32elf.sh 11 Feb 2002 12:09:07 -0000 1.1
--- ld/emulparams/or32elf.sh 13 Nov 2003 05:41:47 -0000
***************
*** 4,6 ****
--- 4,7 ----
TARGET_PAGE_SIZE=0x1000000
MAXPAGESIZE=0x1000
ARCH=or32
+ EXTRA_EM_FILE=or32elf
|
 |
Browse
