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

/* D10V-specific support for 32-bit ELF
   Copyright (C) 1996-2019 Free Software Foundation, Inc.
   Contributed by Martin Hunt (hunt@cygnus.com).

   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/d10v.h"

/* Use REL instead of RELA to save space.  */
#define USE_REL	1

static reloc_howto_type elf_d10v_howto_table[] =
{
  /* This reloc does nothing.  */
  HOWTO (R_D10V_NONE,		/* Type.  */
	 0,			/* Rightshift.  */
	 3,			/* Size (0 = byte, 1 = short, 2 = long).  */
	 0,			/* Bitsize.  */
	 FALSE,			/* PC_relative.  */
	 0,			/* Bitpos.  */
	 complain_overflow_dont,/* Complain_on_overflow.  */
	 bfd_elf_generic_reloc, /* Special_function.  */
	 "R_D10V_NONE",		/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0,			/* Src_mask.  */
	 0,			/* Dst_mask.  */
	 FALSE),		/* PCrel_offset.  */

  /* An PC Relative 10-bit relocation, shifted by 2, right container.  */
  HOWTO (R_D10V_10_PCREL_R,	/* Type.  */
	 2,			/* Rightshift.  */
	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
	 8,			/* Bitsize.  */
	 TRUE,			/* PC_relative.  */
	 0,			/* Bitpos.  */
	 complain_overflow_signed, /* Complain_on_overflow.  */
	 bfd_elf_generic_reloc, /* Special_function.  */
	 "R_D10V_10_PCREL_R",	/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0xff,			/* Src_mask.  */
	 0xff,			/* Dst_mask.  */
	 TRUE),			/* PCrel_offset.  */

  /* An PC Relative 10-bit relocation, shifted by 2, left container.  */
  HOWTO (R_D10V_10_PCREL_L,	/* Type.  */
	 2,			/* Rightshift.  */
	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
	 8,			/* Bitsize.  */
	 TRUE,			/* PC_relative.  */
	 15,			/* Bitpos.  */
	 complain_overflow_signed, /* Complain_on_overflow.  */
	 bfd_elf_generic_reloc, /* Special_function.  */
	 "R_D10V_10_PCREL_L",	/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0x07f8000,		/* Src_mask.  */
	 0x07f8000,		/* Dst_mask.  */
	 TRUE),			/* PCrel_offset.  */

  /* A 16 bit absolute relocation.  */
  HOWTO (R_D10V_16,		/* 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_D10V_16",		/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0xffff,		/* Src_mask.  */
	 0xffff,		/* Dst_mask.  */
	 FALSE),		/* PCrel_offset.  */

  /* An 18 bit absolute relocation, right shifted 2.  */
  HOWTO (R_D10V_18,		/* Type.  */
	 2,			/* 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_D10V_18",		/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0xffff,		/* Src_mask.  */
	 0xffff,		/* Dst_mask.  */
	 FALSE),		/* PCrel_offset.  */

  /* A relative 18 bit relocation, right shifted by 2.  */
  HOWTO (R_D10V_18_PCREL,	/* Type.  */
	 2,			/* Rightshift.  */
	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
	 16,			/* Bitsize.  */
	 TRUE,			/* PC_relative.  */
	 0,			/* Bitpos.  */
	 complain_overflow_signed, /* Complain_on_overflow.  */
	 bfd_elf_generic_reloc, /* Special_function.  */
	 "R_D10V_18_PCREL",	/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0xffff,		/* Src_mask.  */
	 0xffff,		/* Dst_mask.  */
	 TRUE),			/* PCrel_offset.  */

  /* A 32 bit absolute relocation.  */
  HOWTO (R_D10V_32,		/* Type.  */
	 0,			/* Rightshift.  */
	 2,			/* Size (0 = byte, 1 = short, 2 = long).  */
	 32,			/* Bitsize.  */
	 FALSE,			/* PC_relative.  */
	 0,			/* Bitpos.  */
	 complain_overflow_dont,/* Complain_on_overflow.  */
	 bfd_elf_generic_reloc, /* Special_function.  */
	 "R_D10V_32",		/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0xffffffff,		/* Src_mask.  */
	 0xffffffff,		/* Dst_mask.  */
	 FALSE),		/* PCrel_offset.  */

  /* GNU extension to record C++ vtable hierarchy.  */
  HOWTO (R_D10V_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_D10V_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_D10V_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_D10V_GNU_VTENTRY",	/* Name.  */
	 FALSE,			/* Partial_inplace.  */
	 0,			/* Src_mask.  */
	 0,			/* Dst_mask.  */
	 FALSE),		/* PCrel_offset.  */
};

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

struct d10v_reloc_map
{
  bfd_reloc_code_real_type bfd_reloc_val;
  unsigned char elf_reloc_val;
};

static const struct d10v_reloc_map d10v_reloc_map[] =
{
  { BFD_RELOC_NONE, R_D10V_NONE, },
  { BFD_RELOC_D10V_10_PCREL_R, R_D10V_10_PCREL_R },
  { BFD_RELOC_D10V_10_PCREL_L, R_D10V_10_PCREL_L },
  { BFD_RELOC_16, R_D10V_16 },
  { BFD_RELOC_D10V_18, R_D10V_18 },
  { BFD_RELOC_D10V_18_PCREL, R_D10V_18_PCREL },
  { BFD_RELOC_32, R_D10V_32 },
  { BFD_RELOC_VTABLE_INHERIT, R_D10V_GNU_VTINHERIT },
  { BFD_RELOC_VTABLE_ENTRY, R_D10V_GNU_VTENTRY },
};

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

  for (i = 0;
       i < sizeof (d10v_reloc_map) / sizeof (struct d10v_reloc_map);
       i++)
    if (d10v_reloc_map[i].bfd_reloc_val == code)
      return &elf_d10v_howto_table[d10v_reloc_map[i].elf_reloc_val];

  return NULL;
}

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

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

  return NULL;
}

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

static bfd_boolean
d10v_info_to_howto_rel (bfd *abfd,
			arelent *cache_ptr,
			Elf_Internal_Rela *dst)
{
  unsigned int r_type;

  r_type = ELF32_R_TYPE (dst->r_info);
  if (r_type >= (unsigned int) R_D10V_max)
    {
      /* 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 = &elf_d10v_howto_table[r_type];
  return TRUE;
}

static asection *
elf32_d10v_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_D10V_GNU_VTINHERIT:
      case R_D10V_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
elf32_d10v_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 (bfd_link_relocatable (info))
    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_D10V_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_D10V_GNU_VTENTRY:
	  if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
	    return FALSE;
	  break;
	}
    }

  return TRUE;
}

static bfd_vma
extract_rel_addend (bfd *abfd,
		    bfd_byte *where,
		    reloc_howto_type *howto)
{
  bfd_vma insn, val;

  switch (howto->size)
    {
    case 0:
      insn = bfd_get_8 (abfd, where);
      break;
    case 1:
      insn = bfd_get_16 (abfd, where);
      break;
    case 2:
      insn = bfd_get_32 (abfd, where);
      break;
    default:
      abort ();
    }

  val = (insn & howto->dst_mask) >> howto->bitpos << howto->rightshift;
  /* We should really be testing for signed addends here, but we don't
     have that info directly in the howto.  */
  if (howto->pc_relative)
    {
      bfd_vma sign;
      sign = howto->dst_mask & (~howto->dst_mask >> 1 | ~(-(bfd_vma) 1 >> 1));
      sign = sign >> howto->bitpos << howto->rightshift;
      val = (val ^ sign) - sign;
    }
  return val;
}

static void
insert_rel_addend (bfd *abfd,
		   bfd_byte *where,
		   reloc_howto_type *howto,
		   bfd_vma addend)
{
  bfd_vma insn;

  addend = (addend >> howto->rightshift << howto->bitpos) & howto->dst_mask;
  insn = ~howto->dst_mask;
  switch (howto->size)
    {
    case 0:
      insn &= bfd_get_8 (abfd, where);
      insn |= addend;
      bfd_put_8 (abfd, insn, where);
      break;
    case 1:
      insn &= bfd_get_16 (abfd, where);
      insn |= addend;
      bfd_put_16 (abfd, insn, where);
      break;
    case 2:
      insn &= bfd_get_32 (abfd, where);
      insn |= addend;
      bfd_put_32 (abfd, insn, where);
      break;
    default:
      abort ();
    }
}

/* Relocate a D10V ELF section.  */

static bfd_boolean
elf32_d10v_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, *relend;
  const char *name;

  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (input_bfd);

  rel = relocs;
  relend = relocs + input_section->reloc_count;
  for (; rel < relend; rel++)
    {
      int r_type;
      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;

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

      if (r_type == R_D10V_GNU_VTENTRY
	  || r_type == R_D10V_GNU_VTINHERIT)
	continue;

      howto = elf_d10v_howto_table + r_type;
      h = NULL;
      sym = NULL;
      sec = NULL;
      if (r_symndx < symtab_hdr->sh_info)
	{
	  sym = local_syms + r_symndx;
	  sec = local_sections[r_symndx];
	  relocation = (sec->output_section->vma
			+ sec->output_offset
			+ sym->st_value);
	  if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
	      && ((sec->flags & SEC_MERGE) != 0
		  || (bfd_link_relocatable (info)
		      && sec->output_offset != 0)))
	    {
	      bfd_vma addend;
	      bfd_byte *where = contents + rel->r_offset;

	      addend = extract_rel_addend (input_bfd, where, howto);

	      if (bfd_link_relocatable (info))
		addend += sec->output_offset;
	      else
		{
		  asection *msec = sec;
		  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
						   addend);
		  addend -= relocation;
		  addend += msec->output_section->vma + msec->output_offset;
		}
	      insert_rel_addend (input_bfd, where, howto, addend);
	    }
	}
      else
	{
	  bfd_boolean unresolved_reloc, 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);
	}

      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;

      if (h != NULL)
	name = h->root.root.string;
      else
	{
	  name = (bfd_elf_string_from_elf_section
		  (input_bfd, symtab_hdr->sh_link, sym->st_name));
	  if (name == NULL || *name == '\0')
	    name = bfd_section_name (input_bfd, sec);
	}

      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
				    contents, rel->r_offset,
				    relocation, (bfd_vma) 0);

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

	  switch (r)
	    {
	    case bfd_reloc_overflow:
	      (*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:
	      (*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");
	      goto common_error;

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

	    case bfd_reloc_dangerous:
	      msg = _("internal error: dangerous error");
	      goto common_error;

	    default:
	      msg = _("internal error: unknown error");
	      /* fall through */

	    common_error:
	      (*info->callbacks->warning) (info, msg, name, input_bfd,
					   input_section, rel->r_offset);
	      break;
	    }
	}
    }

  return TRUE;
}
#define ELF_ARCH		bfd_arch_d10v
#define ELF_MACHINE_CODE	EM_D10V
#define ELF_MACHINE_ALT1	EM_CYGNUS_D10V
#define ELF_MAXPAGESIZE		0x1000

#define TARGET_BIG_SYM		d10v_elf32_vec
#define TARGET_BIG_NAME		"elf32-d10v"

#define elf_info_to_howto		     NULL
#define elf_info_to_howto_rel		     d10v_info_to_howto_rel
#define elf_backend_object_p		     0
#define elf_backend_gc_mark_hook	     elf32_d10v_gc_mark_hook
#define elf_backend_check_relocs	     elf32_d10v_check_relocs
#define elf_backend_relocate_section	     elf32_d10v_relocate_section
#define elf_backend_can_gc_sections	     1

#include "elf32-target.h"
Commit	Line	Data
252b5132	1	/* D10V-specific support for 32-bit ELF
82704155	2	Copyright (C) 1996-2019 Free Software Foundation, Inc.
252b5132 RH	3	Contributed by Martin Hunt (hunt@cygnus.com).
252b5132 RH	4
47b0e7ad	5	This file is part of BFD, the Binary File Descriptor library.
252b5132	6
47b0e7ad NC	7	This program is free software; you can redistribute it and/or modify
47b0e7ad NC	8	it under the terms of the GNU General Public License as published by
cd123cb7	9	the Free Software Foundation; either version 3 of the License, or
47b0e7ad	10	(at your option) any later version.
252b5132	11
47b0e7ad NC	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
252b5132	16
47b0e7ad NC	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	20	MA 02110-1301, USA. */
252b5132	21
252b5132	22	#include "sysdep.h"
3db64b00	23	#include "bfd.h"
252b5132 RH	24	#include "libbfd.h"
252b5132 RH	25	#include "elf-bfd.h"
1b452ec6	26	#include "elf/d10v.h"
252b5132	27
917583ad	28	/* Use REL instead of RELA to save space. */
acf8aed4	29	#define USE_REL 1
252b5132	30
252b5132	31	static reloc_howto_type elf_d10v_howto_table[] =
47b0e7ad NC	32	{
	33	/* This reloc does nothing. */
	34	HOWTO (R_D10V_NONE, /* Type. */
	35	0, /* Rightshift. */
6346d5ca AM	36	3, /* Size (0 = byte, 1 = short, 2 = long). */
6346d5ca AM	37	0, /* Bitsize. */
47b0e7ad NC	38	FALSE, /* PC_relative. */
	39	0, /* Bitpos. */
	40	complain_overflow_dont,/* Complain_on_overflow. */
	41	bfd_elf_generic_reloc, /* Special_function. */
	42	"R_D10V_NONE", /* Name. */
	43	FALSE, /* Partial_inplace. */
	44	0, /* Src_mask. */
	45	0, /* Dst_mask. */
	46	FALSE), /* PCrel_offset. */
	47
	48	/* An PC Relative 10-bit relocation, shifted by 2, right container. */
	49	HOWTO (R_D10V_10_PCREL_R, /* Type. */
07d6d2b8 AM	50	2, /* Rightshift. */
	51	2, /* Size (0 = byte, 1 = short, 2 = long). */
	52	8, /* Bitsize. */
	53	TRUE, /* PC_relative. */
	54	0, /* Bitpos. */
a7985d73	55	complain_overflow_signed, /* Complain_on_overflow. */
47b0e7ad NC	56	bfd_elf_generic_reloc, /* Special_function. */
47b0e7ad NC	57	"R_D10V_10_PCREL_R", /* Name. */
07d6d2b8	58	FALSE, /* Partial_inplace. */
47b0e7ad	59	0xff, /* Src_mask. */
07d6d2b8	60	0xff, /* Dst_mask. */
47b0e7ad NC	61	TRUE), /* PCrel_offset. */
	62
	63	/* An PC Relative 10-bit relocation, shifted by 2, left container. */
	64	HOWTO (R_D10V_10_PCREL_L, /* Type. */
07d6d2b8 AM	65	2, /* Rightshift. */
	66	2, /* Size (0 = byte, 1 = short, 2 = long). */
	67	8, /* Bitsize. */
	68	TRUE, /* PC_relative. */
	69	15, /* Bitpos. */
a7985d73	70	complain_overflow_signed, /* Complain_on_overflow. */
47b0e7ad NC	71	bfd_elf_generic_reloc, /* Special_function. */
47b0e7ad NC	72	"R_D10V_10_PCREL_L", /* Name. */
07d6d2b8	73	FALSE, /* Partial_inplace. */
47b0e7ad	74	0x07f8000, /* Src_mask. */
07d6d2b8	75	0x07f8000, /* Dst_mask. */
47b0e7ad NC	76	TRUE), /* PCrel_offset. */
	77
	78	/* A 16 bit absolute relocation. */
	79	HOWTO (R_D10V_16, /* Type. */
	80	0, /* Rightshift. */
	81	1, /* Size (0 = byte, 1 = short, 2 = long). */
	82	16, /* Bitsize. */
	83	FALSE, /* PC_relative. */
	84	0, /* Bitpos. */
	85	complain_overflow_dont,/* Complain_on_overflow. */
	86	bfd_elf_generic_reloc, /* Special_function. */
	87	"R_D10V_16", /* Name. */
	88	FALSE, /* Partial_inplace. */
	89	0xffff, /* Src_mask. */
	90	0xffff, /* Dst_mask. */
	91	FALSE), /* PCrel_offset. */
	92
	93	/* An 18 bit absolute relocation, right shifted 2. */
	94	HOWTO (R_D10V_18, /* Type. */
	95	2, /* Rightshift. */
	96	1, /* Size (0 = byte, 1 = short, 2 = long). */
	97	16, /* Bitsize. */
	98	FALSE, /* PC_relative. */
	99	0, /* Bitpos. */
	100	complain_overflow_dont, /* Complain_on_overflow. */
	101	bfd_elf_generic_reloc, /* Special_function. */
	102	"R_D10V_18", /* Name. */
	103	FALSE, /* Partial_inplace. */
	104	0xffff, /* Src_mask. */
	105	0xffff, /* Dst_mask. */
	106	FALSE), /* PCrel_offset. */
	107
	108	/* A relative 18 bit relocation, right shifted by 2. */
	109	HOWTO (R_D10V_18_PCREL, /* Type. */
	110	2, /* Rightshift. */
	111	2, /* Size (0 = byte, 1 = short, 2 = long). */
a7985d73	112	16, /* Bitsize. */
47b0e7ad NC	113	TRUE, /* PC_relative. */
47b0e7ad NC	114	0, /* Bitpos. */
a7985d73	115	complain_overflow_signed, /* Complain_on_overflow. */
47b0e7ad NC	116	bfd_elf_generic_reloc, /* Special_function. */
	117	"R_D10V_18_PCREL", /* Name. */
	118	FALSE, /* Partial_inplace. */
	119	0xffff, /* Src_mask. */
	120	0xffff, /* Dst_mask. */
	121	TRUE), /* PCrel_offset. */
	122
	123	/* A 32 bit absolute relocation. */
	124	HOWTO (R_D10V_32, /* Type. */
	125	0, /* Rightshift. */
	126	2, /* Size (0 = byte, 1 = short, 2 = long). */
	127	32, /* Bitsize. */
	128	FALSE, /* PC_relative. */
	129	0, /* Bitpos. */
	130	complain_overflow_dont,/* Complain_on_overflow. */
	131	bfd_elf_generic_reloc, /* Special_function. */
	132	"R_D10V_32", /* Name. */
	133	FALSE, /* Partial_inplace. */
	134	0xffffffff, /* Src_mask. */
	135	0xffffffff, /* Dst_mask. */
	136	FALSE), /* PCrel_offset. */
	137
	138	/* GNU extension to record C++ vtable hierarchy. */
	139	HOWTO (R_D10V_GNU_VTINHERIT, /* Type. */
07d6d2b8 AM	140	0, /* Rightshift. */
	141	2, /* Size (0 = byte, 1 = short, 2 = long). */
	142	0, /* Bitsize. */
	143	FALSE, /* PC_relative. */
	144	0, /* Bitpos. */
47b0e7ad	145	complain_overflow_dont,/* Complain_on_overflow. */
07d6d2b8	146	NULL, /* Special_function. */
47b0e7ad	147	"R_D10V_GNU_VTINHERIT",/* Name. */
07d6d2b8 AM	148	FALSE, /* Partial_inplace. */
	149	0, /* Src_mask. */
	150	0, /* Dst_mask. */
	151	FALSE), /* PCrel_offset. */
47b0e7ad NC	152
47b0e7ad NC	153	/* GNU extension to record C++ vtable member usage. */
07d6d2b8 AM	154	HOWTO (R_D10V_GNU_VTENTRY, /* Type. */
	155	0, /* Rightshift. */
	156	2, /* Size (0 = byte, 1 = short, 2 = long). */
	157	0, /* Bitsize. */
	158	FALSE, /* PC_relative. */
	159	0, /* Bitpos. */
47b0e7ad NC	160	complain_overflow_dont,/* Complain_on_overflow. */
47b0e7ad NC	161	_bfd_elf_rel_vtable_reloc_fn, /* Special_function. */
07d6d2b8 AM	162	"R_D10V_GNU_VTENTRY", /* Name. */
	163	FALSE, /* Partial_inplace. */
	164	0, /* Src_mask. */
	165	0, /* Dst_mask. */
	166	FALSE), /* PCrel_offset. */
47b0e7ad	167	};
252b5132 RH	168
	169	/* Map BFD reloc types to D10V ELF reloc types. */
	170
	171	struct d10v_reloc_map
47b0e7ad NC	172	{
	173	bfd_reloc_code_real_type bfd_reloc_val;
	174	unsigned char elf_reloc_val;
	175	};
917583ad NC	176
917583ad NC	177	static const struct d10v_reloc_map d10v_reloc_map[] =
47b0e7ad NC	178	{
	179	{ BFD_RELOC_NONE, R_D10V_NONE, },
	180	{ BFD_RELOC_D10V_10_PCREL_R, R_D10V_10_PCREL_R },
	181	{ BFD_RELOC_D10V_10_PCREL_L, R_D10V_10_PCREL_L },
	182	{ BFD_RELOC_16, R_D10V_16 },
	183	{ BFD_RELOC_D10V_18, R_D10V_18 },
	184	{ BFD_RELOC_D10V_18_PCREL, R_D10V_18_PCREL },
	185	{ BFD_RELOC_32, R_D10V_32 },
	186	{ BFD_RELOC_VTABLE_INHERIT, R_D10V_GNU_VTINHERIT },
	187	{ BFD_RELOC_VTABLE_ENTRY, R_D10V_GNU_VTENTRY },
	188	};
252b5132 RH	189
252b5132 RH	190	static reloc_howto_type *
47b0e7ad NC	191	bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
47b0e7ad NC	192	bfd_reloc_code_real_type code)
252b5132 RH	193	{
	194	unsigned int i;
	195
	196	for (i = 0;
	197	i < sizeof (d10v_reloc_map) / sizeof (struct d10v_reloc_map);
	198	i++)
47b0e7ad NC	199	if (d10v_reloc_map[i].bfd_reloc_val == code)
47b0e7ad NC	200	return &elf_d10v_howto_table[d10v_reloc_map[i].elf_reloc_val];
252b5132 RH	201
	202	return NULL;
	203	}
	204
157090f7 AM	205	static reloc_howto_type *
	206	bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
	207	const char *r_name)
	208	{
	209	unsigned int i;
	210
	211	for (i = 0;
	212	i < sizeof (elf_d10v_howto_table) / sizeof (elf_d10v_howto_table[0]);
	213	i++)
	214	if (elf_d10v_howto_table[i].name != NULL
	215	&& strcasecmp (elf_d10v_howto_table[i].name, r_name) == 0)
	216	return &elf_d10v_howto_table[i];
	217
	218	return NULL;
	219	}
	220
252b5132 RH	221	/* Set the howto pointer for an D10V ELF reloc. */
252b5132 RH	222
f3185997	223	static bfd_boolean
0aa13fee	224	d10v_info_to_howto_rel (bfd *abfd,
47b0e7ad NC	225	arelent *cache_ptr,
47b0e7ad NC	226	Elf_Internal_Rela *dst)
252b5132 RH	227	{
	228	unsigned int r_type;
	229
	230	r_type = ELF32_R_TYPE (dst->r_info);
5860e3f8 NC	231	if (r_type >= (unsigned int) R_D10V_max)
5860e3f8 NC	232	{
695344c0	233	/* xgettext:c-format */
0aa13fee AM	234	_bfd_error_handler (_("%pB: unsupported relocation type %#x"),
0aa13fee AM	235	abfd, r_type);
f3185997 NC	236	bfd_set_error (bfd_error_bad_value);
f3185997 NC	237	return FALSE;
5860e3f8	238	}
252b5132	239	cache_ptr->howto = &elf_d10v_howto_table[r_type];
f3185997	240	return TRUE;
252b5132 RH	241	}
	242
	243	static asection *
47b0e7ad	244	elf32_d10v_gc_mark_hook (asection *sec,
07adf181	245	struct bfd_link_info *info,
47b0e7ad NC	246	Elf_Internal_Rela *rel,
	247	struct elf_link_hash_entry *h,
	248	Elf_Internal_Sym *sym)
252b5132 RH	249	{
252b5132 RH	250	if (h != NULL)
07adf181	251	switch (ELF32_R_TYPE (rel->r_info))
252b5132 RH	252	{
	253	case R_D10V_GNU_VTINHERIT:
	254	case R_D10V_GNU_VTENTRY:
07adf181 AM	255	return NULL;
07adf181 AM	256	}
1e2f5b6e	257
07adf181	258	return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132 RH	259	}
	260
	261	/* Look through the relocs for a section during the first phase.
	262	Since we don't do .gots or .plts, we just need to consider the
	263	virtual table relocs for gc. */
a7c10850	264
b34976b6	265	static bfd_boolean
47b0e7ad NC	266	elf32_d10v_check_relocs (bfd *abfd,
	267	struct bfd_link_info *info,
	268	asection *sec,
	269	const Elf_Internal_Rela *relocs)
252b5132 RH	270	{
252b5132 RH	271	Elf_Internal_Shdr *symtab_hdr;
5582a088	272	struct elf_link_hash_entry **sym_hashes;
252b5132 RH	273	const Elf_Internal_Rela *rel;
252b5132 RH	274	const Elf_Internal_Rela *rel_end;
a7c10850	275
0e1862bb	276	if (bfd_link_relocatable (info))
b34976b6	277	return TRUE;
a7c10850	278
252b5132 RH	279	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
252b5132 RH	280	sym_hashes = elf_sym_hashes (abfd);
a7c10850	281
252b5132 RH	282	rel_end = relocs + sec->reloc_count;
	283	for (rel = relocs; rel < rel_end; rel++)
	284	{
	285	struct elf_link_hash_entry *h;
	286	unsigned long r_symndx;
a7c10850	287
252b5132 RH	288	r_symndx = ELF32_R_SYM (rel->r_info);
252b5132 RH	289	if (r_symndx < symtab_hdr->sh_info)
07d6d2b8	290	h = NULL;
252b5132	291	else
973a3492 L	292	{
	293	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	294	while (h->root.type == bfd_link_hash_indirect
	295	\|\| h->root.type == bfd_link_hash_warning)
	296	h = (struct elf_link_hash_entry *) h->root.u.i.link;
	297	}
a7c10850	298
252b5132	299	switch (ELF32_R_TYPE (rel->r_info))
07d6d2b8 AM	300	{
	301	/* This relocation describes the C++ object vtable hierarchy.
	302	Reconstruct it for later use during GC. */
	303	case R_D10V_GNU_VTINHERIT:
	304	if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
	305	return FALSE;
	306	break;
	307
	308	/* This relocation describes which C++ vtable entries are actually
	309	used. Record for later use during GC. */
	310	case R_D10V_GNU_VTENTRY:
a0ea3a14	311	if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
07d6d2b8 AM	312	return FALSE;
	313	break;
	314	}
252b5132	315	}
a7c10850	316
b34976b6	317	return TRUE;
252b5132 RH	318	}
252b5132 RH	319
a2b0fe9d	320	static bfd_vma
47b0e7ad NC	321	extract_rel_addend (bfd *abfd,
	322	bfd_byte *where,
	323	reloc_howto_type *howto)
a2b0fe9d AM	324	{
	325	bfd_vma insn, val;
	326
	327	switch (howto->size)
	328	{
	329	case 0:
	330	insn = bfd_get_8 (abfd, where);
	331	break;
	332	case 1:
	333	insn = bfd_get_16 (abfd, where);
	334	break;
	335	case 2:
	336	insn = bfd_get_32 (abfd, where);
	337	break;
	338	default:
	339	abort ();
	340	}
	341
	342	val = (insn & howto->dst_mask) >> howto->bitpos << howto->rightshift;
	343	/* We should really be testing for signed addends here, but we don't
	344	have that info directly in the howto. */
	345	if (howto->pc_relative)
	346	{
	347	bfd_vma sign;
	348	sign = howto->dst_mask & (~howto->dst_mask >> 1 \| ~(-(bfd_vma) 1 >> 1));
	349	sign = sign >> howto->bitpos << howto->rightshift;
	350	val = (val ^ sign) - sign;
	351	}
	352	return val;
	353	}
	354
	355	static void
47b0e7ad NC	356	insert_rel_addend (bfd *abfd,
	357	bfd_byte *where,
	358	reloc_howto_type *howto,
	359	bfd_vma addend)
a2b0fe9d AM	360	{
	361	bfd_vma insn;
	362
	363	addend = (addend >> howto->rightshift << howto->bitpos) & howto->dst_mask;
	364	insn = ~howto->dst_mask;
	365	switch (howto->size)
	366	{
	367	case 0:
	368	insn &= bfd_get_8 (abfd, where);
	369	insn \|= addend;
	370	bfd_put_8 (abfd, insn, where);
	371	break;
	372	case 1:
	373	insn &= bfd_get_16 (abfd, where);
	374	insn \|= addend;
	375	bfd_put_16 (abfd, insn, where);
	376	break;
	377	case 2:
	378	insn &= bfd_get_32 (abfd, where);
	379	insn \|= addend;
	380	bfd_put_32 (abfd, insn, where);
	381	break;
	382	default:
	383	abort ();
	384	}
	385	}
	386
252b5132	387	/* Relocate a D10V ELF section. */
47b0e7ad	388
b34976b6	389	static bfd_boolean
47b0e7ad NC	390	elf32_d10v_relocate_section (bfd *output_bfd,
	391	struct bfd_link_info *info,
	392	bfd *input_bfd,
	393	asection *input_section,
	394	bfd_byte *contents,
	395	Elf_Internal_Rela *relocs,
	396	Elf_Internal_Sym *local_syms,
	397	asection **local_sections)
252b5132 RH	398	{
	399	Elf_Internal_Shdr *symtab_hdr;
	400	struct elf_link_hash_entry **sym_hashes;
	401	Elf_Internal_Rela rel, relend;
	402	const char *name;
	403
	404	symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
	405	sym_hashes = elf_sym_hashes (input_bfd);
	406
	407	rel = relocs;
	408	relend = relocs + input_section->reloc_count;
	409	for (; rel < relend; rel++)
	410	{
	411	int r_type;
	412	reloc_howto_type *howto;
	413	unsigned long r_symndx;
	414	Elf_Internal_Sym *sym;
	415	asection *sec;
	416	struct elf_link_hash_entry *h;
	417	bfd_vma relocation;
	418	bfd_reloc_status_type r;
	419
	420	r_symndx = ELF32_R_SYM (rel->r_info);
	421	r_type = ELF32_R_TYPE (rel->r_info);
	422
	423	if (r_type == R_D10V_GNU_VTENTRY
07d6d2b8 AM	424	\|\| r_type == R_D10V_GNU_VTINHERIT)
07d6d2b8 AM	425	continue;
252b5132 RH	426
252b5132 RH	427	howto = elf_d10v_howto_table + r_type;
252b5132 RH	428	h = NULL;
	429	sym = NULL;
	430	sec = NULL;
	431	if (r_symndx < symtab_hdr->sh_info)
	432	{
	433	sym = local_syms + r_symndx;
	434	sec = local_sections[r_symndx];
a2b0fe9d AM	435	relocation = (sec->output_section->vma
	436	+ sec->output_offset
	437	+ sym->st_value);
ab96bf03 AM	438	if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
ab96bf03 AM	439	&& ((sec->flags & SEC_MERGE) != 0
0e1862bb	440	\|\| (bfd_link_relocatable (info)
ab96bf03	441	&& sec->output_offset != 0)))
a2b0fe9d	442	{
a2b0fe9d AM	443	bfd_vma addend;
	444	bfd_byte *where = contents + rel->r_offset;
	445
	446	addend = extract_rel_addend (input_bfd, where, howto);
ab96bf03	447
0e1862bb	448	if (bfd_link_relocatable (info))
ab96bf03 AM	449	addend += sec->output_offset;
	450	else
	451	{
	452	asection *msec = sec;
	453	addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
	454	addend);
	455	addend -= relocation;
	456	addend += msec->output_section->vma + msec->output_offset;
	457	}
a2b0fe9d AM	458	insert_rel_addend (input_bfd, where, howto, addend);
a2b0fe9d AM	459	}
252b5132 RH	460	}
	461	else
	462	{
62d887d4	463	bfd_boolean unresolved_reloc, warned, ignored;
59c2e50f	464
b2a8e766 AM	465	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
	466	r_symndx, symtab_hdr, sym_hashes,
	467	h, sec, relocation,
62d887d4	468	unresolved_reloc, warned, ignored);
252b5132 RH	469	}
252b5132 RH	470
dbaa2011	471	if (sec != NULL && discarded_section (sec))
e4067dbb	472	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b	473	rel, 1, relend, howto, 0, contents);
b1e24c02	474
0e1862bb	475	if (bfd_link_relocatable (info))
ab96bf03 AM	476	continue;
ab96bf03 AM	477
252b5132 RH	478	if (h != NULL)
	479	name = h->root.root.string;
	480	else
	481	{
	482	name = (bfd_elf_string_from_elf_section
	483	(input_bfd, symtab_hdr->sh_link, sym->st_name));
	484	if (name == NULL \|\| *name == '\0')
	485	name = bfd_section_name (input_bfd, sec);
	486	}
a7c10850	487
252b5132	488	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
07d6d2b8 AM	489	contents, rel->r_offset,
07d6d2b8 AM	490	relocation, (bfd_vma) 0);
252b5132 RH	491
	492	if (r != bfd_reloc_ok)
	493	{
	494	const char * msg = (const char *) 0;
	495
	496	switch (r)
	497	{
	498	case bfd_reloc_overflow:
1a72702b AM	499	(*info->callbacks->reloc_overflow)
	500	(info, (h ? &h->root : NULL), name, howto->name,
	501	(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
252b5132 RH	502	break;
	503
	504	case bfd_reloc_undefined:
1a72702b AM	505	(*info->callbacks->undefined_symbol)
1a72702b AM	506	(info, name, input_bfd, input_section, rel->r_offset, TRUE);
252b5132 RH	507	break;
	508
	509	case bfd_reloc_outofrange:
517662d4	510	msg = _("internal error: out of range error");
252b5132 RH	511	goto common_error;
	512
	513	case bfd_reloc_notsupported:
517662d4	514	msg = _("internal error: unsupported relocation error");
252b5132 RH	515	goto common_error;
	516
	517	case bfd_reloc_dangerous:
517662d4	518	msg = _("internal error: dangerous error");
252b5132 RH	519	goto common_error;
	520
	521	default:
517662d4	522	msg = _("internal error: unknown error");
252b5132 RH	523	/* fall through */
	524
	525	common_error:
1a72702b AM	526	(*info->callbacks->warning) (info, msg, name, input_bfd,
1a72702b AM	527	input_section, rel->r_offset);
252b5132 RH	528	break;
	529	}
	530	}
	531	}
	532
b34976b6	533	return TRUE;
252b5132 RH	534	}
252b5132 RH	535	#define ELF_ARCH bfd_arch_d10v
aa4f99bb AO	536	#define ELF_MACHINE_CODE EM_D10V
aa4f99bb AO	537	#define ELF_MACHINE_ALT1 EM_CYGNUS_D10V
252b5132 RH	538	#define ELF_MAXPAGESIZE 0x1000
252b5132 RH	539
07d6d2b8	540	#define TARGET_BIG_SYM d10v_elf32_vec
252b5132 RH	541	#define TARGET_BIG_NAME "elf32-d10v"
252b5132 RH	542
f3185997	543	#define elf_info_to_howto NULL
07d6d2b8 AM	544	#define elf_info_to_howto_rel d10v_info_to_howto_rel
07d6d2b8 AM	545	#define elf_backend_object_p 0
07d6d2b8 AM	546	#define elf_backend_gc_mark_hook elf32_d10v_gc_mark_hook
	547	#define elf_backend_check_relocs elf32_d10v_check_relocs
	548	#define elf_backend_relocate_section elf32_d10v_relocate_section
	549	#define elf_backend_can_gc_sections 1
252b5132 RH	550
252b5132 RH	551	#include "elf32-target.h"