[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_vma val, addend;
  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)
    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)
    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))
    return false;
  sym -> symbol.the_bfd = abfd;
  sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
  if (!sym -> symbol.name)
    {
      bfd_set_error (bfd_error_no_memory);
      return false;
    }
  
  /*
   * Then read in the symbol
   */
  
  if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
      != symlength)
    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_set_error (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))
    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)
    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)
    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	{
cdbfad1c	125	bfd_vma val, addend;
cdbfad1c ILT	126	int index;
	127	unsigned int type;
	128	struct nlm32_sparc_reloc_ext tmp_reloc;
df561b14	129	asection code_sec, data_sec;
cdbfad1c	130
25057836	131	if (bfd_read (&tmp_reloc, 12, 1, abfd) != 12)
cdbfad1c	132	return false;
cdbfad1c	133
df561b14 SEF	134	code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	135	data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	136
	137	*secp = code_sec;
cdbfad1c ILT	138
	139	val = bfd_get_32 (abfd, tmp_reloc.offset);
	140	addend = bfd_get_32 (abfd, tmp_reloc.addend);
	141	type = bfd_get_8 (abfd, tmp_reloc.type);
	142
	143	rel->address = val;
	144	rel->addend = addend;
	145	rel->howto = NULL;
	146
	147	for (index = 0;
	148	index < sizeof(nlm32_sparc_howto_table) / sizeof(reloc_howto_type);
	149	index++)
	150	if (nlm32_sparc_howto_table[index].type == type) {
	151	rel->howto = &nlm32_sparc_howto_table[index];
	152	break;
	153	}
	154
	155	#ifdef DEBUG
	156	fprintf (stderr, "%s: address = %08lx, addend = %08lx, type = %d, howto = %08lx\n",
df561b14	157	__FUNCTION__, rel->address, rel->addend, type, rel->howto);
cdbfad1c ILT	158	#endif
	159	return true;
	160
	161	}
	162
	163	/* Write a NetWare sparc reloc. */
	164
	165	static boolean
	166	nlm_sparc_write_reloc (abfd, sec, rel)
	167	bfd *abfd;
	168	asection *sec;
	169	arelent *rel;
	170	{
	171	bfd_vma val;
9783e04a	172	struct nlm32_sparc_reloc_ext tmp_reloc;
cdbfad1c ILT	173	int index;
	174	int type = -1;
	175	reloc_howto_type *tmp;
	176
	177
	178	for (index = 0;
	179	index < sizeof (nlm32_sparc_howto_table) / sizeof(reloc_howto_type);
	180	index++) {
	181	tmp = &nlm32_sparc_howto_table[index];
	182
	183	if (tmp->rightshift == rel->howto->rightshift
	184	&& tmp->size == rel->howto->size
	185	&& tmp->bitsize == rel->howto->bitsize
	186	&& tmp->pc_relative == rel->howto->pc_relative
	187	&& tmp->bitpos == rel->howto->bitpos
	188	&& tmp->src_mask == rel->howto->src_mask
	189	&& tmp->dst_mask == rel->howto->dst_mask) {
	190	type = tmp->type;
	191	break;
	192	}
	193	}
	194	if (type == -1)
	195	abort();
	196
	197	/*
	198	* Netware wants a list of relocs for each address.
	199	* Format is:
	200	* long offset
	201	* long addend
	202	* char type
	203	* That should be it.
	204	*/
	205
	206	/* The value we write out is the offset into the appropriate
	207	segment. This offset is the section vma, adjusted by the vma of
	208	the lowest section in that segment, plus the address of the
	209	relocation. */
df561b14 SEF	210	#if 0
	211	val = bfd_get_section_vma (abfd, (*rel->sym_ptr_ptr)->section) + rel->address;
	212	#else
cdbfad1c	213	val = bfd_get_section_vma (abfd, sec) + rel->address;
df561b14	214	#endif
cdbfad1c ILT	215
	216	#ifdef DEBUG
	217	fprintf (stderr, "%s: val = %08lx, addend = %08lx, type = %d\n",
df561b14	218	__FUNCTION__, val, rel->addend, rel->howto->type);
cdbfad1c ILT	219	#endif
	220	bfd_put_32 (abfd, val, tmp_reloc.offset);
	221	bfd_put_32 (abfd, rel->addend, tmp_reloc.addend);
	222	bfd_put_8 (abfd, (short)(rel->howto->type), tmp_reloc.type);
	223
	224	if (bfd_write (&tmp_reloc, 12, 1, abfd) != 12)
	225	{
	226	abort();
	227	}
	228
	229	return true;
	230	}
	231
	232	/* Mangle relocs for SPARC NetWare. We can just use the standard
	233	SPARC relocs. */
	234
	235	static boolean
	236	nlm_sparc_mangle_relocs (abfd, sec, data, offset, count)
	237	bfd *abfd;
	238	asection *sec;
	239	PTR data;
	240	bfd_vma offset;
	241	bfd_size_type count;
	242	{
	243	return true;
	244	}
	245
	246	/* Read a NetWare sparc import record */
	247	static boolean
	248	nlm_sparc_read_import (abfd, sym)
	249	bfd *abfd;
	250	nlmNAME(symbol_type) *sym;
	251	{
	252	struct nlm_relent nlm_relocs; / relocation records for symbol */
	253	bfd_size_type rcount; /* number of relocs */
	254	bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* temporary 32-bit value */
	255	unsigned char symlength; /* length of symbol name */
	256
	257	/*
	258	* First, read in the number of relocation
	259	* entries for this symbol
	260	*/
25057836 JL	261	if (bfd_read ((PTR) temp, 4, 1, abfd) != 4)
25057836 JL	262	return false;
cdbfad1c ILT	263
	264	rcount = bfd_get_32 (abfd, temp);
	265
	266	/*
	267	* Next, read in the length of the symbol
	268	*/
	269
	270	if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
	271	!= sizeof (symlength))
25057836	272	return false;
cdbfad1c ILT	273	sym -> symbol.the_bfd = abfd;
cdbfad1c ILT	274	sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
9783e04a DM	275	if (!sym -> symbol.name)
9783e04a DM	276	{
25057836	277	bfd_set_error (bfd_error_no_memory);
9783e04a DM	278	return false;
9783e04a DM	279	}
cdbfad1c ILT	280
	281	/*
	282	* Then read in the symbol
	283	*/
	284
	285	if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
	286	!= symlength)
25057836	287	return false;
cdbfad1c ILT	288	sym -> symbol.flags = 0;
	289	sym -> symbol.value = 0;
	290	sym -> symbol.section = &bfd_und_section;
	291
	292	/*
	293	* Next, start reading in the relocs.
	294	*/
	295
	296	nlm_relocs = ((struct nlm_relent *)
	297	bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
9783e04a DM	298	if (!nlm_relocs)
9783e04a DM	299	{
25057836	300	bfd_set_error (bfd_error_no_memory);
9783e04a DM	301	return false;
9783e04a DM	302	}
cdbfad1c ILT	303	sym -> relocs = nlm_relocs;
	304	sym -> rcnt = 0;
	305	while (sym -> rcnt < rcount)
	306	{
	307	asection *section;
	308
	309	if (nlm_sparc_read_reloc (abfd, sym, &section,
	310	&nlm_relocs -> reloc)
	311	== false)
	312	return false;
	313	nlm_relocs -> section = section;
	314	nlm_relocs++;
	315	sym -> rcnt++;
	316	}
	317	return true;
	318	}
	319
	320	static boolean
	321	nlm_sparc_write_import (abfd, sec, rel)
	322	bfd *abfd;
	323	asection *sec;
	324	arelent *rel;
	325	{
	326	char temp[4];
df561b14 SEF	327	asection code, data, bss, symsec;
	328	bfd_vma base;
	329
	330	code = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	331	data = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	332	bss = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
	333	symsec = (*rel->sym_ptr_ptr)->section;
	334
	335	if (symsec == code) {
	336	base = 0;
	337	} else if (symsec == data) {
	338	base = bfd_section_size (abfd, code);
	339	} else if (symsec == bss) {
	340	base = bfd_section_size (abfd, code) + bfd_section_size (abfd, data);
	341	} else
	342	base = 0;
cdbfad1c	343
df561b14 SEF	344	#ifdef DEBUG
	345	fprintf (stderr, "%s: <%x, 1>\n\t",
	346	__FUNCTION__, base + (*rel->sym_ptr_ptr)->value);
	347	#endif
	348	bfd_put_32 (abfd, base + (*rel->sym_ptr_ptr)->value, temp);
cdbfad1c ILT	349	bfd_write ((PTR)temp, 4, 1, abfd);
	350	bfd_put_32 (abfd, 1, temp);
	351	bfd_write ((PTR)temp, 4, 1, abfd);
	352	if (nlm_sparc_write_reloc (abfd, sec, rel) == false)
	353	return false;
	354	return true;
	355	}
	356
	357	/* Write out an external reference. */
	358
	359	static boolean
	360	nlm_sparc_write_external (abfd, count, sym, relocs)
	361	bfd *abfd;
	362	bfd_size_type count;
	363	asymbol *sym;
	364	struct reloc_and_sec *relocs;
	365	{
	366	int i;
	367	bfd_byte len;
	368	unsigned char temp[NLM_TARGET_LONG_SIZE];
	369
	370	bfd_put_32 (abfd, count, temp);
	371	if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
25057836	372	return false;
cdbfad1c ILT	373
	374	len = strlen (sym->name);
	375	if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
	376	\|\| bfd_write (sym->name, len, 1, abfd) != len)
25057836	377	return false;
cdbfad1c ILT	378
	379	for (i = 0; i < count; i++)
	380	{
	381	if (nlm_sparc_write_reloc (abfd, relocs[i].sec,
	382	relocs[i].rel) == false)
	383	return false;
	384	}
	385
	386	return true;
	387	}
	388
df561b14 SEF	389	static boolean
	390	nlm_sparc_write_export (abfd, sym, value)
	391	bfd *abfd;
	392	asymbol *sym;
	393	bfd_vma value;
	394	{
	395	bfd_byte len;
	396	bfd_byte temp[4];
	397
	398	#ifdef DEBUG
	399	fprintf (stderr, "%s: <%x, %d, %s>\n",
	400	__FUNCTION__, value, strlen (sym->name), sym->name);
	401	#endif
	402	bfd_put_32 (abfd, value, temp);
	403	len = strlen (sym->name);
	404
	405	if (bfd_write (temp, 4, 1, abfd) != 4
	406	\|\| bfd_write (&len, 1, 1, abfd) != 1
	407	\|\| bfd_write (sym->name, len, 1, abfd) != len)
25057836	408	return false;
df561b14 SEF	409
	410	return true;
	411	}
	412
cdbfad1c ILT	413	#undef nlm_swap_fixed_header_in
	414	#undef nlm_swap_fixed_header_out
	415
	416	#include "nlmswap.h"
	417
	418	static const struct nlm_backend_data nlm32_sparc_backend =
	419	{
	420	"NetWare SPARC Module \032",
	421	sizeof (Nlm32_sparc_External_Fixed_Header),
	422	0, /* optional_prefix_size */
	423	bfd_arch_sparc,
	424	0,
df561b14	425	false,
cdbfad1c ILT	426	0, /* backend_object_p */
	427	0, /* write_prefix_func */
	428	nlm_sparc_read_reloc,
	429	nlm_sparc_mangle_relocs,
	430	nlm_sparc_read_import,
	431	nlm_sparc_write_import,
	432	0, /* set_public_section */
	433	0, /* get_public_offset */
	434	nlm_swap_fixed_header_in,
	435	nlm_swap_fixed_header_out,
	436	nlm_sparc_write_external,
df561b14	437	nlm_sparc_write_export
cdbfad1c ILT	438	};
	439
	440	#define TARGET_BIG_NAME "nlm32-sparc"
	441	#define TARGET_BIG_SYM nlmNAME(sparc_vec)
	442	#define TARGET_BACKEND_DATA &nlm32_sparc_backend
	443
	444	#include "nlm-target.h"