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

/* FR30-specific support for 32-bit ELF.
   Copyright (C) 1998 Free Software Foundation, 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 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/fr30.h"

/* Forward declarations.  */
static bfd_reloc_status_type fr30_elf_i20_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type fr30_elf_i32_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static reloc_howto_type * fr30_reloc_type_lookup
  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
static void fr30_info_to_howto_rela 
  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
static boolean fr30_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 fr30_final_link_relocate
  PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, bfd_vma));

static reloc_howto_type fr30_elf_howto_table [] =
{
  /* This reloc does nothing.  */
  HOWTO (R_FR30_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_FR30_NONE",		/* name */
	 false,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 false),		/* pcrel_offset */

  /* An 8 bit absolute relocation.  */
  HOWTO (R_FR30_8,		/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 8,			/* bitsize */
	 false,			/* pc_relative */
	 4,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_FR30_8",		/* name */
	 true,			/* partial_inplace */
	 0x0ff0,		/* src_mask */
	 0x0ff0,		/* dst_mask */
	 false),		/* pcrel_offset */

  /* A 20 bit absolute relocation.  */
  HOWTO (R_FR30_20,		/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 20,			/* bitsize */
	 false,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 fr30_elf_i20_reloc,	/* special_function */
	 "R_FR30_20",		/* name */
	 true,			/* partial_inplace */
	 0x00f0ffff,		/* src_mask */
	 0x00f0ffff,		/* dst_mask */
	 false),		/* pcrel_offset */

  /* A 32 bit absolute relocation.  */
  HOWTO (R_FR30_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_FR30_32",		/* name */
	 true,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 false),		/* pcrel_offset */

  /* A 32 bit into 48 bits absolute relocation.  */
  HOWTO (R_FR30_48,		/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 false,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 fr30_elf_i32_reloc,	/* special_function */
	 "R_FR30_32",		/* name */
	 true,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 false),		/* pcrel_offset */

  /* A 6 bit absolute relocation.  */
  HOWTO (R_FR30_6_IN_4,		/* type */
	 2,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 6,			/* bitsize */
	 false,			/* pc_relative */
	 4,			/* bitpos */
	 complain_overflow_unsigned, /* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_FR30_6_IN_4",	/* name */
	 true,			/* partial_inplace */
	 0x00f0,		/* src_mask */
	 0x00f0,		/* dst_mask */
	 false),		/* pcrel_offset */
  
  /* An 8 bit absolute relocation.  */
  HOWTO (R_FR30_8_IN_8,		/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 8,			/* bitsize */
	 false,			/* pc_relative */
	 4,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,/* special_function */
	 "R_FR30_8_IN_8",	/* name */
	 true,			/* partial_inplace */
	 0x0ff0,		/* src_mask */
	 0x0ff0,		/* dst_mask */
	 false),		/* pcrel_offset */
  
  /* A 9 bit absolute relocation.  */
  HOWTO (R_FR30_9_IN_8,		/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 9,			/* bitsize */
	 false,			/* pc_relative */
	 4,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,/* special_function */
	 "R_FR30_9_IN_8",	/* name */
	 true,			/* partial_inplace */
	 0x0ff0,		/* src_mask */
	 0x0ff0,		/* dst_mask */
	 false),		/* pcrel_offset */
  
  /* A 10 bit absolute relocation.  */
  HOWTO (R_FR30_10_IN_8,	/* type */
	 2,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 10,			/* bitsize */
	 false,			/* pc_relative */
	 4,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc,/* special_function */
	 "R_FR30_10_IN_8",	/* name */
	 true,			/* partial_inplace */
	 0x0ff0,		/* src_mask */
	 0x0ff0,		/* dst_mask */
	 false),		/* pcrel_offset */

  /* A PC relative 9 bit relocation, right shifted by 1.  */
  HOWTO (R_FR30_9_PCREL,	/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 9,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc, /* special_function */
	 "R_FR30_9_PCREL",	/* name */
	 false,			/* partial_inplace */
	 0x00ff,		/* src_mask */
	 0x00ff,		/* dst_mask */
	 false),		/* pcrel_offset */

  /* A PC relative 12 bit relocation, right shifted by 1.  */
  HOWTO (R_FR30_12_PCREL,	/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 12,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 bfd_elf_generic_reloc, /* special_function */
	 "R_FR30_12_PCREL",	/* name */
	 false,			/* partial_inplace */
	 0x07ff,		/* src_mask */
	 0x07ff,		/* dst_mask */
	 false),		/* pcrel_offset */
};
\f
/* Utility to actually perform an R_FR30_20 reloc.  */

static bfd_reloc_status_type
fr30_elf_i20_reloc (abfd, reloc_entry, symbol, data,
		    input_section, output_bfd, error_message)
     bfd *      abfd;
     arelent *  reloc_entry;
     asymbol *  symbol;
     PTR        data;
     asection * input_section;
     bfd *      output_bfd;
     char **    error_message;
{
  bfd_vma       relocation;
  unsigned long x;
  
  /* This part is from bfd_elf_generic_reloc.  */
  if (output_bfd != (bfd *) NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (! reloc_entry->howto->partial_inplace
	  || reloc_entry->addend == 0))
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  if (output_bfd != NULL)
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
    return bfd_reloc_ok;

  relocation =
    symbol->value
    + symbol->section->output_section->vma
    + symbol->section->output_offset
    + reloc_entry->addend;

  if (relocation > ((1U << 20) - 1))
    return bfd_reloc_overflow;

  x = bfd_get_32 (abfd, data + reloc_entry->address);
  x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
  bfd_put_32 (abfd, x, data + reloc_entry->address);

  return bfd_reloc_ok;
}

\f
/* Utility to actually perform a R_FR30_48 reloc.  */

static bfd_reloc_status_type
fr30_elf_i32_reloc (abfd, reloc_entry, symbol, data,
		    input_section, output_bfd, error_message)
     bfd *      abfd;
     arelent *  reloc_entry;
     asymbol *  symbol;
     PTR        data;
     asection * input_section;
     bfd *      output_bfd;
     char **    error_message;
{
  bfd_vma       relocation;

  /* This part is from bfd_elf_generic_reloc.  */
  if (output_bfd != (bfd *) NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && (! reloc_entry->howto->partial_inplace
	  || reloc_entry->addend == 0))
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  if (output_bfd != NULL)
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
    return bfd_reloc_ok;

  relocation =
    symbol->value
    + symbol->section->output_section->vma
    + symbol->section->output_offset
    + reloc_entry->addend;

  bfd_put_32 (abfd, relocation, data + reloc_entry->address + 2);

  return bfd_reloc_ok;
}
\f
/* Map BFD reloc types to FR30 ELF reloc types.  */

struct fr30_reloc_map
{
  unsigned int bfd_reloc_val;
  unsigned int fr30_reloc_val;
};

static const struct fr30_reloc_map fr30_reloc_map [] =
{
  { BFD_RELOC_NONE,           R_FR30_NONE },
  { BFD_RELOC_8,              R_FR30_8 },
  { BFD_RELOC_FR30_20,        R_FR30_20 },
  { BFD_RELOC_32,             R_FR30_32 },
  { BFD_RELOC_FR30_48,        R_FR30_48 },
  { BFD_RELOC_FR30_6_IN_4,    R_FR30_6_IN_4 },
  { BFD_RELOC_FR30_8_IN_8,    R_FR30_8_IN_8 },
  { BFD_RELOC_FR30_9_IN_8,    R_FR30_9_IN_8 },
  { BFD_RELOC_FR30_10_IN_8,   R_FR30_10_IN_8 },
  { BFD_RELOC_FR30_9_PCREL,   R_FR30_9_PCREL },
  { BFD_RELOC_FR30_12_PCREL,  R_FR30_12_PCREL },
};

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

  for (i = sizeof (fr30_reloc_map) / sizeof (fr30_reloc_map[0]);
       --i;)
    if (fr30_reloc_map [i].bfd_reloc_val == code)
      return & fr30_elf_howto_table [fr30_reloc_map[i].fr30_reloc_val];
  
  return NULL;
}

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

static void
fr30_info_to_howto_rela (abfd, cache_ptr, dst)
     bfd * abfd;
     arelent * cache_ptr;
     Elf32_Internal_Rela * dst;
{
  unsigned int r_type;

  r_type = ELF32_R_TYPE (dst->r_info);
  BFD_ASSERT (r_type < (unsigned int) R_FR30_max);
  cache_ptr->howto = & fr30_elf_howto_table [r_type];
}
\f
/* 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
fr30_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;
  bfd_vma               x;
  bfd_signed_vma	srel;
  
  switch (howto->type)
    {
    case R_FR30_20:
      contents   += rel->r_offset;
      relocation += rel->r_addend;

      if (relocation > ((1 << 20) - 1))
	return bfd_reloc_overflow;
      
      x = bfd_get_32 (input_bfd, contents);
      x = (x & 0xff0f0000) | (relocation & 0x0000ffff) | ((relocation & 0x000f0000) << 4);
      bfd_put_32 (input_bfd, relocation, contents);
      break;
      
    case R_FR30_48:
      contents   += rel->r_offset + 2;
      relocation += rel->r_addend;
      bfd_put_32 (input_bfd, relocation, contents);
      break;

    case R_FR30_9_PCREL:
      contents   += rel->r_offset + 1;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;
      srel -= rel->r_offset;
      srel -= 2;  /* Branch instructions add 2 to the PC... */
      srel -= (input_section->output_section->vma +
		     input_section->output_offset);
      
      if (srel & 1)
	return bfd_reloc_outofrange;
      if (srel > ((1 << 8) - 1) || (srel < - (1 << 8)))
	return bfd_reloc_overflow;

      bfd_put_8 (input_bfd, srel >> 1, contents);
      break;

    case R_FR30_12_PCREL:
      contents   += rel->r_offset;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;
      srel -= rel->r_offset;
      srel -= 2; /* Branch instructions add 2 to the PC... */
      srel -= (input_section->output_section->vma +
		     input_section->output_offset);
      
      if (srel & 1)
	return bfd_reloc_outofrange;
      if (srel > ((1 << 11) - 1) || (srel < - (1 << 11)))
	  return bfd_reloc_overflow;
      
      x = bfd_get_16 (input_bfd, contents);
      x = (x & 0xf800) | ((srel >> 1) & 0x7ff);
      bfd_put_16 (input_bfd, x, contents);
      break;

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

  return r;
}

\f
/* Relocate an FR30 ELF section.
   There is some attempt to make this function usable for many architectures,
   both USE_REL and USE_RELA ['twould be nice if such a critter existed],
   if only to serve as a learning tool.

   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 relocateable
   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 relocateable 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 boolean
fr30_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;

  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;

      r_symndx = ELF32_R_SYM (rel->r_info);

      if (info->relocateable)
	{
	  /* This is a relocateable link.  We don't have to change
             anything, unless the reloc is against a section symbol,
             in which case we have to adjust according to where the
             section symbol winds up in the output section.  */
	  if (r_symndx < symtab_hdr->sh_info)
	    {
	      sym = local_syms + r_symndx;
	      
	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
		{
		  sec = local_sections [r_symndx];
		  rel->r_addend += sec->output_offset + sym->st_value;
		}
	    }

	  continue;
	}

      /* This is a final link.  */
      howto  = fr30_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 = (sec->output_section->vma
			+ sec->output_offset
			+ sym->st_value);
	  
	  name = bfd_elf_string_from_elf_section
	    (input_bfd, symtab_hdr->sh_link, sym->st_name);
	  name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
#if 0
	  fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
		   sec->name, name, sym->st_name,
		   sec->output_section->vma, sec->output_offset,
		   sym->st_value, rel->r_addend);
#endif
	}
      else
	{
	  h = sym_hashes [r_symndx - symtab_hdr->sh_info];
	  
	  while (h->root.type == bfd_link_hash_indirect
		 || h->root.type == bfd_link_hash_warning)
	    h = (struct elf_link_hash_entry *) h->root.u.i.link;

	  name = h->root.root.string;
	  
	  if (h->root.type == bfd_link_hash_defined
	      || h->root.type == bfd_link_hash_defweak)
	    {
	      sec = h->root.u.def.section;
	      relocation = (h->root.u.def.value
			    + sec->output_section->vma
			    + sec->output_offset);
#if 0
	      fprintf (stderr,
		       "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
		       sec->name, name, h->root.u.def.value,
		       sec->output_section->vma, sec->output_offset, relocation);
#endif
	    }
	  else if (h->root.type == bfd_link_hash_undefweak)
	    {
#if 0
	      fprintf (stderr, "undefined: sec: %s, name: %s\n",
		       sec->name, name);
#endif
	      relocation = 0;
	    }
	  else
	    {
	      if (! ((*info->callbacks->undefined_symbol)
		     (info, h->root.root.string, input_bfd,
		      input_section, rel->r_offset)))
		return false;
#if 0
	      fprintf (stderr, "unknown: name: %s\n", name);
#endif
	      relocation = 0;
	    }
	}
      
      r = fr30_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, 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);
	      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;
}
\f
#define ELF_ARCH		bfd_arch_fr30
#define ELF_MACHINE_CODE	EM_CYGNUS_FR30
#define ELF_MAXPAGESIZE		0x1000

#define TARGET_BIG_SYM          bfd_elf32_fr30_vec
#define TARGET_BIG_NAME		"elf32-fr30"

#define elf_info_to_howto_rel			NULL
#define elf_info_to_howto			fr30_info_to_howto_rela
#define elf_backend_relocate_section		fr30_elf_relocate_section

#define bfd_elf32_bfd_reloc_type_lookup		fr30_reloc_type_lookup
					
#include "elf32-target.h"
Commit	Line	Data
4aeed4f2 NC	1	/* FR30-specific support for 32-bit ELF.
	2	Copyright (C) 1998 Free Software Foundation, Inc.
	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20	#include "bfd.h"
	21	#include "sysdep.h"
	22	#include "libbfd.h"
	23	#include "elf-bfd.h"
	24	#include "elf/fr30.h"
	25
	26	/* Forward declarations. */
	27	static bfd_reloc_status_type fr30_elf_i20_reloc
	28	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
cb4ec686 NC	29	static bfd_reloc_status_type fr30_elf_i32_reloc
cb4ec686 NC	30	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
82ef568c NC	31	static reloc_howto_type * fr30_reloc_type_lookup
	32	PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
	33	static void fr30_info_to_howto_rela
	34	PARAMS ((bfd , arelent , Elf32_Internal_Rela *));
	35	static boolean fr30_elf_relocate_section
	36	PARAMS ((bfd , struct bfd_link_info , bfd , asection , bfd_byte , Elf_Internal_Rela , Elf_Internal_Sym , asection *));
cb4ec686 NC	37	static bfd_reloc_status_type fr30_final_link_relocate
cb4ec686 NC	38	PARAMS ((reloc_howto_type , bfd , asection , bfd_byte , Elf_Internal_Rela *, bfd_vma));
4aeed4f2 NC	39
	40	static reloc_howto_type fr30_elf_howto_table [] =
	41	{
	42	/* This reloc does nothing. */
	43	HOWTO (R_FR30_NONE, /* type */
	44	0, /* rightshift */
	45	2, /* size (0 = byte, 1 = short, 2 = long) */
	46	32, /* bitsize */
	47	false, /* pc_relative */
	48	0, /* bitpos */
	49	complain_overflow_bitfield, /* complain_on_overflow */
	50	bfd_elf_generic_reloc, /* special_function */
	51	"R_FR30_NONE", /* name */
	52	false, /* partial_inplace */
	53	0, /* src_mask */
	54	0, /* dst_mask */
	55	false), /* pcrel_offset */
	56
	57	/* An 8 bit absolute relocation. */
	58	HOWTO (R_FR30_8, /* type */
	59	0, /* rightshift */
	60	1, /* size (0 = byte, 1 = short, 2 = long) */
	61	8, /* bitsize */
	62	false, /* pc_relative */
	63	4, /* bitpos */
	64	complain_overflow_bitfield, /* complain_on_overflow */
	65	bfd_elf_generic_reloc, /* special_function */
	66	"R_FR30_8", /* name */
	67	true, /* partial_inplace */
	68	0x0ff0, /* src_mask */
	69	0x0ff0, /* dst_mask */
	70	false), /* pcrel_offset */
	71
	72	/* A 20 bit absolute relocation. */
	73	HOWTO (R_FR30_20, /* type */
	74	0, /* rightshift */
	75	2, /* size (0 = byte, 1 = short, 2 = long) */
	76	20, /* bitsize */
	77	false, /* pc_relative */
	78	0, /* bitpos */
	79	complain_overflow_bitfield, /* complain_on_overflow */
	80	fr30_elf_i20_reloc, /* special_function */
	81	"R_FR30_20", /* name */
	82	true, /* partial_inplace */
	83	0x00f0ffff, /* src_mask */
	84	0x00f0ffff, /* dst_mask */
	85	false), /* pcrel_offset */
	86
	87	/* A 32 bit absolute relocation. */
	88	HOWTO (R_FR30_32, /* type */
a617cb0b NC	89	0, /* rightshift */
	90	2, /* size (0 = byte, 1 = short, 2 = long) */
	91	32, /* bitsize */
	92	false, /* pc_relative */
	93	0, /* bitpos */
	94	complain_overflow_bitfield, /* complain_on_overflow */
	95	bfd_elf_generic_reloc, /* special_function */
	96	"R_FR30_32", /* name */
	97	true, /* partial_inplace */
	98	0xffffffff, /* src_mask */
	99	0xffffffff, /* dst_mask */
	100	false), /* pcrel_offset */
	101
	102	/* A 32 bit into 48 bits absolute relocation. */
	103	HOWTO (R_FR30_48, /* type */
4aeed4f2 NC	104	0, /* rightshift */
	105	2, /* size (0 = byte, 1 = short, 2 = long) */
	106	32, /* bitsize */
	107	false, /* pc_relative */
	108	0, /* bitpos */
	109	complain_overflow_bitfield, /* complain_on_overflow */
cb4ec686	110	fr30_elf_i32_reloc, /* special_function */
4aeed4f2 NC	111	"R_FR30_32", /* name */
	112	true, /* partial_inplace */
	113	0xffffffff, /* src_mask */
	114	0xffffffff, /* dst_mask */
	115	false), /* pcrel_offset */
	116
	117	/* A 6 bit absolute relocation. */
	118	HOWTO (R_FR30_6_IN_4, /* type */
	119	2, /* rightshift */
	120	1, /* size (0 = byte, 1 = short, 2 = long) */
	121	6, /* bitsize */
	122	false, /* pc_relative */
	123	4, /* bitpos */
	124	complain_overflow_unsigned, /* complain_on_overflow */
	125	bfd_elf_generic_reloc, /* special_function */
	126	"R_FR30_6_IN_4", /* name */
	127	true, /* partial_inplace */
	128	0x00f0, /* src_mask */
	129	0x00f0, /* dst_mask */
	130	false), /* pcrel_offset */
	131
	132	/* An 8 bit absolute relocation. */
	133	HOWTO (R_FR30_8_IN_8, /* type */
	134	0, /* rightshift */
	135	1, /* size (0 = byte, 1 = short, 2 = long) */
	136	8, /* bitsize */
	137	false, /* pc_relative */
	138	4, /* bitpos */
	139	complain_overflow_signed, /* complain_on_overflow */
	140	bfd_elf_generic_reloc,/* special_function */
	141	"R_FR30_8_IN_8", /* name */
	142	true, /* partial_inplace */
	143	0x0ff0, /* src_mask */
	144	0x0ff0, /* dst_mask */
	145	false), /* pcrel_offset */
	146
	147	/* A 9 bit absolute relocation. */
	148	HOWTO (R_FR30_9_IN_8, /* type */
	149	1, /* rightshift */
	150	1, /* size (0 = byte, 1 = short, 2 = long) */
	151	9, /* bitsize */
	152	false, /* pc_relative */
	153	4, /* bitpos */
	154	complain_overflow_signed, /* complain_on_overflow */
	155	bfd_elf_generic_reloc,/* special_function */
	156	"R_FR30_9_IN_8", /* name */
	157	true, /* partial_inplace */
	158	0x0ff0, /* src_mask */
	159	0x0ff0, /* dst_mask */
	160	false), /* pcrel_offset */
	161
	162	/* A 10 bit absolute relocation. */
	163	HOWTO (R_FR30_10_IN_8, /* type */
	164	2, /* rightshift */
	165	1, /* size (0 = byte, 1 = short, 2 = long) */
	166	10, /* bitsize */
	167	false, /* pc_relative */
	168	4, /* bitpos */
	169	complain_overflow_signed, /* complain_on_overflow */
	170	bfd_elf_generic_reloc,/* special_function */
	171	"R_FR30_10_IN_8", /* name */
	172	true, /* partial_inplace */
	173	0x0ff0, /* src_mask */
	174	0x0ff0, /* dst_mask */
175	false), /* pcrel_offset */
176
177	/* A PC relative 9 bit relocation, right shifted by 1. */
178	HOWTO (R_FR30_9_PCREL, /* type */
179	1, /* rightshift */
180	1, /* size (0 = byte, 1 = short, 2 = long) */
181	9, /* bitsize */
182	true, /* pc_relative */
183	0, /* bitpos */
184	complain_overflow_signed, /* complain_on_overflow */
a617cb0b	185	bfd_elf_generic_reloc, /* special_function */
4aeed4f2 NC	186	"R_FR30_9_PCREL", /* name */
	187	false, /* partial_inplace */
	188	0x00ff, /* src_mask */
	189	0x00ff, /* dst_mask */
226c1993	190	false), /* pcrel_offset */
4aeed4f2 NC	191
	192	/* A PC relative 12 bit relocation, right shifted by 1. */
	193	HOWTO (R_FR30_12_PCREL, /* type */
	194	1, /* rightshift */
	195	1, /* size (0 = byte, 1 = short, 2 = long) */
	196	12, /* bitsize */
	197	true, /* pc_relative */
	198	0, /* bitpos */
	199	complain_overflow_signed, /* complain_on_overflow */
a617cb0b	200	bfd_elf_generic_reloc, /* special_function */
4aeed4f2 NC	201	"R_FR30_12_PCREL", /* name */
	202	false, /* partial_inplace */
	203	0x07ff, /* src_mask */
	204	0x07ff, /* dst_mask */
226c1993	205	false), /* pcrel_offset */
4aeed4f2 NC	206	};
	207	\f
	208	/* Utility to actually perform an R_FR30_20 reloc. */
	209
	210	static bfd_reloc_status_type
	211	fr30_elf_i20_reloc (abfd, reloc_entry, symbol, data,
	212	input_section, output_bfd, error_message)
	213	bfd * abfd;
	214	arelent * reloc_entry;
	215	asymbol * symbol;
	216	PTR data;
	217	asection * input_section;
	218	bfd * output_bfd;
	219	char ** error_message;
	220	{
	221	bfd_vma relocation;
	222	unsigned long x;
	223
	224	/* This part is from bfd_elf_generic_reloc. */
	225	if (output_bfd != (bfd *) NULL
	226	&& (symbol->flags & BSF_SECTION_SYM) == 0
	227	&& (! reloc_entry->howto->partial_inplace
	228	\|\| reloc_entry->addend == 0))
	229	{
	230	reloc_entry->address += input_section->output_offset;
	231	return bfd_reloc_ok;
	232	}
	233
	234	if (output_bfd != NULL)
	235	/* FIXME: See bfd_perform_relocation. Is this right? */
cb4ec686	236	return bfd_reloc_ok;
4aeed4f2 NC	237
	238	relocation =
	239	symbol->value
	240	+ symbol->section->output_section->vma
	241	+ symbol->section->output_offset
	242	+ reloc_entry->addend;
	243
	244	if (relocation > ((1U << 20) - 1))
	245	return bfd_reloc_overflow;
	246
	247	x = bfd_get_32 (abfd, data + reloc_entry->address);
	248	x = (x & 0xff0f0000) \| (relocation & 0x0000ffff) \| ((relocation & 0x000f0000) << 4);
	249	bfd_put_32 (abfd, x, data + reloc_entry->address);
	250
	251	return bfd_reloc_ok;
	252	}
	253
cb4ec686	254	\f
37b0c1aa	255	/* Utility to actually perform a R_FR30_48 reloc. */
cb4ec686 NC	256
	257	static bfd_reloc_status_type
	258	fr30_elf_i32_reloc (abfd, reloc_entry, symbol, data,
	259	input_section, output_bfd, error_message)
	260	bfd * abfd;
	261	arelent * reloc_entry;
	262	asymbol * symbol;
	263	PTR data;
	264	asection * input_section;
	265	bfd * output_bfd;
	266	char ** error_message;
	267	{
	268	bfd_vma relocation;
	269
	270	/* This part is from bfd_elf_generic_reloc. */
	271	if (output_bfd != (bfd *) NULL
	272	&& (symbol->flags & BSF_SECTION_SYM) == 0
	273	&& (! reloc_entry->howto->partial_inplace
	274	\|\| reloc_entry->addend == 0))
	275	{
	276	reloc_entry->address += input_section->output_offset;
	277	return bfd_reloc_ok;
	278	}
	279
	280	if (output_bfd != NULL)
	281	/* FIXME: See bfd_perform_relocation. Is this right? */
	282	return bfd_reloc_ok;
	283
	284	relocation =
	285	symbol->value
	286	+ symbol->section->output_section->vma
	287	+ symbol->section->output_offset
	288	+ reloc_entry->addend;
	289
	290	bfd_put_32 (abfd, relocation, data + reloc_entry->address + 2);
	291
	292	return bfd_reloc_ok;
	293	}
4aeed4f2 NC	294	\f
	295	/* Map BFD reloc types to FR30 ELF reloc types. */
	296
	297	struct fr30_reloc_map
	298	{
82ef568c NC	299	unsigned int bfd_reloc_val;
82ef568c NC	300	unsigned int fr30_reloc_val;
4aeed4f2 NC	301	};
	302
	303	static const struct fr30_reloc_map fr30_reloc_map [] =
	304	{
	305	{ BFD_RELOC_NONE, R_FR30_NONE },
	306	{ BFD_RELOC_8, R_FR30_8 },
	307	{ BFD_RELOC_FR30_20, R_FR30_20 },
	308	{ BFD_RELOC_32, R_FR30_32 },
a617cb0b	309	{ BFD_RELOC_FR30_48, R_FR30_48 },
4aeed4f2 NC	310	{ BFD_RELOC_FR30_6_IN_4, R_FR30_6_IN_4 },
	311	{ BFD_RELOC_FR30_8_IN_8, R_FR30_8_IN_8 },
	312	{ BFD_RELOC_FR30_9_IN_8, R_FR30_9_IN_8 },
	313	{ BFD_RELOC_FR30_10_IN_8, R_FR30_10_IN_8 },
	314	{ BFD_RELOC_FR30_9_PCREL, R_FR30_9_PCREL },
	315	{ BFD_RELOC_FR30_12_PCREL, R_FR30_12_PCREL },
	316	};
	317
	318	static reloc_howto_type *
82ef568c	319	fr30_reloc_type_lookup (abfd, code)
4aeed4f2 NC	320	bfd * abfd;
	321	bfd_reloc_code_real_type code;
	322	{
	323	unsigned int i;
	324
	325	for (i = sizeof (fr30_reloc_map) / sizeof (fr30_reloc_map[0]);
	326	--i;)
82ef568c NC	327	if (fr30_reloc_map [i].bfd_reloc_val == code)
	328	return & fr30_elf_howto_table [fr30_reloc_map[i].fr30_reloc_val];
	329
4aeed4f2 NC	330	return NULL;
	331	}
	332
	333	/* Set the howto pointer for an FR30 ELF reloc. */
	334
	335	static void
82ef568c	336	fr30_info_to_howto_rela (abfd, cache_ptr, dst)
4aeed4f2 NC	337	bfd * abfd;
	338	arelent * cache_ptr;
	339	Elf32_Internal_Rela * dst;
	340	{
	341	unsigned int r_type;
	342
	343	r_type = ELF32_R_TYPE (dst->r_info);
	344	BFD_ASSERT (r_type < (unsigned int) R_FR30_max);
	345	cache_ptr->howto = & fr30_elf_howto_table [r_type];
	346	}
cb4ec686 NC	347	\f
	348	/* Perform a single relocation. By default we use the standard BFD
	349	routines, but a few relocs, we have to do them ourselves. */
	350
	351	static bfd_reloc_status_type
	352	fr30_final_link_relocate (howto, input_bfd, input_section, contents, rel, relocation)
	353	reloc_howto_type * howto;
	354	bfd * input_bfd;
	355	asection * input_section;
	356	bfd_byte * contents;
	357	Elf_Internal_Rela * rel;
	358	bfd_vma relocation;
	359	{
	360	bfd_reloc_status_type r = bfd_reloc_ok;
	361	bfd_vma x;
8f34fce5	362	bfd_signed_vma srel;
cb4ec686 NC	363
	364	switch (howto->type)
	365	{
	366	case R_FR30_20:
226c1993	367	contents += rel->r_offset;
cb4ec686	368	relocation += rel->r_addend;
226c1993 NC	369
	370	if (relocation > ((1 << 20) - 1))
	371	return bfd_reloc_overflow;
	372
cb4ec686 NC	373	x = bfd_get_32 (input_bfd, contents);
	374	x = (x & 0xff0f0000) \| (relocation & 0x0000ffff) \| ((relocation & 0x000f0000) << 4);
	375	bfd_put_32 (input_bfd, relocation, contents);
	376	break;
	377
a617cb0b	378	case R_FR30_48:
226c1993	379	contents += rel->r_offset + 2;
cb4ec686 NC	380	relocation += rel->r_addend;
	381	bfd_put_32 (input_bfd, relocation, contents);
	382	break;
226c1993 NC	383
	384	case R_FR30_9_PCREL:
	385	contents += rel->r_offset + 1;
8f34fce5	386	srel = (bfd_signed_vma) relocation;
811c57ff NC	387	srel += rel->r_addend;
	388	srel -= rel->r_offset;
	389	srel -= 2; /* Branch instructions add 2 to the PC... */
8f34fce5	390	srel -= (input_section->output_section->vma +
226c1993 NC	391	input_section->output_offset);
226c1993 NC	392
8f34fce5	393	if (srel & 1)
226c1993	394	return bfd_reloc_outofrange;
8f34fce5	395	if (srel > ((1 << 8) - 1) \|\| (srel < - (1 << 8)))
226c1993	396	return bfd_reloc_overflow;
811c57ff	397
8f34fce5	398	bfd_put_8 (input_bfd, srel >> 1, contents);
226c1993 NC	399	break;
	400
	401	case R_FR30_12_PCREL:
	402	contents += rel->r_offset;
8f34fce5	403	srel = (bfd_signed_vma) relocation;
811c57ff NC	404	srel += rel->r_addend;
	405	srel -= rel->r_offset;
	406	srel -= 2; /* Branch instructions add 2 to the PC... */
8f34fce5	407	srel -= (input_section->output_section->vma +
226c1993	408	input_section->output_offset);
cb4ec686	409
8f34fce5	410	if (srel & 1)
226c1993	411	return bfd_reloc_outofrange;
8f34fce5 NC	412	if (srel > ((1 << 11) - 1) \|\| (srel < - (1 << 11)))
8f34fce5 NC	413	return bfd_reloc_overflow;
226c1993 NC	414
226c1993 NC	415	x = bfd_get_16 (input_bfd, contents);
8f34fce5	416	x = (x & 0xf800) \| ((srel >> 1) & 0x7ff);
226c1993 NC	417	bfd_put_16 (input_bfd, x, contents);
	418	break;
	419
cb4ec686 NC	420	default:
	421	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
	422	contents, rel->r_offset,
	423	relocation, rel->r_addend);
	424	}
	425
	426	return r;
	427	}
	428
4aeed4f2 NC	429	\f
	430	/* Relocate an FR30 ELF section.
	431	There is some attempt to make this function usable for many architectures,
	432	both USE_REL and USE_RELA ['twould be nice if such a critter existed],
	433	if only to serve as a learning tool.
	434
	435	The RELOCATE_SECTION function is called by the new ELF backend linker
	436	to handle the relocations for a section.
	437
	438	The relocs are always passed as Rela structures; if the section
	439	actually uses Rel structures, the r_addend field will always be
	440	zero.
	441
	442	This function is responsible for adjusting the section contents as
	443	necessary, and (if using Rela relocs and generating a relocateable
	444	output file) adjusting the reloc addend as necessary.
	445
	446	This function does not have to worry about setting the reloc
	447	address or the reloc symbol index.
	448
	449	LOCAL_SYMS is a pointer to the swapped in local symbols.
	450
	451	LOCAL_SECTIONS is an array giving the section in the input file
	452	corresponding to the st_shndx field of each local symbol.
	453
	454	The global hash table entry for the global symbols can be found
	455	via elf_sym_hashes (input_bfd).
	456
	457	When generating relocateable output, this function must handle
	458	STB_LOCAL/STT_SECTION symbols specially. The output symbol is
	459	going to be the section symbol corresponding to the output
	460	section, which means that the addend must be adjusted
	461	accordingly. */
	462
	463	static boolean
	464	fr30_elf_relocate_section (output_bfd, info, input_bfd, input_section,
	465	contents, relocs, local_syms, local_sections)
	466	bfd * output_bfd;
	467	struct bfd_link_info * info;
	468	bfd * input_bfd;
	469	asection * input_section;
	470	bfd_byte * contents;
	471	Elf_Internal_Rela * relocs;
	472	Elf_Internal_Sym * local_syms;
	473	asection ** local_sections;
	474	{
	475	Elf_Internal_Shdr * symtab_hdr;
	476	struct elf_link_hash_entry ** sym_hashes;
	477	Elf_Internal_Rela * rel;
	478	Elf_Internal_Rela * relend;
	479
	480	symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
	481	sym_hashes = elf_sym_hashes (input_bfd);
	482	relend = relocs + input_section->reloc_count;
cb4ec686	483
4aeed4f2 NC	484	for (rel = relocs; rel < relend; rel ++)
	485	{
	486	reloc_howto_type * howto;
	487	unsigned long r_symndx;
	488	Elf_Internal_Sym * sym;
	489	asection * sec;
	490	struct elf_link_hash_entry * h;
	491	bfd_vma relocation;
	492	bfd_reloc_status_type r;
cb4ec686	493	const char * name = NULL;
4aeed4f2 NC	494
	495	r_symndx = ELF32_R_SYM (rel->r_info);
	496
	497	if (info->relocateable)
	498	{
	499	/* This is a relocateable link. We don't have to change
	500	anything, unless the reloc is against a section symbol,
	501	in which case we have to adjust according to where the
	502	section symbol winds up in the output section. */
	503	if (r_symndx < symtab_hdr->sh_info)
	504	{
	505	sym = local_syms + r_symndx;
	506
	507	if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
	508	{
	509	sec = local_sections [r_symndx];
	510	rel->r_addend += sec->output_offset + sym->st_value;
	511	}
	512	}
	513
	514	continue;
	515	}
	516
	517	/* This is a final link. */
	518	howto = fr30_elf_howto_table + ELF32_R_TYPE (rel->r_info);
	519	h = NULL;
	520	sym = NULL;
	521	sec = NULL;
	522
	523	if (r_symndx < symtab_hdr->sh_info)
	524	{
	525	sym = local_syms + r_symndx;
	526	sec = local_sections [r_symndx];
	527	relocation = (sec->output_section->vma
	528	+ sec->output_offset
	529	+ sym->st_value);
	530
	531	name = bfd_elf_string_from_elf_section
	532	(input_bfd, symtab_hdr->sh_link, sym->st_name);
	533	name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
8f34fce5	534	#if 0
4aeed4f2 NC	535	fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
	536	sec->name, name, sym->st_name,
	537	sec->output_section->vma, sec->output_offset,
	538	sym->st_value, rel->r_addend);
	539	#endif
	540	}
	541	else
	542	{
	543	h = sym_hashes [r_symndx - symtab_hdr->sh_info];
	544
	545	while (h->root.type == bfd_link_hash_indirect
	546	\|\| h->root.type == bfd_link_hash_warning)
	547	h = (struct elf_link_hash_entry *) h->root.u.i.link;
	548
	549	name = h->root.root.string;
	550
	551	if (h->root.type == bfd_link_hash_defined
	552	\|\| h->root.type == bfd_link_hash_defweak)
	553	{
	554	sec = h->root.u.def.section;
	555	relocation = (h->root.u.def.value
	556	+ sec->output_section->vma
	557	+ sec->output_offset);
8f34fce5	558	#if 0
4aeed4f2 NC	559	fprintf (stderr,
	560	"defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
	561	sec->name, name, h->root.u.def.value,
	562	sec->output_section->vma, sec->output_offset, relocation);
	563	#endif
	564	}
	565	else if (h->root.type == bfd_link_hash_undefweak)
	566	{
8f34fce5	567	#if 0
4aeed4f2 NC	568	fprintf (stderr, "undefined: sec: %s, name: %s\n",
	569	sec->name, name);
	570	#endif
	571	relocation = 0;
	572	}
	573	else
	574	{
	575	if (! ((*info->callbacks->undefined_symbol)
	576	(info, h->root.root.string, input_bfd,
	577	input_section, rel->r_offset)))
	578	return false;
8f34fce5	579	#if 0
4aeed4f2 NC	580	fprintf (stderr, "unknown: name: %s\n", name);
	581	#endif
	582	relocation = 0;
	583	}
	584	}
cb4ec686 NC	585
	586	r = fr30_final_link_relocate (howto, input_bfd, input_section,
	587	contents, rel, relocation);
4aeed4f2 NC	588
	589	if (r != bfd_reloc_ok)
	590	{
cb4ec686	591	const char * msg = (const char *) NULL;
4aeed4f2 NC	592
	593	switch (r)
	594	{
	595	case bfd_reloc_overflow:
cb4ec686 NC	596	r = info->callbacks->reloc_overflow
	597	(info, name, howto->name, (bfd_vma) 0,
	598	input_bfd, input_section, rel->r_offset);
4aeed4f2	599	break;
cb4ec686	600
4aeed4f2	601	case bfd_reloc_undefined:
cb4ec686 NC	602	r = info->callbacks->undefined_symbol
cb4ec686 NC	603	(info, name, input_bfd, input_section, rel->r_offset);
4aeed4f2	604	break;
cb4ec686	605
4aeed4f2 NC	606	case bfd_reloc_outofrange:
4aeed4f2 NC	607	msg = _("internal error: out of range error");
cb4ec686	608	break;
4aeed4f2 NC	609
	610	case bfd_reloc_notsupported:
	611	msg = _("internal error: unsupported relocation error");
cb4ec686	612	break;
4aeed4f2 NC	613
	614	case bfd_reloc_dangerous:
	615	msg = _("internal error: dangerous relocation");
cb4ec686	616	break;
4aeed4f2	617
4aeed4f2 NC	618	default:
4aeed4f2 NC	619	msg = _("internal error: unknown error");
4aeed4f2 NC	620	break;
4aeed4f2 NC	621	}
cb4ec686 NC	622
	623	if (msg)
	624	r = info->callbacks->warning
	625	(info, msg, name, input_bfd, input_section, rel->r_offset);
	626
	627	if (! r)
	628	return false;
4aeed4f2 NC	629	}
	630	}
	631
	632	return true;
	633	}
	634	\f
	635	#define ELF_ARCH bfd_arch_fr30
	636	#define ELF_MACHINE_CODE EM_CYGNUS_FR30
	637	#define ELF_MAXPAGESIZE 0x1000
	638
	639	#define TARGET_BIG_SYM bfd_elf32_fr30_vec
	640	#define TARGET_BIG_NAME "elf32-fr30"
	641
82ef568c NC	642	#define elf_info_to_howto_rel NULL
82ef568c NC	643	#define elf_info_to_howto fr30_info_to_howto_rela
4aeed4f2	644	#define elf_backend_relocate_section fr30_elf_relocate_section
82ef568c NC	645
82ef568c NC	646	#define bfd_elf32_bfd_reloc_type_lookup fr30_reloc_type_lookup
4aeed4f2 NC	647
4aeed4f2 NC	648	#include "elf32-target.h"