URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf32-d10v.c] - Blame information for rev 866

Go to most recent revision | Details | Compare with Previous | View Log


/* D10V-specific support for 32-bit ELF
   Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   2007 Free Software Foundation, Inc.
   Contributed by Martin Hunt (hunt@cygnus.com).
 
   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/d10v.h"
 
/* Use REL instead of RELA to save space.  */
#define USE_REL 1
 
static reloc_howto_type elf_d10v_howto_table[] =
{
  /* This reloc does nothing.  */
  HOWTO (R_D10V_NONE,           /* Type.  */
         0,                      /* Rightshift.  */
         2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
         32,                    /* Bitsize.  */
         FALSE,                 /* PC_relative.  */
         0,                      /* Bitpos.  */
         complain_overflow_dont,/* Complain_on_overflow.  */
         bfd_elf_generic_reloc, /* Special_function.  */
         "R_D10V_NONE",         /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0,                      /* Src_mask.  */
         0,                      /* Dst_mask.  */
         FALSE),                /* PCrel_offset.  */
 
  /* An PC Relative 10-bit relocation, shifted by 2, right container.  */
  HOWTO (R_D10V_10_PCREL_R,     /* Type.  */
         2,                     /* Rightshift.  */
         2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
         8,                     /* Bitsize.  */
         TRUE,                  /* PC_relative.  */
         0,                      /* Bitpos.  */
         complain_overflow_signed, /* Complain_on_overflow.  */
         bfd_elf_generic_reloc, /* Special_function.  */
         "R_D10V_10_PCREL_R",   /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0xff,                  /* Src_mask.  */
         0xff,                  /* Dst_mask.  */
         TRUE),                 /* PCrel_offset.  */
 
  /* An PC Relative 10-bit relocation, shifted by 2, left container.  */
  HOWTO (R_D10V_10_PCREL_L,     /* Type.  */
         2,                     /* Rightshift.  */
         2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
         8,                     /* Bitsize.  */
         TRUE,                  /* PC_relative.  */
         15,                    /* Bitpos.  */
         complain_overflow_signed, /* Complain_on_overflow.  */
         bfd_elf_generic_reloc, /* Special_function.  */
         "R_D10V_10_PCREL_L",   /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0x07f8000,             /* Src_mask.  */
         0x07f8000,             /* Dst_mask.  */
         TRUE),                 /* PCrel_offset.  */
 
  /* A 16 bit absolute relocation.  */
  HOWTO (R_D10V_16,             /* 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_D10V_16",           /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0xffff,                /* Src_mask.  */
         0xffff,                /* Dst_mask.  */
         FALSE),                /* PCrel_offset.  */
 
  /* An 18 bit absolute relocation, right shifted 2.  */
  HOWTO (R_D10V_18,             /* Type.  */
         2,                     /* 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_D10V_18",           /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0xffff,                /* Src_mask.  */
         0xffff,                /* Dst_mask.  */
         FALSE),                /* PCrel_offset.  */
 
  /* A relative 18 bit relocation, right shifted by 2.  */
  HOWTO (R_D10V_18_PCREL,       /* Type.  */
         2,                     /* Rightshift.  */
         2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
         16,                    /* Bitsize.  */
         TRUE,                  /* PC_relative.  */
         0,                      /* Bitpos.  */
         complain_overflow_signed, /* Complain_on_overflow.  */
         bfd_elf_generic_reloc, /* Special_function.  */
         "R_D10V_18_PCREL",     /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0xffff,                /* Src_mask.  */
         0xffff,                /* Dst_mask.  */
         TRUE),                 /* PCrel_offset.  */
 
  /* A 32 bit absolute relocation.  */
  HOWTO (R_D10V_32,             /* Type.  */
         0,                      /* Rightshift.  */
         2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
         32,                    /* Bitsize.  */
         FALSE,                 /* PC_relative.  */
         0,                      /* Bitpos.  */
         complain_overflow_dont,/* Complain_on_overflow.  */
         bfd_elf_generic_reloc, /* Special_function.  */
         "R_D10V_32",           /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0xffffffff,            /* Src_mask.  */
         0xffffffff,            /* Dst_mask.  */
         FALSE),                /* PCrel_offset.  */
 
  /* GNU extension to record C++ vtable hierarchy.  */
  HOWTO (R_D10V_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_D10V_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_D10V_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_D10V_GNU_VTENTRY",  /* Name.  */
         FALSE,                 /* Partial_inplace.  */
         0,                     /* Src_mask.  */
         0,                     /* Dst_mask.  */
         FALSE),                /* PCrel_offset.  */
};
 
/* Map BFD reloc types to D10V ELF reloc types.  */
 
struct d10v_reloc_map
{
  bfd_reloc_code_real_type bfd_reloc_val;
  unsigned char elf_reloc_val;
};
 
static const struct d10v_reloc_map d10v_reloc_map[] =
{
  { BFD_RELOC_NONE, R_D10V_NONE, },
  { BFD_RELOC_D10V_10_PCREL_R, R_D10V_10_PCREL_R },
  { BFD_RELOC_D10V_10_PCREL_L, R_D10V_10_PCREL_L },
  { BFD_RELOC_16, R_D10V_16 },
  { BFD_RELOC_D10V_18, R_D10V_18 },
  { BFD_RELOC_D10V_18_PCREL, R_D10V_18_PCREL },
  { BFD_RELOC_32, R_D10V_32 },
  { BFD_RELOC_VTABLE_INHERIT, R_D10V_GNU_VTINHERIT },
  { BFD_RELOC_VTABLE_ENTRY, R_D10V_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 = 0;
       i < sizeof (d10v_reloc_map) / sizeof (struct d10v_reloc_map);
       i++)
    if (d10v_reloc_map[i].bfd_reloc_val == code)
      return &elf_d10v_howto_table[d10v_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_d10v_howto_table) / sizeof (elf_d10v_howto_table[0]);
       i++)
    if (elf_d10v_howto_table[i].name != NULL
        && strcasecmp (elf_d10v_howto_table[i].name, r_name) == 0)
      return &elf_d10v_howto_table[i];
 
  return NULL;
}
 
/* Set the howto pointer for an D10V ELF reloc.  */
 
static void
d10v_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_D10V_max);
  cache_ptr->howto = &elf_d10v_howto_table[r_type];
}
 
static asection *
elf32_d10v_gc_mark_hook (asection *sec,
                         struct bfd_link_info *info,
                         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_D10V_GNU_VTINHERIT:
      case R_D10V_GNU_VTENTRY:
        return NULL;
      }
 
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}
 
/* 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
elf32_d10v_check_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;
  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);
 
  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];
          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;
        }
 
      switch (ELF32_R_TYPE (rel->r_info))
        {
        /* This relocation describes the C++ object vtable hierarchy.
           Reconstruct it for later use during GC.  */
        case R_D10V_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_D10V_GNU_VTENTRY:
          BFD_ASSERT (h != NULL);
          if (h != NULL
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
            return FALSE;
          break;
        }
    }
 
  return TRUE;
}
 
static bfd_vma
extract_rel_addend (bfd *abfd,
                    bfd_byte *where,
                    reloc_howto_type *howto)
{
  bfd_vma insn, val;
 
  switch (howto->size)
    {
    case 0:
      insn = bfd_get_8 (abfd, where);
      break;
    case 1:
      insn = bfd_get_16 (abfd, where);
      break;
    case 2:
      insn = bfd_get_32 (abfd, where);
      break;
    default:
      abort ();
    }
 
  val = (insn & howto->dst_mask) >> howto->bitpos << howto->rightshift;
  /* We should really be testing for signed addends here, but we don't
     have that info directly in the howto.  */
  if (howto->pc_relative)
    {
      bfd_vma sign;
      sign = howto->dst_mask & (~howto->dst_mask >> 1 | ~(-(bfd_vma) 1 >> 1));
      sign = sign >> howto->bitpos << howto->rightshift;
      val = (val ^ sign) - sign;
    }
  return val;
}
 
static void
insert_rel_addend (bfd *abfd,
                   bfd_byte *where,
                   reloc_howto_type *howto,
                   bfd_vma addend)
{
  bfd_vma insn;
 
  addend = (addend >> howto->rightshift << howto->bitpos) & howto->dst_mask;
  insn = ~howto->dst_mask;
  switch (howto->size)
    {
    case 0:
      insn &= bfd_get_8 (abfd, where);
      insn |= addend;
      bfd_put_8 (abfd, insn, where);
      break;
    case 1:
      insn &= bfd_get_16 (abfd, where);
      insn |= addend;
      bfd_put_16 (abfd, insn, where);
      break;
    case 2:
      insn &= bfd_get_32 (abfd, where);
      insn |= addend;
      bfd_put_32 (abfd, insn, where);
      break;
    default:
      abort ();
    }
}
 
/* Relocate a D10V ELF section.  */
 
static bfd_boolean
elf32_d10v_relocate_section (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, *relend;
  const char *name;
 
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (input_bfd);
 
  rel = relocs;
  relend = relocs + input_section->reloc_count;
  for (; rel < relend; rel++)
    {
      int r_type;
      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;
 
      r_symndx = ELF32_R_SYM (rel->r_info);
      r_type = ELF32_R_TYPE (rel->r_info);
 
      if (r_type == R_D10V_GNU_VTENTRY
          || r_type == R_D10V_GNU_VTINHERIT)
        continue;
 
      howto = elf_d10v_howto_table + r_type;
      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);
          if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
              && ((sec->flags & SEC_MERGE) != 0
                  || (info->relocatable
                      && sec->output_offset != 0)))
            {
              bfd_vma addend;
              bfd_byte *where = contents + rel->r_offset;
 
              addend = extract_rel_addend (input_bfd, where, howto);
 
              if (info->relocatable)
                addend += sec->output_offset;
              else
                {
                  asection *msec = sec;
                  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
                                                   addend);
                  addend -= relocation;
                  addend += msec->output_section->vma + msec->output_offset;
                }
              insert_rel_addend (input_bfd, where, howto, addend);
            }
        }
      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);
        }
 
      if (sec != NULL && elf_discarded_section (sec))
        {
          /* For relocs against symbols from removed linkonce sections,
             or sections discarded by a linker script, we just want the
             section contents zeroed.  Avoid any special processing.  */
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
          rel->r_info = 0;
          rel->r_addend = 0;
          continue;
        }
 
      if (info->relocatable)
        continue;
 
      if (h != NULL)
        name = h->root.root.string;
      else
        {
          name = (bfd_elf_string_from_elf_section
                  (input_bfd, symtab_hdr->sh_link, sym->st_name));
          if (name == NULL || *name == '\0')
            name = bfd_section_name (input_bfd, sec);
        }
 
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
                                    contents, rel->r_offset,
                                    relocation, (bfd_vma) 0);
 
      if (r != bfd_reloc_ok)
        {
          const char * msg = (const char *) 0;
 
          switch (r)
            {
            case bfd_reloc_overflow:
              if (!((*info->callbacks->reloc_overflow)
                    (info, (h ? &h->root : NULL), name, howto->name,
                     (bfd_vma) 0, input_bfd, input_section,
                     rel->r_offset)))
                return FALSE;
              break;
 
            case bfd_reloc_undefined:
              if (!((*info->callbacks->undefined_symbol)
                    (info, name, input_bfd, input_section,
                     rel->r_offset, TRUE)))
                return FALSE;
              break;
 
            case bfd_reloc_outofrange:
              msg = _("internal error: out of range error");
              goto common_error;
 
            case bfd_reloc_notsupported:
              msg = _("internal error: unsupported relocation error");
              goto common_error;
 
            case bfd_reloc_dangerous:
              msg = _("internal error: dangerous error");
              goto common_error;
 
            default:
              msg = _("internal error: unknown error");
              /* fall through */
 
            common_error:
              if (!((*info->callbacks->warning)
                    (info, msg, name, input_bfd, input_section,
                     rel->r_offset)))
                return FALSE;
              break;
            }
        }
    }
 
  return TRUE;
}
#define ELF_ARCH                bfd_arch_d10v
#define ELF_MACHINE_CODE        EM_D10V
#define ELF_MACHINE_ALT1        EM_CYGNUS_D10V
#define ELF_MAXPAGESIZE         0x1000
 
#define TARGET_BIG_SYM          bfd_elf32_d10v_vec
#define TARGET_BIG_NAME         "elf32-d10v"
 
#define elf_info_to_howto                    0
#define elf_info_to_howto_rel                d10v_info_to_howto_rel
#define elf_backend_object_p                 0
#define elf_backend_final_write_processing   0
#define elf_backend_gc_mark_hook             elf32_d10v_gc_mark_hook
#define elf_backend_check_relocs             elf32_d10v_check_relocs
#define elf_backend_relocate_section         elf32_d10v_relocate_section
#define elf_backend_can_gc_sections          1
 
#include "elf32-target.h"

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elf32-d10v.c] - Blame information for rev 866

Line No.	Rev	Author	Line
1	227	jeremybenn	`/* D10V-specific support for 32-bit ELF`
2			`Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,`
3			`2007 Free Software Foundation, Inc.`
4			`Contributed by Martin Hunt (hunt@cygnus.com).`
5
6			`This file is part of BFD, the Binary File Descriptor library.`
7
8			`This program is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 3 of the License, or`
11			`(at your option) any later version.`
12
13			`This program is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with this program; if not, write to the Free Software`
20			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
21			`MA 02110-1301, USA. */`
22
23			`#include "sysdep.h"`
24			`#include "bfd.h"`
25			`#include "libbfd.h"`
26			`#include "elf-bfd.h"`
27			`#include "elf/d10v.h"`
28
29			`/* Use REL instead of RELA to save space. */`
30			`#define USE_REL 1`
31
32			`static reloc_howto_type elf_d10v_howto_table[] =`
33			`{`
34			`/* This reloc does nothing. */`
35			`HOWTO (R_D10V_NONE, /* Type. */`
36			`0, /* Rightshift. */`
37			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
38			`32, /* Bitsize. */`
39			`FALSE, /* PC_relative. */`
40			`0, /* Bitpos. */`
41			`complain_overflow_dont,/* Complain_on_overflow. */`
42			`bfd_elf_generic_reloc, /* Special_function. */`
43			`"R_D10V_NONE", /* Name. */`
44			`FALSE, /* Partial_inplace. */`
45			`0, /* Src_mask. */`
46			`0, /* Dst_mask. */`
47			`FALSE), /* PCrel_offset. */`
48
49			`/* An PC Relative 10-bit relocation, shifted by 2, right container. */`
50			`HOWTO (R_D10V_10_PCREL_R, /* Type. */`
51			`2, /* Rightshift. */`
52			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
53			`8, /* Bitsize. */`
54			`TRUE, /* PC_relative. */`
55			`0, /* Bitpos. */`
56			`complain_overflow_signed, /* Complain_on_overflow. */`
57			`bfd_elf_generic_reloc, /* Special_function. */`
58			`"R_D10V_10_PCREL_R", /* Name. */`
59			`FALSE, /* Partial_inplace. */`
60			`0xff, /* Src_mask. */`
61			`0xff, /* Dst_mask. */`
62			`TRUE), /* PCrel_offset. */`
63
64			`/* An PC Relative 10-bit relocation, shifted by 2, left container. */`
65			`HOWTO (R_D10V_10_PCREL_L, /* Type. */`
66			`2, /* Rightshift. */`
67			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
68			`8, /* Bitsize. */`
69			`TRUE, /* PC_relative. */`
70			`15, /* Bitpos. */`
71			`complain_overflow_signed, /* Complain_on_overflow. */`
72			`bfd_elf_generic_reloc, /* Special_function. */`
73			`"R_D10V_10_PCREL_L", /* Name. */`
74			`FALSE, /* Partial_inplace. */`
75			`0x07f8000, /* Src_mask. */`
76			`0x07f8000, /* Dst_mask. */`
77			`TRUE), /* PCrel_offset. */`
78
79			`/* A 16 bit absolute relocation. */`
80			`HOWTO (R_D10V_16, /* Type. */`
81			`0, /* Rightshift. */`
82			`1, /* Size (0 = byte, 1 = short, 2 = long). */`
83			`16, /* Bitsize. */`
84			`FALSE, /* PC_relative. */`
85			`0, /* Bitpos. */`
86			`complain_overflow_dont,/* Complain_on_overflow. */`
87			`bfd_elf_generic_reloc, /* Special_function. */`
88			`"R_D10V_16", /* Name. */`
89			`FALSE, /* Partial_inplace. */`
90			`0xffff, /* Src_mask. */`
91			`0xffff, /* Dst_mask. */`
92			`FALSE), /* PCrel_offset. */`
93
94			`/* An 18 bit absolute relocation, right shifted 2. */`
95			`HOWTO (R_D10V_18, /* Type. */`
96			`2, /* Rightshift. */`
97			`1, /* Size (0 = byte, 1 = short, 2 = long). */`
98			`16, /* Bitsize. */`
99			`FALSE, /* PC_relative. */`
100			`0, /* Bitpos. */`
101			`complain_overflow_dont, /* Complain_on_overflow. */`
102			`bfd_elf_generic_reloc, /* Special_function. */`
103			`"R_D10V_18", /* Name. */`
104			`FALSE, /* Partial_inplace. */`
105			`0xffff, /* Src_mask. */`
106			`0xffff, /* Dst_mask. */`
107			`FALSE), /* PCrel_offset. */`
108
109			`/* A relative 18 bit relocation, right shifted by 2. */`
110			`HOWTO (R_D10V_18_PCREL, /* Type. */`
111			`2, /* Rightshift. */`
112			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
113			`16, /* Bitsize. */`
114			`TRUE, /* PC_relative. */`
115			`0, /* Bitpos. */`
116			`complain_overflow_signed, /* Complain_on_overflow. */`
117			`bfd_elf_generic_reloc, /* Special_function. */`
118			`"R_D10V_18_PCREL", /* Name. */`
119			`FALSE, /* Partial_inplace. */`
120			`0xffff, /* Src_mask. */`
121			`0xffff, /* Dst_mask. */`
122			`TRUE), /* PCrel_offset. */`
123
124			`/* A 32 bit absolute relocation. */`
125			`HOWTO (R_D10V_32, /* Type. */`
126			`0, /* Rightshift. */`
127			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
128			`32, /* Bitsize. */`
129			`FALSE, /* PC_relative. */`
130			`0, /* Bitpos. */`
131			`complain_overflow_dont,/* Complain_on_overflow. */`
132			`bfd_elf_generic_reloc, /* Special_function. */`
133			`"R_D10V_32", /* Name. */`
134			`FALSE, /* Partial_inplace. */`
135			`0xffffffff, /* Src_mask. */`
136			`0xffffffff, /* Dst_mask. */`
137			`FALSE), /* PCrel_offset. */`
138
139			`/* GNU extension to record C++ vtable hierarchy. */`
140			`HOWTO (R_D10V_GNU_VTINHERIT, /* Type. */`
141			`0, /* Rightshift. */`
142			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
143			`0, /* Bitsize. */`
144			`FALSE, /* PC_relative. */`
145			`0, /* Bitpos. */`
146			`complain_overflow_dont,/* Complain_on_overflow. */`
147			`NULL, /* Special_function. */`
148			`"R_D10V_GNU_VTINHERIT",/* Name. */`
149			`FALSE, /* Partial_inplace. */`
150			`0, /* Src_mask. */`
151			`0, /* Dst_mask. */`
152			`FALSE), /* PCrel_offset. */`
153
154			`/* GNU extension to record C++ vtable member usage. */`
155			`HOWTO (R_D10V_GNU_VTENTRY, /* Type. */`
156			`0, /* Rightshift. */`
157			`2, /* Size (0 = byte, 1 = short, 2 = long). */`
158			`0, /* Bitsize. */`
159			`FALSE, /* PC_relative. */`
160			`0, /* Bitpos. */`
161			`complain_overflow_dont,/* Complain_on_overflow. */`
162			`_bfd_elf_rel_vtable_reloc_fn, /* Special_function. */`
163			`"R_D10V_GNU_VTENTRY", /* Name. */`
164			`FALSE, /* Partial_inplace. */`
165			`0, /* Src_mask. */`
166			`0, /* Dst_mask. */`
167			`FALSE), /* PCrel_offset. */`
168			`};`
169
170			`/* Map BFD reloc types to D10V ELF reloc types. */`
171
172			`struct d10v_reloc_map`
173			`{`
174			`bfd_reloc_code_real_type bfd_reloc_val;`
175			`unsigned char elf_reloc_val;`
176			`};`
177
178			`static const struct d10v_reloc_map d10v_reloc_map[] =`
179			`{`
180			`{ BFD_RELOC_NONE, R_D10V_NONE, },`
181			`{ BFD_RELOC_D10V_10_PCREL_R, R_D10V_10_PCREL_R },`
182			`{ BFD_RELOC_D10V_10_PCREL_L, R_D10V_10_PCREL_L },`
183			`{ BFD_RELOC_16, R_D10V_16 },`
184			`{ BFD_RELOC_D10V_18, R_D10V_18 },`
185			`{ BFD_RELOC_D10V_18_PCREL, R_D10V_18_PCREL },`
186			`{ BFD_RELOC_32, R_D10V_32 },`
187			`{ BFD_RELOC_VTABLE_INHERIT, R_D10V_GNU_VTINHERIT },`
188			`{ BFD_RELOC_VTABLE_ENTRY, R_D10V_GNU_VTENTRY },`
189			`};`
190
191			`static reloc_howto_type *`
192			`bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,`
193			`bfd_reloc_code_real_type code)`
194			`{`
195			`unsigned int i;`
196
197			`for (i = 0;`
198			`i < sizeof (d10v_reloc_map) / sizeof (struct d10v_reloc_map);`
199			`i++)`
200			`if (d10v_reloc_map[i].bfd_reloc_val == code)`
201			`return &elf_d10v_howto_table[d10v_reloc_map[i].elf_reloc_val];`
202
203			`return NULL;`
204			`}`
205
206			`static reloc_howto_type *`
207			`bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,`
208			`const char *r_name)`
209			`{`
210			`unsigned int i;`
211
212			`for (i = 0;`
213			`i < sizeof (elf_d10v_howto_table) / sizeof (elf_d10v_howto_table[0]);`
214			`i++)`
215			`if (elf_d10v_howto_table[i].name != NULL`
216			`&& strcasecmp (elf_d10v_howto_table[i].name, r_name) == 0)`
217			`return &elf_d10v_howto_table[i];`
218
219			`return NULL;`
220			`}`
221
222			`/* Set the howto pointer for an D10V ELF reloc. */`
223
224			`static void`
225			`d10v_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,`
226			`arelent *cache_ptr,`
227			`Elf_Internal_Rela *dst)`
228			`{`
229			`unsigned int r_type;`
230
231			`r_type = ELF32_R_TYPE (dst->r_info);`
232			`BFD_ASSERT (r_type < (unsigned int) R_D10V_max);`
233			`cache_ptr->howto = &elf_d10v_howto_table[r_type];`
234			`}`
235
236			`static asection *`
237			`elf32_d10v_gc_mark_hook (asection *sec,`
238			`struct bfd_link_info *info,`
239			`Elf_Internal_Rela *rel,`
240			`struct elf_link_hash_entry *h,`
241			`Elf_Internal_Sym *sym)`
242			`{`
243			`if (h != NULL)`
244			`switch (ELF32_R_TYPE (rel->r_info))`
245			`{`
246			`case R_D10V_GNU_VTINHERIT:`
247			`case R_D10V_GNU_VTENTRY:`
248			`return NULL;`
249			`}`
250
251			`return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);`
252			`}`
253
254			`/* Look through the relocs for a section during the first phase.`
255			`Since we don't do .gots or .plts, we just need to consider the`
256			`virtual table relocs for gc. */`
257
258			`static bfd_boolean`
259			`elf32_d10v_check_relocs (bfd *abfd,`
260			`struct bfd_link_info *info,`
261			`asection *sec,`
262			`const Elf_Internal_Rela *relocs)`
263			`{`
264			`Elf_Internal_Shdr *symtab_hdr;`
265			`struct elf_link_hash_entry **sym_hashes;`
266			`const Elf_Internal_Rela *rel;`
267			`const Elf_Internal_Rela *rel_end;`
268
269			`if (info->relocatable)`
270			`return TRUE;`
271
272			`symtab_hdr = &elf_tdata (abfd)->symtab_hdr;`
273			`sym_hashes = elf_sym_hashes (abfd);`
274
275			`rel_end = relocs + sec->reloc_count;`
276			`for (rel = relocs; rel < rel_end; rel++)`
277			`{`
278			`struct elf_link_hash_entry *h;`
279			`unsigned long r_symndx;`
280
281			`r_symndx = ELF32_R_SYM (rel->r_info);`
282			`if (r_symndx < symtab_hdr->sh_info)`
283			`h = NULL;`
284			`else`
285			`{`
286			`h = sym_hashes[r_symndx - symtab_hdr->sh_info];`
287			`while (h->root.type == bfd_link_hash_indirect`
288			`\|\| h->root.type == bfd_link_hash_warning)`
289			`h = (struct elf_link_hash_entry *) h->root.u.i.link;`
290			`}`
291
292			`switch (ELF32_R_TYPE (rel->r_info))`
293			`{`
294			`/* This relocation describes the C++ object vtable hierarchy.`
295			`Reconstruct it for later use during GC. */`
296			`case R_D10V_GNU_VTINHERIT:`
297			`if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))`
298			`return FALSE;`
299			`break;`
300
301			`/* This relocation describes which C++ vtable entries are actually`
302			`used. Record for later use during GC. */`
303			`case R_D10V_GNU_VTENTRY:`
304			`BFD_ASSERT (h != NULL);`
305			`if (h != NULL`
306			`&& !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))`
307			`return FALSE;`
308			`break;`
309			`}`
310			`}`
311
312			`return TRUE;`
313			`}`
314
315			`static bfd_vma`
316			`extract_rel_addend (bfd *abfd,`
317			`bfd_byte *where,`
318			`reloc_howto_type *howto)`
319			`{`
320			`bfd_vma insn, val;`
321
322			`switch (howto->size)`
323			`{`
324			`case 0:`
325			`insn = bfd_get_8 (abfd, where);`
326			`break;`
327			`case 1:`
328			`insn = bfd_get_16 (abfd, where);`
329			`break;`
330			`case 2:`
331			`insn = bfd_get_32 (abfd, where);`
332			`break;`
333			`default:`
334			`abort ();`
335			`}`
336
337			`val = (insn & howto->dst_mask) >> howto->bitpos << howto->rightshift;`
338			`/* We should really be testing for signed addends here, but we don't`
339			`have that info directly in the howto. */`
340			`if (howto->pc_relative)`
341			`{`
342			`bfd_vma sign;`
343			`sign = howto->dst_mask & (~howto->dst_mask >> 1 \| ~(-(bfd_vma) 1 >> 1));`
344			`sign = sign >> howto->bitpos << howto->rightshift;`
345			`val = (val ^ sign) - sign;`
346			`}`
347			`return val;`
348			`}`
349
350			`static void`
351			`insert_rel_addend (bfd *abfd,`
352			`bfd_byte *where,`
353			`reloc_howto_type *howto,`
354			`bfd_vma addend)`
355			`{`
356			`bfd_vma insn;`
357
358			`addend = (addend >> howto->rightshift << howto->bitpos) & howto->dst_mask;`
359			`insn = ~howto->dst_mask;`
360			`switch (howto->size)`
361			`{`
362			`case 0:`
363			`insn &= bfd_get_8 (abfd, where);`
364			`insn \|= addend;`
365			`bfd_put_8 (abfd, insn, where);`
366			`break;`
367			`case 1:`
368			`insn &= bfd_get_16 (abfd, where);`
369			`insn \|= addend;`
370			`bfd_put_16 (abfd, insn, where);`
371			`break;`
372			`case 2:`
373			`insn &= bfd_get_32 (abfd, where);`
374			`insn \|= addend;`
375			`bfd_put_32 (abfd, insn, where);`
376			`break;`
377			`default:`
378			`abort ();`
379			`}`
380			`}`
381
382			`/* Relocate a D10V ELF section. */`
383
384			`static bfd_boolean`
385			`elf32_d10v_relocate_section (bfd *output_bfd,`
386			`struct bfd_link_info *info,`
387			`bfd *input_bfd,`
388			`asection *input_section,`
389			`bfd_byte *contents,`
390			`Elf_Internal_Rela *relocs,`
391			`Elf_Internal_Sym *local_syms,`
392			`asection **local_sections)`
393			`{`
394			`Elf_Internal_Shdr *symtab_hdr;`
395			`struct elf_link_hash_entry **sym_hashes;`
396			`Elf_Internal_Rela rel, relend;`
397			`const char *name;`
398
399			`symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;`
400			`sym_hashes = elf_sym_hashes (input_bfd);`
401
402			`rel = relocs;`
403			`relend = relocs + input_section->reloc_count;`
404			`for (; rel < relend; rel++)`
405			`{`
406			`int r_type;`
407			`reloc_howto_type *howto;`
408			`unsigned long r_symndx;`
409			`Elf_Internal_Sym *sym;`
410			`asection *sec;`
411			`struct elf_link_hash_entry *h;`
412			`bfd_vma relocation;`
413			`bfd_reloc_status_type r;`
414
415			`r_symndx = ELF32_R_SYM (rel->r_info);`
416			`r_type = ELF32_R_TYPE (rel->r_info);`
417
418			`if (r_type == R_D10V_GNU_VTENTRY`
419			`\|\| r_type == R_D10V_GNU_VTINHERIT)`
420			`continue;`
421
422			`howto = elf_d10v_howto_table + r_type;`
423			`h = NULL;`
424			`sym = NULL;`
425			`sec = NULL;`
426			`if (r_symndx < symtab_hdr->sh_info)`
427			`{`
428			`sym = local_syms + r_symndx;`
429			`sec = local_sections[r_symndx];`
430			`relocation = (sec->output_section->vma`
431			`+ sec->output_offset`
432			`+ sym->st_value);`
433			`if (ELF_ST_TYPE (sym->st_info) == STT_SECTION`
434			`&& ((sec->flags & SEC_MERGE) != 0`
435			`\|\| (info->relocatable`
436			`&& sec->output_offset != 0)))`
437			`{`
438			`bfd_vma addend;`
439			`bfd_byte *where = contents + rel->r_offset;`
440
441			`addend = extract_rel_addend (input_bfd, where, howto);`
442
443			`if (info->relocatable)`
444			`addend += sec->output_offset;`
445			`else`
446			`{`
447			`asection *msec = sec;`
448			`addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,`
449			`addend);`
450			`addend -= relocation;`
451			`addend += msec->output_section->vma + msec->output_offset;`
452			`}`
453			`insert_rel_addend (input_bfd, where, howto, addend);`
454			`}`
455			`}`
456			`else`
457			`{`
458			`bfd_boolean unresolved_reloc, warned;`
459
460			`RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,`
461			`r_symndx, symtab_hdr, sym_hashes,`
462			`h, sec, relocation,`
463			`unresolved_reloc, warned);`
464			`}`
465
466			`if (sec != NULL && elf_discarded_section (sec))`
467			`{`
468			`/* For relocs against symbols from removed linkonce sections,`
469			`or sections discarded by a linker script, we just want the`
470			`section contents zeroed. Avoid any special processing. */`
471			`_bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);`
472			`rel->r_info = 0;`
473			`rel->r_addend = 0;`
474			`continue;`
475			`}`
476
477			`if (info->relocatable)`
478			`continue;`
479
480			`if (h != NULL)`
481			`name = h->root.root.string;`
482			`else`
483			`{`
484			`name = (bfd_elf_string_from_elf_section`
485			`(input_bfd, symtab_hdr->sh_link, sym->st_name));`
486			`if (name == NULL \|\| *name == '\0')`
487			`name = bfd_section_name (input_bfd, sec);`
488			`}`
489
490			`r = _bfd_final_link_relocate (howto, input_bfd, input_section,`
491			`contents, rel->r_offset,`
492			`relocation, (bfd_vma) 0);`
493
494			`if (r != bfd_reloc_ok)`
495			`{`
496			`const char * msg = (const char *) 0;`
497
498			`switch (r)`
499			`{`
500			`case bfd_reloc_overflow:`
501			`if (!((*info->callbacks->reloc_overflow)`
502			`(info, (h ? &h->root : NULL), name, howto->name,`
503			`(bfd_vma) 0, input_bfd, input_section,`
504			`rel->r_offset)))`
505			`return FALSE;`
506			`break;`
507
508			`case bfd_reloc_undefined:`
509			`if (!((*info->callbacks->undefined_symbol)`
510			`(info, name, input_bfd, input_section,`
511			`rel->r_offset, TRUE)))`
512			`return FALSE;`
513			`break;`
514
515			`case bfd_reloc_outofrange:`
516			`msg = _("internal error: out of range error");`
517			`goto common_error;`
518
519			`case bfd_reloc_notsupported:`
520			`msg = _("internal error: unsupported relocation error");`
521			`goto common_error;`
522
523			`case bfd_reloc_dangerous:`
524			`msg = _("internal error: dangerous error");`
525			`goto common_error;`
526
527			`default:`
528			`msg = _("internal error: unknown error");`
529			`/* fall through */`
530
531			`common_error:`
532			`if (!((*info->callbacks->warning)`
533			`(info, msg, name, input_bfd, input_section,`
534			`rel->r_offset)))`
535			`return FALSE;`
536			`break;`
537			`}`
538			`}`
539			`}`
540
541			`return TRUE;`
542			`}`
543			`#define ELF_ARCH bfd_arch_d10v`
544			`#define ELF_MACHINE_CODE EM_D10V`
545			`#define ELF_MACHINE_ALT1 EM_CYGNUS_D10V`
546			`#define ELF_MAXPAGESIZE 0x1000`
547
548			`#define TARGET_BIG_SYM bfd_elf32_d10v_vec`
549			`#define TARGET_BIG_NAME "elf32-d10v"`
550
551			`#define elf_info_to_howto 0`
552			`#define elf_info_to_howto_rel d10v_info_to_howto_rel`
553			`#define elf_backend_object_p 0`
554			`#define elf_backend_final_write_processing 0`
555			`#define elf_backend_gc_mark_hook elf32_d10v_gc_mark_hook`
556			`#define elf_backend_check_relocs elf32_d10v_check_relocs`
557			`#define elf_backend_relocate_section elf32_d10v_relocate_section`
558			`#define elf_backend_can_gc_sections 1`
559
560			`#include "elf32-target.h"`