/* IQ2000-specific support for 32-bit ELF.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003-2018 Free Software Foundation, Inc.
-This file is part of BFD, the Binary File Descriptor library.
+ This file is part of BFD, the Binary File Descriptor library.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/iq2000.h"
+#include "libiberty.h"
/* Forward declarations. */
-/* Private relocation functions. */
-static bfd_reloc_status_type iq2000_elf_relocate_hi16 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
-static reloc_howto_type * iq2000_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
-static void iq2000_info_to_howto_rela PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
-static bfd_boolean iq2000_elf_relocate_section PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
-static bfd_reloc_status_type iq2000_final_link_relocate PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma));
-static bfd_boolean iq2000_elf_gc_sweep_hook PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
-static asection * iq2000_elf_gc_mark_hook PARAMS ((asection *sec, struct bfd_link_info *, Elf_Internal_Rela *, struct elf_link_hash_entry *, Elf_Internal_Sym *));
-static reloc_howto_type * iq2000_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
-static int elf32_iq2000_machine PARAMS ((bfd *));
-static bfd_boolean iq2000_elf_object_p PARAMS ((bfd *));
-static bfd_boolean iq2000_elf_set_private_flags PARAMS ((bfd *, flagword));
-static bfd_boolean iq2000_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
-static bfd_boolean iq2000_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
-static bfd_boolean iq2000_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
-static bfd_boolean iq2000_elf_check_relocs PARAMS ((bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *));
-static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
\f
static reloc_howto_type iq2000_elf_howto_table [] =
HOWTO (R_IQ2000_NONE, /* type */
0, /* rightshift */
- 2, /* size (0 = byte, 1 = short, 2 = long) */
- 32, /* bitsize */
+ 3, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
FALSE, /* pc_relative */
0, /* bitpos */
- complain_overflow_bitfield, /* complain_on_overflow */
+ complain_overflow_dont, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_IQ2000_NONE", /* name */
FALSE, /* partial_inplace */
FALSE); /* pcrel_offset */
\f
-/* Map BFD reloc types to IQ2000 ELF reloc types. */
-
-struct iq2000_reloc_map
-{
- bfd_reloc_code_real_type bfd_reloc_val;
- unsigned int iq2000_reloc_val;
-};
-
-static const struct iq2000_reloc_map iq2000_reloc_map [] =
-{
- { BFD_RELOC_NONE, R_IQ2000_NONE },
- { BFD_RELOC_16, R_IQ2000_16 },
- { BFD_RELOC_32, R_IQ2000_32 },
- { BFD_RELOC_MIPS_JMP, R_IQ2000_26 },
- { BFD_RELOC_16_PCREL_S2, R_IQ2000_PC16 },
- { BFD_RELOC_HI16, R_IQ2000_HI16 },
- { BFD_RELOC_LO16, R_IQ2000_LO16 },
- { BFD_RELOC_IQ2000_OFFSET_16,R_IQ2000_OFFSET_16 },
- { BFD_RELOC_IQ2000_OFFSET_21,R_IQ2000_OFFSET_21 },
- { BFD_RELOC_IQ2000_UHI16, R_IQ2000_UHI16 },
- { BFD_RELOC_VTABLE_INHERIT, R_IQ2000_GNU_VTINHERIT },
- { BFD_RELOC_VTABLE_ENTRY, R_IQ2000_GNU_VTENTRY },
-};
-
static bfd_reloc_status_type
-iq2000_elf_howto_hi16_reloc (abfd,
- reloc_entry,
- symbol,
- data,
- input_section,
- output_bfd,
- error_message)
- bfd *abfd ATTRIBUTE_UNUSED;
- arelent *reloc_entry;
- asymbol *symbol;
- PTR data;
- asection *input_section;
- bfd *output_bfd;
- char **error_message ATTRIBUTE_UNUSED;
+iq2000_elf_howto_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
+ arelent *reloc_entry,
+ asymbol *symbol,
+ void * data,
+ asection *input_section,
+ bfd *output_bfd,
+ char **error_message ATTRIBUTE_UNUSED)
{
bfd_reloc_status_type ret;
bfd_vma relocation;
- /* If we're relocating, and this an external symbol, we don't want
- to change anything. */
+ /* If we're relocating and this an external symbol,
+ we don't want to change anything. */
if (output_bfd != (bfd *) NULL
&& (symbol->flags & BSF_SECTION_SYM) == 0
&& reloc_entry->addend == 0)
relocation += symbol->section->output_offset;
relocation += reloc_entry->addend;
- /* if %lo will have sign-extension, compensate by add 0x10000 to hi portion */
+ /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion. */
if (relocation & 0x8000)
reloc_entry->addend += 0x10000;
ret = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
input_section, output_bfd, error_message);
- /* put it back the way it was */
+ /* Put it back the way it was. */
if (relocation & 0x8000)
reloc_entry->addend -= 0x10000;
}
static bfd_reloc_status_type
-iq2000_elf_relocate_hi16 (input_bfd, relhi, contents, value)
- bfd *input_bfd;
- Elf_Internal_Rela *relhi;
- bfd_byte *contents;
- bfd_vma value;
+iq2000_elf_relocate_hi16 (bfd *input_bfd,
+ Elf_Internal_Rela *relhi,
+ bfd_byte *contents,
+ bfd_vma value)
{
bfd_vma insn;
insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
-
+
value += relhi->r_addend;
- value &= 0x7fffffff; /* mask off top-bit which is Harvard mask bit */
+ value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit. */
- /* if top-bit of %lo value is on, this means that %lo will
- sign-propagate and so we compensate by adding 1 to %hi value */
+ /* If top-bit of %lo value is on, this means that %lo will
+ sign-propagate and so we compensate by adding 1 to %hi value. */
if (value & 0x8000)
value += 0x10000;
- value >>= 16;
+ value >>= 16;
insn = ((insn & ~0xFFFF) | value);
bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
return bfd_reloc_ok;
}
+static bfd_reloc_status_type
+iq2000_elf_relocate_offset16 (bfd *input_bfd,
+ Elf_Internal_Rela *rel,
+ bfd_byte *contents,
+ bfd_vma value,
+ bfd_vma location)
+{
+ bfd_vma insn;
+ bfd_vma jtarget;
+
+ insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
+
+ value += rel->r_addend;
+
+ if (value & 3)
+ return bfd_reloc_dangerous;
+
+ jtarget = (value & 0x3fffc) | (location & 0xf0000000L);
+
+ if (jtarget != value)
+ return bfd_reloc_overflow;
+
+ insn = (insn & ~0xFFFF) | ((value >> 2) & 0xFFFF);
+
+ bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
+ return bfd_reloc_ok;
+}
+
+/* Map BFD reloc types to IQ2000 ELF reloc types. */
+
static reloc_howto_type *
-iq2000_reloc_type_lookup (abfd, code)
- bfd * abfd ATTRIBUTE_UNUSED;
- bfd_reloc_code_real_type code;
+iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_reloc_code_real_type code)
{
/* Note that the iq2000_elf_howto_table is indxed by the R_
constants. Thus, the order that the howto records appear in the
return NULL;
}
+static reloc_howto_type *
+iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
+{
+ unsigned int i;
+
+ for (i = 0;
+ i < (sizeof (iq2000_elf_howto_table)
+ / sizeof (iq2000_elf_howto_table[0]));
+ i++)
+ if (iq2000_elf_howto_table[i].name != NULL
+ && strcasecmp (iq2000_elf_howto_table[i].name, r_name) == 0)
+ return &iq2000_elf_howto_table[i];
+
+ if (strcasecmp (iq2000_elf_vtinherit_howto.name, r_name) == 0)
+ return &iq2000_elf_vtinherit_howto;
+ if (strcasecmp (iq2000_elf_vtentry_howto.name, r_name) == 0)
+ return &iq2000_elf_vtentry_howto;
+
+ return NULL;
+}
\f
/* Perform a single relocation. By default we use the standard BFD
routines. */
static bfd_reloc_status_type
-iq2000_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;
+iq2000_final_link_relocate (reloc_howto_type * howto,
+ bfd * input_bfd,
+ asection * input_section,
+ bfd_byte * contents,
+ Elf_Internal_Rela * rel,
+ bfd_vma relocation)
{
return _bfd_final_link_relocate (howto, input_bfd, input_section,
contents, rel->r_offset,
\f
/* Set the howto pointer for a IQ2000 ELF reloc. */
-static void
-iq2000_info_to_howto_rela (abfd, cache_ptr, dst)
- bfd * abfd ATTRIBUTE_UNUSED;
- arelent * cache_ptr;
- Elf_Internal_Rela * dst;
+static bfd_boolean
+iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
+ arelent * cache_ptr,
+ Elf_Internal_Rela * dst)
{
unsigned int r_type;
break;
default:
+ if (r_type >= ARRAY_SIZE (iq2000_elf_howto_table))
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
cache_ptr->howto = & iq2000_elf_howto_table [r_type];
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. */
-
+
static bfd_boolean
-iq2000_elf_check_relocs (abfd, info, sec, relocs)
- bfd *abfd;
- struct bfd_link_info *info;
- asection *sec;
- const Elf_Internal_Rela *relocs;
+iq2000_elf_check_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;
+ struct elf_link_hash_entry **sym_hashes;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
bfd_boolean changed = FALSE;
-
- if (info->relocateable)
+
+ if (bfd_link_relocatable (info))
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];
-
+ {
+ 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))
{
- /* This relocation describes the C++ object vtable hierarchy.
- Reconstruct it for later use during GC. */
+ /* This relocation describes the C++ object vtable
+ hierarchy. Reconstruct it for later use during GC. */
case R_IQ2000_GNU_VTINHERIT:
- if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+ if (!bfd_elf_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. */
+
+ /* This relocation describes which C++ vtable entries
+ are actually used. Record for later use during GC. */
case R_IQ2000_GNU_VTENTRY:
- if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ BFD_ASSERT (h != NULL);
+ if (h != NULL
+ && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
return FALSE;
break;
case R_IQ2000_32:
- /* For debug section, change to special harvard-aware relocations */
- if (memcmp (sec->name, ".debug", 6) == 0
- || memcmp (sec->name, ".stab", 5) == 0
- || memcmp (sec->name, ".eh_frame", 9) == 0)
+ /* For debug section, change to special harvard-aware relocations. */
+ if (CONST_STRNEQ (sec->name, ".debug")
+ || CONST_STRNEQ (sec->name, ".stab")
+ || CONST_STRNEQ (sec->name, ".eh_frame"))
{
((Elf_Internal_Rela *) rel)->r_info
= ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
if (changed)
/* Note that we've changed relocs, otherwise if !info->keep_memory
we'll free the relocs and lose our changes. */
- (const Elf_Internal_Rela *) (elf_section_data (sec)->relocs) = relocs;
+ elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
return TRUE;
}
zero.
This function is responsible for adjusting the section contents as
- necessary, and (if using Rela relocs and generating a relocateable
+ necessary, and (if using Rela relocs and generating a relocatable
output file) adjusting the reloc addend as necessary.
This function does not have to worry about setting the reloc
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
+ When generating relocatable 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 bfd_boolean
-iq2000_elf_relocate_section (output_bfd, info, input_bfd, input_section,
- contents, relocs, local_syms, local_sections)
- 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;
+iq2000_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)
{
Elf_Internal_Shdr * symtab_hdr;
struct elf_link_hash_entry ** sym_hashes;
bfd_reloc_status_type r;
const char * name = NULL;
int r_type;
-
+
r_type = ELF32_R_TYPE (rel->r_info);
-
+
if ( r_type == R_IQ2000_GNU_VTINHERIT
|| r_type == R_IQ2000_GNU_VTENTRY)
continue;
-
+
r_symndx = ELF32_R_SYM (rel->r_info);
- /* This is a final link. */
howto = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
h = NULL;
sym = NULL;
sec = NULL;
-
+
if (r_symndx < symtab_hdr->sh_info)
{
+ asection *osec;
+
sym = local_syms + r_symndx;
- sec = local_sections [r_symndx];
+ osec = sec = local_sections [r_symndx];
+ if ((sec->flags & SEC_MERGE)
+ && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+ /* This relocation is relative to a section symbol that is
+ going to be merged. Change it so that it is relative
+ to the merged section symbol. */
+ rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym, &sec,
+ rel->r_addend);
+
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 = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
-#ifdef DEBUG
- fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
- sec->name, name, sym->st_name,
- sec->output_section->vma, sec->output_offset,
- sym->st_value, rel->r_addend);
-#endif
+ name = (name == NULL) ? bfd_section_name (input_bfd, osec) : name;
}
else
{
- h = sym_hashes [r_symndx];
-
- 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;
+ bfd_boolean unresolved_reloc;
+ bfd_boolean warned, ignored;
+
+ RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
+ r_symndx, symtab_hdr, sym_hashes,
+ h, sec, relocation,
+ unresolved_reloc, warned, ignored);
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);
-#ifdef DEBUG
- fprintf (stderr,
- "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
- sec->name, name, h->root.u.def.value,
- sec->output_section->vma, sec->output_offset, relocation);
-#endif
- }
- else if (h->root.type == bfd_link_hash_undefweak)
- {
-#ifdef DEBUG
- fprintf (stderr, "undefined: sec: %s, name: %s\n",
- sec->name, name);
-#endif
- relocation = 0;
- }
- else
- {
- if (! ((*info->callbacks->undefined_symbol)
- (info, h->root.root.string, input_bfd,
- input_section, rel->r_offset,
- (!info->shared || info->no_undefined))))
- return FALSE;
-#ifdef DEBUG
- fprintf (stderr, "unknown: name: %s\n", name);
-#endif
- relocation = 0;
- }
}
+ if (sec != NULL && discarded_section (sec))
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rel, 1, relend, howto, 0, contents);
+
+ if (bfd_link_relocatable (info))
+ continue;
+
switch (r_type)
{
case R_IQ2000_HI16:
r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
break;
+ case R_IQ2000_OFFSET_16:
+ r = iq2000_elf_relocate_offset16 (input_bfd, rel, contents, relocation,
+ input_section->output_section->vma
+ + input_section->output_offset
+ + rel->r_offset);
+ break;
+
case R_IQ2000_PC16:
rel->r_addend -= 4;
/* Fall through. */
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);
+ (*info->callbacks->reloc_overflow)
+ (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->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;
}
if (msg)
- r = info->callbacks->warning
- (info, msg, name, input_bfd, input_section, rel->r_offset);
-
- if (! r)
- return FALSE;
+ (*info->callbacks->warning) (info, msg, name, input_bfd,
+ input_section, rel->r_offset);
}
}
}
\f
-/* Update the got entry reference counts for the section being
- removed. */
-
-static bfd_boolean
-iq2000_elf_gc_sweep_hook (abfd, info, sec, relocs)
- bfd * abfd ATTRIBUTE_UNUSED;
- struct bfd_link_info * info ATTRIBUTE_UNUSED;
- asection * sec ATTRIBUTE_UNUSED;
- const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
-{
- return TRUE;
-}
-
/* Return the section that should be marked against GC for a given
relocation. */
static asection *
-iq2000_elf_gc_mark_hook (sec, info, rel, h, sym)
- asection * sec;
- struct bfd_link_info * info ATTRIBUTE_UNUSED;
- Elf_Internal_Rela * rel;
- struct elf_link_hash_entry * h;
- Elf_Internal_Sym * sym;
+iq2000_elf_gc_mark_hook (asection *sec,
+ struct bfd_link_info *info,
+ Elf_Internal_Rela *rel,
+ struct elf_link_hash_entry *h,
+ Elf_Internal_Sym *sym)
{
if (h != NULL)
- {
- switch (ELF32_R_TYPE (rel->r_info))
- {
- case R_IQ2000_GNU_VTINHERIT:
- case R_IQ2000_GNU_VTENTRY:
- break;
-
- default:
- switch (h->root.type)
- {
- case bfd_link_hash_defined:
- case bfd_link_hash_defweak:
- return h->root.u.def.section;
-
- case bfd_link_hash_common:
- return h->root.u.c.p->section;
-
- default:
- break;
- }
- }
- }
- else
- return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
-
- return NULL;
+ switch (ELF32_R_TYPE (rel->r_info))
+ {
+ case R_IQ2000_GNU_VTINHERIT:
+ case R_IQ2000_GNU_VTENTRY:
+ return NULL;
+ }
+
+ return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}
\f
/* Return the MACH for an e_flags value. */
static int
-elf32_iq2000_machine (abfd)
- bfd *abfd;
+elf32_iq2000_machine (bfd *abfd)
{
switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
{
- case EF_IQ2000_CPU_IQ2000: return bfd_mach_iq2000;
- case EF_IQ2000_CPU_IQ10: return bfd_mach_iq10;
- }
+ case EF_IQ2000_CPU_IQ10:
+ return bfd_mach_iq10;
- return bfd_mach_iq2000;
+ case EF_IQ2000_CPU_IQ2000:
+ default:
+ return bfd_mach_iq2000;
+ }
}
\f
/* Function to set the ELF flag bits. */
static bfd_boolean
-iq2000_elf_set_private_flags (abfd, flags)
- bfd *abfd;
- flagword flags;
+iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
{
elf_elfheader (abfd)->e_flags = flags;
elf_flags_init (abfd) = TRUE;
return TRUE;
}
-/* Copy backend specific data from one object module to another. */
-
-static bfd_boolean
-iq2000_elf_copy_private_bfd_data (ibfd, obfd)
- bfd *ibfd;
- bfd *obfd;
-{
- if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
- || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return TRUE;
-
- BFD_ASSERT (!elf_flags_init (obfd)
- || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
-
- elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
- elf_flags_init (obfd) = TRUE;
- return TRUE;
-}
-
-/* Merge backend specific data from an object file to the output
- object file when linking. */
+/* Merge backend specific data from an object
+ file to the output object file when linking. */
static bfd_boolean
-iq2000_elf_merge_private_bfd_data (ibfd, obfd)
- bfd *ibfd;
- bfd *obfd;
+iq2000_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
flagword old_flags, old_partial;
flagword new_flags, new_partial;
bfd_boolean error = FALSE;
new_flags = elf_elfheader (ibfd)->e_flags;
old_flags = elf_elfheader (obfd)->e_flags;
-#ifdef DEBUG
- (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
- old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
- bfd_get_filename (ibfd));
-#endif
-
if (!elf_flags_init (obfd))
{
/* First call, no flags set. */
elf_elfheader (obfd)->e_flags = new_flags;
}
- else if (new_flags == old_flags)
- /* Compatible flags are ok. */
- ;
-
- else /* Possibly incompatible flags. */
+ else if (new_flags != old_flags)
{
- /* Warn if different cpu is used (allow a specific cpu to override
- the generic cpu). */
+ /* Warn if different cpu is used, but allow a
+ specific cpu to override the generic cpu. */
new_partial = (new_flags & EF_IQ2000_CPU_MASK);
old_partial = (old_flags & EF_IQ2000_CPU_MASK);
- if (new_partial == old_partial)
- ;
- else
+ if (new_partial != old_partial)
{
switch (new_partial)
{
- default: strcat (new_opt, " -m2000"); break;
- case EF_IQ2000_CPU_IQ2000: strcat (new_opt, " -m2000"); break;
- case EF_IQ2000_CPU_IQ10: strcat (new_opt, " -m10"); break;
+ case EF_IQ2000_CPU_IQ10:
+ strcat (new_opt, " -m10");
+ break;
+
+ default:
+ case EF_IQ2000_CPU_IQ2000:
+ strcat (new_opt, " -m2000");
+ break;
}
switch (old_partial)
{
- default: strcat (old_opt, " -m2000"); break;
- case EF_IQ2000_CPU_IQ2000: strcat (old_opt, " -m2000"); break;
- case EF_IQ2000_CPU_IQ10: strcat (old_opt, " -m10"); break;
+ case EF_IQ2000_CPU_IQ10:
+ strcat (old_opt, " -m10");
+ break;
+
+ default:
+ case EF_IQ2000_CPU_IQ2000:
+ strcat (old_opt, " -m2000");
+ break;
}
}
-
+
/* Print out any mismatches from above. */
if (new_opt[0])
{
error = TRUE;
- (*_bfd_error_handler)
- (_("%s: compiled with %s and linked with modules compiled with %s"),
- bfd_get_filename (ibfd), new_opt, old_opt);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: compiled with %s and linked with modules compiled with %s"),
+ ibfd, new_opt, old_opt);
}
new_flags &= ~ EF_IQ2000_ALL_FLAGS;
if (new_flags != old_flags)
{
error = TRUE;
- (*_bfd_error_handler)
- (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
- bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
+
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
+ ibfd, new_flags, old_flags);
}
}
\f
static bfd_boolean
-iq2000_elf_print_private_bfd_data (abfd, ptr)
- bfd *abfd;
- PTR ptr;
+iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
{
FILE *file = (FILE *) ptr;
flagword flags;
_bfd_elf_print_private_bfd_data (abfd, ptr);
flags = elf_elfheader (abfd)->e_flags;
- fprintf (file, _("private flags = 0x%lx:"), (long)flags);
+ fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
switch (flags & EF_IQ2000_CPU_MASK)
{
- default: break;
- case EF_IQ2000_CPU_IQ2000: fprintf (file, " -m2000"); break;
- case EF_IQ2000_CPU_IQ10: fprintf (file, " -m10"); break;
+ case EF_IQ2000_CPU_IQ10:
+ fprintf (file, " -m10");
+ break;
+ case EF_IQ2000_CPU_IQ2000:
+ fprintf (file, " -m2000");
+ break;
+ default:
+ break;
}
fputc ('\n', file);
static
bfd_boolean
-iq2000_elf_object_p (abfd)
- bfd *abfd;
+iq2000_elf_object_p (bfd *abfd)
{
- /* Irix 5 and 6 is broken. Object file symbol tables are not always
- sorted correctly such that local symbols precede global symbols,
- and the sh_info field in the symbol table is not always right. */
- elf_bad_symtab (abfd) = TRUE;
-
bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
elf32_iq2000_machine (abfd));
return TRUE;
#define ELF_MACHINE_CODE EM_IQ2000
#define ELF_MAXPAGESIZE 0x1000
-#define TARGET_BIG_SYM bfd_elf32_iq2000_vec
+#define TARGET_BIG_SYM iq2000_elf32_vec
#define TARGET_BIG_NAME "elf32-iq2000"
#define elf_info_to_howto_rel NULL
#define elf_info_to_howto iq2000_info_to_howto_rela
#define elf_backend_relocate_section iq2000_elf_relocate_section
#define elf_backend_gc_mark_hook iq2000_elf_gc_mark_hook
-#define elf_backend_gc_sweep_hook iq2000_elf_gc_sweep_hook
#define elf_backend_check_relocs iq2000_elf_check_relocs
#define elf_backend_object_p iq2000_elf_object_p
#define elf_backend_rela_normal 1
#define elf_backend_can_gc_sections 1
#define bfd_elf32_bfd_reloc_type_lookup iq2000_reloc_type_lookup
+#define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup
#define bfd_elf32_bfd_set_private_flags iq2000_elf_set_private_flags
-#define bfd_elf32_bfd_copy_private_bfd_data iq2000_elf_copy_private_bfd_data
#define bfd_elf32_bfd_merge_private_bfd_data iq2000_elf_merge_private_bfd_data
#define bfd_elf32_bfd_print_private_bfd_data iq2000_elf_print_private_bfd_data