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

/* BFD back-end for Intel 386 COFF files.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
   Written by Cygnus Support.

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"
#include "obstack.h"

#include "coff/i386.h"

#include "coff/internal.h"

#ifdef COFF_WITH_PE
#include "coff/pe.h"
#endif

#include "libcoff.h"

static bfd_reloc_status_type coff_i386_reloc 
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static reloc_howto_type *coff_i386_rtype_to_howto
  PARAMS ((bfd *, asection *, struct internal_reloc *,
	   struct coff_link_hash_entry *, struct internal_syment *,

	   bfd_vma *));

#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
/* The page size is a guess based on ELF.  */

#define COFF_PAGE_SIZE 0x1000

/* 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_i386_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;
    }


#ifdef COFF_WITH_PE
  if (reloc_entry->howto->type == 7)
    {
/*      diff -= coff_data(output_bfd)->link_info->pe_info.image_base.value;*/
      exit(1);
    }
#endif

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

    if (diff != 0)
      {
	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;
}


#ifndef PCRELOFFSET
#define PCRELOFFSET false
#endif

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_i386_reloc,       /* special_function */                     
	 "dir32",               /* name */                                 
	 true,	                /* partial_inplace */                      
	 0xffffffff,            /* src_mask */                             
	 0xffffffff,            /* dst_mask */                             
	 true),                /* pcrel_offset */
  /* {7}, */
  HOWTO (R_IMAGEBASE,            /* 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_i386_reloc,       /* special_function */                     
	 "rva32",	           /* name */                                 
	 true,	                /* partial_inplace */                      
	 0xffffffff,            /* src_mask */                             
	 0xffffffff,            /* dst_mask */                             
	 false),                /* pcrel_offset */
  {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_i386_reloc,	/* special_function */                     
	 "8",			/* name */                                 
	 true,			/* partial_inplace */                      
	 0x000000ff,		/* src_mask */                             
	 0x000000ff,		/* dst_mask */                             
	 PCRELOFFSET),		/* 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_i386_reloc,	/* special_function */                     
	 "16",			/* name */                                 
	 true,			/* partial_inplace */                      
	 0x0000ffff,		/* src_mask */                             
	 0x0000ffff,		/* dst_mask */                             
	 PCRELOFFSET),		/* 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_i386_reloc,	/* special_function */                     
	 "32",			/* name */                                 
	 true,			/* partial_inplace */                      
	 0xffffffff,		/* src_mask */                             
	 0xffffffff,		/* dst_mask */                             
	 PCRELOFFSET),		/* 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_i386_reloc,	/* special_function */                     
	 "DISP8",		/* name */                                 
	 true,			/* partial_inplace */                      
	 0x000000ff,		/* src_mask */                             
	 0x000000ff,		/* dst_mask */                             
	 PCRELOFFSET),		/* 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_i386_reloc,	/* special_function */                     
	 "DISP16",		/* name */                                 
	 true,			/* partial_inplace */                      
	 0x0000ffff,		/* src_mask */                             
	 0x0000ffff,		/* dst_mask */                             
	 PCRELOFFSET),		/* 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_i386_reloc,	/* special_function */                     
	 "DISP32",		/* name */                                 
	 true,			/* partial_inplace */                      
	 0xffffffff,		/* src_mask */                             
	 0xffffffff,		/* dst_mask */                             
	 PCRELOFFSET)		/* 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;				\
  }

/* We use the special COFF backend linker.  */
#define coff_relocate_section _bfd_coff_generic_relocate_section

static reloc_howto_type *
coff_i386_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
     bfd *abfd;
     asection *sec;
     struct internal_reloc *rel;
     struct coff_link_hash_entry *h;
     struct internal_syment *sym;
     bfd_vma *addendp;
{

  reloc_howto_type *howto;

  howto = howto_table + rel->r_type;

#ifdef COFF_WITH_PE
  *addendp = 0;
#endif

  if (howto->pc_relative)
    *addendp += sec->vma;

  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
    {
      /* This is a common symbol.  The section contents include the
	 size (sym->n_value) as an addend.  The relocate_section
	 function will be adding in the final value of the symbol.  We
	 need to subtract out the current size in order to get the
	 correct result.  */
 
      BFD_ASSERT (h != NULL);


#ifndef COFF_WITH_PE
      /* I think we *do* want to bypass this.  If we don't, I have seen some data
	 parameters get the wrong relcation address.  If I link two versions
	 with and without this section bypassed and then do a binary comparison,
	 the addresses which are different can be looked up in the map.  The 
	 case in which this section has been bypassed has addresses which correspond
	 to values I can find in the map */
      *addendp -= sym->n_value;
#endif
    }

  /* If the output symbol is common (in which case this must be a
     relocateable link), we need to add in the final size of the
     common symbol.  */
  if (h != NULL && h->root.type == bfd_link_hash_common) 
    *addendp += h->root.u.c.size;


#ifdef COFF_WITH_PE
  if (howto->pc_relative)
    *addendp -= 4;

  if (rel->r_type == R_IMAGEBASE)
    {
      *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
    }
#endif

  return howto;
}

#define coff_rtype_to_howto coff_i386_rtype_to_howto

#include "coffcode.h"

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

const bfd_target
#ifdef TARGET_SYM
  TARGET_SYM =
#else
  i386coff_vec =
#endif
{
#ifdef TARGET_NAME
  TARGET_NAME,
#else
  "coff-i386",			/* 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 | D_PAGED),

  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
#ifdef TARGET_UNDERSCORE
  TARGET_UNDERSCORE,		/* leading underscore */
#else
  0,				/* leading underscore */
#endif
  '/',				/* ar_pad_char */
  15,				/* ar_max_namelen */

  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, i3coff_object_p, /* bfd_check_format */
       bfd_generic_archive_p, i3coff_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
6a469027	1	/* BFD back-end for Intel 386 COFF files.
89665c85	2	Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
6a469027	3	Written by Cygnus Support.
517496c5	4
6a469027	5	This file is part of BFD, the Binary File Descriptor library.
517496c5	6
6a469027	7	This program is free software; you can redistribute it and/or modify
517496c5	8	it under the terms of the GNU General Public License as published by
6a469027 JG	9	the Free Software Foundation; either version 2 of the License, or
6a469027 JG	10	(at your option) any later version.
517496c5	11
6a469027	12	This program is distributed in the hope that it will be useful,
517496c5 SC	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
6a469027	18	along with this program; if not, write to the Free Software
a5655244	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
517496c5	20
517496c5	21	#include "bfd.h"
3b4f1a5d	22	#include "sysdep.h"
517496c5 SC	23	#include "libbfd.h"
517496c5 SC	24	#include "obstack.h"
89665c85	25
294eaca4	26	#include "coff/i386.h"
89665c85	27
294eaca4	28	#include "coff/internal.h"
89665c85 SC	29
	30	#ifdef COFF_WITH_PE
	31	#include "coff/pe.h"
	32	#endif
	33
517496c5 SC	34	#include "libcoff.h"
517496c5 SC	35
82b1edf7 KR	36	static bfd_reloc_status_type coff_i386_reloc
82b1edf7 KR	37	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
89665c85	38	static reloc_howto_type *coff_i386_rtype_to_howto
82b1edf7 KR	39	PARAMS ((bfd , asection , struct internal_reloc *,
82b1edf7 KR	40	struct coff_link_hash_entry , struct internal_syment ,
89665c85	41
82b1edf7 KR	42	bfd_vma *));
	43
	44	#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
82b1edf7	45	/* The page size is a guess based on ELF. */
a5655244	46
82b1edf7	47	#define COFF_PAGE_SIZE 0x1000
48ee0757 SS	48
	49	/* For some reason when using i386 COFF the value stored in the .text
	50	section for a reference to a common symbol is the value itself plus
	51	any desired offset. Ian Taylor, Cygnus Support. */
	52
	53	/* If we are producing relocateable output, we need to do some
	54	adjustments to the object file that are not done by the
	55	bfd_perform_relocation function. This function is called by every
	56	reloc type to make any required adjustments. */
	57
	58	static bfd_reloc_status_type
6812b607 ILT	59	coff_i386_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
6812b607 ILT	60	error_message)
48ee0757 SS	61	bfd *abfd;
	62	arelent *reloc_entry;
	63	asymbol *symbol;
	64	PTR data;
	65	asection *input_section;
	66	bfd *output_bfd;
6812b607	67	char **error_message;
48ee0757 SS	68	{
	69	symvalue diff;
	70
	71	if (output_bfd == (bfd *) NULL)
	72	return bfd_reloc_continue;
	73
a5655244	74
48ee0757 SS	75	if (bfd_is_com_section (symbol->section))
	76	{
	77	/* We are relocating a common symbol. The current value in the
	78	object file is ORIG + OFFSET, where ORIG is the value of the
	79	common symbol as seen by the object file when it was compiled
	80	(this may be zero if the symbol was undefined) and OFFSET is
	81	the offset into the common symbol (normally zero, but may be
	82	non-zero when referring to a field in a common structure).
	83	ORIG is the negative of reloc_entry->addend, which is set by
	84	the CALC_ADDEND macro below. We want to replace the value in
	85	the object file with NEW + OFFSET, where NEW is the value of
	86	the common symbol which we are going to put in the final
	87	object file. NEW is symbol->value. */
	88	diff = symbol->value + reloc_entry->addend;
	89	}
	90	else
	91	{
	92	/* For some reason bfd_perform_relocation always effectively
	93	ignores the addend for a COFF target when producing
	94	relocateable output. This seems to be always wrong for 386
	95	COFF, so we handle the addend here instead. */
	96	diff = reloc_entry->addend;
	97	}
	98
48ee0757	99
a5655244 ILT	100	#ifdef COFF_WITH_PE
a5655244 ILT	101	if (reloc_entry->howto->type == 7)
48ee0757	102	{
a5655244 ILT	103	/* diff -= coff_data(output_bfd)->link_info->pe_info.image_base.value;*/
	104	exit(1);
	105	}
	106	#endif
48ee0757	107
a5655244 ILT	108	#define DOIT(x) \
a5655244 ILT	109	x = ((x & ~howto->dst_mask) \| (((x & howto->src_mask) + diff) & howto->dst_mask))
48ee0757	110
a5655244 ILT	111	if (diff != 0)
	112	{
	113	reloc_howto_type *howto = reloc_entry->howto;
	114	unsigned char addr = (unsigned char ) data + reloc_entry->address;
48ee0757	115
a5655244	116	switch (howto->size)
48ee0757	117	{
a5655244 ILT	118	case 0:
	119	{
	120	char x = bfd_get_8 (abfd, addr);
	121	DOIT (x);
	122	bfd_put_8 (abfd, x, addr);
	123	}
	124	break;
	125
	126	case 1:
	127	{
	128	short x = bfd_get_16 (abfd, addr);
	129	DOIT (x);
	130	bfd_put_16 (abfd, x, addr);
	131	}
	132	break;
	133
	134	case 2:
	135	{
	136	long x = bfd_get_32 (abfd, addr);
	137	DOIT (x);
	138	bfd_put_32 (abfd, x, addr);
	139	}
	140	break;
	141
	142	default:
	143	abort ();
48ee0757	144	}
a5655244	145	}
48ee0757 SS	146
	147	/* Now let bfd_perform_relocation finish everything up. */
	148	return bfd_reloc_continue;
	149	}
517496c5	150
89665c85 SC	151
	152
	153	#ifndef PCRELOFFSET
	154	#define PCRELOFFSET false
	155	#endif
	156
517496c5 SC	157	static reloc_howto_type howto_table[] =
517496c5 SC	158	{
48ee0757 SS	159	{0},
	160	{1},
	161	{2},
	162	{3},
	163	{4},
	164	{5},
	165	HOWTO (R_DIR32, /* type */
89665c85 SC	166	0, /* rightshift */
	167	2, /* size (0 = byte, 1 = short, 2 = long) */
	168	32, /* bitsize */
	169	false, /* pc_relative */
	170	0, /* bitpos */
	171	complain_overflow_bitfield, /* complain_on_overflow */
	172	coff_i386_reloc, /* special_function */
	173	"dir32", /* name */
	174	true, /* partial_inplace */
	175	0xffffffff, /* src_mask */
	176	0xffffffff, /* dst_mask */
	177	true), /* pcrel_offset */
	178	/* {7}, */
a5655244	179	HOWTO (R_IMAGEBASE, /* type */
48ee0757 SS	180	0, /* rightshift */
	181	2, /* size (0 = byte, 1 = short, 2 = long) */
	182	32, /* bitsize */
	183	false, /* pc_relative */
	184	0, /* bitpos */
	185	complain_overflow_bitfield, /* complain_on_overflow */
	186	coff_i386_reloc, /* special_function */
a5655244	187	"rva32", /* name */
48ee0757 SS	188	true, /* partial_inplace */
	189	0xffffffff, /* src_mask */
	190	0xffffffff, /* dst_mask */
	191	false), /* pcrel_offset */
48ee0757 SS	192	{010},
	193	{011},
	194	{012},
	195	{013},
	196	{014},
	197	{015},
	198	{016},
	199	HOWTO (R_RELBYTE, /* type */
	200	0, /* rightshift */
	201	0, /* size (0 = byte, 1 = short, 2 = long) */
	202	8, /* bitsize */
	203	false, /* pc_relative */
	204	0, /* bitpos */
	205	complain_overflow_bitfield, /* complain_on_overflow */
	206	coff_i386_reloc, /* special_function */
	207	"8", /* name */
	208	true, /* partial_inplace */
	209	0x000000ff, /* src_mask */
	210	0x000000ff, /* dst_mask */
89665c85	211	PCRELOFFSET), /* pcrel_offset */
48ee0757 SS	212	HOWTO (R_RELWORD, /* type */
	213	0, /* rightshift */
	214	1, /* size (0 = byte, 1 = short, 2 = long) */
	215	16, /* bitsize */
	216	false, /* pc_relative */
	217	0, /* bitpos */
	218	complain_overflow_bitfield, /* complain_on_overflow */
	219	coff_i386_reloc, /* special_function */
	220	"16", /* name */
	221	true, /* partial_inplace */
	222	0x0000ffff, /* src_mask */
	223	0x0000ffff, /* dst_mask */
89665c85	224	PCRELOFFSET), /* pcrel_offset */
48ee0757 SS	225	HOWTO (R_RELLONG, /* type */
	226	0, /* rightshift */
	227	2, /* size (0 = byte, 1 = short, 2 = long) */
	228	32, /* bitsize */
	229	false, /* pc_relative */
	230	0, /* bitpos */
	231	complain_overflow_bitfield, /* complain_on_overflow */
	232	coff_i386_reloc, /* special_function */
	233	"32", /* name */
	234	true, /* partial_inplace */
	235	0xffffffff, /* src_mask */
	236	0xffffffff, /* dst_mask */
89665c85	237	PCRELOFFSET), /* pcrel_offset */
48ee0757 SS	238	HOWTO (R_PCRBYTE, /* type */
	239	0, /* rightshift */
	240	0, /* size (0 = byte, 1 = short, 2 = long) */
	241	8, /* bitsize */
	242	true, /* pc_relative */
	243	0, /* bitpos */
	244	complain_overflow_signed, /* complain_on_overflow */
	245	coff_i386_reloc, /* special_function */
	246	"DISP8", /* name */
	247	true, /* partial_inplace */
	248	0x000000ff, /* src_mask */
	249	0x000000ff, /* dst_mask */
89665c85	250	PCRELOFFSET), /* pcrel_offset */
48ee0757 SS	251	HOWTO (R_PCRWORD, /* type */
	252	0, /* rightshift */
	253	1, /* size (0 = byte, 1 = short, 2 = long) */
	254	16, /* bitsize */
	255	true, /* pc_relative */
	256	0, /* bitpos */
	257	complain_overflow_signed, /* complain_on_overflow */
	258	coff_i386_reloc, /* special_function */
	259	"DISP16", /* name */
	260	true, /* partial_inplace */
	261	0x0000ffff, /* src_mask */
	262	0x0000ffff, /* dst_mask */
89665c85	263	PCRELOFFSET), /* pcrel_offset */
48ee0757 SS	264	HOWTO (R_PCRLONG, /* type */
	265	0, /* rightshift */
	266	2, /* size (0 = byte, 1 = short, 2 = long) */
	267	32, /* bitsize */
	268	true, /* pc_relative */
	269	0, /* bitpos */
	270	complain_overflow_signed, /* complain_on_overflow */
	271	coff_i386_reloc, /* special_function */
	272	"DISP32", /* name */
	273	true, /* partial_inplace */
	274	0xffffffff, /* src_mask */
	275	0xffffffff, /* dst_mask */
89665c85	276	PCRELOFFSET) /* pcrel_offset */
517496c5 SC	277	};
517496c5 SC	278
517496c5 SC	279	/* Turn a howto into a reloc nunmber */
517496c5 SC	280
6812b607	281	#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
517496c5	282	#define BADMAG(x) I386BADMAG(x)
3b4f1a5d SC	283	#define I386 1 /* Customize coffcode.h */
3b4f1a5d SC	284
c9301d7b	285	#define RTYPE2HOWTO(cache_ptr, dst) \
82b1edf7	286	(cache_ptr)->howto = howto_table + (dst)->r_type;
3b4f1a5d	287
48ee0757 SS	288	/* On SCO Unix 3.2.2 the native assembler generates two .data
	289	sections. We handle that by renaming the second one to .data2. It
	290	does no harm to do this for any 386 COFF target. */
	291	#define TWO_DATA_SECS
	292
	293	/* For 386 COFF a STYP_NOLOAD \| STYP_BSS section is part of a shared
	294	library. On some other COFF targets STYP_BSS is normally
	295	STYP_NOLOAD. */
	296	#define BSS_NOLOAD_IS_SHARED_LIBRARY
517496c5	297
48ee0757 SS	298	/* Compute the addend of a reloc. If the reloc is to a common symbol,
	299	the object file contains the value of the common symbol. By the
	300	time this is called, the linker may be using a different symbol
	301	from a different object file with a different value. Therefore, we
	302	hack wildly to locate the original symbol from this file so that we
	303	can make the correct adjustment. This macro sets coffsym to the
	304	symbol from the original file, and uses it to set the addend value
	305	correctly. If this is not a common symbol, the usual addend
	306	calculation is done, except that an additional tweak is needed for
	307	PC relative relocs.
	308	FIXME: This macro refers to symbols and asect; these are from the
	309	calling function, not the macro arguments. */
	310
	311	#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
	312	{ \
	313	coff_symbol_type coffsym = (coff_symbol_type ) NULL; \
	314	if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
	315	coffsym = (obj_symbols (abfd) \
	316	+ (cache_ptr->sym_ptr_ptr - symbols)); \
	317	else if (ptr) \
	318	coffsym = coff_symbol_from (abfd, ptr); \
	319	if (coffsym != (coff_symbol_type *) NULL \
	320	&& coffsym->native->u.syment.n_scnum == 0) \
	321	cache_ptr->addend = - coffsym->native->u.syment.n_value; \
	322	else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
	323	&& ptr->section != (asection *) NULL) \
	324	cache_ptr->addend = - (ptr->section->vma + ptr->value); \
	325	else \
	326	cache_ptr->addend = 0; \
	327	if (ptr && howto_table[reloc.r_type].pc_relative) \
	328	cache_ptr->addend += asect->vma; \
	329	}
	330
82b1edf7 KR	331	/* We use the special COFF backend linker. */
	332	#define coff_relocate_section _bfd_coff_generic_relocate_section
	333
89665c85	334	static reloc_howto_type *
82b1edf7 KR	335	coff_i386_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
	336	bfd *abfd;
	337	asection *sec;
	338	struct internal_reloc *rel;
	339	struct coff_link_hash_entry *h;
	340	struct internal_syment *sym;
	341	bfd_vma *addendp;
	342	{
89665c85 SC	343
89665c85 SC	344	reloc_howto_type *howto;
82b1edf7 KR	345
	346	howto = howto_table + rel->r_type;
	347
89665c85 SC	348	#ifdef COFF_WITH_PE
	349	*addendp = 0;
	350	#endif
	351
82b1edf7 KR	352	if (howto->pc_relative)
	353	*addendp += sec->vma;
	354
	355	if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
	356	{
	357	/* This is a common symbol. The section contents include the
	358	size (sym->n_value) as an addend. The relocate_section
	359	function will be adding in the final value of the symbol. We
	360	need to subtract out the current size in order to get the
	361	correct result. */
89665c85	362
82b1edf7	363	BFD_ASSERT (h != NULL);
89665c85 SC	364
	365
	366	#ifndef COFF_WITH_PE
a5655244 ILT	367	/* I think we do want to bypass this. If we don't, I have seen some data
	368	parameters get the wrong relcation address. If I link two versions
	369	with and without this section bypassed and then do a binary comparison,
	370	the addresses which are different can be looked up in the map. The
	371	case in which this section has been bypassed has addresses which correspond
	372	to values I can find in the map */
82b1edf7	373	*addendp -= sym->n_value;
89665c85	374	#endif
82b1edf7 KR	375	}
	376
	377	/* If the output symbol is common (in which case this must be a
	378	relocateable link), we need to add in the final size of the
	379	common symbol. */
89665c85	380	if (h != NULL && h->root.type == bfd_link_hash_common)
82b1edf7 KR	381	*addendp += h->root.u.c.size;
82b1edf7 KR	382
89665c85 SC	383
	384	#ifdef COFF_WITH_PE
	385	if (howto->pc_relative)
a5655244 ILT	386	*addendp -= 4;
	387
	388	if (rel->r_type == R_IMAGEBASE)
	389	{
	390	*addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
	391	}
89665c85 SC	392	#endif
89665c85 SC	393
82b1edf7 KR	394	return howto;
	395	}
	396
	397	#define coff_rtype_to_howto coff_i386_rtype_to_howto
	398
48ee0757	399	#include "coffcode.h"
517496c5	400
82b1edf7	401	static const bfd_target *
cbd8493e KR	402	i3coff_object_p(a)
	403	bfd *a;
	404	{
	405	return coff_object_p(a);
	406	}
517496c5	407
82b1edf7	408	const bfd_target
48ee0757 SS	409	#ifdef TARGET_SYM
	410	TARGET_SYM =
	411	#else
	412	i386coff_vec =
	413	#endif
517496c5	414	{
48ee0757 SS	415	#ifdef TARGET_NAME
	416	TARGET_NAME,
	417	#else
3b4f1a5d	418	"coff-i386", /* name */
48ee0757	419	#endif
6a469027 JG	420	bfd_target_coff_flavour,
	421	false, /* data byte order is little */
	422	false, /* header byte order is little */
517496c5 SC	423
	424	(HAS_RELOC \| EXEC_P \| /* object flags */
	425	HAS_LINENO \| HAS_DEBUG \|
82b1edf7	426	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
517496c5 SC	427
517496c5 SC	428	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
82b1edf7 KR	429	#ifdef TARGET_UNDERSCORE
	430	TARGET_UNDERSCORE, /* leading underscore */
	431	#else
294eaca4	432	0, /* leading underscore */
82b1edf7	433	#endif
517496c5 SC	434	'/', /* ar_pad_char */
	435	15, /* ar_max_namelen */
	436
48ee0757 SS	437	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	438	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	439	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
	440	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	441	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	442	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
517496c5	443
6a469027 JG	444	/* Note that we allow an object file to be treated as a core file as well. */
	445	{_bfd_dummy_target, i3coff_object_p, /* bfd_check_format */
	446	bfd_generic_archive_p, i3coff_object_p},
	447	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
	448	bfd_false},
	449	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
	450	_bfd_write_archive_contents, bfd_false},
517496c5	451
6812b607 ILT	452	BFD_JUMP_TABLE_GENERIC (coff),
	453	BFD_JUMP_TABLE_COPY (coff),
	454	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	455	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
	456	BFD_JUMP_TABLE_SYMBOLS (coff),
	457	BFD_JUMP_TABLE_RELOCS (coff),
	458	BFD_JUMP_TABLE_WRITE (coff),
	459	BFD_JUMP_TABLE_LINK (coff),
82b1edf7	460	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
6812b607	461
48ee0757 SS	462	COFF_SWAP_TABLE,
48ee0757 SS	463	};