contrib/binutils-2.25/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   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         pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
 977                                     BFD_RELOC_32, (asymbol **) imp_sym,
 978                                     imp_index);
 979
 980       pe_ILF_save_relocs (& vars, text);
 981       break;
 982
 983     case IMPORT_DATA:
 984       break;
 985
 986     default:
 987       /* XXX code not yet written.  */
 988       abort ();
 989     }
 990
 991   /* Initialise the bfd.  */
 992   memset (& internal_f, 0, sizeof (internal_f));
 993
 994   internal_f.f_magic  = magic;
 995   internal_f.f_symptr = 0;
 996   internal_f.f_nsyms  = 0;
 997   internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
 998
 999   if (   ! bfd_set_start_address (abfd, (bfd_vma) 0)
1000       || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
1001     goto error_return;
1002
1003   if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL)
1004     goto error_return;
1005
1006   coff_data (abfd)->pe = 1;
1007 #ifdef THUMBPEMAGIC
1008   if (vars.magic == THUMBPEMAGIC)
1009     /* Stop some linker warnings about thumb code not supporting interworking.  */
1010     coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
1011 #endif
1012
1013   /* Switch from file contents to memory contents.  */
1014   bfd_cache_close (abfd);
1015
1016   abfd->iostream = (void *) vars.bim;
1017   abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
1018   abfd->iovec = &_bfd_memory_iovec;
1019   abfd->where = 0;
1020   abfd->origin = 0;
1021   obj_sym_filepos (abfd) = 0;
1022
1023   /* Now create a symbol describing the imported value.  */
1024   switch (import_type)
1025     {
1026     case IMPORT_CODE:
1027       pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
1028                             BSF_NOT_AT_END | BSF_FUNCTION);
1029
1030       /* Create an import symbol for the DLL, without the
1031        .dll suffix.  */
1032       ptr = (bfd_byte *) strrchr (source_dll, '.');
1033       if (ptr)
1034         * ptr = 0;
1035       pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
1036       if (ptr)
1037         * ptr = '.';
1038       break;
1039
1040     case IMPORT_DATA:
1041       /* Nothing to do here.  */
1042       break;
1043
1044     default:
1045       /* XXX code not yet written.  */
1046       abort ();
1047     }
1048
1049   /* Point the bfd at the symbol table.  */
1050   obj_symbols (abfd) = vars.sym_cache;
1051   bfd_get_symcount (abfd) = vars.sym_index;
1052
1053   obj_raw_syments (abfd) = vars.native_syms;
1054   obj_raw_syment_count (abfd) = vars.sym_index;
1055
1056   obj_coff_external_syms (abfd) = (void *) vars.esym_table;
1057   obj_coff_keep_syms (abfd) = TRUE;
1058
1059   obj_convert (abfd) = vars.sym_table;
1060   obj_conv_table_size (abfd) = vars.sym_index;
1061
1062   obj_coff_strings (abfd) = vars.string_table;
1063   obj_coff_keep_strings (abfd) = TRUE;
1064
1065   abfd->flags |= HAS_SYMS;
1066
1067   return TRUE;
1068
1069  error_return:
1070   if (vars.bim->buffer != NULL)
1071     free (vars.bim->buffer);
1072   free (vars.bim);
1073   return FALSE;
1074 }
1075
1076 /* We have detected a Image Library Format archive element.
1077    Decode the element and return the appropriate target.  */
1078
1079 static const bfd_target *
1080 pe_ILF_object_p (bfd * abfd)
1081 {
1082   bfd_byte        buffer[14];
1083   bfd_byte *      ptr;
1084   char *          symbol_name;
1085   char *          source_dll;
1086   unsigned int    machine;
1087   bfd_size_type   size;
1088   unsigned int    ordinal;
1089   unsigned int    types;
1090   unsigned int    magic;
1091
1092   /* Upon entry the first six bytes of the ILF header have
1093       already been read.  Now read the rest of the header.  */
1094   if (bfd_bread (buffer, (bfd_size_type) 14, abfd) != 14)
1095     return NULL;
1096
1097   ptr = buffer;
1098
1099   machine = H_GET_16 (abfd, ptr);
1100   ptr += 2;
1101
1102   /* Check that the machine type is recognised.  */
1103   magic = 0;
1104
1105   switch (machine)
1106     {
1107     case IMAGE_FILE_MACHINE_UNKNOWN:
1108     case IMAGE_FILE_MACHINE_ALPHA:
1109     case IMAGE_FILE_MACHINE_ALPHA64:
1110     case IMAGE_FILE_MACHINE_IA64:
1111       break;
1112
1113     case IMAGE_FILE_MACHINE_I386:
1114 #ifdef I386MAGIC
1115       magic = I386MAGIC;
1116 #endif
1117       break;
1118
1119     case IMAGE_FILE_MACHINE_AMD64:
1120 #ifdef AMD64MAGIC
1121       magic = AMD64MAGIC;
1122 #endif
1123       break;
1124
1125     case IMAGE_FILE_MACHINE_M68K:
1126 #ifdef MC68AGIC
1127       magic = MC68MAGIC;
1128 #endif
1129       break;
1130
1131     case IMAGE_FILE_MACHINE_R3000:
1132     case IMAGE_FILE_MACHINE_R4000:
1133     case IMAGE_FILE_MACHINE_R10000:
1134
1135     case IMAGE_FILE_MACHINE_MIPS16:
1136     case IMAGE_FILE_MACHINE_MIPSFPU:
1137     case IMAGE_FILE_MACHINE_MIPSFPU16:
1138 #ifdef MIPS_ARCH_MAGIC_WINCE
1139       magic = MIPS_ARCH_MAGIC_WINCE;
1140 #endif
1141       break;
1142
1143     case IMAGE_FILE_MACHINE_SH3:
1144     case IMAGE_FILE_MACHINE_SH4:
1145 #ifdef SH_ARCH_MAGIC_WINCE
1146       magic = SH_ARCH_MAGIC_WINCE;
1147 #endif
1148       break;
1149
1150     case IMAGE_FILE_MACHINE_ARM:
1151 #ifdef ARMPEMAGIC
1152       magic = ARMPEMAGIC;
1153 #endif
1154       break;
1155
1156     case IMAGE_FILE_MACHINE_THUMB:
1157 #ifdef THUMBPEMAGIC
1158       {
1159         extern const bfd_target TARGET_LITTLE_SYM;
1160
1161         if (abfd->xvec == & TARGET_LITTLE_SYM)
1162           magic = THUMBPEMAGIC;
1163       }
1164 #endif
1165       break;
1166
1167     case IMAGE_FILE_MACHINE_POWERPC:
1168       /* We no longer support PowerPC.  */
1169     default:
1170       _bfd_error_handler
1171         (_("%B: Unrecognised machine type (0x%x)"
1172            " in Import Library Format archive"),
1173          abfd, machine);
1174       bfd_set_error (bfd_error_malformed_archive);
1175
1176       return NULL;
1177       break;
1178     }
1179
1180   if (magic == 0)
1181     {
1182       _bfd_error_handler
1183         (_("%B: Recognised but unhandled machine type (0x%x)"
1184            " in Import Library Format archive"),
1185          abfd, machine);
1186       bfd_set_error (bfd_error_wrong_format);
1187
1188       return NULL;
1189     }
1190
1191   /* We do not bother to check the date.
1192      date = H_GET_32 (abfd, ptr);  */
1193   ptr += 4;
1194
1195   size = H_GET_32 (abfd, ptr);
1196   ptr += 4;
1197
1198   if (size == 0)
1199     {
1200       _bfd_error_handler
1201         (_("%B: size field is zero in Import Library Format header"), abfd);
1202       bfd_set_error (bfd_error_malformed_archive);
1203
1204       return NULL;
1205     }
1206
1207   ordinal = H_GET_16 (abfd, ptr);
1208   ptr += 2;
1209
1210   types = H_GET_16 (abfd, ptr);
1211   /* ptr += 2; */
1212
1213   /* Now read in the two strings that follow.  */
1214   ptr = (bfd_byte *) bfd_alloc (abfd, size);
1215   if (ptr == NULL)
1216     return NULL;
1217
1218   if (bfd_bread (ptr, size, abfd) != size)
1219     {
1220       bfd_release (abfd, ptr);
1221       return NULL;
1222     }
1223
1224   symbol_name = (char *) ptr;
1225   source_dll  = symbol_name + strlen (symbol_name) + 1;
1226
1227   /* Verify that the strings are null terminated.  */
1228   if (ptr[size - 1] != 0
1229       || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size)
1230     {
1231       _bfd_error_handler
1232         (_("%B: string not null terminated in ILF object file."), abfd);
1233       bfd_set_error (bfd_error_malformed_archive);
1234       bfd_release (abfd, ptr);
1235       return NULL;
1236     }
1237
1238   /* Now construct the bfd.  */
1239   if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
1240                             source_dll, ordinal, types))
1241     {
1242       bfd_release (abfd, ptr);
1243       return NULL;
1244     }
1245
1246   return abfd->xvec;
1247 }
1248
1249 static const bfd_target *
1250 pe_bfd_object_p (bfd * abfd)
1251 {
1252   bfd_byte buffer[6];
1253   struct external_PEI_DOS_hdr dos_hdr;
1254   struct external_PEI_IMAGE_hdr image_hdr;
1255   struct internal_filehdr internal_f;
1256   struct internal_aouthdr internal_a;
1257   file_ptr opt_hdr_size;
1258   file_ptr offset;
1259
1260   /* Detect if this a Microsoft Import Library Format element.  */
1261   /* First read the beginning of the header.  */
1262   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1263       || bfd_bread (buffer, (bfd_size_type) 6, abfd) != 6)
1264     {
1265       if (bfd_get_error () != bfd_error_system_call)
1266         bfd_set_error (bfd_error_wrong_format);
1267       return NULL;
1268     }
1269
1270   /* Then check the magic and the version (only 0 is supported).  */
1271   if (H_GET_32 (abfd, buffer) == 0xffff0000
1272       && H_GET_16 (abfd, buffer + 4) == 0)
1273     return pe_ILF_object_p (abfd);
1274
1275   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1276       || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd)
1277          != sizeof (dos_hdr))
1278     {
1279       if (bfd_get_error () != bfd_error_system_call)
1280         bfd_set_error (bfd_error_wrong_format);
1281       return NULL;
1282     }
1283
1284   /* There are really two magic numbers involved; the magic number
1285      that says this is a NT executable (PEI) and the magic number that
1286      determines the architecture.  The former is DOSMAGIC, stored in
1287      the e_magic field.  The latter is stored in the f_magic field.
1288      If the NT magic number isn't valid, the architecture magic number
1289      could be mimicked by some other field (specifically, the number
1290      of relocs in section 3).  Since this routine can only be called
1291      correctly for a PEI file, check the e_magic number here, and, if
1292      it doesn't match, clobber the f_magic number so that we don't get
1293      a false match.  */
1294   if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC)
1295     {
1296       bfd_set_error (bfd_error_wrong_format);
1297       return NULL;
1298     }
1299
1300   offset = H_GET_32 (abfd, dos_hdr.e_lfanew);
1301   if (bfd_seek (abfd, offset, SEEK_SET) != 0
1302       || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd)
1303           != sizeof (image_hdr)))
1304     {
1305       if (bfd_get_error () != bfd_error_system_call)
1306         bfd_set_error (bfd_error_wrong_format);
1307       return NULL;
1308     }
1309
1310   if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550)
1311     {
1312       bfd_set_error (bfd_error_wrong_format);
1313       return NULL;
1314     }
1315
1316   /* Swap file header, so that we get the location for calling
1317      real_object_p.  */
1318   bfd_coff_swap_filehdr_in (abfd, &image_hdr, &internal_f);
1319
1320   if (! bfd_coff_bad_format_hook (abfd, &internal_f)
1321       || internal_f.f_opthdr > bfd_coff_aoutsz (abfd))
1322     {
1323       bfd_set_error (bfd_error_wrong_format);
1324       return NULL;
1325     }
1326
1327   /* Read the optional header, which has variable size.  */
1328   opt_hdr_size = internal_f.f_opthdr;
1329
1330   if (opt_hdr_size != 0)
1331     {
1332       bfd_size_type amt = opt_hdr_size;
1333       void * opthdr;
1334
1335       /* PR 17521 file: 230-131433-0.004.  */
1336       if (amt < sizeof (PEAOUTHDR))
1337         amt = sizeof (PEAOUTHDR);
1338
1339       opthdr = bfd_zalloc (abfd, amt);
1340       if (opthdr == NULL)
1341         return NULL;
1342       if (bfd_bread (opthdr, opt_hdr_size, abfd)
1343           != (bfd_size_type) opt_hdr_size)
1344         return NULL;
1345
1346       bfd_set_error (bfd_error_no_error);
1347       bfd_coff_swap_aouthdr_in (abfd, opthdr, & internal_a);
1348       if (bfd_get_error () != bfd_error_no_error)
1349         return NULL;
1350     }
1351
1352   return coff_real_object_p (abfd, internal_f.f_nscns, &internal_f,
1353                             (opt_hdr_size != 0
1354                              ? &internal_a
1355                              : (struct internal_aouthdr *) NULL));
1356 }
1357
1358 #define coff_object_p pe_bfd_object_p
1359 #endif /* COFF_IMAGE_WITH_PE */