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

/* picoJava specific support for 32-bit ELF
   Copyright 1999, 2000, 2001, 2002, 2005, 2007
   Free Software Foundation, Inc.
   Contributed by Steve Chamberlan of Transmeta (sac@pobox.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 "bfdlink.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/pj.h"

/* This function is used for normal relocs.  This is like the COFF
   function, and is almost certainly incorrect for other ELF targets.  */

static bfd_reloc_status_type
pj_elf_reloc (bfd *abfd,
	      arelent *reloc_entry,
	      asymbol *symbol_in,
	      void * data,
	      asection *input_section,
	      bfd *output_bfd,
	      char **error_message ATTRIBUTE_UNUSED)
{
  unsigned long insn;
  bfd_vma sym_value;
  enum elf_pj_reloc_type r_type;
  bfd_vma addr = reloc_entry->address;
  bfd_byte *hit_data = addr + (bfd_byte *) data;

  r_type = (enum elf_pj_reloc_type) reloc_entry->howto->type;

  if (output_bfd != NULL)
    {
      /* Partial linking--do nothing.  */
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  if (symbol_in != NULL
      && bfd_is_und_section (symbol_in->section))
    return bfd_reloc_undefined;

  if (bfd_is_com_section (symbol_in->section))
    sym_value = 0;
  else
    sym_value = (symbol_in->value +
		 symbol_in->section->output_section->vma +
		 symbol_in->section->output_offset);

  switch (r_type)
    {
    case R_PJ_DATA_DIR32:
      insn = bfd_get_32 (abfd, hit_data);
      insn += sym_value + reloc_entry->addend;
      bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
      break;

      /* Relocations in code are always bigendian, no matter what the
	 data endianness is.  */

    case R_PJ_CODE_DIR32:
      insn = bfd_getb32 (hit_data);
      insn += sym_value + reloc_entry->addend;
      bfd_putb32 ((bfd_vma) insn, hit_data);
      break;

    case R_PJ_CODE_REL16:
      insn = bfd_getb16 (hit_data);
      insn += sym_value + reloc_entry->addend
        -  (input_section->output_section->vma
            + input_section->output_offset);
      bfd_putb16 ((bfd_vma) insn, hit_data);
      break;
    case R_PJ_CODE_LO16:
      insn = bfd_getb16 (hit_data);
      insn += sym_value + reloc_entry->addend;
      bfd_putb16 ((bfd_vma) insn, hit_data);
      break;

    case R_PJ_CODE_HI16:
      insn = bfd_getb16 (hit_data);
      insn += (sym_value + reloc_entry->addend) >> 16;
      bfd_putb16 ((bfd_vma) insn, hit_data);
      break;

    default:
      abort ();
      break;
    }

  return bfd_reloc_ok;
}

static reloc_howto_type pj_elf_howto_table[] =
{
  /* No relocation.  */
  HOWTO (R_PJ_NONE,		/* type */
	 0,			/* rightshift */
	 0,			/* size (0 = byte, 1 = short, 2 = long) */
	 0,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_NONE",		/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* 32 bit absolute relocation.  Setting partial_inplace to TRUE and
     src_mask to a non-zero value is similar to the COFF toolchain.  */
  HOWTO (R_PJ_DATA_DIR32,	/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_DIR32",		/* name */
	 TRUE,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* 32 bit PC relative relocation.  */
  HOWTO (R_PJ_CODE_REL32,	/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_REL32",		/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0xffffffff,		/* dst_mask */
	 TRUE),			/* pcrel_offset */

/* 16 bit PC relative relocation.  */
  HOWTO (R_PJ_CODE_REL16,	/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overf6w */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_REL16",		/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 TRUE),			/* pcrel_offset */
  EMPTY_HOWTO (4),
  EMPTY_HOWTO (5),
  HOWTO (R_PJ_CODE_DIR32,	/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_CODE_DIR32",	/* name */
	 TRUE,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  EMPTY_HOWTO (7),
  EMPTY_HOWTO (8),
  EMPTY_HOWTO (9),
  EMPTY_HOWTO (10),
  EMPTY_HOWTO (11),
  EMPTY_HOWTO (12),

  HOWTO (R_PJ_CODE_LO16,	/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_unsigned, /* complain_on_overflow */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_LO16",		/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 TRUE),			/* pcrel_offset */

    HOWTO (R_PJ_CODE_HI16,	/* type */
	 16,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_unsigned, /* complain_on_overflow */
	 pj_elf_reloc,		/* special_function */
	 "R_PJ_HI16",		/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 TRUE),			/* pcrel_offset */

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

/* This structure is used to map BFD reloc codes to PJ ELF relocs.  */

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

/* An array mapping BFD reloc codes to PJ ELF relocs.  */

static const struct elf_reloc_map pj_reloc_map[] =
{
    { BFD_RELOC_NONE, 		R_PJ_NONE          },
    { BFD_RELOC_32, 		R_PJ_DATA_DIR32    },
    { BFD_RELOC_PJ_CODE_DIR16, 	R_PJ_CODE_DIR16    },
    { BFD_RELOC_PJ_CODE_DIR32, 	R_PJ_CODE_DIR32    },
    { BFD_RELOC_PJ_CODE_LO16, 	R_PJ_CODE_LO16     },
    { BFD_RELOC_PJ_CODE_HI16, 	R_PJ_CODE_HI16     },
    { BFD_RELOC_PJ_CODE_REL32,  R_PJ_CODE_REL32    },
    { BFD_RELOC_PJ_CODE_REL16,  R_PJ_CODE_REL16    },
    { BFD_RELOC_VTABLE_INHERIT, R_PJ_GNU_VTINHERIT },
    { BFD_RELOC_VTABLE_ENTRY,   R_PJ_GNU_VTENTRY   },
};

/* Given a BFD reloc code, return the howto structure for the
   corresponding PJ ELf reloc.  */

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

  for (i = 0; i < sizeof (pj_reloc_map) / sizeof (struct elf_reloc_map); i++)
    if (pj_reloc_map[i].bfd_reloc_val == code)
      return & pj_elf_howto_table[(int) pj_reloc_map[i].elf_reloc_val];

  return NULL;
}

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

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

  return NULL;
}

/* Given an ELF reloc, fill in the howto field of a relent.  */

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

  r = ELF32_R_TYPE (dst->r_info);

  BFD_ASSERT (r < (unsigned int) R_PJ_max);

  cache_ptr->howto = &pj_elf_howto_table[r];
}

/* Take this moment to fill in the special picoJava bits in the
   e_flags field.  */

static void
pj_elf_final_write_processing (bfd *abfd,
			       bfd_boolean linker ATTRIBUTE_UNUSED)
{
  elf_elfheader (abfd)->e_flags |= EF_PICOJAVA_ARCH;
  elf_elfheader (abfd)->e_flags |= EF_PICOJAVA_GNUCALLS;
}

#define TARGET_BIG_SYM		bfd_elf32_pj_vec
#define TARGET_BIG_NAME		"elf32-pj"
#define TARGET_LITTLE_SYM	bfd_elf32_pjl_vec
#define TARGET_LITTLE_NAME	"elf32-pjl"
#define ELF_ARCH		bfd_arch_pj
#define ELF_MACHINE_CODE	EM_PJ
#define ELF_MACHINE_ALT1	EM_PJ_OLD
#define ELF_MAXPAGESIZE		0x1000
#define bfd_elf32_bfd_get_relocated_section_contents \
  bfd_generic_get_relocated_section_contents
#define bfd_elf32_bfd_reloc_type_lookup	        pj_elf_reloc_type_lookup
#define bfd_elf32_bfd_reloc_name_lookup   pj_elf_reloc_name_lookup
#define elf_backend_final_write_processing      pj_elf_final_write_processing
#define elf_info_to_howto		        pj_elf_info_to_howto
#include "elf32-target.h"
Commit	Line	Data
0bcb993b	1	/* picoJava specific support for 32-bit ELF
157090f7 AM	2	Copyright 1999, 2000, 2001, 2002, 2005, 2007
157090f7 AM	3	Free Software Foundation, Inc.
0bcb993b ILT	4	Contributed by Steve Chamberlan of Transmeta (sac@pobox.com).
0bcb993b ILT	5
47b0e7ad	6	This file is part of BFD, the Binary File Descriptor library.
0bcb993b	7
47b0e7ad NC	8	This program is free software; you can redistribute it and/or modify
47b0e7ad NC	9	it under the terms of the GNU General Public License as published by
cd123cb7	10	the Free Software Foundation; either version 3 of the License, or
47b0e7ad	11	(at your option) any later version.
0bcb993b	12
47b0e7ad NC	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
0bcb993b	17
47b0e7ad NC	18	You should have received a copy of the GNU General Public License
47b0e7ad NC	19	along with this program; if not, write to the Free Software
cd123cb7 NC	20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
cd123cb7 NC	21	MA 02110-1301, USA. */
0bcb993b	22
0bcb993b	23	#include "sysdep.h"
3db64b00	24	#include "bfd.h"
0bcb993b ILT	25	#include "bfdlink.h"
	26	#include "libbfd.h"
	27	#include "elf-bfd.h"
	28	#include "elf/pj.h"
	29
47b0e7ad NC	30	/* This function is used for normal relocs. This is like the COFF
	31	function, and is almost certainly incorrect for other ELF targets. */
	32
	33	static bfd_reloc_status_type
	34	pj_elf_reloc (bfd *abfd,
	35	arelent *reloc_entry,
	36	asymbol *symbol_in,
	37	void * data,
	38	asection *input_section,
	39	bfd *output_bfd,
	40	char **error_message ATTRIBUTE_UNUSED)
	41	{
	42	unsigned long insn;
	43	bfd_vma sym_value;
	44	enum elf_pj_reloc_type r_type;
	45	bfd_vma addr = reloc_entry->address;
	46	bfd_byte hit_data = addr + (bfd_byte ) data;
	47
	48	r_type = (enum elf_pj_reloc_type) reloc_entry->howto->type;
	49
	50	if (output_bfd != NULL)
	51	{
	52	/* Partial linking--do nothing. */
	53	reloc_entry->address += input_section->output_offset;
	54	return bfd_reloc_ok;
	55	}
	56
	57	if (symbol_in != NULL
	58	&& bfd_is_und_section (symbol_in->section))
	59	return bfd_reloc_undefined;
	60
	61	if (bfd_is_com_section (symbol_in->section))
	62	sym_value = 0;
	63	else
	64	sym_value = (symbol_in->value +
	65	symbol_in->section->output_section->vma +
	66	symbol_in->section->output_offset);
	67
	68	switch (r_type)
	69	{
	70	case R_PJ_DATA_DIR32:
	71	insn = bfd_get_32 (abfd, hit_data);
	72	insn += sym_value + reloc_entry->addend;
	73	bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
	74	break;
	75
	76	/* Relocations in code are always bigendian, no matter what the
	77	data endianness is. */
	78
	79	case R_PJ_CODE_DIR32:
	80	insn = bfd_getb32 (hit_data);
	81	insn += sym_value + reloc_entry->addend;
	82	bfd_putb32 ((bfd_vma) insn, hit_data);
	83	break;
	84
	85	case R_PJ_CODE_REL16:
	86	insn = bfd_getb16 (hit_data);
	87	insn += sym_value + reloc_entry->addend
	88	- (input_section->output_section->vma
	89	+ input_section->output_offset);
	90	bfd_putb16 ((bfd_vma) insn, hit_data);
	91	break;
	92	case R_PJ_CODE_LO16:
	93	insn = bfd_getb16 (hit_data);
94	insn += sym_value + reloc_entry->addend;
95	bfd_putb16 ((bfd_vma) insn, hit_data);
96	break;
97
98	case R_PJ_CODE_HI16:
99	insn = bfd_getb16 (hit_data);
100	insn += (sym_value + reloc_entry->addend) >> 16;
101	bfd_putb16 ((bfd_vma) insn, hit_data);
102	break;
103
104	default:
105	abort ();
106	break;
107	}
108
109	return bfd_reloc_ok;
110	}
0bcb993b ILT	111
	112	static reloc_howto_type pj_elf_howto_table[] =
	113	{
	114	/* No relocation. */
	115	HOWTO (R_PJ_NONE, /* type */
	116	0, /* rightshift */
	117	0, /* size (0 = byte, 1 = short, 2 = long) */
	118	0, /* bitsize */
b34976b6	119	FALSE, /* pc_relative */
0bcb993b ILT	120	0, /* bitpos */
	121	complain_overflow_dont, /* complain_on_overflow */
	122	pj_elf_reloc, /* special_function */
	123	"R_PJ_NONE", /* name */
b34976b6	124	FALSE, /* partial_inplace */
0bcb993b ILT	125	0, /* src_mask */
0bcb993b ILT	126	0, /* dst_mask */
b34976b6	127	FALSE), /* pcrel_offset */
0bcb993b	128
b34976b6	129	/* 32 bit absolute relocation. Setting partial_inplace to TRUE and
0bcb993b	130	src_mask to a non-zero value is similar to the COFF toolchain. */
47b0e7ad	131	HOWTO (R_PJ_DATA_DIR32, /* type */
0bcb993b ILT	132	0, /* rightshift */
	133	2, /* size (0 = byte, 1 = short, 2 = long) */
	134	32, /* bitsize */
b34976b6	135	FALSE, /* pc_relative */
0bcb993b ILT	136	0, /* bitpos */
	137	complain_overflow_bitfield, /* complain_on_overflow */
	138	pj_elf_reloc, /* special_function */
	139	"R_PJ_DIR32", /* name */
b34976b6	140	TRUE, /* partial_inplace */
0bcb993b ILT	141	0xffffffff, /* src_mask */
0bcb993b ILT	142	0xffffffff, /* dst_mask */
b34976b6	143	FALSE), /* pcrel_offset */
0bcb993b ILT	144
0bcb993b ILT	145	/* 32 bit PC relative relocation. */
47b0e7ad	146	HOWTO (R_PJ_CODE_REL32, /* type */
0bcb993b ILT	147	0, /* rightshift */
	148	2, /* size (0 = byte, 1 = short, 2 = long) */
	149	32, /* bitsize */
b34976b6	150	TRUE, /* pc_relative */
0bcb993b ILT	151	0, /* bitpos */
	152	complain_overflow_signed, /* complain_on_overflow */
	153	pj_elf_reloc, /* special_function */
	154	"R_PJ_REL32", /* name */
b34976b6	155	FALSE, /* partial_inplace */
0bcb993b ILT	156	0, /* src_mask */
0bcb993b ILT	157	0xffffffff, /* dst_mask */
b34976b6	158	TRUE), /* pcrel_offset */
0bcb993b ILT	159
0bcb993b ILT	160	/* 16 bit PC relative relocation. */
47b0e7ad	161	HOWTO (R_PJ_CODE_REL16, /* type */
0bcb993b ILT	162	0, /* rightshift */
	163	1, /* size (0 = byte, 1 = short, 2 = long) */
	164	16, /* bitsize */
b34976b6	165	TRUE, /* pc_relative */
0bcb993b ILT	166	0, /* bitpos */
	167	complain_overflow_signed, /* complain_on_overf6w */
	168	pj_elf_reloc, /* special_function */
	169	"R_PJ_REL16", /* name */
b34976b6	170	FALSE, /* partial_inplace */
0bcb993b ILT	171	0xffff, /* src_mask */
0bcb993b ILT	172	0xffff, /* dst_mask */
b34976b6	173	TRUE), /* pcrel_offset */
0bcb993b ILT	174	EMPTY_HOWTO (4),
	175	EMPTY_HOWTO (5),
	176	HOWTO (R_PJ_CODE_DIR32, /* type */
	177	0, /* rightshift */
	178	2, /* size (0 = byte, 1 = short, 2 = long) */
	179	32, /* bitsize */
b34976b6	180	FALSE, /* pc_relative */
0bcb993b ILT	181	0, /* bitpos */
	182	complain_overflow_bitfield, /* complain_on_overflow */
	183	pj_elf_reloc, /* special_function */
	184	"R_PJ_CODE_DIR32", /* name */
b34976b6	185	TRUE, /* partial_inplace */
0bcb993b ILT	186	0xffffffff, /* src_mask */
0bcb993b ILT	187	0xffffffff, /* dst_mask */
b34976b6	188	FALSE), /* pcrel_offset */
0bcb993b ILT	189
	190	EMPTY_HOWTO (7),
	191	EMPTY_HOWTO (8),
	192	EMPTY_HOWTO (9),
	193	EMPTY_HOWTO (10),
	194	EMPTY_HOWTO (11),
	195	EMPTY_HOWTO (12),
	196
	197	HOWTO (R_PJ_CODE_LO16, /* type */
	198	0, /* rightshift */
	199	1, /* size (0 = byte, 1 = short, 2 = long) */
	200	16, /* bitsize */
b34976b6	201	FALSE, /* pc_relative */
0bcb993b ILT	202	0, /* bitpos */
	203	complain_overflow_unsigned, /* complain_on_overflow */
	204	pj_elf_reloc, /* special_function */
	205	"R_PJ_LO16", /* name */
b34976b6	206	FALSE, /* partial_inplace */
0bcb993b ILT	207	0xffff, /* src_mask */
0bcb993b ILT	208	0xffff, /* dst_mask */
b34976b6	209	TRUE), /* pcrel_offset */
0bcb993b	210
0bcb993b ILT	211	HOWTO (R_PJ_CODE_HI16, /* type */
	212	16, /* rightshift */
	213	1, /* size (0 = byte, 1 = short, 2 = long) */
	214	16, /* bitsize */
b34976b6	215	FALSE, /* pc_relative */
0bcb993b ILT	216	0, /* bitpos */
	217	complain_overflow_unsigned, /* complain_on_overflow */
	218	pj_elf_reloc, /* special_function */
	219	"R_PJ_HI16", /* name */
b34976b6	220	FALSE, /* partial_inplace */
0bcb993b ILT	221	0xffff, /* src_mask */
0bcb993b ILT	222	0xffff, /* dst_mask */
b34976b6	223	TRUE), /* pcrel_offset */
0bcb993b	224
47b0e7ad	225	/* GNU extension to record C++ vtable hierarchy. */
0bcb993b ILT	226	HOWTO (R_PJ_GNU_VTINHERIT, /* type */
	227	0, /* rightshift */
	228	2, /* size (0 = byte, 1 = short, 2 = long) */
	229	0, /* bitsize */
b34976b6	230	FALSE, /* pc_relative */
0bcb993b ILT	231	0, /* bitpos */
	232	complain_overflow_dont, /* complain_on_overflow */
	233	NULL, /* special_function */
	234	"R_PJ_GNU_VTINHERIT", /* name */
b34976b6	235	FALSE, /* partial_inplace */
0bcb993b ILT	236	0, /* src_mask */
0bcb993b ILT	237	0, /* dst_mask */
b34976b6	238	FALSE), /* pcrel_offset */
0bcb993b	239
47b0e7ad	240	/* GNU extension to record C++ vtable member usage. */
0bcb993b ILT	241	HOWTO (R_PJ_GNU_VTENTRY, /* type */
	242	0, /* rightshift */
	243	2, /* size (0 = byte, 1 = short, 2 = long) */
	244	0, /* bitsize */
b34976b6	245	FALSE, /* pc_relative */
0bcb993b ILT	246	0, /* bitpos */
	247	complain_overflow_dont, /* complain_on_overflow */
	248	_bfd_elf_rel_vtable_reloc_fn, /* special_function */
	249	"R_PJ_GNU_VTENTRY", /* name */
b34976b6	250	FALSE, /* partial_inplace */
0bcb993b ILT	251	0, /* src_mask */
0bcb993b ILT	252	0, /* dst_mask */
b34976b6	253	FALSE), /* pcrel_offset */
0bcb993b ILT	254	};
0bcb993b ILT	255
0bcb993b ILT	256	/* This structure is used to map BFD reloc codes to PJ ELF relocs. */
	257
	258	struct elf_reloc_map
	259	{
	260	bfd_reloc_code_real_type bfd_reloc_val;
	261	unsigned char elf_reloc_val;
	262	};
	263
	264	/* An array mapping BFD reloc codes to PJ ELF relocs. */
	265
	266	static const struct elf_reloc_map pj_reloc_map[] =
	267	{
	268	{ BFD_RELOC_NONE, R_PJ_NONE },
	269	{ BFD_RELOC_32, R_PJ_DATA_DIR32 },
	270	{ BFD_RELOC_PJ_CODE_DIR16, R_PJ_CODE_DIR16 },
	271	{ BFD_RELOC_PJ_CODE_DIR32, R_PJ_CODE_DIR32 },
	272	{ BFD_RELOC_PJ_CODE_LO16, R_PJ_CODE_LO16 },
	273	{ BFD_RELOC_PJ_CODE_HI16, R_PJ_CODE_HI16 },
	274	{ BFD_RELOC_PJ_CODE_REL32, R_PJ_CODE_REL32 },
	275	{ BFD_RELOC_PJ_CODE_REL16, R_PJ_CODE_REL16 },
	276	{ BFD_RELOC_VTABLE_INHERIT, R_PJ_GNU_VTINHERIT },
	277	{ BFD_RELOC_VTABLE_ENTRY, R_PJ_GNU_VTENTRY },
	278	};
	279
	280	/* Given a BFD reloc code, return the howto structure for the
	281	corresponding PJ ELf reloc. */
	282
	283	static reloc_howto_type *
47b0e7ad NC	284	pj_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
47b0e7ad NC	285	bfd_reloc_code_real_type code)
0bcb993b ILT	286	{
0bcb993b ILT	287	unsigned int i;
c3668558	288
0bcb993b	289	for (i = 0; i < sizeof (pj_reloc_map) / sizeof (struct elf_reloc_map); i++)
47b0e7ad NC	290	if (pj_reloc_map[i].bfd_reloc_val == code)
47b0e7ad NC	291	return & pj_elf_howto_table[(int) pj_reloc_map[i].elf_reloc_val];
0bcb993b ILT	292
	293	return NULL;
	294	}
	295
157090f7 AM	296	static reloc_howto_type *
	297	pj_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
	298	const char *r_name)
	299	{
	300	unsigned int i;
	301
	302	for (i = 0;
	303	i < sizeof (pj_elf_howto_table) / sizeof (pj_elf_howto_table[0]);
	304	i++)
	305	if (pj_elf_howto_table[i].name != NULL
	306	&& strcasecmp (pj_elf_howto_table[i].name, r_name) == 0)
	307	return &pj_elf_howto_table[i];
	308
	309	return NULL;
	310	}
	311
0bcb993b ILT	312	/* Given an ELF reloc, fill in the howto field of a relent. */
	313
	314	static void
47b0e7ad NC	315	pj_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
	316	arelent *cache_ptr,
	317	Elf_Internal_Rela *dst)
0bcb993b ILT	318	{
	319	unsigned int r;
	320
	321	r = ELF32_R_TYPE (dst->r_info);
	322
	323	BFD_ASSERT (r < (unsigned int) R_PJ_max);
	324
	325	cache_ptr->howto = &pj_elf_howto_table[r];
	326	}
	327
	328	/* Take this moment to fill in the special picoJava bits in the
c3668558	329	e_flags field. */
0bcb993b ILT	330
0bcb993b ILT	331	static void
47b0e7ad NC	332	pj_elf_final_write_processing (bfd *abfd,
47b0e7ad NC	333	bfd_boolean linker ATTRIBUTE_UNUSED)
0bcb993b	334	{
47b0e7ad NC	335	elf_elfheader (abfd)->e_flags \|= EF_PICOJAVA_ARCH;
47b0e7ad NC	336	elf_elfheader (abfd)->e_flags \|= EF_PICOJAVA_GNUCALLS;
0bcb993b ILT	337	}
	338
	339	#define TARGET_BIG_SYM bfd_elf32_pj_vec
	340	#define TARGET_BIG_NAME "elf32-pj"
	341	#define TARGET_LITTLE_SYM bfd_elf32_pjl_vec
	342	#define TARGET_LITTLE_NAME "elf32-pjl"
	343	#define ELF_ARCH bfd_arch_pj
	344	#define ELF_MACHINE_CODE EM_PJ
aa4f99bb	345	#define ELF_MACHINE_ALT1 EM_PJ_OLD
0bcb993b	346	#define ELF_MAXPAGESIZE 0x1000
157090f7 AM	347	#define bfd_elf32_bfd_get_relocated_section_contents \
	348	bfd_generic_get_relocated_section_contents
	349	#define bfd_elf32_bfd_reloc_type_lookup pj_elf_reloc_type_lookup
	350	#define bfd_elf32_bfd_reloc_name_lookup pj_elf_reloc_name_lookup
	351	#define elf_backend_final_write_processing pj_elf_final_write_processing
	352	#define elf_info_to_howto pj_elf_info_to_howto
0bcb993b	353	#include "elf32-target.h"