/* NDS32-specific support for 32-bit ELF.
- Copyright (C) 2012-2016 Free Software Foundation, Inc.
+ Copyright (C) 2012-2017 Free Software Foundation, Inc.
Contributed by Andes Technology Corporation.
This file is part of BFD, the Binary File Descriptor library.
static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
(bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
asection *, bfd_vma, bfd_vma);
-static void nds32_elf_relocate_hi20
- (bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
-static reloc_howto_type *bfd_elf32_bfd_reloc_type_table_lookup
- (enum elf_nds32_reloc_type);
-static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
- (bfd *, bfd_reloc_code_real_type);
-
-/* Target hooks. */
-static void nds32_info_to_howto_rel
- (bfd *, arelent *, Elf_Internal_Rela *dst);
-static void nds32_info_to_howto
- (bfd *, arelent *, Elf_Internal_Rela *dst);
-static bfd_boolean nds32_elf_add_symbol_hook
- (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **,
- flagword *, asection **, bfd_vma *);
-static bfd_boolean nds32_elf_relocate_section
- (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
- Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
-static bfd_boolean nds32_elf_object_p (bfd *);
-static void nds32_elf_final_write_processing (bfd *, bfd_boolean);
-static bfd_boolean nds32_elf_set_private_flags (bfd *, flagword);
-static bfd_boolean nds32_elf_merge_private_bfd_data
- (bfd *, struct bfd_link_info *);
-static bfd_boolean nds32_elf_print_private_bfd_data (bfd *, void *);
-static bfd_boolean nds32_elf_gc_sweep_hook
- (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
-static bfd_boolean nds32_elf_check_relocs
- (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
-static asection *nds32_elf_gc_mark_hook
- (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
- struct elf_link_hash_entry *, Elf_Internal_Sym *);
-static bfd_boolean nds32_elf_adjust_dynamic_symbol
- (struct bfd_link_info *, struct elf_link_hash_entry *);
-static bfd_boolean nds32_elf_size_dynamic_sections
- (bfd *, struct bfd_link_info *);
-static bfd_boolean nds32_elf_create_dynamic_sections
- (bfd *, struct bfd_link_info *);
-static bfd_boolean nds32_elf_finish_dynamic_sections
- (bfd *, struct bfd_link_info *info);
-static bfd_boolean nds32_elf_finish_dynamic_symbol
- (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
- Elf_Internal_Sym *);
-static bfd_boolean nds32_elf_mkobject (bfd *);
/* Nds32 helper functions. */
-static bfd_reloc_status_type nds32_elf_final_sda_base
- (bfd *, struct bfd_link_info *, bfd_vma *, bfd_boolean);
-static bfd_boolean allocate_dynrelocs (struct elf_link_hash_entry *, void *);
-static bfd_boolean readonly_dynrelocs (struct elf_link_hash_entry *, void *);
-static Elf_Internal_Rela *find_relocs_at_address
- (Elf_Internal_Rela *, Elf_Internal_Rela *,
- Elf_Internal_Rela *, enum elf_nds32_reloc_type);
static bfd_vma calculate_memory_address
(bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
static int nds32_get_section_contents (bfd *, asection *,
static bfd_boolean nds32_fag_remove_unused_fpbase
(bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
Elf_Internal_Rela *irelend);
-static bfd_byte *
-nds32_elf_get_relocated_section_contents (bfd *abfd,
- struct bfd_link_info *link_info,
- struct bfd_link_order *link_order,
- bfd_byte *data,
- bfd_boolean relocatable,
- asymbol **symbols);
enum
{
/* The first entry in a procedure linkage table are reserved,
and the initial contents are unimportant (we zero them out).
Subsequent entries look like this. */
-#define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
-#define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
-#define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
-#define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
-#define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
+#define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
+#define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
+#define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
+#define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
+#define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
/* $ta is change to $r15 (from $r25). */
#define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
-#define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
-#define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
-#define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
-#define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
-#define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
-
-#define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
-#define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
-#define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
-#define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
-#define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
+#define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
+#define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
+#define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
+#define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
+#define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
+
+#define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
+#define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
+#define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
+#define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
+#define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
#define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
-#define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
-#define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
-#define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
-#define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
-#define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
+#define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
+#define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
+#define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
+#define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
+#define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
/* These are macros used to get the relocation accurate value. */
#define ACCURATE_8BIT_S1 (0x100)
bfd_size_type count;
};
-/* The sh linker needs to keep track of the number of relocs that it
- decides to copy as dynamic relocs in check_relocs for each symbol.
- This is so that it can later discard them if they are found to be
- unnecessary. We store the information in a field extending the
- regular ELF linker hash table. */
-
-struct elf_nds32_dyn_relocs
-{
- struct elf_nds32_dyn_relocs *next;
-
- /* The input section of the reloc. */
- asection *sec;
-
- /* Total number of relocs copied for the input section. */
- bfd_size_type count;
-
- /* Number of pc-relative relocs copied for the input section. */
- bfd_size_type pc_count;
-};
-
/* Nds32 ELF linker hash entry. */
struct elf_nds32_link_hash_entry
struct elf_link_hash_entry root;
/* Track dynamic relocs copied for this symbol. */
- struct elf_nds32_dyn_relocs *dyn_relocs;
+ struct elf_dyn_relocs *dyn_relocs;
/* For checking relocation type. */
#define GOT_UNKNOWN 0
}
}
- if (add_symbol == TRUE)
+ if (add_symbol)
{
if (h)
{
{
if (edir->dyn_relocs != NULL)
{
- struct elf_nds32_dyn_relocs **pp;
- struct elf_nds32_dyn_relocs *p;
+ struct elf_dyn_relocs **pp;
+ struct elf_dyn_relocs *p;
if (ind->root.type == bfd_link_hash_indirect)
abort ();
list. Merge any entries against the same section. */
for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
{
- struct elf_nds32_dyn_relocs *q;
+ struct elf_dyn_relocs *q;
for (q = edir->dyn_relocs; q != NULL; q = q->next)
if (q->sec == p->sec)
_bfd_elf_link_hash_copy_indirect (info, dir, ind);
}
\f
+/* Find dynamic relocs for H that apply to read-only sections. */
+
+static asection *
+readonly_dynrelocs (struct elf_link_hash_entry *h)
+{
+ struct elf_dyn_relocs *p;
+
+ for (p = elf32_nds32_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
+ {
+ asection *s = p->sec->output_section;
+
+ if (s != NULL && (s->flags & SEC_READONLY) != 0)
+ return p->sec;
+ }
+ return NULL;
+}
/* Adjust a symbol defined by a dynamic object and referenced by a
regular object. The current definition is in some section of the
struct elf_link_hash_entry *h)
{
struct elf_nds32_link_hash_table *htab;
- struct elf_nds32_link_hash_entry *eh;
- struct elf_nds32_dyn_relocs *p;
bfd *dynobj;
asection *s;
unsigned int power_of_two;
/* Make sure we know what is going on here. */
BFD_ASSERT (dynobj != NULL
&& (h->needs_plt
- || h->u.weakdef != NULL
+ || h->is_weakalias
|| (h->def_dynamic && h->ref_regular && !h->def_regular)));
/* If this is a weak symbol, and there is a real definition, the
processor independent code will have arranged for us to see the
real definition first, and we can just use the same value. */
- if (h->u.weakdef != NULL)
+ if (h->is_weakalias)
{
- BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
- || h->u.weakdef->root.type == bfd_link_hash_defweak);
- h->root.u.def.section = h->u.weakdef->root.u.def.section;
- h->root.u.def.value = h->u.weakdef->root.u.def.value;
+ struct elf_link_hash_entry *def = weakdef (h);
+ BFD_ASSERT (def->root.type == bfd_link_hash_defined);
+ h->root.u.def.section = def->root.u.def.section;
+ h->root.u.def.value = def->root.u.def.value;
return TRUE;
}
return TRUE;
/* If -z nocopyreloc was given, we won't generate them either. */
- if (info->nocopyreloc)
+ if (0 && info->nocopyreloc)
{
h->non_got_ref = 0;
return TRUE;
}
- eh = (struct elf_nds32_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- {
- s = p->sec->output_section;
- if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
- break;
- }
-
- /* If we didn't find any dynamic relocs in sections which needs the
- copy reloc, then we'll be keeping the dynamic relocs and avoiding
- the copy reloc. */
- if (p == NULL)
+ /* If we don't find any dynamic relocs in read-only sections, then
+ we'll be keeping the dynamic relocs and avoiding the copy reloc. */
+ if (0 && !readonly_dynrelocs (h))
{
h->non_got_ref = 0;
return TRUE;
struct bfd_link_info *info;
struct elf_nds32_link_hash_table *htab;
struct elf_nds32_link_hash_entry *eh;
- struct elf_nds32_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
{
if (h->def_regular && (h->forced_local || info->symbolic))
{
- struct elf_nds32_dyn_relocs **pp;
+ struct elf_dyn_relocs **pp;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
{
return TRUE;
}
-/* Find any dynamic relocs that apply to read-only sections. */
+/* Set DF_TEXTREL if we find any dynamic relocs that apply to
+ read-only sections. */
static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
{
- struct elf_nds32_link_hash_entry *eh;
- struct elf_nds32_dyn_relocs *p;
+ asection *sec;
- if (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_indirect)
+ return TRUE;
- eh = (struct elf_nds32_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ sec = readonly_dynrelocs (h);
+ if (sec != NULL)
{
- asection *s = p->sec->output_section;
-
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
- {
- struct bfd_link_info *info = (struct bfd_link_info *) inf;
+ struct bfd_link_info *info = (struct bfd_link_info *) info_p;
- info->flags |= DF_TEXTREL;
+ info->flags |= DF_TEXTREL;
+ info->callbacks->minfo
+ (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
+ sec->owner, h->root.root.string, sec);
- /* Not an error, just cut short the traversal. */
- return FALSE;
- }
+ /* Not an error, just cut short the traversal. */
+ return FALSE;
}
return TRUE;
}
if (htab->root.dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (!bfd_link_pic (info) && !info->nointerp)
+ if (bfd_link_executable (info) && !info->nointerp)
{
s = bfd_get_section_by_name (dynobj, ".interp");
BFD_ASSERT (s != NULL);
for (s = ibfd->sections; s != NULL; s = s->next)
{
- struct elf_nds32_dyn_relocs *p;
+ struct elf_dyn_relocs *p;
- for (p = ((struct elf_nds32_dyn_relocs *)
+ for (p = ((struct elf_dyn_relocs *)
elf_section_data (s)->local_dynrel);
p != NULL; p = p->next)
{
/* If any dynamic relocs apply to a read-only section,
then we need a DT_TEXTREL entry. */
if ((info->flags & DF_TEXTREL) == 0)
- elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
+ elf_link_hash_traverse (&htab->root, maybe_set_textrel,
(void *) info);
if ((info->flags & DF_TEXTREL) != 0)
}
static bfd_boolean
-nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
+nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
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)
+ 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;
if (bfd_link_pic (info))
{
_bfd_error_handler
- (_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
- "mode."), bfd_get_filename (input_bfd));
+ (_("%B: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
+ "mode."), input_bfd);
return FALSE;
}
break;
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}
-static bfd_boolean
-nds32_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
- const Elf_Internal_Rela *relocs)
-{
- /* Update the got entry reference counts for the section being removed. */
- Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
- bfd_signed_vma *local_got_refcounts;
- const Elf_Internal_Rela *rel, *relend;
-
- elf_section_data (sec)->local_dynrel = NULL;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sym_hashes = elf_sym_hashes (abfd);
- local_got_refcounts = elf_local_got_refcounts (abfd);
-
- relend = relocs + sec->reloc_count;
- for (rel = relocs; rel < relend; rel++)
- {
- unsigned long r_symndx;
- struct elf_link_hash_entry *h = NULL;
-
- r_symndx = ELF32_R_SYM (rel->r_info);
- if (r_symndx >= symtab_hdr->sh_info)
- {
- /* External symbol. */
- 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;
- }
-
- switch (ELF32_R_TYPE (rel->r_info))
- {
- case R_NDS32_GOT_HI20:
- case R_NDS32_GOT_LO12:
- case R_NDS32_GOT_LO15:
- case R_NDS32_GOT_LO19:
- case R_NDS32_GOT17S2_RELA:
- case R_NDS32_GOT15S2_RELA:
- case R_NDS32_GOTOFF:
- case R_NDS32_GOTOFF_HI20:
- case R_NDS32_GOTOFF_LO12:
- case R_NDS32_GOTOFF_LO15:
- case R_NDS32_GOTOFF_LO19:
- case R_NDS32_GOT20:
- case R_NDS32_GOTPC_HI20:
- case R_NDS32_GOTPC_LO12:
- case R_NDS32_GOTPC20:
- if (h != NULL)
- {
- if (h->got.refcount > 0)
- h->got.refcount--;
- }
- else
- {
- if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx]--;
- }
- break;
-
- case R_NDS32_16_RELA:
- case R_NDS32_20_RELA:
- case R_NDS32_5_RELA:
- case R_NDS32_32_RELA:
- case R_NDS32_HI20_RELA:
- case R_NDS32_LO12S3_RELA:
- case R_NDS32_LO12S2_RELA:
- case R_NDS32_LO12S2_DP_RELA:
- case R_NDS32_LO12S2_SP_RELA:
- case R_NDS32_LO12S1_RELA:
- case R_NDS32_LO12S0_RELA:
- case R_NDS32_LO12S0_ORI_RELA:
- case R_NDS32_SDA16S3_RELA:
- case R_NDS32_SDA17S2_RELA:
- case R_NDS32_SDA18S1_RELA:
- case R_NDS32_SDA19S0_RELA:
- case R_NDS32_SDA15S3_RELA:
- case R_NDS32_SDA15S2_RELA:
- case R_NDS32_SDA12S2_DP_RELA:
- case R_NDS32_SDA12S2_SP_RELA:
- case R_NDS32_SDA15S1_RELA:
- case R_NDS32_SDA15S0_RELA:
- case R_NDS32_SDA_FP7U2_RELA:
- case R_NDS32_15_PCREL_RELA:
- case R_NDS32_17_PCREL_RELA:
- case R_NDS32_25_PCREL_RELA:
- if (h != NULL)
- {
- struct elf_nds32_link_hash_entry *eh;
- struct elf_nds32_dyn_relocs **pp;
- struct elf_nds32_dyn_relocs *p;
-
- if (!bfd_link_pic (info) && h->plt.refcount > 0)
- h->plt.refcount -= 1;
-
- eh = (struct elf_nds32_link_hash_entry *) h;
-
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
- if (p->sec == sec)
- {
- if (ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
- || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
- || ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA)
- p->pc_count -= 1;
- p->count -= 1;
- if (p->count == 0)
- *pp = p->next;
- break;
- }
- }
- break;
-
- case R_NDS32_9_PLTREL:
- case R_NDS32_25_PLTREL:
- if (h != NULL)
- {
- if (h->plt.refcount > 0)
- h->plt.refcount--;
- }
- break;
-
- default:
- break;
- }
- }
-
- 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. */
if (bfd_link_relocatable (info))
return TRUE;
+ /* Don't do anything special with non-loaded, non-alloced sections.
+ In particular, any relocs in such sections should not affect GOT
+ and PLT reference counting (ie. we don't allow them to create GOT
+ or PLT entries), there's no possibility or desire to optimize TLS
+ relocs, and there's not much point in propagating relocs to shared
+ libs that the dynamic linker won't relocate. */
+ if ((sec->flags & SEC_ALLOC) == 0)
+ return TRUE;
+
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
sym_hashes_end =
&& (h->root.type == bfd_link_hash_defweak
|| !h->def_regular)))
{
- struct elf_nds32_dyn_relocs *p;
- struct elf_nds32_dyn_relocs **head;
+ struct elf_dyn_relocs *p;
+ struct elf_dyn_relocs **head;
if (dynobj == NULL)
htab->root.dynobj = dynobj = abfd;
return FALSE;
vpp = &elf_section_data (s)->local_dynrel;
- head = (struct elf_nds32_dyn_relocs **) vpp;
+ head = (struct elf_dyn_relocs **) vpp;
}
p = *head;
if (p == NULL || p->sec != sec)
{
bfd_size_type amt = sizeof (*p);
- p = (struct elf_nds32_dyn_relocs *) bfd_alloc (dynobj, amt);
+ p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
if (p == NULL)
return FALSE;
p->next = *head;
if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
goto done;
- if ((insn & __BIT (14)) == 0)
+ if ((insn & N32_BIT (14)) == 0)
{
/* N32_BR1_BEQ */
if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
break;
case N32_OP6_JI:
- if ((insn & __BIT (24)) == 0)
+ if ((insn & N32_BIT (24)) == 0)
{
/* N32_JI_J */
if (IS_WITHIN_S (N32_IMM24S (insn), 8))
insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
goto done;
case 0x34: /* beqzs8, bnezs8 */
- if (insn16 & __BIT (8))
+ if (insn16 & N32_BIT (8))
insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
else
insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
switch (__GF (insn16, 11, 4))
{
case 0x7: /* lwi37.fp/swi37.fp */
- if (insn16 & __BIT (7)) /* swi37.fp */
+ if (insn16 & N32_BIT (7)) /* swi37.fp */
insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
else /* lwi37.fp */
insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
break;
case N32_OP6_LBSI:
/* lbsi.gp */
- oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
+ oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
break;
case N32_OP6_SBI:
/* sbi.gp */
break;
case N32_OP6_ORI:
/* addi.gp */
- oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
+ oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
break;
}
break;
break;
case N32_OP6_LHSI:
/* lhsi.gp */
- oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
+ oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
break;
case N32_OP6_SHI:
/* shi.gp */
- oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
+ oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
break;
}
break;
unsigned long before, between;
bfd_byte *endp, *p;
- val = read_unsigned_leb128 (abfd, contents + irel->r_offset,
- &len);
+ val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
+ &len);
before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
between = get_nds32_elf_blank_total (&blank_t,
static const char * unrecognized_reloc_msg =
/* xgettext:c-format */
- N_("%B: warning: %s points to unrecognized reloc at 0x%lx.");
+ N_("%B: warning: %s points to unrecognized reloc at %#Lx");
/* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
{
/* There are 3 variations for LONGCALL1
case 4-4-2; 16-bit on, optimize off or optimize for space
- sethi ta, hi20(symbol) ; LONGCALL1/HI20
+ sethi ta, hi20(symbol) ; LONGCALL1/HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jral5 ta ;
+ jral5 ta ;
case 4-4-4; 16-bit off, optimize don't care
- sethi ta, hi20(symbol) ; LONGCALL1/HI20
+ sethi ta, hi20(symbol) ; LONGCALL1/HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jral ta ;
+ jral ta ;
case 4-4-4; 16-bit on, optimize for speed
- sethi ta, hi20(symbol) ; LONGCALL1/HI20
+ sethi ta, hi20(symbol) ; LONGCALL1/HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jral ta ;
+ jral ta ;
Check code for -mlong-calls output. */
/* Get the reloc for the address from which the register is
if (hi_irelfn == irelend || lo_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (i1_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
{
/* There are 3 variations for LONGCALL3
case 4-4-4-2; 16-bit on, optimize off or optimize for space
- bltz rt, $1 ; LONGCALL3
- sethi ta, hi20(symbol) ; HI20
+ bltz rt, $1 ; LONGCALL3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jral5 ta ;
+ jral5 ta ;
$1
case 4-4-4-4; 16-bit off, optimize don't care
- bltz rt, $1 ; LONGCALL3
- sethi ta, hi20(symbol) ; HI20
+ bltz rt, $1 ; LONGCALL3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jral ta ;
+ jral ta ;
$1
case 4-4-4-4; 16-bit on, optimize for speed
- bltz rt, $1 ; LONGCALL3
- sethi ta, hi20(symbol) ; HI20
+ bltz rt, $1 ; LONGCALL3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jral ta ;
+ jral ta ;
$1 */
/* Get the reloc for the address from which the register is
if (hi_irelfn == irelend || lo_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
{
/* There are 3 variations for LONGJUMP1
case 4-4-2; 16-bit bit on, optimize off or optimize for space
- sethi ta, hi20(symbol) ; LONGJUMP1/HI20
- ori ta, ta, lo12(symbol) ; LO12S0
- jr5 ta ;
+ sethi ta, hi20(symbol) ; LONGJUMP1/HI20
+ ori ta, ta, lo12(symbol) ; LO12S0
+ jr5 ta ;
case 4-4-4; 16-bit off, optimize don't care
- sethi ta, hi20(symbol) ; LONGJUMP1/HI20
- ori ta, ta, lo12(symbol) ; LO12S0
- jr ta ;
+ sethi ta, hi20(symbol) ; LONGJUMP1/HI20
+ ori ta, ta, lo12(symbol) ; LO12S0
+ jr ta ;
case 4-4-4; 16-bit on, optimize for speed
- sethi ta, hi20(symbol) ; LONGJUMP1/HI20
- ori ta, ta, lo12(symbol) ; LO12S0
- jr ta ; */
+ sethi ta, hi20(symbol) ; LONGJUMP1/HI20
+ ori ta, ta, lo12(symbol) ; LO12S0
+ jr ta ; */
/* Get the reloc for the address from which the register is
being loaded. This reloc will tell us which function is
if (hi_irelfn == irelend || lo_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (i2_irelfn == irelend || cond_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
/* There are 5 variations for LONGJUMP3
case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
optimize off or optimize for space
- bnes38 rt, ra, $1 ; LONGJUMP3
- sethi ta, hi20(symbol) ; HI20
+ bnes38 rt, ra, $1 ; LONGJUMP3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jr5 ta ;
- $1: ;
+ jr5 ta ;
+ $1: ;
case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
- bnes38 rt, ra, $1 ; LONGJUMP3
- sethi ta, hi20(symbol) ; HI20
+ bnes38 rt, ra, $1 ; LONGJUMP3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jr5 ta ;
- $1: ; LABEL
+ jr5 ta ;
+ $1: ; LABEL
case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
optimize off or optimize for space
- bne rt, ra, $1 ; LONGJUMP3
- sethi ta, hi20(symbol) ; HI20
+ bne rt, ra, $1 ; LONGJUMP3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jr5 ta ;
- $1: ;
+ jr5 ta ;
+ $1: ;
case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
16-bit off if no INSN16
- bne rt, ra, $1 ; LONGJUMP3
- sethi ta, hi20(symbol) ; HI20
+ bne rt, ra, $1 ; LONGJUMP3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jr ta ;
- $1: ;
+ jr ta ;
+ $1: ;
case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
16-bit off if no INSN16
- bne rt, ra, $1 ; LONGJUMP3
- sethi ta, hi20(symbol) ; HI20
+ bne rt, ra, $1 ; LONGJUMP3
+ sethi ta, hi20(symbol) ; HI20
ori ta, ta, lo12(symbol) ; LO12S0
- jr ta ;
- $1: ; LABEL */
+ jr ta ;
+ $1: ; LABEL */
/* Get the reloc for the address from which the register is
being loaded. This reloc will tell us which function is
if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (hi_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (ptr_irel == irelend || em_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
/* Check these is enough space to insert jal in R_NDS32_EMPTY. */
if (cond_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (em_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (cond_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd,
- "R_NDS32_LONGCALL6", (long) irel->r_offset);
+ "R_NDS32_LONGCALL6", irel->r_offset);
return FALSE;
}
cond_irel->r_addend = 1;
if (cond_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd,
- "R_NDS32_LONGCALL6", (long) irel->r_offset);
+ "R_NDS32_LONGCALL6", irel->r_offset);
return FALSE;
}
cond_irel->r_addend = 1;
if (hi_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (ptr_irel == irelend || em_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (cond_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (em_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (cond_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
if (hi_irelfn == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
{
/* Local TLS non-pic
- sethi ta, hi20(symbol@tpoff) ; TLS_LE_HI20
+ sethi ta, hi20(symbol@tpoff) ; TLS_LE_HI20
ori ta, ta, lo12(symbol@tpoff) ; TLS_LE_LO12
- add ra, ta, tp ; TLS_LE_ADD */
+ add ra, ta, tp ; TLS_LE_ADD */
uint32_t insn;
bfd_vma laddr;
if (re_irel == irelend)
{
_bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
- (long) irel->r_offset);
+ irel->r_offset);
return FALSE;
}
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
R_NDS32_PLT_GOTREL_LO19);
/* addi.gp */
- insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
+ insn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
}
else if (N32_OP6 (insn) == N32_OP6_JREG
&& N32_SUB5 (insn) == N32_JREG_JRAL)
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
break;
case (N32_OP6_MEM << 8) | N32_MEM_LHS:
- insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
+ insn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
irel->r_info =
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
break;
case (N32_OP6_MEM << 8) | N32_MEM_SH:
- insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
+ insn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
irel->r_info =
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
break;
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
break;
case (N32_OP6_MEM << 8) | N32_MEM_LBS:
- insn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
+ insn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
irel->r_info =
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
break;
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
break;
case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
- insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
+ insn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
irel->r_info =
ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
break;
of instruction a time.
It recognizes three types of relocations.
- 1. R_NDS32_LABEL - a aligment.
+ 1. R_NDS32_LABEL - a alignment.
2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
3. is_16bit_NOP () - remove a 16-bit instruction. */
- /* TODO: It seems currently implementation only support 4-byte aligment.
- We should handle any-aligment. */
+ /* TODO: It seems currently implementation only support 4-byte alignment.
+ We should handle any-alignment. */
Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
* no reloc entry. */
if (bfd_link_relocatable (link_info)
|| (sec->flags & SEC_RELOC) == 0
- || (sec->flags & SEC_EXCLUDE) == 1
+ || (sec->flags & SEC_EXCLUDE) != 0
|| (sec->flags & SEC_CODE) == 0
|| sec->size == 0)
return TRUE;
irelend, isymbuf))
goto error_return;
- if (*again == FALSE)
+ if (!*again)
{
if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
irelend))
nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
- if (*again == FALSE)
+ if (!*again)
{
if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
&relax_blank_list, optimize, opt_size))
relax_blank_list = NULL;
}
- if (*again == FALSE)
+ if (!*again)
{
/* Closing the section, so we don't relax it anymore. */
bfd_vma sec_size_align;
{
int num = 0;
bfd_byte *contents;
- unsigned long insn;
FILE *ex9_import_file;
int update_ex9_table;
struct elf_nds32_link_hash_table *table;
/* Read instructions from the input file and build the list. */
while (!feof (ex9_import_file))
{
+ unsigned long insn;
char *code;
struct elf_nds32_insn_times_entry *ptr;
size_t nread;
break;
insn = bfd_getb32 (contents);
code = bfd_malloc (sizeof (char) * 9);
- snprintf (code, 9, "%08lx", insn);
+ snprintf (code, 9, "%08lx", (insn & 0xffffffff));
ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
ptr->string = code;
ptr->order = num;
/* Incorrect alignment. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%s: warning: unaligned small data access. "
- "For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
- bfd_get_filename (abfd), irel->r_offset,
+ (_("%B: warning: unaligned small data access "
+ "for entry: {%Ld, %Ld, %Ld}, addr = %#Lx, align = %#x"),
+ abfd, irel->r_offset,
irel->r_info, irel->r_addend, relocation, align);
off += 4;
continue;
if (entry == NULL)
{
_bfd_error_handler
- (_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
+ (_("failed creating ex9.it %s hash table entry"), code);
return FALSE;
}
if (h)
#define ELF_ARCH bfd_arch_nds32
#define ELF_MACHINE_CODE EM_NDS32
#define ELF_MAXPAGESIZE 0x1000
-#define ELF_TARGET_ID NDS32_ELF_DATA
+#define ELF_TARGET_ID NDS32_ELF_DATA
#define TARGET_BIG_SYM nds32_elf32_be_vec
#define TARGET_BIG_NAME "elf32-nds32be"
#define bfd_elf32_bfd_relax_section nds32_elf_relax_section
#define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
-#define bfd_elf32_mkobject nds32_elf_mkobject
+#define bfd_elf32_mkobject nds32_elf_mkobject
#define elf_backend_action_discarded nds32_elf_action_discarded
#define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
#define elf_backend_check_relocs nds32_elf_check_relocs
#define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
#define elf_backend_relocate_section nds32_elf_relocate_section
#define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
-#define elf_backend_gc_sweep_hook nds32_elf_gc_sweep_hook
#define elf_backend_grok_prstatus nds32_elf_grok_prstatus
#define elf_backend_grok_psinfo nds32_elf_grok_psinfo
#define elf_backend_reloc_type_class nds32_elf_reloc_type_class
#define elf_backend_final_write_processing nds32_elf_final_write_processing
#define elf_backend_special_sections nds32_elf_special_sections
#define bfd_elf32_bfd_get_relocated_section_contents \
- nds32_elf_get_relocated_section_contents
+ nds32_elf_get_relocated_section_contents
#define elf_backend_can_gc_sections 1
#define elf_backend_can_refcount 1
projects / deliverable / binutils-gdb.git / blobdiff