bfd/peicode.h

   1 /* Support for the generic parts of PE/PEI, for BFD.
   2    Copyright (C) 1995-2014 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
 572   sym->symbol.the_bfd = vars->abfd;
 573   sym->symbol.name    = vars->string_ptr;
 574   sym->symbol.flags   = BSF_EXPORT | BSF_GLOBAL | extra_flags;
 575   sym->symbol.section = section;
 576   sym->native         = ent;
 577
 578   * vars->table_ptr = vars->sym_index;
 579   * vars->sym_ptr_ptr = sym;
 580
 581   /* Adjust pointers for the next symbol.  */
 582   vars->sym_index ++;
 583   vars->sym_ptr ++;
 584   vars->sym_ptr_ptr ++;
 585   vars->table_ptr ++;
 586   vars->native_ptr ++;
 587   vars->esym_ptr ++;
 588   vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1;
 589
 590   BFD_ASSERT (vars->string_ptr < vars->end_string_ptr);
 591 }
 592
 593 /* Create a section.  */
 594
 595 static asection_ptr
 596 pe_ILF_make_a_section (pe_ILF_vars * vars,
 597                        const char *  name,
 598                        unsigned int  size,
 599                        flagword      extra_flags)
 600 {
 601   asection_ptr sec;
 602   flagword     flags;
 603
 604   sec = bfd_make_section_old_way (vars->abfd, name);
 605   if (sec == NULL)
 606     return NULL;
 607
 608   flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY;
 609
 610   bfd_set_section_flags (vars->abfd, sec, flags | extra_flags);
 611
 612   (void) bfd_set_section_alignment (vars->abfd, sec, 2);
 613
 614   /* Check that we will not run out of space.  */
 615   BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size);
 616
 617   /* Set the section size and contents.  The actual
 618      contents are filled in by our parent.  */
 619   bfd_set_section_size (vars->abfd, sec, (bfd_size_type) size);
 620   sec->contents = vars->data;
 621   sec->target_index = vars->sec_index ++;
 622
 623   /* Advance data pointer in the vars structure.  */
 624   vars->data += size;
 625
 626   /* Skip the padding byte if it was not needed.
 627      The logic here is that if the string length is odd,
 628      then the entire string length, including the null byte,
 629      is even and so the extra, padding byte, is not needed.  */
 630   if (size & 1)
 631     vars->data --;
 632
 633   /* Create a coff_section_tdata structure for our use.  */
 634   sec->used_by_bfd = (struct coff_section_tdata *) vars->data;
 635   vars->data += sizeof (struct coff_section_tdata);
 636
 637   BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size);
 638
 639   /* Create a symbol to refer to this section.  */
 640   pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL);
 641
 642   /* Cache the index to the symbol in the coff_section_data structure.  */
 643   coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1;
 644
 645   return sec;
 646 }
 647
 648 /* This structure contains the code that goes into the .text section
 649    in order to perform a jump into the DLL lookup table.  The entries
 650    in the table are index by the magic number used to represent the
 651    machine type in the PE file.  The contents of the data[] arrays in
 652    these entries are stolen from the jtab[] arrays in ld/pe-dll.c.
 653    The SIZE field says how many bytes in the DATA array are actually
 654    used.  The OFFSET field says where in the data array the address
 655    of the .idata$5 section should be placed.  */
 656 #define MAX_TEXT_SECTION_SIZE 32
 657
 658 typedef struct
 659 {
 660   unsigned short magic;
 661   unsigned char  data[MAX_TEXT_SECTION_SIZE];
 662   unsigned int   size;
 663   unsigned int   offset;
 664 }
 665 jump_table;
 666
 667 static jump_table jtab[] =
 668 {
 669 #ifdef I386MAGIC
 670   { I386MAGIC,
 671     { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
 672     8, 2
 673   },
 674 #endif
 675
 676 #ifdef AMD64MAGIC
 677   { AMD64MAGIC,
 678     { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
 679     8, 2
 680   },
 681 #endif
 682
 683 #ifdef  MC68MAGIC
 684   { MC68MAGIC,
 685     { /* XXX fill me in */ },
 686     0, 0
 687   },
 688 #endif
 689
 690 #ifdef  MIPS_ARCH_MAGIC_WINCE
 691   { MIPS_ARCH_MAGIC_WINCE,
 692     { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
 693       0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 },
 694     16, 0
 695   },
 696 #endif
 697
 698 #ifdef  SH_ARCH_MAGIC_WINCE
 699   { SH_ARCH_MAGIC_WINCE,
 700     { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40,
 701       0x09, 0x00, 0x00, 0x00, 0x00, 0x00 },
 702     12, 8
 703   },
 704 #endif
 705
 706 #ifdef  ARMPEMAGIC
 707   { ARMPEMAGIC,
 708     { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0,
 709       0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00},
 710     12, 8
 711   },
 712 #endif
 713
 714 #ifdef  THUMBPEMAGIC
 715   { THUMBPEMAGIC,
 716     { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46,
 717       0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 },
 718     16, 12
 719   },
 720 #endif
 721   { 0, { 0 }, 0, 0 }
 722 };
 723
 724 #ifndef NUM_ENTRIES
 725 #define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0])
 726 #endif
 727
 728 /* Build a full BFD from the information supplied in a ILF object.  */
 729
 730 static bfd_boolean
 731 pe_ILF_build_a_bfd (bfd *           abfd,
 732                     unsigned int    magic,
 733                     char *          symbol_name,
 734                     char *          source_dll,
 735                     unsigned int    ordinal,
 736                     unsigned int    types)
 737 {
 738   bfd_byte *               ptr;
 739   pe_ILF_vars              vars;
 740   struct internal_filehdr  internal_f;
 741   unsigned int             import_type;
 742   unsigned int             import_name_type;
 743   asection_ptr             id4, id5, id6 = NULL, text = NULL;
 744   coff_symbol_type **      imp_sym;
 745   unsigned int             imp_index;
 746
 747   /* Decode and verify the types field of the ILF structure.  */
 748   import_type = types & 0x3;
 749   import_name_type = (types & 0x1c) >> 2;
 750
 751   switch (import_type)
 752     {
 753     case IMPORT_CODE:
 754     case IMPORT_DATA:
 755       break;
 756
 757     case IMPORT_CONST:
 758       /* XXX code yet to be written.  */
 759       _bfd_error_handler (_("%B: Unhandled import type; %x"),
 760                           abfd, import_type);
 761       return FALSE;
 762
 763     default:
 764       _bfd_error_handler (_("%B: Unrecognised import type; %x"),
 765                           abfd, import_type);
 766       return FALSE;
 767     }
 768
 769   switch (import_name_type)
 770     {
 771     case IMPORT_ORDINAL:
 772     case IMPORT_NAME:
 773     case IMPORT_NAME_NOPREFIX:
 774     case IMPORT_NAME_UNDECORATE:
 775       break;
 776
 777     default:
 778       _bfd_error_handler (_("%B: Unrecognised import name type; %x"),
 779                           abfd, import_name_type);
 780       return FALSE;
 781     }
 782
 783   /* Initialise local variables.
 784
 785      Note these are kept in a structure rather than being
 786      declared as statics since bfd frowns on global variables.
 787
 788      We are going to construct the contents of the BFD in memory,
 789      so allocate all the space that we will need right now.  */
 790   vars.bim
 791     = (struct bfd_in_memory *) bfd_malloc ((bfd_size_type) sizeof (*vars.bim));
 792   if (vars.bim == NULL)
 793     return FALSE;
 794
 795   ptr = (bfd_byte *) bfd_zmalloc ((bfd_size_type) ILF_DATA_SIZE);
 796   vars.bim->buffer = ptr;
 797   vars.bim->size   = ILF_DATA_SIZE;
 798   if (ptr == NULL)
 799     goto error_return;
 800
 801   /* Initialise the pointers to regions of the memory and the
 802      other contents of the pe_ILF_vars structure as well.  */
 803   vars.sym_cache = (coff_symbol_type *) ptr;
 804   vars.sym_ptr   = (coff_symbol_type *) ptr;
 805   vars.sym_index = 0;
 806   ptr += SIZEOF_ILF_SYMS;
 807
 808   vars.sym_table = (unsigned int *) ptr;
 809   vars.table_ptr = (unsigned int *) ptr;
 810   ptr += SIZEOF_ILF_SYM_TABLE;
 811
 812   vars.native_syms = (combined_entry_type *) ptr;
 813   vars.native_ptr  = (combined_entry_type *) ptr;
 814   ptr += SIZEOF_ILF_NATIVE_SYMS;
 815
 816   vars.sym_ptr_table = (coff_symbol_type **) ptr;
 817   vars.sym_ptr_ptr   = (coff_symbol_type **) ptr;
 818   ptr += SIZEOF_ILF_SYM_PTR_TABLE;
 819
 820   vars.esym_table = (SYMENT *) ptr;
 821   vars.esym_ptr   = (SYMENT *) ptr;
 822   ptr += SIZEOF_ILF_EXT_SYMS;
 823
 824   vars.reltab   = (arelent *) ptr;
 825   vars.relcount = 0;
 826   ptr += SIZEOF_ILF_RELOCS;
 827
 828   vars.int_reltab  = (struct internal_reloc *) ptr;
 829   ptr += SIZEOF_ILF_INT_RELOCS;
 830
 831   vars.string_table = (char *) ptr;
 832   vars.string_ptr   = (char *) ptr + STRING_SIZE_SIZE;
 833   ptr += SIZEOF_ILF_STRINGS;
 834   vars.end_string_ptr = (char *) ptr;
 835
 836   /* The remaining space in bim->buffer is used
 837      by the pe_ILF_make_a_section() function.  */
 838   vars.data = ptr;
 839   vars.abfd = abfd;
 840   vars.sec_index = 0;
 841   vars.magic = magic;
 842
 843   /* Create the initial .idata$<n> sections:
 844      [.idata$2:  Import Directory Table -- not needed]
 845      .idata$4:  Import Lookup Table
 846      .idata$5:  Import Address Table
 847
 848      Note we do not create a .idata$3 section as this is
 849      created for us by the linker script.  */
 850   id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0);
 851   id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0);
 852   if (id4 == NULL || id5 == NULL)
 853     goto error_return;
 854
 855   /* Fill in the contents of these sections.  */
 856   if (import_name_type == IMPORT_ORDINAL)
 857     {
 858       if (ordinal == 0)
 859         /* XXX - treat as IMPORT_NAME ??? */
 860         abort ();
 861
 862 #ifdef COFF_WITH_pex64
 863       ((unsigned int *) id4->contents)[0] = ordinal;
 864       ((unsigned int *) id4->contents)[1] = 0x80000000;
 865       ((unsigned int *) id5->contents)[0] = ordinal;
 866       ((unsigned int *) id5->contents)[1] = 0x80000000;
 867 #else
 868       * (unsigned int *) id4->contents = ordinal | 0x80000000;
 869       * (unsigned int *) id5->contents = ordinal | 0x80000000;
 870 #endif
 871     }
 872   else
 873     {
 874       char * symbol;
 875       unsigned int len;
 876
 877       /* Create .idata$6 - the Hint Name Table.  */
 878       id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
 879       if (id6 == NULL)
 880         goto error_return;
 881
 882       /* If necessary, trim the import symbol name.  */
 883       symbol = symbol_name;
 884
 885       /* As used by MS compiler, '_', '@', and '?' are alternative
 886          forms of USER_LABEL_PREFIX, with '?' for c++ mangled names,
 887          '@' used for fastcall (in C),  '_' everywhere else.  Only one
 888          of these is used for a symbol.  We strip this leading char for
 889          IMPORT_NAME_NOPREFIX and IMPORT_NAME_UNDECORATE as per the
 890          PE COFF 6.0 spec (section 8.3, Import Name Type).  */
 891
 892       if (import_name_type != IMPORT_NAME)
 893         {
 894           char c = symbol[0];
 895
 896           /* Check that we don't remove for targets with empty
 897              USER_LABEL_PREFIX the leading underscore.  */
 898           if ((c == '_' && abfd->xvec->symbol_leading_char != 0)
 899               || c == '@' || c == '?')
 900             symbol++;
 901         }
 902
 903       len = strlen (symbol);
 904       if (import_name_type == IMPORT_NAME_UNDECORATE)
 905         {
 906           /* Truncate at the first '@'.  */
 907           char *at = strchr (symbol, '@');
 908
 909           if (at != NULL)
 910             len = at - symbol;
 911         }
 912
 913       id6->contents[0] = ordinal & 0xff;
 914       id6->contents[1] = ordinal >> 8;
 915
 916       memcpy ((char *) id6->contents + 2, symbol, len);
 917       id6->contents[len + 2] = '\0';
 918     }
 919
 920   if (import_name_type != IMPORT_ORDINAL)
 921     {
 922       pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6);
 923       pe_ILF_save_relocs (&vars, id4);
 924
 925       pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6);
 926       pe_ILF_save_relocs (&vars, id5);
 927     }
 928
 929   /* Create extra sections depending upon the type of import we are dealing with.  */
 930   switch (import_type)
 931     {
 932       int i;
 933
 934     case IMPORT_CODE:
 935       /* Create a .text section.
 936          First we need to look up its contents in the jump table.  */
 937       for (i = NUM_ENTRIES (jtab); i--;)
 938         {
 939           if (jtab[i].size == 0)
 940             continue;
 941           if (jtab[i].magic == magic)
 942             break;
 943         }
 944       /* If we did not find a matching entry something is wrong.  */
 945       if (i < 0)
 946         abort ();
 947
 948       /* Create the .text section.  */
 949       text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
 950       if (text == NULL)
 951         goto error_return;
 952
 953       /* Copy in the jump code.  */
 954       memcpy (text->contents, jtab[i].data, jtab[i].size);
 955
 956       /* Create an import symbol.  */
 957       pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
 958       imp_sym   = vars.sym_ptr_ptr - 1;
 959       imp_index = vars.sym_index - 1;
 960
 961       /* Create a reloc for the data in the text section.  */
 962 #ifdef MIPS_ARCH_MAGIC_WINCE
 963       if (magic == MIPS_ARCH_MAGIC_WINCE)
 964         {
 965           pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S,
 966                                       (struct bfd_symbol **) imp_sym,
 967                                       imp_index);
 968           pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text);
 969           pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16,
 970                                       (struct bfd_symbol **) imp_sym,
 971                                       imp_index);
 972         }
 973       else
 974 #endif
 975         pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
 976                                     BFD_RELOC_32, (asymbol **) imp_sym,
 977                                     imp_index);
 978
 979       pe_ILF_save_relocs (& vars, text);
 980       break;
 981
 982     case IMPORT_DATA:
 983       break;
 984
 985     default:
 986       /* XXX code not yet written.  */
 987       abort ();
 988     }
 989
 990   /* Initialise the bfd.  */
 991   memset (& internal_f, 0, sizeof (internal_f));
 992
 993   internal_f.f_magic  = magic;
 994   internal_f.f_symptr = 0;
 995   internal_f.f_nsyms  = 0;
 996   internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
 997
 998   if (   ! bfd_set_start_address (abfd, (bfd_vma) 0)
 999       || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
1000     goto error_return;
1001
1002   if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL)
1003     goto error_return;
1004
1005   coff_data (abfd)->pe = 1;
1006 #ifdef THUMBPEMAGIC
1007   if (vars.magic == THUMBPEMAGIC)
1008     /* Stop some linker warnings about thumb code not supporting interworking.  */
1009     coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
1010 #endif
1011
1012   /* Switch from file contents to memory contents.  */
1013   bfd_cache_close (abfd);
1014
1015   abfd->iostream = (void *) vars.bim;
1016   abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
1017   abfd->iovec = &_bfd_memory_iovec;
1018   abfd->where = 0;
1019   abfd->origin = 0;
1020   obj_sym_filepos (abfd) = 0;
1021
1022   /* Now create a symbol describing the imported value.  */
1023   switch (import_type)
1024     {
1025     case IMPORT_CODE:
1026       pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
1027                             BSF_NOT_AT_END | BSF_FUNCTION);
1028
1029       /* Create an import symbol for the DLL, without the
1030        .dll suffix.  */
1031       ptr = (bfd_byte *) strrchr (source_dll, '.');
1032       if (ptr)
1033         * ptr = 0;
1034       pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
1035       if (ptr)
1036         * ptr = '.';
1037       break;
1038
1039     case IMPORT_DATA:
1040       /* Nothing to do here.  */
1041       break;
1042
1043     default:
1044       /* XXX code not yet written.  */
1045       abort ();
1046     }
1047
1048   /* Point the bfd at the symbol table.  */
1049   obj_symbols (abfd) = vars.sym_cache;
1050   bfd_get_symcount (abfd) = vars.sym_index;
1051
1052   obj_raw_syments (abfd) = vars.native_syms;
1053   obj_raw_syment_count (abfd) = vars.sym_index;
1054
1055   obj_coff_external_syms (abfd) = (void *) vars.esym_table;
1056   obj_coff_keep_syms (abfd) = TRUE;
1057
1058   obj_convert (abfd) = vars.sym_table;
1059   obj_conv_table_size (abfd) = vars.sym_index;
1060
1061   obj_coff_strings (abfd) = vars.string_table;
1062   obj_coff_keep_strings (abfd) = TRUE;
1063
1064   abfd->flags |= HAS_SYMS;
1065
1066   return TRUE;
1067
1068  error_return:
1069   if (vars.bim->buffer != NULL)
1070     free (vars.bim->buffer);
1071   free (vars.bim);
1072   return FALSE;
1073 }
1074
1075 /* We have detected a Image Library Format archive element.
1076    Decode the element and return the appropriate target.  */
1077
1078 static const bfd_target *
1079 pe_ILF_object_p (bfd * abfd)
1080 {
1081   bfd_byte        buffer[14];
1082   bfd_byte *      ptr;
1083   char *          symbol_name;
1084   char *          source_dll;
1085   unsigned int    machine;
1086   bfd_size_type   size;
1087   unsigned int    ordinal;
1088   unsigned int    types;
1089   unsigned int    magic;
1090
1091   /* Upon entry the first six bytes of the ILF header have
1092       already been read.  Now read the rest of the header.  */
1093   if (bfd_bread (buffer, (bfd_size_type) 14, abfd) != 14)
1094     return NULL;
1095
1096   ptr = buffer;
1097
1098   machine = H_GET_16 (abfd, ptr);
1099   ptr += 2;
1100
1101   /* Check that the machine type is recognised.  */
1102   magic = 0;
1103
1104   switch (machine)
1105     {
1106     case IMAGE_FILE_MACHINE_UNKNOWN:
1107     case IMAGE_FILE_MACHINE_ALPHA:
1108     case IMAGE_FILE_MACHINE_ALPHA64:
1109     case IMAGE_FILE_MACHINE_IA64:
1110       break;
1111
1112     case IMAGE_FILE_MACHINE_I386:
1113 #ifdef I386MAGIC
1114       magic = I386MAGIC;
1115 #endif
1116       break;
1117
1118     case IMAGE_FILE_MACHINE_AMD64:
1119 #ifdef AMD64MAGIC
1120       magic = AMD64MAGIC;
1121 #endif
1122       break;
1123
1124     case IMAGE_FILE_MACHINE_M68K:
1125 #ifdef MC68AGIC
1126       magic = MC68MAGIC;
1127 #endif
1128       break;
1129
1130     case IMAGE_FILE_MACHINE_R3000:
1131     case IMAGE_FILE_MACHINE_R4000:
1132     case IMAGE_FILE_MACHINE_R10000:
1133
1134     case IMAGE_FILE_MACHINE_MIPS16:
1135     case IMAGE_FILE_MACHINE_MIPSFPU:
1136     case IMAGE_FILE_MACHINE_MIPSFPU16:
1137 #ifdef MIPS_ARCH_MAGIC_WINCE
1138       magic = MIPS_ARCH_MAGIC_WINCE;
1139 #endif
1140       break;
1141
1142     case IMAGE_FILE_MACHINE_SH3:
1143     case IMAGE_FILE_MACHINE_SH4:
1144 #ifdef SH_ARCH_MAGIC_WINCE
1145       magic = SH_ARCH_MAGIC_WINCE;
1146 #endif
1147       break;
1148
1149     case IMAGE_FILE_MACHINE_ARM:
1150 #ifdef ARMPEMAGIC
1151       magic = ARMPEMAGIC;
1152 #endif
1153       break;
1154
1155     case IMAGE_FILE_MACHINE_THUMB:
1156 #ifdef THUMBPEMAGIC
1157       {
1158         extern const bfd_target TARGET_LITTLE_SYM;
1159
1160         if (abfd->xvec == & TARGET_LITTLE_SYM)
1161           magic = THUMBPEMAGIC;
1162       }
1163 #endif
1164       break;
1165
1166     case IMAGE_FILE_MACHINE_POWERPC:
1167       /* We no longer support PowerPC.  */
1168     default:
1169       _bfd_error_handler
1170         (_("%B: Unrecognised machine type (0x%x)"
1171            " in Import Library Format archive"),
1172          abfd, machine);
1173       bfd_set_error (bfd_error_malformed_archive);
1174
1175       return NULL;
1176       break;
1177     }
1178
1179   if (magic == 0)
1180     {
1181       _bfd_error_handler
1182         (_("%B: Recognised but unhandled machine type (0x%x)"
1183            " in Import Library Format archive"),
1184          abfd, machine);
1185       bfd_set_error (bfd_error_wrong_format);
1186
1187       return NULL;
1188     }
1189
1190   /* We do not bother to check the date.
1191      date = H_GET_32 (abfd, ptr);  */
1192   ptr += 4;
1193
1194   size = H_GET_32 (abfd, ptr);
1195   ptr += 4;
1196
1197   if (size == 0)
1198     {
1199       _bfd_error_handler
1200         (_("%B: size field is zero in Import Library Format header"), abfd);
1201       bfd_set_error (bfd_error_malformed_archive);
1202
1203       return NULL;
1204     }
1205
1206   ordinal = H_GET_16 (abfd, ptr);
1207   ptr += 2;
1208
1209   types = H_GET_16 (abfd, ptr);
1210   /* ptr += 2; */
1211
1212   /* Now read in the two strings that follow.  */
1213   ptr = (bfd_byte *) bfd_alloc (abfd, size);
1214   if (ptr == NULL)
1215     return NULL;
1216
1217   if (bfd_bread (ptr, size, abfd) != size)
1218     {
1219       bfd_release (abfd, ptr);
1220       return NULL;
1221     }
1222
1223   symbol_name = (char *) ptr;
1224   source_dll  = symbol_name + strlen (symbol_name) + 1;
1225
1226   /* Verify that the strings are null terminated.  */
1227   if (ptr[size - 1] != 0
1228       || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size)
1229     {
1230       _bfd_error_handler
1231         (_("%B: string not null terminated in ILF object file."), abfd);
1232       bfd_set_error (bfd_error_malformed_archive);
1233       bfd_release (abfd, ptr);
1234       return NULL;
1235     }
1236
1237   /* Now construct the bfd.  */
1238   if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
1239                             source_dll, ordinal, types))
1240     {
1241       bfd_release (abfd, ptr);
1242       return NULL;
1243     }
1244
1245   return abfd->xvec;
1246 }
1247
1248 static const bfd_target *
1249 pe_bfd_object_p (bfd * abfd)
1250 {
1251   bfd_byte buffer[6];
1252   struct external_PEI_DOS_hdr dos_hdr;
1253   struct external_PEI_IMAGE_hdr image_hdr;
1254   struct internal_filehdr internal_f;
1255   struct internal_aouthdr internal_a;
1256   file_ptr opt_hdr_size;
1257   file_ptr offset;
1258
1259   /* Detect if this a Microsoft Import Library Format element.  */
1260   /* First read the beginning of the header.  */
1261   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1262       || bfd_bread (buffer, (bfd_size_type) 6, abfd) != 6)
1263     {
1264       if (bfd_get_error () != bfd_error_system_call)
1265         bfd_set_error (bfd_error_wrong_format);
1266       return NULL;
1267     }
1268
1269   /* Then check the magic and the version (only 0 is supported).  */
1270   if (H_GET_32 (abfd, buffer) == 0xffff0000
1271       && H_GET_16 (abfd, buffer + 4) == 0)
1272     return pe_ILF_object_p (abfd);
1273
1274   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1275       || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd)
1276          != sizeof (dos_hdr))
1277     {
1278       if (bfd_get_error () != bfd_error_system_call)
1279         bfd_set_error (bfd_error_wrong_format);
1280       return NULL;
1281     }
1282
1283   /* There are really two magic numbers involved; the magic number
1284      that says this is a NT executable (PEI) and the magic number that
1285      determines the architecture.  The former is DOSMAGIC, stored in
1286      the e_magic field.  The latter is stored in the f_magic field.
1287      If the NT magic number isn't valid, the architecture magic number
1288      could be mimicked by some other field (specifically, the number
1289      of relocs in section 3).  Since this routine can only be called
1290      correctly for a PEI file, check the e_magic number here, and, if
1291      it doesn't match, clobber the f_magic number so that we don't get
1292      a false match.  */
1293   if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC)
1294     {
1295       bfd_set_error (bfd_error_wrong_format);
1296       return NULL;
1297     }
1298
1299   offset = H_GET_32 (abfd, dos_hdr.e_lfanew);
1300   if (bfd_seek (abfd, offset, SEEK_SET) != 0
1301       || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd)
1302           != sizeof (image_hdr)))
1303     {
1304       if (bfd_get_error () != bfd_error_system_call)
1305         bfd_set_error (bfd_error_wrong_format);
1306       return NULL;
1307     }
1308
1309   if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550)
1310     {
1311       bfd_set_error (bfd_error_wrong_format);
1312       return NULL;
1313     }
1314
1315   /* Swap file header, so that we get the location for calling
1316      real_object_p.  */
1317   bfd_coff_swap_filehdr_in (abfd, &image_hdr, &internal_f);
1318
1319   if (! bfd_coff_bad_format_hook (abfd, &internal_f)
1320       || internal_f.f_opthdr > bfd_coff_aoutsz (abfd))
1321     {
1322       bfd_set_error (bfd_error_wrong_format);
1323       return NULL;
1324     }
1325
1326   /* Read the optional header, which has variable size.  */
1327   opt_hdr_size = internal_f.f_opthdr;
1328
1329   if (opt_hdr_size != 0)
1330     {
1331       bfd_size_type amt = opt_hdr_size;
1332       void * opthdr;
1333
1334       /* PR 17521 file: 230-131433-0.004.  */
1335       if (amt < sizeof (PEAOUTHDR))
1336         amt = sizeof (PEAOUTHDR);
1337
1338       opthdr = bfd_zalloc (abfd, amt);
1339       if (opthdr == NULL)
1340         return NULL;
1341       if (bfd_bread (opthdr, opt_hdr_size, abfd)
1342           != (bfd_size_type) opt_hdr_size)
1343         return NULL;
1344
1345       bfd_coff_swap_aouthdr_in (abfd, opthdr, & internal_a);
1346     }
1347
1348   return coff_real_object_p (abfd, internal_f.f_nscns, &internal_f,
1349                             (opt_hdr_size != 0
1350                              ? &internal_a
1351                              : (struct internal_aouthdr *) NULL));
1352 }
1353
1354 #define coff_object_p pe_bfd_object_p
1355 #endif /* COFF_IMAGE_WITH_PE */