[binutils.git] / bfd / elf32-epiphany.c

/* Adapteva epiphany specific support for 32-bit ELF
   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2011, 2012
   Free Software Foundation, Inc.
   Contributed by Embecosm on behalf of Adapteva, Inc.

   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 "libbfd.h"
#include "elf-bfd.h"
#include "elf/epiphany.h"
#include "libiberty.h"

/* Struct used to pass miscellaneous paramaters which
   helps to avoid overly long parameter lists.  */
struct misc
{
  Elf_Internal_Shdr *  symtab_hdr;
  Elf_Internal_Rela *  irelbase;
  bfd_byte *           contents;
  Elf_Internal_Sym *   isymbuf;
};

struct epiphany_opcode
{
  unsigned short opcode;
  unsigned short mask;
};

static bfd_boolean epiphany_relaxed = FALSE;

/* Relocation tables.  */
static reloc_howto_type epiphany_elf_howto_table [] =
{
#define AHOW(t,rs,s,bs,pr,bp,co,name,sm,dm)	\
    HOWTO(t,                    /* type */ \
	  rs,                   /* rightshift */ \
	  s,                    /* size (0 = byte, 1 = short, 2 = long) */ \
	  bs,                   /* bitsize */ \
	  pr,                   /* pc_relative */ \
	  bp,                   /* bitpos */ \
	  co,			/* complain_on_overflow */	       \
	  bfd_elf_generic_reloc,/* special_function */ \
	  name,                 /* name */ \
	  FALSE,                /* partial_inplace */ \
	  sm,                   /* src_mask */ \
	  dm,                   /* dst_mask */ \
	  pr)                   /* pcrel_offset */

  /* This reloc does nothing.  */
  AHOW (R_EPIPHANY_NONE,    0, 0,32, FALSE, 0, complain_overflow_dont,     "R_EPIPHANY_NONE",        0,          0),

  /* 8 bit absolute (not likely) */
  AHOW (R_EPIPHANY_8,       0, 0, 8, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_8",      0x000000ff, 0x000000ff),
  /* 16 bit absolute */
  AHOW (R_EPIPHANY_16,      0, 1,16, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_16",     0x0000ffff, 0x00ff1fe0),
  /* A 32 bit absolute relocation.  */
  AHOW (R_EPIPHANY_32,      0, 2,32, FALSE, 0, complain_overflow_dont,     "R_EPIPHANY_32",     0xffffffff, 0xffffffff),

  /*  8 bit relative relocation */
  HOWTO ( R_EPIPHANY_8_PCREL,  0, 0,  8, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
  /* 16 bit relative relocation */
  HOWTO ( R_EPIPHANY_16_PCREL, 0, 1, 16, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
  /* 32 bit relative relocation */
  HOWTO ( R_EPIPHANY_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),

  /* 8 bit pc-relative relocation */
  AHOW (R_EPIPHANY_SIMM8,   1, 0, 8,  TRUE, 8, complain_overflow_signed,   "R_EPIPHANY_SIMM8",   0x000000ff, 0x0000ff00),
  /* 24 bit pc-relative relocation */
  AHOW (R_EPIPHANY_SIMM24,  1, 2,24,  TRUE, 8, complain_overflow_signed,   "R_EPIPHANY_SIMM24",  0x00ffffff, 0xffffff00),

  /* %HIGH(EA) */
  AHOW (R_EPIPHANY_HIGH,    0, 2,16, FALSE, 0, complain_overflow_dont,     "R_EPIPHANY_HIGH",    0x0ff01fe0, 0x0ff01fe0),

  /* %LOW(EA) */
  AHOW (R_EPIPHANY_LOW,     0, 2,16, FALSE, 0, complain_overflow_dont,	"R_EPIPHANY_LOW",     0x0ff01fe0, 0x0ff01fe0),

  /* simm11 */
  AHOW (R_EPIPHANY_SIMM11,  0, 2,11, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_SIMM11",  0x00ff0380, 0x00ff0380),
  /* imm12 - sign-magnitude */
  AHOW (R_EPIPHANY_IMM11,   0, 2,11, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_IMM12",   0x00ff0380, 0x00ff0380),
  /* imm8 */
  AHOW (R_EPIPHANY_IMM8,    0, 1, 8, FALSE, 8, complain_overflow_signed,   "R_EPIPHANY_IMM8",    0x0000ff00, 0x0000ff00)


};
#undef AHOW

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

static reloc_howto_type *
epiphany_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
			    bfd_reloc_code_real_type code)
{
  /* Note that the epiphany_elf_howto_table is indxed by the R_
     constants.  Thus, the order that the howto records appear in the
     table *must* match the order of the relocation types defined in
     include/elf/epiphany.h.  */

  switch (code)
    {
    case BFD_RELOC_NONE:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_NONE];

    case BFD_RELOC_EPIPHANY_SIMM8:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM8];
    case BFD_RELOC_EPIPHANY_SIMM24:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM24];

    case BFD_RELOC_8_PCREL:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8_PCREL];
    case BFD_RELOC_16_PCREL:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16_PCREL];
    case BFD_RELOC_32_PCREL:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32_PCREL];

    case BFD_RELOC_8:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8];
    case BFD_RELOC_16:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16];
    case BFD_RELOC_32:
      return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32];

    case BFD_RELOC_EPIPHANY_HIGH:
      return & epiphany_elf_howto_table[ (int) R_EPIPHANY_HIGH];
    case BFD_RELOC_EPIPHANY_LOW:
      return & epiphany_elf_howto_table[ (int) R_EPIPHANY_LOW];

    case BFD_RELOC_EPIPHANY_SIMM11:
      return & epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM11];
    case BFD_RELOC_EPIPHANY_IMM11:
      return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM11];

    case BFD_RELOC_EPIPHANY_IMM8:
      return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM8];

    default:
      /* Pacify gcc -Wall.  */
      return NULL;
    }
  return NULL;
}

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

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

  return NULL;
}

#define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000)
#define BASEADDR(SEC)	((SEC)->output_section->vma + (SEC)->output_offset)

/* This function handles relaxing for the epiphany.
   Dummy placeholder for future optimizations.  */

static bfd_boolean
epiphany_elf_relax_section (bfd *abfd, asection *sec,
			    struct bfd_link_info *link_info,
			    bfd_boolean *again)
{
  Elf_Internal_Shdr *symtab_hdr;
  Elf_Internal_Rela *internal_relocs;
  bfd_byte *contents = NULL;
  Elf_Internal_Sym *isymbuf = NULL;
  static asection * first_section = NULL;
  static unsigned long search_addr;
  static unsigned long page_start = 0;
  static unsigned long page_end = 0;
  static unsigned int pass = 0;
  static bfd_boolean new_pass = FALSE;
  static bfd_boolean changed = FALSE;
  struct misc misc ATTRIBUTE_UNUSED;
  asection *stab;

  /* Assume nothing changes.  */
  *again = FALSE;

  if (first_section == NULL)
    {
      epiphany_relaxed = TRUE;
      first_section = sec;
    }

  if (first_section == sec)
    {
      pass++;
      new_pass = TRUE;
    }

  /* We don't have to do anything for a relocatable link,
     if this section does not have relocs, or if this is
     not a code section.  */
  if (link_info->relocatable
      || (sec->flags & SEC_RELOC) == 0
      || sec->reloc_count == 0
      || (sec->flags & SEC_CODE) == 0)
    return TRUE;

  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;

  internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
					       link_info->keep_memory);
  if (internal_relocs == NULL)
    goto error_return;

  /* Make sure the stac.rela stuff gets read in.  */
  stab = bfd_get_section_by_name (abfd, ".stab");

  if (stab)
    {
      /* So stab does exits.  */
      Elf_Internal_Rela * irelbase ATTRIBUTE_UNUSED;

      irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL,
					    link_info->keep_memory);
    }

  /* Get section contents cached copy if it exists.  */
  if (contents == NULL)
    {
      /* Get cached copy if it exists.  */
      if (elf_section_data (sec)->this_hdr.contents != NULL)
	contents = elf_section_data (sec)->this_hdr.contents;
      else
	{
	  /* Go get them off disk.  */
	  if (!bfd_malloc_and_get_section (abfd, sec, &contents))
	    goto error_return;
	}
    }

  /* Read this BFD's symbols cached copy if it exists.  */
  if (isymbuf == NULL && symtab_hdr->sh_info != 0)
    {
      isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
      if (isymbuf == NULL)
	isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
					symtab_hdr->sh_info, 0,
					NULL, NULL, NULL);
      if (isymbuf == NULL)
	goto error_return;
    }

  misc.symtab_hdr = symtab_hdr;
  misc.isymbuf = isymbuf;
  misc.irelbase = internal_relocs;
  misc.contents = contents;

  /* This is where all the relaxation actually get done.  */
  if ((pass == 1) || (new_pass && !changed))
    {
      /* On the first pass we simply search for the lowest page that
	 we havn't relaxed yet. Note that the pass count is reset
	 each time a page is complete in order to move on to the next page.
	 If we can't find any more pages then we are finished.  */
      if (new_pass)
	{
	  pass = 1;
	  new_pass = FALSE;
	  changed = TRUE; /* Pre-initialize to break out of pass 1.  */
	  search_addr = 0xFFFFFFFF;
	}

      if ((BASEADDR (sec) + sec->size < search_addr)
	  && (BASEADDR (sec) + sec->size > page_end))
	{
	  if (BASEADDR (sec) <= page_end)
	    search_addr = page_end + 1;
	  else
	    search_addr = BASEADDR (sec);

	  /* Found a page => more work to do.  */
	  *again = TRUE;
	}
    }
  else
    {
      if (new_pass)
	{
	  new_pass = FALSE;
	  changed = FALSE;
	  page_start = PAGENO (search_addr);
	  page_end = page_start | 0x00003FFF;
	}

      /* Only process sections in range.  */
      if ((BASEADDR (sec) + sec->size >= page_start)
	  && (BASEADDR (sec) <= page_end))
	{
#if 0
	  if (!epiphany_elf_relax_section_page (abfd, sec, &changed, &misc,
						page_start, page_end))
#endif
	    return FALSE;
	}
      *again = TRUE;
    }

  /* Perform some house keeping after relaxing the section.  */

  if (isymbuf != NULL
      && symtab_hdr->contents != (unsigned char *) isymbuf)
    {
      if (! link_info->keep_memory)
	free (isymbuf);
      else
	symtab_hdr->contents = (unsigned char *) isymbuf;
    }

  if (contents != NULL
      && elf_section_data (sec)->this_hdr.contents != contents)
    {
      if (! link_info->keep_memory)
	free (contents);
      else
	{
	  /* Cache the section contents for elf_link_input_bfd.  */
	  elf_section_data (sec)->this_hdr.contents = contents;
	}
    }

  if (internal_relocs != NULL
      && elf_section_data (sec)->relocs != internal_relocs)
    free (internal_relocs);

  return TRUE;

 error_return:
  if (isymbuf != NULL
      && symtab_hdr->contents != (unsigned char *) isymbuf)
    free (isymbuf);
  if (contents != NULL
      && elf_section_data (sec)->this_hdr.contents != contents)
    free (contents);
  if (internal_relocs != NULL
      && elf_section_data (sec)->relocs != internal_relocs)
    free (internal_relocs);
  return FALSE;
}

/* Set the howto pointer for a EPIPHANY ELF reloc.  */

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

  r_type = ELF32_R_TYPE (dst->r_info);
  cache_ptr->howto = & epiphany_elf_howto_table [r_type];
}

/* Perform a single relocation.
   By default we use the standard BFD routines.  */

static bfd_reloc_status_type
epiphany_final_link_relocate (reloc_howto_type *  howto,
			      bfd *               input_bfd,
			      asection *          input_section,
			      bfd_byte *          contents,
			      Elf_Internal_Rela * rel,
			      bfd_vma             relocation)
{
  switch (howto->type)
    {
      /* Handle 16 bit immediates.  */
    case R_EPIPHANY_HIGH:
      relocation += rel->r_addend;
      relocation >>= 16;
      goto common;

    case R_EPIPHANY_LOW:
      relocation += rel->r_addend;
    common:
      relocation = ((relocation & 0xff00L) << 12)
	| ((relocation & 0x00ffL) << 5);
      /* Sanity check the address.  */
      if (rel->r_offset > bfd_get_section_limit (input_bfd, input_section))
	return bfd_reloc_outofrange;

      return _bfd_relocate_contents (howto, input_bfd, relocation,
				     contents + rel->r_offset);

    case R_EPIPHANY_SIMM11:
      relocation += rel->r_addend;
      /* Check signed overflow.  */
      if ((int)relocation > 1023 || (int)relocation < -1024)
	return bfd_reloc_outofrange;
      goto disp11;

    case R_EPIPHANY_IMM11:
      relocation += rel->r_addend;
      if ((unsigned int) relocation > 0x7ff)
	return bfd_reloc_outofrange;
    disp11:
      relocation = ((relocation & 7) << 5)
	|| ((relocation & 0x7f8 )  << 13);
      return _bfd_relocate_contents (howto, input_bfd, relocation,
				     contents + rel->r_offset);

      /* Pass others through.  */
    default:
      break;
    }

  /* Only install relocation if above tests did not disqualify it.  */
  return _bfd_final_link_relocate (howto, input_bfd, input_section,
				   contents, rel->r_offset,
				   relocation, rel->r_addend);
}

/* Relocate an EPIPHANY ELF section.

   The RELOCATE_SECTION function is called by the new ELF backend linker
   to handle the relocations for a section.

   The relocs are always passed as Rela structures; if the section
   actually uses Rel structures, the r_addend field will always be
   zero.

   This function is responsible for adjusting the section contents as
   necessary, and (if using Rela relocs and generating a relocatable
   output file) adjusting the reloc addend as necessary.

   This function does not have to worry about setting the reloc
   address or the reloc symbol index.

   LOCAL_SYMS is a pointer to the swapped in local symbols.

   LOCAL_SECTIONS is an array giving the section in the input file
   corresponding to the st_shndx field of each local symbol.

   The global hash table entry for the global symbols can be found
   via elf_sym_hashes (input_bfd).

   When generating relocatable output, this function must handle
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
   going to be the section symbol corresponding to the output
   section, which means that the addend must be adjusted
   accordingly.  */

static bfd_boolean
epiphany_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
			       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;
  Elf_Internal_Rela *relend;

  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (input_bfd);
  relend     = relocs + input_section->reloc_count;

  for (rel = relocs; rel < relend; rel ++)
    {
      reloc_howto_type *           howto;
      unsigned long                r_symndx;
      Elf_Internal_Sym *           sym;
      asection *                   sec;
      struct elf_link_hash_entry * h;
      bfd_vma                      relocation;
      bfd_reloc_status_type        r;
      const char *                 name = NULL;
      int                          r_type ATTRIBUTE_UNUSED;

      r_type = ELF32_R_TYPE (rel->r_info);
      r_symndx = ELF32_R_SYM (rel->r_info);
      howto  = epiphany_elf_howto_table + 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 = BASEADDR (sec) + sym->st_value;

	  name = bfd_elf_string_from_elf_section
	    (input_bfd, symtab_hdr->sh_link, sym->st_name);
	  name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
	}
      else
	{
	  bfd_boolean warned ATTRIBUTE_UNUSED;
	  bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;

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

	  name = h->root.root.string;
	}

      if (sec != NULL && discarded_section (sec))
	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
					 rel, 1, relend, howto, 0, contents);

      if (info->relocatable)
	continue;

      /* Finally, the sole EPIPHANY-specific part.  */
      r = epiphany_final_link_relocate (howto, input_bfd, input_section,
				     contents, rel, relocation);

      if (r != bfd_reloc_ok)
	{
	  const char * msg = NULL;

	  switch (r)
	    {
	    case bfd_reloc_overflow:
	      r = info->callbacks->reloc_overflow
		(info, (h ? &h->root : NULL), name, howto->name,
		 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
	      break;

	    case bfd_reloc_undefined:
	      r = info->callbacks->undefined_symbol
		(info, name, input_bfd, input_section, rel->r_offset, TRUE);
	      break;

	    case bfd_reloc_outofrange:
	      msg = _("internal error: out of range error");
	      break;

	      /* This is how epiphany_final_link_relocate tells us of a
		 non-kosher reference between insn & data address spaces.  */
	    case bfd_reloc_notsupported:
	      if (sym != NULL) /* Only if it's not an unresolved symbol.  */
		 msg = _("unsupported relocation between data/insn address spaces");
	      break;

	    case bfd_reloc_dangerous:
	      msg = _("internal error: dangerous relocation");
	      break;

	    default:
	      msg = _("internal error: unknown error");
	      break;
	    }

	  if (msg)
	    r = info->callbacks->warning
	      (info, msg, name, input_bfd, input_section, rel->r_offset);

	  if (! r)
	    return FALSE;
	}
    }

  return TRUE;
}

/* We only have a little-endian target.  */
#define TARGET_LITTLE_SYM	 bfd_elf32_epiphany_vec
#define TARGET_LITTLE_NAME  "elf32-epiphany"

#define ELF_ARCH	 bfd_arch_epiphany
#define ELF_MACHINE_CODE EM_ADAPTEVA_EPIPHANY

#define ELF_MAXPAGESIZE  0x8000 /* No pages on the EPIPHANY.  */

#define elf_info_to_howto_rel			NULL
#define elf_info_to_howto			epiphany_info_to_howto_rela

#define elf_backend_can_gc_sections     	1
#define elf_backend_rela_normal			1
#define elf_backend_relocate_section		epiphany_elf_relocate_section

#define elf_symbol_leading_char			'_'
#define bfd_elf32_bfd_reloc_type_lookup		epiphany_reloc_type_lookup
#define bfd_elf32_bfd_reloc_name_lookup		epiphany_reloc_name_lookup
#define bfd_elf32_bfd_relax_section		epiphany_elf_relax_section

#include "elf32-target.h"
Commit	Line	Data
cfb8c092	1	/* Adapteva epiphany specific support for 32-bit ELF
dbaa2011	2	Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2011, 2012
cfb8c092 NC	3	Free Software Foundation, Inc.
	4	Contributed by Embecosm on behalf of Adapteva, Inc.
	5
	6	This file is part of BFD, the Binary File Descriptor library.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 3 of the License, or
	11	(at your option) any later version.
	12
	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.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	21	MA 02110-1301, USA. */
	22
	23	#include "sysdep.h"
	24	#include "bfd.h"
	25	#include "libbfd.h"
	26	#include "elf-bfd.h"
	27	#include "elf/epiphany.h"
	28	#include "libiberty.h"
	29
	30	/* Struct used to pass miscellaneous paramaters which
	31	helps to avoid overly long parameter lists. */
	32	struct misc
	33	{
	34	Elf_Internal_Shdr * symtab_hdr;
	35	Elf_Internal_Rela * irelbase;
	36	bfd_byte * contents;
	37	Elf_Internal_Sym * isymbuf;
	38	};
	39
	40	struct epiphany_opcode
	41	{
	42	unsigned short opcode;
	43	unsigned short mask;
	44	};
	45
	46	static bfd_boolean epiphany_relaxed = FALSE;
	47
	48	/* Relocation tables. */
	49	static reloc_howto_type epiphany_elf_howto_table [] =
	50	{
	51	#define AHOW(t,rs,s,bs,pr,bp,co,name,sm,dm) \
	52	HOWTO(t, /* type */ \
	53	rs, /* rightshift */ \
	54	s, /* size (0 = byte, 1 = short, 2 = long) */ \
	55	bs, /* bitsize */ \
	56	pr, /* pc_relative */ \
	57	bp, /* bitpos */ \
	58	co, /* complain_on_overflow */ \
	59	bfd_elf_generic_reloc,/* special_function */ \
	60	name, /* name */ \
	61	FALSE, /* partial_inplace */ \
	62	sm, /* src_mask */ \
	63	dm, /* dst_mask */ \
	64	pr) /* pcrel_offset */
	65
	66	/* This reloc does nothing. */
67	AHOW (R_EPIPHANY_NONE, 0, 0,32, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_NONE", 0, 0),
68
69	/* 8 bit absolute (not likely) */
70	AHOW (R_EPIPHANY_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_8", 0x000000ff, 0x000000ff),
71	/* 16 bit absolute */
72	AHOW (R_EPIPHANY_16, 0, 1,16, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_16", 0x0000ffff, 0x00ff1fe0),
73	/* A 32 bit absolute relocation. */
74	AHOW (R_EPIPHANY_32, 0, 2,32, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_32", 0xffffffff, 0xffffffff),
75
76	/* 8 bit relative relocation */
77	HOWTO ( R_EPIPHANY_8_PCREL, 0, 0, 8, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
78	/* 16 bit relative relocation */
79	HOWTO ( R_EPIPHANY_16_PCREL, 0, 1, 16, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
80	/* 32 bit relative relocation */
81	HOWTO ( R_EPIPHANY_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", FALSE, 0x000000ff, 0x000000ff, FALSE),
82
83	/* 8 bit pc-relative relocation */
84	AHOW (R_EPIPHANY_SIMM8, 1, 0, 8, TRUE, 8, complain_overflow_signed, "R_EPIPHANY_SIMM8", 0x000000ff, 0x0000ff00),
85	/* 24 bit pc-relative relocation */
86	AHOW (R_EPIPHANY_SIMM24, 1, 2,24, TRUE, 8, complain_overflow_signed, "R_EPIPHANY_SIMM24", 0x00ffffff, 0xffffff00),
87
88	/* %HIGH(EA) */
89	AHOW (R_EPIPHANY_HIGH, 0, 2,16, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_HIGH", 0x0ff01fe0, 0x0ff01fe0),
90
91	/* %LOW(EA) */
92	AHOW (R_EPIPHANY_LOW, 0, 2,16, FALSE, 0, complain_overflow_dont, "R_EPIPHANY_LOW", 0x0ff01fe0, 0x0ff01fe0),
93
94	/* simm11 */
95	AHOW (R_EPIPHANY_SIMM11, 0, 2,11, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_SIMM11", 0x00ff0380, 0x00ff0380),
96	/* imm12 - sign-magnitude */
97	AHOW (R_EPIPHANY_IMM11, 0, 2,11, FALSE, 0, complain_overflow_bitfield, "R_EPIPHANY_IMM12", 0x00ff0380, 0x00ff0380),
98	/* imm8 */
99	AHOW (R_EPIPHANY_IMM8, 0, 1, 8, FALSE, 8, complain_overflow_signed, "R_EPIPHANY_IMM8", 0x0000ff00, 0x0000ff00)
100
101
102	};
103	#undef AHOW
104
105	/* Map BFD reloc types to EPIPHANY ELF reloc types. */
106
107	static reloc_howto_type *
108	epiphany_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
109	bfd_reloc_code_real_type code)
110	{
111	/* Note that the epiphany_elf_howto_table is indxed by the R_
112	constants. Thus, the order that the howto records appear in the
113	table must match the order of the relocation types defined in
114	include/elf/epiphany.h. */
115
116	switch (code)
117	{
118	case BFD_RELOC_NONE:
119	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_NONE];
120
121	case BFD_RELOC_EPIPHANY_SIMM8:
122	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM8];
123	case BFD_RELOC_EPIPHANY_SIMM24:
124	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM24];
125
126	case BFD_RELOC_8_PCREL:
127	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8_PCREL];
128	case BFD_RELOC_16_PCREL:
129	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16_PCREL];
130	case BFD_RELOC_32_PCREL:
131	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32_PCREL];
132
133	case BFD_RELOC_8:
134	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8];
135	case BFD_RELOC_16:
136	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16];
137	case BFD_RELOC_32:
138	return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32];
139
140	case BFD_RELOC_EPIPHANY_HIGH:
141	return & epiphany_elf_howto_table[ (int) R_EPIPHANY_HIGH];
142	case BFD_RELOC_EPIPHANY_LOW:
143	return & epiphany_elf_howto_table[ (int) R_EPIPHANY_LOW];
144
145	case BFD_RELOC_EPIPHANY_SIMM11:
146	return & epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM11];
147	case BFD_RELOC_EPIPHANY_IMM11:
148	return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM11];
149
150	case BFD_RELOC_EPIPHANY_IMM8:
151	return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM8];
152
153	default:
154	/* Pacify gcc -Wall. */
155	return NULL;
156	}
157	return NULL;
158	}
159
160	static reloc_howto_type *
161	epiphany_reloc_name_lookup (bfd abfd ATTRIBUTE_UNUSED, const char r_name)
162	{
163	unsigned int i;
164
165	for (i = 0; i < ARRAY_SIZE (epiphany_elf_howto_table); i++)
166	if (epiphany_elf_howto_table[i].name != NULL
167	&& strcasecmp (epiphany_elf_howto_table[i].name, r_name) == 0)
168	return &epiphany_elf_howto_table[i];
169
170	return NULL;
171	}
172
173	#define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000)
174	#define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset)
175
176	/* This function handles relaxing for the epiphany.
177	Dummy placeholder for future optimizations. */
178
179	static bfd_boolean
180	epiphany_elf_relax_section (bfd abfd, asection sec,
181	struct bfd_link_info *link_info,
182	bfd_boolean *again)
183	{
184	Elf_Internal_Shdr *symtab_hdr;
185	Elf_Internal_Rela *internal_relocs;
186	bfd_byte *contents = NULL;
187	Elf_Internal_Sym *isymbuf = NULL;
188	static asection * first_section = NULL;
189	static unsigned long search_addr;
190	static unsigned long page_start = 0;
191	static unsigned long page_end = 0;
192	static unsigned int pass = 0;
193	static bfd_boolean new_pass = FALSE;
194	static bfd_boolean changed = FALSE;
195	struct misc misc ATTRIBUTE_UNUSED;
196	asection *stab;
197
198	/* Assume nothing changes. */
199	*again = FALSE;
200
201	if (first_section == NULL)
202	{
203	epiphany_relaxed = TRUE;
204	first_section = sec;
205	}
206
207	if (first_section == sec)
208	{
209	pass++;
210	new_pass = TRUE;
211	}
212
213	/* We don't have to do anything for a relocatable link,
214	if this section does not have relocs, or if this is
215	not a code section. */
216	if (link_info->relocatable
217	\|\| (sec->flags & SEC_RELOC) == 0
218	\|\| sec->reloc_count == 0
219	\|\| (sec->flags & SEC_CODE) == 0)
220	return TRUE;
221
222	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
223
224	internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
225	link_info->keep_memory);
226	if (internal_relocs == NULL)
227	goto error_return;
228
229	/* Make sure the stac.rela stuff gets read in. */
230	stab = bfd_get_section_by_name (abfd, ".stab");
231
232	if (stab)
233	{
234	/* So stab does exits. */
235	Elf_Internal_Rela * irelbase ATTRIBUTE_UNUSED;
236
237	irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL,
238	link_info->keep_memory);
239	}
240
241	/* Get section contents cached copy if it exists. */
242	if (contents == NULL)
243	{
244	/* Get cached copy if it exists. */
245	if (elf_section_data (sec)->this_hdr.contents != NULL)
246	contents = elf_section_data (sec)->this_hdr.contents;
247	else
248	{
249	/* Go get them off disk. */
250	if (!bfd_malloc_and_get_section (abfd, sec, &contents))
251	goto error_return;
252	}
253	}
254
255	/* Read this BFD's symbols cached copy if it exists. */
256	if (isymbuf == NULL && symtab_hdr->sh_info != 0)
257	{
258	isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
259	if (isymbuf == NULL)
260	isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
261	symtab_hdr->sh_info, 0,
262	NULL, NULL, NULL);
263	if (isymbuf == NULL)
264	goto error_return;
265	}
266
267	misc.symtab_hdr = symtab_hdr;
268	misc.isymbuf = isymbuf;
269	misc.irelbase = internal_relocs;
270	misc.contents = contents;
271
272	/* This is where all the relaxation actually get done. */
273	if ((pass == 1) \|\| (new_pass && !changed))
274	{
275	/* On the first pass we simply search for the lowest page that
276	we havn't relaxed yet. Note that the pass count is reset
277	each time a page is complete in order to move on to the next page.
278	If we can't find any more pages then we are finished. */
279	if (new_pass)
280	{
281	pass = 1;
282	new_pass = FALSE;
283	changed = TRUE; /* Pre-initialize to break out of pass 1. */
284	search_addr = 0xFFFFFFFF;
285	}
286
287	if ((BASEADDR (sec) + sec->size < search_addr)
288	&& (BASEADDR (sec) + sec->size > page_end))
289	{
290	if (BASEADDR (sec) <= page_end)
291	search_addr = page_end + 1;
292	else
293	search_addr = BASEADDR (sec);
294
295	/* Found a page => more work to do. */
296	*again = TRUE;
297	}
298	}
299	else
300	{
301	if (new_pass)
302	{
303	new_pass = FALSE;
304	changed = FALSE;
305	page_start = PAGENO (search_addr);
306	page_end = page_start \| 0x00003FFF;
307	}
308
309	/* Only process sections in range. */
310	if ((BASEADDR (sec) + sec->size >= page_start)
311	&& (BASEADDR (sec) <= page_end))
312	{
313	#if 0
314	if (!epiphany_elf_relax_section_page (abfd, sec, &changed, &misc,
315	page_start, page_end))
316	#endif
317	return FALSE;
318	}
319	*again = TRUE;
320	}
321
322	/* Perform some house keeping after relaxing the section. */
323
324	if (isymbuf != NULL
325	&& symtab_hdr->contents != (unsigned char *) isymbuf)
326	{
327	if (! link_info->keep_memory)
328	free (isymbuf);
329	else
330	symtab_hdr->contents = (unsigned char *) isymbuf;
331	}
332
333	if (contents != NULL
334	&& elf_section_data (sec)->this_hdr.contents != contents)
335	{
336	if (! link_info->keep_memory)
337	free (contents);
338	else
339	{
340	/* Cache the section contents for elf_link_input_bfd. */
341	elf_section_data (sec)->this_hdr.contents = contents;
342	}
343	}
344
345	if (internal_relocs != NULL
346	&& elf_section_data (sec)->relocs != internal_relocs)
347	free (internal_relocs);
348
349	return TRUE;
350
351	error_return:
352	if (isymbuf != NULL
353	&& symtab_hdr->contents != (unsigned char *) isymbuf)
354	free (isymbuf);
355	if (contents != NULL
356	&& elf_section_data (sec)->this_hdr.contents != contents)
357	free (contents);
358	if (internal_relocs != NULL
359	&& elf_section_data (sec)->relocs != internal_relocs)
360	free (internal_relocs);
361	return FALSE;
362	}
363
364	/* Set the howto pointer for a EPIPHANY ELF reloc. */
365
366	static void
367	epiphany_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
368	arelent * cache_ptr,
369	Elf_Internal_Rela * dst)
370	{
371	unsigned int r_type;
372
373	r_type = ELF32_R_TYPE (dst->r_info);
374	cache_ptr->howto = & epiphany_elf_howto_table [r_type];
375	}
376
377	/* Perform a single relocation.
378	By default we use the standard BFD routines. */
379
380	static bfd_reloc_status_type
381	epiphany_final_link_relocate (reloc_howto_type * howto,
382	bfd * input_bfd,
383	asection * input_section,
384	bfd_byte * contents,
385	Elf_Internal_Rela * rel,
386	bfd_vma relocation)
387	{
388	switch (howto->type)
389	{
390	/* Handle 16 bit immediates. */
391	case R_EPIPHANY_HIGH:
392	relocation += rel->r_addend;
393	relocation >>= 16;
394	goto common;
395
396	case R_EPIPHANY_LOW:
397	relocation += rel->r_addend;
398	common:
399	relocation = ((relocation & 0xff00L) << 12)
400	\| ((relocation & 0x00ffL) << 5);
401	/* Sanity check the address. */
402	if (rel->r_offset > bfd_get_section_limit (input_bfd, input_section))
403	return bfd_reloc_outofrange;
404
405	return _bfd_relocate_contents (howto, input_bfd, relocation,
406	contents + rel->r_offset);
407
408	case R_EPIPHANY_SIMM11:
409	relocation += rel->r_addend;
410	/* Check signed overflow. */
411	if ((int)relocation > 1023 \|\| (int)relocation < -1024)
412	return bfd_reloc_outofrange;
413	goto disp11;
414
415	case R_EPIPHANY_IMM11:
416	relocation += rel->r_addend;
417	if ((unsigned int) relocation > 0x7ff)
418	return bfd_reloc_outofrange;
419	disp11:
420	relocation = ((relocation & 7) << 5)
421	\|\| ((relocation & 0x7f8 ) << 13);
422	return _bfd_relocate_contents (howto, input_bfd, relocation,
423	contents + rel->r_offset);
424
425	/* Pass others through. */
426	default:
427	break;
428	}
429
430	/* Only install relocation if above tests did not disqualify it. */
431	return _bfd_final_link_relocate (howto, input_bfd, input_section,
432	contents, rel->r_offset,
433	relocation, rel->r_addend);
434	}
435
436	/* Relocate an EPIPHANY ELF section.
437
438	The RELOCATE_SECTION function is called by the new ELF backend linker
439	to handle the relocations for a section.
440
441	The relocs are always passed as Rela structures; if the section
442	actually uses Rel structures, the r_addend field will always be
443	zero.
444
445	This function is responsible for adjusting the section contents as
446	necessary, and (if using Rela relocs and generating a relocatable
447	output file) adjusting the reloc addend as necessary.
448
449	This function does not have to worry about setting the reloc
450	address or the reloc symbol index.
451
452	LOCAL_SYMS is a pointer to the swapped in local symbols.
453
454	LOCAL_SECTIONS is an array giving the section in the input file
455	corresponding to the st_shndx field of each local symbol.
456
457	The global hash table entry for the global symbols can be found
458	via elf_sym_hashes (input_bfd).
459
460	When generating relocatable output, this function must handle
461	STB_LOCAL/STT_SECTION symbols specially. The output symbol is
462	going to be the section symbol corresponding to the output
463	section, which means that the addend must be adjusted
464	accordingly. */
465
466	static bfd_boolean
467	epiphany_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
468	struct bfd_link_info *info,
469	bfd *input_bfd,
470	asection *input_section,
471	bfd_byte *contents,
472	Elf_Internal_Rela *relocs,
473	Elf_Internal_Sym *local_syms,
474	asection **local_sections)
475	{
476	Elf_Internal_Shdr *symtab_hdr;
477	struct elf_link_hash_entry **sym_hashes;
478	Elf_Internal_Rela *rel;
479	Elf_Internal_Rela *relend;
480
481	symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
482	sym_hashes = elf_sym_hashes (input_bfd);
483	relend = relocs + input_section->reloc_count;
484
485	for (rel = relocs; rel < relend; rel ++)
486	{
487	reloc_howto_type * howto;
488	unsigned long r_symndx;
489	Elf_Internal_Sym * sym;
490	asection * sec;
491	struct elf_link_hash_entry * h;
492	bfd_vma relocation;
493	bfd_reloc_status_type r;
494	const char * name = NULL;
495	int r_type ATTRIBUTE_UNUSED;
496
497	r_type = ELF32_R_TYPE (rel->r_info);
498	r_symndx = ELF32_R_SYM (rel->r_info);
499	howto = epiphany_elf_howto_table + ELF32_R_TYPE (rel->r_info);
500	h = NULL;
501	sym = NULL;
502	sec = NULL;
503
504	if (r_symndx < symtab_hdr->sh_info)
505	{
506	sym = local_syms + r_symndx;
507	sec = local_sections [r_symndx];
508	relocation = BASEADDR (sec) + sym->st_value;
509
510	name = bfd_elf_string_from_elf_section
511	(input_bfd, symtab_hdr->sh_link, sym->st_name);
512	name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
513	}
514	else
515	{
516	bfd_boolean warned ATTRIBUTE_UNUSED;
517	bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
518
519	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
520	r_symndx, symtab_hdr, sym_hashes,
521	h, sec, relocation,
522	unresolved_reloc, warned);
523
524	name = h->root.root.string;
525	}
526
dbaa2011	527	if (sec != NULL && discarded_section (sec))
cfb8c092	528	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b	529	rel, 1, relend, howto, 0, contents);
cfb8c092 NC	530
	531	if (info->relocatable)
	532	continue;
	533
	534	/* Finally, the sole EPIPHANY-specific part. */
	535	r = epiphany_final_link_relocate (howto, input_bfd, input_section,
	536	contents, rel, relocation);
	537
	538	if (r != bfd_reloc_ok)
	539	{
	540	const char * msg = NULL;
	541
	542	switch (r)
	543	{
	544	case bfd_reloc_overflow:
	545	r = info->callbacks->reloc_overflow
	546	(info, (h ? &h->root : NULL), name, howto->name,
	547	(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
	548	break;
	549
	550	case bfd_reloc_undefined:
	551	r = info->callbacks->undefined_symbol
	552	(info, name, input_bfd, input_section, rel->r_offset, TRUE);
	553	break;
	554
	555	case bfd_reloc_outofrange:
	556	msg = _("internal error: out of range error");
	557	break;
	558
	559	/* This is how epiphany_final_link_relocate tells us of a
	560	non-kosher reference between insn & data address spaces. */
	561	case bfd_reloc_notsupported:
	562	if (sym != NULL) /* Only if it's not an unresolved symbol. */
	563	msg = _("unsupported relocation between data/insn address spaces");
	564	break;
	565
	566	case bfd_reloc_dangerous:
	567	msg = _("internal error: dangerous relocation");
	568	break;
	569
	570	default:
	571	msg = _("internal error: unknown error");
	572	break;
	573	}
	574
	575	if (msg)
	576	r = info->callbacks->warning
	577	(info, msg, name, input_bfd, input_section, rel->r_offset);
	578
	579	if (! r)
	580	return FALSE;
	581	}
	582	}
	583
	584	return TRUE;
	585	}
	586
	587	/* We only have a little-endian target. */
	588	#define TARGET_LITTLE_SYM bfd_elf32_epiphany_vec
	589	#define TARGET_LITTLE_NAME "elf32-epiphany"
	590
	591	#define ELF_ARCH bfd_arch_epiphany
	592	#define ELF_MACHINE_CODE EM_ADAPTEVA_EPIPHANY
	593
594	#define ELF_MAXPAGESIZE 0x8000 /* No pages on the EPIPHANY. */
595
596	#define elf_info_to_howto_rel NULL
597	#define elf_info_to_howto epiphany_info_to_howto_rela
598
599	#define elf_backend_can_gc_sections 1
600	#define elf_backend_rela_normal 1
601	#define elf_backend_relocate_section epiphany_elf_relocate_section
602
603	#define elf_symbol_leading_char '_'
604	#define bfd_elf32_bfd_reloc_type_lookup epiphany_reloc_type_lookup
605	#define bfd_elf32_bfd_reloc_name_lookup epiphany_reloc_name_lookup
606	#define bfd_elf32_bfd_relax_section epiphany_elf_relax_section
607
608	#include "elf32-target.h"