bfd/peicode.h

   1 /* Support for the generic parts of PE/PEI, for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   3    Written by Cygnus Solutions.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /*
  22 Most of this hacked by  Steve Chamberlain,
  23                         sac@cygnus.com
  24
  25 PE/PEI rearrangement (and code added): Donn Terry
  26                                        Softway Systems, Inc.
  27 */
  28
  29 /* Hey look, some documentation [and in a place you expect to find it]!
  30
  31    The main reference for the pei format is "Microsoft Portable Executable
  32    and Common Object File Format Specification 4.1".  Get it if you need to
  33    do some serious hacking on this code.
  34
  35    Another reference:
  36    "Peering Inside the PE: A Tour of the Win32 Portable Executable
  37    File Format", MSJ 1994, Volume 9.
  38
  39    The *sole* difference between the pe format and the pei format is that the
  40    latter has an MSDOS 2.0 .exe header on the front that prints the message
  41    "This app must be run under Windows." (or some such).
  42    (FIXME: Whether that statement is *really* true or not is unknown.
  43    Are there more subtle differences between pe and pei formats?
  44    For now assume there aren't.  If you find one, then for God sakes
  45    document it here!)
  46
  47    The Microsoft docs use the word "image" instead of "executable" because
  48    the former can also refer to a DLL (shared library).  Confusion can arise
  49    because the `i' in `pei' also refers to "image".  The `pe' format can
  50    also create images (i.e. executables), it's just that to run on a win32
  51    system you need to use the pei format.
  52
  53    FIXME: Please add more docs here so the next poor fool that has to hack
  54    on this code has a chance of getting something accomplished without
  55    wasting too much time.
  56 */
  57
  58 #include "libpei.h"
  59
  60 static boolean (*pe_saved_coff_bfd_print_private_bfd_data)
  61     PARAMS ((bfd *, PTR)) =
  62 #ifndef coff_bfd_print_private_bfd_data
  63      NULL;
  64 #else
  65      coff_bfd_print_private_bfd_data;
  66 #undef coff_bfd_print_private_bfd_data
  67 #endif
  68
  69 static boolean pe_print_private_bfd_data PARAMS ((bfd *, PTR));
  70 #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data
  71
  72 static boolean (*pe_saved_coff_bfd_copy_private_bfd_data)
  73     PARAMS ((bfd *, bfd *)) =
  74 #ifndef coff_bfd_copy_private_bfd_data
  75      NULL;
  76 #else
  77      coff_bfd_copy_private_bfd_data;
  78 #undef coff_bfd_copy_private_bfd_data
  79 #endif
  80
  81 static boolean pe_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
  82 #define coff_bfd_copy_private_bfd_data pe_bfd_copy_private_bfd_data
  83
  84 #define coff_mkobject      pe_mkobject
  85 #define coff_mkobject_hook pe_mkobject_hook
  86
  87 #ifndef NO_COFF_RELOCS
  88 static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
  89 static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
  90 #endif
  91 static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR));
  92 static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR));
  93 static boolean pe_mkobject PARAMS ((bfd *));
  94 static PTR pe_mkobject_hook PARAMS ((bfd *, PTR, PTR));
  95
  96 #ifdef COFF_IMAGE_WITH_PE
  97 /* This structure contains static variables used by the ILF code.  */
  98 typedef asection * asection_ptr;
  99
 100 typedef struct
 101 {
 102   bfd *                 abfd;
 103   bfd_byte *            data;
 104   struct bfd_in_memory * bim;
 105   unsigned short        magic;
 106
 107   arelent *             reltab;
 108   unsigned int          relcount;
 109
 110   coff_symbol_type *    sym_cache;
 111   coff_symbol_type *    sym_ptr;
 112   unsigned int          sym_index;
 113
 114   unsigned int *        sym_table;
 115   unsigned int *        table_ptr;
 116
 117   combined_entry_type * native_syms;
 118   combined_entry_type * native_ptr;
 119
 120   coff_symbol_type **   sym_ptr_table;
 121   coff_symbol_type **   sym_ptr_ptr;
 122
 123   unsigned int          sec_index;
 124
 125   char *                string_table;
 126   char *                string_ptr;
 127   char *                end_string_ptr;
 128
 129   SYMENT *              esym_table;
 130   SYMENT *              esym_ptr;
 131
 132   struct internal_reloc * int_reltab;
 133 }
 134 pe_ILF_vars;
 135
 136 static asection_ptr       pe_ILF_make_a_section   PARAMS ((pe_ILF_vars *, const char *, unsigned int, flagword));
 137 static void               pe_ILF_make_a_reloc     PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, asection_ptr));
 138 static void               pe_ILF_make_a_symbol    PARAMS ((pe_ILF_vars *, const char *, const char *, asection_ptr, flagword));
 139 static void               pe_ILF_save_relocs      PARAMS ((pe_ILF_vars *, asection_ptr));
 140 static void               pe_ILF_make_a_symbol_reloc  PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, struct symbol_cache_entry **, unsigned int));
 141 static boolean            pe_ILF_build_a_bfd      PARAMS ((bfd *, unsigned short, bfd_byte *, bfd_byte *, unsigned int, unsigned int));
 142 static const bfd_target * pe_ILF_object_p         PARAMS ((bfd *));
 143 static const bfd_target * pe_bfd_object_p         PARAMS ((bfd *));
 144 #endif /* COFF_IMAGE_WITH_PE */
 145
 146 /**********************************************************************/
 147
 148 #ifndef NO_COFF_RELOCS
 149 static void
 150 coff_swap_reloc_in (abfd, src, dst)
 151      bfd *abfd;
 152      PTR src;
 153      PTR dst;
 154 {
 155   RELOC *reloc_src = (RELOC *) src;
 156   struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
 157
 158   reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
 159   reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
 160
 161   reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
 162
 163 #ifdef SWAP_IN_RELOC_OFFSET
 164   reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
 165                                              (bfd_byte *) reloc_src->r_offset);
 166 #endif
 167 }
 168
 169 static unsigned int
 170 coff_swap_reloc_out (abfd, src, dst)
 171      bfd       *abfd;
 172      PTR        src;
 173      PTR        dst;
 174 {
 175   struct internal_reloc *reloc_src = (struct internal_reloc *)src;
 176   struct external_reloc *reloc_dst = (struct external_reloc *)dst;
 177   bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
 178   bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
 179
 180   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
 181                reloc_dst->r_type);
 182
 183 #ifdef SWAP_OUT_RELOC_OFFSET
 184   SWAP_OUT_RELOC_OFFSET(abfd,
 185                         reloc_src->r_offset,
 186                         (bfd_byte *) reloc_dst->r_offset);
 187 #endif
 188 #ifdef SWAP_OUT_RELOC_EXTRA
 189   SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
 190 #endif
 191   return RELSZ;
 192 }
 193 #endif /* not NO_COFF_RELOCS */
 194
 195 static void
 196 coff_swap_filehdr_in (abfd, src, dst)
 197      bfd            *abfd;
 198      PTR             src;
 199      PTR             dst;
 200 {
 201   FILHDR *filehdr_src = (FILHDR *) src;
 202   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
 203   filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
 204   filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
 205   filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
 206
 207   filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
 208   filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
 209   filehdr_dst->f_symptr = bfd_h_get_32 (abfd, (bfd_byte *) filehdr_src->f_symptr);
 210
 211 #ifdef COFF_IMAGE_WITH_PE
 212   /* There are really two magic numbers involved; the magic number
 213      that says this is a NT executable (PEI) and the magic number that
 214      determines the architecture.  The former is DOSMAGIC, stored in
 215      the e_magic field.  The latter is stored in the f_magic field.
 216      If the NT magic number isn't valid, the architecture magic number
 217      could be mimicked by some other field (specifically, the number
 218      of relocs in section 3).  Since this routine can only be called
 219      correctly for a PEI file, check the e_magic number here, and, if
 220      it doesn't match, clobber the f_magic number so that we don't get
 221      a false match.  */
 222 #if 0
 223   /* We can't assume that the PE header is at offset 0x80.  When it
 224      isn't, the DOS header isn't read correctly, so we can't assume
 225      e_magic is set even for valid PE files.  */
 226   if (bfd_h_get_16 (abfd, (bfd_byte *) filehdr_src->e_magic) != DOSMAGIC)
 227     filehdr_dst->f_magic = -1;
 228 #endif
 229 #endif
 230
 231   /* Other people's tools sometimes generate headers with an nsyms but
 232      a zero symptr.  */
 233   if (filehdr_dst->f_nsyms != 0 && filehdr_dst->f_symptr == 0)
 234     {
 235       filehdr_dst->f_nsyms = 0;
 236       filehdr_dst->f_flags |= F_LSYMS;
 237     }
 238
 239   filehdr_dst->f_opthdr = bfd_h_get_16(abfd,
 240                                        (bfd_byte *)filehdr_src-> f_opthdr);
 241 }
 242
 243 #ifdef COFF_IMAGE_WITH_PE
 244 #define coff_swap_filehdr_out _bfd_pei_only_swap_filehdr_out
 245 #else
 246 #define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out
 247 #endif
 248
 249 static void
 250 coff_swap_scnhdr_in (abfd, ext, in)
 251      bfd            *abfd;
 252      PTR             ext;
 253      PTR             in;
 254 {
 255   SCNHDR *scnhdr_ext = (SCNHDR *) ext;
 256   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 257
 258   memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name));
 259   scnhdr_int->s_vaddr =
 260     GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
 261   scnhdr_int->s_paddr =
 262     GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
 263   scnhdr_int->s_size =
 264     GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
 265   scnhdr_int->s_scnptr =
 266     GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
 267   scnhdr_int->s_relptr =
 268     GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
 269   scnhdr_int->s_lnnoptr =
 270     GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
 271   scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
 272
 273   /* MS handles overflow of line numbers by carrying into the reloc
 274      field (it appears).  Since it's supposed to be zero for PE
 275      *IMAGE* format, that's safe.  This is still a bit iffy.  */
 276 #ifdef COFF_IMAGE_WITH_PE
 277   scnhdr_int->s_nlnno =
 278     (bfd_h_get_16 (abfd, (bfd_byte *) scnhdr_ext->s_nlnno)
 279      + (bfd_h_get_16 (abfd, (bfd_byte *) scnhdr_ext->s_nreloc) << 16));
 280   scnhdr_int->s_nreloc = 0;
 281 #else
 282   scnhdr_int->s_nreloc = bfd_h_get_16 (abfd,
 283                                        (bfd_byte *) scnhdr_ext->s_nreloc);
 284   scnhdr_int->s_nlnno = bfd_h_get_16 (abfd,
 285                                       (bfd_byte *) scnhdr_ext->s_nlnno);
 286 #endif
 287
 288   if (scnhdr_int->s_vaddr != 0)
 289     {
 290       scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
 291       scnhdr_int->s_vaddr &= 0xffffffff;
 292     }
 293
 294 #ifndef COFF_NO_HACK_SCNHDR_SIZE
 295   /* If this section holds uninitialized data, use the virtual size
 296      (stored in s_paddr) instead of the physical size.  */
 297   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
 298     {
 299       scnhdr_int->s_size = scnhdr_int->s_paddr;
 300       /* This code used to set scnhdr_int->s_paddr to 0.  However,
 301          coff_set_alignment_hook stores s_paddr in virt_size, which
 302          only works if it correctly holds the virtual size of the
 303          section.  */
 304     }
 305 #endif
 306 }
 307
 308 static boolean
 309 pe_mkobject (abfd)
 310      bfd * abfd;
 311 {
 312   pe_data_type *pe;
 313   abfd->tdata.pe_obj_data =
 314     (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
 315
 316   if (abfd->tdata.pe_obj_data == 0)
 317     return false;
 318
 319   pe = pe_data (abfd);
 320
 321   pe->coff.pe = 1;
 322
 323   /* in_reloc_p is architecture dependent.  */
 324   pe->in_reloc_p = in_reloc_p;
 325   return true;
 326 }
 327
 328 /* Create the COFF backend specific information.  */
 329 static PTR
 330 pe_mkobject_hook (abfd, filehdr, aouthdr)
 331      bfd * abfd;
 332      PTR filehdr;
 333      PTR aouthdr ATTRIBUTE_UNUSED;
 334 {
 335   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
 336   pe_data_type *pe;
 337
 338   if (pe_mkobject (abfd) == false)
 339     return NULL;
 340
 341   pe = pe_data (abfd);
 342   pe->coff.sym_filepos = internal_f->f_symptr;
 343   /* These members communicate important constants about the symbol
 344      table to GDB's symbol-reading code.  These `constants'
 345      unfortunately vary among coff implementations...  */
 346   pe->coff.local_n_btmask = N_BTMASK;
 347   pe->coff.local_n_btshft = N_BTSHFT;
 348   pe->coff.local_n_tmask = N_TMASK;
 349   pe->coff.local_n_tshift = N_TSHIFT;
 350   pe->coff.local_symesz = SYMESZ;
 351   pe->coff.local_auxesz = AUXESZ;
 352   pe->coff.local_linesz = LINESZ;
 353
 354   pe->coff.timestamp = internal_f->f_timdat;
 355
 356   obj_raw_syment_count (abfd) =
 357     obj_conv_table_size (abfd) =
 358       internal_f->f_nsyms;
 359
 360   pe->real_flags = internal_f->f_flags;
 361
 362   if ((internal_f->f_flags & F_DLL) != 0)
 363     pe->dll = 1;
 364
 365   if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
 366     abfd->flags |= HAS_DEBUG;
 367
 368 #ifdef COFF_IMAGE_WITH_PE
 369   if (aouthdr)
 370     pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe;
 371 #endif
 372
 373 #ifdef ARM
 374   if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
 375     coff_data (abfd) ->flags = 0;
 376 #endif
 377
 378   return (PTR) pe;
 379 }
 380
 381 static boolean
 382 pe_print_private_bfd_data (abfd, vfile)
 383      bfd *abfd;
 384      PTR vfile;
 385 {
 386   FILE *file = (FILE *) vfile;
 387
 388   if (!_bfd_pe_print_private_bfd_data_common (abfd, vfile))
 389     return false;
 390
 391   if (pe_saved_coff_bfd_print_private_bfd_data != NULL)
 392     {
 393       fputc ('\n', file);
 394
 395       return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile);
 396     }
 397
 398   return true;
 399 }
 400
 401 /* Copy any private info we understand from the input bfd
 402    to the output bfd.  */
 403
 404 static boolean
 405 pe_bfd_copy_private_bfd_data (ibfd, obfd)
 406      bfd *ibfd, *obfd;
 407 {
 408   if (!_bfd_pe_bfd_copy_private_bfd_data_common (ibfd, obfd))
 409     return false;
 410
 411   if (pe_saved_coff_bfd_copy_private_bfd_data)
 412     return pe_saved_coff_bfd_copy_private_bfd_data (ibfd, obfd);
 413
 414   return true;
 415 }
 416
 417 #define coff_bfd_copy_private_section_data \
 418   _bfd_pe_bfd_copy_private_section_data
 419
 420 #define coff_get_symbol_info _bfd_pe_get_symbol_info
 421
 422 #ifdef COFF_IMAGE_WITH_PE
 423 \f
 424 /* Code to handle Microsoft's Image Library Format.
 425    Also known as LINK6 format.
 426    Documentation about this format can be found at:
 427
 428    http://msdn.microsoft.com/library/specs/pecoff_section8.htm  */
 429
 430 /* The following constants specify the sizes of the various data
 431    structures that we have to create in order to build a bfd describing
 432    an ILF object file.  The final "+ 1" in the definitions of SIZEOF_IDATA6
 433    and SIZEOF_IDATA7 below is to allow for the possibility that we might
 434    need a padding byte in order to ensure 16 bit alignment for the section's
 435    contents.
 436
 437    The value for SIZEOF_ILF_STRINGS is computed as follows:
 438
 439       There will be NUM_ILF_SECTIONS section symbols.  Allow 9 characters
 440       per symbol for their names (longest section name is .idata$x).
 441
 442       There will be two symbols for the imported value, one the symbol name
 443       and one with _imp__ prefixed.  Allowing for the terminating nul's this
 444       is strlen (symbol_name) * 2 + 8 + 21 + strlen (source_dll).
 445
 446       The strings in the string table must start STRING__SIZE_SIZE bytes into
 447       the table in order to for the string lookup code in coffgen/coffcode to
 448       work.  */
 449 #define NUM_ILF_RELOCS          8
 450 #define NUM_ILF_SECTIONS        6
 451 #define NUM_ILF_SYMS            (2 + NUM_ILF_SECTIONS)
 452
 453 #define SIZEOF_ILF_SYMS         (NUM_ILF_SYMS * sizeof (* vars.sym_cache))
 454 #define SIZEOF_ILF_SYM_TABLE    (NUM_ILF_SYMS * sizeof (* vars.sym_table))
 455 #define SIZEOF_ILF_NATIVE_SYMS  (NUM_ILF_SYMS * sizeof (* vars.native_syms))
 456 #define SIZEOF_ILF_SYM_PTR_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_ptr_table))
 457 #define SIZEOF_ILF_EXT_SYMS     (NUM_ILF_SYMS * sizeof (* vars.esym_table))
 458 #define SIZEOF_ILF_RELOCS       (NUM_ILF_RELOCS * sizeof (* vars.reltab))
 459 #define SIZEOF_ILF_INT_RELOCS   (NUM_ILF_RELOCS * sizeof (* vars.int_reltab))
 460 #define SIZEOF_ILF_STRINGS      (strlen (symbol_name) * 2 + 8 \
 461                                         + 21 + strlen (source_dll) \
 462                                         + NUM_ILF_SECTIONS * 9 \
 463                                         + STRING_SIZE_SIZE)
 464 #define SIZEOF_IDATA2           (5 * 4)
 465 #define SIZEOF_IDATA4           (1 * 4)
 466 #define SIZEOF_IDATA5           (1 * 4)
 467 #define SIZEOF_IDATA6           (2 + strlen (symbol_name) + 1 + 1)
 468 #define SIZEOF_IDATA7           (strlen (source_dll) + 1 + 1)
 469 #define SIZEOF_ILF_SECTIONS     (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata))
 470
 471 #define ILF_DATA_SIZE                           \
 472       sizeof (* vars.bim)                       \
 473     + SIZEOF_ILF_SYMS                           \
 474     + SIZEOF_ILF_SYM_TABLE                      \
 475     + SIZEOF_ILF_NATIVE_SYMS                    \
 476     + SIZEOF_ILF_SYM_PTR_TABLE                  \
 477     + SIZEOF_ILF_EXT_SYMS                       \
 478     + SIZEOF_ILF_RELOCS                         \
 479     + SIZEOF_ILF_INT_RELOCS                     \
 480     + SIZEOF_ILF_STRINGS                        \
 481     + SIZEOF_IDATA2                             \
 482     + SIZEOF_IDATA4                             \
 483     + SIZEOF_IDATA5                             \
 484     + SIZEOF_IDATA6                             \
 485     + SIZEOF_IDATA7                             \
 486     + SIZEOF_ILF_SECTIONS                       \
 487     + MAX_TEXT_SECTION_SIZE
 488
 489 /* Create an empty relocation against the given symbol.  */
 490 static void
 491 pe_ILF_make_a_symbol_reloc (pe_ILF_vars *                 vars,
 492                             bfd_vma                       address,
 493                             bfd_reloc_code_real_type      reloc,
 494                             struct symbol_cache_entry **  sym,
 495                             unsigned int                  sym_index)
 496 {
 497   arelent * entry;
 498   struct internal_reloc * internal;
 499
 500   entry = vars->reltab + vars->relcount;
 501   internal = vars->int_reltab + vars->relcount;
 502
 503   entry->address     = address;
 504   entry->addend      = 0;
 505   entry->howto       = bfd_reloc_type_lookup (vars->abfd, reloc);
 506   entry->sym_ptr_ptr = sym;
 507
 508   internal->r_vaddr  = address;
 509   internal->r_symndx = sym_index;
 510   internal->r_type   = entry->howto->type;
 511 #if 0  /* These fields do not need to be initialised.  */
 512   internal->r_size   = 0;
 513   internal->r_extern = 0;
 514   internal->r_offset = 0;
 515 #endif
 516
 517   vars->relcount ++;
 518
 519   BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS);
 520 }
 521
 522 /* Create an empty relocation against the given section.  */
 523 static void
 524 pe_ILF_make_a_reloc (pe_ILF_vars *             vars,
 525                      bfd_vma                   address,
 526                      bfd_reloc_code_real_type  reloc,
 527                      asection_ptr              sec)
 528 {
 529   pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr,
 530                               coff_section_data (vars->abfd, sec)->i);
 531 }
 532
 533 /* Move the queued relocs into the given section.  */
 534 static void
 535 pe_ILF_save_relocs (pe_ILF_vars * vars,
 536                     asection_ptr  sec)
 537 {
 538   /* Make sure that there is somewhere to store the internal relocs.  */
 539   if (coff_section_data (vars->abfd, sec) == NULL)
 540     /* We should probably return an error indication here.  */
 541     abort ();
 542
 543   coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab;
 544   coff_section_data (vars->abfd, sec)->keep_relocs = true;
 545
 546   sec->relocation  = vars->reltab;
 547   sec->reloc_count = vars->relcount;
 548   sec->flags      |= SEC_RELOC;
 549
 550   vars->reltab     += vars->relcount;
 551   vars->int_reltab += vars->relcount;
 552   vars->relcount   = 0;
 553
 554   BFD_ASSERT ((bfd_byte *)vars->int_reltab < (bfd_byte *)vars->string_table);
 555 }
 556
 557 /* Create a global symbol and add it to the relevant tables.  */
 558 static void
 559 pe_ILF_make_a_symbol (pe_ILF_vars *  vars,
 560                       const char *   prefix,
 561                       const char *   symbol_name,
 562                       asection_ptr   section,
 563                       flagword       extra_flags)
 564 {
 565   coff_symbol_type * sym;
 566   combined_entry_type * ent;
 567   SYMENT * esym;
 568   unsigned short sclass;
 569
 570   if (extra_flags & BSF_LOCAL)
 571     sclass = C_STAT;
 572   else
 573     sclass = C_EXT;
 574
 575 #ifdef THUMBPEMAGIC
 576   if (vars->magic == THUMBPEMAGIC)
 577     {
 578       if (extra_flags & BSF_FUNCTION)
 579         sclass = C_THUMBEXTFUNC;
 580       else if (extra_flags & BSF_LOCAL)
 581         sclass = C_THUMBSTAT;
 582       else
 583         sclass = C_THUMBEXT;
 584     }
 585 #endif
 586
 587   BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS);
 588
 589   sym = vars->sym_ptr;
 590   ent = vars->native_ptr;
 591   esym = vars->esym_ptr;
 592
 593   /* Copy the symbol's name into the string table.  */
 594   sprintf (vars->string_ptr, "%s%s", prefix, symbol_name);
 595
 596   if (section == NULL)
 597     section = (asection_ptr) & bfd_und_section;
 598
 599   /* Initialise the external symbol.  */
 600   bfd_h_put_32 (vars->abfd, vars->string_ptr - vars->string_table, (bfd_byte *) esym->e.e.e_offset);
 601   bfd_h_put_16 (vars->abfd, section->target_index, (bfd_byte *) esym->e_scnum);
 602   esym->e_sclass[0] = sclass;
 603
 604   /* The following initialisations are unnecessary - the memory is
 605      zero initialised.  They are just kept here as reminders.  */
 606 #if 0
 607   esym->e.e.e_zeroes = 0;
 608   esym->e_value = 0;
 609   esym->e_type = T_NULL;
 610   esym->e_numaux = 0;
 611 #endif
 612
 613   /* Initialise the internal symbol structure.  */
 614   ent->u.syment.n_sclass          = sclass;
 615   ent->u.syment.n_scnum           = section->target_index;
 616   ent->u.syment._n._n_n._n_offset = (long) sym;
 617
 618 #if 0 /* See comment above.  */
 619   ent->u.syment.n_value  = 0;
 620   ent->u.syment.n_flags  = 0;
 621   ent->u.syment.n_type   = T_NULL;
 622   ent->u.syment.n_numaux = 0;
 623   ent->fix_value         = 0;
 624 #endif
 625
 626   sym->symbol.the_bfd = vars->abfd;
 627   sym->symbol.name    = vars->string_ptr;
 628   sym->symbol.flags   = BSF_EXPORT | BSF_GLOBAL | extra_flags;
 629   sym->symbol.section = section;
 630   sym->native         = ent;
 631
 632 #if 0 /* See comment above.  */
 633   sym->symbol.value   = 0;
 634   sym->symbol.udata.i = 0;
 635   sym->done_lineno    = false;
 636   sym->lineno         = NULL;
 637 #endif
 638
 639   * vars->table_ptr = vars->sym_index;
 640   * vars->sym_ptr_ptr = sym;
 641
 642   /* Adjust pointers for the next symbol.  */
 643   vars->sym_index ++;
 644   vars->sym_ptr ++;
 645   vars->sym_ptr_ptr ++;
 646   vars->table_ptr ++;
 647   vars->native_ptr ++;
 648   vars->esym_ptr ++;
 649   vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1;
 650
 651   BFD_ASSERT (vars->string_ptr < vars->end_string_ptr);
 652 }
 653
 654 /* Create a section.  */
 655 static asection_ptr
 656 pe_ILF_make_a_section (pe_ILF_vars * vars,
 657                        const char *  name,
 658                        unsigned int  size,
 659                        flagword      extra_flags)
 660 {
 661   asection_ptr sec;
 662   flagword     flags;
 663
 664   sec = bfd_make_section_old_way (vars->abfd, name);
 665   if (sec == NULL)
 666     return NULL;
 667
 668   flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY;
 669
 670   bfd_set_section_flags (vars->abfd, sec, flags | extra_flags);
 671
 672   bfd_set_section_alignment (vars->abfd, sec, 2);
 673
 674   /* Check that we will not run out of space.  */
 675   BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size);
 676
 677   /* Set the section size and contents.  The actual
 678      contents are filled in by our parent.  */
 679   bfd_set_section_size (vars->abfd, sec, size);
 680   sec->contents = vars->data;
 681   sec->target_index = vars->sec_index ++;
 682
 683   /* Advance data pointer in the vars structure.  */
 684   vars->data += size;
 685
 686   /* Skip the padding byte if it was not needed.
 687      The logic here is that if the string length is odd,
 688      then the entire string length, including the null byte,
 689      is even and so the extra, padding byte, is not needed.  */
 690   if (size & 1)
 691     vars->data --;
 692
 693   /* Create a coff_section_tdata structure for our use.  */
 694   sec->used_by_bfd = (struct coff_section_tdata *) vars->data;
 695   vars->data += sizeof (struct coff_section_tdata);
 696
 697   BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size);
 698
 699   /* Create a symbol to refer to this section.  */
 700   pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL);
 701
 702   /* Cache the index to the symbol in the coff_section_data structure.  */
 703   coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1;
 704
 705   return sec;
 706 }
 707
 708 /* This structure contains the code that goes into the .text section
 709    in order to perform a jump into the DLL lookup table.  The entries
 710    in the table are index by the magic number used to represent the
 711    machine type in the PE file.  The contents of the data[] arrays in
 712    these entries are stolen from the jtab[] arrays in ld/pe-dll.c.
 713    The SIZE field says how many bytes in the DATA array are actually
 714    used.  The OFFSET field says where in the data array the address
 715    of the .idata$5 section should be placed.  */
 716 #define MAX_TEXT_SECTION_SIZE 32
 717
 718 typedef struct
 719 {
 720   unsigned short magic;
 721   unsigned char  data[MAX_TEXT_SECTION_SIZE];
 722   unsigned int   size;
 723   unsigned int   offset;
 724 }
 725 jump_table;
 726
 727 static jump_table jtab[] =
 728 {
 729 #ifdef I386MAGIC
 730   { I386MAGIC,
 731     { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
 732     8, 2
 733   },
 734 #endif
 735
 736 #ifdef  MC68MAGIC
 737   { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 },
 738 #endif
 739 #ifdef  MIPS_ARCH_MAGIC_WINCE
 740   { MIPS_ARCH_MAGIC_WINCE,
 741     { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
 742       0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 },
 743     16, 0
 744   },
 745 #endif
 746
 747 #ifdef  SH_ARCH_MAGIC_WINCE
 748   { SH_ARCH_MAGIC_WINCE,
 749     { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40,
 750       0x09, 0x00, 0x00, 0x00, 0x00, 0x00 },
 751     12, 8
 752   },
 753 #endif
 754
 755 #ifdef  ARMPEMAGIC
 756   { ARMPEMAGIC,
 757     { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0,
 758       0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00},
 759     12, 8
 760   },
 761 #endif
 762
 763 #ifdef  THUMBPEMAGIC
 764   { THUMBPEMAGIC,
 765     { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46,
 766       0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 },
 767     16, 12
 768   },
 769 #endif
 770   { 0, { 0 }, 0, 0 }
 771 };
 772
 773 #ifndef NUM_ENTRIES
 774 #define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0])
 775 #endif
 776
 777 /* Build a full BFD from the information supplied in a ILF object.  */
 778 static boolean
 779 pe_ILF_build_a_bfd (bfd *           abfd,
 780                     unsigned short  magic,
 781                     bfd_byte *      symbol_name,
 782                     bfd_byte *      source_dll,
 783                     unsigned int    ordinal,
 784                     unsigned int    types)
 785 {
 786   bfd_byte *               ptr;
 787   pe_ILF_vars              vars;
 788   struct internal_filehdr  internal_f;
 789   unsigned int             import_type;
 790   unsigned int             import_name_type;
 791   asection_ptr             id4, id5, id6 = NULL, text = NULL;
 792   coff_symbol_type **      imp_sym;
 793   unsigned int             imp_index;
 794
 795   /* Decode and verify the types field of the ILF structure.  */
 796   import_type = types & 0x3;
 797   import_name_type = (types & 0x1c) >> 2;
 798
 799   switch (import_type)
 800     {
 801     case IMPORT_CODE:
 802     case IMPORT_DATA:
 803       break;
 804
 805     case IMPORT_CONST:
 806       /* XXX code yet to be written.  */
 807       _bfd_error_handler (_("%s: Unhandled import type; %x"),
 808                           bfd_get_filename (abfd), import_type);
 809       return false;
 810
 811     default:
 812       _bfd_error_handler (_("%s: Unrecognised import type; %x"),
 813                           bfd_get_filename (abfd), import_type);
 814       return false;
 815     }
 816
 817   switch (import_name_type)
 818     {
 819     case IMPORT_ORDINAL:
 820     case IMPORT_NAME:
 821     case IMPORT_NAME_NOPREFIX:
 822     case IMPORT_NAME_UNDECORATE:
 823       break;
 824
 825     default:
 826       _bfd_error_handler (_("%s: Unrecognised import name type; %x"),
 827                           bfd_get_filename (abfd), import_name_type);
 828       return false;
 829     }
 830
 831   /* Initialise local variables.
 832
 833      Note these are kept in a structure rather than being
 834      declared as statics since bfd frowns on global variables.
 835
 836      We are going to construct the contents of the BFD in memory,
 837      so allocate all the space that we will need right now.  */
 838   ptr = bfd_zalloc (abfd, ILF_DATA_SIZE);
 839   if (ptr == NULL)
 840     return false;
 841
 842   /* Create a bfd_in_memory structure.  */
 843   vars.bim = (struct bfd_in_memory *) ptr;
 844   vars.bim->buffer = ptr;
 845   vars.bim->size   = ILF_DATA_SIZE;
 846   ptr += sizeof (* vars.bim);
 847
 848   /* Initialise the pointers to regions of the memory and the
 849      other contents of the pe_ILF_vars structure as well.  */
 850   vars.sym_cache = (coff_symbol_type *) ptr;
 851   vars.sym_ptr   = (coff_symbol_type *) ptr;
 852   vars.sym_index = 0;
 853   ptr += SIZEOF_ILF_SYMS;
 854
 855   vars.sym_table = (unsigned int *) ptr;
 856   vars.table_ptr = (unsigned int *) ptr;
 857   ptr += SIZEOF_ILF_SYM_TABLE;
 858
 859   vars.native_syms = (combined_entry_type *) ptr;
 860   vars.native_ptr  = (combined_entry_type *) ptr;
 861   ptr += SIZEOF_ILF_NATIVE_SYMS;
 862
 863   vars.sym_ptr_table = (coff_symbol_type **) ptr;
 864   vars.sym_ptr_ptr   = (coff_symbol_type **) ptr;
 865   ptr += SIZEOF_ILF_SYM_PTR_TABLE;
 866
 867   vars.esym_table = (SYMENT *) ptr;
 868   vars.esym_ptr   = (SYMENT *) ptr;
 869   ptr += SIZEOF_ILF_EXT_SYMS;
 870
 871   vars.reltab   = (arelent *) ptr;
 872   vars.relcount = 0;
 873   ptr += SIZEOF_ILF_RELOCS;
 874
 875   vars.int_reltab  = (struct internal_reloc *) ptr;
 876   ptr += SIZEOF_ILF_INT_RELOCS;
 877
 878   vars.string_table = ptr;
 879   vars.string_ptr   = ptr + STRING_SIZE_SIZE;
 880   ptr += SIZEOF_ILF_STRINGS;
 881   vars.end_string_ptr = ptr;
 882
 883   /* The remaining space in bim->buffer is used
 884      by the pe_ILF_make_a_section() function.  */
 885   vars.data = ptr;
 886   vars.abfd = abfd;
 887   vars.sec_index = 0;
 888   vars.magic = magic;
 889
 890   /* Create the initial .idata$<n> sections:
 891      [.idata$2:  Import Directory Table -- not needed]
 892      .idata$4:  Import Lookup Table
 893      .idata$5:  Import Address Table
 894
 895      Note we do not create a .idata$3 section as this is
 896      created for us by the linker script.  */
 897   id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0);
 898   id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0);
 899   if (id4 == NULL || id5 == NULL)
 900     return false;
 901
 902   /* Fill in the contents of these sections.  */
 903   if (import_name_type == IMPORT_ORDINAL)
 904     {
 905       if (ordinal == 0)
 906         /* XXX - treat as IMPORT_NAME ??? */
 907         abort ();
 908
 909       * (unsigned int *) id4->contents = ordinal | 0x80000000;
 910       * (unsigned int *) id5->contents = ordinal | 0x80000000;
 911     }
 912   else
 913     {
 914       char * symbol;
 915
 916       /* Create .idata$6 - the Hint Name Table.  */
 917       id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
 918       if (id6 == NULL)
 919         return false;
 920
 921       /* If necessary, trim the import symbol name.  */
 922       symbol = symbol_name;
 923
 924       if (import_name_type != IMPORT_NAME)
 925         /* Skip any prefix in symbol_name.  */
 926         while (*symbol == '@' || * symbol == '?' || * symbol == '_')
 927           ++ symbol;
 928
 929       if (import_name_type == IMPORT_NAME_UNDECORATE)
 930         {
 931           /* Truncate at the first '@'  */
 932           while (* symbol != 0 && * symbol != '@')
 933             symbol ++;
 934
 935           * symbol = 0;
 936         }
 937
 938       id6->contents[0] = ordinal & 0xff;
 939       id6->contents[1] = ordinal >> 8;
 940
 941       strcpy (id6->contents + 2, symbol);
 942     }
 943
 944   if (import_name_type != IMPORT_ORDINAL)
 945     {
 946       pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
 947       pe_ILF_save_relocs (& vars, id4);
 948
 949       pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
 950       pe_ILF_save_relocs (& vars, id5);
 951     }
 952
 953   /* Create extra sections depending upon the type of import we are dealing with.  */
 954   switch (import_type)
 955     {
 956       int i;
 957
 958     case IMPORT_CODE:
 959       /* Create a .text section.
 960          First we need to look up its contents in the jump table.  */
 961       for (i = NUM_ENTRIES (jtab); i--;)
 962         {
 963           if (jtab[i].size == 0)
 964             continue;
 965           if (jtab[i].magic == magic)
 966             break;
 967         }
 968       /* If we did not find a matching entry something is wrong.  */
 969       if (i < 0)
 970         abort ();
 971
 972       /* Create the .text section.  */
 973       text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
 974       if (text == NULL)
 975         return false;
 976
 977       /* Copy in the jump code.  */
 978       memcpy (text->contents, jtab[i].data, jtab[i].size);
 979
 980       /* Create an import symbol.  */
 981       pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
 982       imp_sym   = vars.sym_ptr_ptr - 1;
 983       imp_index = vars.sym_index - 1;
 984
 985       /* Create a reloc for the data in the text section.  */
 986 #ifdef MIPS_ARCH_MAGIC_WINCE
 987       if (magic == MIPS_ARCH_MAGIC_WINCE)
 988         {
 989           pe_ILF_make_a_symbol_reloc (& vars, 0, BFD_RELOC_HI16_S,
 990                                       (struct symbol_cache_entry **) imp_sym, imp_index);
 991           pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_LO16, text);
 992           pe_ILF_make_a_symbol_reloc (& vars, 4, BFD_RELOC_LO16,
 993                                       (struct symbol_cache_entry **) imp_sym, imp_index);
 994         }
 995       else
 996 #endif
 997         pe_ILF_make_a_symbol_reloc (& vars, jtab[i].offset, BFD_RELOC_32,
 998                                     (asymbol **) imp_sym, imp_index);
 999
1000       pe_ILF_save_relocs (& vars, text);
1001       break;
1002
1003     case IMPORT_DATA:
1004       break;
1005
1006     default:
1007       /* XXX code not yet written.  */
1008       abort ();
1009     }
1010
1011   /* Initialise the bfd.  */
1012   memset (& internal_f, 0, sizeof (internal_f));
1013
1014   internal_f.f_magic  = magic;
1015   internal_f.f_symptr = 0;
1016   internal_f.f_nsyms  = 0;
1017   internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
1018
1019   if (   ! bfd_set_start_address (abfd, 0)
1020       || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
1021     return false;
1022
1023   if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL)
1024     return false;
1025
1026   coff_data (abfd)->pe = 1;
1027 #ifdef THUMBPEMAGIC
1028   if (vars.magic == THUMBPEMAGIC)
1029     /* Stop some linker warnings about thumb code not supporting interworking.  */
1030     coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
1031 #endif
1032
1033   /* Switch from file contents to memory contents.  */
1034   bfd_cache_close (abfd);
1035
1036   abfd->iostream = (PTR) vars.bim;
1037   abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
1038   abfd->where = 0;
1039   obj_sym_filepos (abfd) = 0;
1040
1041   /* Now create a symbol describing the imported value.  */
1042   switch (import_type)
1043     {
1044       bfd_byte * ptr;
1045
1046     case IMPORT_CODE:
1047       pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
1048                             BSF_NOT_AT_END | BSF_FUNCTION);
1049
1050       /* Create an import symbol for the DLL, without the
1051        .dll suffix.  */
1052       ptr = strrchr (source_dll, '.');
1053       if (ptr)
1054         * ptr = 0;
1055       pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
1056       if (ptr)
1057         * ptr = '.';
1058       break;
1059
1060     case IMPORT_DATA:
1061       /* Nothing to do here.  */
1062       break;
1063
1064     default:
1065       /* XXX code not yet written.  */
1066       abort ();
1067     }
1068
1069   /* Point the bfd at the symbol table.  */
1070   obj_symbols (abfd) = vars.sym_cache;
1071   bfd_get_symcount (abfd) = vars.sym_index;
1072
1073   obj_raw_syments (abfd) = vars.native_syms;
1074   obj_raw_syment_count (abfd) = vars.sym_index;
1075
1076   obj_coff_external_syms (abfd) = (PTR) vars.esym_table;
1077   obj_coff_keep_syms (abfd) = true;
1078
1079   obj_convert (abfd) = vars.sym_table;
1080   obj_conv_table_size (abfd) = vars.sym_index;
1081
1082   obj_coff_strings (abfd) = vars.string_table;
1083   obj_coff_keep_strings (abfd) = true;
1084
1085   abfd->flags |= HAS_SYMS;
1086
1087   return true;
1088 }
1089
1090 /* We have detected a Image Library Format archive element.
1091    Decode the element and return the appropriate target.  */
1092 static const bfd_target *
1093 pe_ILF_object_p (bfd * abfd)
1094 {
1095   bfd_byte        buffer[16];
1096   bfd_byte *      ptr;
1097   bfd_byte *      symbol_name;
1098   bfd_byte *      source_dll;
1099   unsigned int    machine;
1100   unsigned long   size;
1101   unsigned int    ordinal;
1102   unsigned int    types;
1103   unsigned short  magic;
1104
1105   /* Upon entry the first four buyes of the ILF header have
1106       already been read.  Now read the rest of the header.  */
1107   if (bfd_read (buffer, 1, 16, abfd) != 16)
1108     return NULL;
1109
1110   ptr = buffer;
1111
1112   /*  We do not bother to check the version number.
1113       version = bfd_h_get_16 (abfd, ptr);  */
1114   ptr += 2;
1115
1116   machine = bfd_h_get_16 (abfd, ptr);
1117   ptr += 2;
1118
1119   /* Check that the machine type is recognised.  */
1120   magic = 0;
1121
1122   switch (machine)
1123     {
1124     case IMAGE_FILE_MACHINE_UNKNOWN:
1125     case IMAGE_FILE_MACHINE_ALPHA:
1126     case IMAGE_FILE_MACHINE_ALPHA64:
1127     case IMAGE_FILE_MACHINE_IA64:
1128       break;
1129
1130     case IMAGE_FILE_MACHINE_I386:
1131 #ifdef I386MAGIC
1132       magic = I386MAGIC;
1133 #endif
1134       break;
1135
1136     case IMAGE_FILE_MACHINE_M68K:
1137 #ifdef MC68AGIC
1138       magic = MC68MAGIC;
1139 #endif
1140       break;
1141
1142     case IMAGE_FILE_MACHINE_R3000:
1143     case IMAGE_FILE_MACHINE_R4000:
1144     case IMAGE_FILE_MACHINE_R10000:
1145
1146     case IMAGE_FILE_MACHINE_MIPS16:
1147     case IMAGE_FILE_MACHINE_MIPSFPU:
1148     case IMAGE_FILE_MACHINE_MIPSFPU16:
1149 #ifdef MIPS_ARCH_MAGIC_WINCE
1150       magic = MIPS_ARCH_MAGIC_WINCE;
1151 #endif
1152       break;
1153
1154     case IMAGE_FILE_MACHINE_SH3:
1155     case IMAGE_FILE_MACHINE_SH4:
1156 #ifdef SH_ARCH_MAGIC_WINCE
1157       magic = SH_ARCH_MAGIC_WINCE;
1158 #endif
1159       break;
1160
1161     case IMAGE_FILE_MACHINE_ARM:
1162 #ifdef ARMPEMAGIC
1163       magic = ARMPEMAGIC;
1164 #endif
1165       break;
1166
1167     case IMAGE_FILE_MACHINE_THUMB:
1168 #ifdef THUMBPEMAGIC
1169       {
1170         extern const bfd_target TARGET_LITTLE_SYM;
1171
1172         if (abfd->xvec == & TARGET_LITTLE_SYM)
1173           magic = THUMBPEMAGIC;
1174       }
1175 #endif
1176       break;
1177
1178     case IMAGE_FILE_MACHINE_POWERPC:
1179       /* We no longer support PowerPC.  */
1180     default:
1181       _bfd_error_handler
1182         (
1183 _("%s: Unrecognised machine type (0x%x) in Import Library Format archive"),
1184          bfd_get_filename (abfd), machine);
1185       bfd_set_error (bfd_error_malformed_archive);
1186
1187       return NULL;
1188       break;
1189     }
1190
1191   if (magic == 0)
1192     {
1193       _bfd_error_handler
1194         (
1195 _("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"),
1196          bfd_get_filename (abfd), machine);
1197       bfd_set_error (bfd_error_wrong_format);
1198
1199       return NULL;
1200     }
1201
1202   /* We do not bother to check the date.
1203      date = bfd_h_get_32 (abfd, ptr);  */
1204   ptr += 4;
1205
1206   size = bfd_h_get_32 (abfd, ptr);
1207   ptr += 4;
1208
1209   if (size == 0)
1210     {
1211       _bfd_error_handler
1212         (_("%s: size field is zero in Import Library Format header"),
1213          bfd_get_filename (abfd));
1214       bfd_set_error (bfd_error_malformed_archive);
1215
1216       return NULL;
1217     }
1218
1219   ordinal = bfd_h_get_16 (abfd, ptr);
1220   ptr += 2;
1221
1222   types = bfd_h_get_16 (abfd, ptr);
1223   /* ptr += 2; */
1224
1225   /* Now read in the two strings that follow.  */
1226   ptr = bfd_alloc (abfd, size);
1227   if (ptr == NULL)
1228     return NULL;
1229
1230   if (bfd_read (ptr, 1, size, abfd) != size)
1231     return NULL;
1232
1233   symbol_name = ptr;
1234   source_dll  = ptr + strlen (ptr) + 1;
1235
1236   /* Verify that the strings are null terminated.  */
1237   if (ptr[size - 1] != 0 || ((unsigned long) (source_dll - ptr) >= size))
1238     {
1239       _bfd_error_handler
1240         (_("%s: string not null terminated in ILF object file."),
1241          bfd_get_filename (abfd));
1242       bfd_set_error (bfd_error_malformed_archive);
1243
1244       return NULL;
1245     }
1246
1247   /* Now construct the bfd.  */
1248   if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
1249                             source_dll, ordinal, types))
1250     return NULL;
1251
1252   return abfd->xvec;
1253 }
1254
1255 static const bfd_target *
1256 pe_bfd_object_p (bfd * abfd)
1257 {
1258   /* We need to handle a PE image correctly.  In PE images created by
1259      the GNU linker, the offset to the COFF header is always the size.
1260      However, this is not the case in images generated by other PE
1261      linkers.  The PE format stores a four byte offset to the PE
1262      signature just before the COFF header at location 0x3c of the file.
1263      We pick up that offset, verify that the PE signature is there, and
1264      then set ourselves up to read in the COFF header.  */
1265   bfd_byte buffer[4];
1266   file_ptr offset;
1267   unsigned long signature;
1268
1269   /* Detect if this a Microsoft Import Library Format element.  */
1270   if (bfd_seek (abfd, 0x00, SEEK_SET) != 0
1271       || bfd_read (buffer, 1, 4, abfd) != 4)
1272     {
1273       if (bfd_get_error () != bfd_error_system_call)
1274         bfd_set_error (bfd_error_wrong_format);
1275       return NULL;
1276     }
1277
1278   signature = bfd_h_get_32 (abfd, buffer);
1279
1280   if (signature == 0xffff0000)
1281     return pe_ILF_object_p (abfd);
1282
1283   if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
1284       || bfd_read (buffer, 1, 4, abfd) != 4)
1285     {
1286       if (bfd_get_error () != bfd_error_system_call)
1287         bfd_set_error (bfd_error_wrong_format);
1288       return NULL;
1289     }
1290
1291   offset = bfd_h_get_32 (abfd, buffer);
1292
1293   if (bfd_seek (abfd, offset, SEEK_SET) != 0
1294       || bfd_read (buffer, 1, 4, abfd) != 4)
1295     {
1296       if (bfd_get_error () != bfd_error_system_call)
1297         bfd_set_error (bfd_error_wrong_format);
1298       return NULL;
1299     }
1300
1301   signature = bfd_h_get_32 (abfd, buffer);
1302
1303   if (signature != 0x4550)
1304     {
1305       bfd_set_error (bfd_error_wrong_format);
1306       return NULL;
1307     }
1308
1309   /* Here is the hack.  coff_object_p wants to read filhsz bytes to
1310      pick up the COFF header.  We adjust so that that will work.  20
1311      is the size of the i386 COFF filehdr.  */
1312   if (bfd_seek (abfd,
1313                 (bfd_tell (abfd)
1314                  - bfd_coff_filhsz (abfd)
1315                  + 20),
1316                 SEEK_SET)
1317       != 0)
1318     {
1319       if (bfd_get_error () != bfd_error_system_call)
1320         bfd_set_error (bfd_error_wrong_format);
1321       return NULL;
1322     }
1323
1324   return coff_object_p (abfd);
1325 }
1326
1327 #define coff_object_p pe_bfd_object_p
1328 #endif /* COFF_IMAGE_WITH_PE */