/* M16C/M32C specific support for 32-bit ELF.
- Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
- Free Software Foundation, Inc.
+ Copyright (C) 2005-2014 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
/* Forward declarations. */
static reloc_howto_type * m32c_reloc_type_lookup
(bfd *, bfd_reloc_code_real_type);
-static void m32c_info_to_howto_rela
+static void m32c_info_to_howto_rela
(bfd *, arelent *, Elf_Internal_Rela *);
-static bfd_boolean m32c_elf_relocate_section
+static bfd_boolean m32c_elf_relocate_section
(bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
static bfd_boolean m32c_elf_check_relocs
(bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
for (i = ARRAY_SIZE (m32c_reloc_map); --i;)
if (m32c_reloc_map [i].bfd_reloc_val == code)
return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
-
+
return NULL;
}
bfd_reloc_status_type r;
const char * name = NULL;
int r_type;
-
+
r_type = ELF32_R_TYPE (rel->r_info);
/* These are only used for relaxing; we don't actually relocate
|| r_type == R_M32C_RL_1ADDR
|| r_type == R_M32C_RL_2ADDR)
continue;
-
+
r_symndx = ELF32_R_SYM (rel->r_info);
howto = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
relocation = (sec->output_section->vma
+ sec->output_offset
+ sym->st_value);
-
+
name = bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name);
name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
else
{
h = sym_hashes [r_symndx - symtab_hdr->sh_info];
-
+
+ if (info->wrap_hash != NULL
+ && (input_section->flags & SEC_DEBUGGING) != 0)
+ h = ((struct elf_link_hash_entry *)
+ unwrap_hash_lookup (info, input_bfd, &h->root));
+
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)
{
(info, (h ? &h->root : NULL), 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;
\f
/* We support 16-bit pointers to code above 64k by generating a thunk
below 64k containing a JMP instruction to the final address. */
-
+
static bfd_boolean
m32c_elf_check_relocs
(bfd * abfd,
bfd_vma *local_plt_offsets;
asection *splt;
bfd *dynobj;
-
+
if (info->relocatable)
return TRUE;
-
+
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
local_plt_offsets = elf_local_got_offsets (abfd);
struct elf_link_hash_entry *h;
unsigned long r_symndx;
bfd_vma *offset;
-
+
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
h = NULL;
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;
+
+ /* PR15323, ref flags aren't set for references in the same
+ object. */
+ h->root.non_ir_ref = 1;
}
-
+
switch (ELF32_R_TYPE (rel->r_info))
{
/* This relocation describes a 16-bit pointer to a function.
flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
| SEC_IN_MEMORY | SEC_LINKER_CREATED
| SEC_READONLY | SEC_CODE);
- splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
+ splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
+ flags);
if (splt == NULL
|| ! bfd_set_section_alignment (dynobj, splt, 1))
return FALSE;
break;
}
}
-
+
return TRUE;
}
case EF_M32C_CPU_M32C: strcat (old_opt, " -m32c"); break;
}
}
-
+
/* Print out any mismatches from above. */
if (new_opt[0])
{
\f
static bfd_boolean
-m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
+m32c_elf_print_private_bfd_data (bfd *abfd, void *ptr)
{
FILE *file = (FILE *) ptr;
flagword flags;
external_syms = bfd_malloc (1000);
free_external = 1;
}
-
+
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
if (free_internal)
{
switch (ELF_ST_TYPE (isym->st_info))
{
- case STT_FUNC: st_info_str = "STT_FUNC";
- case STT_SECTION: st_info_str = "STT_SECTION";
- case STT_FILE: st_info_str = "STT_FILE";
- case STT_OBJECT: st_info_str = "STT_OBJECT";
- case STT_TLS: st_info_str = "STT_TLS";
- default: st_info_str = "";
+ case STT_FUNC:
+ st_info_str = "STT_FUNC";
+ break;
+
+ case STT_SECTION:
+ st_info_str = "STT_SECTION";
+ break;
+
+ case STT_FILE:
+ st_info_str = "STT_FILE";
+ break;
+
+ case STT_OBJECT:
+ st_info_str = "STT_OBJECT";
+ break;
+
+ case STT_TLS:
+ st_info_str = "STT_TLS";
+ break;
+
+ default:
+ st_info_str = "";
}
+
switch (ELF_ST_BIND (isym->st_info))
{
- case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
- case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
- default: st_info_stb_str = "";
+ case STB_LOCAL:
+ st_info_stb_str = "STB_LOCAL";
+ break;
+
+ case STB_GLOBAL:
+ st_info_stb_str = "STB_GLOBAL";
+ break;
+
+ default:
+ st_info_stb_str = "";
}
+
switch (ELF_ST_VISIBILITY (isym->st_other))
{
- case STV_DEFAULT: st_other_str = "STV_DEFAULT";
- case STV_INTERNAL: st_other_str = "STV_INTERNAL";
- case STV_PROTECTED: st_other_str = "STV_PROTECTED";
- default: st_other_str = "";
+ case STV_DEFAULT:
+ st_other_str = "STV_DEFAULT";
+ break;
+
+ case STV_INTERNAL:
+ st_other_str = "STV_INTERNAL";
+ break;
+
+ case STV_PROTECTED:
+ st_other_str = "STV_PROTECTED";
+ break;
+
+ default:
+ st_other_str = "";
}
+
switch (isym->st_shndx)
{
- case SHN_ABS: st_shndx_str = "SHN_ABS";
- case SHN_COMMON: st_shndx_str = "SHN_COMMON";
- case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
- default: st_shndx_str = "";
+ case SHN_ABS:
+ st_shndx_str = "SHN_ABS";
+ break;
+
+ case SHN_COMMON:
+ st_shndx_str = "SHN_COMMON";
+ break;
+
+ case SHN_UNDEF:
+ st_shndx_str = "SHN_UNDEF";
+ break;
+
+ default:
+ st_shndx_str = "";
}
-
+
printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
"st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
- isym,
+ isym,
(unsigned long) isym->st_value,
(unsigned long) isym->st_size,
isym->st_name,
};
static bfd_boolean
-m32c_relax_plt_check (struct elf_link_hash_entry *h,
- PTR xdata)
+m32c_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
{
struct relax_plt_data *data = (struct relax_plt_data *) xdata;
previously had a plt entry, give it a new entry offset. */
static bfd_boolean
-m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
- PTR xdata)
+m32c_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
{
bfd_vma *entry = (bfd_vma *) xdata;
}
static bfd_boolean
-m32c_elf_relax_plt_section (bfd *dynobj,
- asection *splt,
+m32c_elf_relax_plt_section (asection *splt,
struct bfd_link_info *info,
bfd_boolean *again)
{
if (info->relocatable)
return TRUE;
- /* We only relax the .plt section at the moment. */
- if (dynobj != elf_hash_table (info)->dynobj
- || strcmp (splt->name, ".plt") != 0)
- return TRUE;
-
/* Quick check for an empty plt. */
if (splt->size == 0)
return TRUE;
/* Likewise for local symbols, though that's somewhat less convenient
as we have to walk the list of input bfds and swap in symbol data. */
- for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
Elf_Internal_Shdr *symtab_hdr;
elf_link_hash_traverse (elf_hash_table (info),
m32c_relax_plt_realloc, &entry);
- for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
{
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
int machine;
if (abfd == elf_hash_table (link_info)->dynobj
+ && (sec->flags & SEC_LINKER_CREATED) != 0
&& strcmp (sec->name, ".plt") == 0)
- return m32c_elf_relax_plt_section (abfd, sec, link_info, again);
+ return m32c_elf_relax_plt_section (sec, link_info, again);
/* Assume nothing changes. */
*again = FALSE;
if (shndx_buf == NULL)
goto error_return;
if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
- || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
+ || bfd_bread (shndx_buf, amt, abfd) != amt)
goto error_return;
shndx_hdr->contents = (bfd_byte *) shndx_buf;
}
/* Get a copy of the native relocations. */
internal_relocs = (_bfd_elf_link_read_relocs
- (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
+ (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
link_info->keep_memory));
if (internal_relocs == NULL)
goto error_return;
enctbl = m16c_addr_encodings;
posn = 2;
-
+
/* Check the opcode for jumps. We know it's safe to
do this because all 2ADDR insns are at least two
bytes long. */
/* Note that we've changed the relocs, section contents, etc. */
elf_section_data (sec)->relocs = internal_relocs;
free_relocs = NULL;
-
+
elf_section_data (sec)->this_hdr.contents = contents;
free_contents = NULL;
#define ELF_MAXPAGESIZE 0x100
#if 0
-#define TARGET_BIG_SYM bfd_elf32_m32c_vec
+#define TARGET_BIG_SYM m32c_elf32_vec
#define TARGET_BIG_NAME "elf32-m32c"
#else
-#define TARGET_LITTLE_SYM bfd_elf32_m32c_vec
+#define TARGET_LITTLE_SYM m32c_elf32_vec
#define TARGET_LITTLE_NAME "elf32-m32c"
#endif