[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 = {0};
  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);
  
  /*
   * 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)));
  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;
	176	struct nlm32_sparc_reloc_ext tmp_reloc = {0};
	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);
	286
287	/*
288	* Then read in the symbol
289	*/
290
291	if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
292	!= symlength)
293	{
294	bfd_error = system_call_error;
295	return (false);
296	}
297	sym -> symbol.flags = 0;
298	sym -> symbol.value = 0;
299	sym -> symbol.section = &bfd_und_section;
300
301	/*
302	* Next, start reading in the relocs.
303	*/
304
305	nlm_relocs = ((struct nlm_relent *)
306	bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
307	sym -> relocs = nlm_relocs;
308	sym -> rcnt = 0;
309	while (sym -> rcnt < rcount)
310	{
311	asection *section;
312
313	if (nlm_sparc_read_reloc (abfd, sym, &section,
314	&nlm_relocs -> reloc)
315	== false)
316	return false;
317	nlm_relocs -> section = section;
318	nlm_relocs++;
319	sym -> rcnt++;
320	}
321	return true;
322	}
323
324	static boolean
325	nlm_sparc_write_import (abfd, sec, rel)
326	bfd *abfd;
327	asection *sec;
328	arelent *rel;
329	{
330	char temp[4];
df561b14 SEF	331	asection code, data, bss, symsec;
	332	bfd_vma base;
	333
	334	code = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	335	data = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	336	bss = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
	337	symsec = (*rel->sym_ptr_ptr)->section;
	338
	339	if (symsec == code) {
	340	base = 0;
	341	} else if (symsec == data) {
	342	base = bfd_section_size (abfd, code);
	343	} else if (symsec == bss) {
	344	base = bfd_section_size (abfd, code) + bfd_section_size (abfd, data);
	345	} else
	346	base = 0;
cdbfad1c	347
df561b14 SEF	348	#ifdef DEBUG
	349	fprintf (stderr, "%s: <%x, 1>\n\t",
	350	__FUNCTION__, base + (*rel->sym_ptr_ptr)->value);
	351	#endif
	352	bfd_put_32 (abfd, base + (*rel->sym_ptr_ptr)->value, temp);
cdbfad1c ILT	353	bfd_write ((PTR)temp, 4, 1, abfd);
	354	bfd_put_32 (abfd, 1, temp);
	355	bfd_write ((PTR)temp, 4, 1, abfd);
	356	if (nlm_sparc_write_reloc (abfd, sec, rel) == false)
	357	return false;
	358	return true;
	359	}
	360
	361	/* Write out an external reference. */
	362
	363	static boolean
	364	nlm_sparc_write_external (abfd, count, sym, relocs)
	365	bfd *abfd;
	366	bfd_size_type count;
	367	asymbol *sym;
	368	struct reloc_and_sec *relocs;
	369	{
	370	int i;
	371	bfd_byte len;
	372	unsigned char temp[NLM_TARGET_LONG_SIZE];
	373
	374	bfd_put_32 (abfd, count, temp);
	375	if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
	376	{
	377	bfd_error = system_call_error;
	378	return false;
	379	}
	380
	381	len = strlen (sym->name);
	382	if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
	383	\|\| bfd_write (sym->name, len, 1, abfd) != len)
	384	{
	385	bfd_error = system_call_error;
	386	return false;
	387	}
	388
	389	for (i = 0; i < count; i++)
	390	{
	391	if (nlm_sparc_write_reloc (abfd, relocs[i].sec,
	392	relocs[i].rel) == false)
	393	return false;
	394	}
	395
	396	return true;
	397	}
	398
df561b14 SEF	399	static boolean
	400	nlm_sparc_write_export (abfd, sym, value)
	401	bfd *abfd;
	402	asymbol *sym;
	403	bfd_vma value;
	404	{
	405	bfd_byte len;
	406	bfd_byte temp[4];
	407
	408	#ifdef DEBUG
	409	fprintf (stderr, "%s: <%x, %d, %s>\n",
	410	__FUNCTION__, value, strlen (sym->name), sym->name);
	411	#endif
	412	bfd_put_32 (abfd, value, temp);
	413	len = strlen (sym->name);
	414
	415	if (bfd_write (temp, 4, 1, abfd) != 4
	416	\|\| bfd_write (&len, 1, 1, abfd) != 1
	417	\|\| bfd_write (sym->name, len, 1, abfd) != len)
	418	{
	419	bfd_error = system_call_error;
	420	return false;
	421	}
	422
	423	return true;
	424	}
	425
cdbfad1c ILT	426	#undef nlm_swap_fixed_header_in
	427	#undef nlm_swap_fixed_header_out
	428
	429	#include "nlmswap.h"
	430
	431	static const struct nlm_backend_data nlm32_sparc_backend =
	432	{
	433	"NetWare SPARC Module \032",
	434	sizeof (Nlm32_sparc_External_Fixed_Header),
	435	0, /* optional_prefix_size */
	436	bfd_arch_sparc,
	437	0,
df561b14	438	false,
cdbfad1c ILT	439	0, /* backend_object_p */
	440	0, /* write_prefix_func */
	441	nlm_sparc_read_reloc,
	442	nlm_sparc_mangle_relocs,
	443	nlm_sparc_read_import,
	444	nlm_sparc_write_import,
	445	0, /* set_public_section */
	446	0, /* get_public_offset */
	447	nlm_swap_fixed_header_in,
	448	nlm_swap_fixed_header_out,
	449	nlm_sparc_write_external,
df561b14	450	nlm_sparc_write_export
cdbfad1c ILT	451	};
	452
	453	#define TARGET_BIG_NAME "nlm32-sparc"
	454	#define TARGET_BIG_SYM nlmNAME(sparc_vec)
	455	#define TARGET_BACKEND_DATA &nlm32_sparc_backend
	456
	457	#include "nlm-target.h"