bfd/peicode.h

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