[thirdparty/binutils-gdb.git] / bfd / elf32-or32.c

/* OR32-specific support for 32-bit ELF
   Copyright 2002 Free Software Foundation, Inc.
   Contributed by Ivan Guzvinec  <ivang@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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/or32.h"
#include "libiberty.h"

static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  PARAMS ((bfd *, bfd_reloc_code_real_type));
static void or32_info_to_howto_rel
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
static bfd_boolean or32_elf_object_p
  PARAMS ((bfd *));
static void or32_elf_final_write_processing
  PARAMS ((bfd *, bfd_boolean));
static bfd_reloc_status_type or32_elf_32_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type or32_elf_16_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type or32_elf_8_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type or32_elf_const_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type or32_elf_consth_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type or32_elf_jumptarg_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));

/* Try to minimize the amount of space occupied by relocation tables
   on the ROM (not that the ROM won't be swamped by other ELF overhead).  */
#define USE_REL	1

static reloc_howto_type elf_or32_howto_table[] =
{
  /* This reloc does nothing.  */
  HOWTO (R_OR32_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_OR32_NONE",		/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A standard 32 bit relocation.  */
  HOWTO (R_OR32_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 */
	 or32_elf_32_reloc, 	/* special_function */
	 "R_OR32_32",		/* name */
	 FALSE,	                /* partial_inplace */
	 0xffffffff,	        /* src_mask */
	 0xffffffff,   		/* dst_mask */
	 FALSE),                /* pcrel_offset */

  /* A standard 16 bit relocation.  */
  HOWTO (R_OR32_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 */
	 or32_elf_16_reloc, 	/* special_function */
	 "R_OR32_16",		/* name */
	 FALSE,	                /* partial_inplace */
	 0x0000ffff,	        /* src_mask */
	 0x0000ffff,   		/* dst_mask */
	 FALSE),                /* pcrel_offset */

  /* A standard 8 bit relocation.  */
  HOWTO (R_OR32_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 */
	 or32_elf_8_reloc, 	/* special_function */
	 "R_OR32_8",		/* name */
	 FALSE,	                /* partial_inplace */
	 0x000000ff,	        /* src_mask */
	 0x000000ff,   		/* dst_mask */
	 FALSE),                /* pcrel_offset */

  /* A standard low 16 bit relocation.  */
  HOWTO (R_OR32_CONST,		/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 or32_elf_const_reloc,	/* special_function */
	 "R_OR32_CONST",	/* name */
	 FALSE,			/* partial_inplace */
	 0x0000ffff,		/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A standard high 16 bit relocation.  */
  HOWTO (R_OR32_CONSTH,		/* type */
	 16,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 or32_elf_consth_reloc,	/* special_function */
	 "R_OR32_CONSTH",	/* name */
	 FALSE,			/* partial_inplace */
	 0xffff0000,		/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A standard branch relocation.  */
  HOWTO (R_OR32_JUMPTARG,	/* type */
	 2,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 28,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 or32_elf_jumptarg_reloc,/* special_function */
	 "R_OR32_JUMPTARG",	/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0x03ffffff,		/* dst_mask */
	 TRUE), 		/* pcrel_offset */

  /* GNU extension to record C++ vtable hierarchy.  */
  HOWTO (R_OR32_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_OR32_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_OR32_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_OR32_GNU_VTENTRY",   /* name */
         FALSE,                 /* partial_inplace */
         0,                     /* src_mask */
         0,                     /* dst_mask */
         FALSE),                /* pcrel_offset */
};

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

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

static const struct or32_reloc_map or32_reloc_map[] =
{
  { BFD_RELOC_NONE, R_OR32_NONE },
  { BFD_RELOC_32, R_OR32_32 },
  { BFD_RELOC_16, R_OR32_16 },
  { BFD_RELOC_8, R_OR32_8 },
  { BFD_RELOC_LO16, R_OR32_CONST },
  { BFD_RELOC_HI16, R_OR32_CONSTH },
  { BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },
  { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
  { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
};

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

  for (i = ARRAY_SIZE (or32_reloc_map); i--;)
    {
      if (or32_reloc_map[i].bfd_reloc_val == code)
	return &elf_or32_howto_table[or32_reloc_map[i].elf_reloc_val];
    }

  return NULL;
}

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

static void
or32_info_to_howto_rel (abfd, cache_ptr, dst)
     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_OR32_max);
  cache_ptr->howto = &elf_or32_howto_table[r_type];
}

/* Set the right machine number for an OR32 ELF file.  */

static bfd_boolean
or32_elf_object_p (abfd)
     bfd *abfd;
{
  (void) bfd_default_set_arch_mach (abfd, bfd_arch_or32, 0);
  return TRUE;
}

/* The final processing done just before writing out an OR32 ELF object file.
   This gets the OR32 architecture right based on the machine number.  */

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

  switch (mach = bfd_get_mach (abfd))
    {
    /*
    case bfd_mach_arc_base:
      val = E_OR32_MACH_BASE;
      break;
    */
    default:
      val = 0;
      return;
    }

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

bfd_reloc_status_type
or32_elf_32_reloc (abfd, reloc_entry, symbol, data, input_section,
		   output_bfd, error_message)
     bfd *abfd;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
{
  if (output_bfd != (bfd *) NULL)
    {
      unsigned long insn;
      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
      insn += symbol->section->output_section->vma;
      insn += symbol->section->output_offset;
      insn += symbol->value;
      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;
    }

  return bfd_reloc_continue;
}

bfd_reloc_status_type
or32_elf_16_reloc (abfd, reloc_entry, symbol, data, input_section,
		   output_bfd, error_message)
     bfd *abfd;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
{
  if (output_bfd != (bfd *) NULL)
    {
      unsigned short insn;
      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);
      insn += symbol->section->output_section->vma;
      insn += symbol->section->output_offset;
      insn += symbol->value;
      bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;
    }

  return bfd_reloc_continue;
}

bfd_reloc_status_type
or32_elf_8_reloc (abfd, reloc_entry, symbol, data, input_section,
		  output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
{
  if (output_bfd != (bfd *) NULL)
    {
      unsigned char insn;
      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_8 (abfd, (bfd_byte *) data + addr);
      insn += symbol->section->output_section->vma;
      insn += symbol->section->output_offset;
      insn += symbol->value;
      bfd_put_8 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;
    }

  return bfd_reloc_continue;
}

/* Do a R_OR32_CONSTH relocation.  This has to be done in combination
   with a R_OR32_CONST reloc, because there is a carry from the LO16 to
   the HI16.  Here we just save the information we need; we do the
   actual relocation when we see the LO16.  OR32 ELF requires that the
   LO16 immediately follow the HI16.  As a GNU extension, we permit an
   arbitrary number of HI16 relocs to be associated with a single LO16
   reloc.  This extension permits gcc to output the HI and LO relocs
   itself. This code is copied from the elf32-mips.c.  */

struct or32_consth
{
  struct or32_consth *next;
  bfd_byte *addr;
  bfd_vma addend;
};

/* FIXME: This should not be a static variable.  */

static struct or32_consth *or32_consth_list;

bfd_reloc_status_type
or32_elf_consth_reloc (abfd, reloc_entry, symbol, data, input_section,
		       output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
{
  bfd_reloc_status_type ret;
  bfd_vma relocation;
  struct or32_consth *n;

  ret = bfd_reloc_ok;

  if (bfd_is_und_section (symbol->section)
      && output_bfd == (bfd *) NULL)
    ret = bfd_reloc_undefined;

  if (bfd_is_com_section (symbol->section))
    relocation = 0;
  else
    relocation = symbol->value;

  relocation += symbol->section->output_section->vma;
  relocation += symbol->section->output_offset;
  relocation += reloc_entry->addend;

  if (reloc_entry->address > input_section->_cooked_size)
    return bfd_reloc_outofrange;

  /* Save the information, and let LO16 do the actual relocation.  */
  n = (struct or32_consth *) bfd_malloc (sizeof *n);
  if (n == NULL)
    return bfd_reloc_outofrange;
  n->addr = (bfd_byte *) data + reloc_entry->address;
  n->addend = relocation;
  n->next = or32_consth_list;
  or32_consth_list = n;

  if (output_bfd != (bfd *) NULL)
    reloc_entry->address += input_section->output_offset;

  return ret;
}

/* Do a R_OR32_CONST relocation.  This is a straightforward 16 bit
   inplace relocation; this function exists in order to do the
   R_OR32_CONSTH relocation described above.  */

bfd_reloc_status_type
or32_elf_const_reloc (abfd, reloc_entry, symbol, data, input_section,
		      output_bfd, error_message)
     bfd *abfd;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message;
{
  if (or32_consth_list != NULL)
    {
      struct or32_consth *l;

      l = or32_consth_list;
      while (l != NULL)
	{
	  unsigned long insn;
	  unsigned long val;
          unsigned long vallo;
	  struct or32_consth *next;

	  /* Do the HI16 relocation.  Note that we actually don't need
	     to know anything about the LO16 itself, except where to
	     find the low 16 bits of the addend needed by the LO16.  */
	  insn = bfd_get_32 (abfd, l->addr);
	  vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
		   & 0xffff);
	  val = ((insn & 0xffff) << 16) + vallo;
	  val += l->addend;

	  insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
	  bfd_put_32 (abfd, insn, l->addr);

	  next = l->next;
	  free (l);
	  l = next;
	}

      or32_consth_list = NULL;
    }

  if (output_bfd != (bfd *) NULL)
    {
      unsigned long insn, tmp;
      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
      tmp = insn & 0x0000ffff;
      tmp += symbol->section->output_section->vma;
      tmp += symbol->section->output_offset;
      tmp += symbol->value;
      insn = (insn & 0xffff0000) | (tmp & 0x0000ffff);
      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;
    }

  /* Now do the LO16 reloc in the usual way.  */
  return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
				input_section, output_bfd, error_message);
}

bfd_reloc_status_type
or32_elf_jumptarg_reloc (abfd, reloc_entry, symbol, data, input_section,
			 output_bfd, error_message)
     bfd *abfd;
     arelent *reloc_entry;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
{
  if (output_bfd != (bfd *) NULL)
    {
      unsigned long insn, tmp;
      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
      tmp = insn | 0xfc000000;
      tmp -= (input_section->output_offset >> 2);
      insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);
      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;
    }

  return bfd_reloc_continue;
}

#define TARGET_LITTLE_SYM	bfd_elf32_or32_little_vec
#define TARGET_LITTLE_NAME	"elf32-littleor32"
#define TARGET_BIG_SYM		bfd_elf32_or32_big_vec
#define TARGET_BIG_NAME		"elf32-or32"
#define ELF_ARCH		bfd_arch_or32
#define ELF_MACHINE_CODE	EM_OR32
#define ELF_MAXPAGESIZE		0x1000

#define elf_info_to_howto	0
#define elf_info_to_howto_rel	or32_info_to_howto_rel
#define elf_backend_object_p	or32_elf_object_p
#define elf_backend_final_write_processing \
				or32_elf_final_write_processing

#include "elf32-target.h"
Commit	Line	Data
3b16e843	1	/* OR32-specific support for 32-bit ELF
b34976b6	2	Copyright 2002 Free Software Foundation, Inc.
3b16e843 NC	3	Contributed by Ivan Guzvinec <ivang@opencores.org>
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	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.
	16
	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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "elf-bfd.h"
	25	#include "elf/or32.h"
	26	#include "libiberty.h"
	27
b34976b6 AM	28	static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
	29	PARAMS ((bfd *, bfd_reloc_code_real_type));
	30	static void or32_info_to_howto_rel
	31	PARAMS ((bfd , arelent , Elf_Internal_Rela *));
	32	static bfd_boolean or32_elf_object_p
	33	PARAMS ((bfd *));
	34	static void or32_elf_final_write_processing
	35	PARAMS ((bfd *, bfd_boolean));
	36	static bfd_reloc_status_type or32_elf_32_reloc
	37	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	38	static bfd_reloc_status_type or32_elf_16_reloc
	39	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	40	static bfd_reloc_status_type or32_elf_8_reloc
	41	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	42	static bfd_reloc_status_type or32_elf_const_reloc
	43	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	44	static bfd_reloc_status_type or32_elf_consth_reloc
	45	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	46	static bfd_reloc_status_type or32_elf_jumptarg_reloc
	47	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
3b16e843 NC	48
	49	/* Try to minimize the amount of space occupied by relocation tables
	50	on the ROM (not that the ROM won't be swamped by other ELF overhead). */
acf8aed4	51	#define USE_REL 1
3b16e843 NC	52
	53	static reloc_howto_type elf_or32_howto_table[] =
	54	{
	55	/* This reloc does nothing. */
	56	HOWTO (R_OR32_NONE, /* type */
	57	0, /* rightshift */
	58	2, /* size (0 = byte, 1 = short, 2 = long) */
	59	32, /* bitsize */
b34976b6	60	FALSE, /* pc_relative */
3b16e843 NC	61	0, /* bitpos */
	62	complain_overflow_bitfield, /* complain_on_overflow */
	63	bfd_elf_generic_reloc, /* special_function */
	64	"R_OR32_NONE", /* name */
b34976b6	65	FALSE, /* partial_inplace */
3b16e843 NC	66	0, /* src_mask */
3b16e843 NC	67	0, /* dst_mask */
b34976b6	68	FALSE), /* pcrel_offset */
3b16e843 NC	69
	70	/* A standard 32 bit relocation. */
	71	HOWTO (R_OR32_32, /* type */
	72	0, /* rightshift */
	73	2, /* size (0 = byte, 1 = short, 2 = long) */
	74	32, /* bitsize */
b34976b6	75	FALSE, /* pc_relative */
3b16e843 NC	76	0, /* bitpos */
	77	complain_overflow_bitfield, /* complain_on_overflow */
	78	or32_elf_32_reloc, /* special_function */
	79	"R_OR32_32", /* name */
b34976b6	80	FALSE, /* partial_inplace */
3b16e843 NC	81	0xffffffff, /* src_mask */
3b16e843 NC	82	0xffffffff, /* dst_mask */
b34976b6	83	FALSE), /* pcrel_offset */
3b16e843 NC	84
	85	/* A standard 16 bit relocation. */
	86	HOWTO (R_OR32_16, /* type */
	87	0, /* rightshift */
	88	1, /* size (0 = byte, 1 = short, 2 = long) */
	89	16, /* bitsize */
b34976b6	90	FALSE, /* pc_relative */
3b16e843 NC	91	0, /* bitpos */
	92	complain_overflow_bitfield, /* complain_on_overflow */
	93	or32_elf_16_reloc, /* special_function */
	94	"R_OR32_16", /* name */
b34976b6	95	FALSE, /* partial_inplace */
3b16e843 NC	96	0x0000ffff, /* src_mask */
3b16e843 NC	97	0x0000ffff, /* dst_mask */
b34976b6	98	FALSE), /* pcrel_offset */
3b16e843 NC	99
	100	/* A standard 8 bit relocation. */
	101	HOWTO (R_OR32_8, /* type */
	102	0, /* rightshift */
	103	0, /* size (0 = byte, 1 = short, 2 = long) */
	104	8, /* bitsize */
b34976b6	105	FALSE, /* pc_relative */
3b16e843 NC	106	0, /* bitpos */
	107	complain_overflow_bitfield, /* complain_on_overflow */
	108	or32_elf_8_reloc, /* special_function */
	109	"R_OR32_8", /* name */
b34976b6	110	FALSE, /* partial_inplace */
3b16e843 NC	111	0x000000ff, /* src_mask */
3b16e843 NC	112	0x000000ff, /* dst_mask */
b34976b6	113	FALSE), /* pcrel_offset */
3b16e843 NC	114
	115	/* A standard low 16 bit relocation. */
	116	HOWTO (R_OR32_CONST, /* type */
	117	0, /* rightshift */
	118	2, /* size (0 = byte, 1 = short, 2 = long) */
	119	16, /* bitsize */
b34976b6	120	FALSE, /* pc_relative */
3b16e843 NC	121	0, /* bitpos */
	122	complain_overflow_dont, /* complain_on_overflow */
	123	or32_elf_const_reloc, /* special_function */
	124	"R_OR32_CONST", /* name */
b34976b6	125	FALSE, /* partial_inplace */
3b16e843 NC	126	0x0000ffff, /* src_mask */
3b16e843 NC	127	0x0000ffff, /* dst_mask */
b34976b6	128	FALSE), /* pcrel_offset */
3b16e843 NC	129
	130	/* A standard high 16 bit relocation. */
	131	HOWTO (R_OR32_CONSTH, /* type */
	132	16, /* rightshift */
	133	2, /* size (0 = byte, 1 = short, 2 = long) */
	134	16, /* bitsize */
b34976b6	135	TRUE, /* pc_relative */
3b16e843 NC	136	0, /* bitpos */
	137	complain_overflow_dont, /* complain_on_overflow */
	138	or32_elf_consth_reloc, /* special_function */
	139	"R_OR32_CONSTH", /* name */
b34976b6	140	FALSE, /* partial_inplace */
3b16e843 NC	141	0xffff0000, /* src_mask */
3b16e843 NC	142	0x0000ffff, /* dst_mask */
b34976b6	143	FALSE), /* pcrel_offset */
3b16e843 NC	144
	145	/* A standard branch relocation. */
	146	HOWTO (R_OR32_JUMPTARG, /* type */
	147	2, /* rightshift */
	148	2, /* size (0 = byte, 1 = short, 2 = long) */
	149	28, /* bitsize */
b34976b6	150	TRUE, /* pc_relative */
3b16e843 NC	151	0, /* bitpos */
	152	complain_overflow_signed, /* complain_on_overflow */
	153	or32_elf_jumptarg_reloc,/* special_function */
	154	"R_OR32_JUMPTARG", /* name */
b34976b6	155	FALSE, /* partial_inplace */
3b16e843 NC	156	0, /* src_mask */
3b16e843 NC	157	0x03ffffff, /* dst_mask */
b34976b6	158	TRUE), /* pcrel_offset */
3b16e843 NC	159
	160	/* GNU extension to record C++ vtable hierarchy. */
	161	HOWTO (R_OR32_GNU_VTINHERIT, /* type */
	162	0, /* rightshift */
	163	2, /* size (0 = byte, 1 = short, 2 = long) */
	164	0, /* bitsize */
b34976b6	165	FALSE, /* pc_relative */
3b16e843 NC	166	0, /* bitpos */
	167	complain_overflow_dont, /* complain_on_overflow */
	168	NULL, /* special_function */
	169	"R_OR32_GNU_VTINHERIT", /* name */
b34976b6	170	FALSE, /* partial_inplace */
3b16e843 NC	171	0, /* src_mask */
3b16e843 NC	172	0, /* dst_mask */
b34976b6	173	FALSE), /* pcrel_offset */
3b16e843 NC	174
	175	/* GNU extension to record C++ vtable member usage. */
	176	HOWTO (R_OR32_GNU_VTENTRY, /* type */
	177	0, /* rightshift */
	178	2, /* size (0 = byte, 1 = short, 2 = long) */
	179	0, /* bitsize */
b34976b6	180	FALSE, /* pc_relative */
3b16e843 NC	181	0, /* bitpos */
	182	complain_overflow_dont, /* complain_on_overflow */
	183	_bfd_elf_rel_vtable_reloc_fn, /* special_function */
	184	"R_OR32_GNU_VTENTRY", /* name */
b34976b6	185	FALSE, /* partial_inplace */
3b16e843 NC	186	0, /* src_mask */
3b16e843 NC	187	0, /* dst_mask */
b34976b6	188	FALSE), /* pcrel_offset */
3b16e843 NC	189	};
	190
	191	/* Map BFD reloc types to OR32 ELF reloc types. */
	192
	193	struct or32_reloc_map
	194	{
	195	bfd_reloc_code_real_type bfd_reloc_val;
	196	unsigned char elf_reloc_val;
	197	};
	198
	199	static const struct or32_reloc_map or32_reloc_map[] =
	200	{
	201	{ BFD_RELOC_NONE, R_OR32_NONE },
	202	{ BFD_RELOC_32, R_OR32_32 },
	203	{ BFD_RELOC_16, R_OR32_16 },
	204	{ BFD_RELOC_8, R_OR32_8 },
	205	{ BFD_RELOC_LO16, R_OR32_CONST },
	206	{ BFD_RELOC_HI16, R_OR32_CONSTH },
	207	{ BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },
	208	{ BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
	209	{ BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
	210	};
	211
	212	static reloc_howto_type *
	213	bfd_elf32_bfd_reloc_type_lookup (abfd, code)
	214	bfd *abfd ATTRIBUTE_UNUSED;
	215	bfd_reloc_code_real_type code;
	216	{
	217	unsigned int i;
	218
	219	for (i = ARRAY_SIZE (or32_reloc_map); i--;)
	220	{
	221	if (or32_reloc_map[i].bfd_reloc_val == code)
	222	return &elf_or32_howto_table[or32_reloc_map[i].elf_reloc_val];
	223	}
	224
	225	return NULL;
	226	}
	227
	228	/* Set the howto pointer for an OR32 ELF reloc. */
	229
	230	static void
	231	or32_info_to_howto_rel (abfd, cache_ptr, dst)
	232	bfd *abfd ATTRIBUTE_UNUSED;
	233	arelent *cache_ptr;
947216bf	234	Elf_Internal_Rela *dst;
3b16e843 NC	235	{
	236	unsigned int r_type;
	237
	238	r_type = ELF32_R_TYPE (dst->r_info);
	239	BFD_ASSERT (r_type < (unsigned int) R_OR32_max);
	240	cache_ptr->howto = &elf_or32_howto_table[r_type];
	241	}
	242
	243	/* Set the right machine number for an OR32 ELF file. */
	244
b34976b6	245	static bfd_boolean
3b16e843 NC	246	or32_elf_object_p (abfd)
	247	bfd *abfd;
	248	{
	249	(void) bfd_default_set_arch_mach (abfd, bfd_arch_or32, 0);
b34976b6	250	return TRUE;
3b16e843 NC	251	}
	252
	253	/* The final processing done just before writing out an OR32 ELF object file.
	254	This gets the OR32 architecture right based on the machine number. */
	255
	256	static void
	257	or32_elf_final_write_processing (abfd, linker)
	258	bfd *abfd;
b34976b6	259	bfd_boolean linker ATTRIBUTE_UNUSED;
3b16e843 NC	260	{
	261	int mach;
	262	unsigned long val;
	263
	264	switch (mach = bfd_get_mach (abfd))
	265	{
	266	/*
	267	case bfd_mach_arc_base:
	268	val = E_OR32_MACH_BASE;
	269	break;
	270	*/
	271	default:
	272	val = 0;
	273	return;
	274	}
	275
	276	elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;
	277	elf_elfheader (abfd)->e_flags \|= val;
	278	}
	279
	280	bfd_reloc_status_type
	281	or32_elf_32_reloc (abfd, reloc_entry, symbol, data, input_section,
	282	output_bfd, error_message)
	283	bfd *abfd;
	284	arelent *reloc_entry;
	285	asymbol *symbol;
	286	PTR data;
	287	asection *input_section;
	288	bfd *output_bfd;
	289	char **error_message ATTRIBUTE_UNUSED;
cedb70c5	290	{
3b16e843 NC	291	if (output_bfd != (bfd *) NULL)
	292	{
	293	unsigned long insn;
	294	bfd_size_type addr = reloc_entry->address;
	295
	296	reloc_entry->address += input_section->output_offset;
cedb70c5	297
3b16e843 NC	298	insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
	299	insn += symbol->section->output_section->vma;
	300	insn += symbol->section->output_offset;
	301	insn += symbol->value;
cedb70c5	302	bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
3b16e843 NC	303
	304	return bfd_reloc_ok;
	305	}
	306
	307	return bfd_reloc_continue;
	308	}
	309
	310	bfd_reloc_status_type
	311	or32_elf_16_reloc (abfd, reloc_entry, symbol, data, input_section,
	312	output_bfd, error_message)
	313	bfd *abfd;
	314	arelent *reloc_entry;
	315	asymbol *symbol;
	316	PTR data;
	317	asection *input_section;
	318	bfd *output_bfd;
	319	char **error_message ATTRIBUTE_UNUSED;
cedb70c5	320	{
3b16e843 NC	321	if (output_bfd != (bfd *) NULL)
	322	{
	323	unsigned short insn;
	324	bfd_size_type addr = reloc_entry->address;
	325
	326	reloc_entry->address += input_section->output_offset;
	327
	328	insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);
	329	insn += symbol->section->output_section->vma;
	330	insn += symbol->section->output_offset;
	331	insn += symbol->value;
cedb70c5	332	bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);
3b16e843 NC	333
	334	return bfd_reloc_ok;
	335	}
	336
	337	return bfd_reloc_continue;
	338	}
	339
	340	bfd_reloc_status_type
	341	or32_elf_8_reloc (abfd, reloc_entry, symbol, data, input_section,
	342	output_bfd, error_message)
	343	bfd *abfd ATTRIBUTE_UNUSED;
	344	arelent *reloc_entry;
	345	asymbol *symbol;
	346	PTR data;
	347	asection *input_section;
	348	bfd *output_bfd;
	349	char **error_message ATTRIBUTE_UNUSED;
cedb70c5	350	{
3b16e843 NC	351	if (output_bfd != (bfd *) NULL)
	352	{
	353	unsigned char insn;
	354	bfd_size_type addr = reloc_entry->address;
	355
	356	reloc_entry->address += input_section->output_offset;
	357
	358	insn = bfd_get_8 (abfd, (bfd_byte *) data + addr);
	359	insn += symbol->section->output_section->vma;
	360	insn += symbol->section->output_offset;
	361	insn += symbol->value;
cedb70c5	362	bfd_put_8 (abfd, insn, (bfd_byte *) data + addr);
3b16e843 NC	363
	364	return bfd_reloc_ok;
	365	}
	366
	367	return bfd_reloc_continue;
	368	}
	369
	370	/* Do a R_OR32_CONSTH relocation. This has to be done in combination
	371	with a R_OR32_CONST reloc, because there is a carry from the LO16 to
	372	the HI16. Here we just save the information we need; we do the
	373	actual relocation when we see the LO16. OR32 ELF requires that the
	374	LO16 immediately follow the HI16. As a GNU extension, we permit an
	375	arbitrary number of HI16 relocs to be associated with a single LO16
	376	reloc. This extension permits gcc to output the HI and LO relocs
	377	itself. This code is copied from the elf32-mips.c. */
	378
	379	struct or32_consth
	380	{
	381	struct or32_consth *next;
	382	bfd_byte *addr;
	383	bfd_vma addend;
	384	};
	385
	386	/* FIXME: This should not be a static variable. */
	387
	388	static struct or32_consth *or32_consth_list;
	389
	390	bfd_reloc_status_type
	391	or32_elf_consth_reloc (abfd, reloc_entry, symbol, data, input_section,
	392	output_bfd, error_message)
	393	bfd *abfd ATTRIBUTE_UNUSED;
	394	arelent *reloc_entry;
	395	asymbol *symbol;
	396	PTR data;
	397	asection *input_section;
	398	bfd *output_bfd;
	399	char **error_message ATTRIBUTE_UNUSED;
	400	{
	401	bfd_reloc_status_type ret;
	402	bfd_vma relocation;
	403	struct or32_consth *n;
cedb70c5	404
3b16e843 NC	405	ret = bfd_reloc_ok;
	406
	407	if (bfd_is_und_section (symbol->section)
	408	&& output_bfd == (bfd *) NULL)
	409	ret = bfd_reloc_undefined;
	410
	411	if (bfd_is_com_section (symbol->section))
	412	relocation = 0;
	413	else
	414	relocation = symbol->value;
	415
	416	relocation += symbol->section->output_section->vma;
	417	relocation += symbol->section->output_offset;
	418	relocation += reloc_entry->addend;
	419
	420	if (reloc_entry->address > input_section->_cooked_size)
	421	return bfd_reloc_outofrange;
	422
	423	/* Save the information, and let LO16 do the actual relocation. */
	424	n = (struct or32_consth ) bfd_malloc (sizeof n);
	425	if (n == NULL)
	426	return bfd_reloc_outofrange;
	427	n->addr = (bfd_byte *) data + reloc_entry->address;
	428	n->addend = relocation;
	429	n->next = or32_consth_list;
	430	or32_consth_list = n;
	431
	432	if (output_bfd != (bfd *) NULL)
	433	reloc_entry->address += input_section->output_offset;
	434
	435	return ret;
	436	}
	437
	438	/* Do a R_OR32_CONST relocation. This is a straightforward 16 bit
	439	inplace relocation; this function exists in order to do the
	440	R_OR32_CONSTH relocation described above. */
	441
	442	bfd_reloc_status_type
	443	or32_elf_const_reloc (abfd, reloc_entry, symbol, data, input_section,
	444	output_bfd, error_message)
	445	bfd *abfd;
	446	arelent *reloc_entry;
	447	asymbol *symbol;
	448	PTR data;
	449	asection *input_section;
	450	bfd *output_bfd;
	451	char **error_message;
	452	{
	453	if (or32_consth_list != NULL)
	454	{
	455	struct or32_consth *l;
	456
	457	l = or32_consth_list;
	458	while (l != NULL)
	459	{
	460	unsigned long insn;
	461	unsigned long val;
	462	unsigned long vallo;
	463	struct or32_consth *next;
	464
	465	/* Do the HI16 relocation. Note that we actually don't need
	466	to know anything about the LO16 itself, except where to
	467	find the low 16 bits of the addend needed by the LO16. */
	468	insn = bfd_get_32 (abfd, l->addr);
469	vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
470	& 0xffff);
471	val = ((insn & 0xffff) << 16) + vallo;
472	val += l->addend;
473
474	insn = (insn &~ 0xffff) \| ((val >> 16) & 0xffff);
475	bfd_put_32 (abfd, insn, l->addr);
476
477	next = l->next;
478	free (l);
479	l = next;
480	}
481
482	or32_consth_list = NULL;
483	}
484
485	if (output_bfd != (bfd *) NULL)
486	{
487	unsigned long insn, tmp;
488	bfd_size_type addr = reloc_entry->address;
489
490	reloc_entry->address += input_section->output_offset;
491
492	insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
493	tmp = insn & 0x0000ffff;
494	tmp += symbol->section->output_section->vma;
495	tmp += symbol->section->output_offset;
496	tmp += symbol->value;
497	insn = (insn & 0xffff0000) \| (tmp & 0x0000ffff);
498	bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
499
500	return bfd_reloc_ok;
501	}
502
503	/* Now do the LO16 reloc in the usual way. */
504	return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
505	input_section, output_bfd, error_message);
506	}
507
508	bfd_reloc_status_type
509	or32_elf_jumptarg_reloc (abfd, reloc_entry, symbol, data, input_section,
510	output_bfd, error_message)
511	bfd *abfd;
512	arelent *reloc_entry;
513	asymbol *symbol ATTRIBUTE_UNUSED;
514	PTR data;
515	asection *input_section;
516	bfd *output_bfd;
517	char **error_message ATTRIBUTE_UNUSED;
cedb70c5	518	{
3b16e843 NC	519	if (output_bfd != (bfd *) NULL)
	520	{
	521	unsigned long insn, tmp;
	522	bfd_size_type addr = reloc_entry->address;
	523
	524	reloc_entry->address += input_section->output_offset;
	525
	526	insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
	527	tmp = insn \| 0xfc000000;
	528	tmp -= (input_section->output_offset >> 2);
	529	insn = (insn & 0xfc000000) \| (tmp & 0x03ffffff);
cedb70c5	530	bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);
3b16e843 NC	531
	532	return bfd_reloc_ok;
	533	}
	534
	535	return bfd_reloc_continue;
	536	}
	537
	538	#define TARGET_LITTLE_SYM bfd_elf32_or32_little_vec
	539	#define TARGET_LITTLE_NAME "elf32-littleor32"
	540	#define TARGET_BIG_SYM bfd_elf32_or32_big_vec
	541	#define TARGET_BIG_NAME "elf32-or32"
	542	#define ELF_ARCH bfd_arch_or32
	543	#define ELF_MACHINE_CODE EM_OR32
	544	#define ELF_MAXPAGESIZE 0x1000
	545
	546	#define elf_info_to_howto 0
	547	#define elf_info_to_howto_rel or32_info_to_howto_rel
	548	#define elf_backend_object_p or32_elf_object_p
	549	#define elf_backend_final_write_processing \
	550	or32_elf_final_write_processing
	551
	552	#include "elf32-target.h"