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

/* Adapteva epiphany specific support for 32-bit ELF
   Copyright (C) 2000-2024 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 bool 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 */ \
	  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,0, false, 0, complain_overflow_dont,	  "R_EPIPHANY_NONE",	    0,		0),

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

  /*  8 bit relative relocation */
  HOWTO ( R_EPIPHANY_8_PCREL,  0, 1,  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, 2, 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, 4, 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, 1, 8,  true, 8, complain_overflow_signed,   "R_EPIPHANY_SIMM8",	 0x000000ff, 0x0000ff00),
  /* 24 bit pc-relative relocation */
  AHOW (R_EPIPHANY_SIMM24,  1, 4,24,  true, 8, complain_overflow_signed,   "R_EPIPHANY_SIMM24",	 0x00ffffff, 0xffffff00),

  /* %HIGH(EA) */
  AHOW (R_EPIPHANY_HIGH,    0, 4,16, false, 0, complain_overflow_dont,	   "R_EPIPHANY_HIGH",	 0x0ff01fe0, 0x0ff01fe0),

  /* %LOW(EA) */
  AHOW (R_EPIPHANY_LOW,	    0, 4,16, false, 0, complain_overflow_dont,	"R_EPIPHANY_LOW",     0x0ff01fe0, 0x0ff01fe0),

  /* simm11 */
  AHOW (R_EPIPHANY_SIMM11,  0, 4,11, false, 0, complain_overflow_bitfield, "R_EPIPHANY_SIMM11",	 0x00ff0380, 0x00ff0380),
  /* imm12 - sign-magnitude */
  AHOW (R_EPIPHANY_IMM11,   0, 4,11, false, 0, complain_overflow_bitfield, "R_EPIPHANY_IMM12",	 0x00ff0380, 0x00ff0380),
  /* imm8 */
  AHOW (R_EPIPHANY_IMM8,    0, 2, 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 bool
epiphany_elf_relax_section (bfd *abfd, asection *sec,
			    struct bfd_link_info *link_info,
			    bool *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 bool new_pass = false;
  static bool 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->reloc_count == 0
      || (sec->flags & SEC_RELOC) == 0
      || (sec->flags & SEC_HAS_CONTENTS) == 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 bool
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 int
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
	{
	  bool warned ATTRIBUTE_UNUSED;
	  bool unresolved_reloc ATTRIBUTE_UNUSED;
	  bool 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
fd67aa11	2	Copyright (C) 2000-2024 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
0a1b45a2	45	static bool epiphany_relaxed = false;
cfb8c092 NC	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 */ \
07d6d2b8 AM	52	rs, /* rightshift */ \
c94cb026	53	s, /* size */ \
07d6d2b8 AM	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	59	name, /* name */ \
0a1b45a2	60	false, /* partial_inplace */ \
07d6d2b8 AM	61	sm, /* src_mask */ \
	62	dm, /* dst_mask */ \
	63	pr) /* pcrel_offset */
cfb8c092 NC	64
cfb8c092 NC	65	/* This reloc does nothing. */
c94cb026	66	AHOW (R_EPIPHANY_NONE, 0, 0,0, false, 0, complain_overflow_dont, "R_EPIPHANY_NONE", 0, 0),
cfb8c092 NC	67
cfb8c092 NC	68	/* 8 bit absolute (not likely) */
c94cb026	69	AHOW (R_EPIPHANY_8, 0, 1, 8, false, 0, complain_overflow_bitfield, "R_EPIPHANY_8", 0x000000ff, 0x000000ff),
cfb8c092	70	/* 16 bit absolute */
c94cb026	71	AHOW (R_EPIPHANY_16, 0, 2,16, false, 0, complain_overflow_bitfield, "R_EPIPHANY_16", 0x0000ffff, 0x00ff1fe0),
cfb8c092	72	/* A 32 bit absolute relocation. */
c94cb026	73	AHOW (R_EPIPHANY_32, 0, 4,32, false, 0, complain_overflow_dont, "R_EPIPHANY_32", 0xffffffff, 0xffffffff),
cfb8c092 NC	74
cfb8c092 NC	75	/* 8 bit relative relocation */
c94cb026	76	HOWTO ( R_EPIPHANY_8_PCREL, 0, 1, 8, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", false, 0x000000ff, 0x000000ff, false),
cfb8c092	77	/* 16 bit relative relocation */
c94cb026	78	HOWTO ( R_EPIPHANY_16_PCREL, 0, 2, 16, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", false, 0x000000ff, 0x000000ff, false),
cfb8c092	79	/* 32 bit relative relocation */
c94cb026	80	HOWTO ( R_EPIPHANY_32_PCREL, 0, 4, 32, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", false, 0x000000ff, 0x000000ff, false),
cfb8c092 NC	81
cfb8c092 NC	82	/* 8 bit pc-relative relocation */
c94cb026	83	AHOW (R_EPIPHANY_SIMM8, 1, 1, 8, true, 8, complain_overflow_signed, "R_EPIPHANY_SIMM8", 0x000000ff, 0x0000ff00),
cfb8c092	84	/* 24 bit pc-relative relocation */
c94cb026	85	AHOW (R_EPIPHANY_SIMM24, 1, 4,24, true, 8, complain_overflow_signed, "R_EPIPHANY_SIMM24", 0x00ffffff, 0xffffff00),
cfb8c092 NC	86
cfb8c092 NC	87	/* %HIGH(EA) */
c94cb026	88	AHOW (R_EPIPHANY_HIGH, 0, 4,16, false, 0, complain_overflow_dont, "R_EPIPHANY_HIGH", 0x0ff01fe0, 0x0ff01fe0),
cfb8c092 NC	89
cfb8c092 NC	90	/* %LOW(EA) */
c94cb026	91	AHOW (R_EPIPHANY_LOW, 0, 4,16, false, 0, complain_overflow_dont, "R_EPIPHANY_LOW", 0x0ff01fe0, 0x0ff01fe0),
cfb8c092 NC	92
cfb8c092 NC	93	/* simm11 */
c94cb026	94	AHOW (R_EPIPHANY_SIMM11, 0, 4,11, false, 0, complain_overflow_bitfield, "R_EPIPHANY_SIMM11", 0x00ff0380, 0x00ff0380),
cfb8c092	95	/* imm12 - sign-magnitude */
c94cb026	96	AHOW (R_EPIPHANY_IMM11, 0, 4,11, false, 0, complain_overflow_bitfield, "R_EPIPHANY_IMM12", 0x00ff0380, 0x00ff0380),
cfb8c092	97	/* imm8 */
c94cb026	98	AHOW (R_EPIPHANY_IMM8, 0, 2, 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
0a1b45a2	178	static bool
cfb8c092 NC	179	epiphany_elf_relax_section (bfd abfd, asection sec,
cfb8c092 NC	180	struct bfd_link_info *link_info,
0a1b45a2	181	bool *again)
cfb8c092 NC	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;
0a1b45a2 AM	192	static bool new_pass = false;
0a1b45a2 AM	193	static bool changed = false;
cfb8c092 NC	194	struct misc misc ATTRIBUTE_UNUSED;
	195	asection *stab;
	196
	197	/* Assume nothing changes. */
0a1b45a2	198	*again = false;
cfb8c092 NC	199
	200	if (first_section == NULL)
	201	{
0a1b45a2	202	epiphany_relaxed = true;
cfb8c092 NC	203	first_section = sec;
	204	}
	205
	206	if (first_section == sec)
	207	{
	208	pass++;
0a1b45a2	209	new_pass = true;
cfb8c092 NC	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	216	\|\| sec->reloc_count == 0
3a574cce AM	217	\|\| (sec->flags & SEC_RELOC) == 0
3a574cce AM	218	\|\| (sec->flags & SEC_HAS_CONTENTS) == 0
cfb8c092	219	\|\| (sec->flags & SEC_CODE) == 0)
0a1b45a2	220	return true;
cfb8c092 NC	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;
0a1b45a2 AM	282	new_pass = false;
0a1b45a2 AM	283	changed = true; /* Pre-initialize to break out of pass 1. */
cfb8c092 NC	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. */
0a1b45a2	296	*again = true;
cfb8c092 NC	297	}
	298	}
	299	else
	300	{
	301	if (new_pass)
	302	{
0a1b45a2 AM	303	new_pass = false;
0a1b45a2 AM	304	changed = false;
cfb8c092 NC	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
0a1b45a2	317	return false;
cfb8c092	318	}
0a1b45a2	319	*again = true;
cfb8c092 NC	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
c9594989	345	if (elf_section_data (sec)->relocs != internal_relocs)
cfb8c092 NC	346	free (internal_relocs);
cfb8c092 NC	347
0a1b45a2	348	return true;
cfb8c092 NC	349
cfb8c092 NC	350	error_return:
c9594989	351	if (symtab_hdr->contents != (unsigned char *) isymbuf)
cfb8c092	352	free (isymbuf);
c9594989	353	if (elf_section_data (sec)->this_hdr.contents != contents)
cfb8c092	354	free (contents);
c9594989	355	if (elf_section_data (sec)->relocs != internal_relocs)
cfb8c092	356	free (internal_relocs);
0a1b45a2	357	return false;
cfb8c092 NC	358	}
	359
	360	/* Set the howto pointer for a EPIPHANY ELF reloc. */
	361
0a1b45a2	362	static bool
0aa13fee	363	epiphany_info_to_howto_rela (bfd * abfd,
cfb8c092 NC	364	arelent * cache_ptr,
	365	Elf_Internal_Rela * dst)
	366	{
	367	unsigned int r_type;
	368
	369	r_type = ELF32_R_TYPE (dst->r_info);
5860e3f8 NC	370	if (r_type >= (unsigned int) R_EPIPHANY_max)
5860e3f8 NC	371	{
695344c0	372	/* xgettext:c-format */
0aa13fee AM	373	_bfd_error_handler (_("%pB: unsupported relocation type %#x"),
0aa13fee AM	374	abfd, r_type);
f3185997	375	bfd_set_error (bfd_error_bad_value);
0a1b45a2	376	return false;
5860e3f8	377	}
cfb8c092	378	cache_ptr->howto = & epiphany_elf_howto_table [r_type];
0a1b45a2	379	return true;
cfb8c092 NC	380	}
	381
	382	/* Perform a single relocation.
	383	By default we use the standard BFD routines. */
	384
	385	static bfd_reloc_status_type
	386	epiphany_final_link_relocate (reloc_howto_type * howto,
07d6d2b8 AM	387	bfd * input_bfd,
	388	asection * input_section,
	389	bfd_byte * contents,
cfb8c092	390	Elf_Internal_Rela * rel,
07d6d2b8	391	bfd_vma relocation)
cfb8c092 NC	392	{
	393	switch (howto->type)
	394	{
	395	/* Handle 16 bit immediates. */
	396	case R_EPIPHANY_HIGH:
	397	relocation += rel->r_addend;
	398	relocation >>= 16;
	399	goto common;
	400
	401	case R_EPIPHANY_LOW:
	402	relocation += rel->r_addend;
	403	common:
	404	relocation = ((relocation & 0xff00L) << 12)
	405	\| ((relocation & 0x00ffL) << 5);
	406	/* Sanity check the address. */
	407	if (rel->r_offset > bfd_get_section_limit (input_bfd, input_section))
	408	return bfd_reloc_outofrange;
	409
	410	return _bfd_relocate_contents (howto, input_bfd, relocation,
	411	contents + rel->r_offset);
	412
	413	case R_EPIPHANY_SIMM11:
	414	relocation += rel->r_addend;
	415	/* Check signed overflow. */
	416	if ((int)relocation > 1023 \|\| (int)relocation < -1024)
	417	return bfd_reloc_outofrange;
	418	goto disp11;
	419
	420	case R_EPIPHANY_IMM11:
	421	relocation += rel->r_addend;
	422	if ((unsigned int) relocation > 0x7ff)
	423	return bfd_reloc_outofrange;
616ec358	424	/* Fall through. */
cfb8c092	425	disp11:
616ec358 AM	426	relocation = (((relocation & 7) << 5)
616ec358 AM	427	\| ((relocation & 0x7f8 ) << 13));
cfb8c092 NC	428	return _bfd_relocate_contents (howto, input_bfd, relocation,
	429	contents + rel->r_offset);
	430
	431	/* Pass others through. */
	432	default:
	433	break;
	434	}
	435
	436	/* Only install relocation if above tests did not disqualify it. */
	437	return _bfd_final_link_relocate (howto, input_bfd, input_section,
	438	contents, rel->r_offset,
	439	relocation, rel->r_addend);
	440	}
	441
	442	/* Relocate an EPIPHANY ELF section.
	443
	444	The RELOCATE_SECTION function is called by the new ELF backend linker
	445	to handle the relocations for a section.
	446
	447	The relocs are always passed as Rela structures; if the section
	448	actually uses Rel structures, the r_addend field will always be
	449	zero.
	450
	451	This function is responsible for adjusting the section contents as
	452	necessary, and (if using Rela relocs and generating a relocatable
	453	output file) adjusting the reloc addend as necessary.
	454
	455	This function does not have to worry about setting the reloc
	456	address or the reloc symbol index.
	457
	458	LOCAL_SYMS is a pointer to the swapped in local symbols.
	459
	460	LOCAL_SECTIONS is an array giving the section in the input file
	461	corresponding to the st_shndx field of each local symbol.
	462
	463	The global hash table entry for the global symbols can be found
	464	via elf_sym_hashes (input_bfd).
	465
	466	When generating relocatable output, this function must handle
	467	STB_LOCAL/STT_SECTION symbols specially. The output symbol is
	468	going to be the section symbol corresponding to the output
	469	section, which means that the addend must be adjusted
	470	accordingly. */
	471
0f684201	472	static int
cfb8c092 NC	473	epiphany_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
	474	struct bfd_link_info *info,
	475	bfd *input_bfd,
	476	asection *input_section,
	477	bfd_byte *contents,
	478	Elf_Internal_Rela *relocs,
	479	Elf_Internal_Sym *local_syms,
	480	asection **local_sections)
	481	{
	482	Elf_Internal_Shdr *symtab_hdr;
	483	struct elf_link_hash_entry **sym_hashes;
	484	Elf_Internal_Rela *rel;
	485	Elf_Internal_Rela *relend;
	486
	487	symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
	488	sym_hashes = elf_sym_hashes (input_bfd);
	489	relend = relocs + input_section->reloc_count;
	490
	491	for (rel = relocs; rel < relend; rel ++)
	492	{
07d6d2b8 AM	493	reloc_howto_type * howto;
	494	unsigned long r_symndx;
	495	Elf_Internal_Sym * sym;
	496	asection * sec;
cfb8c092	497	struct elf_link_hash_entry * h;
07d6d2b8 AM	498	bfd_vma relocation;
	499	bfd_reloc_status_type r;
	500	const char * name = NULL;
	501	int r_type ATTRIBUTE_UNUSED;
cfb8c092 NC	502
	503	r_type = ELF32_R_TYPE (rel->r_info);
	504	r_symndx = ELF32_R_SYM (rel->r_info);
	505	howto = epiphany_elf_howto_table + ELF32_R_TYPE (rel->r_info);
	506	h = NULL;
	507	sym = NULL;
	508	sec = NULL;
	509
	510	if (r_symndx < symtab_hdr->sh_info)
	511	{
	512	sym = local_syms + r_symndx;
	513	sec = local_sections [r_symndx];
	514	relocation = BASEADDR (sec) + sym->st_value;
	515
	516	name = bfd_elf_string_from_elf_section
	517	(input_bfd, symtab_hdr->sh_link, sym->st_name);
fd361982	518	name = name == NULL ? bfd_section_name (sec) : name;
cfb8c092 NC	519	}
	520	else
	521	{
0a1b45a2 AM	522	bool warned ATTRIBUTE_UNUSED;
	523	bool unresolved_reloc ATTRIBUTE_UNUSED;
	524	bool ignored ATTRIBUTE_UNUSED;
cfb8c092 NC	525
	526	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
	527	r_symndx, symtab_hdr, sym_hashes,
	528	h, sec, relocation,
62d887d4	529	unresolved_reloc, warned, ignored);
cfb8c092 NC	530
	531	name = h->root.root.string;
	532	}
	533
dbaa2011	534	if (sec != NULL && discarded_section (sec))
cfb8c092	535	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b	536	rel, 1, relend, howto, 0, contents);
cfb8c092	537
0e1862bb	538	if (bfd_link_relocatable (info))
cfb8c092 NC	539	continue;
	540
	541	/* Finally, the sole EPIPHANY-specific part. */
	542	r = epiphany_final_link_relocate (howto, input_bfd, input_section,
	543	contents, rel, relocation);
	544
	545	if (r != bfd_reloc_ok)
	546	{
	547	const char * msg = NULL;
	548
	549	switch (r)
	550	{
	551	case bfd_reloc_overflow:
1a72702b	552	(*info->callbacks->reloc_overflow)
cfb8c092 NC	553	(info, (h ? &h->root : NULL), name, howto->name,
	554	(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
	555	break;
	556
	557	case bfd_reloc_undefined:
1a72702b	558	(*info->callbacks->undefined_symbol)
0a1b45a2	559	(info, name, input_bfd, input_section, rel->r_offset, true);
cfb8c092 NC	560	break;
	561
	562	case bfd_reloc_outofrange:
	563	msg = _("internal error: out of range error");
	564	break;
	565
	566	/* This is how epiphany_final_link_relocate tells us of a
	567	non-kosher reference between insn & data address spaces. */
	568	case bfd_reloc_notsupported:
	569	if (sym != NULL) /* Only if it's not an unresolved symbol. */
	570	msg = _("unsupported relocation between data/insn address spaces");
	571	break;
	572
	573	case bfd_reloc_dangerous:
	574	msg = _("internal error: dangerous relocation");
	575	break;
	576
	577	default:
	578	msg = _("internal error: unknown error");
	579	break;
	580	}
	581
	582	if (msg)
1a72702b AM	583	(*info->callbacks->warning) (info, msg, name, input_bfd,
1a72702b AM	584	input_section, rel->r_offset);
cfb8c092 NC	585	}
	586	}
	587
0a1b45a2	588	return true;
cfb8c092 NC	589	}
	590
	591	/* We only have a little-endian target. */
6d00b590	592	#define TARGET_LITTLE_SYM epiphany_elf32_vec
cfb8c092 NC	593	#define TARGET_LITTLE_NAME "elf32-epiphany"
	594
	595	#define ELF_ARCH bfd_arch_epiphany
	596	#define ELF_MACHINE_CODE EM_ADAPTEVA_EPIPHANY
	597
	598	#define ELF_MAXPAGESIZE 0x8000 /* No pages on the EPIPHANY. */
	599
	600	#define elf_info_to_howto_rel NULL
	601	#define elf_info_to_howto epiphany_info_to_howto_rela
	602
07d6d2b8	603	#define elf_backend_can_gc_sections 1
cfb8c092 NC	604	#define elf_backend_rela_normal 1
	605	#define elf_backend_relocate_section epiphany_elf_relocate_section
	606
	607	#define elf_symbol_leading_char '_'
	608	#define bfd_elf32_bfd_reloc_type_lookup epiphany_reloc_type_lookup
	609	#define bfd_elf32_bfd_reloc_name_lookup epiphany_reloc_name_lookup
	610	#define bfd_elf32_bfd_relax_section epiphany_elf_relax_section
	611
	612	#include "elf32-target.h"