bfd/peicode.h

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