Add WinCE support.

1 files changed, 856 insertions, 12 deletions

diff --git a/bfd/peicode.h b/bfd/peicode.h
index 8482b2d..b94d0f8 100644
--- a/bfd/peicode.h
+++ b/bfd/peicode.h
@@ -85,15 +85,64 @@ static boolean pe_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 #define coff_mkobject      pe_mkobject
 #define coff_mkobject_hook pe_mkobject_hook
 
+#ifndef NO_COFF_RELOCS
 static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
 static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
+#endif
 static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR));
 static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR));
 static boolean pe_mkobject PARAMS ((bfd *));
 static PTR pe_mkobject_hook PARAMS ((bfd *, PTR, PTR));
 
+#ifdef COFF_IMAGE_WITH_PE
+/* This structure contains static variables used by the ILF code.  */
+typedef asection * asection_ptr;
+
+typedef struct
+{
+  bfd *			abfd;
+  bfd_byte *		data;
+  struct bfd_in_memory * bim;
+  unsigned short        magic;
+  
+  arelent *		reltab;
+  unsigned int 		relcount;
+
+  coff_symbol_type * 	sym_cache;
+  coff_symbol_type * 	sym_ptr;
+  unsigned int       	sym_index;
+  
+  unsigned int * 	sym_table;
+  unsigned int * 	table_ptr;
+
+  combined_entry_type * native_syms;
+  combined_entry_type * native_ptr;
+
+  unsigned int		sec_index;
+
+  char *                string_table;
+  char *                string_ptr;
+  char *		end_string_ptr;
+  
+  SYMENT *              esym_table;
+  SYMENT *              esym_ptr;
+
+  struct internal_reloc * int_reltab;
+}
+pe_ILF_vars;
+
+static asection_ptr       pe_ILF_make_a_section   PARAMS ((pe_ILF_vars *, const char *, unsigned int, flagword));
+static void               pe_ILF_make_a_reloc     PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, asection_ptr));
+static void               pe_ILF_make_a_symbol    PARAMS ((pe_ILF_vars *, const char *, const char *, asection_ptr, flagword));
+static void               pe_ILF_save_relocs      PARAMS ((pe_ILF_vars *, asection_ptr));
+static boolean            pe_ILF_build_a_bfd      PARAMS ((bfd *, unsigned short, bfd_byte *, bfd_byte *, unsigned int, unsigned int));
+static const bfd_target * pe_ILF_object_p         PARAMS ((bfd *));
+static const bfd_target * pe_bfd_object_p         PARAMS ((bfd *));
+#endif /* COFF_IMAGE_WITH_PE */
+
 /**********************************************************************/
 
+#ifndef NO_COFF_RELOCS
 static void
 coff_swap_reloc_in (abfd, src, dst)
      bfd *abfd;
@@ -139,7 +188,7 @@ coff_swap_reloc_out (abfd, src, dst)
 #endif
   return RELSZ;
 }
-
+#endif /* not NO_COFF_RELOCS */
 
 static void
 coff_swap_filehdr_in (abfd, src, dst)
@@ -236,6 +285,7 @@ coff_swap_scnhdr_in (abfd, ext, in)
       scnhdr_int->s_vaddr &= 0xffffffff;
     }
 
+#ifndef COFF_NO_HACK_SCNHDR_SIZE
   /* If this section holds uninitialized data, use the virtual size
      (stored in s_paddr) instead of the physical size.  */
   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
@@ -246,6 +296,7 @@ coff_swap_scnhdr_in (abfd, ext, in)
          only works if it correctly holds the virtual size of the
          section.  */
     }
+#endif
 }
 
 static boolean
@@ -363,9 +414,809 @@ pe_bfd_copy_private_bfd_data (ibfd, obfd)
 #define coff_get_symbol_info _bfd_pe_get_symbol_info
 
 #ifdef COFF_IMAGE_WITH_PE
+
+/* Code to handle Microsoft's Image Library Format.
+   Also known as LINK6 format.
+   Documentation about this format can be found at: 
+
+   http://msdn.microsoft.com/library/specs/pecoff_section8.htm  */
+
+/* The following constants specify the sizes of the various data
+   structures that we have to create in order to build a bfd describing
+   an ILF object file.  The final "+ 1" in the definitions of SIZEOF_IDATA6
+   and SIZEOF_IDATA7 below is to allow for the possibility that we might
+   need a padding byte in order to ensure 16 bit alignment for the section's
+   contents.
+
+   The value for SIZEOF_ILF_STRINGS is computed as follows:
+
+      There will be NUM_ILF_SECTIONS section symbols.  Allow 9 characters
+      per symbol for their names (longest section name is .idata$2).
+
+      There will be two symbols for the imported value, one the symbol name
+      and one with _imp__ prefixed.  Allowing for the terminating nul's this
+      is strlen (symbol_name) * 2 + 8.
+
+      The strings in the string table must start STRING__SIZE_SIZE bytes into
+      the table in order to for the string lookup code in coffgen/coffcode to
+      work.  */
+#define NUM_ILF_RELOCS		8
+#define NUM_ILF_SECTIONS        6
+#define NUM_ILF_SYMS 		(2 + NUM_ILF_SECTIONS)
+  
+#define SIZEOF_ILF_SYMS		(NUM_ILF_SYMS * sizeof (* vars.sym_cache))
+#define SIZEOF_ILF_SYM_TABLE	(NUM_ILF_SYMS * sizeof (* vars.sym_table))
+#define SIZEOF_ILF_NATIVE_SYMS	(NUM_ILF_SYMS * sizeof (* vars.native_syms))
+#define SIZEOF_ILF_EXT_SYMS	(NUM_ILF_SYMS * sizeof (* vars.esym_table))
+#define SIZEOF_ILF_RELOCS	(NUM_ILF_RELOCS * sizeof (* vars.reltab))
+#define SIZEOF_ILF_INT_RELOCS	(NUM_ILF_RELOCS * sizeof (* vars.int_reltab))
+#define SIZEOF_ILF_STRINGS	(strlen (symbol_name) * 2 + 8 + NUM_ILF_SECTIONS * 9 + STRING_SIZE_SIZE)
+#define SIZEOF_IDATA2		(5 * 4)
+#define SIZEOF_IDATA4		(1 * 4)
+#define SIZEOF_IDATA5		(1 * 4)
+#define SIZEOF_IDATA6		(2 + strlen (symbol_name) + 1 + 1)
+#define SIZEOF_IDATA7		(strlen (source_dll) + 1 + 1)
+#define SIZEOF_ILF_SECTIONS     (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata))
+  
+#define ILF_DATA_SIZE				\
+      sizeof (* vars.bim)			\
+    + SIZEOF_ILF_SYMS				\
+    + SIZEOF_ILF_SYM_TABLE			\
+    + SIZEOF_ILF_NATIVE_SYMS			\
+    + SIZEOF_ILF_EXT_SYMS			\
+    + SIZEOF_ILF_RELOCS				\
+    + SIZEOF_ILF_INT_RELOCS			\
+    + SIZEOF_ILF_STRINGS			\
+    + SIZEOF_IDATA2				\
+    + SIZEOF_IDATA4				\
+    + SIZEOF_IDATA5				\
+    + SIZEOF_IDATA6				\
+    + SIZEOF_IDATA7				\
+    + SIZEOF_ILF_SECTIONS			\
+    + MAX_TEXT_SECTION_SIZE
+
+
+/* Create an empty relocation against the given symbol.  */
+static void
+pe_ILF_make_a_reloc (pe_ILF_vars *             vars,
+		     bfd_vma                   address,
+		     bfd_reloc_code_real_type  reloc,
+		     asection_ptr              sec)
+{
+  arelent * entry;
+  struct internal_reloc * internal;
+
+  entry = vars->reltab + vars->relcount;
+  internal = vars->int_reltab + vars->relcount;
+  
+  entry->address     = address;
+  entry->addend      = 0;
+  entry->howto       = bfd_reloc_type_lookup (vars->abfd, reloc);
+  entry->sym_ptr_ptr = sec->symbol_ptr_ptr;
+
+  internal->r_vaddr  = address;
+  internal->r_symndx = coff_section_data (vars->abfd, sec)->i;
+  internal->r_type   = entry->howto->type;
+#if 0  /* These fields do not need to be initialised.  */
+  internal->r_size   = 0;
+  internal->r_extern = 0;
+  internal->r_offset = 0;
+#endif
+  
+  vars->relcount ++;
+  
+  BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS);
+}
+
+/* Move the queued relocs into the given section.  */
+static void
+pe_ILF_save_relocs (pe_ILF_vars * vars,
+		    asection_ptr  sec)
+{
+  /* Make sure that there is somewhere to store the internal relocs.  */
+  if (coff_section_data (vars->abfd, sec) == NULL)
+    /* We should probably return an error indication here.  */
+    abort ();
+
+  coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab;
+  coff_section_data (vars->abfd, sec)->keep_relocs = true;
+
+  sec->relocation  = vars->reltab;
+  sec->reloc_count = vars->relcount;
+  sec->flags      |= SEC_RELOC;
+
+  vars->reltab     += vars->relcount;
+  vars->int_reltab += vars->relcount;
+  vars->relcount   = 0;
+
+  BFD_ASSERT ((bfd_byte *)vars->int_reltab < (bfd_byte *)vars->string_table);
+}
+
+/* Create a global symbol and add it to the relevant tables.  */
+static void
+pe_ILF_make_a_symbol (pe_ILF_vars *  vars,
+		      const char *   prefix,
+		      const char *   symbol_name,
+		      asection_ptr   section,
+		      flagword       extra_flags)
+{
+  coff_symbol_type * sym;
+  combined_entry_type * ent;
+  SYMENT * esym;
+  unsigned short sclass;
+
+  if (extra_flags & BSF_LOCAL)
+    sclass = C_LABEL;
+  else
+    sclass = C_EXT;
+  
+#ifdef THUMBPEMAGIC  
+  if (vars->magic == THUMBPEMAGIC)
+    {
+      if (extra_flags & BSF_FUNCTION)
+	sclass = C_THUMBEXTFUNC;
+      else if (extra_flags & BSF_LOCAL)
+	sclass = C_THUMBLABEL;
+      else
+	sclass = C_THUMBEXT;
+    }
+#endif
+
+  BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS);
+  
+  sym = vars->sym_ptr;
+  ent = vars->native_ptr;
+  esym = vars->esym_ptr;
+
+  /* Copy the symbol's name into the string table.  */
+  sprintf (vars->string_ptr, "%s%s", prefix, symbol_name);
+
+  /* Initialise the external symbol.  */
+  bfd_h_put_32 (vars->abfd, vars->string_ptr - vars->string_table, (bfd_byte *) esym->e.e.e_offset);
+  bfd_h_put_16 (vars->abfd, section->target_index, (bfd_byte *) esym->e_scnum);
+  esym->e_sclass[0] = sclass;
+
+  /* The following initialisations are unnecessary - the memory is
+     zero initialised.  They are just kept here as reminders.  */
+#if 0
+  esym->e.e.e_zeroes = 0;
+  esym->e_value = 0;
+  esym->e_type = T_NULL;
+  esym->e_numaux = 0;
+#endif
+  
+  /* Initialise the internal symbol structure.  */
+  ent->u.syment.n_sclass          = sclass;
+  ent->u.syment.n_scnum           = section->target_index;
+  ent->u.syment._n._n_n._n_offset = (long) sym;
+  
+#if 0 /* See comment above.  */
+  ent->u.syment.n_value  = 0;
+  ent->u.syment.n_flags  = 0;
+  ent->u.syment.n_type   = T_NULL;
+  ent->u.syment.n_numaux = 0;
+  ent->fix_value         = 0;
+#endif
+  
+  sym->symbol.the_bfd = vars->abfd;
+  sym->symbol.name    = vars->string_ptr;
+  sym->symbol.flags   = BSF_EXPORT | BSF_GLOBAL | extra_flags;
+  sym->symbol.section = section;
+  sym->native         = ent;
+  
+#if 0 /* See comment above.  */
+  sym->symbol.value   = 0;
+  sym->symbol.udata.i = 0;
+  sym->done_lineno    = false;
+  sym->lineno         = NULL;
+#endif
+  
+  * vars->table_ptr = vars->sym_index;
+
+  /* Adjust pointers for the next symbol.  */
+  vars->sym_index ++;
+  vars->sym_ptr ++;
+  vars->table_ptr ++;
+  vars->native_ptr ++;
+  vars->esym_ptr ++;
+  vars->string_ptr += strlen (symbol_name) + 1;
+
+  BFD_ASSERT (vars->string_ptr < vars->end_string_ptr);
+}
+
+/* Create a section.  */
+static asection_ptr
+pe_ILF_make_a_section (pe_ILF_vars * vars,
+		       const char *  name,
+		       unsigned int  size,
+		       flagword      extra_flags)
+{
+  asection_ptr sec;
+  flagword     flags;
+  
+  sec = bfd_make_section_old_way (vars->abfd, name);
+  if (sec == NULL)
+    return NULL;
+  
+  flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY;
+  
+  bfd_set_section_flags (vars->abfd, sec, flags | extra_flags);
+     
+  bfd_set_section_alignment (vars->abfd, sec, 2);
+  
+  /* Check that we will not run out of space.  */
+  BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size);
+  
+  /* Set the section size and contents.  The actual
+     contents are filled in by our parent.  */
+  bfd_set_section_size (vars->abfd, sec, size);
+  sec->contents = vars->data;
+  sec->target_index = vars->sec_index ++;
+
+  /* Advance data pointer in the vars structure.  */
+  vars->data += size;
+  
+  /* Skip the padding byte if it was not needed.
+     The logic here is that if the string length is odd,
+     then the entire string length, including the null byte,
+     is even and so the extra, padding byte, is not needed.  */
+  if (size & 1)
+    vars->data --;
+  
+  /* Create a coff_section_tdata structure for our use.  */
+  sec->used_by_bfd = (struct coff_section_tdata *) vars->data;
+  vars->data += sizeof (struct coff_section_tdata);
+
+  BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size);
+  
+  /* Create a symbol to refer to this section.  */
+  pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL);
+
+  /* Cache the index to the symbol in the coff_section_data structire.  */
+  coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1;
+  
+  return sec;
+}
+
+/* This structure contains the code that goes into the .text section
+   in order to perform a jump into the DLL lookup table.  The entries
+   in the table are index by the magic number used to represent the
+   machine type in the PE file.  The contents of the data[] arrays in
+   these entries are stolen from the jtab[] arrays in ld/pe-dll.c.
+   The SIZE field says how many bytes in the DATA array are actually
+   used.  The OFFSET field says where in the data array the address
+   of the .idata$5 section should be placed.  */
+#define MAX_TEXT_SECTION_SIZE 32
+
+typedef struct
+{
+  unsigned short magic;
+  unsigned char  data[MAX_TEXT_SECTION_SIZE];
+  unsigned int   size;
+  unsigned int   offset;
+}
+jump_table;
+
+jump_table jtab[] =
+{
+#ifdef I386MAGIC
+  { I386MAGIC,
+    { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
+    8, 2
+  },
+#endif
+  
+#ifdef  MC68MAGIC
+  { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 },
+#endif
+#ifdef  MIPS_ARCH_MAGIC_WINCE
+  { MIPS_ARCH_MAGIC_WINCE,
+    { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
+      0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 },
+    16, 0
+  },
+#endif
+  
+#ifdef  SH_ARCH_MAGIC_WINCE
+  { SH_ARCH_MAGIC_WINCE,
+    { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40,
+      0x09, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    12, 8
+  },
+#endif
+  
+#ifdef  ARMPEMAGIC
+  { ARMPEMAGIC,
+    { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0,
+      0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00},
+    12, 8
+  },
+#endif
+  
+#ifdef  THUMBPEMAGIC
+  { THUMBPEMAGIC,
+    { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46,
+      0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 },
+    16, 12
+  },
+#endif
+  { 0, { 0 }, 0, 0 }
+};
+
+#ifndef NUM_ENTRIES
+#define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0])
+#endif
+
+/* Build a full BFD from the information supplied in a ILF object.  */
+static boolean
+pe_ILF_build_a_bfd (bfd *           abfd,
+		    unsigned short  magic,
+		    bfd_byte *      symbol_name,
+		    bfd_byte *      source_dll,
+		    unsigned int    ordinal,
+		    unsigned int    types)
+{ 
+  bfd_byte *               ptr;
+  pe_ILF_vars              vars;
+  struct internal_filehdr  internal_f;
+  unsigned int             import_type;
+  unsigned int             import_name_type;
+  asection_ptr             id2, id4, id5, id6, id7, text;
+
+  text = NULL;
+  
+  /* Decode and verify the types field of the ILF structure.  */
+  import_type = types & 0x3;
+  import_name_type = (types & 0x1c) >> 2;
+
+  switch (import_type)
+    {
+    case IMPORT_CODE:
+    case IMPORT_DATA:
+      break;
+      
+    case IMPORT_CONST:
+      /* XXX code yet to be written.  */
+      _bfd_error_handler (_("%s: Unhandled import type; %x"),
+			  bfd_get_filename (abfd), import_type);
+      return false;
+      
+    default:
+      _bfd_error_handler (_("%s: Unrecognised import type; %x"),
+			  bfd_get_filename (abfd), import_type);
+      return false;
+    }
+
+  switch (import_name_type)
+    {
+    case IMPORT_ORDINAL:
+    case IMPORT_NAME:
+    case IMPORT_NAME_NOPREFIX:
+    case IMPORT_NAME_UNDECORATE:
+      break;
+      
+    default:
+      _bfd_error_handler (_("%s: Unrecognised import name type; %x"),
+			  bfd_get_filename (abfd), import_name_type);
+      return false;
+    }
+
+  /* Initialise local variables.
+     
+     Note these are kept in a structure rather than being
+     declared as statics since bfd frowns on global variables.
+     
+     We are going to construct the contents of the BFD in memory,
+     so allocate all the space that we will need right now.  */
+  ptr = bfd_zalloc (abfd, ILF_DATA_SIZE);
+  if (ptr == NULL)
+    return false;
+
+  /* Create a bfd_in_memory structure.  */
+  vars.bim = (struct bfd_in_memory *) ptr;
+  vars.bim->buffer = ptr;
+  vars.bim->size   = ILF_DATA_SIZE;
+  ptr += sizeof (* vars.bim);
+  
+  /* Initialise the pointers to regions of the memory and the
+     other contents of the pe_ILF_vars structure as well.  */
+  vars.sym_cache = (coff_symbol_type *) ptr;
+  vars.sym_ptr   = (coff_symbol_type *) ptr;
+  vars.sym_index = 0;
+  ptr += SIZEOF_ILF_SYMS;
+  
+  vars.sym_table = (unsigned int *) ptr;
+  vars.table_ptr = (unsigned int *) ptr;
+  ptr += SIZEOF_ILF_SYM_TABLE;
+
+  vars.native_syms = (combined_entry_type *) ptr;
+  vars.native_ptr  = (combined_entry_type *) ptr;
+  ptr += SIZEOF_ILF_NATIVE_SYMS;
+  
+  vars.esym_table = (SYMENT *) ptr;
+  vars.esym_ptr   = (SYMENT *) ptr;
+  ptr += SIZEOF_ILF_EXT_SYMS;
+  
+  vars.reltab   = (arelent *) ptr;
+  vars.relcount = 0;
+  ptr += SIZEOF_ILF_RELOCS;
+
+  vars.int_reltab  = (struct internal_reloc *) ptr;
+  ptr += SIZEOF_ILF_INT_RELOCS;
+
+  vars.string_table = ptr;
+  vars.string_ptr   = ptr + STRING_SIZE_SIZE;
+  ptr += SIZEOF_ILF_STRINGS;
+  vars.end_string_ptr = ptr;
+  
+  /* The remaining space in bim->buffer is used
+     by the pe_ILF_make_a_section() function.  */
+  vars.data = ptr;
+  vars.abfd = abfd;
+  vars.sec_index = 0;
+  vars.magic = magic;
+  
+  /* Create the initial .idata$<n> sections:
+     .idata$2:  Import Directory Table
+     .idata$4:  Import Lookup Table
+     .idata$5:  Import Address Table
+
+     Note we do not create a .idata$3 section as this is
+     created for us by the linker script.  */
+  id2 = pe_ILF_make_a_section (& vars, ".idata$2", SIZEOF_IDATA2, 0);
+  id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0);
+  id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0);
+  if (id2 == NULL || id4 == NULL || id5 == NULL)
+    return false;
+  
+  /* Fill in the contents of these sections.  */
+  if (import_name_type == IMPORT_ORDINAL)
+    {
+      if (ordinal == 0)
+	/* XXX - treat as IMPORT_NAME ??? */
+	abort ();
+      
+      * (unsigned int *) id4->contents = ordinal | 0x80000000;
+      * (unsigned int *) id5->contents = ordinal | 0x80000000;
+    }
+  else
+    {
+      char * symbol;
+      
+      /* Create .idata$6 - the Hint Name Table.  */
+      id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
+      if (id6 == NULL)
+	return false;
+
+      /* If necessary, trim the import symbol name.  */
+      symbol = symbol_name;
+
+      if (import_name_type != IMPORT_NAME)
+	/* Skip any prefix in symbol_name.  */
+	while (*symbol == '@' || * symbol == '?' || * symbol == '_')
+	  ++ symbol;
+
+      if (import_name_type == IMPORT_NAME_UNDECORATE)
+	{
+	  /* Truncate at the first '@'  */
+	  while (* symbol != 0 && * symbol != '@')
+	    symbol ++;
+
+	  * symbol = 0;
+	}
+      
+      strcpy (id6->contents, symbol);
+    }
+
+  /* Create .idata$7 - the Dll Name Table.  */
+  id7 = pe_ILF_make_a_section (& vars, ".idata$7", SIZEOF_IDATA7, 0);
+  if (id7 == NULL)
+    return false;
+  
+  strcpy (id7->contents + 2, source_dll);
+
+  /* Now generate the relocs for the sections.  */
+  pe_ILF_make_a_reloc (& vars,  0, BFD_RELOC_RVA, id4);
+  pe_ILF_make_a_reloc (& vars, 12, BFD_RELOC_RVA, id7);
+  pe_ILF_make_a_reloc (& vars, 16, BFD_RELOC_RVA, id5);
+  pe_ILF_save_relocs (& vars, id2);
+
+  if (import_name_type != IMPORT_ORDINAL)
+    {
+      pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
+      pe_ILF_save_relocs (& vars, id4);
+      
+      pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
+      pe_ILF_save_relocs (& vars, id5);
+    }
+
+  /* Create extra sections depending upon the type of import we are dealing with.  */
+  switch (import_type)
+    {
+      int i;
+      
+    case IMPORT_CODE:
+      /* Create a .text section.
+	 First we need to look up its contents in the jump table.  */
+      for (i = NUM_ENTRIES (jtab); i--;)
+	{
+	  if (jtab[i].size == 0)
+	    continue;
+	  if (jtab[i].magic == magic)
+	    break;
+	}
+      /* If we did not find a matching entry something is wrong.  */
+      if (i < 0)
+	abort ();
+
+      /* Create the .text section.  */
+      text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
+      if (text == NULL)
+	return false;
+
+      /* Copy in the jump code.  */
+      memcpy (text->contents, jtab[i].data, jtab[i].size);
+
+      /* Create a reloc for the data in the text section.  */
+#ifdef MIPS_ARCH_MAGIC_WINCE      
+      if (magic == MIPS_ARCH_MAGIC_WINCE)
+	{
+	  pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_HI16_S, id5);
+	  pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_LO16, text);
+	  pe_ILF_make_a_reloc (& vars, 4, BFD_RELOC_LO16, id5);
+	}
+      else
+#endif
+	pe_ILF_make_a_reloc (& vars, jtab[i].offset, BFD_RELOC_32, id5);
+      
+      pe_ILF_save_relocs (& vars, text);
+      break;
+
+    case IMPORT_DATA:
+      break;
+
+    default:
+      /* XXX code not yet written.  */
+      abort ();
+    }
+  
+  /* Initialise the bfd.  */
+  memset (& internal_f, 0, sizeof (internal_f));
+  
+  internal_f.f_magic  = magic;
+  internal_f.f_symptr = 0;
+  internal_f.f_nsyms  = 0;
+  internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
+  
+  if (   ! bfd_set_start_address (abfd, 0)
+      || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
+    return false;
+
+  if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL)
+    return false;
+
+  coff_data (abfd)->pe = 1;
+#ifdef THUMBPEMAGIC  
+  if (vars.magic == THUMBPEMAGIC)
+    /* Stop some linker warnings about thumb code not supporting interworking.  */
+    coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
+#endif
+    
+  /* Switch from file contents to memory contents.  */
+  bfd_cache_close (abfd);
+
+  abfd->iostream = (PTR) vars.bim;
+  abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
+  abfd->where = 0;
+  obj_sym_filepos (abfd) = 0;
+
+  /* Now create a symbol describing the imported value.  */
+  switch (import_type)
+    {
+    case IMPORT_CODE:
+      pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
+			    BSF_NOT_AT_END | BSF_FUNCTION);
+      break;
+
+    case IMPORT_DATA:
+      /* XXX not sure if I need to do anythign here.  */
+      break;
+      
+    default:
+      /* XXX code not yet written.  */
+      abort ();
+    }
+
+  pe_ILF_make_a_symbol (& vars, "_imp__", symbol_name, id5, 0);
+  
+  /* Point the bfd at the symbol table.  */
+  obj_symbols (abfd) = vars.sym_cache;
+  bfd_get_symcount (abfd) = vars.sym_index;
+  
+  obj_raw_syments (abfd) = vars.native_syms;
+  obj_raw_syment_count (abfd) = vars.sym_index;
+
+  obj_coff_external_syms (abfd) = (PTR) vars.esym_table;
+  obj_coff_keep_syms (abfd) = true;
+  
+  obj_convert (abfd) = vars.sym_table;
+  obj_conv_table_size (abfd) = vars.sym_index;
+  
+  obj_coff_strings (abfd) = vars.string_table;
+  obj_coff_keep_strings (abfd) = true;
+
+  abfd->flags |= HAS_SYMS;
+
+  return true;
+}
+
+/* We have detected a Image Library Format archive element.
+   Decode the element and return the appropriate target.  */
 static const bfd_target *
-pe_bfd_object_p (abfd)
-     bfd * abfd;
+pe_ILF_object_p (bfd * abfd)
+{
+  bfd_byte        buffer[16];
+  bfd_byte *      ptr;
+  bfd_byte *      symbol_name;
+  bfd_byte *      source_dll;
+  unsigned int    machine;
+  unsigned long   size;
+  unsigned int    ordinal;
+  unsigned int    types;
+  unsigned short  magic;
+  
+  /* Upon entry the first four buyes of the ILF header have
+      already been read.  Now read the rest of the header.  */
+  if (bfd_read (buffer, 1, 16, abfd) != 16)
+    return NULL;
+
+  ptr = buffer;
+  
+  /*  We do not bother to check the version number.
+      version = bfd_h_get_16 (abfd, ptr);  */
+  ptr += 2;
+
+  machine = bfd_h_get_16 (abfd, ptr);
+  ptr += 2;
+
+  /* Check that the machine type is recognised.  */
+  magic = 0;
+  
+  switch (machine)
+    {
+    case IMAGE_FILE_MACHINE_UNKNOWN:
+    case IMAGE_FILE_MACHINE_ALPHA:
+    case IMAGE_FILE_MACHINE_ALPHA64:
+    case IMAGE_FILE_MACHINE_IA64:
+      break;
+      
+    case IMAGE_FILE_MACHINE_I386:
+#ifdef I386MAGIC
+      magic = I386MAGIC;
+#endif
+      break;
+      
+    case IMAGE_FILE_MACHINE_M68K:
+#ifdef MC68AGIC
+      magic = MC68MAGIC;
+#endif
+      break;
+      
+    case IMAGE_FILE_MACHINE_R3000:
+    case IMAGE_FILE_MACHINE_R4000:
+    case IMAGE_FILE_MACHINE_R10000:
+      
+    case IMAGE_FILE_MACHINE_MIPS16:
+    case IMAGE_FILE_MACHINE_MIPSFPU:
+    case IMAGE_FILE_MACHINE_MIPSFPU16:
+#ifdef MIPS_ARCH_MAGIC_WINCE
+      magic = MIPS_ARCH_MAGIC_WINCE;
+#endif
+      break;
+      
+    case IMAGE_FILE_MACHINE_SH3:
+    case IMAGE_FILE_MACHINE_SH4:
+#ifdef SH_ARCH_MAGIC_WINCE
+      magic = SH_ARCH_MAGIC_WINCE;
+#endif
+      break;
+      
+    case IMAGE_FILE_MACHINE_ARM:
+#ifdef ARMPEMAGIC
+      magic = ARMPEMAGIC;
+#endif      
+      break;
+      
+    case IMAGE_FILE_MACHINE_THUMB:
+#ifdef THUMBPEMAGIC
+      {
+	extern bfd_target armpei_little_vec;
+	
+	if (abfd->xvec == & armpei_little_vec)
+	  magic = THUMBPEMAGIC;
+      }
+#endif      
+      break;
+      
+    case IMAGE_FILE_MACHINE_POWERPC:
+      /* We no longer support PowerPC.  */
+    default:
+      _bfd_error_handler
+	(
+_("%s: Unrecognised machine type (0x%x) in Import Library Format archive"),
+         bfd_get_filename (abfd), machine);
+      bfd_set_error (bfd_error_malformed_archive);
+	
+      return NULL;
+      break;
+    }
+
+  if (magic == 0)
+    {
+      _bfd_error_handler
+	(
+_("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"),
+	 bfd_get_filename (abfd), machine);
+      bfd_set_error (bfd_error_wrong_format);
+	
+      return NULL;
+    }  
+
+  /* We do not bother to check the date.
+     date = bfd_h_get_32 (abfd, ptr);  */
+  ptr += 4;
+  
+  size = bfd_h_get_32 (abfd, ptr);
+  ptr += 4;
+
+  if (size == 0)
+    {
+      _bfd_error_handler
+	(_("%s: size field is zero in Import Library Format header"),
+	 bfd_get_filename (abfd));
+      bfd_set_error (bfd_error_malformed_archive);
+	
+      return NULL;
+    }
+
+  ordinal = bfd_h_get_16 (abfd, ptr);
+  ptr += 2;
+
+  types = bfd_h_get_16 (abfd, ptr);
+  /* ptr += 2; */
+
+  /* Now read in the two strings that follow.  */
+  ptr = bfd_alloc (abfd, size);
+  if (ptr == NULL)
+    return NULL;
+  
+  if (bfd_read (ptr, 1, size, abfd) != size)
+    return NULL;
+
+  symbol_name = ptr;
+  source_dll  = ptr + strlen (ptr) + 1;
+  
+  /* Verify that the strings are null terminated.  */
+  if (ptr[size - 1] != 0 || ((source_dll - ptr) >= size))
+    {
+      _bfd_error_handler
+	(_("%s: string not null terminated in ILF object file."),
+	 bfd_get_filename (abfd));
+      bfd_set_error (bfd_error_malformed_archive);
+	
+      return NULL;
+    }
+  
+  /* Now construct the bfd.  */
+  if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
+			    source_dll, ordinal, types))
+    return NULL;
+  
+  return abfd->xvec;
+}
+
+static const bfd_target *
+pe_bfd_object_p (bfd * abfd)
 {
   /* We need to handle a PE image correctly.  In PE images created by
      the GNU linker, the offset to the COFF header is always the size.
@@ -390,14 +1241,7 @@ pe_bfd_object_p (abfd)
   signature = bfd_h_get_32 (abfd, buffer);
   
   if (signature == 0xffff0000)
-    {
-      _bfd_error_handler (
-_("%s: Import Library Format archives are not currently supported"),
-			  bfd_get_filename (abfd));
-      bfd_set_error (bfd_error_wrong_format);
-	
-      return NULL;
-    }
+    return pe_ILF_object_p (abfd);
   
   if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
       || bfd_read (buffer, 1, 4, abfd) != 4)
@@ -444,4 +1288,4 @@ _("%s: Import Library Format archives are not currently supported"),
 }
 
 #define coff_object_p pe_bfd_object_p
-#endif
+#endif /* COFF_IMAGE_WITH_PE */