OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf32-or32.c] - Diff between revs 157 and 225

Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
/* OR32-specific support for 32-bit ELF
/* OR32-specific support for 32-bit ELF
   Copyright 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
   Copyright 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
   Contributed by Ivan Guzvinec  <ivang@opencores.org>
   Contributed by Ivan Guzvinec  <ivang@opencores.org>
 
   Modified by Gyorgy Jeney <nog@sdf.lonestar.org> and
 
   Balint Cristian <rezso@rdsor.ro>
 
 
   This file is part of BFD, the Binary File Descriptor library.
   This file is part of BFD, the Binary File Descriptor library.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
Line 22... Line 24...
#include "sysdep.h"
#include "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "libbfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf-bfd.h"
#include "elf/or32.h"
#include "elf/or32.h"
 
#include "elf/common.h"
#include "libiberty.h"
#include "libiberty.h"
 
 
/* Try to minimize the amount of space occupied by relocation tables
/* 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).  */
   on the ROM (not that the ROM won't be swamped by other ELF overhead).  */
#define USE_REL 1
#define USE_REL 1
Line 44... Line 47...
 
 
static void
static void
or32_elf_final_write_processing (bfd *abfd,
or32_elf_final_write_processing (bfd *abfd,
                                 bfd_boolean linker ATTRIBUTE_UNUSED)
                                 bfd_boolean linker ATTRIBUTE_UNUSED)
{
{
 
        /* Pad the output file so that the aligned reloc section addresses aren't
 
         * outside the file */
 
        unsigned long zero = 0;
 
  if (bfd_seek (abfd, elf_tdata (abfd)->next_file_pos, SEEK_SET) != 0
 
      || bfd_bwrite (&zero, sizeof(zero), abfd) != sizeof(zero))
 
    (*_bfd_error_handler) (_("%B: failed to ensure that reloc sections aren't outside file"), abfd);
 
 
  elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;
  elf_elfheader (abfd)->e_flags &=~ EF_OR32_MACH;
}
}
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
or32_elf_32_reloc (bfd *abfd,
or32_elf_generic_reloc (bfd *abfd,
                   arelent *reloc_entry,
                   arelent *reloc_entry,
                   asymbol *symbol,
                   asymbol *symbol,
                   void * data,
                   void * data,
                   asection *input_section,
                   asection *input_section,
                   bfd *output_bfd,
                   bfd *output_bfd,
                   char **error_message ATTRIBUTE_UNUSED)
                   char **error_message ATTRIBUTE_UNUSED)
{
{
  if (output_bfd != NULL)
  bfd_signed_vma val;
    {
  bfd_reloc_status_type status;
      unsigned long insn;
  bfd_boolean relocatable;
      bfd_size_type addr = reloc_entry->address;
 
 
  if (bfd_is_und_section (symbol->section) /*RGD fix linker undefined miss*/
 
      && output_bfd == (bfd *) NULL)
 
    return bfd_reloc_undefined;
 
 
      reloc_entry->address += input_section->output_offset;
  relocatable = (output_bfd != NULL);
 
 
      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
      insn += symbol->section->output_section->vma;
    return bfd_reloc_outofrange;
      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
  /* Build up the field adjustment in VAL.  */
or32_elf_16_reloc (bfd *abfd,
  val = 0;
                   arelent *reloc_entry,
  if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
                   asymbol *symbol,
  {
                   void * data,
    /* Either we're calculating the final field value or we have a
                   asection *input_section,
       relocation against a section symbol.  Add in the section's
                   bfd *output_bfd,
       offset or address.  */
                   char **error_message ATTRIBUTE_UNUSED)
    val += symbol->section->output_section->vma;
{
    val += symbol->section->output_offset;
  if (output_bfd != NULL)
  }
 
 
 
  if (!relocatable)
 
  {
 
    /* We're calculating the final field value.  Add in the symbol's value
 
             and, if pc-relative, subtract the address of the field itself.  */
 
    val += symbol->value;
 
    if (reloc_entry->howto->pc_relative)
 
      val -= input_section->output_section->vma;
 
  }
 
 
 
  if (reloc_entry->howto->pc_relative)
 
    val -= input_section->output_offset;
 
  /* VAL is now the final adjustment.  If we're keeping this relocation
 
     in the output file, and if the relocation uses a separate addend,
 
     we just need to add VAL to that addend.  Otherwise we need to add
 
     VAL to the relocation field itself.  */
 
  if (relocatable && !reloc_entry->howto->partial_inplace)
 
    reloc_entry->addend += val;
 
  else
    {
    {
      unsigned short insn;
    /* Add in the separate addend, if any.  */
      bfd_size_type addr = reloc_entry->address;
    val += reloc_entry->addend;
 
    /* Add VAL to the relocation field.  */
      reloc_entry->address += input_section->output_offset;
    status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
 
                                     (bfd_byte *) data
      insn = bfd_get_16 (abfd, (bfd_byte *) data + addr);
                                     + reloc_entry->address);
      insn += symbol->section->output_section->vma;
    if (status != bfd_reloc_ok)
      insn += symbol->section->output_offset;
      return status;
      insn += symbol->value;
 
      bfd_put_16 (abfd, insn, (bfd_byte *) data + addr);
 
 
 
      return bfd_reloc_ok;
 
    }
    }
 
  if (relocatable)
  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;
      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_ok;
    }
    }
 
 
  return bfd_reloc_continue;
 
}
 
 
 
/* Do a R_OR32_CONSTH relocation.  This has to be done in combination
/* 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
   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
   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
   actual relocation when we see the LO16.  OR32 ELF requires that the
   LO16 immediately follow the HI16.  As a GNU extension, we permit an
   LO16 immediately follow the HI16.  As a GNU extension, we permit an
Line 143... Line 136...
   itself. This code is copied from the elf32-mips.c.  */
   itself. This code is copied from the elf32-mips.c.  */
 
 
struct or32_consth
struct or32_consth
{
{
  struct or32_consth *next;
  struct or32_consth *next;
  bfd_byte *addr;
  bfd_byte *data;
  bfd_vma addend;
  asection *input_section;
 
  arelent rel;
};
};
 
 
/* FIXME: This should not be a static variable.  */
/* FIXME: This should not be a static variable.  */
 
 
static struct or32_consth *or32_consth_list;
static struct or32_consth *or32_consth_list;
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
or32_elf_consth_reloc (bfd *abfd ATTRIBUTE_UNUSED,
or32_elf_consth_reloc (bfd *abfd ATTRIBUTE_UNUSED,
                       arelent *reloc_entry,
                       arelent *reloc_entry,
                       asymbol *symbol,
                       asymbol *symbol ATTRIBUTE_UNUSED,
                       void * data,
                       void * data,
                       asection *input_section,
                       asection *input_section,
                       bfd *output_bfd,
                       bfd *output_bfd,
                       char **error_message ATTRIBUTE_UNUSED)
                       char **error_message ATTRIBUTE_UNUSED)
{
{
  bfd_reloc_status_type ret;
 
  bfd_vma relocation;
 
  struct or32_consth *n;
  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))
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
    return bfd_reloc_outofrange;
    return bfd_reloc_outofrange;
 
 
  /* Save the information, and let LO16 do the actual relocation.  */
  /* Save the information, and let LO16 do the actual relocation.  */
  n = bfd_malloc (sizeof *n);
  n = bfd_malloc (sizeof *n);
  if (n == NULL)
  if (n == NULL)
    return bfd_reloc_outofrange;
    return bfd_reloc_outofrange;
  n->addr = (bfd_byte *) data + reloc_entry->address;
 
  n->addend = relocation;
  /* Push this reloc on the list of pending relocations */
  n->next = or32_consth_list;
  n->next = or32_consth_list;
 
  n->data = data;
 
  n->input_section = input_section;
 
  n->rel = *reloc_entry;
  or32_consth_list = n;
  or32_consth_list = n;
 
 
  if (output_bfd != NULL)
  if (output_bfd != NULL)
    reloc_entry->address += input_section->output_offset;
    reloc_entry->address += input_section->output_offset;
 
 
  return ret;
  return bfd_reloc_ok;
}
}
 
 
/* Do a R_OR32_CONST relocation.  This is a straightforward 16 bit
/* Do a R_OR32_CONST relocation.  This is a straightforward 16 bit
   inplace relocation; this function exists in order to do the
   inplace relocation; this function exists in order to do the
   R_OR32_CONSTH relocation described above.  */
   R_OR32_CONSTH relocation described above.  */
Line 210... Line 190...
                      void * data,
                      void * data,
                      asection *input_section,
                      asection *input_section,
                      bfd *output_bfd,
                      bfd *output_bfd,
                      char **error_message)
                      char **error_message)
{
{
  if (or32_consth_list != NULL)
  bfd_vma vallo;
    {
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
      struct or32_consth *l;
    return bfd_reloc_outofrange;
 
  vallo = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address) & 0xffff;
      l = or32_consth_list;
  while (or32_consth_list != NULL)
      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_reloc_status_type ret;
      bfd_size_type addr = reloc_entry->address;
    struct or32_consth *hi;
 
 
      reloc_entry->address += input_section->output_offset;
 
 
 
      insn = bfd_get_32 (abfd, (bfd_byte *) data + addr);
    hi = or32_consth_list;
      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;
    /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
    }
       carry or borrow will induce a change of +1 or -1 in the high part.  */
 
    hi->rel.addend += vallo;
 
 
 
    ret = or32_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
 
                                   hi->input_section, output_bfd,
 
                                   error_message);
 
    if (ret != bfd_reloc_ok)
 
      return ret;
 
 
  /* Now do the LO16 reloc in the usual way.  */
    or32_consth_list = hi->next;
  return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
    free (hi);
                                input_section, output_bfd, error_message);
 
}
}
 
  return or32_elf_generic_reloc (abfd, reloc_entry, symbol, data,
static bfd_reloc_status_type
                                  input_section, output_bfd,
or32_elf_jumptarg_reloc (bfd *abfd,
                                  error_message);
                         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[] =
static reloc_howto_type elf_or32_howto_table[] =
{
{
  /* This reloc does nothing.  */
  /* This reloc does nothing.  */
  HOWTO (R_OR32_NONE,           /* type */
  HOWTO (R_OR32_NONE,           /* type */
Line 318... Line 245...
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_bitfield, /* complain_on_overflow */
         complain_overflow_bitfield, /* complain_on_overflow */
         or32_elf_32_reloc,     /* special_function */
         bfd_elf_generic_reloc,         /* special_function */
         "R_OR32_32",           /* name */
         "R_OR32_32",           /* name */
         FALSE,                 /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* A standard 16 bit relocation.  */
  /* A standard 16 bit relocation.  */
Line 333... Line 260...
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_bitfield, /* complain_on_overflow */
         complain_overflow_bitfield, /* complain_on_overflow */
         or32_elf_16_reloc,     /* special_function */
         bfd_elf_generic_reloc,         /* special_function */
         "R_OR32_16",           /* name */
         "R_OR32_16",           /* name */
         FALSE,                 /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0x0000ffff,            /* src_mask */
         0x0000ffff,            /* src_mask */
         0x0000ffff,            /* dst_mask */
         0x0000ffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* A standard 8 bit relocation.  */
  /* A standard 8 bit relocation.  */
Line 348... Line 275...
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
         8,                     /* bitsize */
         8,                     /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_bitfield, /* complain_on_overflow */
         complain_overflow_bitfield, /* complain_on_overflow */
         or32_elf_8_reloc,      /* special_function */
         bfd_elf_generic_reloc,         /* special_function */
         "R_OR32_8",            /* name */
         "R_OR32_8",            /* name */
         FALSE,                 /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0x000000ff,            /* src_mask */
         0x000000ff,            /* src_mask */
         0x000000ff,            /* dst_mask */
         0x000000ff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* A standard low 16 bit relocation.  */
  /* A standard low 16 bit relocation.  */
Line 365... Line 292...
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         or32_elf_const_reloc,  /* special_function */
         or32_elf_const_reloc,  /* special_function */
         "R_OR32_CONST",        /* name */
         "R_OR32_CONST",        /* name */
         FALSE,                 /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0x0000ffff,            /* src_mask */
         0x0000ffff,            /* src_mask */
         0x0000ffff,            /* dst_mask */
         0x0000ffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* A standard high 16 bit relocation.  */
  /* A standard high 16 bit relocation.  */
  HOWTO (R_OR32_CONSTH,         /* type */
  HOWTO (R_OR32_CONSTH,         /* type */
         16,                    /* rightshift */
         16,                    /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         TRUE,                  /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         or32_elf_consth_reloc, /* special_function */
         or32_elf_consth_reloc, /* special_function */
         "R_OR32_CONSTH",       /* name */
         "R_OR32_CONSTH",       /* name */
         FALSE,                 /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffff0000,            /* src_mask */
         0x0000ffff,            /* src_mask */
         0x0000ffff,            /* dst_mask */
         0x0000ffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* A standard branch relocation.  */
  /* A standard branch relocation.  */
  HOWTO (R_OR32_JUMPTARG,       /* type */
  HOWTO (R_OR32_JUMPTARG,       /* type */
         2,                     /* rightshift */
         2,                     /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         28,                    /* bitsize */
         28,                    /* bitsize */
         TRUE,                  /* pc_relative */
         TRUE,                  /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         or32_elf_jumptarg_reloc,/* special_function */
         or32_elf_generic_reloc,/* special_function */
         "R_OR32_JUMPTARG",     /* name */
         "R_OR32_JUMPTARG",     /* name */
         FALSE,                 /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0,                      /* src_mask */
         0x03ffffff,                    /* src_mask */
         0x03ffffff,            /* dst_mask */
         0x03ffffff,            /* dst_mask */
         TRUE),                 /* pcrel_offset */
         TRUE),                 /* pcrel_offset */
 
 
  /* GNU extension to record C++ vtable hierarchy.  */
  /* GNU extension to record C++ vtable hierarchy.  */
  HOWTO (R_OR32_GNU_VTINHERIT, /* type */
  HOWTO (R_OR32_GNU_VTINHERIT, /* type */
Line 447... Line 374...
  { BFD_RELOC_32, R_OR32_32 },
  { BFD_RELOC_32, R_OR32_32 },
  { BFD_RELOC_16, R_OR32_16 },
  { BFD_RELOC_16, R_OR32_16 },
  { BFD_RELOC_8, R_OR32_8 },
  { BFD_RELOC_8, R_OR32_8 },
  { BFD_RELOC_LO16, R_OR32_CONST },
  { BFD_RELOC_LO16, R_OR32_CONST },
  { BFD_RELOC_HI16, R_OR32_CONSTH },
  { BFD_RELOC_HI16, R_OR32_CONSTH },
  { BFD_RELOC_32_GOT_PCREL, R_OR32_JUMPTARG },
  { BFD_RELOC_28_PCREL_S2, R_OR32_JUMPTARG },
  { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
  { BFD_RELOC_VTABLE_INHERIT, R_OR32_GNU_VTINHERIT },
  { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
  { BFD_RELOC_VTABLE_ENTRY, R_OR32_GNU_VTENTRY },
};
};
 
 
static reloc_howto_type *
static reloc_howto_type *
Line 493... Line 420...
  unsigned int r_type;
  unsigned int r_type;
 
 
  r_type = ELF32_R_TYPE (dst->r_info);
  r_type = ELF32_R_TYPE (dst->r_info);
  BFD_ASSERT (r_type < (unsigned int) R_OR32_max);
  BFD_ASSERT (r_type < (unsigned int) R_OR32_max);
  cache_ptr->howto = &elf_or32_howto_table[r_type];
  cache_ptr->howto = &elf_or32_howto_table[r_type];
 
 
 
  asymbol *s = *(cache_ptr->sym_ptr_ptr);
 
  if (ELF32_R_SYM(dst->r_info) && (s->flags & BSF_SECTION_SYM))
 
    cache_ptr->sym_ptr_ptr = s->section->symbol_ptr_ptr;
}
}
 
 
#define TARGET_LITTLE_SYM       bfd_elf32_or32_little_vec
#define TARGET_LITTLE_SYM       bfd_elf32_or32_little_vec
#define TARGET_LITTLE_NAME      "elf32-littleor32"
#define TARGET_LITTLE_NAME      "elf32-littleor32"
#define TARGET_BIG_SYM          bfd_elf32_or32_big_vec
#define TARGET_BIG_SYM          bfd_elf32_or32_big_vec
#define TARGET_BIG_NAME         "elf32-or32"
#define TARGET_BIG_NAME         "elf32-or32"
#define ELF_ARCH                bfd_arch_or32
#define ELF_ARCH                bfd_arch_or32
#define ELF_MACHINE_CODE        EM_OR32
#define ELF_MACHINE_CODE        EM_OPENRISC
#define ELF_MAXPAGESIZE         0x1000
#define ELF_MACHINE_ALT1        EM_OR32
 
#define ELF_MAXPAGESIZE         0x2000
 
 
#define elf_info_to_howto       0
#define elf_info_to_howto       0
#define elf_info_to_howto_rel   or32_info_to_howto_rel
#define elf_info_to_howto_rel   or32_info_to_howto_rel
#define elf_backend_object_p    or32_elf_object_p
#define elf_backend_object_p    or32_elf_object_p
#define elf_backend_final_write_processing \
#define elf_backend_final_write_processing \

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.