bfd/peicode.h

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