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

/* OpenRISC-specific support for 32-bit ELF.
   Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   Contributed by Johan Rydberg, jrydberg@opencores.org

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

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

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

/* Forward declarations.  */

static reloc_howto_type *openrisc_reloc_type_lookup
  PARAMS ((bfd * , bfd_reloc_code_real_type));
static void openrisc_info_to_howto_rela
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
static bfd_boolean openrisc_elf_relocate_section
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
static bfd_reloc_status_type openrisc_final_link_relocate
  PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
           Elf_Internal_Rela *, bfd_vma));
static bfd_boolean openrisc_elf_gc_sweep_hook
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
           const Elf_Internal_Rela *));
static asection * openrisc_elf_gc_mark_hook
  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
	   struct elf_link_hash_entry *, Elf_Internal_Sym *));
static bfd_boolean openrisc_elf_check_relocs
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
	   const Elf_Internal_Rela *));
static bfd_boolean openrisc_elf_object_p
  PARAMS ((bfd *));
static void openrisc_elf_final_write_processing
  PARAMS ((bfd *, bfd_boolean));


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

  /* A PC relative 26 bit relocation, right shifted by 2.  */
  HOWTO (R_OPENRISC_INSN_REL_26, /* type */
	 2,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 26,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_INSN_REL_26", /* name */
	 FALSE,			/* partial_inplace */
	 0x00000000,		/* src_mask */
	 0x03ffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A absolute 26 bit relocation, right shifted by 2.  */
  HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
	 2,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 26,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_INSN_ABS_26", /* name */
	 FALSE,			/* partial_inplace */
	 0x00000000,		/* src_mask */
	 0x03ffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_LO_16_IN_INSN", /* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
	 16,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont,	/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_OPENRISC_HI_16_IN_INSN",	/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0x0000ffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

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

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

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

  /* GNU extension to record C++ vtable hierarchy */
  HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 0,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 NULL,			/* special_function */
	 "R_OPENRISC_GNU_VTINHERIT", /* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* GNU extension to record C++ vtable member usage */
  HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 0,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont, /* complain_on_overflow */
	 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
	 "R_OPENRISC_GNU_VTENTRY", /* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */
};

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

struct openrisc_reloc_map
  {
    bfd_reloc_code_real_type bfd_reloc_val;
    unsigned int openrisc_reloc_val;
  };

static const struct openrisc_reloc_map openrisc_reloc_map[] =
  {
    { BFD_RELOC_NONE, 		R_OPENRISC_NONE },
    { BFD_RELOC_32, 		R_OPENRISC_32 },
    { BFD_RELOC_16, 		R_OPENRISC_16 },
    { BFD_RELOC_8, 		R_OPENRISC_8 },
    { BFD_RELOC_OPENRISC_REL_26,R_OPENRISC_INSN_REL_26 },
    { BFD_RELOC_OPENRISC_ABS_26,R_OPENRISC_INSN_ABS_26 },
    { BFD_RELOC_HI16, 		R_OPENRISC_HI_16_IN_INSN },
    { BFD_RELOC_LO16, 		R_OPENRISC_LO_16_IN_INSN },
    { BFD_RELOC_VTABLE_INHERIT,	R_OPENRISC_GNU_VTINHERIT },
    { BFD_RELOC_VTABLE_ENTRY, 	R_OPENRISC_GNU_VTENTRY }
  };

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

  for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
    if (openrisc_reloc_map[i].bfd_reloc_val == code)
      return & openrisc_elf_howto_table[openrisc_reloc_map[i].
				       openrisc_reloc_val];

  return NULL;
}

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

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

  r_type = ELF32_R_TYPE (dst->r_info);
  BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
  cache_ptr->howto = & openrisc_elf_howto_table[r_type];
}

/* Perform a single relocation.  By default we use the standard BFD
   routines, but a few relocs, we have to do them ourselves.  */

static bfd_reloc_status_type
openrisc_final_link_relocate (howto, input_bfd, input_section, contents, rel,
			      relocation)
     reloc_howto_type *howto;
     bfd *input_bfd;
     asection *input_section;
     bfd_byte *contents;
     Elf_Internal_Rela *rel;
     bfd_vma relocation;
{
  bfd_reloc_status_type r = bfd_reloc_ok;

  switch (howto->type)
    {
    case R_OPENRISC_LO_16_IN_INSN:
      relocation &= 0xffff;
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
				    contents, rel->r_offset,
				    relocation, rel->r_addend);
      break;

    default:
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
				    contents, rel->r_offset,
				    relocation, rel->r_addend);
    }

  return r;
}

/* Relocate an OpenRISC 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
openrisc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
			       contents, relocs, local_syms, local_sections)
     bfd *output_bfd;
     struct bfd_link_info *info;
     bfd *input_bfd;
     asection *input_section;
     bfd_byte *contents;
     Elf_Internal_Rela *relocs;
     Elf_Internal_Sym *local_syms;
     asection **local_sections;
{
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes;
  Elf_Internal_Rela *rel;
  Elf_Internal_Rela *relend;

  if (info->relocatable)
    return TRUE;

  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;

      r_type = ELF32_R_TYPE (rel->r_info);
      r_symndx = ELF32_R_SYM (rel->r_info);

      if (r_type == R_OPENRISC_GNU_VTINHERIT
	  || r_type == R_OPENRISC_GNU_VTENTRY)
	continue;

      if ((unsigned int) r_type >
	  (sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
	abort ();

      /* This is a final link.  */
      howto = openrisc_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 = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);

	  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 unresolved_reloc, warned;

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

      r = openrisc_final_link_relocate (howto, input_bfd, input_section,
					contents, rel, relocation);

      if (r != bfd_reloc_ok)
	{
	  const char *msg = (const char *) 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;

	    case bfd_reloc_notsupported:
	      msg = _("internal error: unsupported relocation error");
	      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;
}

/* Return the section that should be marked against GC for a given
   relocation.  */

static asection *
openrisc_elf_gc_mark_hook (sec, info, rel, h, sym)
     asection *sec;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     Elf_Internal_Rela *rel;
     struct elf_link_hash_entry *h;
     Elf_Internal_Sym *sym;
{
  if (h != NULL)
    {
      switch (ELF32_R_TYPE (rel->r_info))
	{
	case R_OPENRISC_GNU_VTINHERIT:
	case R_OPENRISC_GNU_VTENTRY:
	  break;

	default:
	  switch (h->root.type)
	    {
	    case bfd_link_hash_defined:
	    case bfd_link_hash_defweak:
	      return h->root.u.def.section;

	    case bfd_link_hash_common:
	      return h->root.u.c.p->section;

	    default:
	      break;
	    }
	}
    }
  else
    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);

  return NULL;
}

/* Update the got entry reference counts for the section being removed.  */

static bfd_boolean
openrisc_elf_gc_sweep_hook (abfd, info, sec, relocs)
     bfd *abfd ATTRIBUTE_UNUSED;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     asection *sec ATTRIBUTE_UNUSED;
     const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
{
  return TRUE;
}

/* Look through the relocs for a section during the first phase.
   Since we don't do .gots or .plts, we just need to consider the
   virtual table relocs for gc.  */

static bfd_boolean
openrisc_elf_check_relocs (abfd, info, sec, relocs)
     bfd *abfd;
     struct bfd_link_info *info;
     asection *sec;
     const Elf_Internal_Rela *relocs;
{
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
  const Elf_Internal_Rela *rel;
  const Elf_Internal_Rela *rel_end;

  if (info->relocatable)
    return TRUE;

  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (abfd);
  sym_hashes_end =
    sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
  if (!elf_bad_symtab (abfd))
    sym_hashes_end -= symtab_hdr->sh_info;

  rel_end = relocs + sec->reloc_count;
  for (rel = relocs; rel < rel_end; rel++)
    {
      struct elf_link_hash_entry *h;
      unsigned long r_symndx;

      r_symndx = ELF32_R_SYM (rel->r_info);
      if (r_symndx < symtab_hdr->sh_info)
	h = NULL;
      else
	h = sym_hashes[r_symndx - symtab_hdr->sh_info];

      switch (ELF32_R_TYPE (rel->r_info))
	{
	  /* This relocation describes the C++ object vtable hierarchy.
	     Reconstruct it for later use during GC.  */
	case R_OPENRISC_GNU_VTINHERIT:
	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
	    return FALSE;
	  break;

	  /* This relocation describes which C++ vtable entries are actually
	     used.  Record for later use during GC.  */
	case R_OPENRISC_GNU_VTENTRY:
	  if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
	    return FALSE;
	  break;
	}
    }

  return TRUE;
}

/* Set the right machine number.  */

static bfd_boolean
openrisc_elf_object_p (abfd)
     bfd *abfd;
{
  switch (elf_elfheader (abfd)->e_flags & 0xf)
    {
    default:
      (void) bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
      break;
    }
  return TRUE;
}

/* Store the machine number in the flags field.  */

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

  switch (bfd_get_mach (abfd))
    {
    default:
      val = 0;
      break;
    }

  elf_elfheader (abfd)->e_flags &= ~0xf;
  elf_elfheader (abfd)->e_flags |= val;
}


#define ELF_ARCH			bfd_arch_openrisc
#define ELF_MACHINE_CODE		EM_OPENRISC
#define ELF_MACHINE_ALT1		EM_OPENRISC_OLD
#define ELF_MAXPAGESIZE			0x1000

#define TARGET_BIG_SYM			bfd_elf32_openrisc_vec
#define TARGET_BIG_NAME			"elf32-openrisc"

#define elf_info_to_howto_rel		NULL
#define elf_info_to_howto		openrisc_info_to_howto_rela
#define elf_backend_relocate_section	openrisc_elf_relocate_section
#define elf_backend_gc_mark_hook	openrisc_elf_gc_mark_hook
#define elf_backend_gc_sweep_hook	openrisc_elf_gc_sweep_hook
#define elf_backend_check_relocs	openrisc_elf_check_relocs

#define elf_backend_can_gc_sections	1
#define elf_backend_rela_normal		1

#define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup

#define elf_backend_object_p                openrisc_elf_object_p
#define elf_backend_final_write_processing  openrisc_elf_final_write_processing

#include "elf32-target.h"
Commit	Line	Data
b3baf5d0	1	/* OpenRISC-specific support for 32-bit ELF.
b2a8e766	2	Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
b3baf5d0 NC	3	Contributed by Johan Rydberg, jrydberg@opencores.org
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "elf-bfd.h"
	25	#include "elf/openrisc.h"
	26	#include "libiberty.h"
	27
	28	/* Forward declarations. */
	29
	30	static reloc_howto_type *openrisc_reloc_type_lookup
	31	PARAMS ((bfd * , bfd_reloc_code_real_type));
	32	static void openrisc_info_to_howto_rela
947216bf	33	PARAMS ((bfd , arelent , Elf_Internal_Rela *));
b34976b6	34	static bfd_boolean openrisc_elf_relocate_section
b3baf5d0 NC	35	PARAMS ((bfd , struct bfd_link_info , bfd , asection , bfd_byte *,
	36	Elf_Internal_Rela , Elf_Internal_Sym , asection **));
	37	static bfd_reloc_status_type openrisc_final_link_relocate
dc810e39	38	PARAMS ((reloc_howto_type , bfd , asection , bfd_byte ,
b3baf5d0	39	Elf_Internal_Rela *, bfd_vma));
b34976b6	40	static bfd_boolean openrisc_elf_gc_sweep_hook
dc810e39	41	PARAMS ((bfd , struct bfd_link_info , asection *,
b3baf5d0	42	const Elf_Internal_Rela *));
917583ad	43	static asection * openrisc_elf_gc_mark_hook
1e2f5b6e	44	PARAMS ((asection , struct bfd_link_info , Elf_Internal_Rela *,
b3baf5d0	45	struct elf_link_hash_entry , Elf_Internal_Sym ));
b34976b6	46	static bfd_boolean openrisc_elf_check_relocs
917583ad NC	47	PARAMS ((bfd , struct bfd_link_info , asection *,
917583ad NC	48	const Elf_Internal_Rela *));
b34976b6	49	static bfd_boolean openrisc_elf_object_p
917583ad NC	50	PARAMS ((bfd *));
917583ad NC	51	static void openrisc_elf_final_write_processing
b34976b6	52	PARAMS ((bfd *, bfd_boolean));
b3baf5d0 NC	53
	54
	55	static reloc_howto_type openrisc_elf_howto_table[] =
	56	{
	57	/* This reloc does nothing. */
	58	HOWTO (R_OPENRISC_NONE, /* type */
	59	0, /* rightshift */
	60	2, /* size (0 = byte, 1 = short, 2 = long) */
	61	32, /* bitsize */
b34976b6	62	FALSE, /* pc_relative */
b3baf5d0 NC	63	0, /* bitpos */
	64	complain_overflow_bitfield, /* complain_on_overflow */
	65	bfd_elf_generic_reloc, /* special_function */
	66	"R_OPENRISC_NONE", /* name */
b34976b6	67	FALSE, /* partial_inplace */
b3baf5d0 NC	68	0, /* src_mask */
b3baf5d0 NC	69	0, /* dst_mask */
b34976b6	70	FALSE), /* pcrel_offset */
b3baf5d0 NC	71
	72	/* A PC relative 26 bit relocation, right shifted by 2. */
	73	HOWTO (R_OPENRISC_INSN_REL_26, /* type */
	74	2, /* rightshift */
	75	2, /* size (0 = byte, 1 = short, 2 = long) */
	76	26, /* bitsize */
b34976b6	77	TRUE, /* pc_relative */
b3baf5d0 NC	78	0, /* bitpos */
	79	complain_overflow_signed, /* complain_on_overflow */
	80	bfd_elf_generic_reloc, /* special_function */
	81	"R_OPENRISC_INSN_REL_26", /* name */
b34976b6	82	FALSE, /* partial_inplace */
b3baf5d0 NC	83	0x00000000, /* src_mask */
b3baf5d0 NC	84	0x03ffffff, /* dst_mask */
b34976b6	85	FALSE), /* pcrel_offset */
b3baf5d0 NC	86
	87	/* A absolute 26 bit relocation, right shifted by 2. */
	88	HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
	89	2, /* rightshift */
	90	2, /* size (0 = byte, 1 = short, 2 = long) */
	91	26, /* bitsize */
b34976b6	92	FALSE, /* pc_relative */
b3baf5d0 NC	93	0, /* bitpos */
	94	complain_overflow_signed, /* complain_on_overflow */
	95	bfd_elf_generic_reloc, /* special_function */
	96	"R_OPENRISC_INSN_ABS_26", /* name */
b34976b6	97	FALSE, /* partial_inplace */
b3baf5d0 NC	98	0x00000000, /* src_mask */
b3baf5d0 NC	99	0x03ffffff, /* dst_mask */
b34976b6	100	FALSE), /* pcrel_offset */
b3baf5d0 NC	101
	102	HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
	103	0, /* rightshift */
c7e40348	104	1, /* size (0 = byte, 1 = short, 2 = long) */
b3baf5d0	105	16, /* bitsize */
b34976b6	106	FALSE, /* pc_relative */
b3baf5d0	107	0, /* bitpos */
c7e40348	108	complain_overflow_dont, /* complain_on_overflow */
b3baf5d0 NC	109	bfd_elf_generic_reloc, /* special_function */
b3baf5d0 NC	110	"R_OPENRISC_LO_16_IN_INSN", /* name */
b34976b6	111	FALSE, /* partial_inplace */
c7e40348	112	0, /* src_mask */
b3baf5d0	113	0x0000ffff, /* dst_mask */
b34976b6	114	FALSE), /* pcrel_offset */
b3baf5d0 NC	115
	116	HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
	117	16, /* rightshift */
c7e40348	118	1, /* size (0 = byte, 1 = short, 2 = long) */
b3baf5d0	119	16, /* bitsize */
b34976b6	120	FALSE, /* pc_relative */
b3baf5d0	121	0, /* bitpos */
c7e40348	122	complain_overflow_dont, /* complain_on_overflow */
b3baf5d0 NC	123	bfd_elf_generic_reloc, /* special_function */
b3baf5d0 NC	124	"R_OPENRISC_HI_16_IN_INSN", /* name */
b34976b6	125	FALSE, /* partial_inplace */
c7e40348	126	0, /* src_mask */
b3baf5d0	127	0x0000ffff, /* dst_mask */
b34976b6	128	FALSE), /* pcrel_offset */
b3baf5d0 NC	129
	130	/* An 8 bit absolute relocation. */
	131	HOWTO (R_OPENRISC_8, /* type */
	132	0, /* rightshift */
	133	0, /* size (0 = byte, 1 = short, 2 = long) */
	134	8, /* bitsize */
b34976b6	135	FALSE, /* pc_relative */
b3baf5d0 NC	136	0, /* bitpos */
	137	complain_overflow_bitfield, /* complain_on_overflow */
	138	bfd_elf_generic_reloc, /* special_function */
	139	"R_OPENRISC_8", /* name */
b34976b6	140	TRUE, /* partial_inplace */
b3baf5d0 NC	141	0x0000, /* src_mask */
b3baf5d0 NC	142	0x00ff, /* dst_mask */
b34976b6	143	FALSE), /* pcrel_offset */
b3baf5d0 NC	144
	145	/* A 16 bit absolute relocation. */
	146	HOWTO (R_OPENRISC_16, /* type */
	147	0, /* rightshift */
	148	1, /* size (0 = byte, 1 = short, 2 = long) */
	149	16, /* bitsize */
b34976b6	150	FALSE, /* pc_relative */
b3baf5d0 NC	151	0, /* bitpos */
	152	complain_overflow_bitfield, /* complain_on_overflow */
	153	bfd_elf_generic_reloc, /* special_function */
	154	"R_OPENRISC_16", /* name */
b34976b6	155	TRUE, /* partial_inplace */
b3baf5d0 NC	156	0x00000000, /* src_mask */
b3baf5d0 NC	157	0x0000ffff, /* dst_mask */
b34976b6	158	FALSE), /* pcrel_offset */
b3baf5d0 NC	159
	160	/* A 32 bit absolute relocation. */
	161	HOWTO (R_OPENRISC_32, /* type */
	162	0, /* rightshift */
	163	2, /* size (0 = byte, 1 = short, 2 = long) */
	164	32, /* bitsize */
b34976b6	165	FALSE, /* pc_relative */
b3baf5d0 NC	166	0, /* bitpos */
	167	complain_overflow_bitfield, /* complain_on_overflow */
	168	bfd_elf_generic_reloc, /* special_function */
	169	"R_OPENRISC_32", /* name */
b34976b6	170	TRUE, /* partial_inplace */
b3baf5d0 NC	171	0x00000000, /* src_mask */
b3baf5d0 NC	172	0xffffffff, /* dst_mask */
b34976b6	173	FALSE), /* pcrel_offset */
b3baf5d0 NC	174
	175	/* GNU extension to record C++ vtable hierarchy */
	176	HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
	177	0, /* rightshift */
	178	2, /* size (0 = byte, 1 = short, 2 = long) */
	179	0, /* bitsize */
b34976b6	180	FALSE, /* pc_relative */
b3baf5d0 NC	181	0, /* bitpos */
	182	complain_overflow_dont, /* complain_on_overflow */
	183	NULL, /* special_function */
	184	"R_OPENRISC_GNU_VTINHERIT", /* name */
b34976b6	185	FALSE, /* partial_inplace */
b3baf5d0 NC	186	0, /* src_mask */
b3baf5d0 NC	187	0, /* dst_mask */
b34976b6	188	FALSE), /* pcrel_offset */
b3baf5d0 NC	189
	190	/* GNU extension to record C++ vtable member usage */
	191	HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
	192	0, /* rightshift */
	193	2, /* size (0 = byte, 1 = short, 2 = long) */
	194	0, /* bitsize */
b34976b6	195	FALSE, /* pc_relative */
b3baf5d0 NC	196	0, /* bitpos */
	197	complain_overflow_dont, /* complain_on_overflow */
	198	_bfd_elf_rel_vtable_reloc_fn, /* special_function */
	199	"R_OPENRISC_GNU_VTENTRY", /* name */
b34976b6	200	FALSE, /* partial_inplace */
b3baf5d0 NC	201	0, /* src_mask */
b3baf5d0 NC	202	0, /* dst_mask */
b34976b6	203	FALSE), /* pcrel_offset */
b3baf5d0 NC	204	};
	205
	206	/* Map BFD reloc types to OpenRISC ELF reloc types. */
	207
	208	struct openrisc_reloc_map
	209	{
	210	bfd_reloc_code_real_type bfd_reloc_val;
	211	unsigned int openrisc_reloc_val;
	212	};
	213
	214	static const struct openrisc_reloc_map openrisc_reloc_map[] =
	215	{
	216	{ BFD_RELOC_NONE, R_OPENRISC_NONE },
	217	{ BFD_RELOC_32, R_OPENRISC_32 },
	218	{ BFD_RELOC_16, R_OPENRISC_16 },
	219	{ BFD_RELOC_8, R_OPENRISC_8 },
	220	{ BFD_RELOC_OPENRISC_REL_26,R_OPENRISC_INSN_REL_26 },
	221	{ BFD_RELOC_OPENRISC_ABS_26,R_OPENRISC_INSN_ABS_26 },
	222	{ BFD_RELOC_HI16, R_OPENRISC_HI_16_IN_INSN },
	223	{ BFD_RELOC_LO16, R_OPENRISC_LO_16_IN_INSN },
	224	{ BFD_RELOC_VTABLE_INHERIT, R_OPENRISC_GNU_VTINHERIT },
	225	{ BFD_RELOC_VTABLE_ENTRY, R_OPENRISC_GNU_VTENTRY }
	226	};
	227
	228	static reloc_howto_type *
	229	openrisc_reloc_type_lookup (abfd, code)
	230	bfd * abfd ATTRIBUTE_UNUSED;
	231	bfd_reloc_code_real_type code;
	232	{
	233	unsigned int i;
	234
	235	for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
	236	if (openrisc_reloc_map[i].bfd_reloc_val == code)
	237	return & openrisc_elf_howto_table[openrisc_reloc_map[i].
	238	openrisc_reloc_val];
	239
	240	return NULL;
	241	}
	242
	243	/* Set the howto pointer for an OpenRISC ELF reloc. */
	244
	245	static void
	246	openrisc_info_to_howto_rela (abfd, cache_ptr, dst)
	247	bfd * abfd ATTRIBUTE_UNUSED;
	248	arelent * cache_ptr;
947216bf	249	Elf_Internal_Rela * dst;
b3baf5d0 NC	250	{
	251	unsigned int r_type;
	252
	253	r_type = ELF32_R_TYPE (dst->r_info);
	254	BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
	255	cache_ptr->howto = & openrisc_elf_howto_table[r_type];
	256	}
	257
	258	/* Perform a single relocation. By default we use the standard BFD
	259	routines, but a few relocs, we have to do them ourselves. */
	260
	261	static bfd_reloc_status_type
	262	openrisc_final_link_relocate (howto, input_bfd, input_section, contents, rel,
	263	relocation)
	264	reloc_howto_type *howto;
	265	bfd *input_bfd;
	266	asection *input_section;
	267	bfd_byte *contents;
	268	Elf_Internal_Rela *rel;
	269	bfd_vma relocation;
	270	{
	271	bfd_reloc_status_type r = bfd_reloc_ok;
	272
	273	switch (howto->type)
	274	{
	275	case R_OPENRISC_LO_16_IN_INSN:
	276	relocation &= 0xffff;
	277	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
	278	contents, rel->r_offset,
	279	relocation, rel->r_addend);
	280	break;
	281
	282	default:
	283	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
	284	contents, rel->r_offset,
	285	relocation, rel->r_addend);
	286	}
	287
	288	return r;
	289	}
	290
	291	/* Relocate an OpenRISC ELF section.
b3baf5d0 NC	292
	293	The RELOCATE_SECTION function is called by the new ELF backend linker
	294	to handle the relocations for a section.
	295
	296	The relocs are always passed as Rela structures; if the section
	297	actually uses Rel structures, the r_addend field will always be
	298	zero.
	299
	300	This function is responsible for adjusting the section contents as
1049f94e	301	necessary, and (if using Rela relocs and generating a relocatable
b3baf5d0 NC	302	output file) adjusting the reloc addend as necessary.
	303
	304	This function does not have to worry about setting the reloc
	305	address or the reloc symbol index.
	306
	307	LOCAL_SYMS is a pointer to the swapped in local symbols.
	308
	309	LOCAL_SECTIONS is an array giving the section in the input file
	310	corresponding to the st_shndx field of each local symbol.
	311
	312	The global hash table entry for the global symbols can be found
	313	via elf_sym_hashes (input_bfd).
	314
1049f94e	315	When generating relocatable output, this function must handle
b3baf5d0 NC	316	STB_LOCAL/STT_SECTION symbols specially. The output symbol is
	317	going to be the section symbol corresponding to the output
	318	section, which means that the addend must be adjusted
	319	accordingly. */
	320
b34976b6	321	static bfd_boolean
b3baf5d0 NC	322	openrisc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
b3baf5d0 NC	323	contents, relocs, local_syms, local_sections)
f8df10f4	324	bfd *output_bfd;
b3baf5d0 NC	325	struct bfd_link_info *info;
	326	bfd *input_bfd;
	327	asection *input_section;
	328	bfd_byte *contents;
	329	Elf_Internal_Rela *relocs;
	330	Elf_Internal_Sym *local_syms;
	331	asection **local_sections;
	332	{
	333	Elf_Internal_Shdr *symtab_hdr;
	334	struct elf_link_hash_entry **sym_hashes;
	335	Elf_Internal_Rela *rel;
	336	Elf_Internal_Rela *relend;
	337
1049f94e	338	if (info->relocatable)
b34976b6	339	return TRUE;
b491616a	340
b3baf5d0 NC	341	symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
	342	sym_hashes = elf_sym_hashes (input_bfd);
	343	relend = relocs + input_section->reloc_count;
	344
	345	for (rel = relocs; rel < relend; rel++)
	346	{
	347	reloc_howto_type *howto;
	348	unsigned long r_symndx;
	349	Elf_Internal_Sym *sym;
	350	asection *sec;
	351	struct elf_link_hash_entry *h;
	352	bfd_vma relocation;
	353	bfd_reloc_status_type r;
	354	const char *name = NULL;
	355	int r_type;
	356
	357	r_type = ELF32_R_TYPE (rel->r_info);
	358	r_symndx = ELF32_R_SYM (rel->r_info);
	359
	360	if (r_type == R_OPENRISC_GNU_VTINHERIT
	361	\|\| r_type == R_OPENRISC_GNU_VTENTRY)
	362	continue;
	363
b3baf5d0 NC	364	if ((unsigned int) r_type >
	365	(sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
	366	abort ();
	367
	368	/* This is a final link. */
	369	howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info);
	370	h = NULL;
	371	sym = NULL;
	372	sec = NULL;
	373
	374	if (r_symndx < symtab_hdr->sh_info)
	375	{
	376	sym = local_syms + r_symndx;
	377	sec = local_sections[r_symndx];
8517fae7	378	relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
b3baf5d0 NC	379
	380	name = bfd_elf_string_from_elf_section
	381	(input_bfd, symtab_hdr->sh_link, sym->st_name);
	382	name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
	383	}
	384	else
	385	{
59c2e50f	386	bfd_boolean unresolved_reloc, warned;
b3baf5d0	387
b2a8e766 AM	388	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
	389	r_symndx, symtab_hdr, sym_hashes,
	390	h, sec, relocation,
	391	unresolved_reloc, warned);
b3baf5d0 NC	392	}
	393
	394	r = openrisc_final_link_relocate (howto, input_bfd, input_section,
	395	contents, rel, relocation);
	396
	397	if (r != bfd_reloc_ok)
	398	{
	399	const char msg = (const char ) NULL;
	400
	401	switch (r)
	402	{
	403	case bfd_reloc_overflow:
	404	r = info->callbacks->reloc_overflow
dfeffb9f L	405	(info, (h ? &h->root : NULL), name, howto->name,
dfeffb9f L	406	(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
b3baf5d0 NC	407	break;
	408
	409	case bfd_reloc_undefined:
	410	r = info->callbacks->undefined_symbol
b34976b6	411	(info, name, input_bfd, input_section, rel->r_offset, TRUE);
b3baf5d0 NC	412	break;
	413
	414	case bfd_reloc_outofrange:
	415	msg = _("internal error: out of range error");
	416	break;
	417
	418	case bfd_reloc_notsupported:
	419	msg = _("internal error: unsupported relocation error");
	420	break;
	421
	422	case bfd_reloc_dangerous:
	423	msg = _("internal error: dangerous relocation");
	424	break;
	425
	426	default:
	427	msg = _("internal error: unknown error");
	428	break;
	429	}
	430
	431	if (msg)
	432	r = info->callbacks->warning
	433	(info, msg, name, input_bfd, input_section, rel->r_offset);
	434
	435	if (!r)
b34976b6	436	return FALSE;
b3baf5d0 NC	437	}
	438	}
	439
b34976b6	440	return TRUE;
b3baf5d0 NC	441	}
	442
	443	/* Return the section that should be marked against GC for a given
	444	relocation. */
	445
	446	static asection *
1e2f5b6e AM	447	openrisc_elf_gc_mark_hook (sec, info, rel, h, sym)
1e2f5b6e AM	448	asection *sec;
b3baf5d0	449	struct bfd_link_info *info ATTRIBUTE_UNUSED;
8d2c33be AM	450	Elf_Internal_Rela *rel;
	451	struct elf_link_hash_entry *h;
	452	Elf_Internal_Sym *sym;
b3baf5d0 NC	453	{
	454	if (h != NULL)
	455	{
	456	switch (ELF32_R_TYPE (rel->r_info))
	457	{
	458	case R_OPENRISC_GNU_VTINHERIT:
	459	case R_OPENRISC_GNU_VTENTRY:
	460	break;
	461
	462	default:
	463	switch (h->root.type)
	464	{
	465	case bfd_link_hash_defined:
	466	case bfd_link_hash_defweak:
	467	return h->root.u.def.section;
	468
	469	case bfd_link_hash_common:
	470	return h->root.u.c.p->section;
	471
	472	default:
	473	break;
	474	}
	475	}
	476	}
	477	else
1e2f5b6e	478	return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
b3baf5d0 NC	479
	480	return NULL;
	481	}
	482
	483	/* Update the got entry reference counts for the section being removed. */
	484
b34976b6	485	static bfd_boolean
b3baf5d0 NC	486	openrisc_elf_gc_sweep_hook (abfd, info, sec, relocs)
	487	bfd *abfd ATTRIBUTE_UNUSED;
	488	struct bfd_link_info *info ATTRIBUTE_UNUSED;
	489	asection *sec ATTRIBUTE_UNUSED;
	490	const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
	491	{
b34976b6	492	return TRUE;
b3baf5d0 NC	493	}
	494
	495	/* Look through the relocs for a section during the first phase.
	496	Since we don't do .gots or .plts, we just need to consider the
	497	virtual table relocs for gc. */
	498
b34976b6	499	static bfd_boolean
b3baf5d0 NC	500	openrisc_elf_check_relocs (abfd, info, sec, relocs)
	501	bfd *abfd;
	502	struct bfd_link_info *info;
	503	asection *sec;
	504	const Elf_Internal_Rela *relocs;
	505	{
	506	Elf_Internal_Shdr *symtab_hdr;
	507	struct elf_link_hash_entry sym_hashes, sym_hashes_end;
	508	const Elf_Internal_Rela *rel;
	509	const Elf_Internal_Rela *rel_end;
	510
1049f94e	511	if (info->relocatable)
b34976b6	512	return TRUE;
b3baf5d0 NC	513
	514	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
	515	sym_hashes = elf_sym_hashes (abfd);
	516	sym_hashes_end =
	517	sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
	518	if (!elf_bad_symtab (abfd))
	519	sym_hashes_end -= symtab_hdr->sh_info;
	520
	521	rel_end = relocs + sec->reloc_count;
	522	for (rel = relocs; rel < rel_end; rel++)
	523	{
	524	struct elf_link_hash_entry *h;
	525	unsigned long r_symndx;
	526
	527	r_symndx = ELF32_R_SYM (rel->r_info);
	528	if (r_symndx < symtab_hdr->sh_info)
	529	h = NULL;
	530	else
	531	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	532
	533	switch (ELF32_R_TYPE (rel->r_info))
	534	{
	535	/* This relocation describes the C++ object vtable hierarchy.
	536	Reconstruct it for later use during GC. */
	537	case R_OPENRISC_GNU_VTINHERIT:
c152c796	538	if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6	539	return FALSE;
b3baf5d0 NC	540	break;
	541
	542	/* This relocation describes which C++ vtable entries are actually
	543	used. Record for later use during GC. */
	544	case R_OPENRISC_GNU_VTENTRY:
c152c796	545	if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6	546	return FALSE;
b3baf5d0 NC	547	break;
	548	}
	549	}
	550
b34976b6	551	return TRUE;
b3baf5d0 NC	552	}
	553
	554	/* Set the right machine number. */
	555
b34976b6	556	static bfd_boolean
b3baf5d0 NC	557	openrisc_elf_object_p (abfd)
	558	bfd *abfd;
	559	{
	560	switch (elf_elfheader (abfd)->e_flags & 0xf)
	561	{
	562	default:
	563	(void) bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
	564	break;
	565	}
b34976b6	566	return TRUE;
b3baf5d0 NC	567	}
	568
	569	/* Store the machine number in the flags field. */
	570
	571	static void
	572	openrisc_elf_final_write_processing (abfd, linker)
	573	bfd *abfd;
b34976b6	574	bfd_boolean linker ATTRIBUTE_UNUSED;
b3baf5d0 NC	575	{
	576	unsigned long val;
	577
	578	switch (bfd_get_mach (abfd))
	579	{
	580	default:
	581	val = 0;
	582	break;
	583	}
	584
	585	elf_elfheader (abfd)->e_flags &= ~0xf;
	586	elf_elfheader (abfd)->e_flags \|= val;
	587	}
	588
	589
	590	#define ELF_ARCH bfd_arch_openrisc
	591	#define ELF_MACHINE_CODE EM_OPENRISC
c11cc227	592	#define ELF_MACHINE_ALT1 EM_OPENRISC_OLD
b3baf5d0 NC	593	#define ELF_MAXPAGESIZE 0x1000
	594
	595	#define TARGET_BIG_SYM bfd_elf32_openrisc_vec
	596	#define TARGET_BIG_NAME "elf32-openrisc"
	597
	598	#define elf_info_to_howto_rel NULL
	599	#define elf_info_to_howto openrisc_info_to_howto_rela
	600	#define elf_backend_relocate_section openrisc_elf_relocate_section
	601	#define elf_backend_gc_mark_hook openrisc_elf_gc_mark_hook
	602	#define elf_backend_gc_sweep_hook openrisc_elf_gc_sweep_hook
	603	#define elf_backend_check_relocs openrisc_elf_check_relocs
	604
	605	#define elf_backend_can_gc_sections 1
b491616a	606	#define elf_backend_rela_normal 1
b3baf5d0 NC	607
	608	#define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
	609
	610	#define elf_backend_object_p openrisc_elf_object_p
	611	#define elf_backend_final_write_processing openrisc_elf_final_write_processing
	612
	613	#include "elf32-target.h"