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

/* Support for 32-bit i386 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 "libnlm.h"

static boolean nlm_i386_read_reloc
  PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
static boolean nlm_i386_write_reloc
  PARAMS ((bfd *, asection *, arelent *));
static boolean nlm_i386_mangle_relocs
  PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));

/* 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 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_read (temp, sizeof (temp), 1, abfd) != sizeof (temp))
    {
      bfd_error = system_call_error;
      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 boolean
nlm_i386_write_reloc (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->partial_inplace
      || rel->howto->src_mask != 0xffffffff
      || rel->howto->dst_mask != 0xffffffff)
    {
      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_get_section (sym) != &bfd_und_section)
    {
      /* NetWare only supports absolute internal relocs.  */
      if (rel->howto->pc_relative)
	{
	  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_error = invalid_operation;
	      return false;
	    }
	}
    }
  
  bfd_put_32 (abfd, val, temp);
  if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
    {
      bfd_error = system_call_error;
      return false;
    }

  return true;
}

/* I want to be able to use objcopy to turn a 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 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_reloc.  */

      /* 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_CODE | SEC_DATA)) == 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->partial_inplace
	  && rel->howto->src_mask == 0xffffffff
	  && rel->howto->dst_mask == 0xffffffff)
	{
	  bfd_vma val;

	  val = bfd_get_32 (abfd, (char *) data + rel->address - offset);
	  val += addend;
	  bfd_put_32 (abfd, val, (char *) 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->partial_inplace
	  && 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, (char *) data + rel->address - offset);
	  val += rel->address;
	  bfd_put_32 (abfd, val, (char *) data + rel->address - offset);

	  rel->howto = &nlm_i386_pcrel_howto;
	}
    }

  return true;
}

static const struct nlm_backend_data nlm32_i386_backend =
{
  bfd_arch_i386,
  nlm_i386_read_reloc,
  nlm_i386_write_reloc,
  nlm_i386_mangle_relocs
};

#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
7389debf ILT	1	/* Support for 32-bit i386 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	#include "libnlm.h"
	26
	27	static boolean nlm_i386_read_reloc
	28	PARAMS ((bfd , nlmNAME(symbol_type) , asection *, arelent ));
	29	static boolean nlm_i386_write_reloc
	30	PARAMS ((bfd , asection , arelent *));
	31	static boolean nlm_i386_mangle_relocs
	32	PARAMS ((bfd , asection , PTR, bfd_vma, bfd_size_type));
	33
	34	/* Adjust the reloc location by an absolute value. */
	35
	36	static reloc_howto_type nlm_i386_abs_howto =
	37	HOWTO (0, /* type */
	38	0, /* rightshift */
	39	2, /* size (0 = byte, 1 = short, 2 = long) */
	40	32, /* bitsize */
	41	false, /* pc_relative */
	42	0, /* bitpos */
	43	complain_overflow_bitfield, /* complain_on_overflow */
	44	0, /* special_function */
	45	"32", /* name */
	46	true, /* partial_inplace */
	47	0xffffffff, /* src_mask */
	48	0xffffffff, /* dst_mask */
	49	false); /* pcrel_offset */
	50
	51	/* Adjust the reloc location by a PC relative displacement. */
	52
	53	static reloc_howto_type nlm_i386_pcrel_howto =
	54	HOWTO (1, /* type */
	55	0, /* rightshift */
	56	2, /* size (0 = byte, 1 = short, 2 = long) */
	57	32, /* bitsize */
	58	true, /* pc_relative */
	59	0, /* bitpos */
	60	complain_overflow_signed, /* complain_on_overflow */
	61	0, /* special_function */
	62	"DISP32", /* name */
	63	true, /* partial_inplace */
	64	0xffffffff, /* src_mask */
65	0xffffffff, /* dst_mask */
66	true); /* pcrel_offset */
67
68	/* Read a NetWare i386 reloc. */
69
70	static boolean
71	nlm_i386_read_reloc (abfd, sym, secp, rel)
72	bfd *abfd;
73	nlmNAME(symbol_type) *sym;
74	asection **secp;
75	arelent *rel;
76	{
77	bfd_byte temp[4];
78	bfd_vma val;
79	const char *name;
80
81	if (bfd_read (temp, sizeof (temp), 1, abfd) != sizeof (temp))
82	{
83	bfd_error = system_call_error;
84	return false;
85	}
86
87	val = bfd_get_32 (abfd, temp);
88
89	/* The value is an offset into either the code or data segment.
90	This is the location which needs to be adjusted.
91
92	If this is a relocation fixup rather than an imported symbol (the
93	sym argument is NULL) then the high bit is 0 if the location
94	needs to be adjusted by the address of the data segment, or 1 if
95	the location needs to be adjusted by the address of the code
96	segment. If this is an imported symbol, then the high bit is 0
97	if the location is 0 if the location should be adjusted by the
98	offset to the symbol, or 1 if the location should adjusted by the
99	absolute value of the symbol.
100
101	The second most significant bit is 0 if the value is an offset
102	into the data segment, or 1 if the value is an offset into the
103	code segment.
104
105	All this translates fairly easily into a BFD reloc. */
106
107	if (sym == NULL)
108	{
109	if ((val & NLM_HIBIT) == 0)
110	name = NLM_INITIALIZED_DATA_NAME;
111	else
112	{
113	name = NLM_CODE_NAME;
114	val &=~ NLM_HIBIT;
115	}
116	rel->sym_ptr_ptr = bfd_get_section_by_name (abfd, name)->symbol_ptr_ptr;
117	rel->howto = &nlm_i386_abs_howto;
118	}
119	else
120	{
121	/* In this case we do not need to set the sym_ptr_ptr field. */
122	rel->sym_ptr_ptr = NULL;
123	if ((val & NLM_HIBIT) == 0)
124	rel->howto = &nlm_i386_pcrel_howto;
125	else
126	{
127	rel->howto = &nlm_i386_abs_howto;
128	val &=~ NLM_HIBIT;
129	}
130	}
131
132	if ((val & (NLM_HIBIT >> 1)) == 0)
133	*secp = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
134	else
135	{
136	*secp = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
137	val &=~ (NLM_HIBIT >> 1);
138	}
139
140	rel->address = val;
141	rel->addend = 0;
142
143	return true;
144	}
145
146	/* Write a NetWare i386 reloc. */
147
148	static boolean
149	nlm_i386_write_reloc (abfd, sec, rel)
150	bfd *abfd;
151	asection *sec;
152	arelent *rel;
153	{
154	asymbol *sym;
155	bfd_vma val;
156	bfd_byte temp[4];
157
158	/* NetWare only supports two kinds of relocs. We should check
159	special_function here, as well, but at the moment coff-i386
160	relocs uses a special_function which does not affect what we do
161	here. */
162	if (rel->addend != 0
163	\|\| rel->howto == NULL
164	\|\| rel->howto->rightshift != 0
165	\|\| rel->howto->size != 2
166	\|\| rel->howto->bitsize != 32
167	\|\| rel->howto->bitpos != 0
168	\|\| ! rel->howto->partial_inplace
169	\|\| rel->howto->src_mask != 0xffffffff
170	\|\| rel->howto->dst_mask != 0xffffffff)
171	{
172	bfd_error = invalid_operation;
173	return false;
174	}
175
176	sym = *rel->sym_ptr_ptr;
177
178	/* The value we write out is the offset into the appropriate
179	segment. This offset is the section vma, adjusted by the vma of
180	the lowest section in that segment, plus the address of the
181	relocation. */
182	val = bfd_get_section_vma (abfd, sec) + rel->address;
183
184	/* The second most significant bit is 0 if the value is an offset
185	into the data segment, or 1 if the value is an offset into the
186	code segment. */
187	if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
188	{
189	val -= nlm_get_text_low (abfd);
190	val \|= NLM_HIBIT >> 1;
191	}
192	else
193	val -= nlm_get_data_low (abfd);
194
195	if (bfd_get_section (sym) != &bfd_und_section)
196	{
197	/* NetWare only supports absolute internal relocs. */
198	if (rel->howto->pc_relative)
199	{
200	bfd_error = invalid_operation;
201	return false;
202	}
203
204	/* The high bit is 1 if the reloc is against the code section, 0
205	if against the data section. */
206	if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
207	val \|= NLM_HIBIT;
208	}
209	else
210	{
211	/* The high bit is 1 if this is an absolute reloc, 0 if it is PC
212	relative. */
213	if (! rel->howto->pc_relative)
214	val \|= NLM_HIBIT;
215	else
216	{
217	/* PC relative relocs on NetWare must be pcrel_offset. */
218	if (! rel->howto->pcrel_offset)
219	{
220	bfd_error = invalid_operation;
221	return false;
222	}
223	}
224	}
225
226	bfd_put_32 (abfd, val, temp);
227	if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
228	{
229	bfd_error = system_call_error;
230	return false;
231	}
232
233	return true;
234	}
235
236	/* I want to be able to use objcopy to turn a i386 a.out or COFF file
237	into a NetWare i386 module. That means that the relocs from the
238	source file have to be mapped into relocs that apply to the target
239	file. This function is called by nlm_set_section_contents to give
240	it a chance to rework the relocs.
241
242	This is actually a fairly general concept. However, this is not a
243	general implementation. */
244
245	static boolean
246	nlm_i386_mangle_relocs (abfd, sec, data, offset, count)
247	bfd *abfd;
248	asection *sec;
249	PTR data;
250	bfd_vma offset;
251	bfd_size_type count;
252	{
253	arelent rel_ptr_ptr, rel_end;
254
255	rel_ptr_ptr = sec->orelocation;
256	rel_end = rel_ptr_ptr + sec->reloc_count;
257	for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
258	{
259	arelent *rel;
260	asymbol *sym;
261	bfd_vma addend;
262
263	rel = *rel_ptr_ptr;
264	sym = *rel->sym_ptr_ptr;
265
266	/* Note that no serious harm will ensue if we fail to change a
267	reloc. We will wind up failing in nlm_i386_write_reloc. */
268
269	/* Make sure this reloc is within the data we have. We only 4
270	byte relocs here, so we insist on having 4 bytes. */
271	if (rel->address < offset
272	\|\| rel->address + 4 > offset + count)
273	continue;
274
275	/* NetWare doesn't support reloc addends, so we get rid of them
276	here by simply adding them into the object data. We handle
277	the symbol value, if any, the same way. */
278	addend = rel->addend + sym->value;
279
280	/* The value of a symbol is the offset into the section. If the
281	symbol is in the .bss segment, we need to include the size of
282	the data segment in the offset as well. Fortunately, we know
283	that at this point the size of the data section is in the NLM
284	header. */
285	if (((bfd_get_section_flags (abfd, bfd_get_section (sym))
286	& (SEC_CODE \| SEC_DATA)) == 0)
287	&& ((bfd_get_section_flags (abfd, bfd_get_section (sym))
288	& SEC_ALLOC) != 0))
289	addend += nlm_fixed_header (abfd)->dataImageSize;
290
291	if (addend != 0
292	&& rel->howto != NULL
293	&& rel->howto->rightshift == 0
294	&& rel->howto->size == 2
295	&& rel->howto->bitsize == 32
296	&& rel->howto->bitpos == 0
297	&& rel->howto->partial_inplace
298	&& rel->howto->src_mask == 0xffffffff
299	&& rel->howto->dst_mask == 0xffffffff)
300	{
301	bfd_vma val;
302
303	val = bfd_get_32 (abfd, (char *) data + rel->address - offset);
304	val += addend;
305	bfd_put_32 (abfd, val, (char *) 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->partial_inplace
323	&& rel->howto->src_mask == 0xffffffff
324	&& rel->howto->dst_mask == 0xffffffff)
325	{
326	bfd_vma val;
327
328	/* When pcrel_offset is not set, it means that the negative
329	of the address of the memory location is stored in the
330	memory location. We must add it back in. */
331	val = bfd_get_32 (abfd, (char *) data + rel->address - offset);
332	val += rel->address;
333	bfd_put_32 (abfd, val, (char *) data + rel->address - offset);
334
335	rel->howto = &nlm_i386_pcrel_howto;
336	}
337	}
338
339	return true;
340	}
341
342	static const struct nlm_backend_data nlm32_i386_backend =
343	{
344	bfd_arch_i386,
345	nlm_i386_read_reloc,
346	nlm_i386_write_reloc,
347	nlm_i386_mangle_relocs
348	};
349
350	#define TARGET_LITTLE_NAME "nlm32-i386"
351	#define TARGET_LITTLE_SYM nlmNAME(i386_vec)
352	#define TARGET_BACKEND_DATA &nlm32_i386_backend
353
354	#include "nlm-target.h"