espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-06 15:38:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Tidy up debugging in the ARC port of the BFD library.

Browse Source 
bfd	* elf32-arc.c (PR_DEBUG): Delete.
	Fix printing of debug information.  Fix formatting of debug
	statements.
	(debug_arc_reloc): Handle symbols that are not from an input file.
	(arc_do_relocation): Remove excessive exclamation points.
	(elf_arc_relocate_section): Print an informative message if the
	relocation fails, even if debugging is not enabled.
	* arc-got.h: Fix formatting.  Fix printing of debug information.
	(new_got_entry_to_list): Use xmalloc.
	* config.bfd: use the big-endian arc vector as the default vector
	for big-endian arc targets.

ld	* testsuite/ld-arc/arc.exp: Always run the sda-relocs test in
	little endian mode.
This commit is contained in:
Nick Clifton
2016-07-15 12:00:03 +01:00
parent 003c15c9fd
commit f7e8b360fe
6 changed files with 332 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
bfd/ChangeLog
View File

@ -1,3 +1,17 @@
2016-07-15 Andrew Burgess <andrew.burgess@embecosm.com>
Nick Clifton <nickc@redhat.com>
* elf32-arc.c (PR_DEBUG): Delete.
Fix printing of debug information. Fix formatting of debug
statements.
(debug_arc_reloc): Handle symbols that are not from an input file.
(arc_do_relocation): Remove excessive exclamation points.
* arc-got.h: Fix formatting. Fix printing of debug information.
(new_got_entry_to_list): Use xmalloc.
* config.bfd: use the big-endian arc vector as the default vector
for big-endian arc targets.
2016-07-15 Alan Modra <amodra@gmail.com> 2016-07-15 Alan Modra <amodra@gmail.com>
* cofflink.c (mark_relocs): Exclude relocs with -1 r_symndx * cofflink.c (mark_relocs): Exclude relocs with -1 r_symndx

240
bfd/arc-got.h
View File

@ -77,6 +77,7 @@ got_entry_for_type (struct got_entry **list,
enum tls_type_e type) enum tls_type_e type)
{ {
struct got_entry **p = list; struct got_entry **p = list;
while (*p != NULL) while (*p != NULL)
{ {
if ((*p)->type == type) if ((*p)->type == type)
@ -95,6 +96,8 @@ new_got_entry_to_list (struct got_entry **list,
/* Find list end. Avoid having multiple entries of the same /* Find list end. Avoid having multiple entries of the same
type. */ type. */
struct got_entry **p = list; struct got_entry **p = list;
struct got_entry *entry;
while (*p != NULL) while (*p != NULL)
{ {
if ((*p)->type == type) if ((*p)->type == type)
@ -102,8 +105,7 @@ new_got_entry_to_list (struct got_entry **list,
p = &((*p)->next); p = &((*p)->next);
} }
struct got_entry *entry entry = (struct got_entry *) xmalloc (sizeof (struct got_entry));
= (struct got_entry *) malloc (sizeof (struct got_entry));
entry->type = type; entry->type = type;
entry->offset = offset; entry->offset = offset;
@ -113,8 +115,8 @@ new_got_entry_to_list (struct got_entry **list,
entry->existing_entries = existing_entries; entry->existing_entries = existing_entries;
ARC_DEBUG ("New GOT got entry added to list: " ARC_DEBUG ("New GOT got entry added to list: "
"type: %d, offset: %d, existing_entries:%d\n", "type: %d, offset: %ld, existing_entries: %d\n",
type, offset, existing_entries); type, (long) offset, existing_entries);
/* Add the entry to the end of the list. */ /* Add the entry to the end of the list. */
*p = entry; *p = entry;
@ -124,26 +126,26 @@ static enum tls_type_e
tls_type_for_reloc (reloc_howto_type *howto) tls_type_for_reloc (reloc_howto_type *howto)
{ {
enum tls_type_e ret = GOT_UNKNOWN; enum tls_type_e ret = GOT_UNKNOWN;
if (is_reloc_for_GOT (howto)) if (is_reloc_for_GOT (howto))
ret = GOT_NORMAL; return GOT_NORMAL;
else
switch (howto->type)
{ {
switch (howto->type) case R_ARC_TLS_GD_GOT:
{ ret = GOT_TLS_GD;
case R_ARC_TLS_GD_GOT: break;
ret = GOT_TLS_GD; case R_ARC_TLS_IE_GOT:
break; ret = GOT_TLS_IE;
case R_ARC_TLS_IE_GOT: break;
ret = GOT_TLS_IE; case R_ARC_TLS_LE_32:
break; ret = GOT_TLS_LE;
case R_ARC_TLS_LE_32: break;
ret = GOT_TLS_LE; default:
break; ret = GOT_UNKNOWN;
default: break;
ret = GOT_UNKNOWN;
break;
}
} }
return ret; return ret;
}; };
@ -171,8 +173,9 @@ arc_got_entry_type_for_reloc (reloc_howto_type *howto)
enum tls_type_e type = GOT_UNKNOWN; enum tls_type_e type = GOT_UNKNOWN;
if (is_reloc_for_GOT (howto)) if (is_reloc_for_GOT (howto))
type = GOT_NORMAL; return GOT_NORMAL;
else if (is_reloc_for_TLS (howto))
if (is_reloc_for_TLS (howto))
{ {
switch (howto->type) switch (howto->type)
{ {
@ -257,30 +260,29 @@ arc_fill_got_info_for_reloc (enum tls_type_e type,
static bfd_vma static bfd_vma
relocate_fix_got_relocs_for_got_info (struct got_entry **list_p, relocate_fix_got_relocs_for_got_info (struct got_entry ** list_p,
enum tls_type_e type, enum tls_type_e type,
struct bfd_link_info * info, struct bfd_link_info * info,
bfd *output_bfd, bfd * output_bfd,
unsigned long r_symndx, unsigned long r_symndx,
Elf_Internal_Sym *local_syms, Elf_Internal_Sym * local_syms,
asection **local_sections, asection ** local_sections,
struct elf_link_hash_entry *h, struct elf_link_hash_entry * h,
struct arc_relocation_data *reloc_data) struct arc_relocation_data * reloc_data)
{ {
struct elf_link_hash_table *htab = elf_hash_table (info);
struct got_entry *entry = NULL;
if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE) if (list_p == NULL || type == GOT_UNKNOWN || type == GOT_TLS_LE)
return 0; return 0;
struct elf_link_hash_table *htab = elf_hash_table (info);
struct got_entry *entry = NULL;
entry = got_entry_for_type (list_p, type); entry = got_entry_for_type (list_p, type);
BFD_ASSERT (entry); BFD_ASSERT (entry);
if (h == NULL if (h == NULL
|| (! elf_hash_table (info)->dynamic_sections_created || (! elf_hash_table (info)->dynamic_sections_created
|| (bfd_link_pic (info) || (bfd_link_pic (info)
&& SYMBOL_REFERENCES_LOCAL (info, h)))) && SYMBOL_REFERENCES_LOCAL (info, h))))
{ {
const char ATTRIBUTE_UNUSED *symbol_name; const char ATTRIBUTE_UNUSED *symbol_name;
static const char local_name[] = "(local)"; static const char local_name[] = "(local)";
@ -294,8 +296,8 @@ relocate_fix_got_relocs_for_got_info (struct got_entry **list_p,
reloc_data->sym_section = h->root.u.def.section; reloc_data->sym_section = h->root.u.def.section;
sym_value = h->root.u.def.value sym_value = h->root.u.def.value
+ h->root.u.def.section->output_section->vma + h->root.u.def.section->output_section->vma
+ h->root.u.def.section->output_offset; + h->root.u.def.section->output_offset;
tls_sec = elf_hash_table (info)->tls_sec; tls_sec = elf_hash_table (info)->tls_sec;
@ -307,8 +309,8 @@ relocate_fix_got_relocs_for_got_info (struct got_entry **list_p,
asection *sec = local_sections[r_symndx]; asection *sec = local_sections[r_symndx];
sym_value = sym->st_value sym_value = sym->st_value
+ sec->output_section->vma + sec->output_section->vma
+ sec->output_offset; + sec->output_offset;
tls_sec = elf_hash_table (info)->tls_sec; tls_sec = elf_hash_table (info)->tls_sec;
@ -320,82 +322,83 @@ relocate_fix_got_relocs_for_got_info (struct got_entry **list_p,
{ {
switch (entry->type) switch (entry->type)
{ {
case GOT_TLS_GD: case GOT_TLS_GD:
{ {
BFD_ASSERT (tls_sec && tls_sec->output_section); BFD_ASSERT (tls_sec && tls_sec->output_section);
bfd_vma sec_vma = tls_sec->output_section->vma; bfd_vma sec_vma = tls_sec->output_section->vma;
bfd_put_32 (output_bfd, bfd_put_32 (output_bfd,
sym_value - sec_vma, sym_value - sec_vma,
htab->sgot->contents + entry->offset htab->sgot->contents + entry->offset
+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
? 4 : 0)); ? 4 : 0));
ARC_DEBUG ("arc_info: FIXED -> %s value = 0x%x " ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
"@ 0x%x, for symbol %s\n", "@ %p, for symbol %s\n",
(entry->type == GOT_TLS_GD ? "GOT_TLS_GD" : (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
"GOT_TLS_IE"), "GOT_TLS_IE"),
sym_value - sec_vma, (long) (sym_value - sec_vma),
htab->sgot->contents + entry->offset htab->sgot->contents + entry->offset
+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
? 4 : 0), ? 4 : 0),
symbol_name); symbol_name);
} }
break; break;
case GOT_TLS_IE: case GOT_TLS_IE:
{ {
BFD_ASSERT (tls_sec && tls_sec->output_section); BFD_ASSERT (tls_sec && tls_sec->output_section);
bfd_vma ATTRIBUTE_UNUSED sec_vma bfd_vma ATTRIBUTE_UNUSED sec_vma
= tls_sec->output_section->vma; = tls_sec->output_section->vma;
ARC_DEBUG ("arc_info: FIXED -> %s value = 0x%x " ARC_DEBUG ("arc_info: FIXED -> %s value = %#lx "
"@ 0x%x, for symbol %s\n", "@ %p, for symbol %s\n",
(entry->type == GOT_TLS_GD ? "GOT_TLS_GD" : (entry->type == GOT_TLS_GD ? "GOT_TLS_GD" :
"GOT_TLS_IE"), "GOT_TLS_IE"),
sym_value - sec_vma, (long) (sym_value - sec_vma),
htab->sgot->contents + entry->offset htab->sgot->contents + entry->offset
+ (entry->existing_entries == TLS_GOT_MOD_AND_OFF + (entry->existing_entries == TLS_GOT_MOD_AND_OFF
? 4 : 0), ? 4 : 0),
symbol_name); symbol_name);
} }
break; break;
case GOT_NORMAL: case GOT_NORMAL:
{ {
bfd_vma sec_vma bfd_vma sec_vma
= reloc_data->sym_section->output_section->vma = reloc_data->sym_section->output_section->vma
+ reloc_data->sym_section->output_offset; + reloc_data->sym_section->output_offset;
if (h->root.type != bfd_link_hash_undefweak) if (h->root.type != bfd_link_hash_undefweak)
{ {
bfd_put_32 (output_bfd, bfd_put_32 (output_bfd,
reloc_data->sym_value + sec_vma, reloc_data->sym_value + sec_vma,
htab->sgot->contents + entry->offset); htab->sgot->contents + entry->offset);
ARC_DEBUG ("arc_info: PATCHED: 0x%08x " ARC_DEBUG ("arc_info: PATCHED: %#08lx "
"@ 0x%08x for sym %s in got offset 0x%x\n", "@ %#08lx for sym %s in got offset %#lx\n",
reloc_data->sym_value + sec_vma, (long) (reloc_data->sym_value + sec_vma),
htab->sgot->output_section->vma (long) (htab->sgot->output_section->vma
+ htab->sgot->output_offset + entry->offset, + htab->sgot->output_offset + entry->offset),
symbol_name, symbol_name,
entry->offset); (long) entry->offset);
}
else
{
ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
"@ 0x%08x for sym %s in got offset 0x%x "
"(is undefweak)\n",
htab->sgot->output_section->vma
+ htab->sgot->output_offset + entry->offset,
symbol_name,
entry->offset);
} }
} else
break; {
default: ARC_DEBUG ("arc_info: PATCHED: NOT_PATCHED "
BFD_ASSERT (0); "@ %#08lx for sym %s in got offset %#lx "
break; "(is undefweak)\n",
(long) (htab->sgot->output_section->vma
+ htab->sgot->output_offset
+ entry->offset),
symbol_name,
(long) entry->offset);
}
}
break;
default:
BFD_ASSERT (0);
break;
} }
entry->processed = TRUE; entry->processed = TRUE;
} }
@ -455,13 +458,14 @@ create_got_dynrelocs_for_single_entry (struct got_entry *list,
ADD_RELA (output_bfd, got, got_offset, dynindx, ADD_RELA (output_bfd, got, got_offset, dynindx,
R_ARC_TLS_DTPMOD, 0); R_ARC_TLS_DTPMOD, 0);
ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \ ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n", GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = 0x0\n",
list->type, list->type,
got_offset, (long) got_offset,
htab->sgot->output_section->vma (long) (htab->sgot->output_section->vma
+ htab->sgot->output_offset + got_offset, + htab->sgot->output_offset + got_offset),
dynindx, 0); (long) dynindx);
} }
if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_OFF) if (e == TLS_GOT_MOD_AND_OFF || e == TLS_GOT_OFF)
{ {
bfd_vma addend = 0; bfd_vma addend = 0;
@ -477,12 +481,12 @@ GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n",
addend); addend);
ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \ ARC_DEBUG ("arc_info: TLS_DYNRELOC: type = %d, \
GOT_OFFSET = 0x%x, GOT_VMA = 0x%x, INDEX = %d, ADDEND = 0x%x\n", GOT_OFFSET = %#lx, GOT_VMA = %#lx, INDEX = %ld, ADDEND = %#lx\n",
list->type, list->type,
got_offset, (long) got_offset,
htab->sgot->output_section->vma (long) (htab->sgot->output_section->vma
+ htab->sgot->output_offset + got_offset, + htab->sgot->output_offset + got_offset),
dynindx, addend); (long) dynindx, (long) addend);
} }
list->created_dyn_relocation = TRUE; list->created_dyn_relocation = TRUE;
} }

5
bfd/config.bfd
View File

@ -276,6 +276,11 @@ case "${targ}" in
targ_defvec=am33_elf32_linux_vec targ_defvec=am33_elf32_linux_vec
;; ;;
arc*eb-*-elf* | arc*eb-*-linux*)
targ_defvec=arc_elf32_be_vec
targ_selvecs=arc_elf32_le_vec
;;
arc*-*-elf* | arc*-*-linux*) arc*-*-elf* | arc*-*-linux*)
targ_defvec=arc_elf32_le_vec targ_defvec=arc_elf32_le_vec
targ_selvecs=arc_elf32_be_vec targ_selvecs=arc_elf32_be_vec

328
bfd/elf32-arc.c
View File

@ -29,22 +29,19 @@
#include "opcode/arc.h" #include "opcode/arc.h"
#include "arc-plt.h" #include "arc-plt.h"
#define PR_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
/* #define ARC_ENABLE_DEBUG 1 */ /* #define ARC_ENABLE_DEBUG 1 */
#ifndef ARC_ENABLE_DEBUG #ifdef ARC_ENABLE_DEBUG
#define ARC_DEBUG(...) static const char *
#else
static char *
name_for_global_symbol (struct elf_link_hash_entry *h) name_for_global_symbol (struct elf_link_hash_entry *h)
{ {
static char *local_str = "(local)"; static char *local_str = "(local)";
if (h == NULL) if (h == NULL)
return local_str; return local_str;
else return h->root.root.string;
return h->root.root.string;
} }
#define ARC_DEBUG(args...) fprintf (stderr, ##args) #define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args)
#else
#define ARC_DEBUG(...)
#endif #endif
@ -236,7 +233,9 @@ enum howto_list
#undef ARC_RELOC_HOWTO #undef ARC_RELOC_HOWTO
#define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
[TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, complain_overflow_##OVERFLOW, arc_elf_reloc, "R_" #TYPE, FALSE, 0, 0, FALSE), [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \
complain_overflow_##OVERFLOW, arc_elf_reloc, \
"R_" #TYPE, FALSE, 0, 0, FALSE),
static struct reloc_howto_struct elf_arc_howto_table[] = static struct reloc_howto_struct elf_arc_howto_table[] =
{ {
@ -640,61 +639,60 @@ DO_NOTHING:
return; return;
} }
#define BFD_DEBUG_PIC(...) #ifdef ARC_ENABLE_DEBUG
#define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
static void static void
debug_arc_reloc (struct arc_relocation_data reloc_data) debug_arc_reloc (struct arc_relocation_data reloc_data)
{ {
PR_DEBUG ("Reloc type=%s, should_relocate = %s\n", ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n",
reloc_data.howto->name, reloc_data.howto->name,
reloc_data.should_relocate ? "true" : "false"); reloc_data.should_relocate ? "true" : "false");
PR_DEBUG (" offset = 0x%x, addend = 0x%x\n", ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n",
(unsigned int) reloc_data.reloc_offset, (unsigned int) reloc_data.reloc_offset,
(unsigned int) reloc_data.reloc_addend); (unsigned int) reloc_data.reloc_addend);
PR_DEBUG (" Symbol:\n"); ARC_DEBUG (" Symbol:\n");
PR_DEBUG (" value = 0x%08x\n", ARC_DEBUG (" value = 0x%08x\n",
(unsigned int) reloc_data.sym_value); (unsigned int) reloc_data.sym_value);
if (reloc_data.sym_section != NULL) if (reloc_data.sym_section != NULL)
{ {
PR_DEBUG (" Symbol Section:\n"); ARC_DEBUG (" Symbol Section:\n");
PR_DEBUG ( ARC_DEBUG (" section name = %s, output_offset 0x%08x",
" section name = %s, output_offset 0x%08x", reloc_data.sym_section->name,
reloc_data.sym_section->name, (unsigned int) reloc_data.sym_section->output_offset);
(unsigned int) reloc_data.sym_section->output_offset);
if (reloc_data.sym_section->output_section != NULL) if (reloc_data.sym_section->output_section != NULL)
{ ARC_DEBUG (", output_section->vma = 0x%08x",
PR_DEBUG (
", output_section->vma = 0x%08x",
((unsigned int) reloc_data.sym_section->output_section->vma)); ((unsigned int) reloc_data.sym_section->output_section->vma));
} ARC_DEBUG ("\n");
PR_DEBUG ( "\n"); if (reloc_data.sym_section->owner && reloc_data.sym_section->owner->filename)
PR_DEBUG (" file: %s\n", reloc_data.sym_section->owner->filename); ARC_DEBUG (" file: %s\n", reloc_data.sym_section->owner->filename);
} }
else else
{ {
PR_DEBUG ( " symbol section is NULL\n"); ARC_DEBUG (" symbol section is NULL\n");
} }
PR_DEBUG ( " Input_section:\n"); ARC_DEBUG (" Input_section:\n");
if (reloc_data.input_section != NULL) if (reloc_data.input_section != NULL)
{ {
PR_DEBUG ( ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n",
" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n", reloc_data.input_section->name,
reloc_data.input_section->name, (unsigned int) reloc_data.input_section->output_offset,
(unsigned int) reloc_data.input_section->output_offset, (unsigned int) reloc_data.input_section->output_section->vma);
(unsigned int) reloc_data.input_section->output_section->vma); ARC_DEBUG (" changed_address = 0x%08x\n",
PR_DEBUG ( " changed_address = 0x%08x\n", (unsigned int) (reloc_data.input_section->output_section->vma
(unsigned int) (reloc_data.input_section->output_section->vma + reloc_data.input_section->output_offset
+ reloc_data.input_section->output_offset + reloc_data.reloc_offset));
+ reloc_data.reloc_offset)); ARC_DEBUG (" file: %s\n", reloc_data.input_section->owner->filename);
PR_DEBUG (" file: %s\n", reloc_data.input_section->owner->filename);
} }
else else
{ {
PR_DEBUG ( " input section is NULL\n"); ARC_DEBUG (" input section is NULL\n");
} }
} }
#else
#define DEBUG_ARC_RELOC(A)
#endif /* ARC_ENABLE_DEBUG */
static bfd_vma static bfd_vma
middle_endian_convert (bfd_vma insn, bfd_boolean do_it) middle_endian_convert (bfd_vma insn, bfd_boolean do_it)
@ -798,60 +796,67 @@ arc_special_overflow_checks (const struct arc_relocation_data reloc_data,
#define none (0) #define none (0)
#define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \ #ifdef ARC_ENABLE_DEBUG
{\ #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \
asection *sym_section = reloc_data.sym_section; \ do \
asection *input_section = reloc_data.input_section; \ { \
ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \ asection *sym_section = reloc_data.sym_section; \
ARC_DEBUG ("FORMULA = " FORMULA "\n"); \ asection *input_section = reloc_data.input_section; \
ARC_DEBUG ("S = 0x%x\n", S); \ ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \
ARC_DEBUG ("A = 0x%x\n", A); \ ARC_DEBUG ("FORMULA = " FORMULA "\n"); \
ARC_DEBUG ("L = 0x%x\n", L); \ ARC_DEBUG ("S = %#lx\n", S); \
if (sym_section->output_section != NULL) \ ARC_DEBUG ("A = %#lx\n", A); \
{ \ ARC_DEBUG ("L = %lx\n", L); \
ARC_DEBUG ("symbol_section->vma = 0x%x\n", \ if (sym_section->output_section != NULL) \
sym_section->output_section->vma + sym_section->output_offset); \ ARC_DEBUG ("symbol_section->vma = %#lx\n", \
} \ sym_section->output_section->vma \
else \ + sym_section->output_offset); \
{ \ else \
ARC_DEBUG ("symbol_section->vma = NULL\n"); \ ARC_DEBUG ("symbol_section->vma = NULL\n"); \
} \ if (input_section->output_section != NULL) \
if (input_section->output_section != NULL) \ ARC_DEBUG ("symbol_section->vma = %#lx\n", \
{ \ input_section->output_section->vma \
ARC_DEBUG ("symbol_section->vma = 0x%x\n", \ + input_section->output_offset); \
input_section->output_section->vma + input_section->output_offset); \ else \
} \ ARC_DEBUG ("symbol_section->vma = NULL\n"); \
else \ ARC_DEBUG ("PCL = %#lx\n", P); \
{ \ ARC_DEBUG ("P = %#lx\n", P); \
ARC_DEBUG ("symbol_section->vma = NULL\n"); \ ARC_DEBUG ("G = %#lx\n", G); \
} \ ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \
ARC_DEBUG ("PCL = 0x%x\n", P); \
ARC_DEBUG ("P = 0x%x\n", P); \
ARC_DEBUG ("G = 0x%x\n", G); \
ARC_DEBUG ("SDA_OFFSET = 0x%x\n", _SDA_BASE_); \
ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \ ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \
ARC_DEBUG ("GOT_OFFSET = 0x%x\n", GOT); \ ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \
ARC_DEBUG ("relocation = 0x%08x\n", relocation); \ ARC_DEBUG ("relocation = %#08lx\n", relocation); \
ARC_DEBUG ("before = 0x%08x\n", (unsigned int) insn); \ ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \
ARC_DEBUG ("data = 0x%08x (%u) (%d)\n", (unsigned int) relocation, (unsigned int) relocation, (int) relocation); \ ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \
} (unsigned) relocation, (int) relocation); \
} \
while (0)
#define PRINT_DEBUG_RELOC_INFO_AFTER \ #define PRINT_DEBUG_RELOC_INFO_AFTER \
{ \ do \
ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \ { \
} ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \
} \
while (0)
#else
#define PRINT_DEBUG_RELOC_INFO_BEFORE(...)
#define PRINT_DEBUG_RELOC_INFO_AFTER
#endif /* ARC_ENABLE_DEBUG */
#define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \
case R_##TYPE: \ case R_##TYPE: \
{ \ { \
bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \ bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \
relocation = FORMULA ; \ relocation = FORMULA ; \
PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \ PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \
insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \ insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \ insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \
insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \ insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \
PRINT_DEBUG_RELOC_INFO_AFTER \ PRINT_DEBUG_RELOC_INFO_AFTER; \
} \ } \
break; break;
static bfd_reloc_status_type static bfd_reloc_status_type
@ -913,24 +918,16 @@ arc_do_relocation (bfd_byte * contents,
else else
flag = arc_special_overflow_checks (reloc_data, relocation, info); flag = arc_special_overflow_checks (reloc_data, relocation, info);
#undef DEBUG_ARC_RELOC
#define DEBUG_ARC_RELOC(A) debug_arc_reloc (A)
if (flag != bfd_reloc_ok) if (flag != bfd_reloc_ok)
{ {
PR_DEBUG ( "Relocation overflows !!!!\n"); ARC_DEBUG ("Relocation overflows !\n");
DEBUG_ARC_RELOC (reloc_data); DEBUG_ARC_RELOC (reloc_data);
ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u"
", hex -> (0x%08x)\n",
(int) relocation, (unsigned) relocation, (int) relocation);
PR_DEBUG (
"Relocation value = signed -> %d, unsigned -> %u"
", hex -> (0x%08x)\n",
(int) relocation,
(unsigned int) relocation,
(unsigned int) relocation);
return flag; return flag;
} }
#undef DEBUG_ARC_RELOC
#define DEBUG_ARC_RELOC(A)
/* Write updated instruction back to memory. */ /* Write updated instruction back to memory. */
switch (reloc_data.howto->size) switch (reloc_data.howto->size)
@ -989,21 +986,21 @@ arc_do_relocation (bfd_byte * contents,
corresponding to the st_shndx field of each corresponding to the st_shndx field of each
local symbol. */ local symbol. */
static bfd_boolean static bfd_boolean
elf_arc_relocate_section (bfd * output_bfd, elf_arc_relocate_section (bfd * output_bfd,
struct bfd_link_info * info, struct bfd_link_info * info,
bfd * input_bfd, bfd * input_bfd,
asection * input_section, asection * input_section,
bfd_byte * contents, bfd_byte * contents,
Elf_Internal_Rela * relocs, Elf_Internal_Rela * relocs,
Elf_Internal_Sym * local_syms, Elf_Internal_Sym * local_syms,
asection ** local_sections) asection ** local_sections)
{ {
Elf_Internal_Shdr * symtab_hdr; Elf_Internal_Shdr * symtab_hdr;
struct elf_link_hash_entry ** sym_hashes; struct elf_link_hash_entry ** sym_hashes;
Elf_Internal_Rela * rel; Elf_Internal_Rela * rel;
Elf_Internal_Rela * wrel; Elf_Internal_Rela * wrel;
Elf_Internal_Rela * relend; Elf_Internal_Rela * relend;
struct elf_link_hash_table *htab = elf_hash_table (info); struct elf_link_hash_table * htab = elf_hash_table (info);
symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr); symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr);
sym_hashes = elf_sym_hashes (input_bfd); sym_hashes = elf_sym_hashes (input_bfd);
@ -1014,11 +1011,12 @@ elf_arc_relocate_section (bfd * output_bfd,
{ {
enum elf_arc_reloc_type r_type; enum elf_arc_reloc_type r_type;
reloc_howto_type * howto; reloc_howto_type * howto;
unsigned long r_symndx; unsigned long r_symndx;
struct elf_link_hash_entry * h; struct elf_link_hash_entry * h;
Elf_Internal_Sym * sym; Elf_Internal_Sym * sym;
asection * sec; asection * sec;
struct elf_link_hash_entry *h2; struct elf_link_hash_entry * h2;
const char * msg;
struct arc_relocation_data reloc_data = struct arc_relocation_data reloc_data =
{ {
@ -1064,17 +1062,13 @@ elf_arc_relocate_section (bfd * output_bfd,
{ {
sec = local_sections[r_symndx]; sec = local_sections[r_symndx];
/* for RELA relocs.Just adjust the addend /* For RELA relocs. Just adjust the addend
value in the relocation entry. */ value in the relocation entry. */
rel->r_addend += sec->output_offset + sym->st_value; rel->r_addend += sec->output_offset + sym->st_value;
BFD_DEBUG_PIC ( ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n",
PR_DEBUG ("local symbols reloc " (int) r_symndx, local_sections[r_symndx]->name,
"(section=%d %s) seen in %s\n", __PRETTY_FUNCTION__);
r_symndx,
local_sections[r_symndx]->name,
__PRETTY_FUNCTION__)
);
} }
} }
} }
@ -1191,6 +1185,9 @@ elf_arc_relocate_section (bfd * output_bfd,
} }
else /* Global symbol. */ else /* Global symbol. */
{ {
/* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro
(defined in elf-bfd.h) here. */
/* Get the symbol's entry in the symtab. */ /* Get the symbol's entry in the symtab. */
h = sym_hashes[r_symndx - symtab_hdr->sh_info]; h = sym_hashes[r_symndx - symtab_hdr->sh_info];
@ -1313,6 +1310,7 @@ elf_arc_relocate_section (bfd * output_bfd,
output_bfd, info, NULL); output_bfd, info, NULL);
} }
} }
switch (r_type) switch (r_type)
{ {
case R_ARC_32: case R_ARC_32:
@ -1347,8 +1345,9 @@ elf_arc_relocate_section (bfd * output_bfd,
+ input_section->output_offset); + input_section->output_offset);
#define IS_ARC_PCREL_TYPE(TYPE) \ #define IS_ARC_PCREL_TYPE(TYPE) \
( (TYPE == R_ARC_PC32) \ ( (TYPE == R_ARC_PC32) \
|| (TYPE == R_ARC_32_PCREL)) || (TYPE == R_ARC_32_PCREL))
if (skip) if (skip)
{ {
memset (&outrel, 0, sizeof outrel); memset (&outrel, 0, sizeof outrel);
@ -1425,8 +1424,47 @@ elf_arc_relocate_section (bfd * output_bfd,
return FALSE; return FALSE;
} }
if (arc_do_relocation (contents, reloc_data, info) != bfd_reloc_ok) msg = NULL;
return FALSE; switch (arc_do_relocation (contents, reloc_data, info))
{
case bfd_reloc_ok:
continue; /* The reloc processing loop. */
case bfd_reloc_overflow:
(*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), reloc_data.symbol_name, howto->name, (bfd_vma) 0,
input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
(*info->callbacks->undefined_symbol)
(info, reloc_data.symbol_name, input_bfd, input_section, rel->r_offset, TRUE);
break;
case bfd_reloc_other:
msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
break;
case bfd_reloc_outofrange:
msg = _("%B(%A): internal error: out of range error");
break;
case bfd_reloc_notsupported:
msg = _("%B(%A): internal error: unsupported relocation error");
break;
case bfd_reloc_dangerous:
msg = _("%B(%A): internal error: dangerous relocation");
break;
default:
msg = _("%B(%A): internal error: unknown error");
break;
}
if (msg)
_bfd_error_handler (msg, input_bfd, input_section, reloc_data.symbol_name);
return FALSE;
} }
return TRUE; return TRUE;
@ -1633,8 +1671,8 @@ arc_get_plt_version (struct bfd_link_info *info)
for (i = 0; i < 1; i++) for (i = 0; i < 1; i++)
{ {
ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i, ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i,
plt_versions[i].entry_size, (int) plt_versions[i].entry_size,
plt_versions[i].elem_size); (int) plt_versions[i].elem_size);
} }
if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2) if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2)
@ -1669,7 +1707,7 @@ add_symbol_to_plt (struct bfd_link_info *info)
ret = htab->splt->size; ret = htab->splt->size;
htab->splt->size += plt_data->elem_size; htab->splt->size += plt_data->elem_size;
ARC_DEBUG ("PLT_SIZE = %d\n", htab->splt->size); ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab->splt->size);
htab->sgotplt->size += 4; htab->sgotplt->size += 4;
htab->srelplt->size += sizeof (Elf32_External_Rela); htab->srelplt->size += sizeof (Elf32_External_Rela);
@ -1746,22 +1784,22 @@ relocate_plt_for_symbol (bfd *output_bfd,
/ plt_data->elem_size; / plt_data->elem_size;
bfd_vma got_offset = (plt_index + 3) * 4; bfd_vma got_offset = (plt_index + 3) * 4;
ARC_DEBUG ("arc_info: PLT_OFFSET = 0x%x, PLT_ENTRY_VMA = 0x%x, \ ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \
GOT_ENTRY_OFFSET = 0x%x, GOT_ENTRY_VMA = 0x%x, for symbol %s\n", GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n",
h->plt.offset, (long) h->plt.offset,
htab->splt->output_section->vma (long) (htab->splt->output_section->vma
+ htab->splt->output_offset + htab->splt->output_offset
+ h->plt.offset, + h->plt.offset),
got_offset, (long) got_offset,
htab->sgotplt->output_section->vma (long) (htab->sgotplt->output_section->vma
+ htab->sgotplt->output_offset + htab->sgotplt->output_offset
+ got_offset, + got_offset),
h->root.root.string); h->root.root.string);
{ {
bfd_vma i = 0; bfd_vma i = 0;
uint16_t *ptr = (uint16_t *) plt_data->elem; uint16_t *ptr = (uint16_t *) plt_data->elem;
for (i = 0; i < plt_data->elem_size/2; i++) for (i = 0; i < plt_data->elem_size/2; i++)
{ {
uint16_t data = ptr[i]; uint16_t data = ptr[i];

5
ld/ChangeLog
View File

@ -1,3 +1,8 @@
2016-07-15 Nick Clifton <nickc@redhat.com>
* testsuite/ld-arc/arc.exp: Always run the sda-relocs test in
little endian mode.
2016-07-14 Maciej W. Rozycki <macro@imgtec.com> 2016-07-14 Maciej W. Rozycki <macro@imgtec.com>
* testsuite/ld-mips-elf/mips-elf.exp: Run * testsuite/ld-mips-elf/mips-elf.exp: Run

4
ld/testsuite/ld-arc/arc.exp
View File

@ -28,9 +28,11 @@ foreach arc_test $arc_test_list {
run_dump_test [file rootname $arc_test] run_dump_test [file rootname $arc_test]
} }
# Note - we force the generation of little endian binaries, even if the default is
# for big endian, because the sda-relocs.ld script selects little endian output.
set arccommon_tests { set arccommon_tests {
{ "SDA relocs" { "SDA relocs"
"-q -T sda-relocs.ld" "" "-mcpu=archs" {sda-relocs.s} "-q -T sda-relocs.ld -A elf32-arclittle" "" "-mcpu=archs -EL" {sda-relocs.s}
{{objdump -fdw sda-relocs.dd} {readelf --relocs sda-relocs.rd}} {{objdump -fdw sda-relocs.dd} {readelf --relocs sda-relocs.rd}}
"sda-relocs.so" } "sda-relocs.so" }
} }