[deliverable/binutils-gdb.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;
  
  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;
	}

      /* 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:
	case IMAGE_REL_MCORE_RVA:
	  rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
	  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
static const bfd_target *
pe_object_p (abfd)
     bfd * abfd;
{
#ifdef COFF_IMAGE_WITH_PE
  /* We need to hack badly to handle a PE image correctly.  In PE
     images created by the GNU linker, the offset to the COFF header
     is always the size.  However, this is not the case in images
     generated by other PE linkers.  The PE format stores a four byte
     offset to the PE signature just before the COFF header at
     location 0x3c of the file.  We pick up that offset, verify that
     the PE signature is there, and then set ourselves up to read in
     the COFF header.  */
  {
    bfd_byte ext_offset[4];
    file_ptr offset;
    bfd_byte ext_signature[4];
    unsigned long signature;

    if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
	|| bfd_read (ext_offset, 1, 4, abfd) != 4)
      {
	if (bfd_get_error () != bfd_error_system_call)
	  bfd_set_error (bfd_error_wrong_format);
	return NULL;
      }
    
    offset = bfd_h_get_32 (abfd, ext_offset);
    
    if (bfd_seek (abfd, offset, SEEK_SET) != 0
	|| bfd_read (ext_signature, 1, 4, abfd) != 4)
      {
	if (bfd_get_error () != bfd_error_system_call)
	  bfd_set_error (bfd_error_wrong_format);
	
	return NULL;
      }
    
    signature = bfd_h_get_32 (abfd, ext_signature);

    if (signature != 0x4550)
      {
	bfd_set_error (bfd_error_wrong_format);
	return NULL;
      }

    /* Here is the hack.  coff_object_p wants to read filhsz bytes to
       pick up the COFF header.  We adjust so that that will work.  20
       is the size of the mips COFF filehdr.  */
    if (bfd_seek (abfd, (bfd_tell (abfd) - bfd_coff_filhsz (abfd) + 20),
		  SEEK_SET) != 0)
      {
	if (bfd_get_error () != bfd_error_system_call)
	  bfd_set_error (bfd_error_wrong_format);
	
	return NULL;
      }
  }
#endif

  return coff_object_p (abfd);
}
\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 RH	341
	342	if (howto->pc_relative)
	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
	443	/* Get the howto and initialise the addend. */
	444	howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
	445	sym, & addend);
	446	if (howto == NULL)
	447	return false;
	448
	449	val = 0;
	450
	451	if (h == NULL)
	452	{
	453	if (symndx == -1)
	454	my_name = "ABS";
	455	else
	456	{
	457	asection * sec = sections[symndx];
	458
	459	val = (sym->n_value
	460	+ sec->output_section->vma
	461	+ sec->output_offset);
	462
	463	if (sym == NULL)
	464	my_name = "unknown";
	465	else if ( sym->_n._n_n._n_zeroes == 0
	466	&& sym->_n._n_n._n_offset != 0)
	467	my_name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
	468	else
	469	{
	470	static char buf [SYMNMLEN + 1];
	471
	472	strncpy (buf, sym->_n._n_name, SYMNMLEN);
	473	buf[SYMNMLEN] = '\0';
	474	my_name = buf;
	475	}
	476	}
	477	}
	478	else
	479	{
	480	if ( h->root.type == bfd_link_hash_defined
	481	\|\| h->root.type == bfd_link_hash_defweak)
482	{
483	asection * sec = h->root.u.def.section;
484
485	val = (h->root.u.def.value
486	+ sec->output_section->vma
487	+ sec->output_offset);
488	}
489	else
490	{
491	if (! ((*info->callbacks->undefined_symbol)
492	(info, h->root.root.string, input_bfd, input_section,
493	rel->r_vaddr - input_section->vma)))
494	return false;
495	}
496
497	my_name = h->root.root.string;
498	}
499
500	rstat = bfd_reloc_ok;
501
502	/* Each case must do its own relocation, setting rstat appropriately. */
503	switch (r_type)
504	{
505	default:
506	_bfd_error_handler (_("%s: unsupported relocation type 0x%02x"),
507	bfd_get_filename (input_bfd), r_type);
508	bfd_set_error (bfd_error_bad_value);
509	return false;
510
511	case IMAGE_REL_MCORE_ABSOLUTE:
512	fprintf (stderr,
513	_("Warning: unsupported reloc %s <file %s, section %s>\n"),
514	howto->name,
515	bfd_get_filename (input_bfd),
516	input_section->name);
517
518	fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
519	rel->r_symndx, my_name, (long) rel->r_vaddr,
520	(unsigned long) rel->r_vaddr);
521	break;
522
523	case IMAGE_REL_MCORE_PCREL_IMM8BY4:
524	case IMAGE_REL_MCORE_PCREL_IMM11BY2:
525	case IMAGE_REL_MCORE_PCREL_IMM4BY2:
526	case IMAGE_REL_MCORE_PCREL_32:
527	case IMAGE_REL_MCORE_PCREL_JSR_IMM11BY2:
528	case IMAGE_REL_MCORE_ADDR32:
36797d47	529	case IMAGE_REL_MCORE_RVA:
252b5132 RH	530	rstat = _bfd_relocate_contents (howto, input_bfd, val, loc);
	531	break;
	532	}
	533
69e70d30 NC	534	if (info->base_file)
	535	{
	536	/* Emit a reloc if the backend thinks it needs it. */
	537	if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
	538	mcore_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
	539	}
	540
252b5132 RH	541	switch (rstat)
	542	{
	543	default:
	544	abort ();
	545
	546	case bfd_reloc_ok:
	547	break;
	548
	549	case bfd_reloc_overflow:
	550	if (! ((*info->callbacks->reloc_overflow)
	551	(info, my_name, howto->name,
	552	(bfd_vma) 0, input_bfd,
	553	input_section, rel->r_vaddr - input_section->vma)))
	554	return false;
	555	}
	556	}
	557
	558	return true;
	559	}
	560
	561	\f
	562	/* Tailor coffcode.h -- macro heaven. */
	563
	564	/* We use the special COFF backend linker, with our own special touch. */
	565
	566	#define coff_bfd_reloc_type_lookup mcore_coff_reloc_type_lookup
	567	#define coff_relocate_section coff_mcore_relocate_section
	568	#define coff_rtype_to_howto coff_mcore_rtype_to_howto
	569
	570	#define SELECT_RELOC(internal, howto) {internal.r_type = howto->type;}
	571
	572	#define COFF_PAGE_SIZE 0x1000
	573
	574	#include "coffcode.h"
	575	\f
	576	static const bfd_target *
	577	pe_object_p (abfd)
	578	bfd * abfd;
	579	{
	580	#ifdef COFF_IMAGE_WITH_PE
	581	/* We need to hack badly to handle a PE image correctly. In PE
	582	images created by the GNU linker, the offset to the COFF header
	583	is always the size. However, this is not the case in images
	584	generated by other PE linkers. The PE format stores a four byte
	585	offset to the PE signature just before the COFF header at
	586	location 0x3c of the file. We pick up that offset, verify that
	587	the PE signature is there, and then set ourselves up to read in
	588	the COFF header. */
	589	{
	590	bfd_byte ext_offset[4];
	591	file_ptr offset;
	592	bfd_byte ext_signature[4];
	593	unsigned long signature;
	594
	595	if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
	596	\|\| bfd_read (ext_offset, 1, 4, abfd) != 4)
	597	{
	598	if (bfd_get_error () != bfd_error_system_call)
	599	bfd_set_error (bfd_error_wrong_format);
	600	return NULL;
	601	}
	602
	603	offset = bfd_h_get_32 (abfd, ext_offset);
	604
605	if (bfd_seek (abfd, offset, SEEK_SET) != 0
606	\|\| bfd_read (ext_signature, 1, 4, abfd) != 4)
607	{
608	if (bfd_get_error () != bfd_error_system_call)
609	bfd_set_error (bfd_error_wrong_format);
610
611	return NULL;
612	}
613
614	signature = bfd_h_get_32 (abfd, ext_signature);
615
616	if (signature != 0x4550)
617	{
618	bfd_set_error (bfd_error_wrong_format);
619	return NULL;
620	}
621
622	/* Here is the hack. coff_object_p wants to read filhsz bytes to
623	pick up the COFF header. We adjust so that that will work. 20
624	is the size of the mips COFF filehdr. */
625	if (bfd_seek (abfd, (bfd_tell (abfd) - bfd_coff_filhsz (abfd) + 20),
626	SEEK_SET) != 0)
627	{
628	if (bfd_get_error () != bfd_error_system_call)
629	bfd_set_error (bfd_error_wrong_format);
630
631	return NULL;
632	}
633	}
634	#endif
635
636	return coff_object_p (abfd);
637	}
638	\f
c3c89269 NC	639	/* Forward declaration to initialise alterbative_target field. */
c3c89269 NC	640	extern const bfd_target TARGET_LITTLE_SYM;
252b5132	641
c3c89269 NC	642	/* The transfer vectors that lead the outside world to all of the above. */
	643	CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, (SEC_LINK_ONCE \| SEC_LINK_DUPLICATES), 0, & TARGET_LITTLE_SYM)
	644	CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, (SEC_LINK_ONCE \| SEC_LINK_DUPLICATES), 0, & TARGET_BIG_SYM)