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

/* OR32-specific support for 32-bit ELF
   Copyright (C) 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 *, Elf32_Internal_Rel *));
static boolean                or32_elf_object_p                PARAMS ((bfd *));
static void                   or32_elf_final_write_processing  PARAMS ((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

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