[binutils.git] / bfd / coff-arm.c

/* BFD back-end for ARM 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/arm.h"

#include "coff/internal.h"

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

#include "libcoff.h"

static bfd_reloc_status_type
aoutarm_fix_pcrel_26_done PARAMS ((bfd *, arelent *, asymbol *, PTR,
				  asection *, bfd *, char **));

static bfd_reloc_status_type
aoutarm_fix_pcrel_26 PARAMS ((bfd *, arelent *, asymbol *, PTR,
			     asection *, bfd *, char **));


static bfd_reloc_status_type coff_arm_reloc 
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));


/* Used by the assembler. */
static bfd_reloc_status_type
coff_arm_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;

  diff = reloc_entry->addend;

#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 true
#endif

static reloc_howto_type aoutarm_std_reloc_howto[] = 
{
  /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
  HOWTO(0,			/* type */
	0,			/* rs */
	0,			/* size */
	8,			/* bsz */
	false,			/* pcrel */
	0,			/* bitpos */
	complain_overflow_bitfield, /* ovf */
	coff_arm_reloc,		/* sf */
	"8",			/*name */
        true,			/* partial */
	0x000000ff,		/*read mask */
	0x000000ff,		/* setmask */
	PCRELOFFSET		/* pcdone */),
  HOWTO(1,  
	0, 
	1, 
	16, 
	false,
	0,
	complain_overflow_bitfield,
	coff_arm_reloc,
	"16", 
	true,
	0x0000ffff,
	0x0000ffff, 
	PCRELOFFSET),
  HOWTO( 2, 
	0,
	2, 
	32,
	false,
	0,
	complain_overflow_bitfield,
	coff_arm_reloc,
	"32",
        true,
	0xffffffff,
	0xffffffff,
	PCRELOFFSET),
  HOWTO( 3,
	2,
	2,
	26,
	true,
	0,
	complain_overflow_signed,
	aoutarm_fix_pcrel_26 ,
	"ARM26",
	false,
	0x00ffffff,
	0x00ffffff, 
	PCRELOFFSET),
  HOWTO( 4,        
	0,
	0,
	8, 
	true,
	0,
	complain_overflow_signed, 
	coff_arm_reloc,
	"DISP8",  
	true,
	0x000000ff,
	0x000000ff,
	true),
  HOWTO( 5, 
	0,
	1,
	16,
	true,
	0,
	complain_overflow_signed, 
	coff_arm_reloc,
	"DISP16",
	true,
	0x0000ffff,
	0x0000ffff,
	true),
  HOWTO( 6,
	0,
	2,
	32,
	true,
	0,
	complain_overflow_signed, 
 	coff_arm_reloc,
	"DISP32",
	true,
	0xffffffff,
	0xffffffff,
	true),
  HOWTO( 7,  
	2, 
	2,
	26,
	false,
	0,
	complain_overflow_signed,
	aoutarm_fix_pcrel_26_done, 
	"ARM26D",
	true,
	0x00ffffff,
	0x00ffffff, 
	false),
  {-1},
  HOWTO( 9,
	0,
	-1,
	16,
	false,
	0, 
	complain_overflow_bitfield,
	coff_arm_reloc,
	"NEG16",
        true, 
	0x0000ffff,
	0x0000ffff, 
	false),
  HOWTO( 10, 
	0, 
	-2,
	32,
	false,
	0,
	complain_overflow_bitfield,
	coff_arm_reloc,
	"NEG32",
        true,
	0xffffffff,
	0xffffffff,
	false),
  HOWTO( 11, 
	0,
	2, 
	32,
	false,
	0,
	complain_overflow_bitfield,
	coff_arm_reloc,
	"rva32",
        true,
	0xffffffff,
	0xffffffff,
	PCRELOFFSET),
};
#ifdef COFF_WITH_PE
/* Return true if this relocation should
   appear in the output .reloc section. */

static boolean in_reloc_p (abfd, howto)
     bfd * abfd;
     reloc_howto_type *howto;
{
  return !howto->pc_relative && howto->type != 11;
}     
#endif


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

#define coff_rtype_to_howto coff_arm_rtype_to_howto

static reloc_howto_type *
coff_arm_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 = aoutarm_std_reloc_howto + rel->r_type;

  if (rel->r_type == 11)
    {
      *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
    }
  return howto;

}
/* Used by the assembler. */

static bfd_reloc_status_type
aoutarm_fix_pcrel_26_done (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;
{
  /* This is dead simple at present.  */
  return bfd_reloc_ok;
}

/* Used by the assembler. */

static bfd_reloc_status_type
aoutarm_fix_pcrel_26 (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;
{
  bfd_vma relocation;
  bfd_size_type addr = reloc_entry->address;
  long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
  bfd_reloc_status_type flag = bfd_reloc_ok;
  
  /* If this is an undefined symbol, return error */
  if (symbol->section == &bfd_und_section
      && (symbol->flags & BSF_WEAK) == 0)
    return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;

  /* If the sections are different, and we are doing a partial relocation,
     just ignore it for now.  */
  if (symbol->section->name != input_section->name
      && output_bfd != (bfd *)NULL)
    return bfd_reloc_continue;

  relocation = (target & 0x00ffffff) << 2;
  relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
  relocation += symbol->value;
  relocation += symbol->section->output_section->vma;
  relocation += symbol->section->output_offset;
  relocation += reloc_entry->addend;
  relocation -= input_section->output_section->vma;
  relocation -= input_section->output_offset;
  relocation -= addr;
  if (relocation & 3)
    return bfd_reloc_overflow;

  /* Check for overflow */
  if (relocation & 0x02000000)
    {
      if ((relocation & ~0x03ffffff) != ~0x03ffffff)
	flag = bfd_reloc_overflow;
    }
  else if (relocation & ~0x03ffffff)
    flag = bfd_reloc_overflow;

  target &= ~0x00ffffff;
  target |= (relocation >> 2) & 0x00ffffff;
  bfd_put_32 (abfd, target, (bfd_byte *) data + addr);

  /* Now the ARM magic... Change the reloc type so that it is marked as done.
     Strictly this is only necessary if we are doing a partial relocation.  */
  reloc_entry->howto = &aoutarm_std_reloc_howto[7];

  return flag;
}


static CONST struct reloc_howto_struct *
arm_reloc_type_lookup(abfd,code)
      bfd *abfd;
      bfd_reloc_code_real_type code;
{
#define ASTD(i,j)       case i: return &aoutarm_std_reloc_howto[j]
  if (code == BFD_RELOC_CTOR)
    switch (bfd_get_arch_info (abfd)->bits_per_address)
      {
      case 32:
        code = BFD_RELOC_32;
        break;
      default: return (CONST struct reloc_howto_struct *) 0;
      }

  switch (code)
    {
      ASTD (BFD_RELOC_16, 1);
      ASTD (BFD_RELOC_32, 2);
      ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
      ASTD (BFD_RELOC_8_PCREL, 4);
      ASTD (BFD_RELOC_16_PCREL, 5);
      ASTD (BFD_RELOC_32_PCREL, 6);
      ASTD (BFD_RELOC_RVA, 11);
    default: return (CONST struct reloc_howto_struct *) 0;
    }
}


#define coff_bfd_reloc_type_lookup arm_reloc_type_lookup

#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
#define COFF_PAGE_SIZE 0x1000
/* Turn a howto into a reloc  nunmber */

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


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


#include "coffcode.h"

const bfd_target
#ifdef TARGET_LITTLE_SYM
TARGET_LITTLE_SYM =
#else
armcoff_little_vec =
#endif
{
#ifdef TARGET_LITTLE_NAME
  TARGET_LITTLE_NAME,
#else
  "coff-arm-little",
#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, coff_object_p, /* bfd_check_format */
       bfd_generic_archive_p, coff_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,
};

const bfd_target
#ifdef TARGET_BIG_SYM
TARGET_BIG_SYM =
#else
armcoff_big_vec =
#endif
{
#ifdef TARGET_BIG_NAME
  TARGET_BIG_NAME,
#else
  "coff-arm-big",
#endif
  bfd_target_coff_flavour,
  true,				/* data byte order is big */
  true,				/* header byte order is big */

  (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_getb64, bfd_getb_signed_64, bfd_putb64,
     bfd_getb32, bfd_getb_signed_32, bfd_putb32,
     bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
     bfd_getb32, bfd_getb_signed_32, bfd_putb32,
     bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */

/* Note that we allow an object file to be treated as a core file as well. */
    {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
       bfd_generic_archive_p, coff_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
177b1932	1	/* BFD back-end for ARM COFF files.
943fbd5b KR	2	Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
	3	Written by Cygnus Support.
	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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "obstack.h"
	25
	26	#include "coff/arm.h"
	27
	28	#include "coff/internal.h"
	29
	30	#ifdef COFF_WITH_PE
	31	#include "coff/pe.h"
	32	#endif
	33
	34	#include "libcoff.h"
	35
	36	static bfd_reloc_status_type
	37	aoutarm_fix_pcrel_26_done PARAMS ((bfd , arelent , asymbol *, PTR,
	38	asection , bfd , char **));
	39
	40	static bfd_reloc_status_type
	41	aoutarm_fix_pcrel_26 PARAMS ((bfd , arelent , asymbol *, PTR,
	42	asection , bfd , char **));
	43
	44
	45	static bfd_reloc_status_type coff_arm_reloc
	46	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
	47
275143eb SC	48
275143eb SC	49	/* Used by the assembler. */
943fbd5b KR	50	static bfd_reloc_status_type
	51	coff_arm_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
	52	error_message)
	53	bfd *abfd;
	54	arelent *reloc_entry;
	55	asymbol *symbol;
	56	PTR data;
	57	asection *input_section;
	58	bfd *output_bfd;
	59	char **error_message;
	60	{
	61	symvalue diff;
943fbd5b KR	62	if (output_bfd == (bfd *) NULL)
	63	return bfd_reloc_continue;
	64
da7afe3b	65	diff = reloc_entry->addend;
943fbd5b KR	66
	67	#define DOIT(x) \
	68	x = ((x & ~howto->dst_mask) \| (((x & howto->src_mask) + diff) & howto->dst_mask))
	69
da7afe3b SC	70	if (diff != 0)
	71	{
	72	reloc_howto_type *howto = reloc_entry->howto;
	73	unsigned char addr = (unsigned char ) data + reloc_entry->address;
943fbd5b	74
da7afe3b	75	switch (howto->size)
943fbd5b	76	{
da7afe3b SC	77	case 0:
	78	{
	79	char x = bfd_get_8 (abfd, addr);
	80	DOIT (x);
	81	bfd_put_8 (abfd, x, addr);
	82	}
	83	break;
	84
	85	case 1:
	86	{
	87	short x = bfd_get_16 (abfd, addr);
	88	DOIT (x);
	89	bfd_put_16 (abfd, x, addr);
	90	}
	91	break;
	92
	93	case 2:
	94	{
	95	long x = bfd_get_32 (abfd, addr);
	96	DOIT (x);
	97	bfd_put_32 (abfd, x, addr);
	98	}
	99	break;
	100
	101	default:
	102	abort ();
943fbd5b	103	}
da7afe3b	104	}
943fbd5b KR	105
	106	/* Now let bfd_perform_relocation finish everything up. */
	107	return bfd_reloc_continue;
	108	}
	109
3ea928f5 SC	110	#ifndef PCRELOFFSET
	111	#define PCRELOFFSET true
	112	#endif
	113
943fbd5b KR	114	static reloc_howto_type aoutarm_std_reloc_howto[] =
	115	{
	116	/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
	117	HOWTO(0, /* type */
	118	0, /* rs */
	119	0, /* size */
	120	8, /* bsz */
	121	false, /* pcrel */
	122	0, /* bitpos */
	123	complain_overflow_bitfield, /* ovf */
	124	coff_arm_reloc, /* sf */
	125	"8", /name /
	126	true, /* partial */
	127	0x000000ff, /read mask /
	128	0x000000ff, /* setmask */
	129	PCRELOFFSET /* pcdone */),
	130	HOWTO(1,
	131	0,
	132	1,
	133	16,
	134	false,
	135	0,
	136	complain_overflow_bitfield,
	137	coff_arm_reloc,
	138	"16",
	139	true,
	140	0x0000ffff,
	141	0x0000ffff,
	142	PCRELOFFSET),
	143	HOWTO( 2,
	144	0,
	145	2,
	146	32,
	147	false,
	148	0,
	149	complain_overflow_bitfield,
	150	coff_arm_reloc,
	151	"32",
	152	true,
	153	0xffffffff,
	154	0xffffffff,
	155	PCRELOFFSET),
	156	HOWTO( 3,
	157	2,
3ea928f5	158	2,
943fbd5b KR	159	26,
	160	true,
	161	0,
	162	complain_overflow_signed,
	163	aoutarm_fix_pcrel_26 ,
	164	"ARM26",
275143eb	165	false,
943fbd5b KR	166	0x00ffffff,
	167	0x00ffffff,
	168	PCRELOFFSET),
	169	HOWTO( 4,
	170	0,
	171	0,
	172	8,
	173	true,
	174	0,
	175	complain_overflow_signed,
	176	coff_arm_reloc,
	177	"DISP8",
	178	true,
	179	0x000000ff,
	180	0x000000ff,
	181	true),
	182	HOWTO( 5,
	183	0,
	184	1,
	185	16,
	186	true,
	187	0,
	188	complain_overflow_signed,
	189	coff_arm_reloc,
	190	"DISP16",
	191	true,
	192	0x0000ffff,
	193	0x0000ffff,
	194	true),
	195	HOWTO( 6,
	196	0,
	197	2,
	198	32,
	199	true,
	200	0,
	201	complain_overflow_signed,
	202	coff_arm_reloc,
	203	"DISP32",
	204	true,
	205	0xffffffff,
	206	0xffffffff,
	207	true),
	208	HOWTO( 7,
	209	2,
3ea928f5	210	2,
943fbd5b KR	211	26,
	212	false,
	213	0,
	214	complain_overflow_signed,
	215	aoutarm_fix_pcrel_26_done,
	216	"ARM26D",
	217	true,
	218	0x00ffffff,
	219	0x00ffffff,
	220	false),
	221	{-1},
	222	HOWTO( 9,
	223	0,
	224	-1,
	225	16,
	226	false,
	227	0,
	228	complain_overflow_bitfield,
	229	coff_arm_reloc,
	230	"NEG16",
	231	true,
	232	0x0000ffff,
	233	0x0000ffff,
	234	false),
	235	HOWTO( 10,
	236	0,
	237	-2,
	238	32,
	239	false,
	240	0,
	241	complain_overflow_bitfield,
	242	coff_arm_reloc,
	243	"NEG32",
	244	true,
	245	0xffffffff,
	246	0xffffffff,
3ea928f5 SC	247	false),
	248	HOWTO( 11,
	249	0,
	250	2,
	251	32,
	252	false,
	253	0,
	254	complain_overflow_bitfield,
	255	coff_arm_reloc,
	256	"rva32",
	257	true,
	258	0xffffffff,
	259	0xffffffff,
	260	PCRELOFFSET),
943fbd5b	261	};
177b1932 DE	262	#ifdef COFF_WITH_PE
	263	/* Return true if this relocation should
	264	appear in the output .reloc section. */
	265
	266	static boolean in_reloc_p (abfd, howto)
	267	bfd * abfd;
	268	reloc_howto_type *howto;
	269	{
	270	return !howto->pc_relative && howto->type != 11;
	271	}
	272	#endif
943fbd5b KR	273
943fbd5b KR	274
943fbd5b KR	275	#define RTYPE2HOWTO(cache_ptr, dst) \
	276	(cache_ptr)->howto = aoutarm_std_reloc_howto + (dst)->r_type;
	277
275143eb	278	#define coff_rtype_to_howto coff_arm_rtype_to_howto
a5655244	279
275143eb SC	280	static reloc_howto_type *
	281	coff_arm_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
	282	bfd *abfd;
	283	asection *sec;
	284	struct internal_reloc *rel;
	285	struct coff_link_hash_entry *h;
	286	struct internal_syment *sym;
	287	bfd_vma *addendp;
	288	{
	289	reloc_howto_type *howto;
	290
	291	howto = aoutarm_std_reloc_howto + rel->r_type;
	292
	293	if (rel->r_type == 11)
	294	{
a5655244	295	*addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
275143eb SC	296	}
	297	return howto;
	298
	299	}
	300	/* Used by the assembler. */
	301
943fbd5b KR	302	static bfd_reloc_status_type
	303	aoutarm_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
	304	output_bfd, error_message)
	305	bfd *abfd;
	306	arelent *reloc_entry;
	307	asymbol *symbol;
	308	PTR data;
	309	asection *input_section;
	310	bfd *output_bfd;
	311	char **error_message;
	312	{
	313	/* This is dead simple at present. */
	314	return bfd_reloc_ok;
	315	}
	316
275143eb SC	317	/* Used by the assembler. */
275143eb SC	318
943fbd5b KR	319	static bfd_reloc_status_type
	320	aoutarm_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
	321	output_bfd, error_message)
	322	bfd *abfd;
	323	arelent *reloc_entry;
	324	asymbol *symbol;
	325	PTR data;
	326	asection *input_section;
	327	bfd *output_bfd;
	328	char **error_message;
	329	{
	330	bfd_vma relocation;
	331	bfd_size_type addr = reloc_entry->address;
	332	long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
	333	bfd_reloc_status_type flag = bfd_reloc_ok;
	334
	335	/* If this is an undefined symbol, return error */
	336	if (symbol->section == &bfd_und_section
	337	&& (symbol->flags & BSF_WEAK) == 0)
	338	return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
	339
	340	/* If the sections are different, and we are doing a partial relocation,
	341	just ignore it for now. */
	342	if (symbol->section->name != input_section->name
	343	&& output_bfd != (bfd *)NULL)
	344	return bfd_reloc_continue;
	345
	346	relocation = (target & 0x00ffffff) << 2;
	347	relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
	348	relocation += symbol->value;
	349	relocation += symbol->section->output_section->vma;
	350	relocation += symbol->section->output_offset;
	351	relocation += reloc_entry->addend;
	352	relocation -= input_section->output_section->vma;
	353	relocation -= input_section->output_offset;
	354	relocation -= addr;
	355	if (relocation & 3)
	356	return bfd_reloc_overflow;
	357
	358	/* Check for overflow */
	359	if (relocation & 0x02000000)
	360	{
	361	if ((relocation & ~0x03ffffff) != ~0x03ffffff)
	362	flag = bfd_reloc_overflow;
	363	}
	364	else if (relocation & ~0x03ffffff)
	365	flag = bfd_reloc_overflow;
	366
	367	target &= ~0x00ffffff;
	368	target \|= (relocation >> 2) & 0x00ffffff;
	369	bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
	370
	371	/* Now the ARM magic... Change the reloc type so that it is marked as done.
	372	Strictly this is only necessary if we are doing a partial relocation. */
	373	reloc_entry->howto = &aoutarm_std_reloc_howto[7];
275143eb	374
943fbd5b KR	375	return flag;
	376	}
	377
275143eb	378
943fbd5b KR	379	static CONST struct reloc_howto_struct *
	380	arm_reloc_type_lookup(abfd,code)
	381	bfd *abfd;
	382	bfd_reloc_code_real_type code;
	383	{
	384	#define ASTD(i,j) case i: return &aoutarm_std_reloc_howto[j]
	385	if (code == BFD_RELOC_CTOR)
	386	switch (bfd_get_arch_info (abfd)->bits_per_address)
	387	{
	388	case 32:
	389	code = BFD_RELOC_32;
	390	break;
	391	default: return (CONST struct reloc_howto_struct *) 0;
	392	}
	393
	394	switch (code)
	395	{
	396	ASTD (BFD_RELOC_16, 1);
	397	ASTD (BFD_RELOC_32, 2);
	398	ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
	399	ASTD (BFD_RELOC_8_PCREL, 4);
	400	ASTD (BFD_RELOC_16_PCREL, 5);
	401	ASTD (BFD_RELOC_32_PCREL, 6);
3ea928f5	402	ASTD (BFD_RELOC_RVA, 11);
943fbd5b KR	403	default: return (CONST struct reloc_howto_struct *) 0;
	404	}
	405	}
	406
	407
	408	#define coff_bfd_reloc_type_lookup arm_reloc_type_lookup
	409
943fbd5b	410	#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
943fbd5b	411	#define COFF_PAGE_SIZE 0x1000
943fbd5b KR	412	/* Turn a howto into a reloc nunmber */
	413
	414	#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
	415	#define BADMAG(x) ARMBADMAG(x)
	416	#define ARM 1 /* Customize coffcode.h */
	417
	418
943fbd5b KR	419	/* We use the special COFF backend linker. */
	420	#define coff_relocate_section _bfd_coff_generic_relocate_section
	421
a5655244	422
943fbd5b KR	423	#include "coffcode.h"
943fbd5b KR	424
177b1932	425	const bfd_target
3ea928f5	426	#ifdef TARGET_LITTLE_SYM
177b1932 DE	427	TARGET_LITTLE_SYM =
	428	#else
	429	armcoff_little_vec =
	430	#endif
943fbd5b	431	{
177b1932 DE	432	#ifdef TARGET_LITTLE_NAME
	433	TARGET_LITTLE_NAME,
	434	#else
	435	"coff-arm-little",
	436	#endif
943fbd5b KR	437	bfd_target_coff_flavour,
	438	false, /* data byte order is little */
	439	false, /* header byte order is little */
	440
	441	(HAS_RELOC \| EXEC_P \| /* object flags */
	442	HAS_LINENO \| HAS_DEBUG \|
	443	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	444
	445	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	446	#ifdef TARGET_UNDERSCORE
	447	TARGET_UNDERSCORE, /* leading underscore */
	448	#else
	449	0, /* leading underscore */
	450	#endif
	451	'/', /* ar_pad_char */
	452	15, /* ar_max_namelen */
	453
943fbd5b KR	454	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	455	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	456	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
	457	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	458	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	459	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
	460
	461	/* Note that we allow an object file to be treated as a core file as well. */
da7afe3b SC	462	{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
da7afe3b SC	463	bfd_generic_archive_p, coff_object_p},
943fbd5b KR	464	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
	465	bfd_false},
	466	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
	467	_bfd_write_archive_contents, bfd_false},
	468
	469	BFD_JUMP_TABLE_GENERIC (coff),
	470	BFD_JUMP_TABLE_COPY (coff),
	471	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	472	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
	473	BFD_JUMP_TABLE_SYMBOLS (coff),
	474	BFD_JUMP_TABLE_RELOCS (coff),
	475	BFD_JUMP_TABLE_WRITE (coff),
	476	BFD_JUMP_TABLE_LINK (coff),
	477	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	478
	479	COFF_SWAP_TABLE,
	480	};
3ea928f5	481
177b1932	482	const bfd_target
3ea928f5	483	#ifdef TARGET_BIG_SYM
177b1932 DE	484	TARGET_BIG_SYM =
	485	#else
	486	armcoff_big_vec =
	487	#endif
3ea928f5	488	{
177b1932 DE	489	#ifdef TARGET_BIG_NAME
	490	TARGET_BIG_NAME,
	491	#else
	492	"coff-arm-big",
	493	#endif
3ea928f5 SC	494	bfd_target_coff_flavour,
	495	true, /* data byte order is big */
	496	true, /* header byte order is big */
	497
	498	(HAS_RELOC \| EXEC_P \| /* object flags */
	499	HAS_LINENO \| HAS_DEBUG \|
	500	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	501
	502	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	503	#ifdef TARGET_UNDERSCORE
	504	TARGET_UNDERSCORE, /* leading underscore */
	505	#else
	506	0, /* leading underscore */
	507	#endif
	508	'/', /* ar_pad_char */
	509	15, /* ar_max_namelen */
	510
3ea928f5 SC	511	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	512	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	513	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
	514	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	515	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	516	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
	517
	518	/* Note that we allow an object file to be treated as a core file as well. */
da7afe3b SC	519	{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
da7afe3b SC	520	bfd_generic_archive_p, coff_object_p},
3ea928f5 SC	521	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
	522	bfd_false},
	523	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
	524	_bfd_write_archive_contents, bfd_false},
	525
	526	BFD_JUMP_TABLE_GENERIC (coff),
	527	BFD_JUMP_TABLE_COPY (coff),
	528	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	529	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
	530	BFD_JUMP_TABLE_SYMBOLS (coff),
	531	BFD_JUMP_TABLE_RELOCS (coff),
	532	BFD_JUMP_TABLE_WRITE (coff),
	533	BFD_JUMP_TABLE_LINK (coff),
	534	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	535
	536	COFF_SWAP_TABLE,
	537	};