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

/* Support for 32-bit SPARC NLM (NetWare Loadable Module)
   Copyright (C) 1993 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., 675 Mass Ave, Cambridge, MA 02139, 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 *));

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;
     asection **secp;
     arelent *rel;
{
  bfd_byte temp[4];
  bfd_vma val, addend;
  const char *name;
  int index;
  unsigned int type;
  struct nlm32_sparc_reloc_ext tmp_reloc;
  asection *code_sec, *data_sec;

  if (bfd_read (&tmp_reloc, 12, 1, abfd) != 12) {
    bfd_error = system_call_error;
    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;
  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_write (&tmp_reloc, 12, 1, abfd) != 12)
    {
      abort();
    }

  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;
     asection *sec;
     PTR data;
     bfd_vma offset;
     bfd_size_type count;
{
  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 */
  
  /*
   * First, read in the number of relocation
   * entries for this symbol
   */
  if (bfd_read ((PTR) temp, 4, 1, abfd)
      != 4)
    {
      bfd_error = system_call_error;
      return (false);
    }
  
  rcount = bfd_get_32 (abfd, temp);
  
  /*
   * Next, read in the length of the symbol
   */
  
  if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
      != sizeof (symlength))
    {
      bfd_error = system_call_error;
      return (false);
    }
  sym -> symbol.the_bfd = abfd;
  sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
  if (!sym -> symbol.name)
    {
      bfd_error = no_memory;
      return false;
    }
  
  /*
   * Then read in the symbol
   */
  
  if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
      != symlength)
    {
      bfd_error = system_call_error;
      return (false);
    }
  sym -> symbol.flags = 0;
  sym -> symbol.value = 0;
  sym -> symbol.section = &bfd_und_section;
  
  /*
   * Next, start reading in the relocs.
   */
  
  nlm_relocs = ((struct nlm_relent *)
		bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
  if (!nlm_relocs)
    {
      bfd_error = no_memory;
      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);
  bfd_write ((PTR)temp, 4, 1, abfd);
  bfd_put_32 (abfd, 1, temp);
  bfd_write ((PTR)temp, 4, 1, abfd);
  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;
{
  int i;
  bfd_byte len;
  unsigned char temp[NLM_TARGET_LONG_SIZE];

  bfd_put_32 (abfd, count, temp);
  if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
    {
      bfd_error = system_call_error;
      return false;
    }

  len = strlen (sym->name);
  if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
      || bfd_write (sym->name, len, 1, abfd) != len)
    {
      bfd_error = system_call_error;
      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_write (temp, 4, 1, abfd) != 4
      || bfd_write (&len, 1, 1, abfd) != 1
      || bfd_write (sym->name, len, 1, abfd) != len)
    {
      bfd_error = system_call_error;
      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
cdbfad1c ILT	1	/* Support for 32-bit SPARC NLM (NetWare Loadable Module)
	2	Copyright (C) 1993 Free Software Foundation, Inc.
	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
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	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 *));
	43
	44	enum reloc_type
	45	{
	46	R_SPARC_NONE = 0,
	47	R_SPARC_8, R_SPARC_16, R_SPARC_32,
	48	R_SPARC_DISP8, R_SPARC_DISP16, R_SPARC_DISP32,
	49	R_SPARC_WDISP30, R_SPARC_WDISP22,
	50	R_SPARC_HI22, R_SPARC_22,
	51	R_SPARC_13, R_SPARC_LO10,
	52	R_SPARC_GOT10, R_SPARC_GOT13, R_SPARC_GOT22,
	53	R_SPARC_PC10, R_SPARC_PC22,
	54	R_SPARC_WPLT30,
	55	R_SPARC_COPY,
	56	R_SPARC_GLOB_DAT, R_SPARC_JMP_SLOT,
	57	R_SPARC_RELATIVE,
	58	R_SPARC_UA32,
	59	R_SPARC_max
	60	};
	61
	62	#if 0
	63	static CONST char *CONST reloc_type_names[] =
	64	{
65	"R_SPARC_NONE",
66	"R_SPARC_8", "R_SPARC_16", "R_SPARC_32",
67	"R_SPARC_DISP8", "R_SPARC_DISP16", "R_SPARC_DISP32",
68	"R_SPARC_WDISP30", "R_SPARC_WDISP22",
69	"R_SPARC_HI22", "R_SPARC_22",
70	"R_SPARC_13", "R_SPARC_LO10",
71	"R_SPARC_GOT10", "R_SPARC_GOT13", "R_SPARC_GOT22",
72	"R_SPARC_PC10", "R_SPARC_PC22",
73	"R_SPARC_WPLT30",
74	"R_SPARC_COPY",
75	"R_SPARC_GLOB_DAT", "R_SPARC_JMP_SLOT",
76	"R_SPARC_RELATIVE",
77	"R_SPARC_UA32",
78	};
79	#endif
80
81	static reloc_howto_type nlm32_sparc_howto_table[] =
82	{
83	HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, 0,"R_SPARC_NONE", false,0,0x00000000,true),
84	HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,0,"R_SPARC_8", false,0,0x000000ff,true),
85	HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,0,"R_SPARC_16", false,0,0x0000ffff,true),
86	HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,0,"R_SPARC_32", false,0,0xffffffff,true),
87	HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, 0,"R_SPARC_DISP8", false,0,0x000000ff,true),
88	HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, 0,"R_SPARC_DISP16", false,0,0x0000ffff,true),
89	HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, 0,"R_SPARC_DISP32", false,0,0x00ffffff,true),
90	HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, 0,"R_SPARC_WDISP30", false,0,0x3fffffff,true),
91	HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, 0,"R_SPARC_WDISP22", false,0,0x003fffff,true),
92	HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, 0,"R_SPARC_HI22", false,0,0x003fffff,true),
93	HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_22", false,0,0x003fffff,true),
94	HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_13", false,0,0x00001fff,true),
95	HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, 0,"R_SPARC_LO10", false,0,0x000003ff,true),
96	HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT10", false,0,0x000003ff,true),
97	HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT13", false,0,0x00001fff,true),
98	HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT22", false,0,0x003fffff,true),
99	HOWTO(R_SPARC_PC10, 0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_PC10", false,0,0x000003ff,true),
100	HOWTO(R_SPARC_PC22, 0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_PC22", false,0,0x003fffff,true),
101	HOWTO(R_SPARC_WPLT30, 0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_WPLT30", false,0,0x00000000,true),
102	HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_COPY", false,0,0x00000000,true),
103	HOWTO(R_SPARC_GLOB_DAT,0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_GLOB_DAT",false,0,0x00000000,true),
104	HOWTO(R_SPARC_JMP_SLOT,0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_JMP_SLOT",false,0,0x00000000,true),
105	HOWTO(R_SPARC_RELATIVE,0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_RELATIVE",false,0,0x00000000,true),
106	HOWTO(R_SPARC_UA32, 0,0,00,false,0,complain_overflow_dont, 0,"R_SPARC_UA32", false,0,0x00000000,true),
107	};
108
109	/* Read a NetWare sparc reloc. */
110
111	struct nlm32_sparc_reloc_ext {
112	unsigned char offset[4];
113	unsigned char addend[4];
114	unsigned char type[1];
115	unsigned char pad1[3];
116	};
117
118	static boolean
119	nlm_sparc_read_reloc (abfd, sym, secp, rel)
120	bfd *abfd;
121	nlmNAME(symbol_type) *sym;
122	asection **secp;
123	arelent *rel;
124	{
125	bfd_byte temp[4];
126	bfd_vma val, addend;
127	const char *name;
128	int index;
129	unsigned int type;
130	struct nlm32_sparc_reloc_ext tmp_reloc;
df561b14	131	asection code_sec, data_sec;
cdbfad1c ILT	132
	133	if (bfd_read (&tmp_reloc, 12, 1, abfd) != 12) {
	134	bfd_error = system_call_error;
	135	return false;
	136	}
	137
df561b14 SEF	138	code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	139	data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	140
	141	*secp = code_sec;
cdbfad1c ILT	142
	143	val = bfd_get_32 (abfd, tmp_reloc.offset);
	144	addend = bfd_get_32 (abfd, tmp_reloc.addend);
	145	type = bfd_get_8 (abfd, tmp_reloc.type);
	146
	147	rel->address = val;
	148	rel->addend = addend;
	149	rel->howto = NULL;
	150
	151	for (index = 0;
	152	index < sizeof(nlm32_sparc_howto_table) / sizeof(reloc_howto_type);
	153	index++)
	154	if (nlm32_sparc_howto_table[index].type == type) {
	155	rel->howto = &nlm32_sparc_howto_table[index];
	156	break;
	157	}
	158
	159	#ifdef DEBUG
	160	fprintf (stderr, "%s: address = %08lx, addend = %08lx, type = %d, howto = %08lx\n",
df561b14	161	__FUNCTION__, rel->address, rel->addend, type, rel->howto);
cdbfad1c ILT	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;
9783e04a	176	struct nlm32_sparc_reloc_ext tmp_reloc;
cdbfad1c ILT	177	int index;
	178	int type = -1;
	179	reloc_howto_type *tmp;
	180
	181
	182	for (index = 0;
	183	index < sizeof (nlm32_sparc_howto_table) / sizeof(reloc_howto_type);
	184	index++) {
	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	type = tmp->type;
	195	break;
	196	}
	197	}
	198	if (type == -1)
	199	abort();
	200
	201	/*
	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.
	208	*/
	209
	210	/* The value we write out is the offset into the appropriate
	211	segment. This offset is the section vma, adjusted by the vma of
	212	the lowest section in that segment, plus the address of the
	213	relocation. */
df561b14 SEF	214	#if 0
	215	val = bfd_get_section_vma (abfd, (*rel->sym_ptr_ptr)->section) + rel->address;
	216	#else
cdbfad1c	217	val = bfd_get_section_vma (abfd, sec) + rel->address;
df561b14	218	#endif
cdbfad1c ILT	219
	220	#ifdef DEBUG
	221	fprintf (stderr, "%s: val = %08lx, addend = %08lx, type = %d\n",
df561b14	222	__FUNCTION__, val, rel->addend, rel->howto->type);
cdbfad1c ILT	223	#endif
	224	bfd_put_32 (abfd, val, tmp_reloc.offset);
	225	bfd_put_32 (abfd, rel->addend, tmp_reloc.addend);
	226	bfd_put_8 (abfd, (short)(rel->howto->type), tmp_reloc.type);
	227
	228	if (bfd_write (&tmp_reloc, 12, 1, abfd) != 12)
	229	{
	230	abort();
	231	}
	232
	233	return true;
	234	}
	235
	236	/* Mangle relocs for SPARC NetWare. We can just use the standard
	237	SPARC relocs. */
	238
	239	static boolean
	240	nlm_sparc_mangle_relocs (abfd, sec, data, offset, count)
	241	bfd *abfd;
	242	asection *sec;
	243	PTR data;
	244	bfd_vma offset;
	245	bfd_size_type count;
	246	{
	247	return true;
	248	}
	249
	250	/* Read a NetWare sparc import record */
	251	static boolean
	252	nlm_sparc_read_import (abfd, sym)
	253	bfd *abfd;
	254	nlmNAME(symbol_type) *sym;
	255	{
	256	struct nlm_relent nlm_relocs; / relocation records for symbol */
	257	bfd_size_type rcount; /* number of relocs */
	258	bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* temporary 32-bit value */
	259	unsigned char symlength; /* length of symbol name */
	260
	261	/*
	262	* First, read in the number of relocation
	263	* entries for this symbol
	264	*/
	265	if (bfd_read ((PTR) temp, 4, 1, abfd)
	266	!= 4)
	267	{
	268	bfd_error = system_call_error;
	269	return (false);
	270	}
	271
	272	rcount = bfd_get_32 (abfd, temp);
	273
	274	/*
	275	* Next, read in the length of the symbol
	276	*/
	277
	278	if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
	279	!= sizeof (symlength))
	280	{
	281	bfd_error = system_call_error;
	282	return (false);
	283	}
	284	sym -> symbol.the_bfd = abfd;
	285	sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
9783e04a DM	286	if (!sym -> symbol.name)
	287	{
	288	bfd_error = no_memory;
	289	return false;
	290	}
cdbfad1c ILT	291
	292	/*
	293	* Then read in the symbol
	294	*/
	295
	296	if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
	297	!= symlength)
	298	{
	299	bfd_error = system_call_error;
	300	return (false);
	301	}
	302	sym -> symbol.flags = 0;
	303	sym -> symbol.value = 0;
	304	sym -> symbol.section = &bfd_und_section;
	305
	306	/*
	307	* Next, start reading in the relocs.
	308	*/
	309
	310	nlm_relocs = ((struct nlm_relent *)
	311	bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
9783e04a DM	312	if (!nlm_relocs)
	313	{
	314	bfd_error = no_memory;
	315	return false;
	316	}
cdbfad1c ILT	317	sym -> relocs = nlm_relocs;
	318	sym -> rcnt = 0;
	319	while (sym -> rcnt < rcount)
	320	{
	321	asection *section;
	322
	323	if (nlm_sparc_read_reloc (abfd, sym, &section,
	324	&nlm_relocs -> reloc)
	325	== false)
	326	return false;
	327	nlm_relocs -> section = section;
	328	nlm_relocs++;
	329	sym -> rcnt++;
	330	}
	331	return true;
	332	}
	333
	334	static boolean
	335	nlm_sparc_write_import (abfd, sec, rel)
	336	bfd *abfd;
	337	asection *sec;
	338	arelent *rel;
	339	{
	340	char temp[4];
df561b14 SEF	341	asection code, data, bss, symsec;
	342	bfd_vma base;
	343
	344	code = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	345	data = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	346	bss = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
	347	symsec = (*rel->sym_ptr_ptr)->section;
	348
	349	if (symsec == code) {
	350	base = 0;
	351	} else if (symsec == data) {
	352	base = bfd_section_size (abfd, code);
	353	} else if (symsec == bss) {
	354	base = bfd_section_size (abfd, code) + bfd_section_size (abfd, data);
	355	} else
	356	base = 0;
cdbfad1c	357
df561b14 SEF	358	#ifdef DEBUG
	359	fprintf (stderr, "%s: <%x, 1>\n\t",
	360	__FUNCTION__, base + (*rel->sym_ptr_ptr)->value);
	361	#endif
	362	bfd_put_32 (abfd, base + (*rel->sym_ptr_ptr)->value, temp);
cdbfad1c ILT	363	bfd_write ((PTR)temp, 4, 1, abfd);
	364	bfd_put_32 (abfd, 1, temp);
	365	bfd_write ((PTR)temp, 4, 1, abfd);
	366	if (nlm_sparc_write_reloc (abfd, sec, rel) == false)
	367	return false;
	368	return true;
	369	}
	370
	371	/* Write out an external reference. */
	372
	373	static boolean
	374	nlm_sparc_write_external (abfd, count, sym, relocs)
	375	bfd *abfd;
	376	bfd_size_type count;
	377	asymbol *sym;
	378	struct reloc_and_sec *relocs;
	379	{
	380	int i;
	381	bfd_byte len;
	382	unsigned char temp[NLM_TARGET_LONG_SIZE];
	383
	384	bfd_put_32 (abfd, count, temp);
	385	if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
	386	{
	387	bfd_error = system_call_error;
	388	return false;
	389	}
	390
	391	len = strlen (sym->name);
	392	if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
	393	\|\| bfd_write (sym->name, len, 1, abfd) != len)
	394	{
	395	bfd_error = system_call_error;
	396	return false;
	397	}
	398
	399	for (i = 0; i < count; i++)
	400	{
	401	if (nlm_sparc_write_reloc (abfd, relocs[i].sec,
	402	relocs[i].rel) == false)
	403	return false;
	404	}
	405
	406	return true;
	407	}
	408
df561b14 SEF	409	static boolean
	410	nlm_sparc_write_export (abfd, sym, value)
	411	bfd *abfd;
	412	asymbol *sym;
	413	bfd_vma value;
	414	{
	415	bfd_byte len;
	416	bfd_byte temp[4];
	417
	418	#ifdef DEBUG
	419	fprintf (stderr, "%s: <%x, %d, %s>\n",
	420	__FUNCTION__, value, strlen (sym->name), sym->name);
	421	#endif
	422	bfd_put_32 (abfd, value, temp);
	423	len = strlen (sym->name);
	424
	425	if (bfd_write (temp, 4, 1, abfd) != 4
	426	\|\| bfd_write (&len, 1, 1, abfd) != 1
	427	\|\| bfd_write (sym->name, len, 1, abfd) != len)
	428	{
	429	bfd_error = system_call_error;
	430	return false;
	431	}
	432
	433	return true;
	434	}
	435
cdbfad1c ILT	436	#undef nlm_swap_fixed_header_in
	437	#undef nlm_swap_fixed_header_out
	438
	439	#include "nlmswap.h"
	440
	441	static const struct nlm_backend_data nlm32_sparc_backend =
	442	{
	443	"NetWare SPARC Module \032",
	444	sizeof (Nlm32_sparc_External_Fixed_Header),
	445	0, /* optional_prefix_size */
	446	bfd_arch_sparc,
	447	0,
df561b14	448	false,
cdbfad1c ILT	449	0, /* backend_object_p */
	450	0, /* write_prefix_func */
	451	nlm_sparc_read_reloc,
	452	nlm_sparc_mangle_relocs,
	453	nlm_sparc_read_import,
	454	nlm_sparc_write_import,
	455	0, /* set_public_section */
	456	0, /* get_public_offset */
	457	nlm_swap_fixed_header_in,
	458	nlm_swap_fixed_header_out,
	459	nlm_sparc_write_external,
df561b14	460	nlm_sparc_write_export
cdbfad1c ILT	461	};
	462
	463	#define TARGET_BIG_NAME "nlm32-sparc"
	464	#define TARGET_BIG_SYM nlmNAME(sparc_vec)
	465	#define TARGET_BACKEND_DATA &nlm32_sparc_backend
	466
	467	#include "nlm-target.h"