[deliverable/binutils-gdb.git] / bfd / elf32-openrisc.c

/* OpenRISC-specific support for 32-bit ELF.
   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
   Free Software Foundation, Inc.
   Contributed by Johan Rydberg, jrydberg@opencores.org

   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 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.

   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 "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/openrisc.h"
#include "libiberty.h"

static reloc_howto_type openrisc_elf_howto_table[] =
{
  /* This reloc does nothing.  */
  HOWTO (R_OPENRISC_NONE,	/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_NONE",	/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A PC relative 26 bit relocation, right shifted by 2.  */
  HOWTO (R_OPENRISC_INSN_REL_26, /* type */
	 2,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 26,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_INSN_REL_26", /* name */
	 FALSE,			/* partial_inplace */
	 0x00000000,		/* src_mask */
	 0x03ffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A absolute 26 bit relocation, right shifted by 2.  */
  HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
	 2,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 26,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_INSN_ABS_26", /* name */
	 FALSE,			/* partial_inplace */
	 0x00000000,		/* src_mask */
	 0x03ffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_LO_16_IN_INSN", /* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
	 16,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont,	/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_HI_16_IN_INSN",	/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* An 8 bit absolute relocation.  */
  HOWTO (R_OPENRISC_8,		/* type */
	 0,			/* rightshift */
	 0,			/* size (0 = byte, 1 = short, 2 = long) */
	 8,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_8",	/* name */
	 TRUE,			/* partial_inplace */
	 0x0000,		/* src_mask */
	 0x00ff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A 16 bit absolute relocation.  */
  HOWTO (R_OPENRISC_16,		/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_16",	/* name */
	 TRUE,			/* partial_inplace */
	 0x00000000,		/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A 32 bit absolute relocation.  */
  HOWTO (R_OPENRISC_32,		/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_32",	/* name */
	 TRUE,			/* partial_inplace */
	 0x00000000,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* GNU extension to record C++ vtable hierarchy.  */
  HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 0,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 NULL,			/* special_function */
	 "R_OPENRISC_GNU_VTINHERIT", /* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* GNU extension to record C++ vtable member usage.  */
  HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 0,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
	 "R_OPENRISC_GNU_VTENTRY", /* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */
};

/* Map BFD reloc types to OpenRISC ELF reloc types.  */

struct openrisc_reloc_map
{
  bfd_reloc_code_real_type bfd_reloc_val;
  unsigned int openrisc_reloc_val;
};

static const struct openrisc_reloc_map openrisc_reloc_map[] =
{
  { BFD_RELOC_NONE, 		R_OPENRISC_NONE },
  { BFD_RELOC_32, 		R_OPENRISC_32 },
  { BFD_RELOC_16, 		R_OPENRISC_16 },
  { BFD_RELOC_8, 		R_OPENRISC_8 },
  { BFD_RELOC_OPENRISC_REL_26,	R_OPENRISC_INSN_REL_26 },
  { BFD_RELOC_OPENRISC_ABS_26,	R_OPENRISC_INSN_ABS_26 },
  { BFD_RELOC_HI16, 		R_OPENRISC_HI_16_IN_INSN },
  { BFD_RELOC_LO16, 		R_OPENRISC_LO_16_IN_INSN },
  { BFD_RELOC_VTABLE_INHERIT,	R_OPENRISC_GNU_VTINHERIT },
  { BFD_RELOC_VTABLE_ENTRY, 	R_OPENRISC_GNU_VTENTRY }
};

static reloc_howto_type *
openrisc_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
			    bfd_reloc_code_real_type code)
{
  unsigned int i;

  for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
    if (openrisc_reloc_map[i].bfd_reloc_val == code)
      return & openrisc_elf_howto_table[openrisc_reloc_map[i].
				       openrisc_reloc_val];

  return NULL;
}

static reloc_howto_type *
openrisc_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
			    const char *r_name)
{
  unsigned int i;

  for (i = 0;
       i < (sizeof (openrisc_elf_howto_table)
	    / sizeof (openrisc_elf_howto_table[0]));
       i++)
    if (openrisc_elf_howto_table[i].name != NULL
	&& strcasecmp (openrisc_elf_howto_table[i].name, r_name) == 0)
      return &openrisc_elf_howto_table[i];

  return NULL;
}

/* Set the howto pointer for an OpenRISC ELF reloc.  */

static void
openrisc_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
			     arelent * cache_ptr,
			     Elf_Internal_Rela * dst)
{
  unsigned int r_type;

  r_type = ELF32_R_TYPE (dst->r_info);
  BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
  cache_ptr->howto = & openrisc_elf_howto_table[r_type];
}

/* Perform a single relocation.  By default we use the standard BFD
   routines, but a few relocs, we have to do them ourselves.  */

static bfd_reloc_status_type
openrisc_final_link_relocate (reloc_howto_type *howto,
			      bfd *input_bfd,
			      asection *input_section,
			      bfd_byte *contents,
			      Elf_Internal_Rela *rel,
			      bfd_vma relocation)
{
  bfd_reloc_status_type r = bfd_reloc_ok;

  switch (howto->type)
    {
    case R_OPENRISC_LO_16_IN_INSN:
      relocation &= 0xffff;
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
				    contents, rel->r_offset,
				    relocation, rel->r_addend);
      break;

    default:
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
				    contents, rel->r_offset,
				    relocation, rel->r_addend);
    }

  return r;
}

/* Relocate an OpenRISC ELF section.

   The RELOCATE_SECTION function is called by the new ELF backend linker
   to handle the relocations for a section.

   The relocs are always passed as Rela structures; if the section
   actually uses Rel structures, the r_addend field will always be
   zero.

   This function is responsible for adjusting the section contents as
   necessary, and (if using Rela relocs and generating a relocatable
   output file) adjusting the reloc addend as necessary.

   This function does not have to worry about setting the reloc
   address or the reloc symbol index.

   LOCAL_SYMS is a pointer to the swapped in local symbols.

   LOCAL_SECTIONS is an array giving the section in the input file
   corresponding to the st_shndx field of each local symbol.

   The global hash table entry for the global symbols can be found
   via elf_sym_hashes (input_bfd).

   When generating 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
openrisc_elf_relocate_section (bfd *output_bfd,
			       struct bfd_link_info *info,
			       bfd *input_bfd,
			       asection *input_section,
			       bfd_byte *contents,
			       Elf_Internal_Rela *relocs,
			       Elf_Internal_Sym *local_syms,
			       asection **local_sections)
{
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes;
  Elf_Internal_Rela *rel;
  Elf_Internal_Rela *relend;

  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (input_bfd);
  relend = relocs + input_section->reloc_count;

  for (rel = relocs; rel < relend; rel++)
    {
      reloc_howto_type *howto;
      unsigned long r_symndx;
      Elf_Internal_Sym *sym;
      asection *sec;
      struct elf_link_hash_entry *h;
      bfd_vma relocation;
      bfd_reloc_status_type r;
      const char *name = NULL;
      int r_type;

      r_type = ELF32_R_TYPE (rel->r_info);
      r_symndx = ELF32_R_SYM (rel->r_info);

      if (r_type == R_OPENRISC_GNU_VTINHERIT
	  || r_type == R_OPENRISC_GNU_VTENTRY)
	continue;

      if ((unsigned int) r_type >
	  (sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
	abort ();

      howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info);
      h = NULL;
      sym = NULL;
      sec = NULL;

      if (r_symndx < symtab_hdr->sh_info)
	{
	  sym = local_syms + r_symndx;
	  sec = local_sections[r_symndx];
	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);

	  name = bfd_elf_string_from_elf_section
	    (input_bfd, symtab_hdr->sh_link, sym->st_name);
	  name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
	}
      else
	{
	  bfd_boolean unresolved_reloc, warned;

	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
				   r_symndx, symtab_hdr, sym_hashes,
				   h, sec, relocation,
				   unresolved_reloc, warned);
	}

      if (sec != NULL && elf_discarded_section (sec))
	{
	  /* For relocs against symbols from removed linkonce sections,
	     or sections discarded by a linker script, we just want the
	     section contents zeroed.  Avoid any special processing.  */
	  _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
	  rel->r_info = 0;
	  rel->r_addend = 0;
	  continue;
	}

      if (info->relocatable)
	continue;

      r = openrisc_final_link_relocate (howto, input_bfd, input_section,
					contents, rel, relocation);

      if (r != bfd_reloc_ok)
	{
	  const char *msg = NULL;

	  switch (r)
	    {
	    case bfd_reloc_overflow:
	      r = 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, name, input_bfd, input_section, rel->r_offset, TRUE);
	      break;

	    case bfd_reloc_outofrange:
	      msg = _("internal error: out of range error");
	      break;

	    case bfd_reloc_notsupported:
	      msg = _("internal error: unsupported relocation error");
	      break;

	    case bfd_reloc_dangerous:
	      msg = _("internal error: dangerous relocation");
	      break;

	    default:
	      msg = _("internal error: unknown error");
	      break;
	    }

	  if (msg)
	    r = info->callbacks->warning
	      (info, msg, name, input_bfd, input_section, rel->r_offset);

	  if (!r)
	    return FALSE;
	}
    }

  return TRUE;
}

/* Return the section that should be marked against GC for a given
   relocation.  */

static asection *
openrisc_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_OPENRISC_GNU_VTINHERIT:
      case R_OPENRISC_GNU_VTENTRY:
	return NULL;
      }

  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}

/* 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
openrisc_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;
  const Elf_Internal_Rela *rel;
  const Elf_Internal_Rela *rel_end;

  if (info->relocatable)
    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];
	  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.  */
	case R_OPENRISC_GNU_VTINHERIT:
	  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.  */
	case R_OPENRISC_GNU_VTENTRY:
	  if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
	    return FALSE;
	  break;
	}
    }

  return TRUE;
}

/* Set the right machine number.  */

static bfd_boolean
openrisc_elf_object_p (bfd *abfd)
{
  bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
  return TRUE;
}

/* Store the machine number in the flags field.  */

static void
openrisc_elf_final_write_processing (bfd *abfd,
				     bfd_boolean linker ATTRIBUTE_UNUSED)
{
  unsigned long val;

  switch (bfd_get_mach (abfd))
    {
    default:
      val = 0;
      break;
    }

  elf_elfheader (abfd)->e_flags &= ~0xf;
  elf_elfheader (abfd)->e_flags |= val;
}


#define ELF_ARCH			bfd_arch_openrisc
#define ELF_MACHINE_CODE		EM_OPENRISC
#define ELF_MACHINE_ALT1		EM_OPENRISC_OLD
#define ELF_MAXPAGESIZE			0x1000

#define TARGET_BIG_SYM			bfd_elf32_openrisc_vec
#define TARGET_BIG_NAME			"elf32-openrisc"

#define elf_info_to_howto_rel		NULL
#define elf_info_to_howto		openrisc_info_to_howto_rela
#define elf_backend_relocate_section	openrisc_elf_relocate_section
#define elf_backend_gc_mark_hook	openrisc_elf_gc_mark_hook
#define elf_backend_check_relocs	openrisc_elf_check_relocs

#define elf_backend_can_gc_sections	1
#define elf_backend_rela_normal		1

#define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
#define bfd_elf32_bfd_reloc_name_lookup openrisc_reloc_name_lookup

#define elf_backend_object_p                openrisc_elf_object_p
#define elf_backend_final_write_processing  openrisc_elf_final_write_processing

#include "elf32-target.h"
Commit	Line	Data
b3baf5d0	1	/* OpenRISC-specific support for 32-bit ELF.
ab96bf03	2	Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
07adf181	3	Free Software Foundation, Inc.
b3baf5d0 NC	4	Contributed by Johan Rydberg, jrydberg@opencores.org
b3baf5d0 NC	5
47b0e7ad	6	This file is part of BFD, the Binary File Descriptor library.
b3baf5d0	7
47b0e7ad NC	8	This program is free software; you can redistribute it and/or modify
47b0e7ad NC	9	it under the terms of the GNU General Public License as published by
cd123cb7	10	the Free Software Foundation; either version 3 of the License, or
47b0e7ad	11	(at your option) any later version.
b3baf5d0	12
47b0e7ad NC	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
b3baf5d0	17
47b0e7ad NC	18	You should have received a copy of the GNU General Public License
47b0e7ad NC	19	along with this program; if not, write to the Free Software
cd123cb7 NC	20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
cd123cb7 NC	21	MA 02110-1301, USA. */
b3baf5d0	22
b3baf5d0	23	#include "sysdep.h"
3db64b00	24	#include "bfd.h"
b3baf5d0 NC	25	#include "libbfd.h"
	26	#include "elf-bfd.h"
	27	#include "elf/openrisc.h"
	28	#include "libiberty.h"
	29
b3baf5d0	30	static reloc_howto_type openrisc_elf_howto_table[] =
47b0e7ad	31	{
b3baf5d0 NC	32	/* This reloc does nothing. */
	33	HOWTO (R_OPENRISC_NONE, /* type */
	34	0, /* rightshift */
	35	2, /* size (0 = byte, 1 = short, 2 = long) */
	36	32, /* bitsize */
b34976b6	37	FALSE, /* pc_relative */
b3baf5d0 NC	38	0, /* bitpos */
	39	complain_overflow_bitfield, /* complain_on_overflow */
	40	bfd_elf_generic_reloc, /* special_function */
	41	"R_OPENRISC_NONE", /* name */
b34976b6	42	FALSE, /* partial_inplace */
b3baf5d0 NC	43	0, /* src_mask */
b3baf5d0 NC	44	0, /* dst_mask */
b34976b6	45	FALSE), /* pcrel_offset */
b3baf5d0 NC	46
	47	/* A PC relative 26 bit relocation, right shifted by 2. */
	48	HOWTO (R_OPENRISC_INSN_REL_26, /* type */
	49	2, /* rightshift */
	50	2, /* size (0 = byte, 1 = short, 2 = long) */
	51	26, /* bitsize */
b34976b6	52	TRUE, /* pc_relative */
b3baf5d0 NC	53	0, /* bitpos */
	54	complain_overflow_signed, /* complain_on_overflow */
	55	bfd_elf_generic_reloc, /* special_function */
	56	"R_OPENRISC_INSN_REL_26", /* name */
b34976b6	57	FALSE, /* partial_inplace */
b3baf5d0 NC	58	0x00000000, /* src_mask */
b3baf5d0 NC	59	0x03ffffff, /* dst_mask */
b34976b6	60	FALSE), /* pcrel_offset */
b3baf5d0 NC	61
	62	/* A absolute 26 bit relocation, right shifted by 2. */
	63	HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
	64	2, /* rightshift */
	65	2, /* size (0 = byte, 1 = short, 2 = long) */
	66	26, /* bitsize */
b34976b6	67	FALSE, /* pc_relative */
b3baf5d0 NC	68	0, /* bitpos */
	69	complain_overflow_signed, /* complain_on_overflow */
	70	bfd_elf_generic_reloc, /* special_function */
	71	"R_OPENRISC_INSN_ABS_26", /* name */
b34976b6	72	FALSE, /* partial_inplace */
b3baf5d0 NC	73	0x00000000, /* src_mask */
b3baf5d0 NC	74	0x03ffffff, /* dst_mask */
b34976b6	75	FALSE), /* pcrel_offset */
b3baf5d0 NC	76
	77	HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
	78	0, /* rightshift */
c7e40348	79	1, /* size (0 = byte, 1 = short, 2 = long) */
b3baf5d0	80	16, /* bitsize */
b34976b6	81	FALSE, /* pc_relative */
b3baf5d0	82	0, /* bitpos */
c7e40348	83	complain_overflow_dont, /* complain_on_overflow */
b3baf5d0 NC	84	bfd_elf_generic_reloc, /* special_function */
b3baf5d0 NC	85	"R_OPENRISC_LO_16_IN_INSN", /* name */
b34976b6	86	FALSE, /* partial_inplace */
c7e40348	87	0, /* src_mask */
b3baf5d0	88	0x0000ffff, /* dst_mask */
b34976b6	89	FALSE), /* pcrel_offset */
b3baf5d0 NC	90
	91	HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
	92	16, /* rightshift */
c7e40348	93	1, /* size (0 = byte, 1 = short, 2 = long) */
b3baf5d0	94	16, /* bitsize */
b34976b6	95	FALSE, /* pc_relative */
b3baf5d0	96	0, /* bitpos */
c7e40348	97	complain_overflow_dont, /* complain_on_overflow */
b3baf5d0 NC	98	bfd_elf_generic_reloc, /* special_function */
b3baf5d0 NC	99	"R_OPENRISC_HI_16_IN_INSN", /* name */
b34976b6	100	FALSE, /* partial_inplace */
c7e40348	101	0, /* src_mask */
b3baf5d0	102	0x0000ffff, /* dst_mask */
b34976b6	103	FALSE), /* pcrel_offset */
b3baf5d0 NC	104
	105	/* An 8 bit absolute relocation. */
	106	HOWTO (R_OPENRISC_8, /* type */
	107	0, /* rightshift */
	108	0, /* size (0 = byte, 1 = short, 2 = long) */
	109	8, /* bitsize */
b34976b6	110	FALSE, /* pc_relative */
b3baf5d0 NC	111	0, /* bitpos */
	112	complain_overflow_bitfield, /* complain_on_overflow */
	113	bfd_elf_generic_reloc, /* special_function */
	114	"R_OPENRISC_8", /* name */
b34976b6	115	TRUE, /* partial_inplace */
b3baf5d0 NC	116	0x0000, /* src_mask */
b3baf5d0 NC	117	0x00ff, /* dst_mask */
b34976b6	118	FALSE), /* pcrel_offset */
b3baf5d0 NC	119
	120	/* A 16 bit absolute relocation. */
	121	HOWTO (R_OPENRISC_16, /* type */
	122	0, /* rightshift */
	123	1, /* size (0 = byte, 1 = short, 2 = long) */
	124	16, /* bitsize */
b34976b6	125	FALSE, /* pc_relative */
b3baf5d0 NC	126	0, /* bitpos */
	127	complain_overflow_bitfield, /* complain_on_overflow */
	128	bfd_elf_generic_reloc, /* special_function */
	129	"R_OPENRISC_16", /* name */
b34976b6	130	TRUE, /* partial_inplace */
b3baf5d0 NC	131	0x00000000, /* src_mask */
b3baf5d0 NC	132	0x0000ffff, /* dst_mask */
b34976b6	133	FALSE), /* pcrel_offset */
b3baf5d0 NC	134
	135	/* A 32 bit absolute relocation. */
	136	HOWTO (R_OPENRISC_32, /* type */
	137	0, /* rightshift */
	138	2, /* size (0 = byte, 1 = short, 2 = long) */
	139	32, /* bitsize */
b34976b6	140	FALSE, /* pc_relative */
b3baf5d0 NC	141	0, /* bitpos */
	142	complain_overflow_bitfield, /* complain_on_overflow */
	143	bfd_elf_generic_reloc, /* special_function */
	144	"R_OPENRISC_32", /* name */
b34976b6	145	TRUE, /* partial_inplace */
b3baf5d0 NC	146	0x00000000, /* src_mask */
b3baf5d0 NC	147	0xffffffff, /* dst_mask */
b34976b6	148	FALSE), /* pcrel_offset */
b3baf5d0	149
47b0e7ad	150	/* GNU extension to record C++ vtable hierarchy. */
b3baf5d0 NC	151	HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
	152	0, /* rightshift */
	153	2, /* size (0 = byte, 1 = short, 2 = long) */
	154	0, /* bitsize */
b34976b6	155	FALSE, /* pc_relative */
b3baf5d0 NC	156	0, /* bitpos */
	157	complain_overflow_dont, /* complain_on_overflow */
	158	NULL, /* special_function */
	159	"R_OPENRISC_GNU_VTINHERIT", /* name */
b34976b6	160	FALSE, /* partial_inplace */
b3baf5d0 NC	161	0, /* src_mask */
b3baf5d0 NC	162	0, /* dst_mask */
b34976b6	163	FALSE), /* pcrel_offset */
b3baf5d0	164
47b0e7ad	165	/* GNU extension to record C++ vtable member usage. */
b3baf5d0 NC	166	HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
	167	0, /* rightshift */
	168	2, /* size (0 = byte, 1 = short, 2 = long) */
	169	0, /* bitsize */
b34976b6	170	FALSE, /* pc_relative */
b3baf5d0 NC	171	0, /* bitpos */
	172	complain_overflow_dont, /* complain_on_overflow */
	173	_bfd_elf_rel_vtable_reloc_fn, /* special_function */
	174	"R_OPENRISC_GNU_VTENTRY", /* name */
b34976b6	175	FALSE, /* partial_inplace */
b3baf5d0 NC	176	0, /* src_mask */
b3baf5d0 NC	177	0, /* dst_mask */
b34976b6	178	FALSE), /* pcrel_offset */
b3baf5d0 NC	179	};
	180
	181	/* Map BFD reloc types to OpenRISC ELF reloc types. */
	182
	183	struct openrisc_reloc_map
47b0e7ad NC	184	{
	185	bfd_reloc_code_real_type bfd_reloc_val;
	186	unsigned int openrisc_reloc_val;
	187	};
b3baf5d0 NC	188
b3baf5d0 NC	189	static const struct openrisc_reloc_map openrisc_reloc_map[] =
47b0e7ad NC	190	{
	191	{ BFD_RELOC_NONE, R_OPENRISC_NONE },
	192	{ BFD_RELOC_32, R_OPENRISC_32 },
	193	{ BFD_RELOC_16, R_OPENRISC_16 },
	194	{ BFD_RELOC_8, R_OPENRISC_8 },
157090f7 AM	195	{ BFD_RELOC_OPENRISC_REL_26, R_OPENRISC_INSN_REL_26 },
	196	{ BFD_RELOC_OPENRISC_ABS_26, R_OPENRISC_INSN_ABS_26 },
	197	{ BFD_RELOC_HI16, R_OPENRISC_HI_16_IN_INSN },
47b0e7ad NC	198	{ BFD_RELOC_LO16, R_OPENRISC_LO_16_IN_INSN },
	199	{ BFD_RELOC_VTABLE_INHERIT, R_OPENRISC_GNU_VTINHERIT },
	200	{ BFD_RELOC_VTABLE_ENTRY, R_OPENRISC_GNU_VTENTRY }
	201	};
b3baf5d0 NC	202
b3baf5d0 NC	203	static reloc_howto_type *
47b0e7ad NC	204	openrisc_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
47b0e7ad NC	205	bfd_reloc_code_real_type code)
b3baf5d0 NC	206	{
	207	unsigned int i;
	208
	209	for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
	210	if (openrisc_reloc_map[i].bfd_reloc_val == code)
	211	return & openrisc_elf_howto_table[openrisc_reloc_map[i].
	212	openrisc_reloc_val];
	213
	214	return NULL;
	215	}
	216
157090f7 AM	217	static reloc_howto_type *
	218	openrisc_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
	219	const char *r_name)
	220	{
	221	unsigned int i;
	222
	223	for (i = 0;
	224	i < (sizeof (openrisc_elf_howto_table)
	225	/ sizeof (openrisc_elf_howto_table[0]));
	226	i++)
	227	if (openrisc_elf_howto_table[i].name != NULL
	228	&& strcasecmp (openrisc_elf_howto_table[i].name, r_name) == 0)
	229	return &openrisc_elf_howto_table[i];
	230
	231	return NULL;
	232	}
	233
b3baf5d0 NC	234	/* Set the howto pointer for an OpenRISC ELF reloc. */
	235
	236	static void
47b0e7ad NC	237	openrisc_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
	238	arelent * cache_ptr,
	239	Elf_Internal_Rela * dst)
b3baf5d0 NC	240	{
	241	unsigned int r_type;
	242
	243	r_type = ELF32_R_TYPE (dst->r_info);
	244	BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
	245	cache_ptr->howto = & openrisc_elf_howto_table[r_type];
	246	}
	247
	248	/* Perform a single relocation. By default we use the standard BFD
	249	routines, but a few relocs, we have to do them ourselves. */
	250
	251	static bfd_reloc_status_type
47b0e7ad NC	252	openrisc_final_link_relocate (reloc_howto_type *howto,
	253	bfd *input_bfd,
	254	asection *input_section,
	255	bfd_byte *contents,
	256	Elf_Internal_Rela *rel,
	257	bfd_vma relocation)
b3baf5d0 NC	258	{
	259	bfd_reloc_status_type r = bfd_reloc_ok;
	260
	261	switch (howto->type)
	262	{
	263	case R_OPENRISC_LO_16_IN_INSN:
	264	relocation &= 0xffff;
	265	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
	266	contents, rel->r_offset,
	267	relocation, rel->r_addend);
	268	break;
	269
	270	default:
	271	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
	272	contents, rel->r_offset,
	273	relocation, rel->r_addend);
	274	}
	275
	276	return r;
	277	}
	278
	279	/* Relocate an OpenRISC ELF section.
b3baf5d0 NC	280
	281	The RELOCATE_SECTION function is called by the new ELF backend linker
	282	to handle the relocations for a section.
	283
	284	The relocs are always passed as Rela structures; if the section
	285	actually uses Rel structures, the r_addend field will always be
	286	zero.
	287
	288	This function is responsible for adjusting the section contents as
1049f94e	289	necessary, and (if using Rela relocs and generating a relocatable
b3baf5d0 NC	290	output file) adjusting the reloc addend as necessary.
	291
	292	This function does not have to worry about setting the reloc
	293	address or the reloc symbol index.
	294
	295	LOCAL_SYMS is a pointer to the swapped in local symbols.
	296
	297	LOCAL_SECTIONS is an array giving the section in the input file
	298	corresponding to the st_shndx field of each local symbol.
	299
	300	The global hash table entry for the global symbols can be found
	301	via elf_sym_hashes (input_bfd).
	302
1049f94e	303	When generating relocatable output, this function must handle
b3baf5d0 NC	304	STB_LOCAL/STT_SECTION symbols specially. The output symbol is
	305	going to be the section symbol corresponding to the output
	306	section, which means that the addend must be adjusted
	307	accordingly. */
	308
b34976b6	309	static bfd_boolean
47b0e7ad NC	310	openrisc_elf_relocate_section (bfd *output_bfd,
	311	struct bfd_link_info *info,
	312	bfd *input_bfd,
	313	asection *input_section,
	314	bfd_byte *contents,
	315	Elf_Internal_Rela *relocs,
	316	Elf_Internal_Sym *local_syms,
	317	asection **local_sections)
b3baf5d0 NC	318	{
	319	Elf_Internal_Shdr *symtab_hdr;
	320	struct elf_link_hash_entry **sym_hashes;
	321	Elf_Internal_Rela *rel;
	322	Elf_Internal_Rela *relend;
	323
	324	symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
	325	sym_hashes = elf_sym_hashes (input_bfd);
	326	relend = relocs + input_section->reloc_count;
	327
	328	for (rel = relocs; rel < relend; rel++)
	329	{
	330	reloc_howto_type *howto;
	331	unsigned long r_symndx;
	332	Elf_Internal_Sym *sym;
	333	asection *sec;
	334	struct elf_link_hash_entry *h;
	335	bfd_vma relocation;
	336	bfd_reloc_status_type r;
	337	const char *name = NULL;
	338	int r_type;
	339
	340	r_type = ELF32_R_TYPE (rel->r_info);
	341	r_symndx = ELF32_R_SYM (rel->r_info);
	342
	343	if (r_type == R_OPENRISC_GNU_VTINHERIT
	344	\|\| r_type == R_OPENRISC_GNU_VTENTRY)
	345	continue;
	346
b3baf5d0 NC	347	if ((unsigned int) r_type >
	348	(sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
	349	abort ();
	350
b3baf5d0 NC	351	howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info);
	352	h = NULL;
	353	sym = NULL;
	354	sec = NULL;
	355
	356	if (r_symndx < symtab_hdr->sh_info)
	357	{
	358	sym = local_syms + r_symndx;
	359	sec = local_sections[r_symndx];
8517fae7	360	relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
b3baf5d0 NC	361
	362	name = bfd_elf_string_from_elf_section
	363	(input_bfd, symtab_hdr->sh_link, sym->st_name);
	364	name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
	365	}
	366	else
	367	{
59c2e50f	368	bfd_boolean unresolved_reloc, warned;
b3baf5d0	369
b2a8e766 AM	370	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
	371	r_symndx, symtab_hdr, sym_hashes,
	372	h, sec, relocation,
	373	unresolved_reloc, warned);
b3baf5d0 NC	374	}
b3baf5d0 NC	375
ab96bf03 AM	376	if (sec != NULL && elf_discarded_section (sec))
	377	{
	378	/* For relocs against symbols from removed linkonce sections,
	379	or sections discarded by a linker script, we just want the
	380	section contents zeroed. Avoid any special processing. */
	381	_bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
	382	rel->r_info = 0;
	383	rel->r_addend = 0;
	384	continue;
	385	}
	386
	387	if (info->relocatable)
	388	continue;
	389
b3baf5d0 NC	390	r = openrisc_final_link_relocate (howto, input_bfd, input_section,
	391	contents, rel, relocation);
	392
	393	if (r != bfd_reloc_ok)
	394	{
47b0e7ad	395	const char *msg = NULL;
b3baf5d0 NC	396
	397	switch (r)
	398	{
	399	case bfd_reloc_overflow:
	400	r = info->callbacks->reloc_overflow
dfeffb9f L	401	(info, (h ? &h->root : NULL), name, howto->name,
dfeffb9f L	402	(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
b3baf5d0 NC	403	break;
	404
	405	case bfd_reloc_undefined:
	406	r = info->callbacks->undefined_symbol
b34976b6	407	(info, name, input_bfd, input_section, rel->r_offset, TRUE);
b3baf5d0 NC	408	break;
	409
	410	case bfd_reloc_outofrange:
	411	msg = _("internal error: out of range error");
	412	break;
	413
	414	case bfd_reloc_notsupported:
	415	msg = _("internal error: unsupported relocation error");
	416	break;
	417
	418	case bfd_reloc_dangerous:
	419	msg = _("internal error: dangerous relocation");
	420	break;
	421
	422	default:
	423	msg = _("internal error: unknown error");
	424	break;
	425	}
	426
	427	if (msg)
	428	r = info->callbacks->warning
	429	(info, msg, name, input_bfd, input_section, rel->r_offset);
	430
	431	if (!r)
b34976b6	432	return FALSE;
b3baf5d0 NC	433	}
	434	}
	435
b34976b6	436	return TRUE;
b3baf5d0 NC	437	}
	438
	439	/* Return the section that should be marked against GC for a given
	440	relocation. */
	441
	442	static asection *
47b0e7ad	443	openrisc_elf_gc_mark_hook (asection *sec,
07adf181	444	struct bfd_link_info *info,
47b0e7ad NC	445	Elf_Internal_Rela *rel,
	446	struct elf_link_hash_entry *h,
	447	Elf_Internal_Sym *sym)
b3baf5d0	448	{
07adf181 AM	449	if (h != NULL)
	450	switch (ELF32_R_TYPE (rel->r_info))
	451	{
	452	case R_OPENRISC_GNU_VTINHERIT:
	453	case R_OPENRISC_GNU_VTENTRY:
	454	return NULL;
	455	}
	456
	457	return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
b3baf5d0 NC	458	}
	459
	460	/* Look through the relocs for a section during the first phase.
	461	Since we don't do .gots or .plts, we just need to consider the
	462	virtual table relocs for gc. */
	463
b34976b6	464	static bfd_boolean
47b0e7ad NC	465	openrisc_elf_check_relocs (bfd *abfd,
	466	struct bfd_link_info *info,
	467	asection *sec,
	468	const Elf_Internal_Rela *relocs)
b3baf5d0 NC	469	{
	470	Elf_Internal_Shdr *symtab_hdr;
	471	struct elf_link_hash_entry sym_hashes, sym_hashes_end;
	472	const Elf_Internal_Rela *rel;
	473	const Elf_Internal_Rela *rel_end;
	474
1049f94e	475	if (info->relocatable)
b34976b6	476	return TRUE;
b3baf5d0 NC	477
	478	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
	479	sym_hashes = elf_sym_hashes (abfd);
	480	sym_hashes_end =
	481	sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
	482	if (!elf_bad_symtab (abfd))
	483	sym_hashes_end -= symtab_hdr->sh_info;
	484
	485	rel_end = relocs + sec->reloc_count;
	486	for (rel = relocs; rel < rel_end; rel++)
	487	{
	488	struct elf_link_hash_entry *h;
	489	unsigned long r_symndx;
	490
	491	r_symndx = ELF32_R_SYM (rel->r_info);
	492	if (r_symndx < symtab_hdr->sh_info)
	493	h = NULL;
	494	else
973a3492 L	495	{
	496	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	497	while (h->root.type == bfd_link_hash_indirect
	498	\|\| h->root.type == bfd_link_hash_warning)
	499	h = (struct elf_link_hash_entry *) h->root.u.i.link;
	500	}
b3baf5d0 NC	501
	502	switch (ELF32_R_TYPE (rel->r_info))
	503	{
	504	/* This relocation describes the C++ object vtable hierarchy.
	505	Reconstruct it for later use during GC. */
	506	case R_OPENRISC_GNU_VTINHERIT:
c152c796	507	if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6	508	return FALSE;
b3baf5d0 NC	509	break;
	510
	511	/* This relocation describes which C++ vtable entries are actually
	512	used. Record for later use during GC. */
	513	case R_OPENRISC_GNU_VTENTRY:
c152c796	514	if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6	515	return FALSE;
b3baf5d0 NC	516	break;
	517	}
	518	}
	519
b34976b6	520	return TRUE;
b3baf5d0 NC	521	}
	522
	523	/* Set the right machine number. */
	524
b34976b6	525	static bfd_boolean
47b0e7ad	526	openrisc_elf_object_p (bfd *abfd)
b3baf5d0	527	{
47b0e7ad	528	bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
b34976b6	529	return TRUE;
b3baf5d0 NC	530	}
	531
	532	/* Store the machine number in the flags field. */
	533
	534	static void
47b0e7ad NC	535	openrisc_elf_final_write_processing (bfd *abfd,
47b0e7ad NC	536	bfd_boolean linker ATTRIBUTE_UNUSED)
b3baf5d0 NC	537	{
	538	unsigned long val;
	539
	540	switch (bfd_get_mach (abfd))
	541	{
	542	default:
	543	val = 0;
	544	break;
	545	}
	546
	547	elf_elfheader (abfd)->e_flags &= ~0xf;
	548	elf_elfheader (abfd)->e_flags \|= val;
	549	}
	550
	551
	552	#define ELF_ARCH bfd_arch_openrisc
	553	#define ELF_MACHINE_CODE EM_OPENRISC
c11cc227	554	#define ELF_MACHINE_ALT1 EM_OPENRISC_OLD
b3baf5d0 NC	555	#define ELF_MAXPAGESIZE 0x1000
	556
	557	#define TARGET_BIG_SYM bfd_elf32_openrisc_vec
	558	#define TARGET_BIG_NAME "elf32-openrisc"
	559
	560	#define elf_info_to_howto_rel NULL
	561	#define elf_info_to_howto openrisc_info_to_howto_rela
	562	#define elf_backend_relocate_section openrisc_elf_relocate_section
	563	#define elf_backend_gc_mark_hook openrisc_elf_gc_mark_hook
b3baf5d0 NC	564	#define elf_backend_check_relocs openrisc_elf_check_relocs
	565
	566	#define elf_backend_can_gc_sections 1
b491616a	567	#define elf_backend_rela_normal 1
b3baf5d0 NC	568
b3baf5d0 NC	569	#define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
157090f7	570	#define bfd_elf32_bfd_reloc_name_lookup openrisc_reloc_name_lookup
b3baf5d0 NC	571
	572	#define elf_backend_object_p openrisc_elf_object_p
	573	#define elf_backend_final_write_processing openrisc_elf_final_write_processing
	574
	575	#include "elf32-target.h"