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