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

/* DLX specific support for 32-bit ELF
   Copyright 2002, 2003, 2004, 2005 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/dlx.h"

int    set_dlx_skip_hi16_flag PARAMS ((int));

static bfd_boolean elf32_dlx_check_relocs
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
	   const Elf_Internal_Rela *));
static void elf32_dlx_info_to_howto
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
static void elf32_dlx_info_to_howto_rel
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
static bfd_reloc_status_type elf32_dlx_relocate16
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static bfd_reloc_status_type elf32_dlx_relocate26
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static reloc_howto_type *elf32_dlx_reloc_type_lookup
  PARAMS ((bfd *, bfd_reloc_code_real_type));
static bfd_reloc_status_type _bfd_dlx_elf_hi16_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static reloc_howto_type * dlx_rtype_to_howto
  PARAMS ((unsigned int));


#define USE_REL 1

#define bfd_elf32_bfd_reloc_type_lookup elf32_dlx_reloc_type_lookup
#define elf_info_to_howto               elf32_dlx_info_to_howto
#define elf_info_to_howto_rel           elf32_dlx_info_to_howto_rel
#define elf_backend_check_relocs        elf32_dlx_check_relocs

static reloc_howto_type dlx_elf_howto_table[]=
  {
    /* No relocation.  */
    HOWTO (R_DLX_NONE,            /* type */
	   0,                     /* rightshift */
	   0,                     /* size (0 = byte, 1 = short, 2 = long) */
	   0,                     /* bitsize */
	   FALSE,                 /* pc_relative */
	   0,                     /* bitpos */
	   complain_overflow_dont,/* complain_on_overflow */
	   bfd_elf_generic_reloc, /* special_function */
	   "R_DLX_NONE",          /* name */
	   FALSE,                 /* partial_inplace */
	   0,                     /* src_mask */
	   0,                     /* dst_mask */
	   FALSE),                /* pcrel_offset */

    /* 8 bit relocation.  */
    HOWTO (R_DLX_RELOC_8,         /* type */
	   0,                     /* rightshift */
	   0,                     /* size (0 = byte, 1 = short, 2 = long) */
	   8,                     /* bitsize */
	   FALSE,                 /* pc_relative */
	   0,                     /* bitpos */
	   complain_overflow_dont,/* complain_on_overflow */
	   bfd_elf_generic_reloc, /* special_function */
	   "R_DLX_RELOC_8",       /* name */
	   TRUE,                  /* partial_inplace */
	   0xff,                  /* src_mask */
	   0xff,                  /* dst_mask */
	   FALSE),                /* pcrel_offset */

    /* 16 bit relocation.  */
    HOWTO (R_DLX_RELOC_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_DLX_RELOC_16",      /* name */
	   TRUE,                  /* partial_inplace */
	   0xffff,                /* src_mask */
	   0xffff,                /* dst_mask */
	   FALSE),                /* pcrel_offset */

    /* 32 bit relocation.  */
    HOWTO (R_DLX_RELOC_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_DLX_RELOC_32",      /* name */
	   TRUE,                  /* partial_inplace */
	   0xffffffff,            /* src_mask */
	   0xffffffff,            /* dst_mask */
	   FALSE),                /* pcrel_offset */

    /* GNU extension to record C++ vtable hierarchy */
    HOWTO (R_DLX_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_DLX_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_DLX_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_DLX_GNU_VTENTRY",	  /* name */
	   FALSE,		  /* partial_inplace */
	   0,			  /* src_mask */
	   0,			  /* dst_mask */
	   FALSE)		  /* pcrel_offset */
  };

/* 16 bit offset for pc-relative branches.  */
static reloc_howto_type elf_dlx_gnu_rel16_s2 =
HOWTO (R_DLX_RELOC_16_PCREL,  /* type */
       0,                     /* rightshift */
       1,                     /* size (0 = byte, 1 = short, 2 = long) */
       16,                    /* bitsize */
       TRUE,                  /* pc_relative */
       0,                     /* bitpos */
       complain_overflow_signed, /* complain_on_overflow */
       elf32_dlx_relocate16,  /* special_function */
       "R_DLX_RELOC_16_PCREL",/* name */
       TRUE,                  /* partial_inplace */
       0xffff,                /* src_mask */
       0xffff,                /* dst_mask */
       TRUE);                 /* pcrel_offset */

/* 26 bit offset for pc-relative branches.  */
static reloc_howto_type elf_dlx_gnu_rel26_s2 =
HOWTO (R_DLX_RELOC_26_PCREL,  /* type */
       0,                     /* rightshift */
       2,                     /* size (0 = byte, 1 = short, 2 = long) */
       26,                    /* bitsize */
       TRUE,                  /* pc_relative */
       0,                     /* bitpos */
       complain_overflow_dont,/* complain_on_overflow */
       elf32_dlx_relocate26,  /* special_function */
       "R_DLX_RELOC_26_PCREL",/* name */
       TRUE,                  /* partial_inplace */
       0xffff,                /* src_mask */
       0xffff,                /* dst_mask */
       TRUE);                 /* pcrel_offset */

/* High 16 bits of symbol value.  */
static reloc_howto_type elf_dlx_reloc_16_hi =
HOWTO (R_DLX_RELOC_16_HI,     /* type */
       16,                    /* rightshift */
       2,                     /* size (0 = byte, 1 = short, 2 = long) */
       32,                    /* bitsize */
       FALSE,                 /* pc_relative */
       0,                     /* bitpos */
       complain_overflow_dont, /* complain_on_overflow */
       _bfd_dlx_elf_hi16_reloc,/* special_function */
       "R_DLX_RELOC_16_HI",   /* name */
       TRUE,                  /* partial_inplace */
       0xFFFF,                /* src_mask */
       0xffff,                /* dst_mask */
       FALSE);                /* pcrel_offset */

  /* Low 16 bits of symbol value.  */
static reloc_howto_type elf_dlx_reloc_16_lo =
HOWTO (R_DLX_RELOC_16_LO,     /* 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_DLX_RELOC_16_LO",   /* name */
       TRUE,                  /* partial_inplace */
       0xffff,                /* src_mask */
       0xffff,                /* dst_mask */
       FALSE);                /* pcrel_offset */


/* The gas default behavior is not to preform the %hi modifier so that the
   GNU assembler can have the lower 16 bits offset placed in the insn, BUT
   we do like the gas to indicate it is %hi reloc type so when we in the link
   loader phase we can have the corrected hi16 vale replace the buggous lo16
   value that was placed there by gas.  */

static int skip_dlx_elf_hi16_reloc = 0;

int
set_dlx_skip_hi16_flag (flag)
     int flag;
{
  skip_dlx_elf_hi16_reloc = flag;
  return flag;
}

static bfd_reloc_status_type
_bfd_dlx_elf_hi16_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_reloc_status_type ret;
  bfd_vma relocation;

  /* If the skip flag is set then we simply do the generic relocating, this
     is more of a hack for dlx gas/gld, so we do not need to do the %hi/%lo
     fixup like mips gld did.   */
  if (skip_dlx_elf_hi16_reloc)
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
                          input_section, output_bfd, error_message);

  /* If we're relocating, and this an external symbol, we don't want
     to change anything.  */
  if (output_bfd != (bfd *) NULL
      && (symbol->flags & BSF_SECTION_SYM) == 0
      && reloc_entry->addend == 0)
    {
      reloc_entry->address += input_section->output_offset;
      return bfd_reloc_ok;
    }

  ret = bfd_reloc_ok;

  if (bfd_is_und_section (symbol->section)
      && output_bfd == (bfd *) NULL)
    ret = bfd_reloc_undefined;

  relocation = (bfd_is_com_section (symbol->section)) ? 0 : symbol->value;
  relocation += symbol->section->output_section->vma;
  relocation += symbol->section->output_offset;
  relocation += reloc_entry->addend;
  relocation += bfd_get_16 (abfd, (bfd_byte *)data + reloc_entry->address);

  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
    return bfd_reloc_outofrange;

  bfd_put_16 (abfd, (short)((relocation >> 16) & 0xFFFF),
              (bfd_byte *)data + reloc_entry->address);

  return ret;
}

/* ELF relocs are against symbols.  If we are producing relocatable
   output, and the reloc is against an external symbol, and nothing
   has given us any additional addend, the resulting reloc will also
   be against the same symbol.  In such a case, we don't want to
   change anything about the way the reloc is handled, since it will
   all be done at final link time.  Rather than put special case code
   into bfd_perform_relocation, all the reloc types use this howto
   function.  It just short circuits the reloc if producing
   relocatable output against an external symbol.  */

static bfd_reloc_status_type
elf32_dlx_relocate16  (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 ATTRIBUTE_UNUSED;
{
  unsigned long insn, vallo, allignment;
  int           val;

  /* HACK: I think this first condition is necessary when producing
     relocatable output.  After the end of HACK, the code is identical
     to bfd_elf_generic_reloc().  I would _guess_ the first change
     belongs there rather than here.  martindo 1998-10-23.  */

  if (skip_dlx_elf_hi16_reloc)
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
                                 input_section, output_bfd, error_message);

  /* Check undefined section and undefined symbols  */
  if (bfd_is_und_section (symbol->section)
      && output_bfd == (bfd *) NULL)
    return bfd_reloc_undefined;

  /* Can not support a long jump to sections other then .text   */
  if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
    {
      fprintf (stderr,
	       "BFD Link Error: branch (PC rel16) to section (%s) not supported\n",
	       symbol->section->output_section->name);
      return bfd_reloc_undefined;
    }

  insn  = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
  allignment = 1 << (input_section->output_section->alignment_power - 1);
  vallo = insn & 0x0000FFFF;

  if (vallo & 0x8000)
    vallo = ~(vallo | 0xFFFF0000) + 1;

  /* vallo points to the vma of next instruction.  */
  vallo += (((unsigned long)(input_section->output_section->vma +
                           input_section->output_offset) +
            allignment) & ~allignment);

  /* val is the displacement (PC relative to next instruction).  */
  val =  (symbol->section->output_offset +
	  symbol->section->output_section->vma +
	  symbol->value) - vallo;

  if (abs ((int) val) > 0x00007FFF)
    return bfd_reloc_outofrange;

  insn  = (insn & 0xFFFF0000) | (val & 0x0000FFFF);

  bfd_put_32 (abfd, insn,
              (bfd_byte *) data + reloc_entry->address);

  return bfd_reloc_ok;
}

static bfd_reloc_status_type
elf32_dlx_relocate26  (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 ATTRIBUTE_UNUSED;
{
  unsigned long insn, vallo, allignment;
  int           val;

  /* HACK: I think this first condition is necessary when producing
     relocatable output.  After the end of HACK, the code is identical
     to bfd_elf_generic_reloc().  I would _guess_ the first change
     belongs there rather than here.  martindo 1998-10-23.  */

  if (skip_dlx_elf_hi16_reloc)
    return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
                                 input_section, output_bfd, error_message);

  /* Check undefined section and undefined symbols.  */
  if (bfd_is_und_section (symbol->section)
      && output_bfd == (bfd *) NULL)
    return bfd_reloc_undefined;

  /* Can not support a long jump to sections other then .text   */
  if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
    {
      fprintf (stderr,
	       "BFD Link Error: jump (PC rel26) to section (%s) not supported\n",
	       symbol->section->output_section->name);
      return bfd_reloc_undefined;
    }

  insn  = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
  allignment = 1 << (input_section->output_section->alignment_power - 1);
  vallo = insn & 0x03FFFFFF;

  if (vallo & 0x03000000)
    vallo = ~(vallo | 0xFC000000) + 1;

  /* vallo is the vma for the next instruction.  */
  vallo += (((unsigned long) (input_section->output_section->vma +
			      input_section->output_offset) +
	     allignment) & ~allignment);

  /* val is the displacement (PC relative to next instruction).  */
  val = (symbol->section->output_offset +
	 symbol->section->output_section->vma + symbol->value)
    - vallo;

  if (abs ((int) val) > 0x01FFFFFF)
    return bfd_reloc_outofrange;

  insn  = (insn & 0xFC000000) | (val & 0x03FFFFFF);
  bfd_put_32 (abfd, insn,
              (bfd_byte *) data + reloc_entry->address);

  return bfd_reloc_ok;
}

/* A mapping from BFD reloc types to DLX ELF reloc types.
   Stolen from elf32-mips.c.

   More about this table - for dlx elf relocation we do not really
   need this table, if we have a rtype defined in this table will
   caused tc_gen_relocate confused and die on us, but if we remove
   this table it will caused more problem, so for now simple solution
   is to remove those entries which may cause problem.  */
struct elf_reloc_map
{
  bfd_reloc_code_real_type bfd_reloc_val;
  enum elf_dlx_reloc_type elf_reloc_val;
};

static const struct elf_reloc_map dlx_reloc_map[] =
  {
    { BFD_RELOC_NONE,           R_DLX_NONE },
    { BFD_RELOC_16,             R_DLX_RELOC_16 },
    { BFD_RELOC_32,             R_DLX_RELOC_32 },
    { BFD_RELOC_DLX_HI16_S,     R_DLX_RELOC_16_HI },
    { BFD_RELOC_DLX_LO16,       R_DLX_RELOC_16_LO },
    { BFD_RELOC_VTABLE_INHERIT,	R_DLX_GNU_VTINHERIT },
    { BFD_RELOC_VTABLE_ENTRY,	R_DLX_GNU_VTENTRY }
  };


/* 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_dlx_check_relocs (abfd, info, sec, relocs)
     bfd *abfd;
     struct bfd_link_info *info;
     asection *sec;
     const Elf_Internal_Rela *relocs;
{
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
  const Elf_Internal_Rela *rel;
  const Elf_Internal_Rela *rel_end;

  if (info->relocatable)
    return TRUE;

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

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

      r_symndx = ELF32_R_SYM (rel->r_info);
      if (r_symndx < symtab_hdr->sh_info)
        h = NULL;
      else
	{
	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	  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_DLX_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_DLX_GNU_VTENTRY:
          if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
            return FALSE;
          break;
        }
    }

  return TRUE;
}

/* Given a BFD reloc type, return a howto structure.  */

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

  for (i = 0; i < sizeof (dlx_reloc_map) / sizeof (struct elf_reloc_map); i++)
    if (dlx_reloc_map[i].bfd_reloc_val == code)
      return &dlx_elf_howto_table[(int) dlx_reloc_map[i].elf_reloc_val];

  switch (code)
    {
    default:
      bfd_set_error (bfd_error_bad_value);
      return NULL;
    case BFD_RELOC_16_PCREL_S2:
      return &elf_dlx_gnu_rel16_s2;
    case BFD_RELOC_DLX_JMP26:
      return &elf_dlx_gnu_rel26_s2;
    case BFD_RELOC_HI16_S:
      return &elf_dlx_reloc_16_hi;
    case BFD_RELOC_LO16:
      return &elf_dlx_reloc_16_lo;
    }
}

static reloc_howto_type *
dlx_rtype_to_howto (r_type)
     unsigned int r_type;
{
  switch (r_type)
    {
    case R_DLX_RELOC_16_PCREL:
      return & elf_dlx_gnu_rel16_s2;
      break;
    case R_DLX_RELOC_26_PCREL:
      return & elf_dlx_gnu_rel26_s2;
      break;
    case R_DLX_RELOC_16_HI:
      return & elf_dlx_reloc_16_hi;
      break;
    case R_DLX_RELOC_16_LO:
      return & elf_dlx_reloc_16_lo;
      break;

    default:
      BFD_ASSERT (r_type < (unsigned int) R_DLX_max);
      return & dlx_elf_howto_table[r_type];
      break;
    }
}

static void
elf32_dlx_info_to_howto (abfd, cache_ptr, dst)
     bfd * abfd ATTRIBUTE_UNUSED;
     arelent * cache_ptr ATTRIBUTE_UNUSED;
     Elf_Internal_Rela * dst ATTRIBUTE_UNUSED;
{
  abort ();
}

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

  r_type = ELF32_R_TYPE (dst->r_info);
  cache_ptr->howto = dlx_rtype_to_howto (r_type);
  return;
}

#define TARGET_BIG_SYM          bfd_elf32_dlx_big_vec
#define TARGET_BIG_NAME         "elf32-dlx"
#define ELF_ARCH                bfd_arch_dlx
#define ELF_MACHINE_CODE        EM_DLX
#define ELF_MAXPAGESIZE         1 /* FIXME: This number is wrong,  It should be the page size in bytes.  */

#include "elf32-target.h"
Commit	Line	Data
d172d4ba	1	/* DLX specific support for 32-bit ELF
9553c638	2	Copyright 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
d172d4ba NC	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
3e110533	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
d172d4ba NC	19
	20	#include "bfd.h"
	21	#include "sysdep.h"
	22	#include "libbfd.h"
	23	#include "elf-bfd.h"
	24	#include "elf/dlx.h"
	25
	26	int set_dlx_skip_hi16_flag PARAMS ((int));
	27
b34976b6 AM	28	static bfd_boolean elf32_dlx_check_relocs
	29	PARAMS ((bfd , struct bfd_link_info , asection *,
	30	const Elf_Internal_Rela *));
d172d4ba	31	static void elf32_dlx_info_to_howto
947216bf	32	PARAMS ((bfd , arelent , Elf_Internal_Rela *));
d172d4ba	33	static void elf32_dlx_info_to_howto_rel
947216bf	34	PARAMS ((bfd , arelent , Elf_Internal_Rela *));
d172d4ba NC	35	static bfd_reloc_status_type elf32_dlx_relocate16
	36	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	37	static bfd_reloc_status_type elf32_dlx_relocate26
	38	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	39	static reloc_howto_type *elf32_dlx_reloc_type_lookup
	40	PARAMS ((bfd *, bfd_reloc_code_real_type));
	41	static bfd_reloc_status_type _bfd_dlx_elf_hi16_reloc
	42	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	43	static reloc_howto_type * dlx_rtype_to_howto
	44	PARAMS ((unsigned int));
	45
	46
	47	#define USE_REL 1
	48
	49	#define bfd_elf32_bfd_reloc_type_lookup elf32_dlx_reloc_type_lookup
	50	#define elf_info_to_howto elf32_dlx_info_to_howto
	51	#define elf_info_to_howto_rel elf32_dlx_info_to_howto_rel
	52	#define elf_backend_check_relocs elf32_dlx_check_relocs
	53
	54	static reloc_howto_type dlx_elf_howto_table[]=
	55	{
	56	/* No relocation. */
	57	HOWTO (R_DLX_NONE, /* type */
	58	0, /* rightshift */
	59	0, /* size (0 = byte, 1 = short, 2 = long) */
	60	0, /* bitsize */
b34976b6	61	FALSE, /* pc_relative */
d172d4ba NC	62	0, /* bitpos */
	63	complain_overflow_dont,/* complain_on_overflow */
	64	bfd_elf_generic_reloc, /* special_function */
	65	"R_DLX_NONE", /* name */
b34976b6	66	FALSE, /* partial_inplace */
d172d4ba NC	67	0, /* src_mask */
d172d4ba NC	68	0, /* dst_mask */
b34976b6	69	FALSE), /* pcrel_offset */
d172d4ba NC	70
	71	/* 8 bit relocation. */
	72	HOWTO (R_DLX_RELOC_8, /* type */
	73	0, /* rightshift */
	74	0, /* size (0 = byte, 1 = short, 2 = long) */
	75	8, /* bitsize */
b34976b6	76	FALSE, /* pc_relative */
d172d4ba NC	77	0, /* bitpos */
	78	complain_overflow_dont,/* complain_on_overflow */
	79	bfd_elf_generic_reloc, /* special_function */
	80	"R_DLX_RELOC_8", /* name */
b34976b6	81	TRUE, /* partial_inplace */
d172d4ba NC	82	0xff, /* src_mask */
d172d4ba NC	83	0xff, /* dst_mask */
b34976b6	84	FALSE), /* pcrel_offset */
d172d4ba NC	85
	86	/* 16 bit relocation. */
	87	HOWTO (R_DLX_RELOC_16, /* type */
	88	0, /* rightshift */
	89	1, /* size (0 = byte, 1 = short, 2 = long) */
	90	16, /* bitsize */
b34976b6	91	FALSE, /* pc_relative */
d172d4ba NC	92	0, /* bitpos */
	93	complain_overflow_dont,/* complain_on_overflow */
	94	bfd_elf_generic_reloc, /* special_function */
	95	"R_DLX_RELOC_16", /* name */
b34976b6	96	TRUE, /* partial_inplace */
d172d4ba NC	97	0xffff, /* src_mask */
d172d4ba NC	98	0xffff, /* dst_mask */
b34976b6	99	FALSE), /* pcrel_offset */
d172d4ba	100
d172d4ba NC	101	/* 32 bit relocation. */
	102	HOWTO (R_DLX_RELOC_32, /* type */
	103	0, /* rightshift */
	104	2, /* size (0 = byte, 1 = short, 2 = long) */
	105	32, /* bitsize */
b34976b6	106	FALSE, /* pc_relative */
d172d4ba NC	107	0, /* bitpos */
	108	complain_overflow_dont,/* complain_on_overflow */
	109	bfd_elf_generic_reloc, /* special_function */
	110	"R_DLX_RELOC_32", /* name */
b34976b6	111	TRUE, /* partial_inplace */
d172d4ba NC	112	0xffffffff, /* src_mask */
d172d4ba NC	113	0xffffffff, /* dst_mask */
b34976b6	114	FALSE), /* pcrel_offset */
d172d4ba NC	115
	116	/* GNU extension to record C++ vtable hierarchy */
	117	HOWTO (R_DLX_GNU_VTINHERIT, /* type */
	118	0, /* rightshift */
	119	2, /* size (0 = byte, 1 = short, 2 = long) */
	120	0, /* bitsize */
b34976b6	121	FALSE, /* pc_relative */
d172d4ba NC	122	0, /* bitpos */
	123	complain_overflow_dont,/* complain_on_overflow */
	124	NULL, /* special_function */
	125	"R_DLX_GNU_VTINHERIT", /* name */
b34976b6	126	FALSE, /* partial_inplace */
d172d4ba NC	127	0, /* src_mask */
d172d4ba NC	128	0, /* dst_mask */
b34976b6	129	FALSE), /* pcrel_offset */
d172d4ba NC	130
	131	/* GNU extension to record C++ vtable member usage */
	132	HOWTO (R_DLX_GNU_VTENTRY, /* type */
	133	0, /* rightshift */
	134	2, /* size (0 = byte, 1 = short, 2 = long) */
	135	0, /* bitsize */
b34976b6	136	FALSE, /* pc_relative */
d172d4ba NC	137	0, /* bitpos */
	138	complain_overflow_dont,/* complain_on_overflow */
	139	_bfd_elf_rel_vtable_reloc_fn,/* special_function */
	140	"R_DLX_GNU_VTENTRY", /* name */
b34976b6	141	FALSE, /* partial_inplace */
d172d4ba NC	142	0, /* src_mask */
d172d4ba NC	143	0, /* dst_mask */
b34976b6	144	FALSE) /* pcrel_offset */
d172d4ba NC	145	};
	146
	147	/* 16 bit offset for pc-relative branches. */
	148	static reloc_howto_type elf_dlx_gnu_rel16_s2 =
	149	HOWTO (R_DLX_RELOC_16_PCREL, /* type */
	150	0, /* rightshift */
	151	1, /* size (0 = byte, 1 = short, 2 = long) */
	152	16, /* bitsize */
b34976b6	153	TRUE, /* pc_relative */
d172d4ba NC	154	0, /* bitpos */
	155	complain_overflow_signed, /* complain_on_overflow */
	156	elf32_dlx_relocate16, /* special_function */
	157	"R_DLX_RELOC_16_PCREL",/* name */
b34976b6	158	TRUE, /* partial_inplace */
d172d4ba NC	159	0xffff, /* src_mask */
d172d4ba NC	160	0xffff, /* dst_mask */
b34976b6	161	TRUE); /* pcrel_offset */
d172d4ba NC	162
	163	/* 26 bit offset for pc-relative branches. */
	164	static reloc_howto_type elf_dlx_gnu_rel26_s2 =
	165	HOWTO (R_DLX_RELOC_26_PCREL, /* type */
	166	0, /* rightshift */
	167	2, /* size (0 = byte, 1 = short, 2 = long) */
	168	26, /* bitsize */
b34976b6	169	TRUE, /* pc_relative */
d172d4ba NC	170	0, /* bitpos */
	171	complain_overflow_dont,/* complain_on_overflow */
	172	elf32_dlx_relocate26, /* special_function */
	173	"R_DLX_RELOC_26_PCREL",/* name */
b34976b6	174	TRUE, /* partial_inplace */
d172d4ba NC	175	0xffff, /* src_mask */
d172d4ba NC	176	0xffff, /* dst_mask */
b34976b6	177	TRUE); /* pcrel_offset */
d172d4ba NC	178
	179	/* High 16 bits of symbol value. */
	180	static reloc_howto_type elf_dlx_reloc_16_hi =
	181	HOWTO (R_DLX_RELOC_16_HI, /* type */
	182	16, /* rightshift */
	183	2, /* size (0 = byte, 1 = short, 2 = long) */
	184	32, /* bitsize */
b34976b6	185	FALSE, /* pc_relative */
d172d4ba NC	186	0, /* bitpos */
	187	complain_overflow_dont, /* complain_on_overflow */
	188	_bfd_dlx_elf_hi16_reloc,/* special_function */
	189	"R_DLX_RELOC_16_HI", /* name */
b34976b6	190	TRUE, /* partial_inplace */
d172d4ba NC	191	0xFFFF, /* src_mask */
d172d4ba NC	192	0xffff, /* dst_mask */
b34976b6	193	FALSE); /* pcrel_offset */
d172d4ba NC	194
	195	/* Low 16 bits of symbol value. */
	196	static reloc_howto_type elf_dlx_reloc_16_lo =
	197	HOWTO (R_DLX_RELOC_16_LO, /* type */
	198	0, /* rightshift */
	199	1, /* size (0 = byte, 1 = short, 2 = long) */
	200	16, /* bitsize */
b34976b6	201	FALSE, /* pc_relative */
d172d4ba NC	202	0, /* bitpos */
	203	complain_overflow_dont,/* complain_on_overflow */
	204	bfd_elf_generic_reloc, /* special_function */
	205	"R_DLX_RELOC_16_LO", /* name */
b34976b6	206	TRUE, /* partial_inplace */
d172d4ba NC	207	0xffff, /* src_mask */
d172d4ba NC	208	0xffff, /* dst_mask */
b34976b6	209	FALSE); /* pcrel_offset */
d172d4ba NC	210
d172d4ba NC	211
4cc11e76	212	/* The gas default behavior is not to preform the %hi modifier so that the
d172d4ba NC	213	GNU assembler can have the lower 16 bits offset placed in the insn, BUT
	214	we do like the gas to indicate it is %hi reloc type so when we in the link
	215	loader phase we can have the corrected hi16 vale replace the buggous lo16
	216	value that was placed there by gas. */
	217
	218	static int skip_dlx_elf_hi16_reloc = 0;
	219
	220	int
	221	set_dlx_skip_hi16_flag (flag)
	222	int flag;
	223	{
	224	skip_dlx_elf_hi16_reloc = flag;
	225	return flag;
	226	}
	227
	228	static bfd_reloc_status_type
	229	_bfd_dlx_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
	230	input_section, output_bfd, error_message)
	231	bfd *abfd;
	232	arelent *reloc_entry;
	233	asymbol *symbol;
	234	PTR data;
	235	asection *input_section;
	236	bfd *output_bfd;
	237	char **error_message;
	238	{
	239	bfd_reloc_status_type ret;
	240	bfd_vma relocation;
	241
	242	/* If the skip flag is set then we simply do the generic relocating, this
	243	is more of a hack for dlx gas/gld, so we do not need to do the %hi/%lo
	244	fixup like mips gld did. */
d172d4ba NC	245	if (skip_dlx_elf_hi16_reloc)
	246	return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
	247	input_section, output_bfd, error_message);
	248
	249	/* If we're relocating, and this an external symbol, we don't want
	250	to change anything. */
	251	if (output_bfd != (bfd *) NULL
	252	&& (symbol->flags & BSF_SECTION_SYM) == 0
	253	&& reloc_entry->addend == 0)
	254	{
	255	reloc_entry->address += input_section->output_offset;
	256	return bfd_reloc_ok;
	257	}
	258
	259	ret = bfd_reloc_ok;
	260
	261	if (bfd_is_und_section (symbol->section)
	262	&& output_bfd == (bfd *) NULL)
	263	ret = bfd_reloc_undefined;
	264
d172d4ba NC	265	relocation = (bfd_is_com_section (symbol->section)) ? 0 : symbol->value;
	266	relocation += symbol->section->output_section->vma;
	267	relocation += symbol->section->output_offset;
	268	relocation += reloc_entry->addend;
	269	relocation += bfd_get_16 (abfd, (bfd_byte *)data + reloc_entry->address);
	270
07515404	271	if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
d172d4ba NC	272	return bfd_reloc_outofrange;
d172d4ba NC	273
d172d4ba NC	274	bfd_put_16 (abfd, (short)((relocation >> 16) & 0xFFFF),
	275	(bfd_byte *)data + reloc_entry->address);
	276
	277	return ret;
	278	}
	279
1049f94e	280	/* ELF relocs are against symbols. If we are producing relocatable
d172d4ba NC	281	output, and the reloc is against an external symbol, and nothing
	282	has given us any additional addend, the resulting reloc will also
	283	be against the same symbol. In such a case, we don't want to
	284	change anything about the way the reloc is handled, since it will
	285	all be done at final link time. Rather than put special case code
	286	into bfd_perform_relocation, all the reloc types use this howto
	287	function. It just short circuits the reloc if producing
1049f94e	288	relocatable output against an external symbol. */
d172d4ba NC	289
	290	static bfd_reloc_status_type
	291	elf32_dlx_relocate16 (abfd, reloc_entry, symbol, data,
	292	input_section, output_bfd, error_message)
	293	bfd *abfd;
	294	arelent *reloc_entry;
	295	asymbol *symbol;
	296	PTR data;
	297	asection *input_section;
	298	bfd *output_bfd;
	299	char **error_message ATTRIBUTE_UNUSED;
	300	{
	301	unsigned long insn, vallo, allignment;
	302	int val;
	303
	304	/* HACK: I think this first condition is necessary when producing
	305	relocatable output. After the end of HACK, the code is identical
	306	to bfd_elf_generic_reloc(). I would _guess_ the first change
	307	belongs there rather than here. martindo 1998-10-23. */
	308
	309	if (skip_dlx_elf_hi16_reloc)
	310	return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
	311	input_section, output_bfd, error_message);
	312
	313	/* Check undefined section and undefined symbols */
	314	if (bfd_is_und_section (symbol->section)
	315	&& output_bfd == (bfd *) NULL)
	316	return bfd_reloc_undefined;
	317
	318	/* Can not support a long jump to sections other then .text */
	319	if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
	320	{
	321	fprintf (stderr,
	322	"BFD Link Error: branch (PC rel16) to section (%s) not supported\n",
	323	symbol->section->output_section->name);
	324	return bfd_reloc_undefined;
	325	}
	326
	327	insn = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
	328	allignment = 1 << (input_section->output_section->alignment_power - 1);
	329	vallo = insn & 0x0000FFFF;
	330
	331	if (vallo & 0x8000)
	332	vallo = ~(vallo \| 0xFFFF0000) + 1;
	333
	334	/* vallo points to the vma of next instruction. */
	335	vallo += (((unsigned long)(input_section->output_section->vma +
	336	input_section->output_offset) +
	337	allignment) & ~allignment);
	338
	339	/* val is the displacement (PC relative to next instruction). */
	340	val = (symbol->section->output_offset +
	341	symbol->section->output_section->vma +
	342	symbol->value) - vallo;
d172d4ba NC	343
	344	if (abs ((int) val) > 0x00007FFF)
	345	return bfd_reloc_outofrange;
	346
	347	insn = (insn & 0xFFFF0000) \| (val & 0x0000FFFF);
	348
	349	bfd_put_32 (abfd, insn,
	350	(bfd_byte *) data + reloc_entry->address);
	351
	352	return bfd_reloc_ok;
	353	}
	354
	355	static bfd_reloc_status_type
	356	elf32_dlx_relocate26 (abfd, reloc_entry, symbol, data,
	357	input_section, output_bfd, error_message)
	358	bfd *abfd;
	359	arelent *reloc_entry;
	360	asymbol *symbol;
	361	PTR data;
	362	asection *input_section;
	363	bfd *output_bfd;
	364	char **error_message ATTRIBUTE_UNUSED;
	365	{
	366	unsigned long insn, vallo, allignment;
	367	int val;
	368
	369	/* HACK: I think this first condition is necessary when producing
	370	relocatable output. After the end of HACK, the code is identical
	371	to bfd_elf_generic_reloc(). I would _guess_ the first change
	372	belongs there rather than here. martindo 1998-10-23. */
	373
	374	if (skip_dlx_elf_hi16_reloc)
	375	return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
	376	input_section, output_bfd, error_message);
	377
	378	/* Check undefined section and undefined symbols. */
	379	if (bfd_is_und_section (symbol->section)
	380	&& output_bfd == (bfd *) NULL)
	381	return bfd_reloc_undefined;
	382
	383	/* Can not support a long jump to sections other then .text */
	384	if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
	385	{
	386	fprintf (stderr,
	387	"BFD Link Error: jump (PC rel26) to section (%s) not supported\n",
	388	symbol->section->output_section->name);
	389	return bfd_reloc_undefined;
	390	}
	391
	392	insn = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
	393	allignment = 1 << (input_section->output_section->alignment_power - 1);
	394	vallo = insn & 0x03FFFFFF;
	395
	396	if (vallo & 0x03000000)
	397	vallo = ~(vallo \| 0xFC000000) + 1;
	398
	399	/* vallo is the vma for the next instruction. */
	400	vallo += (((unsigned long) (input_section->output_section->vma +
	401	input_section->output_offset) +
	402	allignment) & ~allignment);
	403
	404	/* val is the displacement (PC relative to next instruction). */
	405	val = (symbol->section->output_offset +
	406	symbol->section->output_section->vma + symbol->value)
407	- vallo;
d172d4ba NC	408
	409	if (abs ((int) val) > 0x01FFFFFF)
	410	return bfd_reloc_outofrange;
	411
	412	insn = (insn & 0xFC000000) \| (val & 0x03FFFFFF);
	413	bfd_put_32 (abfd, insn,
	414	(bfd_byte *) data + reloc_entry->address);
	415
	416	return bfd_reloc_ok;
	417	}
	418
	419	/* A mapping from BFD reloc types to DLX ELF reloc types.
	420	Stolen from elf32-mips.c.
cedb70c5	421
d172d4ba NC	422	More about this table - for dlx elf relocation we do not really
	423	need this table, if we have a rtype defined in this table will
	424	caused tc_gen_relocate confused and die on us, but if we remove
4cc11e76	425	this table it will caused more problem, so for now simple solution
d172d4ba NC	426	is to remove those entries which may cause problem. */
	427	struct elf_reloc_map
	428	{
	429	bfd_reloc_code_real_type bfd_reloc_val;
	430	enum elf_dlx_reloc_type elf_reloc_val;
	431	};
	432
3f9c735e	433	static const struct elf_reloc_map dlx_reloc_map[] =
d172d4ba NC	434	{
	435	{ BFD_RELOC_NONE, R_DLX_NONE },
	436	{ BFD_RELOC_16, R_DLX_RELOC_16 },
d172d4ba NC	437	{ BFD_RELOC_32, R_DLX_RELOC_32 },
	438	{ BFD_RELOC_DLX_HI16_S, R_DLX_RELOC_16_HI },
	439	{ BFD_RELOC_DLX_LO16, R_DLX_RELOC_16_LO },
	440	{ BFD_RELOC_VTABLE_INHERIT, R_DLX_GNU_VTINHERIT },
	441	{ BFD_RELOC_VTABLE_ENTRY, R_DLX_GNU_VTENTRY }
	442	};
	443
	444
	445	/* Look through the relocs for a section during the first phase.
	446	Since we don't do .gots or .plts, we just need to consider the
	447	virtual table relocs for gc. */
	448
b34976b6	449	static bfd_boolean
d172d4ba NC	450	elf32_dlx_check_relocs (abfd, info, sec, relocs)
	451	bfd *abfd;
	452	struct bfd_link_info *info;
	453	asection *sec;
	454	const Elf_Internal_Rela *relocs;
	455	{
	456	Elf_Internal_Shdr *symtab_hdr;
	457	struct elf_link_hash_entry sym_hashes, sym_hashes_end;
	458	const Elf_Internal_Rela *rel;
	459	const Elf_Internal_Rela *rel_end;
	460
1049f94e	461	if (info->relocatable)
b34976b6	462	return TRUE;
d172d4ba NC	463
	464	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
	465	sym_hashes = elf_sym_hashes (abfd);
	466	sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
	467	if (!elf_bad_symtab (abfd))
	468	sym_hashes_end -= symtab_hdr->sh_info;
	469
	470	rel_end = relocs + sec->reloc_count;
	471	for (rel = relocs; rel < rel_end; rel++)
	472	{
	473	struct elf_link_hash_entry *h;
	474	unsigned long r_symndx;
	475
	476	r_symndx = ELF32_R_SYM (rel->r_info);
	477	if (r_symndx < symtab_hdr->sh_info)
	478	h = NULL;
	479	else
973a3492 L	480	{
	481	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	482	while (h->root.type == bfd_link_hash_indirect
	483	\|\| h->root.type == bfd_link_hash_warning)
	484	h = (struct elf_link_hash_entry *) h->root.u.i.link;
	485	}
d172d4ba NC	486
	487	switch (ELF32_R_TYPE (rel->r_info))
	488	{
	489	/* This relocation describes the C++ object vtable hierarchy.
	490	Reconstruct it for later use during GC. */
	491	case R_DLX_GNU_VTINHERIT:
c152c796	492	if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6	493	return FALSE;
d172d4ba NC	494	break;
	495
	496	/* This relocation describes which C++ vtable entries are actually
	497	used. Record for later use during GC. */
	498	case R_DLX_GNU_VTENTRY:
c152c796	499	if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6	500	return FALSE;
d172d4ba NC	501	break;
	502	}
	503	}
	504
b34976b6	505	return TRUE;
d172d4ba NC	506	}
	507
	508	/* Given a BFD reloc type, return a howto structure. */
	509
	510	static reloc_howto_type *
	511	elf32_dlx_reloc_type_lookup (abfd, code)
	512	bfd *abfd ATTRIBUTE_UNUSED;
	513	bfd_reloc_code_real_type code;
	514	{
	515	unsigned int i;
	516
	517	for (i = 0; i < sizeof (dlx_reloc_map) / sizeof (struct elf_reloc_map); i++)
	518	if (dlx_reloc_map[i].bfd_reloc_val == code)
	519	return &dlx_elf_howto_table[(int) dlx_reloc_map[i].elf_reloc_val];
	520
	521	switch (code)
	522	{
	523	default:
	524	bfd_set_error (bfd_error_bad_value);
	525	return NULL;
	526	case BFD_RELOC_16_PCREL_S2:
	527	return &elf_dlx_gnu_rel16_s2;
	528	case BFD_RELOC_DLX_JMP26:
	529	return &elf_dlx_gnu_rel26_s2;
	530	case BFD_RELOC_HI16_S:
	531	return &elf_dlx_reloc_16_hi;
	532	case BFD_RELOC_LO16:
	533	return &elf_dlx_reloc_16_lo;
	534	}
	535	}
	536
	537	static reloc_howto_type *
	538	dlx_rtype_to_howto (r_type)
	539	unsigned int r_type;
	540	{
	541	switch (r_type)
	542	{
	543	case R_DLX_RELOC_16_PCREL:
	544	return & elf_dlx_gnu_rel16_s2;
	545	break;
	546	case R_DLX_RELOC_26_PCREL:
	547	return & elf_dlx_gnu_rel26_s2;
	548	break;
	549	case R_DLX_RELOC_16_HI:
	550	return & elf_dlx_reloc_16_hi;
	551	break;
	552	case R_DLX_RELOC_16_LO:
	553	return & elf_dlx_reloc_16_lo;
	554	break;
	555
	556	default:
	557	BFD_ASSERT (r_type < (unsigned int) R_DLX_max);
	558	return & dlx_elf_howto_table[r_type];
	559	break;
	560	}
	561	}
	562
	563	static void
	564	elf32_dlx_info_to_howto (abfd, cache_ptr, dst)
	565	bfd * abfd ATTRIBUTE_UNUSED;
	566	arelent * cache_ptr ATTRIBUTE_UNUSED;
947216bf	567	Elf_Internal_Rela * dst ATTRIBUTE_UNUSED;
d172d4ba NC	568	{
	569	abort ();
	570	}
	571
	572	static void
	573	elf32_dlx_info_to_howto_rel (abfd, cache_ptr, dst)
	574	bfd *abfd ATTRIBUTE_UNUSED;
	575	arelent *cache_ptr;
947216bf	576	Elf_Internal_Rela *dst;
d172d4ba NC	577	{
	578	unsigned int r_type;
	579
	580	r_type = ELF32_R_TYPE (dst->r_info);
	581	cache_ptr->howto = dlx_rtype_to_howto (r_type);
	582	return;
	583	}
	584
	585	#define TARGET_BIG_SYM bfd_elf32_dlx_big_vec
	586	#define TARGET_BIG_NAME "elf32-dlx"
	587	#define ELF_ARCH bfd_arch_dlx
	588	#define ELF_MACHINE_CODE EM_DLX
	589	#define ELF_MAXPAGESIZE 1 /* FIXME: This number is wrong, It should be the page size in bytes. */
	590
	591	#include "elf32-target.h"