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

/* BFD back-end for Motorolla 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 *));
static const bfd_target *           pe_object_p
  PARAMS ((bfd *));


\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 (3)

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