[deliverable/binutils-gdb.git] / bfd / nlm32-sparc.c

/* Support for 32-bit SPARC NLM (NetWare Loadable Module)
   Copyright 1993, 1994, 2000, 2001 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"

#define ARCH_SIZE 32

#include "nlm/sparc32-ext.h"
#define Nlm_External_Fixed_Header	Nlm32_sparc_External_Fixed_Header

#include "libnlm.h"

static boolean nlm_sparc_read_reloc
  PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
static boolean nlm_sparc_write_reloc
  PARAMS ((bfd *, asection *, arelent *));
static boolean nlm_sparc_mangle_relocs
  PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
static boolean nlm_sparc_read_import
  PARAMS ((bfd *, nlmNAME(symbol_type) *));
static boolean nlm_sparc_write_import
  PARAMS ((bfd *, asection *, arelent *));
static boolean nlm_sparc_write_external
  PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *));
static boolean nlm_sparc_write_export
  PARAMS ((bfd *, asymbol *, bfd_vma));

enum reloc_type
  {
    R_SPARC_NONE = 0,
    R_SPARC_8,		R_SPARC_16,		R_SPARC_32,
    R_SPARC_DISP8,	R_SPARC_DISP16,		R_SPARC_DISP32,
    R_SPARC_WDISP30,	R_SPARC_WDISP22,
    R_SPARC_HI22,	R_SPARC_22,
    R_SPARC_13,		R_SPARC_LO10,
    R_SPARC_GOT10,	R_SPARC_GOT13,		R_SPARC_GOT22,
    R_SPARC_PC10,	R_SPARC_PC22,
    R_SPARC_WPLT30,
    R_SPARC_COPY,
    R_SPARC_GLOB_DAT,	R_SPARC_JMP_SLOT,
    R_SPARC_RELATIVE,
    R_SPARC_UA32,
    R_SPARC_max
  };

#if 0
static const char *const reloc_type_names[] =
  {
    "R_SPARC_NONE",
    "R_SPARC_8",		"R_SPARC_16",		"R_SPARC_32",
    "R_SPARC_DISP8",	"R_SPARC_DISP16",	"R_SPARC_DISP32",
    "R_SPARC_WDISP30",	"R_SPARC_WDISP22",
    "R_SPARC_HI22",	"R_SPARC_22",
    "R_SPARC_13",		"R_SPARC_LO10",
    "R_SPARC_GOT10",	"R_SPARC_GOT13",	"R_SPARC_GOT22",
    "R_SPARC_PC10",	"R_SPARC_PC22",
    "R_SPARC_WPLT30",
    "R_SPARC_COPY",
    "R_SPARC_GLOB_DAT",	"R_SPARC_JMP_SLOT",
    "R_SPARC_RELATIVE",
    "R_SPARC_UA32",
  };
#endif

static reloc_howto_type nlm32_sparc_howto_table[] =
  {
    HOWTO (R_SPARC_NONE,    0,0, 0,false,0,complain_overflow_dont,    0,"R_SPARC_NONE",    false,0,0x00000000,true),
    HOWTO (R_SPARC_8,       0,0, 8,false,0,complain_overflow_bitfield,0,"R_SPARC_8",       false,0,0x000000ff,true),
    HOWTO (R_SPARC_16,      0,1,16,false,0,complain_overflow_bitfield,0,"R_SPARC_16",      false,0,0x0000ffff,true),
    HOWTO (R_SPARC_32,      0,2,32,false,0,complain_overflow_bitfield,0,"R_SPARC_32",      false,0,0xffffffff,true),
    HOWTO (R_SPARC_DISP8,   0,0, 8,true, 0,complain_overflow_signed,  0,"R_SPARC_DISP8",   false,0,0x000000ff,true),
    HOWTO (R_SPARC_DISP16,  0,1,16,true, 0,complain_overflow_signed,  0,"R_SPARC_DISP16",  false,0,0x0000ffff,true),
    HOWTO (R_SPARC_DISP32,  0,2,32,true, 0,complain_overflow_signed,  0,"R_SPARC_DISP32",  false,0,0x00ffffff,true),
    HOWTO (R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed,  0,"R_SPARC_WDISP30", false,0,0x3fffffff,true),
    HOWTO (R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed,  0,"R_SPARC_WDISP22", false,0,0x003fffff,true),
    HOWTO (R_SPARC_HI22,   10,2,22,false,0,complain_overflow_dont,    0,"R_SPARC_HI22",    false,0,0x003fffff,true),
    HOWTO (R_SPARC_22,      0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_22",      false,0,0x003fffff,true),
    HOWTO (R_SPARC_13,      0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_13",      false,0,0x00001fff,true),
    HOWTO (R_SPARC_LO10,    0,2,10,false,0,complain_overflow_dont,    0,"R_SPARC_LO10",    false,0,0x000003ff,true),
    HOWTO (R_SPARC_GOT10,   0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT10",   false,0,0x000003ff,true),
    HOWTO (R_SPARC_GOT13,   0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT13",   false,0,0x00001fff,true),
    HOWTO (R_SPARC_GOT22,  10,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT22",   false,0,0x003fffff,true),
    HOWTO (R_SPARC_PC10,    0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_PC10",    false,0,0x000003ff,true),
    HOWTO (R_SPARC_PC22,    0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_PC22",    false,0,0x003fffff,true),
    HOWTO (R_SPARC_WPLT30,  0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_WPLT30",  false,0,0x00000000,true),
    HOWTO (R_SPARC_COPY,    0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_COPY",    false,0,0x00000000,true),
    HOWTO (R_SPARC_GLOB_DAT,0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_GLOB_DAT",false,0,0x00000000,true),
    HOWTO (R_SPARC_JMP_SLOT,0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_JMP_SLOT",false,0,0x00000000,true),
    HOWTO (R_SPARC_RELATIVE,0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_RELATIVE",false,0,0x00000000,true),
    HOWTO (R_SPARC_UA32,    0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_UA32",    false,0,0x00000000,true),
};

/* Read a NetWare sparc reloc.  */

struct nlm32_sparc_reloc_ext
  {
    unsigned char offset[4];
    unsigned char addend[4];
    unsigned char type[1];
    unsigned char pad1[3];
  };

static boolean
nlm_sparc_read_reloc (abfd, sym, secp, rel)
     bfd *abfd;
     nlmNAME(symbol_type) *sym ATTRIBUTE_UNUSED;
     asection **secp;
     arelent *rel;
{
  bfd_vma val, addend;
  unsigned int index;
  unsigned int type;
  struct nlm32_sparc_reloc_ext tmp_reloc;
  asection *code_sec, *data_sec;

  if (bfd_bread (&tmp_reloc, (bfd_size_type) 12, abfd) != 12)
    return false;

  code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
  data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);

  *secp = code_sec;

  val = bfd_get_32 (abfd, tmp_reloc.offset);
  addend = bfd_get_32 (abfd, tmp_reloc.addend);
  type = bfd_get_8 (abfd, tmp_reloc.type);

  rel->address = val;
  rel->addend = addend;
  rel->howto = NULL;

  for (index = 0;
       index < sizeof (nlm32_sparc_howto_table) / sizeof (reloc_howto_type);
       index++)
    if (nlm32_sparc_howto_table[index].type == type)
      {
	rel->howto = &nlm32_sparc_howto_table[index];
	break;
      }

#ifdef DEBUG
  fprintf (stderr, "%s:  address = %08lx, addend = %08lx, type = %d, howto = %08lx\n",
	   __FUNCTION__, rel->address, rel->addend, type, rel->howto);
#endif
  return true;

}

/* Write a NetWare sparc reloc.  */

static boolean
nlm_sparc_write_reloc (abfd, sec, rel)
     bfd *abfd;
     asection *sec;
     arelent *rel;
{
  bfd_vma val;
  struct nlm32_sparc_reloc_ext tmp_reloc;
  unsigned int index;
  int type = -1;
  reloc_howto_type *tmp;

  for (index = 0;
       index < sizeof (nlm32_sparc_howto_table) / sizeof (reloc_howto_type);
       index++)
    {
      tmp = &nlm32_sparc_howto_table[index];

      if (tmp->rightshift == rel->howto->rightshift
	  && tmp->size == rel->howto->size
	  && tmp->bitsize == rel->howto->bitsize
	  && tmp->pc_relative == rel->howto->pc_relative
	  && tmp->bitpos == rel->howto->bitpos
	  && tmp->src_mask == rel->howto->src_mask
	  && tmp->dst_mask == rel->howto->dst_mask)
	{
	  type = tmp->type;
	  break;
	}
    }
  if (type == -1)
    abort ();

  /* Netware wants a list of relocs for each address.
     Format is:
    	long	offset
    	long	addend
    	char	type
     That should be it.  */

  /* The value we write out is the offset into the appropriate
     segment.  This offset is the section vma, adjusted by the vma of
     the lowest section in that segment, plus the address of the
     relocation.  */
#if 0
  val = bfd_get_section_vma (abfd, (*rel->sym_ptr_ptr)->section) + rel->address;
#else
  val = bfd_get_section_vma (abfd, sec) + rel->address;
#endif

#ifdef DEBUG
  fprintf (stderr, "%s:  val = %08lx, addend = %08lx, type = %d\n",
	   __FUNCTION__, val, rel->addend, rel->howto->type);
#endif
  bfd_put_32 (abfd, val, tmp_reloc.offset);
  bfd_put_32 (abfd, rel->addend, tmp_reloc.addend);
  bfd_put_8 (abfd, (short) (rel->howto->type), tmp_reloc.type);

  if (bfd_bwrite (&tmp_reloc, (bfd_size_type) 12, abfd) != 12)
    return false;

  return true;
}

/* Mangle relocs for SPARC NetWare.  We can just use the standard
   SPARC relocs.  */

static boolean
nlm_sparc_mangle_relocs (abfd, sec, data, offset, count)
     bfd *abfd ATTRIBUTE_UNUSED;
     asection *sec ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     bfd_vma offset ATTRIBUTE_UNUSED;
     bfd_size_type count ATTRIBUTE_UNUSED;
{
  return true;
}

/* Read a NetWare sparc import record.  */

static boolean
nlm_sparc_read_import (abfd, sym)
     bfd *abfd;
     nlmNAME(symbol_type) *sym;
{
  struct nlm_relent *nlm_relocs;	/* Relocation records for symbol.  */
  bfd_size_type rcount;			/* Number of relocs.  */
  bfd_byte temp[NLM_TARGET_LONG_SIZE];	/* Temporary 32-bit value.  */
  unsigned char symlength;		/* Length of symbol name.  */
  char *name;

  /* First, read in the number of relocation
     entries for this symbol.  */
  if (bfd_bread ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
    return false;

  rcount = bfd_get_32 (abfd, temp);

  /* Next, read in the length of the symbol.  */

  if (bfd_bread ((PTR) &symlength, (bfd_size_type) sizeof (symlength), abfd)
      != sizeof (symlength))
    return false;
  sym -> symbol.the_bfd = abfd;
  name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
  if (name == NULL)
    return false;

  /* Then read in the symbol.  */

  if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
    return false;
  name[symlength] = '\0';
  sym -> symbol.name = name;
  sym -> symbol.flags = 0;
  sym -> symbol.value = 0;
  sym -> symbol.section = bfd_und_section_ptr;

  /* Next, start reading in the relocs.  */

  nlm_relocs = ((struct nlm_relent *)
		bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
  if (!nlm_relocs)
    return false;
  sym -> relocs = nlm_relocs;
  sym -> rcnt = 0;
  while (sym -> rcnt < rcount)
    {
      asection *section;

      if (nlm_sparc_read_reloc (abfd, sym, &section,
			      &nlm_relocs -> reloc)
	  == false)
	return false;
      nlm_relocs -> section = section;
      nlm_relocs++;
      sym -> rcnt++;
    }

  return true;
}

static boolean
nlm_sparc_write_import (abfd, sec, rel)
     bfd *abfd;
     asection *sec;
     arelent *rel;
{
  char temp[4];
  asection *code, *data, *bss, *symsec;
  bfd_vma base;

  code = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
  data = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
  bss = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
  symsec = (*rel->sym_ptr_ptr)->section;

  if (symsec == code)
    base = 0;
  else if (symsec == data)
    base = bfd_section_size (abfd, code);
  else if (symsec == bss)
    base = bfd_section_size (abfd, code) + bfd_section_size (abfd, data);
  else
    base = 0;

#ifdef DEBUG
  fprintf (stderr, "%s:  <%x, 1>\n\t",
	   __FUNCTION__, base + (*rel->sym_ptr_ptr)->value);
#endif
  bfd_put_32 (abfd, base + (*rel->sym_ptr_ptr)->value, temp);
  if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
    return false;
  bfd_put_32 (abfd, (bfd_vma) 1, temp);
  if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
    return false;
  if (nlm_sparc_write_reloc (abfd, sec, rel) == false)
    return false;
  return true;
}

/* Write out an external reference.  */

static boolean
nlm_sparc_write_external (abfd, count, sym, relocs)
     bfd *abfd;
     bfd_size_type count;
     asymbol *sym;
     struct reloc_and_sec *relocs;
{
  unsigned int i;
  bfd_byte len;
  unsigned char temp[NLM_TARGET_LONG_SIZE];

  bfd_put_32 (abfd, count, temp);
  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return false;

  len = strlen (sym->name);
  if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
       != sizeof (bfd_byte))
      || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
    return false;

  for (i = 0; i < count; i++)
    {
      if (nlm_sparc_write_reloc (abfd, relocs[i].sec,
				 relocs[i].rel) == false)
	return false;
    }

  return true;
}

static boolean
nlm_sparc_write_export (abfd, sym, value)
     bfd *abfd;
     asymbol *sym;
     bfd_vma value;
{
  bfd_byte len;
  bfd_byte temp[4];

#ifdef DEBUG
  fprintf (stderr, "%s: <%x, %d, %s>\n",
	   __FUNCTION__, value, strlen (sym->name), sym->name);
#endif
  bfd_put_32 (abfd, value, temp);
  len = strlen (sym->name);

  if (bfd_bwrite (temp, (bfd_size_type) 4, abfd) != 4
      || bfd_bwrite (&len, (bfd_size_type) 1, abfd) != 1
      || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
    return false;

  return true;
}

#undef nlm_swap_fixed_header_in
#undef nlm_swap_fixed_header_out

#include "nlmswap.h"

static const struct nlm_backend_data nlm32_sparc_backend =
  {
    "NetWare SPARC Module   \032",
    sizeof (Nlm32_sparc_External_Fixed_Header),
    0,	/* optional_prefix_size */
    bfd_arch_sparc,
    0,
    false,
    0,	/* backend_object_p */
    0,	/* write_prefix_func */
    nlm_sparc_read_reloc,
    nlm_sparc_mangle_relocs,
    nlm_sparc_read_import,
    nlm_sparc_write_import,
    0,	/* set_public_section */
    0,	/* get_public_offset */
    nlm_swap_fixed_header_in,
    nlm_swap_fixed_header_out,
    nlm_sparc_write_external,
    nlm_sparc_write_export
  };

#define TARGET_BIG_NAME		"nlm32-sparc"
#define TARGET_BIG_SYM		nlmNAME(sparc_vec)
#define TARGET_BACKEND_DATA	& nlm32_sparc_backend

#include "nlm-target.h"
Commit	Line	Data
252b5132	1	/* Support for 32-bit SPARC NLM (NetWare Loadable Module)
42ef282f	2	Copyright 1993, 1994, 2000, 2001 Free Software Foundation, Inc.
252b5132	3
42ef282f	4	This file is part of BFD, the Binary File Descriptor library.
252b5132	5
42ef282f NC	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.
252b5132	10
42ef282f NC	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.
252b5132	15
42ef282f NC	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
	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
252b5132 RH	19
	20	#include "bfd.h"
	21	#include "sysdep.h"
	22	#include "libbfd.h"
	23
	24	#define ARCH_SIZE 32
	25
	26	#include "nlm/sparc32-ext.h"
	27	#define Nlm_External_Fixed_Header Nlm32_sparc_External_Fixed_Header
	28
	29	#include "libnlm.h"
	30
	31	static boolean nlm_sparc_read_reloc
	32	PARAMS ((bfd , nlmNAME(symbol_type) , asection *, arelent ));
	33	static boolean nlm_sparc_write_reloc
	34	PARAMS ((bfd , asection , arelent *));
	35	static boolean nlm_sparc_mangle_relocs
	36	PARAMS ((bfd , asection , PTR, bfd_vma, bfd_size_type));
	37	static boolean nlm_sparc_read_import
	38	PARAMS ((bfd , nlmNAME(symbol_type) ));
	39	static boolean nlm_sparc_write_import
	40	PARAMS ((bfd , asection , arelent *));
	41	static boolean nlm_sparc_write_external
	42	PARAMS ((bfd , bfd_size_type, asymbol , struct reloc_and_sec *));
42ef282f NC	43	static boolean nlm_sparc_write_export
42ef282f NC	44	PARAMS ((bfd , asymbol , bfd_vma));
252b5132 RH	45
	46	enum reloc_type
	47	{
	48	R_SPARC_NONE = 0,
1518639e KH	49	R_SPARC_8, R_SPARC_16, R_SPARC_32,
1518639e KH	50	R_SPARC_DISP8, R_SPARC_DISP16, R_SPARC_DISP32,
252b5132 RH	51	R_SPARC_WDISP30, R_SPARC_WDISP22,
	52	R_SPARC_HI22, R_SPARC_22,
	53	R_SPARC_13, R_SPARC_LO10,
	54	R_SPARC_GOT10, R_SPARC_GOT13, R_SPARC_GOT22,
	55	R_SPARC_PC10, R_SPARC_PC22,
	56	R_SPARC_WPLT30,
	57	R_SPARC_COPY,
	58	R_SPARC_GLOB_DAT, R_SPARC_JMP_SLOT,
	59	R_SPARC_RELATIVE,
	60	R_SPARC_UA32,
	61	R_SPARC_max
	62	};
	63
	64	#if 0
dc810e39	65	static const char *const reloc_type_names[] =
42ef282f NC	66	{
	67	"R_SPARC_NONE",
	68	"R_SPARC_8", "R_SPARC_16", "R_SPARC_32",
	69	"R_SPARC_DISP8", "R_SPARC_DISP16", "R_SPARC_DISP32",
	70	"R_SPARC_WDISP30", "R_SPARC_WDISP22",
	71	"R_SPARC_HI22", "R_SPARC_22",
	72	"R_SPARC_13", "R_SPARC_LO10",
	73	"R_SPARC_GOT10", "R_SPARC_GOT13", "R_SPARC_GOT22",
	74	"R_SPARC_PC10", "R_SPARC_PC22",
	75	"R_SPARC_WPLT30",
	76	"R_SPARC_COPY",
	77	"R_SPARC_GLOB_DAT", "R_SPARC_JMP_SLOT",
	78	"R_SPARC_RELATIVE",
	79	"R_SPARC_UA32",
	80	};
252b5132 RH	81	#endif
252b5132 RH	82
1518639e	83	static reloc_howto_type nlm32_sparc_howto_table[] =
42ef282f NC	84	{
	85	HOWTO (R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, 0,"R_SPARC_NONE", false,0,0x00000000,true),
	86	HOWTO (R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,0,"R_SPARC_8", false,0,0x000000ff,true),
	87	HOWTO (R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,0,"R_SPARC_16", false,0,0x0000ffff,true),
	88	HOWTO (R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,0,"R_SPARC_32", false,0,0xffffffff,true),
	89	HOWTO (R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, 0,"R_SPARC_DISP8", false,0,0x000000ff,true),
	90	HOWTO (R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, 0,"R_SPARC_DISP16", false,0,0x0000ffff,true),
	91	HOWTO (R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, 0,"R_SPARC_DISP32", false,0,0x00ffffff,true),
	92	HOWTO (R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, 0,"R_SPARC_WDISP30", false,0,0x3fffffff,true),
	93	HOWTO (R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, 0,"R_SPARC_WDISP22", false,0,0x003fffff,true),
	94	HOWTO (R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, 0,"R_SPARC_HI22", false,0,0x003fffff,true),
	95	HOWTO (R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_22", false,0,0x003fffff,true),
	96	HOWTO (R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_13", false,0,0x00001fff,true),
	97	HOWTO (R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, 0,"R_SPARC_LO10", false,0,0x000003ff,true),
	98	HOWTO (R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT10", false,0,0x000003ff,true),
	99	HOWTO (R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT13", false,0,0x00001fff,true),
	100	HOWTO (R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT22", false,0,0x003fffff,true),
	101	HOWTO (R_SPARC_PC10, 0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_PC10", false,0,0x000003ff,true),
	102	HOWTO (R_SPARC_PC22, 0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_PC22", false,0,0x003fffff,true),
	103	HOWTO (R_SPARC_WPLT30, 0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_WPLT30", false,0,0x00000000,true),
	104	HOWTO (R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_COPY", false,0,0x00000000,true),
	105	HOWTO (R_SPARC_GLOB_DAT,0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_GLOB_DAT",false,0,0x00000000,true),
	106	HOWTO (R_SPARC_JMP_SLOT,0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_JMP_SLOT",false,0,0x00000000,true),
	107	HOWTO (R_SPARC_RELATIVE,0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_RELATIVE",false,0,0x00000000,true),
	108	HOWTO (R_SPARC_UA32, 0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_UA32", false,0,0x00000000,true),
252b5132 RH	109	};
	110
	111	/* Read a NetWare sparc reloc. */
	112
42ef282f NC	113	struct nlm32_sparc_reloc_ext
	114	{
	115	unsigned char offset[4];
	116	unsigned char addend[4];
	117	unsigned char type[1];
	118	unsigned char pad1[3];
	119	};
252b5132 RH	120
	121	static boolean
	122	nlm_sparc_read_reloc (abfd, sym, secp, rel)
	123	bfd *abfd;
5f771d47	124	nlmNAME(symbol_type) *sym ATTRIBUTE_UNUSED;
252b5132 RH	125	asection **secp;
	126	arelent *rel;
	127	{
	128	bfd_vma val, addend;
	129	unsigned int index;
	130	unsigned int type;
	131	struct nlm32_sparc_reloc_ext tmp_reloc;
	132	asection code_sec, data_sec;
	133
dc810e39	134	if (bfd_bread (&tmp_reloc, (bfd_size_type) 12, abfd) != 12)
252b5132 RH	135	return false;
	136
	137	code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	138	data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	139
	140	*secp = code_sec;
	141
	142	val = bfd_get_32 (abfd, tmp_reloc.offset);
	143	addend = bfd_get_32 (abfd, tmp_reloc.addend);
	144	type = bfd_get_8 (abfd, tmp_reloc.type);
	145
	146	rel->address = val;
	147	rel->addend = addend;
	148	rel->howto = NULL;
	149
	150	for (index = 0;
1518639e	151	index < sizeof (nlm32_sparc_howto_table) / sizeof (reloc_howto_type);
252b5132	152	index++)
42ef282f NC	153	if (nlm32_sparc_howto_table[index].type == type)
	154	{
	155	rel->howto = &nlm32_sparc_howto_table[index];
	156	break;
	157	}
252b5132 RH	158
	159	#ifdef DEBUG
	160	fprintf (stderr, "%s: address = %08lx, addend = %08lx, type = %d, howto = %08lx\n",
	161	__FUNCTION__, rel->address, rel->addend, type, rel->howto);
	162	#endif
	163	return true;
	164
	165	}
	166
	167	/* Write a NetWare sparc reloc. */
	168
	169	static boolean
	170	nlm_sparc_write_reloc (abfd, sec, rel)
	171	bfd *abfd;
	172	asection *sec;
	173	arelent *rel;
	174	{
	175	bfd_vma val;
	176	struct nlm32_sparc_reloc_ext tmp_reloc;
	177	unsigned int index;
	178	int type = -1;
	179	reloc_howto_type *tmp;
	180
252b5132	181	for (index = 0;
1518639e	182	index < sizeof (nlm32_sparc_howto_table) / sizeof (reloc_howto_type);
42ef282f NC	183	index++)
	184	{
	185	tmp = &nlm32_sparc_howto_table[index];
	186
	187	if (tmp->rightshift == rel->howto->rightshift
	188	&& tmp->size == rel->howto->size
	189	&& tmp->bitsize == rel->howto->bitsize
	190	&& tmp->pc_relative == rel->howto->pc_relative
	191	&& tmp->bitpos == rel->howto->bitpos
	192	&& tmp->src_mask == rel->howto->src_mask
	193	&& tmp->dst_mask == rel->howto->dst_mask)
	194	{
	195	type = tmp->type;
	196	break;
	197	}
252b5132	198	}
252b5132	199	if (type == -1)
1518639e	200	abort ();
252b5132	201
42ef282f NC	202	/* Netware wants a list of relocs for each address.
	203	Format is:
	204	long offset
	205	long addend
	206	char type
	207	That should be it. */
252b5132 RH	208
	209	/* The value we write out is the offset into the appropriate
	210	segment. This offset is the section vma, adjusted by the vma of
	211	the lowest section in that segment, plus the address of the
	212	relocation. */
	213	#if 0
	214	val = bfd_get_section_vma (abfd, (*rel->sym_ptr_ptr)->section) + rel->address;
	215	#else
	216	val = bfd_get_section_vma (abfd, sec) + rel->address;
	217	#endif
	218
	219	#ifdef DEBUG
	220	fprintf (stderr, "%s: val = %08lx, addend = %08lx, type = %d\n",
	221	__FUNCTION__, val, rel->addend, rel->howto->type);
	222	#endif
	223	bfd_put_32 (abfd, val, tmp_reloc.offset);
	224	bfd_put_32 (abfd, rel->addend, tmp_reloc.addend);
1518639e	225	bfd_put_8 (abfd, (short) (rel->howto->type), tmp_reloc.type);
252b5132	226
dc810e39	227	if (bfd_bwrite (&tmp_reloc, (bfd_size_type) 12, abfd) != 12)
252b5132 RH	228	return false;
	229
	230	return true;
	231	}
	232
	233	/* Mangle relocs for SPARC NetWare. We can just use the standard
	234	SPARC relocs. */
	235
	236	static boolean
	237	nlm_sparc_mangle_relocs (abfd, sec, data, offset, count)
5f771d47 ILT	238	bfd *abfd ATTRIBUTE_UNUSED;
	239	asection *sec ATTRIBUTE_UNUSED;
	240	PTR data ATTRIBUTE_UNUSED;
	241	bfd_vma offset ATTRIBUTE_UNUSED;
	242	bfd_size_type count ATTRIBUTE_UNUSED;
252b5132 RH	243	{
	244	return true;
	245	}
	246
42ef282f NC	247	/* Read a NetWare sparc import record. */
42ef282f NC	248
252b5132 RH	249	static boolean
	250	nlm_sparc_read_import (abfd, sym)
	251	bfd *abfd;
	252	nlmNAME(symbol_type) *sym;
	253	{
42ef282f NC	254	struct nlm_relent nlm_relocs; / Relocation records for symbol. */
	255	bfd_size_type rcount; /* Number of relocs. */
	256	bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Temporary 32-bit value. */
	257	unsigned char symlength; /* Length of symbol name. */
252b5132	258	char *name;
1518639e	259
42ef282f NC	260	/* First, read in the number of relocation
42ef282f NC	261	entries for this symbol. */
dc810e39	262	if (bfd_bread ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
252b5132	263	return false;
1518639e	264
252b5132	265	rcount = bfd_get_32 (abfd, temp);
1518639e	266
42ef282f	267	/* Next, read in the length of the symbol. */
1518639e	268
dc810e39	269	if (bfd_bread ((PTR) &symlength, (bfd_size_type) sizeof (symlength), abfd)
252b5132 RH	270	!= sizeof (symlength))
	271	return false;
	272	sym -> symbol.the_bfd = abfd;
dc810e39	273	name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
252b5132 RH	274	if (name == NULL)
252b5132 RH	275	return false;
1518639e	276
42ef282f	277	/* Then read in the symbol. */
1518639e	278
dc810e39	279	if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
252b5132 RH	280	return false;
	281	name[symlength] = '\0';
	282	sym -> symbol.name = name;
	283	sym -> symbol.flags = 0;
	284	sym -> symbol.value = 0;
	285	sym -> symbol.section = bfd_und_section_ptr;
1518639e	286
42ef282f	287	/* Next, start reading in the relocs. */
1518639e	288
252b5132 RH	289	nlm_relocs = ((struct nlm_relent *)
	290	bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
	291	if (!nlm_relocs)
	292	return false;
	293	sym -> relocs = nlm_relocs;
	294	sym -> rcnt = 0;
	295	while (sym -> rcnt < rcount)
	296	{
	297	asection *section;
1518639e	298
252b5132 RH	299	if (nlm_sparc_read_reloc (abfd, sym, &section,
	300	&nlm_relocs -> reloc)
	301	== false)
	302	return false;
	303	nlm_relocs -> section = section;
	304	nlm_relocs++;
	305	sym -> rcnt++;
	306	}
42ef282f	307
252b5132 RH	308	return true;
	309	}
	310
	311	static boolean
	312	nlm_sparc_write_import (abfd, sec, rel)
	313	bfd *abfd;
	314	asection *sec;
	315	arelent *rel;
	316	{
	317	char temp[4];
	318	asection code, data, bss, symsec;
	319	bfd_vma base;
	320
	321	code = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	322	data = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	323	bss = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
	324	symsec = (*rel->sym_ptr_ptr)->section;
	325
42ef282f	326	if (symsec == code)
252b5132	327	base = 0;
42ef282f	328	else if (symsec == data)
252b5132	329	base = bfd_section_size (abfd, code);
42ef282f	330	else if (symsec == bss)
252b5132	331	base = bfd_section_size (abfd, code) + bfd_section_size (abfd, data);
42ef282f	332	else
252b5132 RH	333	base = 0;
	334
	335	#ifdef DEBUG
	336	fprintf (stderr, "%s: <%x, 1>\n\t",
	337	__FUNCTION__, base + (*rel->sym_ptr_ptr)->value);
	338	#endif
	339	bfd_put_32 (abfd, base + (*rel->sym_ptr_ptr)->value, temp);
dc810e39	340	if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
252b5132	341	return false;
dc810e39 AM	342	bfd_put_32 (abfd, (bfd_vma) 1, temp);
dc810e39 AM	343	if (bfd_bwrite ((PTR) temp, (bfd_size_type) 4, abfd) != 4)
252b5132 RH	344	return false;
	345	if (nlm_sparc_write_reloc (abfd, sec, rel) == false)
	346	return false;
	347	return true;
	348	}
	349
	350	/* Write out an external reference. */
	351
	352	static boolean
	353	nlm_sparc_write_external (abfd, count, sym, relocs)
	354	bfd *abfd;
	355	bfd_size_type count;
	356	asymbol *sym;
	357	struct reloc_and_sec *relocs;
	358	{
	359	unsigned int i;
	360	bfd_byte len;
	361	unsigned char temp[NLM_TARGET_LONG_SIZE];
	362
	363	bfd_put_32 (abfd, count, temp);
dc810e39	364	if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
252b5132 RH	365	return false;
	366
	367	len = strlen (sym->name);
dc810e39 AM	368	if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
	369	!= sizeof (bfd_byte))
	370	\|\| bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
252b5132 RH	371	return false;
	372
	373	for (i = 0; i < count; i++)
	374	{
	375	if (nlm_sparc_write_reloc (abfd, relocs[i].sec,
	376	relocs[i].rel) == false)
	377	return false;
	378	}
	379
	380	return true;
	381	}
	382
	383	static boolean
	384	nlm_sparc_write_export (abfd, sym, value)
	385	bfd *abfd;
	386	asymbol *sym;
	387	bfd_vma value;
	388	{
	389	bfd_byte len;
	390	bfd_byte temp[4];
	391
	392	#ifdef DEBUG
	393	fprintf (stderr, "%s: <%x, %d, %s>\n",
	394	__FUNCTION__, value, strlen (sym->name), sym->name);
	395	#endif
	396	bfd_put_32 (abfd, value, temp);
	397	len = strlen (sym->name);
	398
dc810e39 AM	399	if (bfd_bwrite (temp, (bfd_size_type) 4, abfd) != 4
	400	\|\| bfd_bwrite (&len, (bfd_size_type) 1, abfd) != 1
	401	\|\| bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
252b5132 RH	402	return false;
	403
	404	return true;
	405	}
	406
	407	#undef nlm_swap_fixed_header_in
	408	#undef nlm_swap_fixed_header_out
	409
	410	#include "nlmswap.h"
	411
	412	static const struct nlm_backend_data nlm32_sparc_backend =
42ef282f NC	413	{
	414	"NetWare SPARC Module \032",
	415	sizeof (Nlm32_sparc_External_Fixed_Header),
	416	0, /* optional_prefix_size */
	417	bfd_arch_sparc,
	418	0,
	419	false,
	420	0, /* backend_object_p */
	421	0, /* write_prefix_func */
	422	nlm_sparc_read_reloc,
	423	nlm_sparc_mangle_relocs,
	424	nlm_sparc_read_import,
	425	nlm_sparc_write_import,
	426	0, /* set_public_section */
	427	0, /* get_public_offset */
	428	nlm_swap_fixed_header_in,
	429	nlm_swap_fixed_header_out,
	430	nlm_sparc_write_external,
	431	nlm_sparc_write_export
	432	};
252b5132 RH	433
	434	#define TARGET_BIG_NAME "nlm32-sparc"
	435	#define TARGET_BIG_SYM nlmNAME(sparc_vec)
42ef282f	436	#define TARGET_BACKEND_DATA & nlm32_sparc_backend
252b5132 RH	437
252b5132 RH	438	#include "nlm-target.h"