bfd/peicode.h

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