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

/* Adapteva epiphany specific support for 32-bit ELF
   Copyright (C) 2000-2020 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, 3,0, 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 (bfd_link_relocatable (link_info)
      || (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 (elf_section_data (sec)->relocs != internal_relocs)
    free (internal_relocs);

  return TRUE;

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

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

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

  r_type = ELF32_R_TYPE (dst->r_info);
  if (r_type >= (unsigned int) R_EPIPHANY_max)
    {
      /* xgettext:c-format */
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
			  abfd, r_type);
      bfd_set_error (bfd_error_bad_value);
      return FALSE;
    }
  cache_ptr->howto = & epiphany_elf_howto_table [r_type];
  return TRUE;
}

/* 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;
      /* Fall through.  */
    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 (sec) : name;
	}
      else
	{
	  bfd_boolean warned ATTRIBUTE_UNUSED;
	  bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
	  bfd_boolean ignored ATTRIBUTE_UNUSED;

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

	  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 (bfd_link_relocatable (info))
	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:
	      (*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:
	      (*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)
	    (*info->callbacks->warning) (info, msg, name, input_bfd,
					 input_section, rel->r_offset);
	}
    }

  return TRUE;
}

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