Subversion Repositories open8_urisc

/* OR32-specific support for 32-bit ELF

   Copyright 2002, 2004, 2005, 2007 Free Software Foundation, Inc.

   Contributed by Ivan Guzvinec  <ivang@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 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/or32.h"

#include "libiberty.h"

/* Try to minimize the amount of space occupied by relocation tables

   on the ROM (not that the ROM won't be swamped by other ELF overhead).  */

#define USE_REL 1

/* Set the right machine number for an OR32 ELF file.  */

static bfd_boolean

or32_elf_object_p (bfd *abfd)

{

  (void) bfd_default_set_arch_mach (abfd, bfd_arch_or32, 0);

  return TRUE;

}

/* The final processing done just before writing out an OR32 ELF object file.

   This gets the OR32 architecture right based on the machine number.  */

static void

or32_elf_final_write_processing (bfd *abfd,

                                 bfd_boolean linker ATTRIBUTE_UNUSED)

{

  elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;

}

static bfd_reloc_status_type

or32_elf_32_reloc (bfd *abfd,

                   arelent *reloc_entry,

                   asymbol *symbol,

                   void * data,

                   asection *input_section,

                   bfd *output_bfd,

                   char **error_message ATTRIBUTE_UNUSED)

{

  if (output_bfd != NULL)

    {

      unsigned long insn;

      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);

      insn += symbol->section->output_section->vma;

      insn += symbol->section->output_offset;

      insn += symbol->value;

      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;

    }

  return bfd_reloc_continue;

}

static bfd_reloc_status_type

or32_elf_16_reloc (bfd *abfd,

                   arelent *reloc_entry,

                   asymbol *symbol,

                   void * data,

                   asection *input_section,

                   bfd *output_bfd,

                   char **error_message ATTRIBUTE_UNUSED)

{

  if (output_bfd != NULL)

    {

      unsigned short insn;

      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);

      insn += symbol->section->output_section->vma;

      insn += symbol->section->output_offset;

      insn += symbol->value;

      bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;

    }

  return bfd_reloc_continue;

}

static bfd_reloc_status_type

or32_elf_8_reloc (bfd *abfd ATTRIBUTE_UNUSED,

                  arelent *reloc_entry,

                  asymbol *symbol,

                  void * data,

                  asection *input_section,

                  bfd *output_bfd,

                  char **error_message ATTRIBUTE_UNUSED)

{

  if (output_bfd != NULL)

    {

      unsigned char insn;

      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_8 (abfd, (bfd_byte *) data + addr);

      insn += symbol->section->output_section->vma;

      insn += symbol->section->output_offset;

      insn += symbol->value;

      bfd_put_8 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;

    }

  return bfd_reloc_continue;

}

/* Do a R_OR32_CONSTH relocation.  This has to be done in combination

   with a R_OR32_CONST reloc, because there is a carry from the LO16 to

   the HI16.  Here we just save the information we need; we do the

   actual relocation when we see the LO16.  OR32 ELF requires that the

   LO16 immediately follow the HI16.  As a GNU extension, we permit an

   arbitrary number of HI16 relocs to be associated with a single LO16

   reloc.  This extension permits gcc to output the HI and LO relocs

   itself. This code is copied from the elf32-mips.c.  */

struct or32_consth

{

  struct or32_consth *next;

  bfd_byte *addr;

  bfd_vma addend;

};

/* FIXME: This should not be a static variable.  */

static struct or32_consth *or32_consth_list;

static bfd_reloc_status_type

or32_elf_consth_reloc (bfd *abfd ATTRIBUTE_UNUSED,

                       arelent *reloc_entry,

                       asymbol *symbol,

                       void * data,

                       asection *input_section,

                       bfd *output_bfd,

                       char **error_message ATTRIBUTE_UNUSED)

{

  bfd_reloc_status_type ret;

  bfd_vma relocation;

  struct or32_consth *n;

  ret = bfd_reloc_ok;

  if (bfd_is_und_section (symbol->section)

      && output_bfd == NULL)

    ret = bfd_reloc_undefined;

  if (bfd_is_com_section (symbol->section))

    relocation = 0;

  else

    relocation = symbol->value;

  relocation += symbol->section->output_section->vma;

  relocation += symbol->section->output_offset;

  relocation += reloc_entry->addend;

  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))

    return bfd_reloc_outofrange;

  /* Save the information, and let LO16 do the actual relocation.  */

  n = bfd_malloc (sizeof *n);

  if (n == NULL)

    return bfd_reloc_outofrange;

  n->addr = (bfd_byte *) data + reloc_entry->address;

  n->addend = relocation;

  n->next = or32_consth_list;

  or32_consth_list = n;

  if (output_bfd != NULL)

    reloc_entry->address += input_section->output_offset;

  return ret;

}

/* Do a R_OR32_CONST relocation.  This is a straightforward 16 bit

   inplace relocation; this function exists in order to do the

   R_OR32_CONSTH relocation described above.  */

static bfd_reloc_status_type

or32_elf_const_reloc (bfd *abfd,

                      arelent *reloc_entry,

                      asymbol *symbol,

                      void * data,

                      asection *input_section,

                      bfd *output_bfd,

                      char **error_message)

{

  if (or32_consth_list != NULL)

    {

      struct or32_consth *l;

      l = or32_consth_list;

      while (l != NULL)

        {

          unsigned long insn;

          unsigned long val;

          unsigned long vallo;

          struct or32_consth *next;

          /* Do the HI16 relocation.  Note that we actually don't need

             to know anything about the LO16 itself, except where to

             find the low 16 bits of the addend needed by the LO16.  */

          insn = bfd_get_32 (abfd, l->addr);

          vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)

                   & 0xffff);

          val = ((insn & 0xffff) << 16) + vallo;

          val += l->addend;

          insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);

          bfd_put_32 (abfd, insn, l->addr);

          next = l->next;

          free (l);

          l = next;

        }

      or32_consth_list = NULL;

    }

  if (output_bfd != NULL)

    {

      unsigned long insn, tmp;

      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);

      tmp = insn & 0x0000ffff;

      tmp += symbol->section->output_section->vma;

      tmp += symbol->section->output_offset;

      tmp += symbol->value;

      insn = (insn & 0xffff0000) | (tmp & 0x0000ffff);

      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;

    }

  /* Now do the LO16 reloc in the usual way.  */

  return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,

                                input_section, output_bfd, error_message);

}

static bfd_reloc_status_type

or32_elf_jumptarg_reloc (bfd *abfd,

                         arelent *reloc_entry,

                         asymbol *symbol ATTRIBUTE_UNUSED,

                         void * data,

                         asection *input_section,

                         bfd *output_bfd,

                         char **error_message ATTRIBUTE_UNUSED)

{

  if (output_bfd != NULL)

    {

      unsigned long insn, tmp;

      bfd_size_type addr = reloc_entry->address;

      reloc_entry->address += input_section->output_offset;

      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);

      tmp = insn | 0xfc000000;

      tmp -= (input_section->output_offset >> 2);

      insn = (insn & 0xfc000000) | (tmp & 0x03ffffff);

      bfd_put_32 (abfd, insn, (bfd_byte *) data + addr);

      return bfd_reloc_ok;

    }

  return bfd_reloc_continue;

}

static reloc_howto_type elf_or32_howto_table[] =

{

  /* This reloc does nothing.  */

  HOWTO (R_OR32_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_OR32_NONE",         /* name */

         FALSE,                 /* partial_inplace */

         0,                      /* src_mask */

         0,                      /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A standard 32 bit relocation.  */

  HOWTO (R_OR32_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 */

         or32_elf_32_reloc,     /* special_function */

         "R_OR32_32",           /* name */

         FALSE,                 /* partial_inplace */

         0xffffffff,            /* src_mask */

         0xffffffff,            /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A standard 16 bit relocation.  */

  HOWTO (R_OR32_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 */

         or32_elf_16_reloc,     /* special_function */

         "R_OR32_16",           /* name */

         FALSE,                 /* partial_inplace */

         0x0000ffff,            /* src_mask */

         0x0000ffff,            /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A standard 8 bit relocation.  */

  HOWTO (R_OR32_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 */

         or32_elf_8_reloc,      /* special_function */

         "R_OR32_8",            /* name */

         FALSE,                 /* partial_inplace */

         0x000000ff,            /* src_mask */

         0x000000ff,            /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A standard low 16 bit relocation.  */

  HOWTO (R_OR32_CONST,          /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         FALSE,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

         or32_elf_const_reloc,  /* special_function */

         "R_OR32_CONST",        /* name */

         FALSE,                 /* partial_inplace */

         0x0000ffff,            /* src_mask */

         0x0000ffff,            /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A standard high 16 bit relocation.  */

  HOWTO (R_OR32_CONSTH,         /* type */

         16,                    /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         16,                    /* bitsize */

         TRUE,                  /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

         or32_elf_consth_reloc, /* special_function */

         "R_OR32_CONSTH",       /* name */

         FALSE,                 /* partial_inplace */

         0xffff0000,            /* src_mask */

         0x0000ffff,            /* dst_mask */

         FALSE),                /* pcrel_offset */

  /* A standard branch relocation.  */

  HOWTO (R_OR32_JUMPTARG,       /* type */

         2,                     /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         28,                    /* bitsize */

         TRUE,                  /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_signed, /* complain_on_overflow */

         or32_elf_jumptarg_reloc,/* special_function */

         "R_OR32_JUMPTARG",     /* name */

         FALSE,                 /* partial_inplace */

         0,                      /* src_mask */

         0x03ffffff,            /* dst_mask */

         TRUE),                 /* pcrel_offset */

  /* GNU extension to record C++ vtable hierarchy.  */

  HOWTO (R_OR32_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_OR32_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_OR32_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_OR32_GNU_VTENTRY",   /* name */

         FALSE,                 /* partial_inplace */

         0,                     /* src_mask */

         0,                     /* dst_mask */

         FALSE),                /* pcrel_offset */

};

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

struct or32_reloc_map

{

  bfd_reloc_code_real_type  bfd_reloc_val;

  unsigned char             elf_reloc_val;

};

static const struct or32_reloc_map or32_reloc_map[] =

{

  { BFD_RELOC_NONE, R_OR32_NONE },

  { BFD_RELOC_32, R_OR32_32 },

  { BFD_RELOC_16, R_OR32_16 },

  { BFD_RELOC_8, R_OR32_8 },

  { BFD_RELOC_LO16, R_OR32_CONST },

  { BFD_RELOC_HI16, R_OR32_CONSTH },

  { BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },

  { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },

  { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },

};

static reloc_howto_type *

bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,

                                 bfd_reloc_code_real_type code)

{

  unsigned int i;

  for (i = ARRAY_SIZE (or32_reloc_map); i--;)

    if (or32_reloc_map[i].bfd_reloc_val == code)

      return &elf_or32_howto_table[or32_reloc_map[i].elf_reloc_val];

  return NULL;

}

static reloc_howto_type *

bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,

                                 const char *r_name)

{

  unsigned int i;

  for (i = 0;

       i < sizeof (elf_or32_howto_table) / sizeof (elf_or32_howto_table[0]);

       i++)

    if (elf_or32_howto_table[i].name != NULL

        && strcasecmp (elf_or32_howto_table[i].name, r_name) == 0)

      return &elf_or32_howto_table[i];

  return NULL;

}

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

static void

or32_info_to_howto_rel (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_OR32_max);

  cache_ptr->howto = &elf_or32_howto_table[r_type];

}

#define TARGET_LITTLE_SYM       bfd_elf32_or32_little_vec

#define TARGET_LITTLE_NAME      "elf32-littleor32"

#define TARGET_BIG_SYM          bfd_elf32_or32_big_vec

#define TARGET_BIG_NAME         "elf32-or32"

#define ELF_ARCH                bfd_arch_or32

#define ELF_MACHINE_CODE        EM_OR32

#define ELF_MAXPAGESIZE         0x1000

#define elf_info_to_howto       0

#define elf_info_to_howto_rel   or32_info_to_howto_rel

#define elf_backend_object_p    or32_elf_object_p

#define elf_backend_final_write_processing \

                                or32_elf_final_write_processing

#include "elf32-target.h"