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

/* BFD back-end for raw ARM a.out binaries.
   Copyright 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005
   Free Software Foundation, Inc.
   Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)

   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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

#include "bfd.h"
#include "sysdep.h"

/* Avoid multiple definitions from aoutx if supporting standard a.out
   as well as our own.  */
/* Do not "beautify" the CONCAT* macro args.  Traditional C will not
   remove whitespace added here, and thus will fail to concatenate
   the tokens.  */
#define NAME(x,y) CONCAT3 (aoutarm,_32_,y)

#define N_TXTADDR(x)						\
  ((N_MAGIC (x) == NMAGIC)					\
   ? (bfd_vma) 0x8000						\
   : ((N_MAGIC (x) != ZMAGIC)					\
      ? (bfd_vma) 0						\
      : ((N_SHARED_LIB (x))					\
	 ? ((x).a_entry & ~(bfd_vma) (TARGET_PAGE_SIZE - 1))	\
	 : (bfd_vma) TEXT_START_ADDR)))

#define TEXT_START_ADDR 0x8000
#define TARGET_PAGE_SIZE 0x8000
#define SEGMENT_SIZE TARGET_PAGE_SIZE
#define DEFAULT_ARCH bfd_arch_arm

#define MY(OP) CONCAT2 (aoutarm_,OP)
#define N_BADMAG(x) ((((x).a_info & ~007200) != ZMAGIC) && \
                     (((x).a_info & ~006000) != OMAGIC) && \
                     ((x).a_info != NMAGIC))
#define N_MAGIC(x) ((x).a_info & ~07200)

#define MY_bfd_reloc_type_lookup aoutarm_bfd_reloc_type_lookup

#include "libaout.h"
#include "aout/aout64.h"

\f
static bfd_reloc_status_type
  MY (fix_pcrel_26) (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
static bfd_reloc_status_type
  MY (fix_pcrel_26_done) (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);

reloc_howto_type MY (howto_table)[] =
{
  /* Type rs size bsz pcrel bitpos ovrf sf name part_inpl
     readmask setmask pcdone.  */
  HOWTO (0, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, 0, "8", TRUE,
	 0x000000ff, 0x000000ff, FALSE),
  HOWTO (1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 0, "16", TRUE,
	 0x0000ffff, 0x0000ffff, FALSE),
  HOWTO (2, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "32", TRUE,
	 0xffffffff, 0xffffffff, FALSE),
  HOWTO (3, 2, 2, 26, TRUE, 0, complain_overflow_signed, MY (fix_pcrel_26),
	 "ARM26", TRUE, 0x00ffffff, 0x00ffffff, TRUE),
  HOWTO (4, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0, "DISP8", TRUE,
	 0x000000ff, 0x000000ff, TRUE),
  HOWTO (5, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0, "DISP16", TRUE,
	 0x0000ffff, 0x0000ffff, TRUE),
  HOWTO (6, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0, "DISP32", TRUE,
	 0xffffffff, 0xffffffff, TRUE),
  HOWTO (7, 2, 2, 26, FALSE, 0, complain_overflow_signed,
	 MY (fix_pcrel_26_done), "ARM26D", TRUE, 0x0, 0x0,
	 FALSE),
  EMPTY_HOWTO (-1),
  HOWTO (9, 0, -1, 16, FALSE, 0, complain_overflow_bitfield, 0, "NEG16", TRUE,
	 0x0000ffff, 0x0000ffff, FALSE),
  HOWTO (10, 0, -2, 32, FALSE, 0, complain_overflow_bitfield, 0, "NEG32", TRUE,
	 0xffffffff, 0xffffffff, FALSE)
};

#define RELOC_ARM_BITS_NEG_BIG      ((unsigned int) 0x08)
#define RELOC_ARM_BITS_NEG_LITTLE   ((unsigned int) 0x10)

static reloc_howto_type *
MY (reloc_howto) (bfd *abfd,
		  struct reloc_std_external *rel,
		  int *r_index,
		  int *r_extern,
		  int *r_pcrel)
{
  unsigned int r_length;
  unsigned int r_pcrel_done;
  unsigned int r_neg;
  int index;

  *r_pcrel = 0;
  if (bfd_header_big_endian (abfd))
    {
      *r_index     =  ((rel->r_index[0] << 16)
		       | (rel->r_index[1] << 8)
		       | rel->r_index[2]);
      *r_extern    = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
      r_pcrel_done = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
      r_neg 	   = (0 != (rel->r_type[0] & RELOC_ARM_BITS_NEG_BIG));
      r_length     = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
		      >> RELOC_STD_BITS_LENGTH_SH_BIG);
    }
  else
    {
      *r_index     = ((rel->r_index[2] << 16)
		      | (rel->r_index[1] << 8)
		      | rel->r_index[0]);
      *r_extern    = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
      r_pcrel_done = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
      r_neg 	   = (0 != (rel->r_type[0] & RELOC_ARM_BITS_NEG_LITTLE));
      r_length     = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
		      >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
    }
  index = r_length + 4 * r_pcrel_done + 8 * r_neg;
  if (index == 3)
    *r_pcrel = 1;

  return MY (howto_table) + index;
}

#define MY_reloc_howto(BFD, REL, IN, EX, PC) \
	MY (reloc_howto) (BFD, REL, &IN, &EX, &PC)

static void
MY (put_reloc) (bfd *abfd,
		int r_extern,
		int r_index,
		bfd_vma value,
		reloc_howto_type *howto,
		struct reloc_std_external *reloc)
{
  unsigned int r_length;
  int r_pcrel;
  int r_neg;

  PUT_WORD (abfd, value, reloc->r_address);
  /* Size as a power of two.  */
  r_length = howto->size;

  /* Special case for branch relocations.  */
  if (howto->type == 3 || howto->type == 7)
    r_length = 3;

  r_pcrel  = howto->type & 4; 	/* PC Relative done?  */
  r_neg = howto->type & 8;	/* Negative relocation.  */

  if (bfd_header_big_endian (abfd))
    {
      reloc->r_index[0] = r_index >> 16;
      reloc->r_index[1] = r_index >> 8;
      reloc->r_index[2] = r_index;
      reloc->r_type[0] =
	((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
	 | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
	 | (r_neg ?	 RELOC_ARM_BITS_NEG_BIG : 0)
	 | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
    }
  else
    {
      reloc->r_index[2] = r_index >> 16;
      reloc->r_index[1] = r_index >> 8;
      reloc->r_index[0] = r_index;
      reloc->r_type[0] =
	((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
	 | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
	 | (r_neg ?	 RELOC_ARM_BITS_NEG_LITTLE : 0)
	 | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
    }
}

#define MY_put_reloc(BFD, EXT, IDX, VAL, HOWTO, RELOC) \
  MY (put_reloc) (BFD, EXT, IDX, VAL, HOWTO, RELOC)

static void
MY (relocatable_reloc) (reloc_howto_type *howto,
			bfd *abfd,
			struct reloc_std_external *reloc,
			bfd_vma *amount,
			bfd_vma r_addr)
{
  if (howto->type == 3)
    {
      if (reloc->r_type[0]
	  & (bfd_header_big_endian (abfd)
	     ? RELOC_STD_BITS_EXTERN_BIG : RELOC_STD_BITS_EXTERN_LITTLE))
	/* The reloc is still external, so don't modify anything.  */
	*amount = 0;
      else
	{
	  *amount -= r_addr;
	  /* Change the r_pcrel value -- on the ARM, this bit is set once the
	     relocation is done.  */
	  if (bfd_header_big_endian (abfd))
	    reloc->r_type[0] |= RELOC_STD_BITS_PCREL_BIG;
	  else
	    reloc->r_type[0] |= RELOC_STD_BITS_PCREL_LITTLE;
	}
    }
  else if (howto->type == 7)
    *amount = 0;
}

#define MY_relocatable_reloc(HOW, BFD, REL, AMOUNT, ADDR) \
  MY (relocatable_reloc) (HOW, BFD, REL, &(AMOUNT), ADDR)

static bfd_reloc_status_type
MY (fix_pcrel_26_done) (bfd *abfd ATTRIBUTE_UNUSED,
			arelent *reloc_entry ATTRIBUTE_UNUSED,
			asymbol *symbol ATTRIBUTE_UNUSED,
			void * data ATTRIBUTE_UNUSED,
			asection *input_section ATTRIBUTE_UNUSED,
			bfd *output_bfd ATTRIBUTE_UNUSED,
			char **error_message ATTRIBUTE_UNUSED)
{
  /* This is dead simple at present.  */
  return bfd_reloc_ok;
}

static bfd_reloc_status_type
MY (fix_pcrel_26) (bfd *abfd,
		   arelent *reloc_entry,
		   asymbol *symbol,
		   void * data,
		   asection *input_section,
		   bfd *output_bfd,
		   char **error_message ATTRIBUTE_UNUSED)
{
  bfd_vma relocation;
  bfd_size_type addr = reloc_entry->address;
  bfd_vma 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_ok : 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 != NULL)
    return bfd_reloc_ok;

  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 & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
	flag = bfd_reloc_overflow;
    }
  else if (relocation & ~ (bfd_vma) 0x03ffffff)
    flag = bfd_reloc_overflow;

  target &= ~ (bfd_vma) 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 = &MY (howto_table)[7];

  return flag;
}

static reloc_howto_type *
MY (bfd_reloc_type_lookup) (bfd *abfd,
			    bfd_reloc_code_real_type code)
{
#define ASTD(i,j)       case i: return & MY (howto_table)[j]

  if (code == BFD_RELOC_CTOR)
    switch (bfd_get_arch_info (abfd)->bits_per_address)
      {
      case 32:
        code = BFD_RELOC_32;
        break;
      default:
	return NULL;
      }

  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);
    default:
      return NULL;
    }
}

#define MY_swap_std_reloc_in     MY (swap_std_reloc_in)
#define MY_swap_std_reloc_out    MY (swap_std_reloc_out)
#define MY_get_section_contents  _bfd_generic_get_section_contents

void MY_swap_std_reloc_in (bfd *, struct reloc_std_external *, arelent *, asymbol **, bfd_size_type);
void MY_swap_std_reloc_out (bfd *, arelent *, struct reloc_std_external *);

#include "aoutx.h"

void
MY_swap_std_reloc_in (bfd *abfd,
		      struct reloc_std_external *bytes,
		      arelent *cache_ptr,
		      asymbol **symbols,
		      bfd_size_type symcount ATTRIBUTE_UNUSED)
{
  int r_index;
  int r_extern;
  int r_pcrel;
  struct aoutdata *su = &(abfd->tdata.aout_data->a);

  cache_ptr->address = H_GET_32 (abfd, bytes->r_address);

  cache_ptr->howto = MY_reloc_howto (abfd, bytes, r_index, r_extern, r_pcrel);

  MOVE_ADDRESS (0);
}

void
MY_swap_std_reloc_out (bfd *abfd,
		       arelent *g,
		       struct reloc_std_external *natptr)
{
  int r_index;
  asymbol *sym = *(g->sym_ptr_ptr);
  int r_extern;
  int r_length;
  int r_pcrel;
  int r_neg = 0;	/* Negative relocs use the BASEREL bit.  */
  asection *output_section = sym->section->output_section;

  PUT_WORD (abfd, g->address, natptr->r_address);

  r_length = g->howto->size ;   /* Size as a power of two.  */
  if (r_length < 0)
    {
      r_length = -r_length;
      r_neg = 1;
    }

  r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC?  */

  /* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
     relocation has been done already (Only for the 26-bit one I think).  */
  if (g->howto->type == 3)
    {
      r_length = 3;
      r_pcrel = 0;
    }
  else if (g->howto->type == 7)
    {
      r_length = 3;
      r_pcrel = 1;
    }

  /* Name was clobbered by aout_write_syms to be symbol index.  */

  /* If this relocation is relative to a symbol then set the
     r_index to the symbols index, and the r_extern bit.

     Absolute symbols can come in in two ways, either as an offset
     from the abs section, or as a symbol which has an abs value.
     check for that here.  */

  if (bfd_is_com_section (output_section)
      || output_section == &bfd_abs_section
      || output_section == &bfd_und_section)
    {
      if (bfd_abs_section.symbol == sym)
	{
	  /* Whoops, looked like an abs symbol, but is really an offset
	     from the abs section.  */
	  r_index = 0;
	  r_extern = 0;
	}
      else
	{
	  /* Fill in symbol.  */
	  r_extern = 1;
	  r_index = (*(g->sym_ptr_ptr))->KEEPIT;
	}
    }
  else
    {
      /* Just an ordinary section.  */
      r_extern = 0;
      r_index  = output_section->target_index;
    }

  /* Now the fun stuff.  */
  if (bfd_header_big_endian (abfd))
    {
      natptr->r_index[0] = r_index >> 16;
      natptr->r_index[1] = r_index >> 8;
      natptr->r_index[2] = r_index;
      natptr->r_type[0] =
	(  (r_extern ?   RELOC_STD_BITS_EXTERN_BIG: 0)
	 | (r_pcrel  ?   RELOC_STD_BITS_PCREL_BIG: 0)
	 | (r_neg    ?   RELOC_ARM_BITS_NEG_BIG: 0)
	 | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
    }
  else
    {
      natptr->r_index[2] = r_index >> 16;
      natptr->r_index[1] = r_index >> 8;
      natptr->r_index[0] = r_index;
      natptr->r_type[0] =
	(  (r_extern ?   RELOC_STD_BITS_EXTERN_LITTLE: 0)
	 | (r_pcrel  ?   RELOC_STD_BITS_PCREL_LITTLE: 0)
	 | (r_neg    ?   RELOC_ARM_BITS_NEG_LITTLE: 0)
	 | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
    }
}

#define MY_BFD_TARGET

#include "aout-target.h"

extern const bfd_target aout_arm_big_vec;

const bfd_target aout_arm_little_vec =
{
  "a.out-arm-little",           /* Name.  */
  bfd_target_aout_flavour,
  BFD_ENDIAN_LITTLE,            /* Target byte order (little).  */
  BFD_ENDIAN_LITTLE,            /* Target headers byte order (little).  */
  (HAS_RELOC | EXEC_P |         /* Object flags.  */
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
  MY_symbol_leading_char,
  AR_PAD_CHAR,                  /* 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,	/* Headers.  */
  {_bfd_dummy_target, MY_object_p,		/* bfd_check_format.  */
   bfd_generic_archive_p, MY_core_file_p},
  {bfd_false, MY_mkobject,			/* bfd_set_format.  */
   _bfd_generic_mkarchive, bfd_false},
  {bfd_false, MY_write_object_contents,		/* bfd_write_contents.  */
   _bfd_write_archive_contents, bfd_false},

  BFD_JUMP_TABLE_GENERIC (MY),
  BFD_JUMP_TABLE_COPY (MY),
  BFD_JUMP_TABLE_CORE (MY),
  BFD_JUMP_TABLE_ARCHIVE (MY),
  BFD_JUMP_TABLE_SYMBOLS (MY),
  BFD_JUMP_TABLE_RELOCS (MY),
  BFD_JUMP_TABLE_WRITE (MY),
  BFD_JUMP_TABLE_LINK (MY),
  BFD_JUMP_TABLE_DYNAMIC (MY),

  & aout_arm_big_vec,

  (void *) MY_backend_data,
};

const bfd_target aout_arm_big_vec =
{
  "a.out-arm-big",              /* Name.  */
  bfd_target_aout_flavour,
  BFD_ENDIAN_BIG,               /* Target byte order (big).  */
  BFD_ENDIAN_BIG,               /* Target headers byte order (big).  */
  (HAS_RELOC | EXEC_P |         /* Object flags.  */
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
  MY_symbol_leading_char,
  AR_PAD_CHAR,                  		/* 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,	/* Headers.  */
  {_bfd_dummy_target, MY_object_p,		/* bfd_check_format.  */
   bfd_generic_archive_p, MY_core_file_p},
  {bfd_false, MY_mkobject,			/* bfd_set_format.  */
   _bfd_generic_mkarchive, bfd_false},
  {bfd_false, MY_write_object_contents,		/* bfd_write_contents.  */
   _bfd_write_archive_contents, bfd_false},

  BFD_JUMP_TABLE_GENERIC (MY),
  BFD_JUMP_TABLE_COPY (MY),
  BFD_JUMP_TABLE_CORE (MY),
  BFD_JUMP_TABLE_ARCHIVE (MY),
  BFD_JUMP_TABLE_SYMBOLS (MY),
  BFD_JUMP_TABLE_RELOCS (MY),
  BFD_JUMP_TABLE_WRITE (MY),
  BFD_JUMP_TABLE_LINK (MY),
  BFD_JUMP_TABLE_DYNAMIC (MY),

  & aout_arm_little_vec,

  (void *) MY_backend_data,
};
Commit	Line	Data
252b5132	1	/* BFD back-end for raw ARM a.out binaries.
9553c638	2	Copyright 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005
7898deda	3	Free Software Foundation, Inc.
252b5132	4	Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
c4dfa77f	5
7920ce38	6	This file is part of BFD, the Binary File Descriptor library.
252b5132	7
7920ce38 NC	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
252b5132	12
7920ce38 NC	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
252b5132	17
7920ce38 NC	18	You should have received a copy of the GNU General Public License
7920ce38 NC	19	along with this program; if not, write to the Free Software
3e110533	20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
252b5132	21
1725a96e NC	22	#include "bfd.h"
1725a96e NC	23	#include "sysdep.h"
e43d48cc	24
5c4491d3	25	/* Avoid multiple definitions from aoutx if supporting standard a.out
1725a96e	26	as well as our own. */
e43d48cc AM	27	/* Do not "beautify" the CONCAT* macro args. Traditional C will not
	28	remove whitespace added here, and thus will fail to concatenate
	29	the tokens. */
	30	#define NAME(x,y) CONCAT3 (aoutarm,_32_,y)
1725a96e	31
dc810e39 AM	32	#define N_TXTADDR(x) \
	33	((N_MAGIC (x) == NMAGIC) \
	34	? (bfd_vma) 0x8000 \
	35	: ((N_MAGIC (x) != ZMAGIC) \
	36	? (bfd_vma) 0 \
	37	: ((N_SHARED_LIB (x)) \
	38	? ((x).a_entry & ~(bfd_vma) (TARGET_PAGE_SIZE - 1)) \
	39	: (bfd_vma) TEXT_START_ADDR)))
252b5132 RH	40
	41	#define TEXT_START_ADDR 0x8000
	42	#define TARGET_PAGE_SIZE 0x8000
	43	#define SEGMENT_SIZE TARGET_PAGE_SIZE
	44	#define DEFAULT_ARCH bfd_arch_arm
	45
e43d48cc	46	#define MY(OP) CONCAT2 (aoutarm_,OP)
252b5132 RH	47	#define N_BADMAG(x) ((((x).a_info & ~007200) != ZMAGIC) && \
	48	(((x).a_info & ~006000) != OMAGIC) && \
	49	((x).a_info != NMAGIC))
	50	#define N_MAGIC(x) ((x).a_info & ~07200)
	51
252b5132 RH	52	#define MY_bfd_reloc_type_lookup aoutarm_bfd_reloc_type_lookup
252b5132 RH	53
dc810e39 AM	54	#include "libaout.h"
	55	#include "aout/aout64.h"
	56
1725a96e	57	\f
7920ce38 NC	58	static bfd_reloc_status_type
	59	MY (fix_pcrel_26) (bfd , arelent , asymbol , void , asection , bfd , char **);
	60	static bfd_reloc_status_type
	61	MY (fix_pcrel_26_done) (bfd , arelent , asymbol , void , asection , bfd , char **);
	62
	63	reloc_howto_type MY (howto_table)[] =
	64	{
	65	/* Type rs size bsz pcrel bitpos ovrf sf name part_inpl
	66	readmask setmask pcdone. */
	67	HOWTO (0, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, 0, "8", TRUE,
	68	0x000000ff, 0x000000ff, FALSE),
	69	HOWTO (1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 0, "16", TRUE,
	70	0x0000ffff, 0x0000ffff, FALSE),
	71	HOWTO (2, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "32", TRUE,
	72	0xffffffff, 0xffffffff, FALSE),
	73	HOWTO (3, 2, 2, 26, TRUE, 0, complain_overflow_signed, MY (fix_pcrel_26),
	74	"ARM26", TRUE, 0x00ffffff, 0x00ffffff, TRUE),
	75	HOWTO (4, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0, "DISP8", TRUE,
	76	0x000000ff, 0x000000ff, TRUE),
	77	HOWTO (5, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0, "DISP16", TRUE,
	78	0x0000ffff, 0x0000ffff, TRUE),
	79	HOWTO (6, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0, "DISP32", TRUE,
	80	0xffffffff, 0xffffffff, TRUE),
	81	HOWTO (7, 2, 2, 26, FALSE, 0, complain_overflow_signed,
	82	MY (fix_pcrel_26_done), "ARM26D", TRUE, 0x0, 0x0,
	83	FALSE),
	84	EMPTY_HOWTO (-1),
	85	HOWTO (9, 0, -1, 16, FALSE, 0, complain_overflow_bitfield, 0, "NEG16", TRUE,
	86	0x0000ffff, 0x0000ffff, FALSE),
	87	HOWTO (10, 0, -2, 32, FALSE, 0, complain_overflow_bitfield, 0, "NEG32", TRUE,
	88	0xffffffff, 0xffffffff, FALSE)
	89	};
252b5132 RH	90
	91	#define RELOC_ARM_BITS_NEG_BIG ((unsigned int) 0x08)
	92	#define RELOC_ARM_BITS_NEG_LITTLE ((unsigned int) 0x10)
	93
7920ce38 NC	94	static reloc_howto_type *
	95	MY (reloc_howto) (bfd *abfd,
	96	struct reloc_std_external *rel,
	97	int *r_index,
	98	int *r_extern,
	99	int *r_pcrel)
252b5132 RH	100	{
	101	unsigned int r_length;
	102	unsigned int r_pcrel_done;
	103	unsigned int r_neg;
	104	int index;
	105
	106	*r_pcrel = 0;
	107	if (bfd_header_big_endian (abfd))
	108	{
	109	*r_index = ((rel->r_index[0] << 16)
	110	\| (rel->r_index[1] << 8)
	111	\| rel->r_index[2]);
	112	*r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
	113	r_pcrel_done = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
	114	r_neg = (0 != (rel->r_type[0] & RELOC_ARM_BITS_NEG_BIG));
	115	r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
	116	>> RELOC_STD_BITS_LENGTH_SH_BIG);
	117	}
	118	else
	119	{
	120	*r_index = ((rel->r_index[2] << 16)
	121	\| (rel->r_index[1] << 8)
	122	\| rel->r_index[0]);
	123	*r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
	124	r_pcrel_done = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
	125	r_neg = (0 != (rel->r_type[0] & RELOC_ARM_BITS_NEG_LITTLE));
	126	r_length = ((rel->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
	127	>> RELOC_STD_BITS_LENGTH_SH_LITTLE);
	128	}
	129	index = r_length + 4 * r_pcrel_done + 8 * r_neg;
	130	if (index == 3)
	131	*r_pcrel = 1;
	132
7920ce38	133	return MY (howto_table) + index;
252b5132	134	}
c4dfa77f	135
252b5132	136	#define MY_reloc_howto(BFD, REL, IN, EX, PC) \
7920ce38	137	MY (reloc_howto) (BFD, REL, &IN, &EX, &PC)
252b5132	138
7920ce38 NC	139	static void
	140	MY (put_reloc) (bfd *abfd,
	141	int r_extern,
	142	int r_index,
	143	bfd_vma value,
	144	reloc_howto_type *howto,
	145	struct reloc_std_external *reloc)
252b5132 RH	146	{
	147	unsigned int r_length;
	148	int r_pcrel;
	149	int r_neg;
	150
	151	PUT_WORD (abfd, value, reloc->r_address);
1725a96e NC	152	/* Size as a power of two. */
1725a96e NC	153	r_length = howto->size;
252b5132	154
c4dfa77f	155	/* Special case for branch relocations. */
252b5132 RH	156	if (howto->type == 3 \|\| howto->type == 7)
	157	r_length = 3;
	158
1725a96e NC	159	r_pcrel = howto->type & 4; /* PC Relative done? */
	160	r_neg = howto->type & 8; /* Negative relocation. */
	161
252b5132 RH	162	if (bfd_header_big_endian (abfd))
	163	{
	164	reloc->r_index[0] = r_index >> 16;
	165	reloc->r_index[1] = r_index >> 8;
	166	reloc->r_index[2] = r_index;
	167	reloc->r_type[0] =
	168	((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
	169	\| (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
	170	\| (r_neg ? RELOC_ARM_BITS_NEG_BIG : 0)
	171	\| (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
	172	}
	173	else
	174	{
	175	reloc->r_index[2] = r_index >> 16;
	176	reloc->r_index[1] = r_index >> 8;
	177	reloc->r_index[0] = r_index;
	178	reloc->r_type[0] =
	179	((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
	180	\| (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
	181	\| (r_neg ? RELOC_ARM_BITS_NEG_LITTLE : 0)
	182	\| (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
	183	}
	184	}
c4dfa77f	185
252b5132	186	#define MY_put_reloc(BFD, EXT, IDX, VAL, HOWTO, RELOC) \
7920ce38	187	MY (put_reloc) (BFD, EXT, IDX, VAL, HOWTO, RELOC)
252b5132	188
7920ce38 NC	189	static void
	190	MY (relocatable_reloc) (reloc_howto_type *howto,
	191	bfd *abfd,
	192	struct reloc_std_external *reloc,
	193	bfd_vma *amount,
	194	bfd_vma r_addr)
252b5132 RH	195	{
	196	if (howto->type == 3)
	197	{
c4dfa77f	198	if (reloc->r_type[0]
252b5132 RH	199	& (bfd_header_big_endian (abfd)
252b5132 RH	200	? RELOC_STD_BITS_EXTERN_BIG : RELOC_STD_BITS_EXTERN_LITTLE))
7920ce38 NC	201	/* The reloc is still external, so don't modify anything. */
7920ce38 NC	202	*amount = 0;
252b5132 RH	203	else
	204	{
	205	*amount -= r_addr;
	206	/* Change the r_pcrel value -- on the ARM, this bit is set once the
	207	relocation is done. */
	208	if (bfd_header_big_endian (abfd))
	209	reloc->r_type[0] \|= RELOC_STD_BITS_PCREL_BIG;
	210	else
	211	reloc->r_type[0] \|= RELOC_STD_BITS_PCREL_LITTLE;
	212	}
	213	}
	214	else if (howto->type == 7)
	215	*amount = 0;
	216	}
	217
	218	#define MY_relocatable_reloc(HOW, BFD, REL, AMOUNT, ADDR) \
7920ce38	219	MY (relocatable_reloc) (HOW, BFD, REL, &(AMOUNT), ADDR)
252b5132 RH	220
252b5132 RH	221	static bfd_reloc_status_type
7920ce38 NC	222	MY (fix_pcrel_26_done) (bfd *abfd ATTRIBUTE_UNUSED,
	223	arelent *reloc_entry ATTRIBUTE_UNUSED,
	224	asymbol *symbol ATTRIBUTE_UNUSED,
	225	void * data ATTRIBUTE_UNUSED,
	226	asection *input_section ATTRIBUTE_UNUSED,
	227	bfd *output_bfd ATTRIBUTE_UNUSED,
	228	char **error_message ATTRIBUTE_UNUSED)
252b5132 RH	229	{
	230	/* This is dead simple at present. */
	231	return bfd_reloc_ok;
	232	}
	233
	234	static bfd_reloc_status_type
7920ce38 NC	235	MY (fix_pcrel_26) (bfd *abfd,
	236	arelent *reloc_entry,
	237	asymbol *symbol,
	238	void * data,
	239	asection *input_section,
	240	bfd *output_bfd,
	241	char **error_message ATTRIBUTE_UNUSED)
252b5132 RH	242	{
	243	bfd_vma relocation;
	244	bfd_size_type addr = reloc_entry->address;
dc810e39	245	bfd_vma target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
252b5132	246	bfd_reloc_status_type flag = bfd_reloc_ok;
c4dfa77f	247
1725a96e	248	/* If this is an undefined symbol, return error. */
252b5132 RH	249	if (symbol->section == &bfd_und_section
	250	&& (symbol->flags & BSF_WEAK) == 0)
	251	return output_bfd ? bfd_reloc_ok : bfd_reloc_undefined;
	252
	253	/* If the sections are different, and we are doing a partial relocation,
	254	just ignore it for now. */
	255	if (symbol->section->name != input_section->name
7920ce38	256	&& output_bfd != NULL)
252b5132 RH	257	return bfd_reloc_ok;
	258
	259	relocation = (target & 0x00ffffff) << 2;
1725a96e	260	relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend. */
252b5132 RH	261	relocation += symbol->value;
	262	relocation += symbol->section->output_section->vma;
	263	relocation += symbol->section->output_offset;
	264	relocation += reloc_entry->addend;
	265	relocation -= input_section->output_section->vma;
	266	relocation -= input_section->output_offset;
	267	relocation -= addr;
	268	if (relocation & 3)
	269	return bfd_reloc_overflow;
	270
1725a96e	271	/* Check for overflow. */
252b5132 RH	272	if (relocation & 0x02000000)
	273	{
	274	if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
	275	flag = bfd_reloc_overflow;
	276	}
dc810e39	277	else if (relocation & ~ (bfd_vma) 0x03ffffff)
252b5132 RH	278	flag = bfd_reloc_overflow;
252b5132 RH	279
dc810e39	280	target &= ~ (bfd_vma) 0x00ffffff;
252b5132 RH	281	target \|= (relocation >> 2) & 0x00ffffff;
	282	bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
	283
	284	/* Now the ARM magic... Change the reloc type so that it is marked as done.
	285	Strictly this is only necessary if we are doing a partial relocation. */
7920ce38	286	reloc_entry->howto = &MY (howto_table)[7];
c4dfa77f	287
252b5132 RH	288	return flag;
	289	}
	290
7920ce38 NC	291	static reloc_howto_type *
	292	MY (bfd_reloc_type_lookup) (bfd *abfd,
	293	bfd_reloc_code_real_type code)
252b5132	294	{
7920ce38 NC	295	#define ASTD(i,j) case i: return & MY (howto_table)[j]
7920ce38 NC	296
252b5132 RH	297	if (code == BFD_RELOC_CTOR)
	298	switch (bfd_get_arch_info (abfd)->bits_per_address)
	299	{
	300	case 32:
	301	code = BFD_RELOC_32;
	302	break;
1725a96e	303	default:
7920ce38	304	return NULL;
252b5132 RH	305	}
	306
	307	switch (code)
	308	{
	309	ASTD (BFD_RELOC_16, 1);
	310	ASTD (BFD_RELOC_32, 2);
	311	ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
	312	ASTD (BFD_RELOC_8_PCREL, 4);
	313	ASTD (BFD_RELOC_16_PCREL, 5);
	314	ASTD (BFD_RELOC_32_PCREL, 6);
1725a96e	315	default:
7920ce38	316	return NULL;
252b5132 RH	317	}
	318	}
	319
7920ce38 NC	320	#define MY_swap_std_reloc_in MY (swap_std_reloc_in)
	321	#define MY_swap_std_reloc_out MY (swap_std_reloc_out)
	322	#define MY_get_section_contents _bfd_generic_get_section_contents
	323
	324	void MY_swap_std_reloc_in (bfd , struct reloc_std_external , arelent , asymbol *, bfd_size_type);
	325	void MY_swap_std_reloc_out (bfd , arelent , struct reloc_std_external *);
252b5132 RH	326
	327	#include "aoutx.h"
	328
7920ce38 NC	329	void
	330	MY_swap_std_reloc_in (bfd *abfd,
	331	struct reloc_std_external *bytes,
	332	arelent *cache_ptr,
	333	asymbol **symbols,
	334	bfd_size_type symcount ATTRIBUTE_UNUSED)
252b5132 RH	335	{
	336	int r_index;
	337	int r_extern;
	338	int r_pcrel;
	339	struct aoutdata *su = &(abfd->tdata.aout_data->a);
	340
dc810e39	341	cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
252b5132 RH	342
	343	cache_ptr->howto = MY_reloc_howto (abfd, bytes, r_index, r_extern, r_pcrel);
	344
	345	MOVE_ADDRESS (0);
	346	}
	347
	348	void
7920ce38 NC	349	MY_swap_std_reloc_out (bfd *abfd,
	350	arelent *g,
	351	struct reloc_std_external *natptr)
252b5132 RH	352	{
	353	int r_index;
	354	asymbol sym = (g->sym_ptr_ptr);
	355	int r_extern;
	356	int r_length;
	357	int r_pcrel;
	358	int r_neg = 0; /* Negative relocs use the BASEREL bit. */
	359	asection *output_section = sym->section->output_section;
	360
7920ce38	361	PUT_WORD (abfd, g->address, natptr->r_address);
252b5132	362
7920ce38	363	r_length = g->howto->size ; /* Size as a power of two. */
252b5132 RH	364	if (r_length < 0)
	365	{
	366	r_length = -r_length;
	367	r_neg = 1;
	368	}
	369
7920ce38	370	r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
252b5132 RH	371
252b5132 RH	372	/* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
7920ce38	373	relocation has been done already (Only for the 26-bit one I think). */
252b5132 RH	374	if (g->howto->type == 3)
	375	{
	376	r_length = 3;
	377	r_pcrel = 0;
	378	}
	379	else if (g->howto->type == 7)
c4dfa77f	380	{
252b5132 RH	381	r_length = 3;
	382	r_pcrel = 1;
	383	}
252b5132	384
7920ce38	385	/* Name was clobbered by aout_write_syms to be symbol index. */
252b5132 RH	386
	387	/* If this relocation is relative to a symbol then set the
	388	r_index to the symbols index, and the r_extern bit.
	389
	390	Absolute symbols can come in in two ways, either as an offset
	391	from the abs section, or as a symbol which has an abs value.
7920ce38	392	check for that here. */
252b5132 RH	393
	394	if (bfd_is_com_section (output_section)
	395	\|\| output_section == &bfd_abs_section
	396	\|\| output_section == &bfd_und_section)
	397	{
	398	if (bfd_abs_section.symbol == sym)
	399	{
	400	/* Whoops, looked like an abs symbol, but is really an offset
1725a96e	401	from the abs section. */
252b5132 RH	402	r_index = 0;
	403	r_extern = 0;
	404	}
	405	else
	406	{
1725a96e	407	/* Fill in symbol. */
252b5132 RH	408	r_extern = 1;
	409	r_index = (*(g->sym_ptr_ptr))->KEEPIT;
	410	}
	411	}
	412	else
	413	{
1725a96e	414	/* Just an ordinary section. */
252b5132 RH	415	r_extern = 0;
	416	r_index = output_section->target_index;
	417	}
	418
1725a96e	419	/* Now the fun stuff. */
252b5132 RH	420	if (bfd_header_big_endian (abfd))
	421	{
	422	natptr->r_index[0] = r_index >> 16;
	423	natptr->r_index[1] = r_index >> 8;
	424	natptr->r_index[2] = r_index;
	425	natptr->r_type[0] =
	426	( (r_extern ? RELOC_STD_BITS_EXTERN_BIG: 0)
	427	\| (r_pcrel ? RELOC_STD_BITS_PCREL_BIG: 0)
	428	\| (r_neg ? RELOC_ARM_BITS_NEG_BIG: 0)
	429	\| (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
	430	}
	431	else
	432	{
	433	natptr->r_index[2] = r_index >> 16;
	434	natptr->r_index[1] = r_index >> 8;
	435	natptr->r_index[0] = r_index;
	436	natptr->r_type[0] =
	437	( (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE: 0)
	438	\| (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE: 0)
	439	\| (r_neg ? RELOC_ARM_BITS_NEG_LITTLE: 0)
	440	\| (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
	441	}
	442	}
	443
	444	#define MY_BFD_TARGET
	445
	446	#include "aout-target.h"
	447
c3c89269 NC	448	extern const bfd_target aout_arm_big_vec;
c3c89269 NC	449
252b5132	450	const bfd_target aout_arm_little_vec =
7920ce38 NC	451	{
	452	"a.out-arm-little", /* Name. */
	453	bfd_target_aout_flavour,
	454	BFD_ENDIAN_LITTLE, /* Target byte order (little). */
	455	BFD_ENDIAN_LITTLE, /* Target headers byte order (little). */
	456	(HAS_RELOC \| EXEC_P \| /* Object flags. */
	457	HAS_LINENO \| HAS_DEBUG \|
	458	HAS_SYMS \| HAS_LOCALS \| DYNAMIC \| WP_TEXT \| D_PAGED),
	459	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC \| SEC_CODE \| SEC_DATA),
	460	MY_symbol_leading_char,
	461	AR_PAD_CHAR, /* AR_pad_char. */
	462	15, /* AR_max_namelen. */
	463	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	464	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	465	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
	466	bfd_getl64, bfd_getl_signed_64, bfd_putl64,
	467	bfd_getl32, bfd_getl_signed_32, bfd_putl32,
	468	bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */
	469	{_bfd_dummy_target, MY_object_p, /* bfd_check_format. */
	470	bfd_generic_archive_p, MY_core_file_p},
	471	{bfd_false, MY_mkobject, /* bfd_set_format. */
	472	_bfd_generic_mkarchive, bfd_false},
	473	{bfd_false, MY_write_object_contents, /* bfd_write_contents. */
	474	_bfd_write_archive_contents, bfd_false},
	475
	476	BFD_JUMP_TABLE_GENERIC (MY),
	477	BFD_JUMP_TABLE_COPY (MY),
	478	BFD_JUMP_TABLE_CORE (MY),
	479	BFD_JUMP_TABLE_ARCHIVE (MY),
	480	BFD_JUMP_TABLE_SYMBOLS (MY),
	481	BFD_JUMP_TABLE_RELOCS (MY),
	482	BFD_JUMP_TABLE_WRITE (MY),
	483	BFD_JUMP_TABLE_LINK (MY),
	484	BFD_JUMP_TABLE_DYNAMIC (MY),
	485
	486	& aout_arm_big_vec,
	487
	488	(void *) MY_backend_data,
	489	};
252b5132 RH	490
252b5132 RH	491	const bfd_target aout_arm_big_vec =
7920ce38 NC	492	{
	493	"a.out-arm-big", /* Name. */
	494	bfd_target_aout_flavour,
	495	BFD_ENDIAN_BIG, /* Target byte order (big). */
	496	BFD_ENDIAN_BIG, /* Target headers byte order (big). */
	497	(HAS_RELOC \| EXEC_P \| /* Object flags. */
	498	HAS_LINENO \| HAS_DEBUG \|
	499	HAS_SYMS \| HAS_LOCALS \| DYNAMIC \| WP_TEXT \| D_PAGED),
	500	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC \| SEC_CODE \| SEC_DATA),
	501	MY_symbol_leading_char,
	502	AR_PAD_CHAR, /* AR_pad_char. */
	503	15, /* AR_max_namelen. */
	504	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	505	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	506	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
	507	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	508	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	509	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
	510	{_bfd_dummy_target, MY_object_p, /* bfd_check_format. */
	511	bfd_generic_archive_p, MY_core_file_p},
	512	{bfd_false, MY_mkobject, /* bfd_set_format. */
	513	_bfd_generic_mkarchive, bfd_false},
	514	{bfd_false, MY_write_object_contents, /* bfd_write_contents. */
	515	_bfd_write_archive_contents, bfd_false},
	516
	517	BFD_JUMP_TABLE_GENERIC (MY),
	518	BFD_JUMP_TABLE_COPY (MY),
	519	BFD_JUMP_TABLE_CORE (MY),
	520	BFD_JUMP_TABLE_ARCHIVE (MY),
	521	BFD_JUMP_TABLE_SYMBOLS (MY),
	522	BFD_JUMP_TABLE_RELOCS (MY),
	523	BFD_JUMP_TABLE_WRITE (MY),
	524	BFD_JUMP_TABLE_LINK (MY),
	525	BFD_JUMP_TABLE_DYNAMIC (MY),
	526
	527	& aout_arm_little_vec,
	528
	529	(void *) MY_backend_data,
	530	};