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

/* Support for 32-bit i386 NLM (NetWare Loadable Module)
   Copyright 1993, 1994, 2000, 2001, 2002 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/i386-ext.h"
#define Nlm_External_Fixed_Header	Nlm32_i386_External_Fixed_Header

#include "libnlm.h"

static bfd_boolean nlm_i386_read_reloc
  PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
static bfd_boolean nlm_i386_write_import
  PARAMS ((bfd *, asection *, arelent *));
static bfd_boolean nlm_i386_mangle_relocs
  PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
static bfd_boolean nlm_i386_read_import
  PARAMS ((bfd *, nlmNAME(symbol_type) *));
static bfd_boolean nlm_i386_write_external
  PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *));

/* Adjust the reloc location by an absolute value.  */

static reloc_howto_type nlm_i386_abs_howto =
  HOWTO (0,			/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 0,			/* special_function */
	 "32",			/* name */
	 TRUE,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 FALSE);		/* pcrel_offset */

/* Adjust the reloc location by a PC relative displacement.  */

static reloc_howto_type nlm_i386_pcrel_howto =
  HOWTO (1,			/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 0,			/* special_function */
	 "DISP32",		/* name */
	 TRUE,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 TRUE);			/* pcrel_offset */

/* Read a NetWare i386 reloc.  */

static bfd_boolean
nlm_i386_read_reloc (abfd, sym, secp, rel)
     bfd *abfd;
     nlmNAME(symbol_type) *sym;
     asection **secp;
     arelent *rel;
{
  bfd_byte temp[4];
  bfd_vma val;
  const char *name;

  if (bfd_bread (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return FALSE;

  val = bfd_get_32 (abfd, temp);

  /* The value is an offset into either the code or data segment.
     This is the location which needs to be adjusted.

     If this is a relocation fixup rather than an imported symbol (the
     sym argument is NULL) then the high bit is 0 if the location
     needs to be adjusted by the address of the data segment, or 1 if
     the location needs to be adjusted by the address of the code
     segment.  If this is an imported symbol, then the high bit is 0
     if the location is 0 if the location should be adjusted by the
     offset to the symbol, or 1 if the location should adjusted by the
     absolute value of the symbol.

     The second most significant bit is 0 if the value is an offset
     into the data segment, or 1 if the value is an offset into the
     code segment.

     All this translates fairly easily into a BFD reloc.  */

  if (sym == NULL)
    {
      if ((val & NLM_HIBIT) == 0)
	name = NLM_INITIALIZED_DATA_NAME;
      else
	{
	  name = NLM_CODE_NAME;
	  val &=~ NLM_HIBIT;
	}
      rel->sym_ptr_ptr = bfd_get_section_by_name (abfd, name)->symbol_ptr_ptr;
      rel->howto = &nlm_i386_abs_howto;
    }
  else
    {
      /* In this case we do not need to set the sym_ptr_ptr field.  */
      rel->sym_ptr_ptr = NULL;
      if ((val & NLM_HIBIT) == 0)
	rel->howto = &nlm_i386_pcrel_howto;
      else
	{
	  rel->howto = &nlm_i386_abs_howto;
	  val &=~ NLM_HIBIT;
	}
    }

  if ((val & (NLM_HIBIT >> 1)) == 0)
    *secp = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
  else
    {
      *secp = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
      val &=~ (NLM_HIBIT >> 1);
    }

  rel->address = val;
  rel->addend = 0;

  return TRUE;
}

/* Write a NetWare i386 reloc.  */

static bfd_boolean
nlm_i386_write_import (abfd, sec, rel)
     bfd *abfd;
     asection *sec;
     arelent *rel;
{
  asymbol *sym;
  bfd_vma val;
  bfd_byte temp[4];

  /* NetWare only supports two kinds of relocs.  We should check
     special_function here, as well, but at the moment coff-i386
     relocs uses a special_function which does not affect what we do
     here.  */
  if (rel->addend != 0
      || rel->howto == NULL
      || rel->howto->rightshift != 0
      || rel->howto->size != 2
      || rel->howto->bitsize != 32
      || rel->howto->bitpos != 0
      || rel->howto->src_mask != 0xffffffff
      || rel->howto->dst_mask != 0xffffffff)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
    }

  sym = *rel->sym_ptr_ptr;

  /* 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.  */
  val = bfd_get_section_vma (abfd, sec) + rel->address;

  /* The second most significant bit is 0 if the value is an offset
     into the data segment, or 1 if the value is an offset into the
     code segment.  */
  if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
    {
      val -= nlm_get_text_low (abfd);
      val |= NLM_HIBIT >> 1;
    }
  else
    val -= nlm_get_data_low (abfd);

  if (! bfd_is_und_section (bfd_get_section (sym)))
    {
      /* NetWare only supports absolute internal relocs.  */
      if (rel->howto->pc_relative)
	{
	  bfd_set_error (bfd_error_invalid_operation);
	  return FALSE;
	}

      /* The high bit is 1 if the reloc is against the code section, 0
	 if against the data section.  */
      if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
	val |= NLM_HIBIT;
    }
  else
    {
      /* The high bit is 1 if this is an absolute reloc, 0 if it is PC
	 relative.  */
      if (! rel->howto->pc_relative)
	val |= NLM_HIBIT;
      else
	{
	  /* PC relative relocs on NetWare must be pcrel_offset.  */
	  if (! rel->howto->pcrel_offset)
	    {
	      bfd_set_error (bfd_error_invalid_operation);
	      return FALSE;
	    }
	}
    }

  bfd_put_32 (abfd, val, temp);
  if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
    return FALSE;

  return TRUE;
}

/* I want to be able to use objcopy to turn an i386 a.out or COFF file
   into a NetWare i386 module.  That means that the relocs from the
   source file have to be mapped into relocs that apply to the target
   file.  This function is called by nlm_set_section_contents to give
   it a chance to rework the relocs.

   This is actually a fairly general concept.  However, this is not a
   general implementation.  */

static bfd_boolean
nlm_i386_mangle_relocs (abfd, sec, data, offset, count)
     bfd *abfd;
     asection *sec;
     PTR data;
     bfd_vma offset;
     bfd_size_type count;
{
  arelent **rel_ptr_ptr, **rel_end;

  rel_ptr_ptr = sec->orelocation;
  rel_end = rel_ptr_ptr + sec->reloc_count;
  for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
    {
      arelent *rel;
      asymbol *sym;
      bfd_vma addend;

      rel = *rel_ptr_ptr;
      sym = *rel->sym_ptr_ptr;

      /* Note that no serious harm will ensue if we fail to change a
	 reloc.  We will wind up failing in nlm_i386_write_import.  */

      /* Make sure this reloc is within the data we have.  We only 4
	 byte relocs here, so we insist on having 4 bytes.  */
      if (rel->address < offset
	  || rel->address + 4 > offset + count)
	continue;

      /* NetWare doesn't support reloc addends, so we get rid of them
	 here by simply adding them into the object data.  We handle
	 the symbol value, if any, the same way.  */
      addend = rel->addend + sym->value;

      /* The value of a symbol is the offset into the section.  If the
	 symbol is in the .bss segment, we need to include the size of
	 the data segment in the offset as well.  Fortunately, we know
	 that at this point the size of the data section is in the NLM
	 header.  */
      if (((bfd_get_section_flags (abfd, bfd_get_section (sym))
	    & SEC_LOAD) == 0)
	  && ((bfd_get_section_flags (abfd, bfd_get_section (sym))
	       & SEC_ALLOC) != 0))
	addend += nlm_fixed_header (abfd)->dataImageSize;

      if (addend != 0
	  && rel->howto != NULL
	  && rel->howto->rightshift == 0
	  && rel->howto->size == 2
	  && rel->howto->bitsize == 32
	  && rel->howto->bitpos == 0
	  && rel->howto->src_mask == 0xffffffff
	  && rel->howto->dst_mask == 0xffffffff)
	{
	  bfd_vma val;

	  val = bfd_get_32 (abfd, (bfd_byte *) data + rel->address - offset);
	  val += addend;
	  bfd_put_32 (abfd, val, (bfd_byte *) data + rel->address - offset);
	  rel->addend = 0;
	}

      /* NetWare uses a reloc with pcrel_offset set.  We adjust
	 pc_relative relocs accordingly.  We are going to change the
	 howto field, so we can only do this if the current one is
	 compatible.  We should check special_function here, but at
	 the moment coff-i386 uses a special_function which does not
	 affect what we are doing here.  */
      if (rel->howto != NULL
	  && rel->howto->pc_relative
	  && ! rel->howto->pcrel_offset
	  && rel->howto->rightshift == 0
	  && rel->howto->size == 2
	  && rel->howto->bitsize == 32
	  && rel->howto->bitpos == 0
	  && rel->howto->src_mask == 0xffffffff
	  && rel->howto->dst_mask == 0xffffffff)
	{
	  bfd_vma val;

	  /* When pcrel_offset is not set, it means that the negative
	     of the address of the memory location is stored in the
	     memory location.  We must add it back in.  */
	  val = bfd_get_32 (abfd, (bfd_byte *) data + rel->address - offset);
	  val += rel->address;
	  bfd_put_32 (abfd, val, (bfd_byte *) data + rel->address - offset);

	  rel->howto = &nlm_i386_pcrel_howto;
	}
    }

  return TRUE;
}

/* Read a NetWare i386 import record */
static bfd_boolean
nlm_i386_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;

  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;
  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;
  if (bfd_bread ((PTR) temp, (bfd_size_type) sizeof (temp), abfd)
      != sizeof (temp))
    return FALSE;
  rcount = H_GET_32 (abfd, temp);
  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_i386_read_reloc (abfd, sym, &section, &nlm_relocs -> reloc))
	return FALSE;
      nlm_relocs -> section = section;
      nlm_relocs++;
      sym -> rcnt++;
    }
  return TRUE;
}

/* Write out an external reference.  */

static bfd_boolean
nlm_i386_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];

  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;

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

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

  return TRUE;
}

#include "nlmswap.h"

static const struct nlm_backend_data nlm32_i386_backend =
{
  "NetWare Loadable Module\032",
  sizeof (Nlm32_i386_External_Fixed_Header),
  0,	/* optional_prefix_size */
  bfd_arch_i386,
  0,
  FALSE,
  0,	/* backend_object_p */
  0,	/* write_prefix_func */
  nlm_i386_read_reloc,
  nlm_i386_mangle_relocs,
  nlm_i386_read_import,
  nlm_i386_write_import,
  0,	/* set_public_section */
  0,	/* get_public_offset */
  nlm_swap_fixed_header_in,
  nlm_swap_fixed_header_out,
  nlm_i386_write_external,
  0,	/* write_export */
};

#define TARGET_LITTLE_NAME		"nlm32-i386"
#define TARGET_LITTLE_SYM		nlmNAME(i386_vec)
#define TARGET_BACKEND_DATA		&nlm32_i386_backend

#include "nlm-target.h"
Commit	Line	Data
	1	/* Support for 32-bit i386 NLM (NetWare Loadable Module)
	2	Copyright 1993, 1994, 2000, 2001, 2002 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20	#include "bfd.h"
	21	#include "sysdep.h"
	22	#include "libbfd.h"
	23
	24	#define ARCH_SIZE 32
	25
	26	#include "nlm/i386-ext.h"
	27	#define Nlm_External_Fixed_Header Nlm32_i386_External_Fixed_Header
	28
	29	#include "libnlm.h"
	30
	31	static bfd_boolean nlm_i386_read_reloc
	32	PARAMS ((bfd , nlmNAME(symbol_type) , asection *, arelent ));
	33	static bfd_boolean nlm_i386_write_import
	34	PARAMS ((bfd , asection , arelent *));
	35	static bfd_boolean nlm_i386_mangle_relocs
	36	PARAMS ((bfd , asection , PTR, bfd_vma, bfd_size_type));
	37	static bfd_boolean nlm_i386_read_import
	38	PARAMS ((bfd , nlmNAME(symbol_type) ));
	39	static bfd_boolean nlm_i386_write_external
	40	PARAMS ((bfd , bfd_size_type, asymbol , struct reloc_and_sec *));
	41
	42	/* Adjust the reloc location by an absolute value. */
	43
	44	static reloc_howto_type nlm_i386_abs_howto =
	45	HOWTO (0, /* type */
	46	0, /* rightshift */
	47	2, /* size (0 = byte, 1 = short, 2 = long) */
	48	32, /* bitsize */
	49	FALSE, /* pc_relative */
	50	0, /* bitpos */
	51	complain_overflow_bitfield, /* complain_on_overflow */
	52	0, /* special_function */
	53	"32", /* name */
	54	TRUE, /* partial_inplace */
	55	0xffffffff, /* src_mask */
	56	0xffffffff, /* dst_mask */
	57	FALSE); /* pcrel_offset */
	58
	59	/* Adjust the reloc location by a PC relative displacement. */
	60
	61	static reloc_howto_type nlm_i386_pcrel_howto =
	62	HOWTO (1, /* type */
	63	0, /* rightshift */
	64	2, /* size (0 = byte, 1 = short, 2 = long) */
	65	32, /* bitsize */
	66	TRUE, /* pc_relative */
	67	0, /* bitpos */
	68	complain_overflow_signed, /* complain_on_overflow */
	69	0, /* special_function */
	70	"DISP32", /* name */
	71	TRUE, /* partial_inplace */
	72	0xffffffff, /* src_mask */
	73	0xffffffff, /* dst_mask */
	74	TRUE); /* pcrel_offset */
	75
	76	/* Read a NetWare i386 reloc. */
	77
	78	static bfd_boolean
	79	nlm_i386_read_reloc (abfd, sym, secp, rel)
	80	bfd *abfd;
	81	nlmNAME(symbol_type) *sym;
	82	asection **secp;
	83	arelent *rel;
	84	{
	85	bfd_byte temp[4];
	86	bfd_vma val;
	87	const char *name;
	88
	89	if (bfd_bread (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
	90	return FALSE;
	91
	92	val = bfd_get_32 (abfd, temp);
	93
	94	/* The value is an offset into either the code or data segment.
	95	This is the location which needs to be adjusted.
	96
	97	If this is a relocation fixup rather than an imported symbol (the
	98	sym argument is NULL) then the high bit is 0 if the location
	99	needs to be adjusted by the address of the data segment, or 1 if
	100	the location needs to be adjusted by the address of the code
	101	segment. If this is an imported symbol, then the high bit is 0
	102	if the location is 0 if the location should be adjusted by the
	103	offset to the symbol, or 1 if the location should adjusted by the
	104	absolute value of the symbol.
	105
	106	The second most significant bit is 0 if the value is an offset
	107	into the data segment, or 1 if the value is an offset into the
	108	code segment.
	109
	110	All this translates fairly easily into a BFD reloc. */
	111
	112	if (sym == NULL)
	113	{
	114	if ((val & NLM_HIBIT) == 0)
	115	name = NLM_INITIALIZED_DATA_NAME;
	116	else
	117	{
	118	name = NLM_CODE_NAME;
	119	val &=~ NLM_HIBIT;
	120	}
	121	rel->sym_ptr_ptr = bfd_get_section_by_name (abfd, name)->symbol_ptr_ptr;
	122	rel->howto = &nlm_i386_abs_howto;
	123	}
	124	else
	125	{
	126	/* In this case we do not need to set the sym_ptr_ptr field. */
	127	rel->sym_ptr_ptr = NULL;
	128	if ((val & NLM_HIBIT) == 0)
	129	rel->howto = &nlm_i386_pcrel_howto;
	130	else
	131	{
	132	rel->howto = &nlm_i386_abs_howto;
	133	val &=~ NLM_HIBIT;
	134	}
	135	}
	136
	137	if ((val & (NLM_HIBIT >> 1)) == 0)
	138	*secp = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	139	else
	140	{
	141	*secp = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	142	val &=~ (NLM_HIBIT >> 1);
	143	}
	144
	145	rel->address = val;
	146	rel->addend = 0;
	147
	148	return TRUE;
	149	}
	150
	151	/* Write a NetWare i386 reloc. */
	152
	153	static bfd_boolean
	154	nlm_i386_write_import (abfd, sec, rel)
	155	bfd *abfd;
	156	asection *sec;
	157	arelent *rel;
	158	{
	159	asymbol *sym;
	160	bfd_vma val;
	161	bfd_byte temp[4];
	162
	163	/* NetWare only supports two kinds of relocs. We should check
	164	special_function here, as well, but at the moment coff-i386
	165	relocs uses a special_function which does not affect what we do
	166	here. */
	167	if (rel->addend != 0
	168	\|\| rel->howto == NULL
	169	\|\| rel->howto->rightshift != 0
	170	\|\| rel->howto->size != 2
	171	\|\| rel->howto->bitsize != 32
	172	\|\| rel->howto->bitpos != 0
	173	\|\| rel->howto->src_mask != 0xffffffff
	174	\|\| rel->howto->dst_mask != 0xffffffff)
	175	{
	176	bfd_set_error (bfd_error_invalid_operation);
	177	return FALSE;
	178	}
	179
	180	sym = *rel->sym_ptr_ptr;
	181
	182	/* The value we write out is the offset into the appropriate
	183	segment. This offset is the section vma, adjusted by the vma of
	184	the lowest section in that segment, plus the address of the
	185	relocation. */
	186	val = bfd_get_section_vma (abfd, sec) + rel->address;
	187
	188	/* The second most significant bit is 0 if the value is an offset
	189	into the data segment, or 1 if the value is an offset into the
	190	code segment. */
	191	if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
	192	{
	193	val -= nlm_get_text_low (abfd);
	194	val \|= NLM_HIBIT >> 1;
	195	}
	196	else
	197	val -= nlm_get_data_low (abfd);
	198
	199	if (! bfd_is_und_section (bfd_get_section (sym)))
	200	{
	201	/* NetWare only supports absolute internal relocs. */
	202	if (rel->howto->pc_relative)
	203	{
	204	bfd_set_error (bfd_error_invalid_operation);
	205	return FALSE;
	206	}
	207
	208	/* The high bit is 1 if the reloc is against the code section, 0
	209	if against the data section. */
	210	if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
	211	val \|= NLM_HIBIT;
	212	}
	213	else
	214	{
	215	/* The high bit is 1 if this is an absolute reloc, 0 if it is PC
	216	relative. */
	217	if (! rel->howto->pc_relative)
	218	val \|= NLM_HIBIT;
	219	else
	220	{
	221	/* PC relative relocs on NetWare must be pcrel_offset. */
	222	if (! rel->howto->pcrel_offset)
	223	{
	224	bfd_set_error (bfd_error_invalid_operation);
	225	return FALSE;
	226	}
	227	}
	228	}
	229
	230	bfd_put_32 (abfd, val, temp);
	231	if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
	232	return FALSE;
	233
	234	return TRUE;
	235	}
	236
	237	/* I want to be able to use objcopy to turn an i386 a.out or COFF file
	238	into a NetWare i386 module. That means that the relocs from the
	239	source file have to be mapped into relocs that apply to the target
	240	file. This function is called by nlm_set_section_contents to give
	241	it a chance to rework the relocs.
	242
	243	This is actually a fairly general concept. However, this is not a
	244	general implementation. */
	245
	246	static bfd_boolean
	247	nlm_i386_mangle_relocs (abfd, sec, data, offset, count)
	248	bfd *abfd;
	249	asection *sec;
	250	PTR data;
	251	bfd_vma offset;
	252	bfd_size_type count;
	253	{
	254	arelent rel_ptr_ptr, rel_end;
	255
	256	rel_ptr_ptr = sec->orelocation;
	257	rel_end = rel_ptr_ptr + sec->reloc_count;
	258	for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
	259	{
	260	arelent *rel;
	261	asymbol *sym;
	262	bfd_vma addend;
	263
	264	rel = *rel_ptr_ptr;
	265	sym = *rel->sym_ptr_ptr;
	266
	267	/* Note that no serious harm will ensue if we fail to change a
	268	reloc. We will wind up failing in nlm_i386_write_import. */
	269
	270	/* Make sure this reloc is within the data we have. We only 4
	271	byte relocs here, so we insist on having 4 bytes. */
	272	if (rel->address < offset
	273	\|\| rel->address + 4 > offset + count)
	274	continue;
	275
	276	/* NetWare doesn't support reloc addends, so we get rid of them
	277	here by simply adding them into the object data. We handle
	278	the symbol value, if any, the same way. */
	279	addend = rel->addend + sym->value;
	280
	281	/* The value of a symbol is the offset into the section. If the
	282	symbol is in the .bss segment, we need to include the size of
	283	the data segment in the offset as well. Fortunately, we know
	284	that at this point the size of the data section is in the NLM
	285	header. */
	286	if (((bfd_get_section_flags (abfd, bfd_get_section (sym))
	287	& SEC_LOAD) == 0)
	288	&& ((bfd_get_section_flags (abfd, bfd_get_section (sym))
	289	& SEC_ALLOC) != 0))
	290	addend += nlm_fixed_header (abfd)->dataImageSize;
	291
	292	if (addend != 0
	293	&& rel->howto != NULL
	294	&& rel->howto->rightshift == 0
	295	&& rel->howto->size == 2
	296	&& rel->howto->bitsize == 32
	297	&& rel->howto->bitpos == 0
	298	&& rel->howto->src_mask == 0xffffffff
	299	&& rel->howto->dst_mask == 0xffffffff)
	300	{
	301	bfd_vma val;
	302
	303	val = bfd_get_32 (abfd, (bfd_byte *) data + rel->address - offset);
	304	val += addend;
	305	bfd_put_32 (abfd, val, (bfd_byte *) data + rel->address - offset);
	306	rel->addend = 0;
	307	}
	308
	309	/* NetWare uses a reloc with pcrel_offset set. We adjust
	310	pc_relative relocs accordingly. We are going to change the
	311	howto field, so we can only do this if the current one is
	312	compatible. We should check special_function here, but at
	313	the moment coff-i386 uses a special_function which does not
	314	affect what we are doing here. */
	315	if (rel->howto != NULL
	316	&& rel->howto->pc_relative
	317	&& ! rel->howto->pcrel_offset
	318	&& rel->howto->rightshift == 0
	319	&& rel->howto->size == 2
	320	&& rel->howto->bitsize == 32
	321	&& rel->howto->bitpos == 0
	322	&& rel->howto->src_mask == 0xffffffff
	323	&& rel->howto->dst_mask == 0xffffffff)
	324	{
	325	bfd_vma val;
	326
	327	/* When pcrel_offset is not set, it means that the negative
	328	of the address of the memory location is stored in the
	329	memory location. We must add it back in. */
	330	val = bfd_get_32 (abfd, (bfd_byte *) data + rel->address - offset);
	331	val += rel->address;
	332	bfd_put_32 (abfd, val, (bfd_byte *) data + rel->address - offset);
	333
	334	rel->howto = &nlm_i386_pcrel_howto;
	335	}
	336	}
	337
	338	return TRUE;
	339	}
	340
	341	/* Read a NetWare i386 import record */
	342	static bfd_boolean
	343	nlm_i386_read_import (abfd, sym)
	344	bfd *abfd;
	345	nlmNAME(symbol_type) *sym;
	346	{
	347	struct nlm_relent nlm_relocs; / relocation records for symbol */
	348	bfd_size_type rcount; /* number of relocs */
	349	bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* temporary 32-bit value */
	350	unsigned char symlength; /* length of symbol name */
	351	char *name;
	352
	353	if (bfd_bread ((PTR) &symlength, (bfd_size_type) sizeof (symlength), abfd)
	354	!= sizeof (symlength))
	355	return FALSE;
	356	sym -> symbol.the_bfd = abfd;
	357	name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
	358	if (name == NULL)
	359	return FALSE;
	360	if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
	361	return FALSE;
	362	name[symlength] = '\0';
	363	sym -> symbol.name = name;
	364	sym -> symbol.flags = 0;
	365	sym -> symbol.value = 0;
	366	sym -> symbol.section = bfd_und_section_ptr;
	367	if (bfd_bread ((PTR) temp, (bfd_size_type) sizeof (temp), abfd)
	368	!= sizeof (temp))
	369	return FALSE;
	370	rcount = H_GET_32 (abfd, temp);
	371	nlm_relocs = ((struct nlm_relent *)
	372	bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
	373	if (!nlm_relocs)
	374	return FALSE;
	375	sym -> relocs = nlm_relocs;
	376	sym -> rcnt = 0;
	377	while (sym -> rcnt < rcount)
	378	{
	379	asection *section;
	380
	381	if (! nlm_i386_read_reloc (abfd, sym, &section, &nlm_relocs -> reloc))
	382	return FALSE;
	383	nlm_relocs -> section = section;
	384	nlm_relocs++;
	385	sym -> rcnt++;
	386	}
	387	return TRUE;
	388	}
	389
	390	/* Write out an external reference. */
	391
	392	static bfd_boolean
	393	nlm_i386_write_external (abfd, count, sym, relocs)
	394	bfd *abfd;
	395	bfd_size_type count;
	396	asymbol *sym;
	397	struct reloc_and_sec *relocs;
	398	{
	399	unsigned int i;
	400	bfd_byte len;
	401	unsigned char temp[NLM_TARGET_LONG_SIZE];
	402
	403	len = strlen (sym->name);
	404	if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
	405	!= sizeof (bfd_byte))
	406	\|\| bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
	407	return FALSE;
	408
	409	bfd_put_32 (abfd, count, temp);
	410	if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
	411	return FALSE;
	412
	413	for (i = 0; i < count; i++)
	414	{
	415	if (! nlm_i386_write_import (abfd, relocs[i].sec, relocs[i].rel))
	416	return FALSE;
	417	}
	418
	419	return TRUE;
	420	}
	421
	422	#include "nlmswap.h"
	423
	424	static const struct nlm_backend_data nlm32_i386_backend =
	425	{
	426	"NetWare Loadable Module\032",
	427	sizeof (Nlm32_i386_External_Fixed_Header),
	428	0, /* optional_prefix_size */
	429	bfd_arch_i386,
	430	0,
	431	FALSE,
	432	0, /* backend_object_p */
	433	0, /* write_prefix_func */
	434	nlm_i386_read_reloc,
	435	nlm_i386_mangle_relocs,
	436	nlm_i386_read_import,
	437	nlm_i386_write_import,
	438	0, /* set_public_section */
	439	0, /* get_public_offset */
	440	nlm_swap_fixed_header_in,
	441	nlm_swap_fixed_header_out,
	442	nlm_i386_write_external,
	443	0, /* write_export */
	444	};
	445
	446	#define TARGET_LITTLE_NAME "nlm32-i386"
	447	#define TARGET_LITTLE_SYM nlmNAME(i386_vec)
	448	#define TARGET_BACKEND_DATA &nlm32_i386_backend
	449
	450	#include "nlm-target.h"