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

/* ARC-specific support for 32-bit ELF
   Copyright (C) 1994, 1995, 1997, 1999, 2000 Free Software Foundation, Inc.
   Contributed by Doug Evans (dje@cygnus.com).

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 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/arc.h"

static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
static void arc_info_to_howto_rel
  PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
static boolean arc_elf_object_p
  PARAMS ((bfd *));
static void arc_elf_final_write_processing
  PARAMS ((bfd *, boolean));

/* 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_arc_howto_table[] =
{
  /* This reloc does nothing.  */
  HOWTO (R_ARC_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_ARC_NONE",		/* name  */
	 false,			/* partial_inplace  */
	 0,			/* src_mask  */
	 0,			/* dst_mask  */
	 false),		/* pcrel_offset  */

  /* A standard 32 bit relocation.  */
  HOWTO (R_ARC_32,		/* type  */
	 0,	                /* rightshift  */
	 2,	                /* size (0 = byte, 1 = short, 2 = long)  */
	 32,	                /* bitsize  */
	 false,	                /* pc_relative  */
	 0,	                /* bitpos  */
	 complain_overflow_bitfield, /* complain_on_overflow  */
	 bfd_elf_generic_reloc, /* special_function  */
	 "R_ARC_32",		/* name  */
	 false,	                /* partial_inplace  */
	 0xffffffff,	        /* src_mask  */
	 0xffffffff,   		/* dst_mask  */
	 false),                /* pcrel_offset  */

  /* A 26 bit absolute branch, right shifted by 2.  */
  HOWTO (R_ARC_B26,		/* type  */
	 2,			/* rightshift  */
	 2,			/* size (0 = byte, 1 = short, 2 = long)  */
	 26,			/* bitsize  */
	 false,			/* pc_relative  */
	 0,			/* bitpos  */
	 complain_overflow_bitfield, /* complain_on_overflow  */
	 bfd_elf_generic_reloc,	/* special_function  */
	 "R_ARC_B26",		/* name  */
	 false,			/* partial_inplace  */
	 0x00ffffff,		/* src_mask  */
	 0x00ffffff,		/* dst_mask  */
	 false),		/* pcrel_offset  */

  /* A relative 22 bit branch; bits 21-2 are stored in bits 26-7.  */
  HOWTO (R_ARC_B22_PCREL,	/* type  */
	 2,			/* rightshift  */
	 2,			/* size (0 = byte, 1 = short, 2 = long)  */
	 22,			/* bitsize  */
	 true,			/* pc_relative  */
	 7,			/* bitpos  */
	 complain_overflow_signed, /* complain_on_overflow  */
	 bfd_elf_generic_reloc,	/* special_function  */
	 "R_ARC_B22_PCREL",	/* name  */
	 false,			/* partial_inplace  */
	 0x07ffff80,		/* src_mask  */
	 0x07ffff80,		/* dst_mask  */
	 true),			/* pcrel_offset  */

};

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

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

static const struct arc_reloc_map arc_reloc_map[] =
{
  { BFD_RELOC_NONE, R_ARC_NONE, },
  { BFD_RELOC_32, R_ARC_32 },
  { BFD_RELOC_CTOR, R_ARC_32 },
  { BFD_RELOC_ARC_B26, R_ARC_B26 },
  { BFD_RELOC_ARC_B22_PCREL, R_ARC_B22_PCREL },
};

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 = 0; i < sizeof (arc_reloc_map) / sizeof (struct arc_reloc_map); i++)
    {
      if (arc_reloc_map[i].bfd_reloc_val == code)
	return &elf_arc_howto_table[arc_reloc_map[i].elf_reloc_val];
    }
  return NULL;
}

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

static void
arc_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_ARC_max);
  cache_ptr->howto = &elf_arc_howto_table[r_type];
}

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

static boolean
arc_elf_object_p (abfd)
     bfd *abfd;
{
  int mach = bfd_mach_arc_5;

  if (elf_elfheader(abfd)->e_machine == EM_ARC)
    {
      unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH;

      switch (arch)
	{
	default:
	case E_ARC_MACH_ARC5:
	  mach = bfd_mach_arc_5;
	  break;
	case E_ARC_MACH_ARC6:
	  mach = bfd_mach_arc_6;
	  break;
	case E_ARC_MACH_ARC7:
	  mach = bfd_mach_arc_7;
	  break;
	case E_ARC_MACH_ARC8:
	  mach = bfd_mach_arc_8;
	  break;
	}
    }
  return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach);
}

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

static void
arc_elf_final_write_processing (abfd, linker)
     bfd *abfd;
     boolean linker ATTRIBUTE_UNUSED;
{
  unsigned long val;

  switch (bfd_get_mach (abfd))
    {
    default:
    case bfd_mach_arc_5:
      val = E_ARC_MACH_ARC5;
      break;
    case bfd_mach_arc_6:
      val = E_ARC_MACH_ARC6;
      break;
    case bfd_mach_arc_7:
      val = E_ARC_MACH_ARC7;
      break;
    case bfd_mach_arc_8:
      val = E_ARC_MACH_ARC8;
      break;
    }
  elf_elfheader (abfd)->e_machine = EM_ARC;
  elf_elfheader (abfd)->e_flags &=~ EF_ARC_MACH;
  elf_elfheader (abfd)->e_flags |= val;
}

#define TARGET_LITTLE_SYM bfd_elf32_littlearc_vec
#define TARGET_LITTLE_NAME "elf32-littlearc"
#define TARGET_BIG_SYM bfd_elf32_bigarc_vec
#define TARGET_BIG_NAME	"elf32-bigarc"
#define ELF_ARCH bfd_arch_arc
#define ELF_MACHINE_CODE EM_ARC
#define ELF_MAXPAGESIZE	0x1000

#define elf_info_to_howto 0
#define elf_info_to_howto_rel arc_info_to_howto_rel
#define elf_backend_object_p arc_elf_object_p
#define elf_backend_final_write_processing arc_elf_final_write_processing

#include "elf32-target.h"
Commit	Line	Data
252b5132	1	/* ARC-specific support for 32-bit ELF
0d2bcfaf	2	Copyright (C) 1994, 1995, 1997, 1999, 2000 Free Software Foundation, Inc.
252b5132 RH	3	Contributed by Doug Evans (dje@cygnus.com).
252b5132 RH	4
0d2bcfaf	5	This file is part of BFD, the Binary File Descriptor library.
252b5132	6
0d2bcfaf NC	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.
252b5132	11
0d2bcfaf NC	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
252b5132	16
0d2bcfaf NC	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
252b5132 RH	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "elf-bfd.h"
	25	#include "elf/arc.h"
	26
	27	static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
0d2bcfaf	28	PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
252b5132 RH	29	static void arc_info_to_howto_rel
252b5132 RH	30	PARAMS ((bfd , arelent , Elf32_Internal_Rel *));
0d2bcfaf NC	31	static boolean arc_elf_object_p
	32	PARAMS ((bfd *));
	33	static void arc_elf_final_write_processing
	34	PARAMS ((bfd *, boolean));
252b5132 RH	35
	36	/* Try to minimize the amount of space occupied by relocation tables
	37	on the ROM (not that the ROM won't be swamped by other ELF overhead). */
0d2bcfaf	38
252b5132 RH	39	#define USE_REL
	40
	41	static reloc_howto_type elf_arc_howto_table[] =
	42	{
	43	/* This reloc does nothing. */
0d2bcfaf NC	44	HOWTO (R_ARC_NONE, /* type */
	45	0, /* rightshift */
	46	2, /* size (0 = byte, 1 = short, 2 = long) */
	47	32, /* bitsize */
	48	false, /* pc_relative */
	49	0, /* bitpos */
	50	complain_overflow_bitfield, /* complain_on_overflow */
	51	bfd_elf_generic_reloc, /* special_function */
	52	"R_ARC_NONE", /* name */
	53	false, /* partial_inplace */
	54	0, /* src_mask */
	55	0, /* dst_mask */
	56	false), /* pcrel_offset */
252b5132 RH	57
252b5132 RH	58	/* A standard 32 bit relocation. */
0d2bcfaf NC	59	HOWTO (R_ARC_32, /* type */
	60	0, /* rightshift */
	61	2, /* size (0 = byte, 1 = short, 2 = long) */
	62	32, /* bitsize */
	63	false, /* pc_relative */
	64	0, /* bitpos */
	65	complain_overflow_bitfield, /* complain_on_overflow */
	66	bfd_elf_generic_reloc, /* special_function */
	67	"R_ARC_32", /* name */
	68	false, /* partial_inplace */
	69	0xffffffff, /* src_mask */
	70	0xffffffff, /* dst_mask */
	71	false), /* pcrel_offset */
252b5132 RH	72
252b5132 RH	73	/* A 26 bit absolute branch, right shifted by 2. */
0d2bcfaf NC	74	HOWTO (R_ARC_B26, /* type */
	75	2, /* rightshift */
	76	2, /* size (0 = byte, 1 = short, 2 = long) */
	77	26, /* bitsize */
	78	false, /* pc_relative */
	79	0, /* bitpos */
	80	complain_overflow_bitfield, /* complain_on_overflow */
	81	bfd_elf_generic_reloc, /* special_function */
	82	"R_ARC_B26", /* name */
	83	false, /* partial_inplace */
	84	0x00ffffff, /* src_mask */
	85	0x00ffffff, /* dst_mask */
	86	false), /* pcrel_offset */
252b5132 RH	87
252b5132 RH	88	/* A relative 22 bit branch; bits 21-2 are stored in bits 26-7. */
0d2bcfaf NC	89	HOWTO (R_ARC_B22_PCREL, /* type */
	90	2, /* rightshift */
	91	2, /* size (0 = byte, 1 = short, 2 = long) */
	92	22, /* bitsize */
	93	true, /* pc_relative */
	94	7, /* bitpos */
	95	complain_overflow_signed, /* complain_on_overflow */
	96	bfd_elf_generic_reloc, /* special_function */
	97	"R_ARC_B22_PCREL", /* name */
	98	false, /* partial_inplace */
	99	0x07ffff80, /* src_mask */
	100	0x07ffff80, /* dst_mask */
	101	true), /* pcrel_offset */
252b5132 RH	102
	103	};
	104
	105	/* Map BFD reloc types to ARC ELF reloc types. */
	106
	107	struct arc_reloc_map
	108	{
	109	bfd_reloc_code_real_type bfd_reloc_val;
	110	unsigned char elf_reloc_val;
	111	};
	112
	113	static const struct arc_reloc_map arc_reloc_map[] =
	114	{
	115	{ BFD_RELOC_NONE, R_ARC_NONE, },
	116	{ BFD_RELOC_32, R_ARC_32 },
	117	{ BFD_RELOC_CTOR, R_ARC_32 },
	118	{ BFD_RELOC_ARC_B26, R_ARC_B26 },
	119	{ BFD_RELOC_ARC_B22_PCREL, R_ARC_B22_PCREL },
	120	};
	121
	122	static reloc_howto_type *
	123	bfd_elf32_bfd_reloc_type_lookup (abfd, code)
5f771d47	124	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	125	bfd_reloc_code_real_type code;
	126	{
	127	unsigned int i;
	128
0d2bcfaf	129	for (i = 0; i < sizeof (arc_reloc_map) / sizeof (struct arc_reloc_map); i++)
252b5132 RH	130	{
	131	if (arc_reloc_map[i].bfd_reloc_val == code)
	132	return &elf_arc_howto_table[arc_reloc_map[i].elf_reloc_val];
	133	}
252b5132 RH	134	return NULL;
	135	}
	136
	137	/* Set the howto pointer for an ARC ELF reloc. */
	138
	139	static void
	140	arc_info_to_howto_rel (abfd, cache_ptr, dst)
5f771d47	141	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	142	arelent *cache_ptr;
	143	Elf32_Internal_Rel *dst;
	144	{
	145	unsigned int r_type;
	146
	147	r_type = ELF32_R_TYPE (dst->r_info);
	148	BFD_ASSERT (r_type < (unsigned int) R_ARC_max);
	149	cache_ptr->howto = &elf_arc_howto_table[r_type];
	150	}
	151
	152	/* Set the right machine number for an ARC ELF file. */
	153
	154	static boolean
	155	arc_elf_object_p (abfd)
	156	bfd *abfd;
	157	{
0d2bcfaf	158	int mach = bfd_mach_arc_5;
252b5132	159
0d2bcfaf	160	if (elf_elfheader(abfd)->e_machine == EM_ARC)
252b5132	161	{
0d2bcfaf NC	162	unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH;
	163
	164	switch (arch)
	165	{
	166	default:
	167	case E_ARC_MACH_ARC5:
	168	mach = bfd_mach_arc_5;
	169	break;
	170	case E_ARC_MACH_ARC6:
	171	mach = bfd_mach_arc_6;
	172	break;
	173	case E_ARC_MACH_ARC7:
	174	mach = bfd_mach_arc_7;
	175	break;
	176	case E_ARC_MACH_ARC8:
	177	mach = bfd_mach_arc_8;
	178	break;
	179	}
252b5132	180	}
0d2bcfaf	181	return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach);
252b5132 RH	182	}
	183
	184	/* The final processing done just before writing out an ARC ELF object file.
	185	This gets the ARC architecture right based on the machine number. */
	186
	187	static void
	188	arc_elf_final_write_processing (abfd, linker)
	189	bfd *abfd;
5f771d47	190	boolean linker ATTRIBUTE_UNUSED;
252b5132	191	{
252b5132 RH	192	unsigned long val;
252b5132 RH	193
0d2bcfaf	194	switch (bfd_get_mach (abfd))
252b5132	195	{
252b5132	196	default:
0d2bcfaf NC	197	case bfd_mach_arc_5:
	198	val = E_ARC_MACH_ARC5;
	199	break;
	200	case bfd_mach_arc_6:
	201	val = E_ARC_MACH_ARC6;
	202	break;
	203	case bfd_mach_arc_7:
	204	val = E_ARC_MACH_ARC7;
	205	break;
	206	case bfd_mach_arc_8:
	207	val = E_ARC_MACH_ARC8;
	208	break;
252b5132	209	}
0d2bcfaf	210	elf_elfheader (abfd)->e_machine = EM_ARC;
252b5132 RH	211	elf_elfheader (abfd)->e_flags &=~ EF_ARC_MACH;
	212	elf_elfheader (abfd)->e_flags \|= val;
	213	}
	214
0d2bcfaf NC	215	#define TARGET_LITTLE_SYM bfd_elf32_littlearc_vec
	216	#define TARGET_LITTLE_NAME "elf32-littlearc"
	217	#define TARGET_BIG_SYM bfd_elf32_bigarc_vec
	218	#define TARGET_BIG_NAME "elf32-bigarc"
	219	#define ELF_ARCH bfd_arch_arc
	220	#define ELF_MACHINE_CODE EM_ARC
	221	#define ELF_MAXPAGESIZE 0x1000
	222
	223	#define elf_info_to_howto 0
	224	#define elf_info_to_howto_rel arc_info_to_howto_rel
	225	#define elf_backend_object_p arc_elf_object_p
	226	#define elf_backend_final_write_processing arc_elf_final_write_processing
252b5132 RH	227
252b5132 RH	228	#include "elf32-target.h"