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

/* BFD back-end for Intel 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),
};


#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"

#ifdef TARGET_LITTLE_SYM
const bfd_target TARGET_LITTLE_SYM =
{
  TARGET_LITTLE_NAME,		/* name or coff-arm-little */
  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,
};
#endif

#ifdef TARGET_BIG_SYM
const bfd_target TARGET_BIG_SYM =
{
  TARGET_BIG_NAME,		/* name or coff-arm-big */
  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,
};
#endif
Commit	Line	Data
943fbd5b KR	1	/* BFD back-end for Intel arm COFF files.
	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 KR	261	};
	262
	263
943fbd5b KR	264	#define RTYPE2HOWTO(cache_ptr, dst) \
	265	(cache_ptr)->howto = aoutarm_std_reloc_howto + (dst)->r_type;
	266
275143eb	267	#define coff_rtype_to_howto coff_arm_rtype_to_howto
a5655244	268
275143eb SC	269	static reloc_howto_type *
	270	coff_arm_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
	271	bfd *abfd;
	272	asection *sec;
	273	struct internal_reloc *rel;
	274	struct coff_link_hash_entry *h;
	275	struct internal_syment *sym;
	276	bfd_vma *addendp;
	277	{
	278	reloc_howto_type *howto;
	279
	280	howto = aoutarm_std_reloc_howto + rel->r_type;
	281
	282	if (rel->r_type == 11)
	283	{
a5655244	284	*addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
275143eb SC	285	}
	286	return howto;
	287
	288	}
	289	/* Used by the assembler. */
	290
943fbd5b KR	291	static bfd_reloc_status_type
	292	aoutarm_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
	293	output_bfd, error_message)
	294	bfd *abfd;
	295	arelent *reloc_entry;
	296	asymbol *symbol;
	297	PTR data;
	298	asection *input_section;
	299	bfd *output_bfd;
	300	char **error_message;
	301	{
	302	/* This is dead simple at present. */
	303	return bfd_reloc_ok;
	304	}
	305
275143eb SC	306	/* Used by the assembler. */
275143eb SC	307
943fbd5b KR	308	static bfd_reloc_status_type
	309	aoutarm_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
	310	output_bfd, error_message)
	311	bfd *abfd;
	312	arelent *reloc_entry;
	313	asymbol *symbol;
	314	PTR data;
	315	asection *input_section;
	316	bfd *output_bfd;
	317	char **error_message;
	318	{
	319	bfd_vma relocation;
	320	bfd_size_type addr = reloc_entry->address;
	321	long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
	322	bfd_reloc_status_type flag = bfd_reloc_ok;
	323
	324	/* If this is an undefined symbol, return error */
	325	if (symbol->section == &bfd_und_section
	326	&& (symbol->flags & BSF_WEAK) == 0)
	327	return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
	328
	329	/* If the sections are different, and we are doing a partial relocation,
	330	just ignore it for now. */
	331	if (symbol->section->name != input_section->name
	332	&& output_bfd != (bfd *)NULL)
	333	return bfd_reloc_continue;
	334
	335	relocation = (target & 0x00ffffff) << 2;
	336	relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
	337	relocation += symbol->value;
	338	relocation += symbol->section->output_section->vma;
	339	relocation += symbol->section->output_offset;
	340	relocation += reloc_entry->addend;
	341	relocation -= input_section->output_section->vma;
	342	relocation -= input_section->output_offset;
	343	relocation -= addr;
	344	if (relocation & 3)
	345	return bfd_reloc_overflow;
	346
	347	/* Check for overflow */
	348	if (relocation & 0x02000000)
	349	{
	350	if ((relocation & ~0x03ffffff) != ~0x03ffffff)
	351	flag = bfd_reloc_overflow;
	352	}
	353	else if (relocation & ~0x03ffffff)
	354	flag = bfd_reloc_overflow;
	355
	356	target &= ~0x00ffffff;
	357	target \|= (relocation >> 2) & 0x00ffffff;
	358	bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
	359
	360	/* Now the ARM magic... Change the reloc type so that it is marked as done.
	361	Strictly this is only necessary if we are doing a partial relocation. */
	362	reloc_entry->howto = &aoutarm_std_reloc_howto[7];
275143eb	363
943fbd5b KR	364	return flag;
	365	}
	366
275143eb	367
943fbd5b KR	368	static CONST struct reloc_howto_struct *
	369	arm_reloc_type_lookup(abfd,code)
	370	bfd *abfd;
	371	bfd_reloc_code_real_type code;
	372	{
	373	#define ASTD(i,j) case i: return &aoutarm_std_reloc_howto[j]
	374	if (code == BFD_RELOC_CTOR)
	375	switch (bfd_get_arch_info (abfd)->bits_per_address)
	376	{
	377	case 32:
	378	code = BFD_RELOC_32;
	379	break;
	380	default: return (CONST struct reloc_howto_struct *) 0;
	381	}
	382
	383	switch (code)
	384	{
	385	ASTD (BFD_RELOC_16, 1);
	386	ASTD (BFD_RELOC_32, 2);
	387	ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
	388	ASTD (BFD_RELOC_8_PCREL, 4);
	389	ASTD (BFD_RELOC_16_PCREL, 5);
	390	ASTD (BFD_RELOC_32_PCREL, 6);
3ea928f5	391	ASTD (BFD_RELOC_RVA, 11);
943fbd5b KR	392	default: return (CONST struct reloc_howto_struct *) 0;
	393	}
	394	}
	395
	396
	397	#define coff_bfd_reloc_type_lookup arm_reloc_type_lookup
	398
943fbd5b	399	#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
943fbd5b	400	#define COFF_PAGE_SIZE 0x1000
943fbd5b KR	401	/* Turn a howto into a reloc nunmber */
	402
	403	#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
	404	#define BADMAG(x) ARMBADMAG(x)
	405	#define ARM 1 /* Customize coffcode.h */
	406
	407
943fbd5b KR	408	/* We use the special COFF backend linker. */
	409	#define coff_relocate_section _bfd_coff_generic_relocate_section
	410
a5655244	411
943fbd5b KR	412	#include "coffcode.h"
943fbd5b KR	413
3ea928f5 SC	414	#ifdef TARGET_LITTLE_SYM
3ea928f5 SC	415	const bfd_target TARGET_LITTLE_SYM =
943fbd5b	416	{
3ea928f5	417	TARGET_LITTLE_NAME, /* name or coff-arm-little */
943fbd5b KR	418	bfd_target_coff_flavour,
	419	false, /* data byte order is little */
	420	false, /* header byte order is little */
	421
	422	(HAS_RELOC \| EXEC_P \| /* object flags */
	423	HAS_LINENO \| HAS_DEBUG \|
	424	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	425
	426	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	427	#ifdef TARGET_UNDERSCORE
	428	TARGET_UNDERSCORE, /* leading underscore */
	429	#else
	430	0, /* leading underscore */
	431	#endif
	432	'/', /* ar_pad_char */
	433	15, /* ar_max_namelen */
	434
943fbd5b KR	435	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	436	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	437	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
	438	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	439	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	440	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
	441
	442	/* Note that we allow an object file to be treated as a core file as well. */
da7afe3b SC	443	{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
da7afe3b SC	444	bfd_generic_archive_p, coff_object_p},
943fbd5b KR	445	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
	446	bfd_false},
	447	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
	448	_bfd_write_archive_contents, bfd_false},
	449
	450	BFD_JUMP_TABLE_GENERIC (coff),
	451	BFD_JUMP_TABLE_COPY (coff),
	452	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	453	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
	454	BFD_JUMP_TABLE_SYMBOLS (coff),
	455	BFD_JUMP_TABLE_RELOCS (coff),
	456	BFD_JUMP_TABLE_WRITE (coff),
	457	BFD_JUMP_TABLE_LINK (coff),
	458	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	459
	460	COFF_SWAP_TABLE,
	461	};
3ea928f5 SC	462	#endif
	463
	464	#ifdef TARGET_BIG_SYM
	465	const bfd_target TARGET_BIG_SYM =
	466	{
	467	TARGET_BIG_NAME, /* name or coff-arm-big */
	468	bfd_target_coff_flavour,
	469	true, /* data byte order is big */
	470	true, /* header byte order is big */
	471
	472	(HAS_RELOC \| EXEC_P \| /* object flags */
	473	HAS_LINENO \| HAS_DEBUG \|
	474	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	475
	476	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	477	#ifdef TARGET_UNDERSCORE
	478	TARGET_UNDERSCORE, /* leading underscore */
	479	#else
	480	0, /* leading underscore */
	481	#endif
	482	'/', /* ar_pad_char */
	483	15, /* ar_max_namelen */
	484
3ea928f5 SC	485	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	486	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	487	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
	488	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	489	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	490	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
	491
	492	/* Note that we allow an object file to be treated as a core file as well. */
da7afe3b SC	493	{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
da7afe3b SC	494	bfd_generic_archive_p, coff_object_p},
3ea928f5 SC	495	{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
	496	bfd_false},
	497	{bfd_false, coff_write_object_contents, /* bfd_write_contents */
	498	_bfd_write_archive_contents, bfd_false},
	499
	500	BFD_JUMP_TABLE_GENERIC (coff),
	501	BFD_JUMP_TABLE_COPY (coff),
	502	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	503	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
	504	BFD_JUMP_TABLE_SYMBOLS (coff),
	505	BFD_JUMP_TABLE_RELOCS (coff),
	506	BFD_JUMP_TABLE_WRITE (coff),
	507	BFD_JUMP_TABLE_LINK (coff),
	508	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	509
	510	COFF_SWAP_TABLE,
	511	};
	512	#endif