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

/* OpenRISC-specific support for 32-bit ELF.
   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2010, 2012
   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 && discarded_section (sec))
	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
					 rel, 1, relend, howto, 0, contents);

      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;
  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);

  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:
	  BFD_ASSERT (h != NULL);
	  if (h != NULL
	      && !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.
dbaa2011	2	Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2010, 2012
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
dbaa2011	376	if (sec != NULL && discarded_section (sec))
e4067dbb	377	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b	378	rel, 1, relend, howto, 0, contents);
ab96bf03 AM	379
	380	if (info->relocatable)
	381	continue;
	382
b3baf5d0 NC	383	r = openrisc_final_link_relocate (howto, input_bfd, input_section,
	384	contents, rel, relocation);
	385
	386	if (r != bfd_reloc_ok)
	387	{
47b0e7ad	388	const char *msg = NULL;
b3baf5d0 NC	389
	390	switch (r)
	391	{
	392	case bfd_reloc_overflow:
	393	r = info->callbacks->reloc_overflow
dfeffb9f L	394	(info, (h ? &h->root : NULL), name, howto->name,
dfeffb9f L	395	(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
b3baf5d0 NC	396	break;
	397
	398	case bfd_reloc_undefined:
	399	r = info->callbacks->undefined_symbol
b34976b6	400	(info, name, input_bfd, input_section, rel->r_offset, TRUE);
b3baf5d0 NC	401	break;
	402
	403	case bfd_reloc_outofrange:
	404	msg = _("internal error: out of range error");
	405	break;
	406
	407	case bfd_reloc_notsupported:
	408	msg = _("internal error: unsupported relocation error");
	409	break;
	410
	411	case bfd_reloc_dangerous:
	412	msg = _("internal error: dangerous relocation");
	413	break;
	414
	415	default:
	416	msg = _("internal error: unknown error");
	417	break;
	418	}
	419
	420	if (msg)
	421	r = info->callbacks->warning
	422	(info, msg, name, input_bfd, input_section, rel->r_offset);
	423
	424	if (!r)
b34976b6	425	return FALSE;
b3baf5d0 NC	426	}
	427	}
	428
b34976b6	429	return TRUE;
b3baf5d0 NC	430	}
	431
	432	/* Return the section that should be marked against GC for a given
	433	relocation. */
	434
	435	static asection *
47b0e7ad	436	openrisc_elf_gc_mark_hook (asection *sec,
07adf181	437	struct bfd_link_info *info,
47b0e7ad NC	438	Elf_Internal_Rela *rel,
	439	struct elf_link_hash_entry *h,
	440	Elf_Internal_Sym *sym)
b3baf5d0	441	{
07adf181 AM	442	if (h != NULL)
	443	switch (ELF32_R_TYPE (rel->r_info))
	444	{
	445	case R_OPENRISC_GNU_VTINHERIT:
	446	case R_OPENRISC_GNU_VTENTRY:
	447	return NULL;
	448	}
	449
	450	return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
b3baf5d0 NC	451	}
	452
	453	/* Look through the relocs for a section during the first phase.
	454	Since we don't do .gots or .plts, we just need to consider the
	455	virtual table relocs for gc. */
	456
b34976b6	457	static bfd_boolean
47b0e7ad NC	458	openrisc_elf_check_relocs (bfd *abfd,
	459	struct bfd_link_info *info,
	460	asection *sec,
	461	const Elf_Internal_Rela *relocs)
b3baf5d0 NC	462	{
b3baf5d0 NC	463	Elf_Internal_Shdr *symtab_hdr;
5582a088	464	struct elf_link_hash_entry **sym_hashes;
b3baf5d0 NC	465	const Elf_Internal_Rela *rel;
	466	const Elf_Internal_Rela *rel_end;
	467
1049f94e	468	if (info->relocatable)
b34976b6	469	return TRUE;
b3baf5d0 NC	470
	471	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
	472	sym_hashes = elf_sym_hashes (abfd);
b3baf5d0 NC	473
	474	rel_end = relocs + sec->reloc_count;
	475	for (rel = relocs; rel < rel_end; rel++)
	476	{
	477	struct elf_link_hash_entry *h;
	478	unsigned long r_symndx;
	479
	480	r_symndx = ELF32_R_SYM (rel->r_info);
	481	if (r_symndx < symtab_hdr->sh_info)
	482	h = NULL;
	483	else
973a3492 L	484	{
	485	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	486	while (h->root.type == bfd_link_hash_indirect
	487	\|\| h->root.type == bfd_link_hash_warning)
	488	h = (struct elf_link_hash_entry *) h->root.u.i.link;
	489	}
b3baf5d0 NC	490
	491	switch (ELF32_R_TYPE (rel->r_info))
	492	{
	493	/* This relocation describes the C++ object vtable hierarchy.
	494	Reconstruct it for later use during GC. */
	495	case R_OPENRISC_GNU_VTINHERIT:
c152c796	496	if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6	497	return FALSE;
b3baf5d0 NC	498	break;
	499
	500	/* This relocation describes which C++ vtable entries are actually
	501	used. Record for later use during GC. */
	502	case R_OPENRISC_GNU_VTENTRY:
d17e0c6e JB	503	BFD_ASSERT (h != NULL);
	504	if (h != NULL
	505	&& !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6	506	return FALSE;
b3baf5d0 NC	507	break;
	508	}
	509	}
	510
b34976b6	511	return TRUE;
b3baf5d0 NC	512	}
	513
	514	/* Set the right machine number. */
	515
b34976b6	516	static bfd_boolean
47b0e7ad	517	openrisc_elf_object_p (bfd *abfd)
b3baf5d0	518	{
47b0e7ad	519	bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
b34976b6	520	return TRUE;
b3baf5d0 NC	521	}
	522
	523	/* Store the machine number in the flags field. */
	524
	525	static void
47b0e7ad NC	526	openrisc_elf_final_write_processing (bfd *abfd,
47b0e7ad NC	527	bfd_boolean linker ATTRIBUTE_UNUSED)
b3baf5d0 NC	528	{
	529	unsigned long val;
	530
	531	switch (bfd_get_mach (abfd))
	532	{
	533	default:
	534	val = 0;
	535	break;
	536	}
	537
	538	elf_elfheader (abfd)->e_flags &= ~0xf;
	539	elf_elfheader (abfd)->e_flags \|= val;
	540	}
	541
	542
	543	#define ELF_ARCH bfd_arch_openrisc
	544	#define ELF_MACHINE_CODE EM_OPENRISC
c11cc227	545	#define ELF_MACHINE_ALT1 EM_OPENRISC_OLD
b3baf5d0 NC	546	#define ELF_MAXPAGESIZE 0x1000
	547
	548	#define TARGET_BIG_SYM bfd_elf32_openrisc_vec
	549	#define TARGET_BIG_NAME "elf32-openrisc"
	550
	551	#define elf_info_to_howto_rel NULL
	552	#define elf_info_to_howto openrisc_info_to_howto_rela
	553	#define elf_backend_relocate_section openrisc_elf_relocate_section
	554	#define elf_backend_gc_mark_hook openrisc_elf_gc_mark_hook
b3baf5d0 NC	555	#define elf_backend_check_relocs openrisc_elf_check_relocs
	556
	557	#define elf_backend_can_gc_sections 1
b491616a	558	#define elf_backend_rela_normal 1
b3baf5d0 NC	559
b3baf5d0 NC	560	#define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
157090f7	561	#define bfd_elf32_bfd_reloc_name_lookup openrisc_reloc_name_lookup
b3baf5d0 NC	562
	563	#define elf_backend_object_p openrisc_elf_object_p
	564	#define elf_backend_final_write_processing openrisc_elf_final_write_processing
	565
	566	#include "elf32-target.h"