[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"

#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

/* 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;

extern int set_dlx_skip_hi16_flag (int);

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

static bfd_reloc_status_type
_bfd_dlx_elf_hi16_reloc (bfd *abfd,
			 arelent *reloc_entry,
			 asymbol *symbol,
			 void * 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 (bfd *abfd,
		      arelent *reloc_entry,
		      asymbol *symbol,
		      void * 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 (bfd *abfd,
		      arelent *reloc_entry,
		      asymbol *symbol,
		      void * 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;
}

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.  */

/* 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 (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 (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 (unsigned int r_type)
{
  switch (r_type)
    {
    case R_DLX_RELOC_16_PCREL:
      return & elf_dlx_gnu_rel16_s2;
    case R_DLX_RELOC_26_PCREL:
      return & elf_dlx_gnu_rel26_s2;
    case R_DLX_RELOC_16_HI:
      return & elf_dlx_reloc_16_hi;
    case R_DLX_RELOC_16_LO:
      return & elf_dlx_reloc_16_lo;
    default:
      BFD_ASSERT (r_type < (unsigned int) R_DLX_max);
      return & dlx_elf_howto_table[r_type];
    }
}

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

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