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

/* Infineon XC16X-specific support for 16-bit ELF.
   Copyright 2006  Free Software Foundation, Inc.
   Contributed by KPIT Cummins Infosystems 

   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, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

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

static reloc_howto_type xc16x_elf_howto_table [] =
{
  /* This reloc does nothing.  */
  HOWTO (R_XC16X_NONE,		/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_XC16X_NONE",	/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* An 8 bit absolute relocation.  */
  HOWTO (R_XC16X_ABS_8,		/* type */
	 0,			/* rightshift */
	 0,			/* size (0 = byte, 1 = short, 2 = long) */
	 8,			/* bitsize */
	 FALSE,			/* pc_relative */
	 8,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_XC16X_ABS_8",	/* name */
	 TRUE,			/* partial_inplace */
	 0x0000,		/* src_mask */
	 0x00ff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

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

  HOWTO (R_XC16X_ABS_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_XC16X_ABS_32",	/* name */
  	 TRUE,			/* partial_inplace */
  	 0x00000000,		/* src_mask */
  	 0xffffffff,		/* dst_mask */
  	 FALSE),		/* pcrel_offset */


  /* A PC relative 8 bit relocation.  */
  HOWTO (R_XC16X_8_PCREL,	/* type */
	 0,			/* rightshift */
	 0,			/* size (0 = byte, 1 = short, 2 = long) */
	 8,			/* bitsize */
	 TRUE,			/* pc_relative */
	 8,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc, /* special_function */
	 "R_XC16X_8_PCREL",	/* name */
	 FALSE,			/* partial_inplace */
	 0x0000,		/* src_mask */
	 0x00ff,		/* dst_mask */
	 TRUE),		/* pcrel_offset */

  /* Relocation regarding page number.  */
    HOWTO (R_XC16X_PAG,	/* type */
  	 0,			/* rightshift */
  	 1,			/* size (0 = byte, 1 = short, 2 = long) */
  	 16,			/* bitsize */
  	 FALSE,			/* pc_relative */
  	 0,			/* bitpos */
  	 complain_overflow_signed, /* complain_on_overflow */
  	 bfd_elf_generic_reloc, /* special_function */
  	 "R_XC16X_PAG",	/* name */
  	 TRUE,			/* partial_inplace */
  	 0x00000000,		/* src_mask */
  	 0x0000ffff,		/* dst_mask */
  	 FALSE),		/* pcrel_offset */


  /* Relocation regarding page number.  */
      HOWTO (R_XC16X_POF,	/* type */
    	 0,			/* rightshift */
    	 1,			/* size (0 = byte, 1 = short, 2 = long) */
    	 16,			/* bitsize */
    	 FALSE,			/* pc_relative */
    	 0,			/* bitpos  */
    	 complain_overflow_signed, /* complain_on_overflow  */
    	 bfd_elf_generic_reloc, /* special_function  */
    	 "R_XC16X_POF",	/* name  */
    	 TRUE,			/* partial_inplace  */
    	 0x00000000,		/* src_mask  */
    	 0x0000ffff,		/* dst_mask  */
    	 FALSE),		/* pcrel_offset  */


  /* Relocation regarding segment number.   */
      HOWTO (R_XC16X_SEG,	/* type  */
    	 0,			/* rightshift  */
    	 1,			/* size (0 = byte, 1 = short, 2 = long)  */
    	 16,			/* bitsize  */
    	 FALSE,			/* pc_relative  */
    	 0,			/* bitpos  */
    	 complain_overflow_signed, /* complain_on_overflow  */
    	 bfd_elf_generic_reloc, /* special_function  */
    	 "R_XC16X_SEG",	/* name  */
    	 TRUE,			/* partial_inplace  */
    	 0x00000000,		/* src_mask  */
    	 0x0000ffff,		/* dst_mask  */
    	 FALSE),		/* pcrel_offset  */

  /* Relocation regarding segment offset.  */
      HOWTO (R_XC16X_SOF,	/* type  */
    	 0,			/* rightshift  */
    	 1,			/* size (0 = byte, 1 = short, 2 = long)  */
    	 16,			/* bitsize  */
    	 FALSE,			/* pc_relative  */
    	 0,			/* bitpos  */
    	 complain_overflow_signed, /* complain_on_overflow  */
    	 bfd_elf_generic_reloc, /* special_function  */
    	 "R_XC16X_SOF",	/* name */
    	 TRUE,			/* partial_inplace  */
    	 0x00000000,		/* src_mask  */
    	 0x0000ffff,		/* dst_mask  */
    	 FALSE)			/* pcrel_offset  */
};


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

struct xc16x_reloc_map
{
  bfd_reloc_code_real_type bfd_reloc_val;
  unsigned int xc16x_reloc_val;
};

static const struct xc16x_reloc_map xc16x_reloc_map [] =
{
  { BFD_RELOC_NONE,           R_XC16X_NONE },
  { BFD_RELOC_8,              R_XC16X_ABS_8 },
  { BFD_RELOC_16,             R_XC16X_ABS_16 },
  { BFD_RELOC_32,             R_XC16X_ABS_32 },
  { BFD_RELOC_8_PCREL,        R_XC16X_8_PCREL },
  { BFD_RELOC_XC16X_PAG,      R_XC16X_PAG},
  { BFD_RELOC_XC16X_POF,      R_XC16X_POF},
  { BFD_RELOC_XC16X_SEG,      R_XC16X_SEG},
  { BFD_RELOC_XC16X_SOF,      R_XC16X_SOF},
};


/* This function is used to search for correct relocation type from
   howto structure.  */

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

  for (i = ARRAY_SIZE (xc16x_reloc_map); --i;)
    if (xc16x_reloc_map [i].bfd_reloc_val == code)
      return & xc16x_elf_howto_table [xc16x_reloc_map[i].xc16x_reloc_val];

  return NULL;
}

/* For a particular operand this function is
   called to finalise the type of relocation.  */

static void
elf32_xc16x_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
			   Elf_Internal_Rela *elf_reloc)
{
  unsigned int r;
  unsigned int i;

  r = ELF32_R_TYPE (elf_reloc->r_info);
  for (i = 0; i < ARRAY_SIZE (xc16x_elf_howto_table); i++)
    if (xc16x_elf_howto_table[i].type == r)
      {
	bfd_reloc->howto = &xc16x_elf_howto_table[i];
	return;
      }
  abort ();
}

static bfd_reloc_status_type
elf32_xc16x_final_link_relocate (unsigned long r_type,
				 bfd *input_bfd,
				 bfd *output_bfd ATTRIBUTE_UNUSED,
				 asection *input_section ATTRIBUTE_UNUSED,
				 bfd_byte *contents,
				 bfd_vma offset,
				 bfd_vma value,
				 bfd_vma addend,
				 struct bfd_link_info *info ATTRIBUTE_UNUSED,
				 asection *sym_sec ATTRIBUTE_UNUSED,
				 int is_local ATTRIBUTE_UNUSED)
{
  bfd_byte *hit_data = contents + offset;
  bfd_vma val1;

  switch (r_type)
    {
    case R_XC16X_NONE:
      return bfd_reloc_ok;

    case R_XC16X_ABS_16:
      value += addend;
      bfd_put_16 (input_bfd, value, hit_data);
      return bfd_reloc_ok;

    case R_XC16X_8_PCREL:
      bfd_put_8 (input_bfd, value, hit_data);
      return bfd_reloc_ok;

      /* Following case is to find page number from actual
	 address for this divide value by 16k i.e. page size.  */

    case R_XC16X_PAG:
      value += addend;
      value /= 0x4000;
      bfd_put_16 (input_bfd, value, hit_data);
      return bfd_reloc_ok;

      /* Following case is to find page offset from actual address
	 for this take modulo of value by 16k i.e. page size.  */

    case R_XC16X_POF:
      value += addend;
      value %= 0x4000;
      bfd_put_16 (input_bfd, value, hit_data);
      return bfd_reloc_ok;

      /* Following case is to find segment number from actual
	 address for this divide value by 64k i.e. segment size.  */

    case R_XC16X_SEG:
      value += addend;
      value /= 0x10000;
      bfd_put_16 (input_bfd, value, hit_data);
      return bfd_reloc_ok;

      /* Following case is to find segment offset from actual address
	 for this take modulo of value by 64k i.e. segment size.  */

    case R_XC16X_SOF:
      value += addend;
      value %= 0x10000;
      bfd_put_16 (input_bfd, value, hit_data);
      return bfd_reloc_ok;

    case R_XC16X_ABS_32:
      if (!strstr (input_section->name,".debug"))
	{
	  value += addend;
	  val1 = value;
	  value %= 0x4000;
	  val1 /= 0x4000;
	  val1 = val1 << 16;
	  value += val1;
	  bfd_put_32 (input_bfd, value, hit_data);
	}
      else
	{
	  value += addend;
	  bfd_put_32 (input_bfd, value, hit_data);
	}
      return bfd_reloc_ok;

    default:
      return bfd_reloc_notsupported;
    }
}

static bfd_boolean
elf32_xc16x_relocate_section (bfd *output_bfd,
			      struct bfd_link_info *info,
			      bfd *input_bfd,
			      asection *input_section,
			      bfd_byte *contents,
			      Elf_Internal_Rela *relocs,
			      Elf_Internal_Sym *local_syms,
			      asection **local_sections)
{
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes;
  Elf_Internal_Rela *rel, *relend;

  if (info->relocatable)
    return TRUE;

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

  rel = relocs;
  relend = relocs + input_section->reloc_count;
  for (; rel < relend; rel++)
    {
      unsigned int r_type;
      unsigned long r_symndx;
      Elf_Internal_Sym *sym;
      asection *sec;
      struct elf_link_hash_entry *h;
      bfd_vma relocation;
      bfd_reloc_status_type r;

      /* This is a final link.  */
      r_symndx = ELF32_R_SYM (rel->r_info);
      r_type = ELF32_R_TYPE (rel->r_info);
      h = NULL;
      sym = NULL;
      sec = NULL;
      if (r_symndx < symtab_hdr->sh_info)
	{
	  sym = local_syms + r_symndx;
	  sec = local_sections[r_symndx];
	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
	}
      else
	{
	  bfd_boolean unresolved_reloc, warned;

	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
				   r_symndx, symtab_hdr, sym_hashes,
				   h, sec, relocation,
				   unresolved_reloc, warned);
	}

      r = elf32_xc16x_final_link_relocate (r_type, input_bfd, output_bfd,
					input_section,
					contents, rel->r_offset,
					relocation, rel->r_addend,
					info, sec, h == NULL);
    }

  return TRUE;
}


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

  switch (bfd_get_mach (abfd))
    {
    default:
    case bfd_mach_xc16x:
      val = 0x1000;
      break;

    case bfd_mach_xc16xl:
      val = 0x1001;
      break;

    case bfd_mach_xc16xs:
      val = 0x1002;
      break;
    }

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

static unsigned long
elf32_xc16x_mach (flagword flags)
{  
  switch (flags)
    {
    case 0x1000:
    default: 
      return bfd_mach_xc16x;

    case 0x1001:
      return bfd_mach_xc16xl;

    case 0x1002:
      return bfd_mach_xc16xs;
    }
}


static bfd_boolean
elf32_xc16x_object_p (bfd *abfd)
{
  bfd_default_set_arch_mach (abfd, bfd_arch_xc16x,
			     elf32_xc16x_mach (elf_elfheader (abfd)->e_flags));
  return TRUE;
}


#define ELF_ARCH		bfd_arch_xc16x
#define ELF_MACHINE_CODE	EM_XC16X
#define ELF_MAXPAGESIZE		0x100

#define TARGET_LITTLE_SYM       bfd_elf32_xc16x_vec
#define TARGET_LITTLE_NAME	"elf32-xc16x"
#define elf_backend_final_write_processing	elf32_xc16x_final_write_processing
#define elf_backend_object_p   		elf32_xc16x_object_p
#define elf_backend_can_gc_sections	1
#define bfd_elf32_bfd_reloc_type_lookup	xc16x_reloc_type_lookup
#define elf_info_to_howto		elf32_xc16x_info_to_howto
#define elf_info_to_howto_rel		elf32_xc16x_info_to_howto
#define elf_backend_relocate_section  	elf32_xc16x_relocate_section
#define elf_backend_rela_normal		1

#include "elf32-target.h"
Commit	Line	Data
d70c5fc7 NC	1	/* Infineon XC16X-specific support for 16-bit ELF.
	2	Copyright 2006 Free Software Foundation, Inc.
	3	Contributed by KPIT Cummins Infosystems
	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, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "elf-bfd.h"
	25	#include "elf/xc16x.h"
	26	#include "elf/dwarf2.h"
	27	#include "libiberty.h"
	28
	29	static reloc_howto_type xc16x_elf_howto_table [] =
	30	{
	31	/* This reloc does nothing. */
	32	HOWTO (R_XC16X_NONE, /* type */
	33	0, /* rightshift */
	34	1, /* size (0 = byte, 1 = short, 2 = long) */
	35	16, /* bitsize */
	36	FALSE, /* pc_relative */
	37	0, /* bitpos */
	38	complain_overflow_bitfield, /* complain_on_overflow */
	39	bfd_elf_generic_reloc, /* special_function */
	40	"R_XC16X_NONE", /* name */
	41	FALSE, /* partial_inplace */
	42	0, /* src_mask */
	43	0, /* dst_mask */
	44	FALSE), /* pcrel_offset */
	45
	46	/* An 8 bit absolute relocation. */
	47	HOWTO (R_XC16X_ABS_8, /* type */
	48	0, /* rightshift */
	49	0, /* size (0 = byte, 1 = short, 2 = long) */
	50	8, /* bitsize */
	51	FALSE, /* pc_relative */
	52	8, /* bitpos */
	53	complain_overflow_bitfield, /* complain_on_overflow */
	54	bfd_elf_generic_reloc, /* special_function */
	55	"R_XC16X_ABS_8", /* name */
	56	TRUE, /* partial_inplace */
	57	0x0000, /* src_mask */
	58	0x00ff, /* dst_mask */
	59	FALSE), /* pcrel_offset */
	60
	61	/* A 16 bit absolute relocation. */
	62	HOWTO (R_XC16X_ABS_16, /* type */
	63	0, /* rightshift */
	64	1, /* size (0 = byte, 1 = short, 2 = long) */
65	16, /* bitsize */
66	FALSE, /* pc_relative */
67	0, /* bitpos */
68	complain_overflow_dont, /* complain_on_overflow */
69	bfd_elf_generic_reloc, /* special_function */
70	"R_XC16X_ABS_16", /* name */
71	TRUE, /* partial_inplace */
72	0x00000000, /* src_mask */
73	0x0000ffff, /* dst_mask */
74	FALSE), /* pcrel_offset */
75
76	HOWTO (R_XC16X_ABS_32, /* type */
77	0, /* rightshift */
78	2, /* size (0 = byte, 1 = short, 2 = long) */
79	32, /* bitsize */
80	FALSE, /* pc_relative */
81	0, /* bitpos */
82	complain_overflow_bitfield, /* complain_on_overflow */
83	bfd_elf_generic_reloc, /* special_function */
84	"R_XC16X_ABS_32", /* name */
85	TRUE, /* partial_inplace */
86	0x00000000, /* src_mask */
87	0xffffffff, /* dst_mask */
88	FALSE), /* pcrel_offset */
89
90
91	/* A PC relative 8 bit relocation. */
92	HOWTO (R_XC16X_8_PCREL, /* type */
93	0, /* rightshift */
94	0, /* size (0 = byte, 1 = short, 2 = long) */
95	8, /* bitsize */
96	TRUE, /* pc_relative */
97	8, /* bitpos */
98	complain_overflow_signed, /* complain_on_overflow */
99	bfd_elf_generic_reloc, /* special_function */
100	"R_XC16X_8_PCREL", /* name */
101	FALSE, /* partial_inplace */
102	0x0000, /* src_mask */
103	0x00ff, /* dst_mask */
104	TRUE), /* pcrel_offset */
105
106	/* Relocation regarding page number. */
107	HOWTO (R_XC16X_PAG, /* type */
108	0, /* rightshift */
109	1, /* size (0 = byte, 1 = short, 2 = long) */
110	16, /* bitsize */
111	FALSE, /* pc_relative */
112	0, /* bitpos */
113	complain_overflow_signed, /* complain_on_overflow */
114	bfd_elf_generic_reloc, /* special_function */
115	"R_XC16X_PAG", /* name */
116	TRUE, /* partial_inplace */
117	0x00000000, /* src_mask */
118	0x0000ffff, /* dst_mask */
119	FALSE), /* pcrel_offset */
120
121
122	/* Relocation regarding page number. */
123	HOWTO (R_XC16X_POF, /* type */
124	0, /* rightshift */
125	1, /* size (0 = byte, 1 = short, 2 = long) */
126	16, /* bitsize */
127	FALSE, /* pc_relative */
128	0, /* bitpos */
129	complain_overflow_signed, /* complain_on_overflow */
130	bfd_elf_generic_reloc, /* special_function */
131	"R_XC16X_POF", /* name */
132	TRUE, /* partial_inplace */
133	0x00000000, /* src_mask */
134	0x0000ffff, /* dst_mask */
135	FALSE), /* pcrel_offset */
136
137
138	/* Relocation regarding segment number. */
139	HOWTO (R_XC16X_SEG, /* type */
140	0, /* rightshift */
141	1, /* size (0 = byte, 1 = short, 2 = long) */
142	16, /* bitsize */
143	FALSE, /* pc_relative */
144	0, /* bitpos */
145	complain_overflow_signed, /* complain_on_overflow */
146	bfd_elf_generic_reloc, /* special_function */
147	"R_XC16X_SEG", /* name */
148	TRUE, /* partial_inplace */
149	0x00000000, /* src_mask */
150	0x0000ffff, /* dst_mask */
151	FALSE), /* pcrel_offset */
152
153	/* Relocation regarding segment offset. */
154	HOWTO (R_XC16X_SOF, /* type */
155	0, /* rightshift */
156	1, /* size (0 = byte, 1 = short, 2 = long) */
157	16, /* bitsize */
158	FALSE, /* pc_relative */
159	0, /* bitpos */
160	complain_overflow_signed, /* complain_on_overflow */
161	bfd_elf_generic_reloc, /* special_function */
162	"R_XC16X_SOF", /* name */
163	TRUE, /* partial_inplace */
164	0x00000000, /* src_mask */
165	0x0000ffff, /* dst_mask */
166	FALSE) /* pcrel_offset */
167	};
168
169
170	/* Map BFD reloc types to XC16X ELF reloc types. */
171
172	struct xc16x_reloc_map
173	{
174	bfd_reloc_code_real_type bfd_reloc_val;
175	unsigned int xc16x_reloc_val;
176	};
177
178	static const struct xc16x_reloc_map xc16x_reloc_map [] =
179	{
180	{ BFD_RELOC_NONE, R_XC16X_NONE },
181	{ BFD_RELOC_8, R_XC16X_ABS_8 },
182	{ BFD_RELOC_16, R_XC16X_ABS_16 },
183	{ BFD_RELOC_32, R_XC16X_ABS_32 },
184	{ BFD_RELOC_8_PCREL, R_XC16X_8_PCREL },
185	{ BFD_RELOC_XC16X_PAG, R_XC16X_PAG},
186	{ BFD_RELOC_XC16X_POF, R_XC16X_POF},
187	{ BFD_RELOC_XC16X_SEG, R_XC16X_SEG},
188	{ BFD_RELOC_XC16X_SOF, R_XC16X_SOF},
189	};
190
191
192	/* This function is used to search for correct relocation type from
193	howto structure. */
194
195	static reloc_howto_type *
196	xc16x_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
197	bfd_reloc_code_real_type code)
198	{
199	unsigned int i;
200
201	for (i = ARRAY_SIZE (xc16x_reloc_map); --i;)
202	if (xc16x_reloc_map [i].bfd_reloc_val == code)
203	return & xc16x_elf_howto_table [xc16x_reloc_map[i].xc16x_reloc_val];
204
205	return NULL;
206	}
207
208	/* For a particular operand this function is
209	called to finalise the type of relocation. */
210
211	static void
212	elf32_xc16x_info_to_howto (bfd abfd ATTRIBUTE_UNUSED, arelent bfd_reloc,
213	Elf_Internal_Rela *elf_reloc)
214	{
215	unsigned int r;
216	unsigned int i;
217
218	r = ELF32_R_TYPE (elf_reloc->r_info);
219	for (i = 0; i < ARRAY_SIZE (xc16x_elf_howto_table); i++)
220	if (xc16x_elf_howto_table[i].type == r)
221	{
222	bfd_reloc->howto = &xc16x_elf_howto_table[i];
223	return;
224	}
225	abort ();
226	}
227
228	static bfd_reloc_status_type
229	elf32_xc16x_final_link_relocate (unsigned long r_type,
230	bfd *input_bfd,
231	bfd *output_bfd ATTRIBUTE_UNUSED,
232	asection *input_section ATTRIBUTE_UNUSED,
233	bfd_byte *contents,
234	bfd_vma offset,
235	bfd_vma value,
236	bfd_vma addend,
237	struct bfd_link_info *info ATTRIBUTE_UNUSED,
238	asection *sym_sec ATTRIBUTE_UNUSED,
239	int is_local ATTRIBUTE_UNUSED)
240	{
241	bfd_byte *hit_data = contents + offset;
242	bfd_vma val1;
243
244	switch (r_type)
245	{
246	case R_XC16X_NONE:
247	return bfd_reloc_ok;
248
249	case R_XC16X_ABS_16:
250	value += addend;
251	bfd_put_16 (input_bfd, value, hit_data);
252	return bfd_reloc_ok;
253
254	case R_XC16X_8_PCREL:
255	bfd_put_8 (input_bfd, value, hit_data);
256	return bfd_reloc_ok;
257
258	/* Following case is to find page number from actual
259	address for this divide value by 16k i.e. page size. */
260
261	case R_XC16X_PAG:
262	value += addend;
263	value /= 0x4000;
264	bfd_put_16 (input_bfd, value, hit_data);
265	return bfd_reloc_ok;
266
267	/* Following case is to find page offset from actual address
268	for this take modulo of value by 16k i.e. page size. */
269
270	case R_XC16X_POF:
271	value += addend;
272	value %= 0x4000;
273	bfd_put_16 (input_bfd, value, hit_data);
274	return bfd_reloc_ok;
275
276	/* Following case is to find segment number from actual
277	address for this divide value by 64k i.e. segment size. */
278
279	case R_XC16X_SEG:
280	value += addend;
281	value /= 0x10000;
282	bfd_put_16 (input_bfd, value, hit_data);
283	return bfd_reloc_ok;
284
285	/* Following case is to find segment offset from actual address
286	for this take modulo of value by 64k i.e. segment size. */
287
288	case R_XC16X_SOF:
289	value += addend;
290	value %= 0x10000;
291	bfd_put_16 (input_bfd, value, hit_data);
292	return bfd_reloc_ok;
293
294	case R_XC16X_ABS_32:
295	if (!strstr (input_section->name,".debug"))
296	{
297	value += addend;
298	val1 = value;
299	value %= 0x4000;
300	val1 /= 0x4000;
301	val1 = val1 << 16;
302	value += val1;
303	bfd_put_32 (input_bfd, value, hit_data);
304	}
305	else
306	{
307	value += addend;
308	bfd_put_32 (input_bfd, value, hit_data);
309	}
310	return bfd_reloc_ok;
311
312	default:
313	return bfd_reloc_notsupported;
314	}
315	}
316
317	static bfd_boolean
318	elf32_xc16x_relocate_section (bfd *output_bfd,
319	struct bfd_link_info *info,
320	bfd *input_bfd,
321	asection *input_section,
322	bfd_byte *contents,
323	Elf_Internal_Rela *relocs,
324	Elf_Internal_Sym *local_syms,
325	asection **local_sections)
326	{
327	Elf_Internal_Shdr *symtab_hdr;
328	struct elf_link_hash_entry **sym_hashes;
329	Elf_Internal_Rela rel, relend;
330
331	if (info->relocatable)
332	return TRUE;
333
334	symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
335	sym_hashes = elf_sym_hashes (input_bfd);
336
337	rel = relocs;
338	relend = relocs + input_section->reloc_count;
339	for (; rel < relend; rel++)
340	{
341	unsigned int r_type;
342	unsigned long r_symndx;
343	Elf_Internal_Sym *sym;
344	asection *sec;
345	struct elf_link_hash_entry *h;
346	bfd_vma relocation;
347	bfd_reloc_status_type r;
348
349	/* This is a final link. */
350	r_symndx = ELF32_R_SYM (rel->r_info);
351	r_type = ELF32_R_TYPE (rel->r_info);
352	h = NULL;
353	sym = NULL;
354	sec = NULL;
355	if (r_symndx < symtab_hdr->sh_info)
356	{
357	sym = local_syms + r_symndx;
358	sec = local_sections[r_symndx];
359	relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
360	}
361	else
362	{
363	bfd_boolean unresolved_reloc, warned;
364
365	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
366	r_symndx, symtab_hdr, sym_hashes,
367	h, sec, relocation,
368	unresolved_reloc, warned);
369	}
370
371	r = elf32_xc16x_final_link_relocate (r_type, input_bfd, output_bfd,
372	input_section,
373	contents, rel->r_offset,
374	relocation, rel->r_addend,
375	info, sec, h == NULL);
376	}
377
378	return TRUE;
379	}
380
381
382	static void
383	elf32_xc16x_final_write_processing (bfd *abfd,
384	bfd_boolean linker ATTRIBUTE_UNUSED)
385	{
386	unsigned long val;
387
388	switch (bfd_get_mach (abfd))
389	{
390	default:
391	case bfd_mach_xc16x:
392	val = 0x1000;
393	break;
394
395	case bfd_mach_xc16xl:
396	val = 0x1001;
397	break;
398
399	case bfd_mach_xc16xs:
400	val = 0x1002;
401	break;
402	}
403
404	elf_elfheader (abfd)->e_flags \|= val;
405	}
406
407	static unsigned long
408	elf32_xc16x_mach (flagword flags)
409	{
410	switch (flags)
411	{
412	case 0x1000:
413	default:
414	return bfd_mach_xc16x;
415
416	case 0x1001:
417	return bfd_mach_xc16xl;
418
419	case 0x1002:
420	return bfd_mach_xc16xs;
421	}
422	}
423
424
425	static bfd_boolean
426	elf32_xc16x_object_p (bfd *abfd)
427	{
428	bfd_default_set_arch_mach (abfd, bfd_arch_xc16x,
429	elf32_xc16x_mach (elf_elfheader (abfd)->e_flags));
430	return TRUE;
431	}
432
433
434	#define ELF_ARCH bfd_arch_xc16x
435	#define ELF_MACHINE_CODE EM_XC16X
436	#define ELF_MAXPAGESIZE 0x100
437
438	#define TARGET_LITTLE_SYM bfd_elf32_xc16x_vec
439	#define TARGET_LITTLE_NAME "elf32-xc16x"
440	#define elf_backend_final_write_processing elf32_xc16x_final_write_processing
441	#define elf_backend_object_p elf32_xc16x_object_p
442	#define elf_backend_can_gc_sections 1
443	#define bfd_elf32_bfd_reloc_type_lookup xc16x_reloc_type_lookup
444	#define elf_info_to_howto elf32_xc16x_info_to_howto
445	#define elf_info_to_howto_rel elf32_xc16x_info_to_howto
446	#define elf_backend_relocate_section elf32_xc16x_relocate_section
447	#define elf_backend_rela_normal 1
448
449	#include "elf32-target.h"