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

/* BFD back-end for Motorola MCore COFF/PE
   Copyright (C) 1999 Free Software Foundation, Inc.

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, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "coff/mcore.h"
#include "coff/internal.h"
#include "coff/pe.h"
#include "libcoff.h"

#ifdef BADMAG
#undef BADMAG
#endif
#define BADMAG(x) MCOREBADMAG(x)

#ifndef NUM_ELEM
#define NUM_ELEM(A) (sizeof (A) / sizeof (A)[0])
#endif

/* This file is compiled more than once, but we only compile the
   final_link routine once.  */
extern boolean mcore_bfd_coff_final_link
  PARAMS ((bfd *, struct bfd_link_info *));

static struct bfd_link_hash_table * coff_mcore_link_hash_table_create
  PARAMS ((bfd *));
static bfd_reloc_status_type        mcore_coff_unsupported_reloc
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static boolean                      coff_mcore_relocate_section
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
	   struct internal_reloc *, struct internal_syment *, asection **));
static reloc_howto_type *           mcore_coff_reloc_type_lookup
  PARAMS ((bfd *, bfd_reloc_code_real_type));
static reloc_howto_type *           coff_mcore_rtype_to_howto
  PARAMS ((bfd *, asection *, struct internal_reloc *,
	   struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
\f
/* The NT loader points the toc register to &toc + 32768, in order to
   use the complete range of a 16-bit displacement. We have to adjust
   for this when we fix up loads displaced off the toc reg.  */
#define TOC_LOAD_ADJUSTMENT (-32768)
#define TOC_SECTION_NAME ".private.toc"

/* The main body of code is in coffcode.h.  */
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2

/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
   from smaller values.  Start with zero, widen, *then* decrement.  */
#define MINUS_ONE	(((bfd_vma)0) - 1)

\f
static reloc_howto_type mcore_coff_howto_table[] =
{
  /* Unused: */
  HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */
	 0,	                 /* rightshift */
	 0,	                 /* size (0 = byte, 1 = short, 2 = long) */
	 0,	                 /* bitsize */
	 false,	                 /* pc_relative */
	 0,	                 /* bitpos */
	 complain_overflow_dont, /* dont complain_on_overflow */
	 NULL,		         /* special_function */
	 "ABSOLUTE",             /* name */
	 false,	                 /* partial_inplace */
	 0x00,	 	         /* src_mask */
	 0x00,        		 /* dst_mask */
	 false),                 /* pcrel_offset */

  HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */
	 0,	                /* rightshift */
	 2,	                /* size (0 = byte, 1 = short, 2 = long) */
	 32,	                /* bitsize */
	 false,	                /* pc_relative */
	 0,	                /* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 NULL,		        /* special_function */
	 "ADDR32",              /* name */
	 true,	                /* partial_inplace */
	 0xffffffff,            /* src_mask */
	 0xffffffff,            /* dst_mask */
	 false),                /* pcrel_offset */

  /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
     Should not appear in object files.  */
  HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4,	/* type */
	 2,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 8,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 mcore_coff_unsupported_reloc, /* special_function */
	 "IMM8BY4",             /* name */
	 false,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 true),			/* pcrel_offset */

  /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
     Span 2k instructions == 4k bytes.
     Only useful pieces at the relocated address are the opcode (5 bits) */
  HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 11,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 NULL,	                /* special_function */
	 "IMM11BY2",            /* name */
	 false,			/* partial_inplace */
	 0x0,			/* src_mask */
	 0x7ff,			/* dst_mask */
	 true),			/* pcrel_offset */

  /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported.  */
  HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2,	/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 4,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 mcore_coff_unsupported_reloc, /* special_function */
	 "IMM4BY2",              /* name */
	 false,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 true),			/* pcrel_offset */

  /* 32-bit pc-relative. Eventually this will help support PIC code.  */
  HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield, /* complain_on_overflow */
	 NULL,	                /* special_function */
	 "PCREL_32",	        /* name */
	 false,			/* partial_inplace */
	 0x0,			/* src_mask */
	 0xffffffff,		/* dst_mask */
	 true),			/* pcrel_offset */

  /* Like PCREL_IMM11BY2, this relocation indicates that there is a
     'jsri' at the specified address. There is a separate relocation
     entry for the literal pool entry that it references, but we
     might be able to change the jsri to a bsr if the target turns out
     to be close enough [even though we won't reclaim the literal pool
     entry, we'll get some runtime efficiency back]. Note that this
     is a relocation that we are allowed to safely ignore.  */
  HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 11,			/* bitsize */
	 true,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 NULL,	                /* special_function */
	 "JSR_IMM11BY2",        /* name */
	 false,			/* partial_inplace */
	 0x0,			/* src_mask */
	 0x7ff,			/* dst_mask */
	 true),			/* pcrel_offset */

  HOWTO (IMAGE_REL_MCORE_RVA,   /* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 false,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_signed, /* complain_on_overflow */
	 NULL,                  /* special_function */
	 "MCORE_RVA",           /* name */
	 true,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 true)			/* pcrel_offset */
};
\f
/* Extend the coff_link_hash_table structure with a few M*Core specific fields.
   This allows us to store global data here without actually creating any
   global variables, which is a no-no in the BFD world.  */
typedef struct coff_mcore_link_hash_table
{
  /* The original coff_link_hash_table structure.  MUST be first field.  */
  struct coff_link_hash_table	root;

  bfd *                         bfd_of_toc_owner;
  long int                      global_toc_size;
  long int                      import_table_size;
  long int                      first_thunk_address;
  long int                      thunk_size;
}
mcore_hash_table;

/* Get the MCore coff linker hash table from a link_info structure.  */
#define coff_mcore_hash_table(info) \
  ((mcore_hash_table *) ((info)->hash))

/* Create an MCore coff linker hash table.  */
static struct bfd_link_hash_table *
coff_mcore_link_hash_table_create (abfd)
     bfd * abfd;
{
  mcore_hash_table * ret;

  ret = ((mcore_hash_table *) bfd_alloc (abfd, sizeof (* ret)));
  if (ret == (mcore_hash_table *) NULL)
    return NULL;

  if (! _bfd_coff_link_hash_table_init
      (& ret->root, abfd, _bfd_coff_link_hash_newfunc))
    {
      bfd_release (abfd, ret);
      return (struct bfd_link_hash_table *) NULL;
    }

  ret->bfd_of_toc_owner = NULL;
  ret->global_toc_size  = 0;
  ret->import_table_size = 0;
  ret->first_thunk_address = 0;
  ret->thunk_size = 0;

  return & ret->root.root;
}
\f
/* Add an entry to the base file.  */
static void
mcore_emit_base_file_entry (info, output_bfd, input_section, reloc_offset)
      struct bfd_link_info * info;
      bfd *                  output_bfd;
      asection *             input_section;
      bfd_vma                reloc_offset;
{
  bfd_vma addr = reloc_offset
                 - input_section->vma
                 + input_section->output_offset
                 + input_section->output_section->vma;

  if (coff_data (output_bfd)->pe)
     addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;

  fwrite (&addr, 1, sizeof (addr), (FILE *) info->base_file);
}
\f
static bfd_reloc_status_type
mcore_coff_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
			   output_bfd, error_message)
     bfd * abfd;
     arelent * reloc_entry;
     asymbol * symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection * input_section ATTRIBUTE_UNUSED;
     bfd * output_bfd ATTRIBUTE_UNUSED;
     char ** error_message ATTRIBUTE_UNUSED;
{
  BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);

  _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
		      bfd_get_filename (abfd),
		      reloc_entry->howto->name,
		      reloc_entry->howto->type);

  return bfd_reloc_notsupported;
}

\f
/* A cheesy little macro to make the code a little more readable.  */
#define HOW2MAP(bfd_rtype, mcore_rtype)  \
 case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]

static reloc_howto_type *
mcore_coff_reloc_type_lookup (abfd, code)
     bfd * abfd ATTRIBUTE_UNUSED;
     bfd_reloc_code_real_type code;
{
  switch (code)
    {
      HOW2MAP (BFD_RELOC_32,                       IMAGE_REL_MCORE_ADDR32);
      HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4,      IMAGE_REL_MCORE_PCREL_IMM8BY4);
      HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2,     IMAGE_REL_MCORE_PCREL_IMM11BY2);
      HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2,      IMAGE_REL_MCORE_PCREL_IMM4BY2);
      HOW2MAP (BFD_RELOC_32_PCREL,                 IMAGE_REL_MCORE_PCREL_32);
      HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2);
      HOW2MAP (BFD_RELOC_RVA,                      IMAGE_REL_MCORE_RVA);
   default:
      return NULL;
    }
  /*NOTREACHED*/
}

#undef HOW2MAP

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

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

  if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
    return NULL;

  howto = mcore_coff_howto_table + rel->r_type;

  if (rel->r_type == IMAGE_REL_MCORE_RVA)
    * addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;

  else if (howto->pc_relative)
    {
      * addendp = sec->vma - 2; /* XXX guess - is this right ? */

      /* If the symbol is defined, then the generic code is going to
         add back the symbol value in order to cancel out an
         adjustment it made to the addend.  However, we set the addend
         to 0 at the start of this function.  We need to adjust here,
         to avoid the adjustment the generic code will make.  FIXME:
         This is getting a bit hackish.  */
      if (sym != NULL && sym->n_scnum != 0)
	* addendp -= sym->n_value;
    }
  else
    * addendp = 0;

  return howto;
}

/* Return true if this relocation should appear in the output .reloc section.
   This function is referenced in pe_mkobject in peicode.h.  */
static boolean
in_reloc_p (abfd, howto)
     bfd * abfd ATTRIBUTE_UNUSED;
     reloc_howto_type * howto;
{
  return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA;
}

\f
/* The reloc processing routine for the optimized COFF linker.  */
static boolean
coff_mcore_relocate_section (output_bfd, info, input_bfd, input_section,
			   contents, relocs, syms, sections)
     bfd * output_bfd;
     struct bfd_link_info * info;
     bfd * input_bfd;
     asection * input_section;
     bfd_byte * contents;
     struct internal_reloc * relocs;
     struct internal_syment * syms;
     asection ** sections;
{
  struct internal_reloc * rel;
  struct internal_reloc * relend;
  boolean hihalf;
  bfd_vma hihalf_val;

  /* If we are performing a relocateable link, we don't need to do a
     thing.  The caller will take care of adjusting the reloc
     addresses and symbol indices.  */
  if (info->relocateable)
    return true;

  /* Check if we have the same endianess */
  if (   input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
      && output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
    {
      (*_bfd_error_handler)
	(_("%s: compiled for a %s endian system and target is %s endian.\n"),
	 bfd_get_filename (input_bfd),
         bfd_big_endian (input_bfd) ? "big" : "little",
         bfd_big_endian (output_bfd) ? "big" : "little");

      bfd_set_error (bfd_error_wrong_format);
      return false;
    }

  hihalf = false;
  hihalf_val = 0;

  rel = relocs;
  relend = rel + input_section->reloc_count;

  for (; rel < relend; rel++)
    {
      long                           symndx;
      struct internal_syment *       sym;
      bfd_vma                        val;
      bfd_vma                        addend;
      bfd_reloc_status_type          rstat;
      bfd_byte *                     loc;
      unsigned short                 r_type = rel->r_type;
      reloc_howto_type *             howto = NULL;
      struct coff_link_hash_entry *  h;
      const char *                   my_name;

      symndx = rel->r_symndx;
      loc = contents + rel->r_vaddr - input_section->vma;

      if (symndx == -1)
	{
	  h = NULL;
	  sym = NULL;
	}
      else
	{
	  h = obj_coff_sym_hashes (input_bfd)[symndx];
	  sym = syms + symndx;
	}

      addend = 0;

      /* Get the howto and initialise the addend.  */
      howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
				       sym, & addend);
      if (howto == NULL)
	return false;

      val = 0;

      if (h == NULL)
	{
	  if (symndx == -1)
	    my_name = "*ABS*";
	  else
	    {
	      asection * sec = sections[symndx];

	      val = (sym->n_value
		     + sec->output_section->vma
		     + sec->output_offset);

	      if (sym == NULL)
		my_name = "*unknown*";
	      else if (   sym->_n._n_n._n_zeroes == 0
		       && sym->_n._n_n._n_offset != 0)
		my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
	      else
		{
		  static char buf [SYMNMLEN + 1];

		  strncpy (buf, sym->_n._n_name, SYMNMLEN);
		  buf[SYMNMLEN] = '\0';
		  my_name = buf;
		}
	    }
	}
      else
	{
	  if (   h->root.type == bfd_link_hash_defined
	      || h->root.type == bfd_link_hash_defweak)
	    {
	      asection * sec = h->root.u.def.section;

	      val = (h->root.u.def.value
		     + sec->output_section->vma
		     + sec->output_offset);
	    }
	  else
	    {
	      if (! ((*info->callbacks->undefined_symbol)
		     (info, h->root.root.string, input_bfd, input_section,
		      rel->r_vaddr - input_section->vma, true)))
		return false;
	    }

	  my_name = h->root.root.string;
	}

      rstat = bfd_reloc_ok;

      /* Each case must do its own relocation, setting rstat appropriately.  */
      switch (r_type)
	{
	default:
	  _bfd_error_handler (_("%s: unsupported relocation type 0x%02x"),
			      bfd_get_filename (input_bfd), r_type);
	  bfd_set_error (bfd_error_bad_value);
	  return false;

	case IMAGE_REL_MCORE_ABSOLUTE:
	  fprintf (stderr,
		   _("Warning: unsupported reloc %s <file %s, section %s>\n"),
		   howto->name,
		   bfd_get_filename (input_bfd),
		   input_section->name);

	  fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
		   rel->r_symndx, my_name, (long) rel->r_vaddr,
		   (unsigned long) rel->r_vaddr);
	  break;

	case IMAGE_REL_MCORE_PCREL_IMM8BY4:
	case IMAGE_REL_MCORE_PCREL_IMM11BY2:
	case IMAGE_REL_MCORE_PCREL_IMM4BY2:
	case IMAGE_REL_MCORE_PCREL_32:
	case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
	case IMAGE_REL_MCORE_ADDR32:
	  /* XXX fixme - shouldn't this be like the code for the RVA reloc ? */
	  rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
	  break;

	case IMAGE_REL_MCORE_RVA:
	  rstat = _bfd_final_link_relocate
	    (howto, input_bfd,
	     input_section, contents, rel->r_vaddr - input_section->vma,
	     val, addend);
	  break;
	}

      if (info->base_file)
	{
	  /* Emit a reloc if the backend thinks it needs it.  */
	  if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
            mcore_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
	}

      switch (rstat)
	{
	default:
	  abort ();

	case bfd_reloc_ok:
	  break;

	case bfd_reloc_overflow:
	  if (! ((*info->callbacks->reloc_overflow)
		 (info, my_name, howto->name,
		  (bfd_vma) 0, input_bfd,
		  input_section, rel->r_vaddr - input_section->vma)))
	    return false;
	}
    }

  return true;
}

\f
/* Tailor coffcode.h -- macro heaven.  */

/* We use the special COFF backend linker, with our own special touch.  */

#define coff_bfd_reloc_type_lookup   mcore_coff_reloc_type_lookup
#define coff_relocate_section        coff_mcore_relocate_section
#define coff_rtype_to_howto          coff_mcore_rtype_to_howto

#define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}

#define COFF_PAGE_SIZE               0x1000

#include "coffcode.h"
\f
/* Forward declaration to initialise alterbative_target field.  */
extern const bfd_target TARGET_LITTLE_SYM;

/* The transfer vectors that lead the outside world to all of the above.  */
CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED,
			    (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
			    0, & TARGET_LITTLE_SYM)
CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED,
			       (SEC_CODE | SEC_DATA | SEC_DEBUGGING | SEC_READONLY | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
			       0, & TARGET_BIG_SYM)
Commit	Line	Data
3442f309	1	/* BFD back-end for Motorola MCore COFF/PE
69e70d30	2	Copyright (C) 1999 Free Software Foundation, Inc.
252b5132 RH	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
	24	#include "coff/mcore.h"
	25	#include "coff/internal.h"
	26	#include "coff/pe.h"
	27	#include "libcoff.h"
	28
	29	#ifdef BADMAG
	30	#undef BADMAG
	31	#endif
	32	#define BADMAG(x) MCOREBADMAG(x)
	33
	34	#ifndef NUM_ELEM
	35	#define NUM_ELEM(A) (sizeof (A) / sizeof (A)[0])
	36	#endif
	37
	38	/* This file is compiled more than once, but we only compile the
	39	final_link routine once. */
	40	extern boolean mcore_bfd_coff_final_link
	41	PARAMS ((bfd , struct bfd_link_info ));
	42
	43	static struct bfd_link_hash_table * coff_mcore_link_hash_table_create
	44	PARAMS ((bfd *));
b48499ec	45	static bfd_reloc_status_type mcore_coff_unsupported_reloc
252b5132	46	PARAMS ((bfd , arelent , asymbol , PTR, asection , bfd , char *));
252b5132 RH	47	static boolean coff_mcore_relocate_section
	48	PARAMS ((bfd , struct bfd_link_info , bfd , asection , bfd_byte *,
	49	struct internal_reloc , struct internal_syment , asection **));
	50	static reloc_howto_type * mcore_coff_reloc_type_lookup
	51	PARAMS ((bfd *, bfd_reloc_code_real_type));
	52	static reloc_howto_type * coff_mcore_rtype_to_howto
	53	PARAMS ((bfd , asection , struct internal_reloc *,
	54	struct coff_link_hash_entry , struct internal_syment , bfd_vma *));
252b5132 RH	55	\f
	56	/* The NT loader points the toc register to &toc + 32768, in order to
	57	use the complete range of a 16-bit displacement. We have to adjust
	58	for this when we fix up loads displaced off the toc reg. */
	59	#define TOC_LOAD_ADJUSTMENT (-32768)
	60	#define TOC_SECTION_NAME ".private.toc"
	61
	62	/* The main body of code is in coffcode.h. */
f45fbf87	63	#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
252b5132 RH	64
	65	/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
	66	from smaller values. Start with zero, widen, then decrement. */
	67	#define MINUS_ONE (((bfd_vma)0) - 1)
	68
	69	\f
	70	static reloc_howto_type mcore_coff_howto_table[] =
	71	{
	72	/* Unused: */
b48499ec KH	73	HOWTO (IMAGE_REL_MCORE_ABSOLUTE,/* type */
	74	0, /* rightshift */
	75	0, /* size (0 = byte, 1 = short, 2 = long) */
	76	0, /* bitsize */
	77	false, /* pc_relative */
	78	0, /* bitpos */
252b5132	79	complain_overflow_dont, /* dont complain_on_overflow */
b48499ec	80	NULL, /* special_function */
252b5132	81	"ABSOLUTE", /* name */
b48499ec KH	82	false, /* partial_inplace */
	83	0x00, /* src_mask */
	84	0x00, /* dst_mask */
252b5132	85	false), /* pcrel_offset */
b48499ec	86
252b5132	87	HOWTO (IMAGE_REL_MCORE_ADDR32,/* type */
b48499ec KH	88	0, /* rightshift */
	89	2, /* size (0 = byte, 1 = short, 2 = long) */
	90	32, /* bitsize */
	91	false, /* pc_relative */
	92	0, /* bitpos */
252b5132	93	complain_overflow_bitfield, /* complain_on_overflow */
b48499ec	94	NULL, /* special_function */
252b5132	95	"ADDR32", /* name */
b48499ec KH	96	true, /* partial_inplace */
	97	0xffffffff, /* src_mask */
	98	0xffffffff, /* dst_mask */
252b5132	99	false), /* pcrel_offset */
b48499ec	100
252b5132	101	/* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
b48499ec	102	Should not appear in object files. */
252b5132 RH	103	HOWTO (IMAGE_REL_MCORE_PCREL_IMM8BY4, /* type */
	104	2, /* rightshift */
	105	1, /* size (0 = byte, 1 = short, 2 = long) */
	106	8, /* bitsize */
	107	true, /* pc_relative */
	108	0, /* bitpos */
	109	complain_overflow_bitfield, /* complain_on_overflow */
36797d47	110	mcore_coff_unsupported_reloc, /* special_function */
252b5132 RH	111	"IMM8BY4", /* name */
	112	false, /* partial_inplace */
	113	0, /* src_mask */
	114	0, /* dst_mask */
	115	true), /* pcrel_offset */
	116
b48499ec	117	/* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
252b5132 RH	118	Span 2k instructions == 4k bytes.
	119	Only useful pieces at the relocated address are the opcode (5 bits) */
	120	HOWTO (IMAGE_REL_MCORE_PCREL_IMM11BY2,/* type */
	121	1, /* rightshift */
	122	1, /* size (0 = byte, 1 = short, 2 = long) */
	123	11, /* bitsize */
	124	true, /* pc_relative */
	125	0, /* bitpos */
	126	complain_overflow_signed, /* complain_on_overflow */
	127	NULL, /* special_function */
	128	"IMM11BY2", /* name */
	129	false, /* partial_inplace */
	130	0x0, /* src_mask */
	131	0x7ff, /* dst_mask */
	132	true), /* pcrel_offset */
	133
b48499ec	134	/* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported. */
252b5132 RH	135	HOWTO (IMAGE_REL_MCORE_PCREL_IMM4BY2, /* type */
	136	1, /* rightshift */
	137	1, /* size (0 = byte, 1 = short, 2 = long) */
	138	4, /* bitsize */
	139	true, /* pc_relative */
	140	0, /* bitpos */
	141	complain_overflow_bitfield, /* complain_on_overflow */
36797d47	142	mcore_coff_unsupported_reloc, /* special_function */
252b5132 RH	143	"IMM4BY2", /* name */
	144	false, /* partial_inplace */
	145	0, /* src_mask */
	146	0, /* dst_mask */
	147	true), /* pcrel_offset */
	148
b48499ec	149	/* 32-bit pc-relative. Eventually this will help support PIC code. */
252b5132 RH	150	HOWTO (IMAGE_REL_MCORE_PCREL_32,/* type */
	151	0, /* rightshift */
	152	2, /* size (0 = byte, 1 = short, 2 = long) */
	153	32, /* bitsize */
	154	true, /* pc_relative */
	155	0, /* bitpos */
	156	complain_overflow_bitfield, /* complain_on_overflow */
	157	NULL, /* special_function */
	158	"PCREL_32", /* name */
	159	false, /* partial_inplace */
	160	0x0, /* src_mask */
	161	0xffffffff, /* dst_mask */
	162	true), /* pcrel_offset */
	163
	164	/* Like PCREL_IMM11BY2, this relocation indicates that there is a
	165	'jsri' at the specified address. There is a separate relocation
b48499ec	166	entry for the literal pool entry that it references, but we
252b5132 RH	167	might be able to change the jsri to a bsr if the target turns out
	168	to be close enough [even though we won't reclaim the literal pool
	169	entry, we'll get some runtime efficiency back]. Note that this
b48499ec	170	is a relocation that we are allowed to safely ignore. */
252b5132 RH	171	HOWTO (IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2,/* type */
	172	1, /* rightshift */
	173	1, /* size (0 = byte, 1 = short, 2 = long) */
	174	11, /* bitsize */
	175	true, /* pc_relative */
	176	0, /* bitpos */
	177	complain_overflow_signed, /* complain_on_overflow */
	178	NULL, /* special_function */
	179	"JSR_IMM11BY2", /* name */
	180	false, /* partial_inplace */
	181	0x0, /* src_mask */
	182	0x7ff, /* dst_mask */
36797d47	183	true), /* pcrel_offset */
b48499ec	184
36797d47 NC	185	HOWTO (IMAGE_REL_MCORE_RVA, /* type */
	186	0, /* rightshift */
	187	2, /* size (0 = byte, 1 = short, 2 = long) */
	188	32, /* bitsize */
	189	false, /* pc_relative */
	190	0, /* bitpos */
	191	complain_overflow_signed, /* complain_on_overflow */
	192	NULL, /* special_function */
	193	"MCORE_RVA", /* name */
	194	true, /* partial_inplace */
	195	0xffffffff, /* src_mask */
	196	0xffffffff, /* dst_mask */
252b5132 RH	197	true) /* pcrel_offset */
	198	};
	199	\f
	200	/* Extend the coff_link_hash_table structure with a few M*Core specific fields.
	201	This allows us to store global data here without actually creating any
	202	global variables, which is a no-no in the BFD world. */
	203	typedef struct coff_mcore_link_hash_table
	204	{
	205	/* The original coff_link_hash_table structure. MUST be first field. */
	206	struct coff_link_hash_table root;
	207
	208	bfd * bfd_of_toc_owner;
	209	long int global_toc_size;
	210	long int import_table_size;
	211	long int first_thunk_address;
	212	long int thunk_size;
	213	}
	214	mcore_hash_table;
	215
	216	/* Get the MCore coff linker hash table from a link_info structure. */
	217	#define coff_mcore_hash_table(info) \
	218	((mcore_hash_table *) ((info)->hash))
	219
	220	/* Create an MCore coff linker hash table. */
	221	static struct bfd_link_hash_table *
	222	coff_mcore_link_hash_table_create (abfd)
	223	bfd * abfd;
	224	{
	225	mcore_hash_table * ret;
	226
	227	ret = ((mcore_hash_table ) bfd_alloc (abfd, sizeof ( ret)));
	228	if (ret == (mcore_hash_table *) NULL)
	229	return NULL;
	230
	231	if (! _bfd_coff_link_hash_table_init
	232	(& ret->root, abfd, _bfd_coff_link_hash_newfunc))
	233	{
	234	bfd_release (abfd, ret);
	235	return (struct bfd_link_hash_table *) NULL;
	236	}
	237
	238	ret->bfd_of_toc_owner = NULL;
	239	ret->global_toc_size = 0;
	240	ret->import_table_size = 0;
	241	ret->first_thunk_address = 0;
	242	ret->thunk_size = 0;
	243
	244	return & ret->root.root;
	245	}
	246	\f
69e70d30 NC	247	/* Add an entry to the base file. */
	248	static void
	249	mcore_emit_base_file_entry (info, output_bfd, input_section, reloc_offset)
	250	struct bfd_link_info * info;
	251	bfd * output_bfd;
	252	asection * input_section;
	253	bfd_vma reloc_offset;
	254	{
	255	bfd_vma addr = reloc_offset
	256	- input_section->vma
	257	+ input_section->output_offset
	258	+ input_section->output_section->vma;
	259
	260	if (coff_data (output_bfd)->pe)
	261	addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
b48499ec	262
69e70d30 NC	263	fwrite (&addr, 1, sizeof (addr), (FILE *) info->base_file);
	264	}
	265	\f
252b5132 RH	266	static bfd_reloc_status_type
	267	mcore_coff_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
	268	output_bfd, error_message)
	269	bfd * abfd;
	270	arelent * reloc_entry;
5f771d47 ILT	271	asymbol * symbol ATTRIBUTE_UNUSED;
	272	PTR data ATTRIBUTE_UNUSED;
	273	asection * input_section ATTRIBUTE_UNUSED;
	274	bfd * output_bfd ATTRIBUTE_UNUSED;
	275	char ** error_message ATTRIBUTE_UNUSED;
252b5132 RH	276	{
252b5132 RH	277	BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
b48499ec	278
252b5132 RH	279	_bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
	280	bfd_get_filename (abfd),
	281	reloc_entry->howto->name,
	282	reloc_entry->howto->type);
b48499ec	283
252b5132 RH	284	return bfd_reloc_notsupported;
	285	}
	286
	287	\f
b48499ec	288	/* A cheesy little macro to make the code a little more readable. */
252b5132 RH	289	#define HOW2MAP(bfd_rtype, mcore_rtype) \
	290	case bfd_rtype: return & mcore_coff_howto_table [mcore_rtype]
	291
	292	static reloc_howto_type *
	293	mcore_coff_reloc_type_lookup (abfd, code)
5f771d47	294	bfd * abfd ATTRIBUTE_UNUSED;
252b5132 RH	295	bfd_reloc_code_real_type code;
	296	{
	297	switch (code)
b48499ec	298	{
252b5132 RH	299	HOW2MAP (BFD_RELOC_32, IMAGE_REL_MCORE_ADDR32);
	300	HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM8BY4, IMAGE_REL_MCORE_PCREL_IMM8BY4);
	301	HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM11BY2, IMAGE_REL_MCORE_PCREL_IMM11BY2);
	302	HOW2MAP (BFD_RELOC_MCORE_PCREL_IMM4BY2, IMAGE_REL_MCORE_PCREL_IMM4BY2);
	303	HOW2MAP (BFD_RELOC_32_PCREL, IMAGE_REL_MCORE_PCREL_32);
	304	HOW2MAP (BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2, IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2);
36797d47	305	HOW2MAP (BFD_RELOC_RVA, IMAGE_REL_MCORE_RVA);
b48499ec	306	default:
252b5132 RH	307	return NULL;
	308	}
	309	/NOTREACHED/
	310	}
	311
	312	#undef HOW2MAP
	313
	314	#define RTYPE2HOWTO(cache_ptr, dst) \
	315	(cache_ptr)->howto = mcore_coff_howto_table + (dst)->r_type;
	316
	317	static reloc_howto_type *
	318	coff_mcore_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5f771d47	319	bfd * abfd ATTRIBUTE_UNUSED;
252b5132 RH	320	asection * sec;
252b5132 RH	321	struct internal_reloc * rel;
5f771d47	322	struct coff_link_hash_entry * h ATTRIBUTE_UNUSED;
252b5132 RH	323	struct internal_syment * sym;
	324	bfd_vma * addendp;
	325	{
	326	reloc_howto_type * howto;
	327
252b5132 RH	328	if (rel->r_type >= NUM_ELEM (mcore_coff_howto_table))
252b5132 RH	329	return NULL;
b48499ec	330
252b5132	331	howto = mcore_coff_howto_table + rel->r_type;
36797d47 NC	332
	333	if (rel->r_type == IMAGE_REL_MCORE_RVA)
	334	* addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
b48499ec	335
078c8694	336	else if (howto->pc_relative)
252b5132 RH	337	{
252b5132 RH	338	* addendp = sec->vma - 2; /* XXX guess - is this right ? */
b48499ec	339
252b5132 RH	340	/* If the symbol is defined, then the generic code is going to
	341	add back the symbol value in order to cancel out an
	342	adjustment it made to the addend. However, we set the addend
	343	to 0 at the start of this function. We need to adjust here,
	344	to avoid the adjustment the generic code will make. FIXME:
	345	This is getting a bit hackish. */
	346	if (sym != NULL && sym->n_scnum != 0)
	347	* addendp -= sym->n_value;
	348	}
	349	else
	350	* addendp = 0;
b48499ec	351
252b5132 RH	352	return howto;
252b5132 RH	353	}
1349dd65 NC	354
	355	/* Return true if this relocation should appear in the output .reloc section.
	356	This function is referenced in pe_mkobject in peicode.h. */
	357	static boolean
	358	in_reloc_p (abfd, howto)
5f771d47	359	bfd * abfd ATTRIBUTE_UNUSED;
1349dd65 NC	360	reloc_howto_type * howto;
	361	{
	362	return ! howto->pc_relative && howto->type != IMAGE_REL_MCORE_RVA;
b48499ec	363	}
1349dd65	364
252b5132	365	\f
252b5132 RH	366	/* The reloc processing routine for the optimized COFF linker. */
	367	static boolean
	368	coff_mcore_relocate_section (output_bfd, info, input_bfd, input_section,
	369	contents, relocs, syms, sections)
	370	bfd * output_bfd;
	371	struct bfd_link_info * info;
	372	bfd * input_bfd;
	373	asection * input_section;
	374	bfd_byte * contents;
	375	struct internal_reloc * relocs;
	376	struct internal_syment * syms;
	377	asection ** sections;
	378	{
	379	struct internal_reloc * rel;
	380	struct internal_reloc * relend;
	381	boolean hihalf;
	382	bfd_vma hihalf_val;
b48499ec	383
252b5132 RH	384	/* If we are performing a relocateable link, we don't need to do a
	385	thing. The caller will take care of adjusting the reloc
	386	addresses and symbol indices. */
	387	if (info->relocateable)
	388	return true;
b48499ec	389
b23f908b NC	390	/* Check if we have the same endianess */
	391	if ( input_bfd->xvec->byteorder != output_bfd->xvec->byteorder
	392	&& output_bfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
	393	{
	394	(*_bfd_error_handler)
	395	(_("%s: compiled for a %s endian system and target is %s endian.\n"),
	396	bfd_get_filename (input_bfd),
	397	bfd_big_endian (input_bfd) ? "big" : "little",
	398	bfd_big_endian (output_bfd) ? "big" : "little");
	399
	400	bfd_set_error (bfd_error_wrong_format);
	401	return false;
	402	}
252b5132 RH	403
	404	hihalf = false;
	405	hihalf_val = 0;
	406
	407	rel = relocs;
	408	relend = rel + input_section->reloc_count;
b48499ec	409
252b5132 RH	410	for (; rel < relend; rel++)
252b5132 RH	411	{
252b5132 RH	412	long symndx;
	413	struct internal_syment * sym;
	414	bfd_vma val;
	415	bfd_vma addend;
	416	bfd_reloc_status_type rstat;
	417	bfd_byte * loc;
	418	unsigned short r_type = rel->r_type;
	419	reloc_howto_type * howto = NULL;
	420	struct coff_link_hash_entry * h;
	421	const char * my_name;
b48499ec	422
252b5132 RH	423	symndx = rel->r_symndx;
	424	loc = contents + rel->r_vaddr - input_section->vma;
	425
	426	if (symndx == -1)
	427	{
	428	h = NULL;
	429	sym = NULL;
	430	}
	431	else
	432	{
	433	h = obj_coff_sym_hashes (input_bfd)[symndx];
	434	sym = syms + symndx;
	435	}
	436
078c8694	437	addend = 0;
b48499ec	438
252b5132 RH	439	/* Get the howto and initialise the addend. */
	440	howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
	441	sym, & addend);
	442	if (howto == NULL)
	443	return false;
	444
	445	val = 0;
b48499ec	446
252b5132 RH	447	if (h == NULL)
	448	{
	449	if (symndx == -1)
	450	my_name = "ABS";
	451	else
	452	{
	453	asection * sec = sections[symndx];
b48499ec KH	454
b48499ec KH	455	val = (sym->n_value
252b5132 RH	456	+ sec->output_section->vma
	457	+ sec->output_offset);
	458
	459	if (sym == NULL)
	460	my_name = "unknown";
	461	else if ( sym->_n._n_n._n_zeroes == 0
	462	&& sym->_n._n_n._n_offset != 0)
	463	my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
b48499ec	464	else
252b5132 RH	465	{
252b5132 RH	466	static char buf [SYMNMLEN + 1];
b48499ec	467
252b5132 RH	468	strncpy (buf, sym->_n._n_name, SYMNMLEN);
	469	buf[SYMNMLEN] = '\0';
	470	my_name = buf;
	471	}
	472	}
	473	}
	474	else
	475	{
	476	if ( h->root.type == bfd_link_hash_defined
	477	\|\| h->root.type == bfd_link_hash_defweak)
	478	{
	479	asection * sec = h->root.u.def.section;
b48499ec	480
252b5132 RH	481	val = (h->root.u.def.value
	482	+ sec->output_section->vma
	483	+ sec->output_offset);
	484	}
	485	else
	486	{
	487	if (! ((*info->callbacks->undefined_symbol)
	488	(info, h->root.root.string, input_bfd, input_section,
5cc7c785	489	rel->r_vaddr - input_section->vma, true)))
252b5132 RH	490	return false;
252b5132 RH	491	}
b48499ec	492
252b5132	493	my_name = h->root.root.string;
b48499ec	494	}
252b5132 RH	495
252b5132 RH	496	rstat = bfd_reloc_ok;
b48499ec	497
252b5132 RH	498	/* Each case must do its own relocation, setting rstat appropriately. */
	499	switch (r_type)
	500	{
	501	default:
	502	_bfd_error_handler (_("%s: unsupported relocation type 0x%02x"),
	503	bfd_get_filename (input_bfd), r_type);
	504	bfd_set_error (bfd_error_bad_value);
	505	return false;
b48499ec	506
252b5132	507	case IMAGE_REL_MCORE_ABSOLUTE:
b48499ec KH	508	fprintf (stderr,
b48499ec KH	509	_("Warning: unsupported reloc %s <file %s, section %s>\n"),
252b5132 RH	510	howto->name,
	511	bfd_get_filename (input_bfd),
	512	input_section->name);
b48499ec KH	513
b48499ec KH	514	fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
252b5132	515	rel->r_symndx, my_name, (long) rel->r_vaddr,
b48499ec	516	(unsigned long) rel->r_vaddr);
252b5132	517	break;
b48499ec	518
252b5132 RH	519	case IMAGE_REL_MCORE_PCREL_IMM8BY4:
	520	case IMAGE_REL_MCORE_PCREL_IMM11BY2:
	521	case IMAGE_REL_MCORE_PCREL_IMM4BY2:
	522	case IMAGE_REL_MCORE_PCREL_32:
	523	case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
	524	case IMAGE_REL_MCORE_ADDR32:
078c8694	525	/* XXX fixme - shouldn't this be like the code for the RVA reloc ? */
252b5132 RH	526	rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
252b5132 RH	527	break;
b48499ec	528
078c8694 NC	529	case IMAGE_REL_MCORE_RVA:
	530	rstat = _bfd_final_link_relocate
	531	(howto, input_bfd,
	532	input_section, contents, rel->r_vaddr - input_section->vma,
	533	val, addend);
	534	break;
252b5132	535	}
b48499ec	536
69e70d30 NC	537	if (info->base_file)
	538	{
	539	/* Emit a reloc if the backend thinks it needs it. */
	540	if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
	541	mcore_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
	542	}
b48499ec	543
252b5132 RH	544	switch (rstat)
	545	{
	546	default:
	547	abort ();
b48499ec	548
252b5132 RH	549	case bfd_reloc_ok:
252b5132 RH	550	break;
b48499ec	551
252b5132 RH	552	case bfd_reloc_overflow:
252b5132 RH	553	if (! ((*info->callbacks->reloc_overflow)
b48499ec	554	(info, my_name, howto->name,
252b5132 RH	555	(bfd_vma) 0, input_bfd,
	556	input_section, rel->r_vaddr - input_section->vma)))
	557	return false;
	558	}
b48499ec	559	}
252b5132 RH	560
	561	return true;
	562	}
	563
	564	\f
b48499ec	565	/* Tailor coffcode.h -- macro heaven. */
252b5132 RH	566
	567	/* We use the special COFF backend linker, with our own special touch. */
	568
	569	#define coff_bfd_reloc_type_lookup mcore_coff_reloc_type_lookup
	570	#define coff_relocate_section coff_mcore_relocate_section
	571	#define coff_rtype_to_howto coff_mcore_rtype_to_howto
	572
	573	#define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}
	574
	575	#define COFF_PAGE_SIZE 0x1000
	576
	577	#include "coffcode.h"
	578	\f
c3c89269 NC	579	/* Forward declaration to initialise alterbative_target field. */
c3c89269 NC	580	extern const bfd_target TARGET_LITTLE_SYM;
252b5132	581
b48499ec	582	/* The transfer vectors that lead the outside world to all of the above. */
60bcf0fa NC	583	CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED,
	584	(SEC_CODE \| SEC_DATA \| SEC_DEBUGGING \| SEC_READONLY \| SEC_LINK_ONCE \| SEC_LINK_DUPLICATES),
	585	0, & TARGET_LITTLE_SYM)
	586	CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED,
	587	(SEC_CODE \| SEC_DATA \| SEC_DEBUGGING \| SEC_READONLY \| SEC_LINK_ONCE \| SEC_LINK_DUPLICATES),
	588	0, & TARGET_BIG_SYM)