[deliverable/binutils-gdb.git] / bfd / coff-go32.c

/* BFD back-end for Intel 386 COFF files (go32 variant).
   Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
   Written by DJ Delorie.

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"
#include "obstack.h"
#include "coff/i386.h"
#include "coff/internal.h"
#include "libcoff.h"

static bfd_reloc_status_type coff_go32_reloc PARAMS ((bfd *abfd,
						      arelent *reloc_entry,
						      asymbol *symbol,
						      PTR data,
						      asection *input_section,
						      bfd *output_bfd,
						      char **error_message));

/* For some reason when using i386 COFF the value stored in the .text
   section for a reference to a common symbol is the value itself plus
   any desired offset.  Ian Taylor, Cygnus Support.  */

/* If we are producing relocateable output, we need to do some
   adjustments to the object file that are not done by the
   bfd_perform_relocation function.  This function is called by every
   reloc type to make any required adjustments.  */

static bfd_reloc_status_type
coff_go32_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
		 error_message)
     bfd *abfd;
     arelent *reloc_entry;
     asymbol *symbol;
     PTR data;
     asection *input_section;
     bfd *output_bfd;
     char **error_message;
{
  symvalue diff;

  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;

  if (bfd_is_com_section (symbol->section))
    {
      /* We are relocating a common symbol.  The current value in the
	 object file is ORIG + OFFSET, where ORIG is the value of the
	 common symbol as seen by the object file when it was compiled
	 (this may be zero if the symbol was undefined) and OFFSET is
	 the offset into the common symbol (normally zero, but may be
	 non-zero when referring to a field in a common structure).
	 ORIG is the negative of reloc_entry->addend, which is set by
	 the CALC_ADDEND macro below.  We want to replace the value in
	 the object file with NEW + OFFSET, where NEW is the value of
	 the common symbol which we are going to put in the final
	 object file.  NEW is symbol->value.  */
      diff = symbol->value + reloc_entry->addend;
    }
  else
    {
      /* For some reason bfd_perform_relocation always effectively
	 ignores the addend for a COFF target when producing
	 relocateable output.  This seems to be always wrong for 386
	 COFF, so we handle the addend here instead.  */
      diff = reloc_entry->addend;
    }

#define DOIT(x) \
  x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))

  if (diff != 0)
    {
      const reloc_howto_type *howto = reloc_entry->howto;
      unsigned char *addr = (unsigned char *) data + reloc_entry->address;

      switch (howto->size)
	{
	case 0:
	  {
	    char x = bfd_get_8 (abfd, addr);
	    DOIT (x);
	    bfd_put_8 (abfd, x, addr);
	  }
	  break;

	case 1:
	  {
	    short x = bfd_get_16 (abfd, addr);
	    DOIT (x);
	    bfd_put_16 (abfd, x, addr);
	  }
	  break;

	case 2:
	  {
	    long x = bfd_get_32 (abfd, addr);
	    DOIT (x);
	    bfd_put_32 (abfd, x, addr);
	  }
	  break;

	default:
	  abort ();
	}
    }

  /* Now let bfd_perform_relocation finish everything up.  */
  return bfd_reloc_continue;
}

static reloc_howto_type howto_table[] = 
{
  {0},
  {1},
  {2},
  {3},
  {4},
  {5},
  HOWTO (R_DIR32,               /* type */                                 
	 0,	                /* rightshift */                           
	 2,	                /* size (0 = byte, 1 = short, 2 = long) */ 
	 32,	                /* bitsize */                   
	 false,	                /* pc_relative */                          
	 0,	                /* bitpos */                               
	 complain_overflow_bitfield, /* complain_on_overflow */
	 coff_go32_reloc,       /* special_function */                     
	 "dir32",               /* name */                                 
	 true,	                /* partial_inplace */                      
	 0xffffffff,            /* src_mask */                             
	 0xffffffff,            /* dst_mask */                             
	 false),                /* pcrel_offset */
  {7},
  {010},
  {011},
  {012},
  {013},
  {014},
  {015},
  {016},
  HOWTO (R_RELBYTE,		/* type */                                 
	 0,			/* rightshift */                           
	 0,			/* size (0 = byte, 1 = short, 2 = long) */ 
	 8,			/* bitsize */                   
	 false,			/* pc_relative */                          
	 0,			/* bitpos */                               
	 complain_overflow_bitfield, /* complain_on_overflow */
	 coff_go32_reloc,	/* special_function */                     
	 "8",			/* name */                                 
	 true,			/* partial_inplace */                      
	 0x000000ff,		/* src_mask */                             
	 0x000000ff,		/* dst_mask */                             
	 false),		/* pcrel_offset */
  HOWTO (R_RELWORD,		/* type */                                 
	 0,			/* rightshift */                           
	 1,			/* size (0 = byte, 1 = short, 2 = long) */ 
	 16,			/* bitsize */                   
	 false,			/* pc_relative */                          
	 0,			/* bitpos */                               
	 complain_overflow_bitfield, /* complain_on_overflow */
	 coff_go32_reloc,	/* special_function */                     
	 "16",			/* name */                                 
	 true,			/* partial_inplace */                      
	 0x0000ffff,		/* src_mask */                             
	 0x0000ffff,		/* dst_mask */                             
	 false),		/* pcrel_offset */
  HOWTO (R_RELLONG,		/* type */                                 
	 0,			/* rightshift */                           
	 2,			/* size (0 = byte, 1 = short, 2 = long) */ 
	 32,			/* bitsize */                   
	 false,			/* pc_relative */                          
	 0,			/* bitpos */                               
	 complain_overflow_bitfield, /* complain_on_overflow */
	 coff_go32_reloc,	/* special_function */                     
	 "32",			/* name */                                 
	 true,			/* partial_inplace */                      
	 0xffffffff,		/* src_mask */                             
	 0xffffffff,		/* dst_mask */                             
	 false),		/* pcrel_offset */
  HOWTO (R_PCRBYTE,		/* type */                                 
	 0,			/* rightshift */                           
	 0,			/* size (0 = byte, 1 = short, 2 = long) */ 
	 8,			/* bitsize */                   
	 true,			/* pc_relative */                          
	 0,			/* bitpos */                               
	 complain_overflow_signed, /* complain_on_overflow */
	 coff_go32_reloc,	/* special_function */                     
	 "DISP8",		/* name */                                 
	 true,			/* partial_inplace */                      
	 0x000000ff,		/* src_mask */                             
	 0x000000ff,		/* dst_mask */                             
	 false),		/* pcrel_offset */
  HOWTO (R_PCRWORD,		/* type */                                 
	 0,			/* rightshift */                           
	 1,			/* size (0 = byte, 1 = short, 2 = long) */ 
	 16,			/* bitsize */                   
	 true,			/* pc_relative */                          
	 0,			/* bitpos */                               
	 complain_overflow_signed, /* complain_on_overflow */
	 coff_go32_reloc,	/* special_function */                     
	 "DISP16",		/* name */                                 
	 true,			/* partial_inplace */                      
	 0x0000ffff,		/* src_mask */                             
	 0x0000ffff,		/* dst_mask */                             
	 false),		/* pcrel_offset */
  HOWTO (R_PCRLONG,		/* type */                                 
	 0,			/* rightshift */                           
	 2,			/* size (0 = byte, 1 = short, 2 = long) */ 
	 32,			/* bitsize */                   
	 true,			/* pc_relative */                          
	 0,			/* bitpos */                               
	 complain_overflow_signed, /* complain_on_overflow */
	 coff_go32_reloc,	/* special_function */                     
	 "DISP32",		/* name */                                 
	 true,			/* partial_inplace */                      
	 0xffffffff,		/* src_mask */                             
	 0xffffffff,		/* dst_mask */                             
	 false)			/* pcrel_offset */
};

/* Turn a howto into a reloc  nunmber */

#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
#define BADMAG(x) I386BADMAG(x)
#define I386 1			/* Customize coffcode.h */

#define RTYPE2HOWTO(cache_ptr, dst) \
	    cache_ptr->howto = howto_table + (dst)->r_type;

/* On SCO Unix 3.2.2 the native assembler generates two .data
   sections.  We handle that by renaming the second one to .data2.  It
   does no harm to do this for any 386 COFF target.  */
#define TWO_DATA_SECS

/* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
   library.  On some other COFF targets STYP_BSS is normally
   STYP_NOLOAD.  */
#define BSS_NOLOAD_IS_SHARED_LIBRARY

/* Compute the addend of a reloc.  If the reloc is to a common symbol,
   the object file contains the value of the common symbol.  By the
   time this is called, the linker may be using a different symbol
   from a different object file with a different value.  Therefore, we
   hack wildly to locate the original symbol from this file so that we
   can make the correct adjustment.  This macro sets coffsym to the
   symbol from the original file, and uses it to set the addend value
   correctly.  If this is not a common symbol, the usual addend
   calculation is done, except that an additional tweak is needed for
   PC relative relocs.
   FIXME: This macro refers to symbols and asect; these are from the
   calling function, not the macro arguments.  */

#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)		\
  {								\
    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;	\
    if (ptr && bfd_asymbol_bfd (ptr) != abfd)			\
      coffsym = (obj_symbols (abfd)				\
	         + (cache_ptr->sym_ptr_ptr - symbols));		\
    else if (ptr)						\
      coffsym = coff_symbol_from (abfd, ptr);			\
    if (coffsym != (coff_symbol_type *) NULL			\
	&& coffsym->native->u.syment.n_scnum == 0)		\
      cache_ptr->addend = - coffsym->native->u.syment.n_value;	\
    else if (ptr && bfd_asymbol_bfd (ptr) == abfd		\
	     && ptr->section != (asection *) NULL)		\
      cache_ptr->addend = - (ptr->section->vma + ptr->value);	\
    else							\
      cache_ptr->addend = 0;					\
    if (ptr && howto_table[reloc.r_type].pc_relative)		\
      cache_ptr->addend += asect->vma;				\
  }

#include "coffcode.h"

static const bfd_target *
go32coff_object_p(a)
     bfd *a;
{
  return coff_object_p(a);
}

static const bfd_target *
go32coff_archive_p(a)
     bfd *a;
{
  return 0;
}

const bfd_target
#ifdef TARGET_SYM
  TARGET_SYM =
#else
  go32coff_vec =
#endif
{
#ifdef TARGET_NAME
  TARGET_NAME,
#else
  "coff-go32",			/* name */
#endif
  bfd_target_coff_flavour,
  false,			/* data byte order is little */
  false,			/* header byte order is little */

  (HAS_RELOC | EXEC_P |		/* object flags */
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | WP_TEXT),

  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
  '_',				/* leading underscore */
  '/',				/* ar_pad_char */
  15,				/* ar_max_namelen */

  2,				/* minimum alignment power */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */

/* Note that we allow an object file to be treated as a core file as well. */
    {_bfd_dummy_target, go32coff_object_p, /* bfd_check_format */
       bfd_generic_archive_p, go32coff_object_p},
    {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
       bfd_false},
    {bfd_false, coff_write_object_contents, /* bfd_write_contents */
       _bfd_write_archive_contents, bfd_false},

     BFD_JUMP_TABLE_GENERIC (coff),
     BFD_JUMP_TABLE_COPY (coff),
     BFD_JUMP_TABLE_CORE (_bfd_nocore),
     BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
     BFD_JUMP_TABLE_SYMBOLS (coff),
     BFD_JUMP_TABLE_RELOCS (coff),
     BFD_JUMP_TABLE_WRITE (coff),
     BFD_JUMP_TABLE_LINK (coff),
     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),

  COFF_SWAP_TABLE,
};
Commit	Line	Data
2f3508ad ILT	1	/* BFD back-end for Intel 386 COFF files (go32 variant).
	2	Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
	3	Written by DJ Delorie.
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "obstack.h"
	25	#include "coff/i386.h"
	26	#include "coff/internal.h"
	27	#include "libcoff.h"
	28
	29	static bfd_reloc_status_type coff_go32_reloc PARAMS ((bfd *abfd,
	30	arelent *reloc_entry,
	31	asymbol *symbol,
	32	PTR data,
	33	asection *input_section,
	34	bfd *output_bfd,
	35	char **error_message));
	36
	37	/* For some reason when using i386 COFF the value stored in the .text
	38	section for a reference to a common symbol is the value itself plus
	39	any desired offset. Ian Taylor, Cygnus Support. */
	40
	41	/* If we are producing relocateable output, we need to do some
	42	adjustments to the object file that are not done by the
	43	bfd_perform_relocation function. This function is called by every
	44	reloc type to make any required adjustments. */
	45
	46	static bfd_reloc_status_type
	47	coff_go32_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
	48	error_message)
	49	bfd *abfd;
	50	arelent *reloc_entry;
	51	asymbol *symbol;
	52	PTR data;
	53	asection *input_section;
	54	bfd *output_bfd;
	55	char **error_message;
	56	{
	57	symvalue diff;
	58
	59	if (output_bfd == (bfd *) NULL)
	60	return bfd_reloc_continue;
	61
	62	if (bfd_is_com_section (symbol->section))
	63	{
	64	/* We are relocating a common symbol. The current value in the
65	object file is ORIG + OFFSET, where ORIG is the value of the
66	common symbol as seen by the object file when it was compiled
67	(this may be zero if the symbol was undefined) and OFFSET is
68	the offset into the common symbol (normally zero, but may be
69	non-zero when referring to a field in a common structure).
70	ORIG is the negative of reloc_entry->addend, which is set by
71	the CALC_ADDEND macro below. We want to replace the value in
72	the object file with NEW + OFFSET, where NEW is the value of
73	the common symbol which we are going to put in the final
74	object file. NEW is symbol->value. */
75	diff = symbol->value + reloc_entry->addend;
76	}
77	else
78	{
79	/* For some reason bfd_perform_relocation always effectively
80	ignores the addend for a COFF target when producing
81	relocateable output. This seems to be always wrong for 386
82	COFF, so we handle the addend here instead. */
83	diff = reloc_entry->addend;
84	}
85
86	#define DOIT(x) \
87	x = ((x & ~howto->dst_mask) \| (((x & howto->src_mask) + diff) & howto->dst_mask))
88
89	if (diff != 0)
90	{
91	const reloc_howto_type *howto = reloc_entry->howto;
92	unsigned char addr = (unsigned char ) data + reloc_entry->address;
93
94	switch (howto->size)
95	{
96	case 0:
97	{
98	char x = bfd_get_8 (abfd, addr);
99	DOIT (x);
100	bfd_put_8 (abfd, x, addr);
101	}
102	break;
103
104	case 1:
105	{
106	short x = bfd_get_16 (abfd, addr);
107	DOIT (x);
108	bfd_put_16 (abfd, x, addr);
109	}
110	break;
111
112	case 2:
113	{
114	long x = bfd_get_32 (abfd, addr);
115	DOIT (x);
116	bfd_put_32 (abfd, x, addr);
117	}
118	break;
119
120	default:
121	abort ();
122	}
123	}
124
125	/* Now let bfd_perform_relocation finish everything up. */
126	return bfd_reloc_continue;
127	}
128
129	static reloc_howto_type howto_table[] =
130	{
131	{0},
132	{1},
133	{2},
134	{3},
135	{4},
136	{5},
137	HOWTO (R_DIR32, /* type */
138	0, /* rightshift */
139	2, /* size (0 = byte, 1 = short, 2 = long) */
140	32, /* bitsize */
141	false, /* pc_relative */
142	0, /* bitpos */
143	complain_overflow_bitfield, /* complain_on_overflow */
144	coff_go32_reloc, /* special_function */
145	"dir32", /* name */
146	true, /* partial_inplace */
147	0xffffffff, /* src_mask */
148	0xffffffff, /* dst_mask */
149	false), /* pcrel_offset */
150	{7},
151	{010},
152	{011},
153	{012},
154	{013},
155	{014},
156	{015},
157	{016},
158	HOWTO (R_RELBYTE, /* type */
159	0, /* rightshift */
160	0, /* size (0 = byte, 1 = short, 2 = long) */
161	8, /* bitsize */
162	false, /* pc_relative */
163	0, /* bitpos */
164	complain_overflow_bitfield, /* complain_on_overflow */
165	coff_go32_reloc, /* special_function */
166	"8", /* name */
167	true, /* partial_inplace */
168	0x000000ff, /* src_mask */
169	0x000000ff, /* dst_mask */
170	false), /* pcrel_offset */
171	HOWTO (R_RELWORD, /* type */
172	0, /* rightshift */
173	1, /* size (0 = byte, 1 = short, 2 = long) */
174	16, /* bitsize */
175	false, /* pc_relative */
176	0, /* bitpos */
177	complain_overflow_bitfield, /* complain_on_overflow */
178	coff_go32_reloc, /* special_function */
179	"16", /* name */
180	true, /* partial_inplace */
181	0x0000ffff, /* src_mask */
182	0x0000ffff, /* dst_mask */
183	false), /* pcrel_offset */
184	HOWTO (R_RELLONG, /* type */
185	0, /* rightshift */
186	2, /* size (0 = byte, 1 = short, 2 = long) */
187	32, /* bitsize */
188	false, /* pc_relative */
189	0, /* bitpos */
190	complain_overflow_bitfield, /* complain_on_overflow */
191	coff_go32_reloc, /* special_function */
192	"32", /* name */
193	true, /* partial_inplace */
194	0xffffffff, /* src_mask */
195	0xffffffff, /* dst_mask */
196	false), /* pcrel_offset */
197	HOWTO (R_PCRBYTE, /* type */
198	0, /* rightshift */
199	0, /* size (0 = byte, 1 = short, 2 = long) */
200	8, /* bitsize */
201	true, /* pc_relative */
202	0, /* bitpos */
203	complain_overflow_signed, /* complain_on_overflow */
204	coff_go32_reloc, /* special_function */
205	"DISP8", /* name */
206	true, /* partial_inplace */
207	0x000000ff, /* src_mask */
208	0x000000ff, /* dst_mask */
209	false), /* pcrel_offset */
210	HOWTO (R_PCRWORD, /* type */
211	0, /* rightshift */
212	1, /* size (0 = byte, 1 = short, 2 = long) */
213	16, /* bitsize */
214	true, /* pc_relative */
215	0, /* bitpos */
216	complain_overflow_signed, /* complain_on_overflow */
217	coff_go32_reloc, /* special_function */
218	"DISP16", /* name */
219	true, /* partial_inplace */
220	0x0000ffff, /* src_mask */
221	0x0000ffff, /* dst_mask */
222	false), /* pcrel_offset */
223	HOWTO (R_PCRLONG, /* type */
224	0, /* rightshift */
225	2, /* size (0 = byte, 1 = short, 2 = long) */
226	32, /* bitsize */
227	true, /* pc_relative */
228	0, /* bitpos */
229	complain_overflow_signed, /* complain_on_overflow */
230	coff_go32_reloc, /* special_function */
231	"DISP32", /* name */
232	true, /* partial_inplace */
233	0xffffffff, /* src_mask */
234	0xffffffff, /* dst_mask */
235	false) /* pcrel_offset */
236	};
237
238	/* Turn a howto into a reloc nunmber */
239
240	#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
241	#define BADMAG(x) I386BADMAG(x)
242	#define I386 1 /* Customize coffcode.h */
243
244	#define RTYPE2HOWTO(cache_ptr, dst) \
245	cache_ptr->howto = howto_table + (dst)->r_type;
246
247	/* On SCO Unix 3.2.2 the native assembler generates two .data
248	sections. We handle that by renaming the second one to .data2. It
249	does no harm to do this for any 386 COFF target. */
250	#define TWO_DATA_SECS
251
252	/* For 386 COFF a STYP_NOLOAD \| STYP_BSS section is part of a shared
253	library. On some other COFF targets STYP_BSS is normally
254	STYP_NOLOAD. */
255	#define BSS_NOLOAD_IS_SHARED_LIBRARY
256
257	/* Compute the addend of a reloc. If the reloc is to a common symbol,
258	the object file contains the value of the common symbol. By the
259	time this is called, the linker may be using a different symbol
260	from a different object file with a different value. Therefore, we
261	hack wildly to locate the original symbol from this file so that we
262	can make the correct adjustment. This macro sets coffsym to the
263	symbol from the original file, and uses it to set the addend value
264	correctly. If this is not a common symbol, the usual addend
265	calculation is done, except that an additional tweak is needed for
266	PC relative relocs.
267	FIXME: This macro refers to symbols and asect; these are from the
268	calling function, not the macro arguments. */
269
270	#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
271	{ \
272	coff_symbol_type coffsym = (coff_symbol_type ) NULL; \
273	if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
274	coffsym = (obj_symbols (abfd) \
275	+ (cache_ptr->sym_ptr_ptr - symbols)); \
276	else if (ptr) \
277	coffsym = coff_symbol_from (abfd, ptr); \
278	if (coffsym != (coff_symbol_type *) NULL \
279	&& coffsym->native->u.syment.n_scnum == 0) \
280	cache_ptr->addend = - coffsym->native->u.syment.n_value; \
281	else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
282	&& ptr->section != (asection *) NULL) \
283	cache_ptr->addend = - (ptr->section->vma + ptr->value); \
284	else \
285	cache_ptr->addend = 0; \
286	if (ptr && howto_table[reloc.r_type].pc_relative) \
287	cache_ptr->addend += asect->vma; \
288	}
289
290	#include "coffcode.h"
291
292	static const bfd_target *
293	go32coff_object_p(a)
294	bfd *a;
295	{
296	return coff_object_p(a);
297	}
298
299	static const bfd_target *
300	go32coff_archive_p(a)
301	bfd *a;
302	{
303	return 0;
304	}
305
306	const bfd_target
307	#ifdef TARGET_SYM
308	TARGET_SYM =
309	#else
310	go32coff_vec =
311	#endif
312	{
313	#ifdef TARGET_NAME
314	TARGET_NAME,
315	#else
316	"coff-go32", /* name */
317	#endif
318	bfd_target_coff_flavour,
319	false, /* data byte order is little */
320	false, /* header byte order is little */
321
322	(HAS_RELOC \| EXEC_P \| /* object flags */
323	HAS_LINENO \| HAS_DEBUG \|
324	HAS_SYMS \| HAS_LOCALS \| WP_TEXT),
325
326	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
327	'_', /* leading underscore */
328	'/', /* ar_pad_char */
329	15, /* ar_max_namelen */
330
331	2, /* minimum alignment power */
332	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
333	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
334	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
335	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
336	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
337	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
338
339	/* Note that we allow an object file to be treated as a core file as well. */
340	{_bfd_dummy_target, go32coff_object_p, /* bfd_check_format */
341	bfd_generic_archive_p, go32coff_object_p},
342	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
343	bfd_false},
344	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
345	_bfd_write_archive_contents, bfd_false},
346
347	BFD_JUMP_TABLE_GENERIC (coff),
348	BFD_JUMP_TABLE_COPY (coff),
349	BFD_JUMP_TABLE_CORE (_bfd_nocore),
350	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
351	BFD_JUMP_TABLE_SYMBOLS (coff),
352	BFD_JUMP_TABLE_RELOCS (coff),
353	BFD_JUMP_TABLE_WRITE (coff),
354	BFD_JUMP_TABLE_LINK (coff),
355	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
356
357	COFF_SWAP_TABLE,
358	};