Automatic date update in version.in
[external/binutils.git] / bfd / peicode.h
1 /* Support for the generic parts of PE/PEI, for BFD.
2    Copyright (C) 1995-2019 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       /* xgettext:c-format */
775       _bfd_error_handler (_("%pB: unhandled import type; %x"),
776                           abfd, import_type);
777       return FALSE;
778
779     default:
780       /* xgettext:c-format */
781       _bfd_error_handler (_("%pB: unrecognized import type; %x"),
782                           abfd, import_type);
783       return FALSE;
784     }
785
786   switch (import_name_type)
787     {
788     case IMPORT_ORDINAL:
789     case IMPORT_NAME:
790     case IMPORT_NAME_NOPREFIX:
791     case IMPORT_NAME_UNDECORATE:
792       break;
793
794     default:
795       /* xgettext:c-format */
796       _bfd_error_handler (_("%pB: unrecognized import name type; %x"),
797                           abfd, import_name_type);
798       return FALSE;
799     }
800
801   /* Initialise local variables.
802
803      Note these are kept in a structure rather than being
804      declared as statics since bfd frowns on global variables.
805
806      We are going to construct the contents of the BFD in memory,
807      so allocate all the space that we will need right now.  */
808   vars.bim
809     = (struct bfd_in_memory *) bfd_malloc ((bfd_size_type) sizeof (*vars.bim));
810   if (vars.bim == NULL)
811     return FALSE;
812
813   ptr = (bfd_byte *) bfd_zmalloc ((bfd_size_type) ILF_DATA_SIZE);
814   vars.bim->buffer = ptr;
815   vars.bim->size   = ILF_DATA_SIZE;
816   if (ptr == NULL)
817     goto error_return;
818
819   /* Initialise the pointers to regions of the memory and the
820      other contents of the pe_ILF_vars structure as well.  */
821   vars.sym_cache = (coff_symbol_type *) ptr;
822   vars.sym_ptr   = (coff_symbol_type *) ptr;
823   vars.sym_index = 0;
824   ptr += SIZEOF_ILF_SYMS;
825
826   vars.sym_table = (unsigned int *) ptr;
827   vars.table_ptr = (unsigned int *) ptr;
828   ptr += SIZEOF_ILF_SYM_TABLE;
829
830   vars.native_syms = (combined_entry_type *) ptr;
831   vars.native_ptr  = (combined_entry_type *) ptr;
832   ptr += SIZEOF_ILF_NATIVE_SYMS;
833
834   vars.sym_ptr_table = (coff_symbol_type **) ptr;
835   vars.sym_ptr_ptr   = (coff_symbol_type **) ptr;
836   ptr += SIZEOF_ILF_SYM_PTR_TABLE;
837
838   vars.esym_table = (SYMENT *) ptr;
839   vars.esym_ptr   = (SYMENT *) ptr;
840   ptr += SIZEOF_ILF_EXT_SYMS;
841
842   vars.reltab   = (arelent *) ptr;
843   vars.relcount = 0;
844   ptr += SIZEOF_ILF_RELOCS;
845
846   vars.int_reltab  = (struct internal_reloc *) ptr;
847   ptr += SIZEOF_ILF_INT_RELOCS;
848
849   vars.string_table = (char *) ptr;
850   vars.string_ptr   = (char *) ptr + STRING_SIZE_SIZE;
851   ptr += SIZEOF_ILF_STRINGS;
852   vars.end_string_ptr = (char *) ptr;
853
854   /* The remaining space in bim->buffer is used
855      by the pe_ILF_make_a_section() function.  */
856 # if (GCC_VERSION >= 3000)
857   /* PR 18758: Make sure that the data area is sufficiently aligned for
858      pointers on the host.  __alignof__ is a gcc extension, hence the test
859      above.  For other compilers we will have to assume that the alignment is
860      unimportant, or else extra code can be added here and in
861      pe_ILF_make_a_section.
862
863      Note - we cannot test 'ptr' directly as it is illegal to perform binary
864      arithmetic on pointers, but we know that the strings section is the only
865      one that might end on an unaligned boundary.  */
866   {
867     unsigned int alignment = __alignof__ (char *);
868
869     if (SIZEOF_ILF_STRINGS & (alignment - 1))
870       ptr += alignment - (SIZEOF_ILF_STRINGS & (alignment - 1));
871   }
872 #endif
873
874   vars.data = ptr;
875   vars.abfd = abfd;
876   vars.sec_index = 0;
877   vars.magic = magic;
878
879   /* Create the initial .idata$<n> sections:
880      [.idata$2:  Import Directory Table -- not needed]
881      .idata$4:  Import Lookup Table
882      .idata$5:  Import Address Table
883
884      Note we do not create a .idata$3 section as this is
885      created for us by the linker script.  */
886   id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0);
887   id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0);
888   if (id4 == NULL || id5 == NULL)
889     goto error_return;
890
891   /* Fill in the contents of these sections.  */
892   if (import_name_type == IMPORT_ORDINAL)
893     {
894       if (ordinal == 0)
895         /* See PR 20907 for a reproducer.  */
896         goto error_return;
897
898 #ifdef COFF_WITH_pex64
899       ((unsigned int *) id4->contents)[0] = ordinal;
900       ((unsigned int *) id4->contents)[1] = 0x80000000;
901       ((unsigned int *) id5->contents)[0] = ordinal;
902       ((unsigned int *) id5->contents)[1] = 0x80000000;
903 #else
904       * (unsigned int *) id4->contents = ordinal | 0x80000000;
905       * (unsigned int *) id5->contents = ordinal | 0x80000000;
906 #endif
907     }
908   else
909     {
910       char * symbol;
911       unsigned int len;
912
913       /* Create .idata$6 - the Hint Name Table.  */
914       id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
915       if (id6 == NULL)
916         goto error_return;
917
918       /* If necessary, trim the import symbol name.  */
919       symbol = symbol_name;
920
921       /* As used by MS compiler, '_', '@', and '?' are alternative
922          forms of USER_LABEL_PREFIX, with '?' for c++ mangled names,
923          '@' used for fastcall (in C),  '_' everywhere else.  Only one
924          of these is used for a symbol.  We strip this leading char for
925          IMPORT_NAME_NOPREFIX and IMPORT_NAME_UNDECORATE as per the
926          PE COFF 6.0 spec (section 8.3, Import Name Type).  */
927
928       if (import_name_type != IMPORT_NAME)
929         {
930           char c = symbol[0];
931
932           /* Check that we don't remove for targets with empty
933              USER_LABEL_PREFIX the leading underscore.  */
934           if ((c == '_' && abfd->xvec->symbol_leading_char != 0)
935               || c == '@' || c == '?')
936             symbol++;
937         }
938
939       len = strlen (symbol);
940       if (import_name_type == IMPORT_NAME_UNDECORATE)
941         {
942           /* Truncate at the first '@'.  */
943           char *at = strchr (symbol, '@');
944
945           if (at != NULL)
946             len = at - symbol;
947         }
948
949       id6->contents[0] = ordinal & 0xff;
950       id6->contents[1] = ordinal >> 8;
951
952       memcpy ((char *) id6->contents + 2, symbol, len);
953       id6->contents[len + 2] = '\0';
954     }
955
956   if (import_name_type != IMPORT_ORDINAL)
957     {
958       pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6);
959       pe_ILF_save_relocs (&vars, id4);
960
961       pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6);
962       pe_ILF_save_relocs (&vars, id5);
963     }
964
965   /* Create an import symbol.  */
966   pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
967   imp_sym   = vars.sym_ptr_ptr - 1;
968   imp_index = vars.sym_index - 1;
969
970   /* Create extra sections depending upon the type of import we are dealing with.  */
971   switch (import_type)
972     {
973       int i;
974
975     case IMPORT_CODE:
976       /* CODE functions are special, in that they get a trampoline that
977          jumps to the main import symbol.  Create a .text section to hold it.
978          First we need to look up its contents in the jump table.  */
979       for (i = NUM_ENTRIES (jtab); i--;)
980         {
981           if (jtab[i].size == 0)
982             continue;
983           if (jtab[i].magic == magic)
984             break;
985         }
986       /* If we did not find a matching entry something is wrong.  */
987       if (i < 0)
988         abort ();
989
990       /* Create the .text section.  */
991       text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
992       if (text == NULL)
993         goto error_return;
994
995       /* Copy in the jump code.  */
996       memcpy (text->contents, jtab[i].data, jtab[i].size);
997
998       /* Create a reloc for the data in the text section.  */
999 #ifdef MIPS_ARCH_MAGIC_WINCE
1000       if (magic == MIPS_ARCH_MAGIC_WINCE)
1001         {
1002           pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S,
1003                                       (struct bfd_symbol **) imp_sym,
1004                                       imp_index);
1005           pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text);
1006           pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16,
1007                                       (struct bfd_symbol **) imp_sym,
1008                                       imp_index);
1009         }
1010       else
1011 #endif
1012 #ifdef AMD64MAGIC
1013       if (magic == AMD64MAGIC)
1014         {
1015           pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
1016                                       BFD_RELOC_32_PCREL, (asymbol **) imp_sym,
1017                                       imp_index);
1018         }
1019       else
1020 #endif
1021         pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
1022                                     BFD_RELOC_32, (asymbol **) imp_sym,
1023                                     imp_index);
1024
1025       pe_ILF_save_relocs (& vars, text);
1026       break;
1027
1028     case IMPORT_DATA:
1029       break;
1030
1031     default:
1032       /* XXX code not yet written.  */
1033       abort ();
1034     }
1035
1036   /* Initialise the bfd.  */
1037   memset (& internal_f, 0, sizeof (internal_f));
1038
1039   internal_f.f_magic  = magic;
1040   internal_f.f_symptr = 0;
1041   internal_f.f_nsyms  = 0;
1042   internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
1043
1044   if (   ! bfd_set_start_address (abfd, (bfd_vma) 0)
1045       || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
1046     goto error_return;
1047
1048   if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL)
1049     goto error_return;
1050
1051   coff_data (abfd)->pe = 1;
1052 #ifdef THUMBPEMAGIC
1053   if (vars.magic == THUMBPEMAGIC)
1054     /* Stop some linker warnings about thumb code not supporting interworking.  */
1055     coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
1056 #endif
1057
1058   /* Switch from file contents to memory contents.  */
1059   bfd_cache_close (abfd);
1060
1061   abfd->iostream = (void *) vars.bim;
1062   abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
1063   abfd->iovec = &_bfd_memory_iovec;
1064   abfd->where = 0;
1065   abfd->origin = 0;
1066   obj_sym_filepos (abfd) = 0;
1067
1068   /* Now create a symbol describing the imported value.  */
1069   switch (import_type)
1070     {
1071     case IMPORT_CODE:
1072       pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
1073                             BSF_NOT_AT_END | BSF_FUNCTION);
1074
1075       break;
1076
1077     case IMPORT_DATA:
1078       /* Nothing to do here.  */
1079       break;
1080
1081     default:
1082       /* XXX code not yet written.  */
1083       abort ();
1084     }
1085
1086   /* Create an import symbol for the DLL, without the .dll suffix.  */
1087   ptr = (bfd_byte *) strrchr (source_dll, '.');
1088   if (ptr)
1089     * ptr = 0;
1090   pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
1091   if (ptr)
1092     * ptr = '.';
1093
1094   /* Point the bfd at the symbol table.  */
1095   obj_symbols (abfd) = vars.sym_cache;
1096   bfd_get_symcount (abfd) = vars.sym_index;
1097
1098   obj_raw_syments (abfd) = vars.native_syms;
1099   obj_raw_syment_count (abfd) = vars.sym_index;
1100
1101   obj_coff_external_syms (abfd) = (void *) vars.esym_table;
1102   obj_coff_keep_syms (abfd) = TRUE;
1103
1104   obj_convert (abfd) = vars.sym_table;
1105   obj_conv_table_size (abfd) = vars.sym_index;
1106
1107   obj_coff_strings (abfd) = vars.string_table;
1108   obj_coff_keep_strings (abfd) = TRUE;
1109
1110   abfd->flags |= HAS_SYMS;
1111
1112   return TRUE;
1113
1114  error_return:
1115   if (vars.bim->buffer != NULL)
1116     free (vars.bim->buffer);
1117   free (vars.bim);
1118   return FALSE;
1119 }
1120
1121 /* We have detected a Image Library Format archive element.
1122    Decode the element and return the appropriate target.  */
1123
1124 static const bfd_target *
1125 pe_ILF_object_p (bfd * abfd)
1126 {
1127   bfd_byte        buffer[14];
1128   bfd_byte *      ptr;
1129   char *          symbol_name;
1130   char *          source_dll;
1131   unsigned int    machine;
1132   bfd_size_type   size;
1133   unsigned int    ordinal;
1134   unsigned int    types;
1135   unsigned int    magic;
1136
1137   /* Upon entry the first six bytes of the ILF header have
1138       already been read.  Now read the rest of the header.  */
1139   if (bfd_bread (buffer, (bfd_size_type) 14, abfd) != 14)
1140     return NULL;
1141
1142   ptr = buffer;
1143
1144   machine = H_GET_16 (abfd, ptr);
1145   ptr += 2;
1146
1147   /* Check that the machine type is recognised.  */
1148   magic = 0;
1149
1150   switch (machine)
1151     {
1152     case IMAGE_FILE_MACHINE_UNKNOWN:
1153     case IMAGE_FILE_MACHINE_ALPHA:
1154     case IMAGE_FILE_MACHINE_ALPHA64:
1155     case IMAGE_FILE_MACHINE_IA64:
1156       break;
1157
1158     case IMAGE_FILE_MACHINE_I386:
1159 #ifdef I386MAGIC
1160       magic = I386MAGIC;
1161 #endif
1162       break;
1163
1164     case IMAGE_FILE_MACHINE_AMD64:
1165 #ifdef AMD64MAGIC
1166       magic = AMD64MAGIC;
1167 #endif
1168       break;
1169
1170     case IMAGE_FILE_MACHINE_R3000:
1171     case IMAGE_FILE_MACHINE_R4000:
1172     case IMAGE_FILE_MACHINE_R10000:
1173
1174     case IMAGE_FILE_MACHINE_MIPS16:
1175     case IMAGE_FILE_MACHINE_MIPSFPU:
1176     case IMAGE_FILE_MACHINE_MIPSFPU16:
1177 #ifdef MIPS_ARCH_MAGIC_WINCE
1178       magic = MIPS_ARCH_MAGIC_WINCE;
1179 #endif
1180       break;
1181
1182     case IMAGE_FILE_MACHINE_SH3:
1183     case IMAGE_FILE_MACHINE_SH4:
1184 #ifdef SH_ARCH_MAGIC_WINCE
1185       magic = SH_ARCH_MAGIC_WINCE;
1186 #endif
1187       break;
1188
1189     case IMAGE_FILE_MACHINE_ARM:
1190 #ifdef ARMPEMAGIC
1191       magic = ARMPEMAGIC;
1192 #endif
1193       break;
1194
1195     case IMAGE_FILE_MACHINE_THUMB:
1196 #ifdef THUMBPEMAGIC
1197       {
1198         extern const bfd_target TARGET_LITTLE_SYM;
1199
1200         if (abfd->xvec == & TARGET_LITTLE_SYM)
1201           magic = THUMBPEMAGIC;
1202       }
1203 #endif
1204       break;
1205
1206     case IMAGE_FILE_MACHINE_POWERPC:
1207       /* We no longer support PowerPC.  */
1208     default:
1209       _bfd_error_handler
1210         /* xgettext:c-format */
1211         (_("%pB: unrecognised machine type (0x%x)"
1212            " in Import Library Format archive"),
1213          abfd, machine);
1214       bfd_set_error (bfd_error_malformed_archive);
1215
1216       return NULL;
1217       break;
1218     }
1219
1220   if (magic == 0)
1221     {
1222       _bfd_error_handler
1223         /* xgettext:c-format */
1224         (_("%pB: recognised but unhandled machine type (0x%x)"
1225            " in Import Library Format archive"),
1226          abfd, machine);
1227       bfd_set_error (bfd_error_wrong_format);
1228
1229       return NULL;
1230     }
1231
1232   /* We do not bother to check the date.
1233      date = H_GET_32 (abfd, ptr);  */
1234   ptr += 4;
1235
1236   size = H_GET_32 (abfd, ptr);
1237   ptr += 4;
1238
1239   if (size == 0)
1240     {
1241       _bfd_error_handler
1242         (_("%pB: size field is zero in Import Library Format header"), abfd);
1243       bfd_set_error (bfd_error_malformed_archive);
1244
1245       return NULL;
1246     }
1247
1248   ordinal = H_GET_16 (abfd, ptr);
1249   ptr += 2;
1250
1251   types = H_GET_16 (abfd, ptr);
1252   /* ptr += 2; */
1253
1254   /* Now read in the two strings that follow.  */
1255   ptr = (bfd_byte *) bfd_alloc (abfd, size);
1256   if (ptr == NULL)
1257     return NULL;
1258
1259   if (bfd_bread (ptr, size, abfd) != size)
1260     {
1261       bfd_release (abfd, ptr);
1262       return NULL;
1263     }
1264
1265   symbol_name = (char *) ptr;
1266   /* See PR 20905 for an example of where the strnlen is necessary.  */
1267   source_dll  = symbol_name + strnlen (symbol_name, size - 1) + 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         (_("%pB: 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   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
1301   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
1302
1303   if (size == 0)
1304     return;
1305
1306   addr += extra->ImageBase;
1307
1308   /* Search for the section containing the DebugDirectory.  */
1309   for (section = abfd->sections; section != NULL; section = section->next)
1310     {
1311       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
1312         break;
1313     }
1314
1315   if (section == NULL)
1316     return;
1317
1318   if (!(section->flags & SEC_HAS_CONTENTS))
1319     return;
1320
1321   dataoff = addr - section->vma;
1322
1323   /* PR 20605 and 22373: Make sure that the data is really there.
1324      Note - since we are dealing with unsigned quantities we have
1325      to be careful to check for potential overflows.  */
1326   if (dataoff >= section->size
1327       || size > section->size - dataoff)
1328     {
1329       _bfd_error_handler
1330         (_("%pB: error: debug data ends beyond end of debug directory"),
1331          abfd);
1332       return;
1333     }
1334
1335   /* Read the whole section. */
1336   if (!bfd_malloc_and_get_section (abfd, section, &data))
1337     {
1338       if (data != NULL)
1339         free (data);
1340       return;
1341     }
1342
1343   /* Search for a CodeView entry in the DebugDirectory */
1344   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
1345     {
1346       struct external_IMAGE_DEBUG_DIRECTORY *ext
1347         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
1348       struct internal_IMAGE_DEBUG_DIRECTORY idd;
1349
1350       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
1351
1352       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
1353         {
1354           char buffer[256 + 1];
1355           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
1356
1357           /*
1358             The debug entry doesn't have to have to be in a section, in which
1359             case AddressOfRawData is 0, so always use PointerToRawData.
1360           */
1361           if (_bfd_XXi_slurp_codeview_record (abfd,
1362                                               (file_ptr) idd.PointerToRawData,
1363                                               idd.SizeOfData, cvinfo))
1364             {
1365               struct bfd_build_id* build_id = bfd_alloc (abfd,
1366                          sizeof (struct bfd_build_id) + cvinfo->SignatureLength);
1367               if (build_id)
1368                 {
1369                   build_id->size = cvinfo->SignatureLength;
1370                   memcpy(build_id->data,  cvinfo->Signature,
1371                          cvinfo->SignatureLength);
1372                   abfd->build_id = build_id;
1373                 }
1374             }
1375           break;
1376         }
1377     }
1378 }
1379
1380 static const bfd_target *
1381 pe_bfd_object_p (bfd * abfd)
1382 {
1383   bfd_byte buffer[6];
1384   struct external_DOS_hdr dos_hdr;
1385   struct external_PEI_IMAGE_hdr image_hdr;
1386   struct internal_filehdr internal_f;
1387   struct internal_aouthdr internal_a;
1388   file_ptr opt_hdr_size;
1389   file_ptr offset;
1390   const bfd_target *result;
1391
1392   /* Detect if this a Microsoft Import Library Format element.  */
1393   /* First read the beginning of the header.  */
1394   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1395       || bfd_bread (buffer, (bfd_size_type) 6, abfd) != 6)
1396     {
1397       if (bfd_get_error () != bfd_error_system_call)
1398         bfd_set_error (bfd_error_wrong_format);
1399       return NULL;
1400     }
1401
1402   /* Then check the magic and the version (only 0 is supported).  */
1403   if (H_GET_32 (abfd, buffer) == 0xffff0000
1404       && H_GET_16 (abfd, buffer + 4) == 0)
1405     return pe_ILF_object_p (abfd);
1406
1407   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1408       || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd)
1409          != sizeof (dos_hdr))
1410     {
1411       if (bfd_get_error () != bfd_error_system_call)
1412         bfd_set_error (bfd_error_wrong_format);
1413       return NULL;
1414     }
1415
1416   /* There are really two magic numbers involved; the magic number
1417      that says this is a NT executable (PEI) and the magic number that
1418      determines the architecture.  The former is IMAGE_DOS_SIGNATURE, stored in
1419      the e_magic field.  The latter is stored in the f_magic field.
1420      If the NT magic number isn't valid, the architecture magic number
1421      could be mimicked by some other field (specifically, the number
1422      of relocs in section 3).  Since this routine can only be called
1423      correctly for a PEI file, check the e_magic number here, and, if
1424      it doesn't match, clobber the f_magic number so that we don't get
1425      a false match.  */
1426   if (H_GET_16 (abfd, dos_hdr.e_magic) != IMAGE_DOS_SIGNATURE)
1427     {
1428       bfd_set_error (bfd_error_wrong_format);
1429       return NULL;
1430     }
1431
1432   offset = H_GET_32 (abfd, dos_hdr.e_lfanew);
1433   if (bfd_seek (abfd, offset, SEEK_SET) != 0
1434       || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd)
1435           != sizeof (image_hdr)))
1436     {
1437       if (bfd_get_error () != bfd_error_system_call)
1438         bfd_set_error (bfd_error_wrong_format);
1439       return NULL;
1440     }
1441
1442   if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550)
1443     {
1444       bfd_set_error (bfd_error_wrong_format);
1445       return NULL;
1446     }
1447
1448   /* Swap file header, so that we get the location for calling
1449      real_object_p.  */
1450   bfd_coff_swap_filehdr_in (abfd, &image_hdr, &internal_f);
1451
1452   if (! bfd_coff_bad_format_hook (abfd, &internal_f)
1453       || internal_f.f_opthdr > bfd_coff_aoutsz (abfd))
1454     {
1455       bfd_set_error (bfd_error_wrong_format);
1456       return NULL;
1457     }
1458
1459   /* Read the optional header, which has variable size.  */
1460   opt_hdr_size = internal_f.f_opthdr;
1461
1462   if (opt_hdr_size != 0)
1463     {
1464       bfd_size_type amt = opt_hdr_size;
1465       void * opthdr;
1466
1467       /* PR 17521 file: 230-131433-0.004.  */
1468       if (amt < sizeof (PEAOUTHDR))
1469         amt = sizeof (PEAOUTHDR);
1470
1471       opthdr = bfd_zalloc (abfd, amt);
1472       if (opthdr == NULL)
1473         return NULL;
1474       if (bfd_bread (opthdr, opt_hdr_size, abfd)
1475           != (bfd_size_type) opt_hdr_size)
1476         return NULL;
1477
1478       bfd_set_error (bfd_error_no_error);
1479       bfd_coff_swap_aouthdr_in (abfd, opthdr, & internal_a);
1480       if (bfd_get_error () != bfd_error_no_error)
1481         return NULL;
1482     }
1483
1484
1485   result = coff_real_object_p (abfd, internal_f.f_nscns, &internal_f,
1486                                (opt_hdr_size != 0
1487                                 ? &internal_a
1488                                 : (struct internal_aouthdr *) NULL));
1489
1490
1491   if (result)
1492     {
1493       /* Now the whole header has been processed, see if there is a build-id */
1494       pe_bfd_read_buildid(abfd);
1495     }
1496
1497   return result;
1498 }
1499
1500 #define coff_object_p pe_bfd_object_p
1501 #endif /* COFF_IMAGE_WITH_PE */