More fixes for problems exposed by valgrind and the address sanitizer
[external/binutils.git] / bfd / peXXigen.c
1 /* Support for the generic parts of PE/PEI; the common executable parts.
2    Copyright (C) 1995-2014 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 <sac@cygnus.com>.
24
25    PE/PEI rearrangement (and code added): Donn Terry
26                                           Softway Systems, Inc.  */
27
28 /* Hey look, some documentation [and in a place you expect to find it]!
29
30    The main reference for the pei format is "Microsoft Portable Executable
31    and Common Object File Format Specification 4.1".  Get it if you need to
32    do some serious hacking on this code.
33
34    Another reference:
35    "Peering Inside the PE: A Tour of the Win32 Portable Executable
36    File Format", MSJ 1994, Volume 9.
37
38    The *sole* difference between the pe format and the pei format is that the
39    latter has an MSDOS 2.0 .exe header on the front that prints the message
40    "This app must be run under Windows." (or some such).
41    (FIXME: Whether that statement is *really* true or not is unknown.
42    Are there more subtle differences between pe and pei formats?
43    For now assume there aren't.  If you find one, then for God sakes
44    document it here!)
45
46    The Microsoft docs use the word "image" instead of "executable" because
47    the former can also refer to a DLL (shared library).  Confusion can arise
48    because the `i' in `pei' also refers to "image".  The `pe' format can
49    also create images (i.e. executables), it's just that to run on a win32
50    system you need to use the pei format.
51
52    FIXME: Please add more docs here so the next poor fool that has to hack
53    on this code has a chance of getting something accomplished without
54    wasting too much time.  */
55
56 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
57    depending on whether we're compiling for straight PE or PE+.  */
58 #define COFF_WITH_XX
59
60 #include "sysdep.h"
61 #include "bfd.h"
62 #include "libbfd.h"
63 #include "coff/internal.h"
64 #include "bfdver.h"
65 #ifdef HAVE_WCHAR_H
66 #include <wchar.h>
67 #endif
68
69 /* NOTE: it's strange to be including an architecture specific header
70    in what's supposed to be general (to PE/PEI) code.  However, that's
71    where the definitions are, and they don't vary per architecture
72    within PE/PEI, so we get them from there.  FIXME: The lack of
73    variance is an assumption which may prove to be incorrect if new
74    PE/PEI targets are created.  */
75 #if defined COFF_WITH_pex64
76 # include "coff/x86_64.h"
77 #elif defined COFF_WITH_pep
78 # include "coff/ia64.h"
79 #else
80 # include "coff/i386.h"
81 #endif
82
83 #include "coff/pe.h"
84 #include "libcoff.h"
85 #include "libpei.h"
86 #include "safe-ctype.h"
87
88 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
89 # undef AOUTSZ
90 # define AOUTSZ         PEPAOUTSZ
91 # define PEAOUTHDR      PEPAOUTHDR
92 #endif
93
94 #define HighBitSet(val)      ((val) & 0x80000000)
95 #define SetHighBit(val)      ((val) | 0x80000000)
96 #define WithoutHighBit(val)  ((val) & 0x7fffffff)
97
98 /* FIXME: This file has various tests of POWERPC_LE_PE.  Those tests
99    worked when the code was in peicode.h, but no longer work now that
100    the code is in peigen.c.  PowerPC NT is said to be dead.  If
101    anybody wants to revive the code, you will have to figure out how
102    to handle those issues.  */
103 \f
104 void
105 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
106 {
107   SYMENT *ext = (SYMENT *) ext1;
108   struct internal_syment *in = (struct internal_syment *) in1;
109
110   if (ext->e.e_name[0] == 0)
111     {
112       in->_n._n_n._n_zeroes = 0;
113       in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
114     }
115   else
116     memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
117
118   in->n_value = H_GET_32 (abfd, ext->e_value);
119   in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
120
121   if (sizeof (ext->e_type) == 2)
122     in->n_type = H_GET_16 (abfd, ext->e_type);
123   else
124     in->n_type = H_GET_32 (abfd, ext->e_type);
125
126   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
127   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
128
129 #ifndef STRICT_PE_FORMAT
130   /* This is for Gnu-created DLLs.  */
131
132   /* The section symbols for the .idata$ sections have class 0x68
133      (C_SECTION), which MS documentation indicates is a section
134      symbol.  Unfortunately, the value field in the symbol is simply a
135      copy of the .idata section's flags rather than something useful.
136      When these symbols are encountered, change the value to 0 so that
137      they will be handled somewhat correctly in the bfd code.  */
138   if (in->n_sclass == C_SECTION)
139     {
140       char namebuf[SYMNMLEN + 1];
141       const char *name = NULL;
142
143       in->n_value = 0x0;
144
145       /* Create synthetic empty sections as needed.  DJ */
146       if (in->n_scnum == 0)
147         {
148           asection *sec;
149
150           name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
151           if (name == NULL)
152             /* FIXME: Return error.  */
153             abort ();
154           sec = bfd_get_section_by_name (abfd, name);
155           if (sec != NULL)
156             in->n_scnum = sec->target_index;
157         }
158
159       if (in->n_scnum == 0)
160         {
161           int unused_section_number = 0;
162           asection *sec;
163           flagword flags;
164
165           for (sec = abfd->sections; sec; sec = sec->next)
166             if (unused_section_number <= sec->target_index)
167               unused_section_number = sec->target_index + 1;
168
169           if (name == namebuf)
170             {
171               name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
172               if (name == NULL)
173                 /* FIXME: Return error.  */
174                 abort ();
175               strcpy ((char *) name, namebuf);
176             }
177           flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
178           sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
179           if (sec == NULL)
180             /* FIXME: Return error.  */
181             abort ();
182
183           sec->vma = 0;
184           sec->lma = 0;
185           sec->size = 0;
186           sec->filepos = 0;
187           sec->rel_filepos = 0;
188           sec->reloc_count = 0;
189           sec->line_filepos = 0;
190           sec->lineno_count = 0;
191           sec->userdata = NULL;
192           sec->next = NULL;
193           sec->alignment_power = 2;
194
195           sec->target_index = unused_section_number;
196
197           in->n_scnum = unused_section_number;
198         }
199       in->n_sclass = C_STAT;
200     }
201 #endif
202
203 #ifdef coff_swap_sym_in_hook
204   /* This won't work in peigen.c, but since it's for PPC PE, it's not
205      worth fixing.  */
206   coff_swap_sym_in_hook (abfd, ext1, in1);
207 #endif
208 }
209
210 static bfd_boolean
211 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
212 {
213   bfd_vma abs_val = * (bfd_vma *) data;
214
215   return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
216 }
217
218 unsigned int
219 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
220 {
221   struct internal_syment *in = (struct internal_syment *) inp;
222   SYMENT *ext = (SYMENT *) extp;
223
224   if (in->_n._n_name[0] == 0)
225     {
226       H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
227       H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
228     }
229   else
230     memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
231
232   /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
233      symbol.  This is a problem on 64-bit targets where we can generate
234      absolute symbols with values >= 1^32.  We try to work around this
235      problem by finding a section whose base address is sufficient to
236      reduce the absolute value to < 1^32, and then transforming the
237      symbol into a section relative symbol.  This of course is a hack.  */
238   if (sizeof (in->n_value) > 4
239       /* The strange computation of the shift amount is here in order to
240          avoid a compile time warning about the comparison always being
241          false.  It does not matter if this test fails to work as expected
242          as the worst that can happen is that some absolute symbols are
243          needlessly converted into section relative symbols.  */
244       && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)
245       && in->n_scnum == -1)
246     {
247       asection * sec;
248
249       sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
250       if (sec)
251         {
252           in->n_value -= sec->vma;
253           in->n_scnum = sec->target_index;
254         }
255       /* else: FIXME: The value is outside the range of any section.  This
256          happens for __image_base__ and __ImageBase and maybe some other
257          symbols as well.  We should find a way to handle these values.  */
258     }
259
260   H_PUT_32 (abfd, in->n_value, ext->e_value);
261   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
262
263   if (sizeof (ext->e_type) == 2)
264     H_PUT_16 (abfd, in->n_type, ext->e_type);
265   else
266     H_PUT_32 (abfd, in->n_type, ext->e_type);
267
268   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
269   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
270
271   return SYMESZ;
272 }
273
274 void
275 _bfd_XXi_swap_aux_in (bfd *     abfd,
276                       void *    ext1,
277                       int       type,
278                       int       in_class,
279                       int       indx ATTRIBUTE_UNUSED,
280                       int       numaux ATTRIBUTE_UNUSED,
281                       void *    in1)
282 {
283   AUXENT *ext = (AUXENT *) ext1;
284   union internal_auxent *in = (union internal_auxent *) in1;
285
286   switch (in_class)
287     {
288     case C_FILE:
289       if (ext->x_file.x_fname[0] == 0)
290         {
291           in->x_file.x_n.x_zeroes = 0;
292           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
293         }
294       else
295         memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
296       return;
297
298     case C_STAT:
299     case C_LEAFSTAT:
300     case C_HIDDEN:
301       if (type == T_NULL)
302         {
303           in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
304           in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
305           in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
306           in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
307           in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
308           in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
309           return;
310         }
311       break;
312     }
313
314   in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
315   in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
316
317   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
318       || ISTAG (in_class))
319     {
320       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
321       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
322     }
323   else
324     {
325       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
326         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
327       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
328         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
329       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
330         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
331       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
332         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
333     }
334
335   if (ISFCN (type))
336     {
337       in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
338     }
339   else
340     {
341       in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
342       in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
343     }
344 }
345
346 unsigned int
347 _bfd_XXi_swap_aux_out (bfd *  abfd,
348                        void * inp,
349                        int    type,
350                        int    in_class,
351                        int    indx ATTRIBUTE_UNUSED,
352                        int    numaux ATTRIBUTE_UNUSED,
353                        void * extp)
354 {
355   union internal_auxent *in = (union internal_auxent *) inp;
356   AUXENT *ext = (AUXENT *) extp;
357
358   memset (ext, 0, AUXESZ);
359
360   switch (in_class)
361     {
362     case C_FILE:
363       if (in->x_file.x_fname[0] == 0)
364         {
365           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
366           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
367         }
368       else
369         memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
370
371       return AUXESZ;
372
373     case C_STAT:
374     case C_LEAFSTAT:
375     case C_HIDDEN:
376       if (type == T_NULL)
377         {
378           PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
379           PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
380           PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
381           H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
382           H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
383           H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
384           return AUXESZ;
385         }
386       break;
387     }
388
389   H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
390   H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
391
392   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
393       || ISTAG (in_class))
394     {
395       PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,  ext);
396       PUT_FCN_ENDNDX  (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
397     }
398   else
399     {
400       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
401                 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
402       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
403                 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
404       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
405                 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
406       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
407                 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
408     }
409
410   if (ISFCN (type))
411     H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
412   else
413     {
414       PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
415       PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
416     }
417
418   return AUXESZ;
419 }
420
421 void
422 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
423 {
424   LINENO *ext = (LINENO *) ext1;
425   struct internal_lineno *in = (struct internal_lineno *) in1;
426
427   in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
428   in->l_lnno = GET_LINENO_LNNO (abfd, ext);
429 }
430
431 unsigned int
432 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
433 {
434   struct internal_lineno *in = (struct internal_lineno *) inp;
435   struct external_lineno *ext = (struct external_lineno *) outp;
436   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
437
438   PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
439   return LINESZ;
440 }
441
442 void
443 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
444                           void * aouthdr_ext1,
445                           void * aouthdr_int1)
446 {
447   PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
448   AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
449   struct internal_aouthdr *aouthdr_int
450     = (struct internal_aouthdr *) aouthdr_int1;
451   struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
452
453   aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
454   aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
455   aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
456   aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
457   aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
458   aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
459   aouthdr_int->text_start =
460     GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
461
462 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
463   /* PE32+ does not have data_start member!  */
464   aouthdr_int->data_start =
465     GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
466   a->BaseOfData = aouthdr_int->data_start;
467 #endif
468
469   a->Magic = aouthdr_int->magic;
470   a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
471   a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
472   a->SizeOfCode = aouthdr_int->tsize ;
473   a->SizeOfInitializedData = aouthdr_int->dsize ;
474   a->SizeOfUninitializedData = aouthdr_int->bsize ;
475   a->AddressOfEntryPoint = aouthdr_int->entry;
476   a->BaseOfCode = aouthdr_int->text_start;
477   a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
478   a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
479   a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
480   a->MajorOperatingSystemVersion =
481     H_GET_16 (abfd, src->MajorOperatingSystemVersion);
482   a->MinorOperatingSystemVersion =
483     H_GET_16 (abfd, src->MinorOperatingSystemVersion);
484   a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
485   a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
486   a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
487   a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
488   a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
489   a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
490   a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
491   a->CheckSum = H_GET_32 (abfd, src->CheckSum);
492   a->Subsystem = H_GET_16 (abfd, src->Subsystem);
493   a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
494   a->SizeOfStackReserve =
495     GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
496   a->SizeOfStackCommit =
497     GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
498   a->SizeOfHeapReserve =
499     GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
500   a->SizeOfHeapCommit =
501     GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
502   a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
503   a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
504
505   {
506     int idx;
507
508     /* PR 17512: Corrupt PE binaries can cause seg-faults.  */
509     if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
510       {
511         (*_bfd_error_handler)
512           (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
513            abfd, a->NumberOfRvaAndSizes);
514         /* Paranoia: If the number is corrupt, then assume that the
515            actual entries themselves might be corrupt as well.  */
516         a->NumberOfRvaAndSizes = 0;
517       }
518
519     for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
520       {
521         /* If data directory is empty, rva also should be 0.  */
522         int size =
523           H_GET_32 (abfd, src->DataDirectory[idx][1]);
524
525         a->DataDirectory[idx].Size = size;
526
527         if (size)
528           a->DataDirectory[idx].VirtualAddress =
529             H_GET_32 (abfd, src->DataDirectory[idx][0]);
530         else
531           a->DataDirectory[idx].VirtualAddress = 0;
532       }
533
534     while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
535       {
536         a->DataDirectory[idx].Size = 0;
537         a->DataDirectory[idx].VirtualAddress = 0;
538         idx ++;
539       }
540   }
541
542   if (aouthdr_int->entry)
543     {
544       aouthdr_int->entry += a->ImageBase;
545 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
546       aouthdr_int->entry &= 0xffffffff;
547 #endif
548     }
549
550   if (aouthdr_int->tsize)
551     {
552       aouthdr_int->text_start += a->ImageBase;
553 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
554       aouthdr_int->text_start &= 0xffffffff;
555 #endif
556     }
557
558 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
559   /* PE32+ does not have data_start member!  */
560   if (aouthdr_int->dsize)
561     {
562       aouthdr_int->data_start += a->ImageBase;
563       aouthdr_int->data_start &= 0xffffffff;
564     }
565 #endif
566
567 #ifdef POWERPC_LE_PE
568   /* These three fields are normally set up by ppc_relocate_section.
569      In the case of reading a file in, we can pick them up from the
570      DataDirectory.  */
571   first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
572   thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
573   import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
574 #endif
575 }
576
577 /* A support function for below.  */
578
579 static void
580 add_data_entry (bfd * abfd,
581                 struct internal_extra_pe_aouthdr *aout,
582                 int idx,
583                 char *name,
584                 bfd_vma base)
585 {
586   asection *sec = bfd_get_section_by_name (abfd, name);
587
588   /* Add import directory information if it exists.  */
589   if ((sec != NULL)
590       && (coff_section_data (abfd, sec) != NULL)
591       && (pei_section_data (abfd, sec) != NULL))
592     {
593       /* If data directory is empty, rva also should be 0.  */
594       int size = pei_section_data (abfd, sec)->virt_size;
595       aout->DataDirectory[idx].Size = size;
596
597       if (size)
598         {
599           aout->DataDirectory[idx].VirtualAddress =
600             (sec->vma - base) & 0xffffffff;
601           sec->flags |= SEC_DATA;
602         }
603     }
604 }
605
606 unsigned int
607 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
608 {
609   struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
610   pe_data_type *pe = pe_data (abfd);
611   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
612   PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
613   bfd_vma sa, fa, ib;
614   IMAGE_DATA_DIRECTORY idata2, idata5, tls;
615
616   sa = extra->SectionAlignment;
617   fa = extra->FileAlignment;
618   ib = extra->ImageBase;
619
620   idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
621   idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
622   tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
623
624   if (aouthdr_in->tsize)
625     {
626       aouthdr_in->text_start -= ib;
627 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
628       aouthdr_in->text_start &= 0xffffffff;
629 #endif
630     }
631
632   if (aouthdr_in->dsize)
633     {
634       aouthdr_in->data_start -= ib;
635 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
636       aouthdr_in->data_start &= 0xffffffff;
637 #endif
638     }
639
640   if (aouthdr_in->entry)
641     {
642       aouthdr_in->entry -= ib;
643 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
644       aouthdr_in->entry &= 0xffffffff;
645 #endif
646     }
647
648 #define FA(x) (((x) + fa -1 ) & (- fa))
649 #define SA(x) (((x) + sa -1 ) & (- sa))
650
651   /* We like to have the sizes aligned.  */
652   aouthdr_in->bsize = FA (aouthdr_in->bsize);
653
654   extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
655
656   add_data_entry (abfd, extra, 0, ".edata", ib);
657   add_data_entry (abfd, extra, 2, ".rsrc", ib);
658   add_data_entry (abfd, extra, 3, ".pdata", ib);
659
660   /* In theory we do not need to call add_data_entry for .idata$2 or
661      .idata$5.  It will be done in bfd_coff_final_link where all the
662      required information is available.  If however, we are not going
663      to perform a final link, eg because we have been invoked by objcopy
664      or strip, then we need to make sure that these Data Directory
665      entries are initialised properly.
666
667      So - we copy the input values into the output values, and then, if
668      a final link is going to be performed, it can overwrite them.  */
669   extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
670   extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
671   extra->DataDirectory[PE_TLS_TABLE] = tls;
672
673   if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
674     /* Until other .idata fixes are made (pending patch), the entry for
675        .idata is needed for backwards compatibility.  FIXME.  */
676     add_data_entry (abfd, extra, 1, ".idata", ib);
677
678   /* For some reason, the virtual size (which is what's set by
679      add_data_entry) for .reloc is not the same as the size recorded
680      in this slot by MSVC; it doesn't seem to cause problems (so far),
681      but since it's the best we've got, use it.  It does do the right
682      thing for .pdata.  */
683   if (pe->has_reloc_section)
684     add_data_entry (abfd, extra, 5, ".reloc", ib);
685
686   {
687     asection *sec;
688     bfd_vma hsize = 0;
689     bfd_vma dsize = 0;
690     bfd_vma isize = 0;
691     bfd_vma tsize = 0;
692
693     for (sec = abfd->sections; sec; sec = sec->next)
694       {
695         int rounded = FA (sec->size);
696
697         /* The first non-zero section filepos is the header size.
698            Sections without contents will have a filepos of 0.  */
699         if (hsize == 0)
700           hsize = sec->filepos;
701         if (sec->flags & SEC_DATA)
702           dsize += rounded;
703         if (sec->flags & SEC_CODE)
704           tsize += rounded;
705         /* The image size is the total VIRTUAL size (which is what is
706            in the virt_size field).  Files have been seen (from MSVC
707            5.0 link.exe) where the file size of the .data segment is
708            quite small compared to the virtual size.  Without this
709            fix, strip munges the file.
710
711            FIXME: We need to handle holes between sections, which may
712            happpen when we covert from another format.  We just use
713            the virtual address and virtual size of the last section
714            for the image size.  */
715         if (coff_section_data (abfd, sec) != NULL
716             && pei_section_data (abfd, sec) != NULL)
717           isize = (sec->vma - extra->ImageBase
718                    + SA (FA (pei_section_data (abfd, sec)->virt_size)));
719       }
720
721     aouthdr_in->dsize = dsize;
722     aouthdr_in->tsize = tsize;
723     extra->SizeOfHeaders = hsize;
724     extra->SizeOfImage = isize;
725   }
726
727   H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
728
729 /* e.g. 219510000 is linker version 2.19  */
730 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
731
732   /* This piece of magic sets the "linker version" field to
733      LINKER_VERSION.  */
734   H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
735             aouthdr_out->standard.vstamp);
736
737   PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
738   PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
739   PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
740   PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
741   PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
742                           aouthdr_out->standard.text_start);
743
744 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
745   /* PE32+ does not have data_start member!  */
746   PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
747                           aouthdr_out->standard.data_start);
748 #endif
749
750   PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
751   H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
752   H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
753   H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
754             aouthdr_out->MajorOperatingSystemVersion);
755   H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
756             aouthdr_out->MinorOperatingSystemVersion);
757   H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
758   H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
759   H_PUT_16 (abfd, extra->MajorSubsystemVersion,
760             aouthdr_out->MajorSubsystemVersion);
761   H_PUT_16 (abfd, extra->MinorSubsystemVersion,
762             aouthdr_out->MinorSubsystemVersion);
763   H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
764   H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
765   H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
766   H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
767   H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
768   H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
769   PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
770                                     aouthdr_out->SizeOfStackReserve);
771   PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
772                                    aouthdr_out->SizeOfStackCommit);
773   PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
774                                    aouthdr_out->SizeOfHeapReserve);
775   PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
776                                   aouthdr_out->SizeOfHeapCommit);
777   H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
778   H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
779             aouthdr_out->NumberOfRvaAndSizes);
780   {
781     int idx;
782
783     for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)
784       {
785         H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
786                   aouthdr_out->DataDirectory[idx][0]);
787         H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
788                   aouthdr_out->DataDirectory[idx][1]);
789       }
790   }
791
792   return AOUTSZ;
793 }
794
795 unsigned int
796 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
797 {
798   int idx;
799   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
800   struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
801
802   if (pe_data (abfd)->has_reloc_section
803       || pe_data (abfd)->dont_strip_reloc)
804     filehdr_in->f_flags &= ~F_RELFLG;
805
806   if (pe_data (abfd)->dll)
807     filehdr_in->f_flags |= F_DLL;
808
809   filehdr_in->pe.e_magic    = DOSMAGIC;
810   filehdr_in->pe.e_cblp     = 0x90;
811   filehdr_in->pe.e_cp       = 0x3;
812   filehdr_in->pe.e_crlc     = 0x0;
813   filehdr_in->pe.e_cparhdr  = 0x4;
814   filehdr_in->pe.e_minalloc = 0x0;
815   filehdr_in->pe.e_maxalloc = 0xffff;
816   filehdr_in->pe.e_ss       = 0x0;
817   filehdr_in->pe.e_sp       = 0xb8;
818   filehdr_in->pe.e_csum     = 0x0;
819   filehdr_in->pe.e_ip       = 0x0;
820   filehdr_in->pe.e_cs       = 0x0;
821   filehdr_in->pe.e_lfarlc   = 0x40;
822   filehdr_in->pe.e_ovno     = 0x0;
823
824   for (idx = 0; idx < 4; idx++)
825     filehdr_in->pe.e_res[idx] = 0x0;
826
827   filehdr_in->pe.e_oemid   = 0x0;
828   filehdr_in->pe.e_oeminfo = 0x0;
829
830   for (idx = 0; idx < 10; idx++)
831     filehdr_in->pe.e_res2[idx] = 0x0;
832
833   filehdr_in->pe.e_lfanew = 0x80;
834
835   /* This next collection of data are mostly just characters.  It
836      appears to be constant within the headers put on NT exes.  */
837   filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
838   filehdr_in->pe.dos_message[1]  = 0xcd09b400;
839   filehdr_in->pe.dos_message[2]  = 0x4c01b821;
840   filehdr_in->pe.dos_message[3]  = 0x685421cd;
841   filehdr_in->pe.dos_message[4]  = 0x70207369;
842   filehdr_in->pe.dos_message[5]  = 0x72676f72;
843   filehdr_in->pe.dos_message[6]  = 0x63206d61;
844   filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
845   filehdr_in->pe.dos_message[8]  = 0x65622074;
846   filehdr_in->pe.dos_message[9]  = 0x6e757220;
847   filehdr_in->pe.dos_message[10] = 0x206e6920;
848   filehdr_in->pe.dos_message[11] = 0x20534f44;
849   filehdr_in->pe.dos_message[12] = 0x65646f6d;
850   filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
851   filehdr_in->pe.dos_message[14] = 0x24;
852   filehdr_in->pe.dos_message[15] = 0x0;
853   filehdr_in->pe.nt_signature = NT_SIGNATURE;
854
855   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
856   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
857
858   /* Only use a real timestamp if the option was chosen.  */
859   if ((pe_data (abfd)->insert_timestamp))
860     H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
861
862   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
863                       filehdr_out->f_symptr);
864   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
865   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
866   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
867
868   /* Put in extra dos header stuff.  This data remains essentially
869      constant, it just has to be tacked on to the beginning of all exes
870      for NT.  */
871   H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
872   H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
873   H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
874   H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
875   H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
876   H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
877   H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
878   H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
879   H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
880   H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
881   H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
882   H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
883   H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
884   H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
885
886   for (idx = 0; idx < 4; idx++)
887     H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
888
889   H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
890   H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
891
892   for (idx = 0; idx < 10; idx++)
893     H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
894
895   H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
896
897   for (idx = 0; idx < 16; idx++)
898     H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
899               filehdr_out->dos_message[idx]);
900
901   /* Also put in the NT signature.  */
902   H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
903
904   return FILHSZ;
905 }
906
907 unsigned int
908 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
909 {
910   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
911   FILHDR *filehdr_out = (FILHDR *) out;
912
913   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
914   H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
915   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
916   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
917   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
918   H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
919   H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
920
921   return FILHSZ;
922 }
923
924 unsigned int
925 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
926 {
927   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
928   SCNHDR *scnhdr_ext = (SCNHDR *) out;
929   unsigned int ret = SCNHSZ;
930   bfd_vma ps;
931   bfd_vma ss;
932
933   memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
934
935   PUT_SCNHDR_VADDR (abfd,
936                     ((scnhdr_int->s_vaddr
937                       - pe_data (abfd)->pe_opthdr.ImageBase)
938                      & 0xffffffff),
939                     scnhdr_ext->s_vaddr);
940
941   /* NT wants the size data to be rounded up to the next
942      NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
943      sometimes).  */
944   if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
945     {
946       if (bfd_pei_p (abfd))
947         {
948           ps = scnhdr_int->s_size;
949           ss = 0;
950         }
951       else
952        {
953          ps = 0;
954          ss = scnhdr_int->s_size;
955        }
956     }
957   else
958     {
959       if (bfd_pei_p (abfd))
960         ps = scnhdr_int->s_paddr;
961       else
962         ps = 0;
963
964       ss = scnhdr_int->s_size;
965     }
966
967   PUT_SCNHDR_SIZE (abfd, ss,
968                    scnhdr_ext->s_size);
969
970   /* s_paddr in PE is really the virtual size.  */
971   PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
972
973   PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
974                      scnhdr_ext->s_scnptr);
975   PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
976                      scnhdr_ext->s_relptr);
977   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
978                       scnhdr_ext->s_lnnoptr);
979
980   {
981     /* Extra flags must be set when dealing with PE.  All sections should also
982        have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
983        .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
984        sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
985        (this is especially important when dealing with the .idata section since
986        the addresses for routines from .dlls must be overwritten).  If .reloc
987        section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
988        (0x02000000).  Also, the resource data should also be read and
989        writable.  */
990
991     /* FIXME: Alignment is also encoded in this field, at least on PPC and
992        ARM-WINCE.  Although - how do we get the original alignment field
993        back ?  */
994
995     typedef struct
996     {
997       const char *      section_name;
998       unsigned long     must_have;
999     }
1000     pe_required_section_flags;
1001
1002     pe_required_section_flags known_sections [] =
1003       {
1004         { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1005         { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1006         { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1007         { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1008         { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1009         { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1010         { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1011         { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1012         { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1013         { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1014         { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1015         { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1016         { NULL, 0}
1017       };
1018
1019     pe_required_section_flags * p;
1020
1021     /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1022        we know exactly what this specific section wants so we remove it
1023        and then allow the must_have field to add it back in if necessary.
1024        However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1025        default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
1026        by ld --enable-auto-import (if auto-import is actually needed),
1027        by ld --omagic, or by obcopy --writable-text.  */
1028
1029     for (p = known_sections; p->section_name; p++)
1030       if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1031         {
1032           if (strcmp (scnhdr_int->s_name, ".text")
1033               || (bfd_get_file_flags (abfd) & WP_TEXT))
1034             scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1035           scnhdr_int->s_flags |= p->must_have;
1036           break;
1037         }
1038
1039     H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1040   }
1041
1042   if (coff_data (abfd)->link_info
1043       && ! coff_data (abfd)->link_info->relocatable
1044       && ! coff_data (abfd)->link_info->shared
1045       && strcmp (scnhdr_int->s_name, ".text") == 0)
1046     {
1047       /* By inference from looking at MS output, the 32 bit field
1048          which is the combination of the number_of_relocs and
1049          number_of_linenos is used for the line number count in
1050          executables.  A 16-bit field won't do for cc1.  The MS
1051          document says that the number of relocs is zero for
1052          executables, but the 17-th bit has been observed to be there.
1053          Overflow is not an issue: a 4G-line program will overflow a
1054          bunch of other fields long before this!  */
1055       H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1056       H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1057     }
1058   else
1059     {
1060       if (scnhdr_int->s_nlnno <= 0xffff)
1061         H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1062       else
1063         {
1064           (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1065                                  bfd_get_filename (abfd),
1066                                  scnhdr_int->s_nlnno);
1067           bfd_set_error (bfd_error_file_truncated);
1068           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1069           ret = 0;
1070         }
1071
1072       /* Although we could encode 0xffff relocs here, we do not, to be
1073          consistent with other parts of bfd. Also it lets us warn, as
1074          we should never see 0xffff here w/o having the overflow flag
1075          set.  */
1076       if (scnhdr_int->s_nreloc < 0xffff)
1077         H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1078       else
1079         {
1080           /* PE can deal with large #s of relocs, but not here.  */
1081           H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1082           scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1083           H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1084         }
1085     }
1086   return ret;
1087 }
1088
1089 void
1090 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1091 {
1092   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1093   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1094
1095   in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1096   in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1097   in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1098   in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1099   in->Type = H_GET_32(abfd, ext->Type);
1100   in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1101   in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1102   in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1103 }
1104
1105 unsigned int
1106 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1107 {
1108   struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1109   struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1110
1111   H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1112   H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1113   H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1114   H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1115   H_PUT_32(abfd, in->Type, ext->Type);
1116   H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1117   H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1118   H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1119
1120   return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1121 }
1122
1123 static CODEVIEW_INFO *
1124 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1125 {
1126   char buffer[256+1];
1127
1128   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1129     return NULL;
1130
1131   if (bfd_bread (buffer, 256, abfd) < 4)
1132     return NULL;
1133
1134   /* Ensure null termination of filename.  */
1135   buffer[256] = '\0';
1136
1137   cvinfo->CVSignature = H_GET_32(abfd, buffer);
1138   cvinfo->Age = 0;
1139
1140   if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1141       && (length > sizeof (CV_INFO_PDB70)))
1142     {
1143       CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1144
1145       cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1146
1147       /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1148          by 8 single bytes.  Byte swap them so we can conveniently treat the GUID
1149          as 16 bytes in big-endian order.  */
1150       bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1151       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1152       bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1153       memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1154
1155       cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1156       // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1157
1158       return cvinfo;
1159     }
1160   else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1161            && (length > sizeof (CV_INFO_PDB20)))
1162     {
1163       CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1164       cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1165       memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1166       cvinfo->SignatureLength = 4;
1167       // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1168
1169       return cvinfo;
1170     }
1171
1172   return NULL;
1173 }
1174
1175 unsigned int
1176 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1177 {
1178   unsigned int size = sizeof (CV_INFO_PDB70) + 1;
1179   CV_INFO_PDB70 *cvinfo70;
1180   char buffer[size];
1181
1182   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1183     return 0;
1184
1185   cvinfo70 = (CV_INFO_PDB70 *) buffer;
1186   H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1187
1188   /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1189      in little-endian order, followed by 8 single bytes.  */
1190   bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1191   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1192   bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1193   memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1194
1195   H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1196   cvinfo70->PdbFileName[0] = '\0';
1197
1198   if (bfd_bwrite (buffer, size, abfd) != size)
1199     return 0;
1200
1201   return size;
1202 }
1203
1204 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1205 {
1206   N_("Export Directory [.edata (or where ever we found it)]"),
1207   N_("Import Directory [parts of .idata]"),
1208   N_("Resource Directory [.rsrc]"),
1209   N_("Exception Directory [.pdata]"),
1210   N_("Security Directory"),
1211   N_("Base Relocation Directory [.reloc]"),
1212   N_("Debug Directory"),
1213   N_("Description Directory"),
1214   N_("Special Directory"),
1215   N_("Thread Storage Directory [.tls]"),
1216   N_("Load Configuration Directory"),
1217   N_("Bound Import Directory"),
1218   N_("Import Address Table Directory"),
1219   N_("Delay Import Directory"),
1220   N_("CLR Runtime Header"),
1221   N_("Reserved")
1222 };
1223
1224 #ifdef POWERPC_LE_PE
1225 /* The code for the PPC really falls in the "architecture dependent"
1226    category.  However, it's not clear that anyone will ever care, so
1227    we're ignoring the issue for now; if/when PPC matters, some of this
1228    may need to go into peicode.h, or arguments passed to enable the
1229    PPC- specific code.  */
1230 #endif
1231
1232 static bfd_boolean
1233 pe_print_idata (bfd * abfd, void * vfile)
1234 {
1235   FILE *file = (FILE *) vfile;
1236   bfd_byte *data;
1237   asection *section;
1238   bfd_signed_vma adj;
1239
1240 #ifdef POWERPC_LE_PE
1241   asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1242 #endif
1243
1244   bfd_size_type datasize = 0;
1245   bfd_size_type dataoff;
1246   bfd_size_type i;
1247   int onaline = 20;
1248
1249   pe_data_type *pe = pe_data (abfd);
1250   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1251
1252   bfd_vma addr;
1253
1254   addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1255
1256   if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1257     {
1258       /* Maybe the extra header isn't there.  Look for the section.  */
1259       section = bfd_get_section_by_name (abfd, ".idata");
1260       if (section == NULL)
1261         return TRUE;
1262
1263       addr = section->vma;
1264       datasize = section->size;
1265       if (datasize == 0)
1266         return TRUE;
1267     }
1268   else
1269     {
1270       addr += extra->ImageBase;
1271       for (section = abfd->sections; section != NULL; section = section->next)
1272         {
1273           datasize = section->size;
1274           if (addr >= section->vma && addr < section->vma + datasize)
1275             break;
1276         }
1277
1278       if (section == NULL)
1279         {
1280           fprintf (file,
1281                    _("\nThere is an import table, but the section containing it could not be found\n"));
1282           return TRUE;
1283         }
1284       else if (!(section->flags & SEC_HAS_CONTENTS))
1285         {
1286           fprintf (file,
1287                    _("\nThere is an import table in %s, but that section has no contents\n"),
1288                    section->name);
1289           return TRUE;
1290         }
1291     }
1292
1293   fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1294            section->name, (unsigned long) addr);
1295
1296   dataoff = addr - section->vma;
1297
1298 #ifdef POWERPC_LE_PE
1299   if (rel_section != 0 && rel_section->size != 0)
1300     {
1301       /* The toc address can be found by taking the starting address,
1302          which on the PPC locates a function descriptor. The
1303          descriptor consists of the function code starting address
1304          followed by the address of the toc. The starting address we
1305          get from the bfd, and the descriptor is supposed to be in the
1306          .reldata section.  */
1307
1308       bfd_vma loadable_toc_address;
1309       bfd_vma toc_address;
1310       bfd_vma start_address;
1311       bfd_byte *data;
1312       bfd_vma offset;
1313
1314       if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1315         {
1316           if (data != NULL)
1317             free (data);
1318           return FALSE;
1319         }
1320
1321       offset = abfd->start_address - rel_section->vma;
1322
1323       if (offset >= rel_section->size || offset + 8 > rel_section->size)
1324         {
1325           if (data != NULL)
1326             free (data);
1327           return FALSE;
1328         }
1329
1330       start_address = bfd_get_32 (abfd, data + offset);
1331       loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1332       toc_address = loadable_toc_address - 32768;
1333
1334       fprintf (file,
1335                _("\nFunction descriptor located at the start address: %04lx\n"),
1336                (unsigned long int) (abfd->start_address));
1337       fprintf (file,
1338                _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1339                start_address, loadable_toc_address, toc_address);
1340       if (data != NULL)
1341         free (data);
1342     }
1343   else
1344     {
1345       fprintf (file,
1346                _("\nNo reldata section! Function descriptor not decoded.\n"));
1347     }
1348 #endif
1349
1350   fprintf (file,
1351            _("\nThe Import Tables (interpreted %s section contents)\n"),
1352            section->name);
1353   fprintf (file,
1354            _("\
1355  vma:            Hint    Time      Forward  DLL       First\n\
1356                  Table   Stamp     Chain    Name      Thunk\n"));
1357
1358   /* Read the whole section.  Some of the fields might be before dataoff.  */
1359   if (!bfd_malloc_and_get_section (abfd, section, &data))
1360     {
1361       if (data != NULL)
1362         free (data);
1363       return FALSE;
1364     }
1365
1366   adj = section->vma - extra->ImageBase;
1367
1368   /* Print all image import descriptors.  */
1369   for (i = dataoff; i + onaline <= datasize; i += onaline)
1370     {
1371       bfd_vma hint_addr;
1372       bfd_vma time_stamp;
1373       bfd_vma forward_chain;
1374       bfd_vma dll_name;
1375       bfd_vma first_thunk;
1376       int idx = 0;
1377       bfd_size_type j;
1378       char *dll;
1379
1380       /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1381       fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1382       hint_addr = bfd_get_32 (abfd, data + i);
1383       time_stamp = bfd_get_32 (abfd, data + i + 4);
1384       forward_chain = bfd_get_32 (abfd, data + i + 8);
1385       dll_name = bfd_get_32 (abfd, data + i + 12);
1386       first_thunk = bfd_get_32 (abfd, data + i + 16);
1387
1388       fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1389                (unsigned long) hint_addr,
1390                (unsigned long) time_stamp,
1391                (unsigned long) forward_chain,
1392                (unsigned long) dll_name,
1393                (unsigned long) first_thunk);
1394
1395       if (hint_addr == 0 && first_thunk == 0)
1396         break;
1397
1398       if (dll_name - adj >= section->size)
1399         break;
1400
1401       dll = (char *) data + dll_name - adj;
1402       /* PR 17512 file: 078-12277-0.004.  */
1403       bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1404       fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
1405
1406       if (hint_addr != 0)
1407         {
1408           bfd_byte *ft_data;
1409           asection *ft_section;
1410           bfd_vma ft_addr;
1411           bfd_size_type ft_datasize;
1412           int ft_idx;
1413           int ft_allocated;
1414
1415           fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1416
1417           idx = hint_addr - adj;
1418
1419           ft_addr = first_thunk + extra->ImageBase;
1420           ft_idx = first_thunk - adj;
1421           ft_data = data + ft_idx;
1422           ft_datasize = datasize - ft_idx;
1423           ft_allocated = 0;
1424
1425           if (first_thunk != hint_addr)
1426             {
1427               /* Find the section which contains the first thunk.  */
1428               for (ft_section = abfd->sections;
1429                    ft_section != NULL;
1430                    ft_section = ft_section->next)
1431                 {
1432                   if (ft_addr >= ft_section->vma
1433                       && ft_addr < ft_section->vma + ft_section->size)
1434                     break;
1435                 }
1436
1437               if (ft_section == NULL)
1438                 {
1439                   fprintf (file,
1440                        _("\nThere is a first thunk, but the section containing it could not be found\n"));
1441                   continue;
1442                 }
1443
1444               /* Now check to see if this section is the same as our current
1445                  section.  If it is not then we will have to load its data in.  */
1446               if (ft_section != section)
1447                 {
1448                   ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1449                   ft_datasize = ft_section->size - ft_idx;
1450                   ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1451                   if (ft_data == NULL)
1452                     continue;
1453
1454                   /* Read ft_datasize bytes starting at offset ft_idx.  */
1455                   if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1456                                                  (bfd_vma) ft_idx, ft_datasize))
1457                     {
1458                       free (ft_data);
1459                       continue;
1460                     }
1461                   ft_allocated = 1;
1462                 }
1463             }
1464
1465           /* Print HintName vector entries.  */
1466 #ifdef COFF_WITH_pex64
1467           for (j = 0; idx + j + 8 <= datasize; j += 8)
1468             {
1469               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1470               unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1471
1472               if (!member && !member_high)
1473                 break;
1474
1475               if (HighBitSet (member_high))
1476                 fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1477                          member_high, member,
1478                          WithoutHighBit (member_high), member);
1479               /* PR binutils/17512: Handle corrupt PE data.  */
1480               else if ((bfd_vma) member - adj + 2 >= datasize)
1481                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1482               else
1483                 {
1484                   int ordinal;
1485                   char *member_name;
1486
1487                   ordinal = bfd_get_16 (abfd, data + member - adj);
1488                   member_name = (char *) data + member - adj + 2;
1489                   fprintf (file, "\t%04lx\t %4d  %s",member, ordinal, member_name);
1490                 }
1491
1492               /* If the time stamp is not zero, the import address
1493                  table holds actual addresses.  */
1494               if (time_stamp != 0
1495                   && first_thunk != 0
1496                   && first_thunk != hint_addr
1497                   && j + 4 <= ft_datasize)
1498                 fprintf (file, "\t%04lx",
1499                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1500               fprintf (file, "\n");
1501             }
1502 #else
1503           for (j = 0; idx + j + 4 <= datasize; j += 4)
1504             {
1505               unsigned long member = bfd_get_32 (abfd, data + idx + j);
1506
1507               /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1508               if (member == 0)
1509                 break;
1510
1511               if (HighBitSet (member))
1512                 fprintf (file, "\t%04lx\t %4lu  <none>",
1513                          member, WithoutHighBit (member));
1514               /* PR binutils/17512: Handle corrupt PE data.  */
1515               else if ((bfd_vma) member - adj + 2 >= datasize)
1516                 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1517               else
1518                 {
1519                   int ordinal;
1520                   char *member_name;
1521
1522                   ordinal = bfd_get_16 (abfd, data + member - adj);
1523                   member_name = (char *) data + member - adj + 2;
1524                   fprintf (file, "\t%04lx\t %4d  %s",
1525                            member, ordinal, member_name);
1526                 }
1527
1528               /* If the time stamp is not zero, the import address
1529                  table holds actual addresses.  */
1530               if (time_stamp != 0
1531                   && first_thunk != 0
1532                   && first_thunk != hint_addr
1533                   && j + 4 <= ft_datasize)
1534                 fprintf (file, "\t%04lx",
1535                          (unsigned long) bfd_get_32 (abfd, ft_data + j));
1536
1537               fprintf (file, "\n");
1538             }
1539 #endif
1540           if (ft_allocated)
1541             free (ft_data);
1542         }
1543
1544       fprintf (file, "\n");
1545     }
1546
1547   free (data);
1548
1549   return TRUE;
1550 }
1551
1552 static bfd_boolean
1553 pe_print_edata (bfd * abfd, void * vfile)
1554 {
1555   FILE *file = (FILE *) vfile;
1556   bfd_byte *data;
1557   asection *section;
1558   bfd_size_type datasize = 0;
1559   bfd_size_type dataoff;
1560   bfd_size_type i;
1561   bfd_vma       adj;
1562   struct EDT_type
1563   {
1564     long export_flags;          /* Reserved - should be zero.  */
1565     long time_stamp;
1566     short major_ver;
1567     short minor_ver;
1568     bfd_vma name;               /* RVA - relative to image base.  */
1569     long base;                  /* Ordinal base.  */
1570     unsigned long num_functions;/* Number in the export address table.  */
1571     unsigned long num_names;    /* Number in the name pointer table.  */
1572     bfd_vma eat_addr;           /* RVA to the export address table.  */
1573     bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1574     bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1575   } edt;
1576
1577   pe_data_type *pe = pe_data (abfd);
1578   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1579
1580   bfd_vma addr;
1581
1582   addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1583
1584   if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1585     {
1586       /* Maybe the extra header isn't there.  Look for the section.  */
1587       section = bfd_get_section_by_name (abfd, ".edata");
1588       if (section == NULL)
1589         return TRUE;
1590
1591       addr = section->vma;
1592       dataoff = 0;
1593       datasize = section->size;
1594       if (datasize == 0)
1595         return TRUE;
1596     }
1597   else
1598     {
1599       addr += extra->ImageBase;
1600
1601       for (section = abfd->sections; section != NULL; section = section->next)
1602         if (addr >= section->vma && addr < section->vma + section->size)
1603           break;
1604
1605       if (section == NULL)
1606         {
1607           fprintf (file,
1608                    _("\nThere is an export table, but the section containing it could not be found\n"));
1609           return TRUE;
1610         }
1611       else if (!(section->flags & SEC_HAS_CONTENTS))
1612         {
1613           fprintf (file,
1614                    _("\nThere is an export table in %s, but that section has no contents\n"),
1615                    section->name);
1616           return TRUE;
1617         }
1618
1619       dataoff = addr - section->vma;
1620       datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1621       if (datasize > section->size - dataoff)
1622         {
1623           fprintf (file,
1624                    _("\nThere is an export table in %s, but it does not fit into that section\n"),
1625                    section->name);
1626           return TRUE;
1627         }
1628     }
1629
1630   /* PR 17512: Handle corrupt PE binaries.  */
1631   if (datasize < 36)
1632     {
1633       fprintf (file,
1634                _("\nThere is an export table in %s, but it is too small (%d)\n"),
1635                section->name, (int) datasize);
1636       return TRUE;
1637     }
1638
1639   fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1640            section->name, (unsigned long) addr);
1641
1642   data = (bfd_byte *) bfd_malloc (datasize);
1643   if (data == NULL)
1644     return FALSE;
1645
1646   if (! bfd_get_section_contents (abfd, section, data,
1647                                   (file_ptr) dataoff, datasize))
1648     return FALSE;
1649
1650   /* Go get Export Directory Table.  */
1651   edt.export_flags   = bfd_get_32 (abfd, data +  0);
1652   edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1653   edt.major_ver      = bfd_get_16 (abfd, data +  8);
1654   edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1655   edt.name           = bfd_get_32 (abfd, data + 12);
1656   edt.base           = bfd_get_32 (abfd, data + 16);
1657   edt.num_functions  = bfd_get_32 (abfd, data + 20);
1658   edt.num_names      = bfd_get_32 (abfd, data + 24);
1659   edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1660   edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1661   edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1662
1663   adj = section->vma - extra->ImageBase + dataoff;
1664
1665   /* Dump the EDT first.  */
1666   fprintf (file,
1667            _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1668            section->name);
1669
1670   fprintf (file,
1671            _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1672
1673   fprintf (file,
1674            _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1675
1676   fprintf (file,
1677            _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1678
1679   fprintf (file,
1680            _("Name \t\t\t\t"));
1681   bfd_fprintf_vma (abfd, file, edt.name);
1682
1683   if ((edt.name >= adj) && (edt.name < adj + datasize))
1684     fprintf (file, " %s\n", data + edt.name - adj);
1685   else
1686     fprintf (file, "(outside .edata section)\n");
1687
1688   fprintf (file,
1689            _("Ordinal Base \t\t\t%ld\n"), edt.base);
1690
1691   fprintf (file,
1692            _("Number in:\n"));
1693
1694   fprintf (file,
1695            _("\tExport Address Table \t\t%08lx\n"),
1696            edt.num_functions);
1697
1698   fprintf (file,
1699            _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1700
1701   fprintf (file,
1702            _("Table Addresses\n"));
1703
1704   fprintf (file,
1705            _("\tExport Address Table \t\t"));
1706   bfd_fprintf_vma (abfd, file, edt.eat_addr);
1707   fprintf (file, "\n");
1708
1709   fprintf (file,
1710            _("\tName Pointer Table \t\t"));
1711   bfd_fprintf_vma (abfd, file, edt.npt_addr);
1712   fprintf (file, "\n");
1713
1714   fprintf (file,
1715            _("\tOrdinal Table \t\t\t"));
1716   bfd_fprintf_vma (abfd, file, edt.ot_addr);
1717   fprintf (file, "\n");
1718
1719   /* The next table to find is the Export Address Table. It's basically
1720      a list of pointers that either locate a function in this dll, or
1721      forward the call to another dll. Something like:
1722       typedef union
1723       {
1724         long export_rva;
1725         long forwarder_rva;
1726       } export_address_table_entry;  */
1727
1728   fprintf (file,
1729           _("\nExport Address Table -- Ordinal Base %ld\n"),
1730           edt.base);
1731
1732   /* PR 17512: Handle corrupt PE binaries.  */
1733   if (edt.eat_addr + (edt.num_functions * 4) - adj >= datasize
1734       /* PR 17512 file: 140-165018-0.004.  */
1735       || data + edt.eat_addr - adj < data)
1736     fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1737              (long) edt.eat_addr,
1738              (long) edt.num_functions);
1739   else for (i = 0; i < edt.num_functions; ++i)
1740     {
1741       bfd_vma eat_member = bfd_get_32 (abfd,
1742                                        data + edt.eat_addr + (i * 4) - adj);
1743       if (eat_member == 0)
1744         continue;
1745
1746       if (eat_member - adj <= datasize)
1747         {
1748           /* This rva is to a name (forwarding function) in our section.  */
1749           /* Should locate a function descriptor.  */
1750           fprintf (file,
1751                    "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1752                    (long) i,
1753                    (long) (i + edt.base),
1754                    (unsigned long) eat_member,
1755                    _("Forwarder RVA"),
1756                    (int)(datasize - (eat_member - adj)),
1757                    data + eat_member - adj);
1758         }
1759       else
1760         {
1761           /* Should locate a function descriptor in the reldata section.  */
1762           fprintf (file,
1763                    "\t[%4ld] +base[%4ld] %04lx %s\n",
1764                    (long) i,
1765                    (long) (i + edt.base),
1766                    (unsigned long) eat_member,
1767                    _("Export RVA"));
1768         }
1769     }
1770
1771   /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1772   /* Dump them in parallel for clarity.  */
1773   fprintf (file,
1774            _("\n[Ordinal/Name Pointer] Table\n"));
1775
1776   /* PR 17512: Handle corrupt PE binaries.  */
1777   if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1778       || (data + edt.npt_addr - adj) < data)
1779     fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1780              (long) edt.npt_addr,
1781              (long) edt.num_names);
1782   /* PR 17512: file: 140-147171-0.004.  */
1783   else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1784            || data + edt.ot_addr - adj < data)
1785     fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1786              (long) edt.ot_addr,
1787              (long) edt.num_names);
1788   else for (i = 0; i < edt.num_names; ++i)
1789     {
1790       bfd_vma  name_ptr;
1791       bfd_vma  ord;
1792
1793       ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1794       name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1795
1796       if ((name_ptr - adj) >= datasize)
1797         {
1798           fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1799                    (long) ord, (long) name_ptr);
1800         }
1801       else
1802         {
1803           char * name = (char *) data + name_ptr - adj;
1804
1805           fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1806                    (int)((char *)(data + datasize) - name), name);
1807         }
1808     }
1809
1810   free (data);
1811
1812   return TRUE;
1813 }
1814
1815 /* This really is architecture dependent.  On IA-64, a .pdata entry
1816    consists of three dwords containing relative virtual addresses that
1817    specify the start and end address of the code range the entry
1818    covers and the address of the corresponding unwind info data.
1819
1820    On ARM and SH-4, a compressed PDATA structure is used :
1821    _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1822    _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1823    See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1824
1825    This is the version for uncompressed data.  */
1826
1827 static bfd_boolean
1828 pe_print_pdata (bfd * abfd, void * vfile)
1829 {
1830 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1831 # define PDATA_ROW_SIZE (3 * 8)
1832 #else
1833 # define PDATA_ROW_SIZE (5 * 4)
1834 #endif
1835   FILE *file = (FILE *) vfile;
1836   bfd_byte *data = 0;
1837   asection *section = bfd_get_section_by_name (abfd, ".pdata");
1838   bfd_size_type datasize = 0;
1839   bfd_size_type i;
1840   bfd_size_type start, stop;
1841   int onaline = PDATA_ROW_SIZE;
1842
1843   if (section == NULL
1844       || coff_section_data (abfd, section) == NULL
1845       || pei_section_data (abfd, section) == NULL)
1846     return TRUE;
1847
1848   stop = pei_section_data (abfd, section)->virt_size;
1849   if ((stop % onaline) != 0)
1850     fprintf (file,
1851              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1852              (long) stop, onaline);
1853
1854   fprintf (file,
1855            _("\nThe Function Table (interpreted .pdata section contents)\n"));
1856 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1857   fprintf (file,
1858            _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1859 #else
1860   fprintf (file, _("\
1861  vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1862      \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1863 #endif
1864
1865   datasize = section->size;
1866   if (datasize == 0)
1867     return TRUE;
1868
1869   if (! bfd_malloc_and_get_section (abfd, section, &data))
1870     {
1871       if (data != NULL)
1872         free (data);
1873       return FALSE;
1874     }
1875
1876   start = 0;
1877
1878   for (i = start; i < stop; i += onaline)
1879     {
1880       bfd_vma begin_addr;
1881       bfd_vma end_addr;
1882       bfd_vma eh_handler;
1883       bfd_vma eh_data;
1884       bfd_vma prolog_end_addr;
1885 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1886       int em_data;
1887 #endif
1888
1889       if (i + PDATA_ROW_SIZE > stop)
1890         break;
1891
1892       begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1893       end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1894       eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1895       eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1896       prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1897
1898       if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1899           && eh_data == 0 && prolog_end_addr == 0)
1900         /* We are probably into the padding of the section now.  */
1901         break;
1902
1903 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1904       em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1905 #endif
1906       eh_handler &= ~(bfd_vma) 0x3;
1907       prolog_end_addr &= ~(bfd_vma) 0x3;
1908
1909       fputc (' ', file);
1910       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1911       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1912       bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1913       bfd_fprintf_vma (abfd, file, eh_handler);
1914 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1915       fputc (' ', file);
1916       bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1917       bfd_fprintf_vma (abfd, file, prolog_end_addr);
1918       fprintf (file, "   %x", em_data);
1919 #endif
1920
1921 #ifdef POWERPC_LE_PE
1922       if (eh_handler == 0 && eh_data != 0)
1923         {
1924           /* Special bits here, although the meaning may be a little
1925              mysterious. The only one I know for sure is 0x03
1926              Code Significance
1927              0x00 None
1928              0x01 Register Save Millicode
1929              0x02 Register Restore Millicode
1930              0x03 Glue Code Sequence.  */
1931           switch (eh_data)
1932             {
1933             case 0x01:
1934               fprintf (file, _(" Register save millicode"));
1935               break;
1936             case 0x02:
1937               fprintf (file, _(" Register restore millicode"));
1938               break;
1939             case 0x03:
1940               fprintf (file, _(" Glue code sequence"));
1941               break;
1942             default:
1943               break;
1944             }
1945         }
1946 #endif
1947       fprintf (file, "\n");
1948     }
1949
1950   free (data);
1951
1952   return TRUE;
1953 #undef PDATA_ROW_SIZE
1954 }
1955
1956 typedef struct sym_cache
1957 {
1958   int        symcount;
1959   asymbol ** syms;
1960 } sym_cache;
1961
1962 static asymbol **
1963 slurp_symtab (bfd *abfd, sym_cache *psc)
1964 {
1965   asymbol ** sy = NULL;
1966   long storage;
1967
1968   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1969     {
1970       psc->symcount = 0;
1971       return NULL;
1972     }
1973
1974   storage = bfd_get_symtab_upper_bound (abfd);
1975   if (storage < 0)
1976     return NULL;
1977   if (storage)
1978     sy = (asymbol **) bfd_malloc (storage);
1979
1980   psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1981   if (psc->symcount < 0)
1982     return NULL;
1983   return sy;
1984 }
1985
1986 static const char *
1987 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1988 {
1989   int i;
1990
1991   if (psc->syms == 0)
1992     psc->syms = slurp_symtab (abfd, psc);
1993
1994   for (i = 0; i < psc->symcount; i++)
1995     {
1996       if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1997         return psc->syms[i]->name;
1998     }
1999
2000   return NULL;
2001 }
2002
2003 static void
2004 cleanup_syms (sym_cache *psc)
2005 {
2006   psc->symcount = 0;
2007   free (psc->syms);
2008   psc->syms = NULL;
2009 }
2010
2011 /* This is the version for "compressed" pdata.  */
2012
2013 bfd_boolean
2014 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2015 {
2016 # define PDATA_ROW_SIZE (2 * 4)
2017   FILE *file = (FILE *) vfile;
2018   bfd_byte *data = NULL;
2019   asection *section = bfd_get_section_by_name (abfd, ".pdata");
2020   bfd_size_type datasize = 0;
2021   bfd_size_type i;
2022   bfd_size_type start, stop;
2023   int onaline = PDATA_ROW_SIZE;
2024   struct sym_cache cache = {0, 0} ;
2025
2026   if (section == NULL
2027       || coff_section_data (abfd, section) == NULL
2028       || pei_section_data (abfd, section) == NULL)
2029     return TRUE;
2030
2031   stop = pei_section_data (abfd, section)->virt_size;
2032   if ((stop % onaline) != 0)
2033     fprintf (file,
2034              _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2035              (long) stop, onaline);
2036
2037   fprintf (file,
2038            _("\nThe Function Table (interpreted .pdata section contents)\n"));
2039
2040   fprintf (file, _("\
2041  vma:\t\tBegin    Prolog   Function Flags    Exception EH\n\
2042      \t\tAddress  Length   Length   32b exc  Handler   Data\n"));
2043
2044   datasize = section->size;
2045   if (datasize == 0)
2046     return TRUE;
2047
2048   if (! bfd_malloc_and_get_section (abfd, section, &data))
2049     {
2050       if (data != NULL)
2051         free (data);
2052       return FALSE;
2053     }
2054
2055   start = 0;
2056
2057   for (i = start; i < stop; i += onaline)
2058     {
2059       bfd_vma begin_addr;
2060       bfd_vma other_data;
2061       bfd_vma prolog_length, function_length;
2062       int flag32bit, exception_flag;
2063       asection *tsection;
2064
2065       if (i + PDATA_ROW_SIZE > stop)
2066         break;
2067
2068       begin_addr = GET_PDATA_ENTRY (abfd, data + i     );
2069       other_data = GET_PDATA_ENTRY (abfd, data + i +  4);
2070
2071       if (begin_addr == 0 && other_data == 0)
2072         /* We are probably into the padding of the section now.  */
2073         break;
2074
2075       prolog_length = (other_data & 0x000000FF);
2076       function_length = (other_data & 0x3FFFFF00) >> 8;
2077       flag32bit = (int)((other_data & 0x40000000) >> 30);
2078       exception_flag = (int)((other_data & 0x80000000) >> 31);
2079
2080       fputc (' ', file);
2081       bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2082       bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2083       bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2084       bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2085       fprintf (file, "%2d  %2d   ", flag32bit, exception_flag);
2086
2087       /* Get the exception handler's address and the data passed from the
2088          .text section. This is really the data that belongs with the .pdata
2089          but got "compressed" out for the ARM and SH4 architectures.  */
2090       tsection = bfd_get_section_by_name (abfd, ".text");
2091       if (tsection && coff_section_data (abfd, tsection)
2092           && pei_section_data (abfd, tsection))
2093         {
2094           bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2095           bfd_byte *tdata;
2096
2097           tdata = (bfd_byte *) bfd_malloc (8);
2098           if (tdata)
2099             {
2100               if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2101                 {
2102                   bfd_vma eh, eh_data;
2103
2104                   eh = bfd_get_32 (abfd, tdata);
2105                   eh_data = bfd_get_32 (abfd, tdata + 4);
2106                   fprintf (file, "%08x  ", (unsigned int) eh);
2107                   fprintf (file, "%08x", (unsigned int) eh_data);
2108                   if (eh != 0)
2109                     {
2110                       const char *s = my_symbol_for_address (abfd, eh, &cache);
2111
2112                       if (s)
2113                         fprintf (file, " (%s) ", s);
2114                     }
2115                 }
2116               free (tdata);
2117             }
2118         }
2119
2120       fprintf (file, "\n");
2121     }
2122
2123   free (data);
2124
2125   cleanup_syms (& cache);
2126
2127   return TRUE;
2128 #undef PDATA_ROW_SIZE
2129 }
2130
2131 \f
2132 #define IMAGE_REL_BASED_HIGHADJ 4
2133 static const char * const tbl[] =
2134 {
2135   "ABSOLUTE",
2136   "HIGH",
2137   "LOW",
2138   "HIGHLOW",
2139   "HIGHADJ",
2140   "MIPS_JMPADDR",
2141   "SECTION",
2142   "REL32",
2143   "RESERVED1",
2144   "MIPS_JMPADDR16",
2145   "DIR64",
2146   "HIGH3ADJ",
2147   "UNKNOWN",   /* MUST be last.  */
2148 };
2149
2150 static bfd_boolean
2151 pe_print_reloc (bfd * abfd, void * vfile)
2152 {
2153   FILE *file = (FILE *) vfile;
2154   bfd_byte *data = 0;
2155   asection *section = bfd_get_section_by_name (abfd, ".reloc");
2156   bfd_byte *p, *end;
2157
2158   if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2159     return TRUE;
2160
2161   fprintf (file,
2162            _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2163
2164   if (! bfd_malloc_and_get_section (abfd, section, &data))
2165     {
2166       if (data != NULL)
2167         free (data);
2168       return FALSE;
2169     }
2170
2171   p = data;
2172   end = data + section->size;
2173   while (p + 8 <= end)
2174     {
2175       int j;
2176       bfd_vma virtual_address;
2177       long number, size;
2178       bfd_byte *chunk_end;
2179
2180       /* The .reloc section is a sequence of blocks, with a header consisting
2181          of two 32 bit quantities, followed by a number of 16 bit entries.  */
2182       virtual_address = bfd_get_32 (abfd, p);
2183       size = bfd_get_32 (abfd, p + 4);
2184       p += 8;
2185       number = (size - 8) / 2;
2186
2187       if (size == 0)
2188         break;
2189
2190       fprintf (file,
2191                _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2192                (unsigned long) virtual_address, size, (unsigned long) size, number);
2193
2194       chunk_end = p + size;
2195       if (chunk_end > end)
2196         chunk_end = end;
2197       j = 0;
2198       while (p + 2 <= chunk_end)
2199         {
2200           unsigned short e = bfd_get_16 (abfd, p);
2201           unsigned int t = (e & 0xF000) >> 12;
2202           int off = e & 0x0FFF;
2203
2204           if (t >= sizeof (tbl) / sizeof (tbl[0]))
2205             t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2206
2207           fprintf (file,
2208                    _("\treloc %4d offset %4x [%4lx] %s"),
2209                    j, off, (unsigned long) (off + virtual_address), tbl[t]);
2210
2211           p += 2;
2212           j++;
2213
2214           /* HIGHADJ takes an argument, - the next record *is* the
2215              low 16 bits of addend.  */
2216           if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2217             {
2218               fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2219               p += 2;
2220               j++;
2221             }
2222
2223           fprintf (file, "\n");
2224         }
2225     }
2226
2227   free (data);
2228
2229   return TRUE;
2230 }
2231 \f
2232 /* A data structure describing the regions of a .rsrc section.
2233    Some fields are filled in as the section is parsed.  */
2234
2235 typedef struct rsrc_regions
2236 {
2237   bfd_byte * section_start;
2238   bfd_byte * section_end;
2239   bfd_byte * strings_start;
2240   bfd_byte * resource_start;
2241 } rsrc_regions;
2242
2243 static bfd_byte *
2244 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2245                                rsrc_regions *, bfd_vma);
2246
2247 /* Print the resource entry at DATA, with the text indented by INDENT.
2248    Recusively calls rsrc_print_resource_directory to print the contents
2249    of directory entries.
2250    Returns the address of the end of the data associated with the entry
2251    or section_end + 1 upon failure.  */
2252
2253 static bfd_byte *
2254 rsrc_print_resource_entries (FILE *         file,
2255                              bfd *          abfd,
2256                              unsigned int   indent,
2257                              bfd_boolean    is_name,
2258                              bfd_byte *     data,
2259                              rsrc_regions * regions,
2260                              bfd_vma        rva_bias)
2261 {
2262   unsigned long entry, addr, size;
2263
2264   if (data + 8 >= regions->section_end)
2265     return regions->section_end + 1;
2266
2267   fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2268
2269   entry = (unsigned long) bfd_get_32 (abfd, data);
2270   if (is_name)
2271     {
2272       bfd_byte * name;
2273
2274       /* Note - the documentation says that this field is an RVA value
2275          but windres appears to produce a section relative offset with
2276          the top bit set.  Support both styles for now.  */
2277       if (HighBitSet (entry))
2278         name = regions->section_start + WithoutHighBit (entry);
2279       else
2280         name = regions->section_start + entry - rva_bias;
2281
2282       if (name + 2 < regions->section_end && name > regions->section_start)
2283         {
2284           unsigned int len;
2285
2286           if (regions->strings_start == NULL)
2287             regions->strings_start = name;
2288
2289           len = bfd_get_16 (abfd, name);
2290
2291           fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2292
2293           if (name + 2 + len * 2 < regions->section_end)
2294             {
2295               /* This strange loop is to cope with multibyte characters.  */
2296               while (len --)
2297                 {
2298                   char c;
2299
2300                   name += 2;
2301                   c = * name;
2302                   /* Avoid printing control characters.  */
2303                   if (c > 0 && c < 32)
2304                     fprintf (file, "^%c", c + 64);
2305                   else
2306                     fprintf (file, "%.1s", name);
2307                 }
2308             }
2309           else
2310             {
2311               fprintf (file, _("<corrupt string length: %#x>\n"), len);
2312               /* PR binutils/17512: Do not try to continue decoding a
2313                  corrupted resource section.  It is likely to end up with
2314                  reams of extraneous output.  FIXME: We could probably
2315                  continue if we disable the printing of strings...  */
2316               return regions->section_end + 1;
2317             }
2318         }
2319       else
2320         {
2321           fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2322           return regions->section_end + 1;
2323         }
2324     }
2325   else
2326     fprintf (file, _("ID: %#08lx"), entry);
2327
2328   entry = (long) bfd_get_32 (abfd, data + 4);
2329   fprintf (file, _(", Value: %#08lx\n"), entry);
2330
2331   if (HighBitSet  (entry))
2332     {
2333       data = regions->section_start + WithoutHighBit (entry);
2334       if (data <= regions->section_start || data > regions->section_end)
2335         return regions->section_end + 1;
2336
2337       /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2338          in the resource table.  We need some way to detect this.  */
2339       return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2340                                             regions, rva_bias);
2341     }
2342
2343   if (regions->section_start + entry + 16 >= regions->section_end)
2344     return regions->section_end + 1;
2345
2346   fprintf (file, _("%03x %*.s  Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2347            (int) (entry),
2348            indent, " ",
2349            addr = (long) bfd_get_32 (abfd, regions->section_start + entry),
2350            size = (long) bfd_get_32 (abfd, regions->section_start + entry + 4),
2351            (int) bfd_get_32 (abfd, regions->section_start + entry + 8));
2352
2353   /* Check that the reserved entry is 0.  */
2354   if (bfd_get_32 (abfd, regions->section_start + entry + 12) != 0
2355       /* And that the data address/size is valid too.  */
2356       || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2357     return regions->section_end + 1;
2358
2359   if (regions->resource_start == NULL)
2360     regions->resource_start = regions->section_start + (addr - rva_bias);
2361
2362   return regions->section_start + (addr - rva_bias) + size;
2363 }
2364
2365 #define max(a,b) ((a) > (b) ? (a) : (b))
2366 #define min(a,b) ((a) < (b) ? (a) : (b))
2367
2368 static bfd_byte *
2369 rsrc_print_resource_directory (FILE *         file,
2370                                bfd *          abfd,
2371                                unsigned int   indent,
2372                                bfd_byte *     data,
2373                                rsrc_regions * regions,
2374                                bfd_vma        rva_bias)
2375 {
2376   unsigned int num_names, num_ids;
2377   bfd_byte * highest_data = data;
2378
2379   if (data + 16 >= regions->section_end)
2380     return regions->section_end + 1;
2381
2382   fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2383   switch (indent)
2384     {
2385     case 0: fprintf (file, "Type"); break;
2386     case 2: fprintf (file, "Name"); break;
2387     case 4: fprintf (file, "Language"); break;
2388     default:
2389       fprintf (file, _("<unknown directory type: %d>\n"), indent);
2390       /* FIXME: For now we end the printing here.  If in the
2391          future more directory types are added to the RSRC spec
2392          then we will need to change this.  */
2393       return regions->section_end + 1;
2394     }
2395
2396   fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2397            (int) bfd_get_32 (abfd, data),
2398            (long) bfd_get_32 (abfd, data + 4),
2399            (int)  bfd_get_16 (abfd, data + 8),
2400            (int)  bfd_get_16 (abfd, data + 10),
2401            num_names = (int) bfd_get_16 (abfd, data + 12),
2402            num_ids =   (int) bfd_get_16 (abfd, data + 14));
2403   data += 16;
2404
2405   while (num_names --)
2406     {
2407       bfd_byte * entry_end;
2408
2409       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2410                                                data, regions, rva_bias);
2411       data += 8;
2412       highest_data = max (highest_data, entry_end);
2413       if (entry_end >= regions->section_end)
2414         return entry_end;
2415     }
2416
2417   while (num_ids --)
2418     {
2419       bfd_byte * entry_end;
2420
2421       entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2422                                                data, regions, rva_bias);
2423       data += 8;
2424       highest_data = max (highest_data, entry_end);
2425       if (entry_end >= regions->section_end)
2426         return entry_end;
2427     }
2428
2429   return max (highest_data, data);
2430 }
2431
2432 /* Display the contents of a .rsrc section.  We do not try to
2433    reproduce the resources, windres does that.  Instead we dump
2434    the tables in a human readable format.  */
2435
2436 static bfd_boolean
2437 rsrc_print_section (bfd * abfd, void * vfile)
2438 {
2439   bfd_vma rva_bias;
2440   pe_data_type * pe;
2441   FILE * file = (FILE *) vfile;
2442   bfd_size_type datasize;
2443   asection * section;
2444   bfd_byte * data;
2445   rsrc_regions regions;
2446
2447   pe = pe_data (abfd);
2448   if (pe == NULL)
2449     return TRUE;
2450
2451   section = bfd_get_section_by_name (abfd, ".rsrc");
2452   if (section == NULL)
2453     return TRUE;
2454   if (!(section->flags & SEC_HAS_CONTENTS))
2455     return TRUE;
2456
2457   datasize = section->size;
2458   if (datasize == 0)
2459     return TRUE;
2460
2461   rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2462
2463   if (! bfd_malloc_and_get_section (abfd, section, & data))
2464     {
2465       if (data != NULL)
2466         free (data);
2467       return FALSE;
2468     }
2469
2470   regions.section_start = data;
2471   regions.section_end = data + datasize;
2472   regions.strings_start = NULL;
2473   regions.resource_start = NULL;
2474
2475   fflush (file);
2476   fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2477
2478   while (data < regions.section_end)
2479     {
2480       bfd_byte * p = data;
2481
2482       data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2483
2484       if (data == regions.section_end + 1)
2485         fprintf (file, _("Corrupt .rsrc section detected!\n"));
2486       else
2487         {
2488           /* Align data before continuing.  */
2489           int align = (1 << section->alignment_power) - 1;
2490
2491           data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2492           rva_bias += data - p;
2493
2494           /* For reasons that are unclear .rsrc sections are sometimes created
2495              aligned to a 1^3 boundary even when their alignment is set at
2496              1^2.  Catch that case here before we issue a spurious warning
2497              message.  */
2498           if (data == (regions.section_end - 4))
2499             data = regions.section_end;
2500           else if (data < regions.section_end)
2501             {
2502               /* If the extra data is all zeros then do not complain.
2503                  This is just padding so that the section meets the
2504                  page size requirements.  */
2505               while (data ++ < regions.section_end)
2506                 if (*data != 0)
2507                   break;
2508               if (data < regions.section_end)
2509                 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2510             }
2511         }
2512     }
2513
2514   if (regions.strings_start != NULL)
2515     fprintf (file, " String table starts at offset: %#03x\n",
2516              (int) (regions.strings_start - regions.section_start));
2517   if (regions.resource_start != NULL)
2518     fprintf (file, " Resources start at offset: %#03x\n",
2519              (int) (regions.resource_start - regions.section_start));
2520   
2521   free (regions.section_start);
2522   return TRUE;
2523 }
2524
2525 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2526
2527 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2528 {
2529   "Unknown",
2530   "COFF",
2531   "CodeView",
2532   "FPO",
2533   "Misc",
2534   "Exception",
2535   "Fixup",
2536   "OMAP-to-SRC",
2537   "OMAP-from-SRC",
2538   "Borland",
2539   "Reserved",
2540   "CLSID",
2541 };
2542
2543 static bfd_boolean
2544 pe_print_debugdata (bfd * abfd, void * vfile)
2545 {
2546   FILE *file = (FILE *) vfile;
2547   pe_data_type *pe = pe_data (abfd);
2548   struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2549   asection *section;
2550   bfd_byte *data = 0;
2551   bfd_size_type dataoff;
2552   unsigned int i;
2553
2554   bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2555   bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2556
2557   if (size == 0)
2558     return TRUE;
2559
2560   addr += extra->ImageBase;
2561   for (section = abfd->sections; section != NULL; section = section->next)
2562     {
2563       if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2564         break;
2565     }
2566
2567   if (section == NULL)
2568     {
2569       fprintf (file,
2570                _("\nThere is a debug directory, but the section containing it could not be found\n"));
2571       return TRUE;
2572     }
2573   else if (!(section->flags & SEC_HAS_CONTENTS))
2574     {
2575       fprintf (file,
2576                _("\nThere is a debug directory in %s, but that section has no contents\n"),
2577                section->name);
2578       return TRUE;
2579     }
2580   else if (section->size < size)
2581     {
2582       fprintf (file,
2583                _("\nError: section %s contains the debug data starting address but it is too small\n"),
2584                section->name);
2585       return FALSE;
2586     }
2587
2588   fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2589            section->name, (unsigned long) addr);
2590
2591   dataoff = addr - section->vma;
2592
2593   if (size > (section->size - dataoff))
2594     {
2595       fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2596       return FALSE;
2597     }
2598
2599   fprintf (file,
2600            _("Type                Size     Rva      Offset\n"));
2601
2602   /* Read the whole section.  */
2603   if (!bfd_malloc_and_get_section (abfd, section, &data))
2604     {
2605       if (data != NULL)
2606         free (data);
2607       return FALSE;
2608     }
2609
2610   for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2611     {
2612       const char *type_name;
2613       struct external_IMAGE_DEBUG_DIRECTORY *ext
2614         = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2615       struct internal_IMAGE_DEBUG_DIRECTORY idd;
2616
2617       _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2618
2619       if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2620         type_name = debug_type_names[0];
2621       else
2622         type_name = debug_type_names[idd.Type];
2623
2624       fprintf (file, " %2ld  %14s %08lx %08lx %08lx\n",
2625                idd.Type, type_name, idd.SizeOfData,
2626                idd.AddressOfRawData, idd.PointerToRawData);
2627
2628       if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2629         {
2630           char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2631           char buffer[256 + 1];
2632           CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2633
2634           /* The debug entry doesn't have to have to be in a section,
2635              in which case AddressOfRawData is 0, so always use PointerToRawData.  */
2636           if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2637                                                idd.SizeOfData, cvinfo))
2638             continue;
2639
2640           for (i = 0; i < cvinfo->SignatureLength; i++)
2641             sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2642
2643           fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2644                    buffer[0], buffer[1], buffer[2], buffer[3],
2645                    signature, cvinfo->Age);
2646         }
2647     }
2648
2649   if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2650     fprintf (file,
2651             _("The debug directory size is not a multiple of the debug directory entry size\n"));
2652
2653   return TRUE;
2654 }
2655
2656 /* Print out the program headers.  */
2657
2658 bfd_boolean
2659 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2660 {
2661   FILE *file = (FILE *) vfile;
2662   int j;
2663   pe_data_type *pe = pe_data (abfd);
2664   struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2665   const char *subsystem_name = NULL;
2666   const char *name;
2667
2668   /* The MS dumpbin program reportedly ands with 0xff0f before
2669      printing the characteristics field.  Not sure why.  No reason to
2670      emulate it here.  */
2671   fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2672 #undef PF
2673 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2674   PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2675   PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2676   PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2677   PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2678   PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2679   PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2680   PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2681   PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2682   PF (IMAGE_FILE_SYSTEM, "system file");
2683   PF (IMAGE_FILE_DLL, "DLL");
2684   PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2685 #undef PF
2686
2687   /* ctime implies '\n'.  */
2688   {
2689     time_t t = pe->coff.timestamp;
2690     fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2691   }
2692
2693 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2694 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2695 #endif
2696 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2697 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2698 #endif
2699 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2700 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2701 #endif
2702
2703   switch (i->Magic)
2704     {
2705     case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2706       name = "PE32";
2707       break;
2708     case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2709       name = "PE32+";
2710       break;
2711     case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2712       name = "ROM";
2713       break;
2714     default:
2715       name = NULL;
2716       break;
2717     }
2718   fprintf (file, "Magic\t\t\t%04x", i->Magic);
2719   if (name)
2720     fprintf (file, "\t(%s)",name);
2721   fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2722   fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2723   fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2724   fprintf (file, "SizeOfInitializedData\t%08lx\n",
2725            (unsigned long) i->SizeOfInitializedData);
2726   fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2727            (unsigned long) i->SizeOfUninitializedData);
2728   fprintf (file, "AddressOfEntryPoint\t");
2729   bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2730   fprintf (file, "\nBaseOfCode\t\t");
2731   bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2732 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2733   /* PE32+ does not have BaseOfData member!  */
2734   fprintf (file, "\nBaseOfData\t\t");
2735   bfd_fprintf_vma (abfd, file, i->BaseOfData);
2736 #endif
2737
2738   fprintf (file, "\nImageBase\t\t");
2739   bfd_fprintf_vma (abfd, file, i->ImageBase);
2740   fprintf (file, "\nSectionAlignment\t");
2741   bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2742   fprintf (file, "\nFileAlignment\t\t");
2743   bfd_fprintf_vma (abfd, file, i->FileAlignment);
2744   fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2745   fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2746   fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2747   fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2748   fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2749   fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2750   fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2751   fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2752   fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2753   fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2754
2755   switch (i->Subsystem)
2756     {
2757     case IMAGE_SUBSYSTEM_UNKNOWN:
2758       subsystem_name = "unspecified";
2759       break;
2760     case IMAGE_SUBSYSTEM_NATIVE:
2761       subsystem_name = "NT native";
2762       break;
2763     case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2764       subsystem_name = "Windows GUI";
2765       break;
2766     case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2767       subsystem_name = "Windows CUI";
2768       break;
2769     case IMAGE_SUBSYSTEM_POSIX_CUI:
2770       subsystem_name = "POSIX CUI";
2771       break;
2772     case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2773       subsystem_name = "Wince CUI";
2774       break;
2775     // These are from UEFI Platform Initialization Specification 1.1.
2776     case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2777       subsystem_name = "EFI application";
2778       break;
2779     case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2780       subsystem_name = "EFI boot service driver";
2781       break;
2782     case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2783       subsystem_name = "EFI runtime driver";
2784       break;
2785     case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2786       subsystem_name = "SAL runtime driver";
2787       break;
2788     // This is from revision 8.0 of the MS PE/COFF spec
2789     case IMAGE_SUBSYSTEM_XBOX:
2790       subsystem_name = "XBOX";
2791       break;
2792     // Added default case for clarity - subsystem_name is NULL anyway.
2793     default:
2794       subsystem_name = NULL;
2795     }
2796
2797   fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2798   if (subsystem_name)
2799     fprintf (file, "\t(%s)", subsystem_name);
2800   fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2801   fprintf (file, "SizeOfStackReserve\t");
2802   bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2803   fprintf (file, "\nSizeOfStackCommit\t");
2804   bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2805   fprintf (file, "\nSizeOfHeapReserve\t");
2806   bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2807   fprintf (file, "\nSizeOfHeapCommit\t");
2808   bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2809   fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2810   fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2811            (unsigned long) i->NumberOfRvaAndSizes);
2812
2813   fprintf (file, "\nThe Data Directory\n");
2814   for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2815     {
2816       fprintf (file, "Entry %1x ", j);
2817       bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2818       fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2819       fprintf (file, "%s\n", dir_names[j]);
2820     }
2821
2822   pe_print_idata (abfd, vfile);
2823   pe_print_edata (abfd, vfile);
2824   if (bfd_coff_have_print_pdata (abfd))
2825     bfd_coff_print_pdata (abfd, vfile);
2826   else
2827     pe_print_pdata (abfd, vfile);
2828   pe_print_reloc (abfd, vfile);
2829   pe_print_debugdata (abfd, file);
2830
2831   rsrc_print_section (abfd, vfile);
2832
2833   return TRUE;
2834 }
2835
2836 static bfd_boolean
2837 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2838 {
2839   bfd_vma addr = * (bfd_vma *) obj;
2840   return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2841 }
2842
2843 static asection *
2844 find_section_by_vma (bfd *abfd, bfd_vma addr)
2845 {
2846   return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2847 }
2848
2849 /* Copy any private info we understand from the input bfd
2850    to the output bfd.  */
2851
2852 bfd_boolean
2853 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2854 {
2855   pe_data_type *ipe, *ope;
2856
2857   /* One day we may try to grok other private data.  */
2858   if (ibfd->xvec->flavour != bfd_target_coff_flavour
2859       || obfd->xvec->flavour != bfd_target_coff_flavour)
2860     return TRUE;
2861
2862   ipe = pe_data (ibfd);
2863   ope = pe_data (obfd);
2864
2865   /* pe_opthdr is copied in copy_object.  */
2866   ope->dll = ipe->dll;
2867
2868   /* Don't copy input subsystem if output is different from input.  */
2869   if (obfd->xvec != ibfd->xvec)
2870     ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2871
2872   /* For strip: if we removed .reloc, we'll make a real mess of things
2873      if we don't remove this entry as well.  */
2874   if (! pe_data (obfd)->has_reloc_section)
2875     {
2876       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2877       pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2878     }
2879
2880   /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2881      But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2882      won't be added.  */
2883   if (! pe_data (ibfd)->has_reloc_section
2884       && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2885     pe_data (obfd)->dont_strip_reloc = 1;
2886
2887   /* The file offsets contained in the debug directory need rewriting.  */
2888   if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2889     {
2890       bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2891         + ope->pe_opthdr.ImageBase;
2892       asection *section = find_section_by_vma (obfd, addr);
2893       bfd_byte *data;
2894
2895       if (section && bfd_malloc_and_get_section (obfd, section, &data))
2896         {
2897           unsigned int i;
2898           struct external_IMAGE_DEBUG_DIRECTORY *dd =
2899             (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2900
2901           for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2902                  / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2903             {
2904               asection *ddsection;
2905               struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
2906               struct internal_IMAGE_DEBUG_DIRECTORY idd;
2907
2908               _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
2909
2910               if (idd.AddressOfRawData == 0)
2911                 continue; /* RVA 0 means only offset is valid, not handled yet.  */
2912
2913               ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
2914               if (!ddsection)
2915                 continue; /* Not in a section! */
2916
2917               idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
2918                                                            + ope->pe_opthdr.ImageBase) - ddsection->vma;
2919
2920               _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
2921             }
2922
2923           if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
2924             _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2925         }
2926     }
2927
2928   return TRUE;
2929 }
2930
2931 /* Copy private section data.  */
2932
2933 bfd_boolean
2934 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2935                                        asection *isec,
2936                                        bfd *obfd,
2937                                        asection *osec)
2938 {
2939   if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2940       || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2941     return TRUE;
2942
2943   if (coff_section_data (ibfd, isec) != NULL
2944       && pei_section_data (ibfd, isec) != NULL)
2945     {
2946       if (coff_section_data (obfd, osec) == NULL)
2947         {
2948           bfd_size_type amt = sizeof (struct coff_section_tdata);
2949           osec->used_by_bfd = bfd_zalloc (obfd, amt);
2950           if (osec->used_by_bfd == NULL)
2951             return FALSE;
2952         }
2953
2954       if (pei_section_data (obfd, osec) == NULL)
2955         {
2956           bfd_size_type amt = sizeof (struct pei_section_tdata);
2957           coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2958           if (coff_section_data (obfd, osec)->tdata == NULL)
2959             return FALSE;
2960         }
2961
2962       pei_section_data (obfd, osec)->virt_size =
2963         pei_section_data (ibfd, isec)->virt_size;
2964       pei_section_data (obfd, osec)->pe_flags =
2965         pei_section_data (ibfd, isec)->pe_flags;
2966     }
2967
2968   return TRUE;
2969 }
2970
2971 void
2972 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2973 {
2974   coff_get_symbol_info (abfd, symbol, ret);
2975 }
2976
2977 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2978 static int
2979 sort_x64_pdata (const void *l, const void *r)
2980 {
2981   const char *lp = (const char *) l;
2982   const char *rp = (const char *) r;
2983   bfd_vma vl, vr;
2984   vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
2985   if (vl != vr)
2986     return (vl < vr ? -1 : 1);
2987   /* We compare just begin address.  */
2988   return 0;
2989 }
2990 #endif
2991 \f
2992 /* Functions to process a .rsrc section.  */
2993
2994 static unsigned int sizeof_leaves;
2995 static unsigned int sizeof_strings;
2996 static unsigned int sizeof_tables_and_entries;
2997
2998 static bfd_byte *
2999 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3000
3001 static bfd_byte *
3002 rsrc_count_entries (bfd *          abfd,
3003                     bfd_boolean    is_name,
3004                     bfd_byte *     datastart,
3005                     bfd_byte *     data,
3006                     bfd_byte *     dataend,
3007                     bfd_vma        rva_bias)
3008 {
3009   unsigned long entry, addr, size;
3010
3011   if (data + 8 >= dataend)
3012     return dataend + 1;
3013
3014   if (is_name)
3015     {
3016       bfd_byte * name;
3017
3018       entry = (long) bfd_get_32 (abfd, data);
3019
3020       if (HighBitSet (entry))
3021         name = datastart + WithoutHighBit (entry);
3022       else
3023         name = datastart + entry - rva_bias;
3024
3025       if (name + 2 >= dataend || name < datastart)
3026         return dataend + 1;
3027
3028       unsigned int len = bfd_get_16 (abfd, name);
3029       if (len == 0 || len > 256)
3030         return dataend + 1;
3031     }
3032
3033   entry = (long) bfd_get_32 (abfd, data + 4);
3034
3035   if (HighBitSet (entry))
3036     {
3037       data = datastart + WithoutHighBit (entry);
3038
3039       if (data <= datastart || data >= dataend)
3040         return dataend + 1;
3041
3042       return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3043     }
3044
3045   if (datastart + entry + 16 >= dataend)
3046     return dataend + 1;
3047
3048   addr = (long) bfd_get_32 (abfd, datastart + entry);
3049   size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3050
3051   return datastart + addr - rva_bias + size;
3052 }
3053
3054 static bfd_byte *
3055 rsrc_count_directory (bfd *          abfd,
3056                       bfd_byte *     datastart,
3057                       bfd_byte *     data,
3058                       bfd_byte *     dataend,
3059                       bfd_vma        rva_bias)
3060 {
3061   unsigned int  num_entries, num_ids;
3062   bfd_byte *    highest_data = data;
3063
3064   if (data + 16 >= dataend)
3065     return dataend + 1;
3066
3067   num_entries  = (int) bfd_get_16 (abfd, data + 12);
3068   num_ids      = (int) bfd_get_16 (abfd, data + 14);
3069
3070   num_entries += num_ids;
3071
3072   data += 16;
3073
3074   while (num_entries --)
3075     {
3076       bfd_byte * entry_end;
3077
3078       entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3079                                       datastart, data, dataend, rva_bias);
3080       data += 8;
3081       highest_data = max (highest_data, entry_end);
3082       if (entry_end >= dataend)
3083         break;
3084     }
3085
3086   return max (highest_data, data);
3087 }
3088
3089 typedef struct rsrc_dir_chain
3090 {
3091   unsigned int         num_entries;
3092   struct rsrc_entry *  first_entry;
3093   struct rsrc_entry *  last_entry;
3094 } rsrc_dir_chain;
3095
3096 typedef struct rsrc_directory
3097 {
3098   unsigned int characteristics;
3099   unsigned int time;
3100   unsigned int major;
3101   unsigned int minor;
3102
3103   rsrc_dir_chain names;
3104   rsrc_dir_chain ids;
3105
3106   struct rsrc_entry * entry;
3107 } rsrc_directory;
3108
3109 typedef struct rsrc_string
3110 {
3111   unsigned int  len;
3112   bfd_byte *    string;
3113 } rsrc_string;
3114
3115 typedef struct rsrc_leaf
3116 {
3117   unsigned int  size;
3118   unsigned int  codepage;
3119   bfd_byte *    data;
3120 } rsrc_leaf;
3121
3122 typedef struct rsrc_entry
3123 {
3124   bfd_boolean is_name;
3125   union
3126   {
3127     unsigned int          id;
3128     struct rsrc_string    name;
3129   } name_id;
3130
3131   bfd_boolean is_dir;
3132   union
3133   {
3134     struct rsrc_directory * directory;
3135     struct rsrc_leaf *      leaf;
3136   } value;
3137
3138   struct rsrc_entry *     next_entry;
3139   struct rsrc_directory * parent;
3140 } rsrc_entry;
3141
3142 static bfd_byte *
3143 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3144                       bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3145
3146 static bfd_byte *
3147 rsrc_parse_entry (bfd *            abfd,
3148                   bfd_boolean      is_name,
3149                   rsrc_entry *     entry,
3150                   bfd_byte *       datastart,
3151                   bfd_byte *       data,
3152                   bfd_byte *       dataend,
3153                   bfd_vma          rva_bias,
3154                   rsrc_directory * parent)
3155 {
3156   unsigned long val, addr, size;
3157
3158   val = bfd_get_32 (abfd, data);
3159
3160   entry->parent = parent;
3161   entry->is_name = is_name;
3162
3163   if (is_name)
3164     {
3165       bfd_byte * address;
3166
3167       if (HighBitSet (val))
3168         {
3169           val = WithoutHighBit (val);
3170
3171           address = datastart + val;
3172         }
3173       else
3174         {
3175           address = datastart + val - rva_bias;
3176         }
3177
3178       if (address + 3 > dataend)
3179         return dataend;
3180
3181       entry->name_id.name.len    = bfd_get_16 (abfd, address);
3182       entry->name_id.name.string = address + 2;
3183     }
3184   else
3185     entry->name_id.id = val;
3186
3187   val = bfd_get_32 (abfd, data + 4);
3188
3189   if (HighBitSet (val))
3190     {
3191       entry->is_dir = TRUE;
3192       entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3193       if (entry->value.directory == NULL)
3194         return dataend;
3195
3196       return rsrc_parse_directory (abfd, entry->value.directory,
3197                                    datastart,
3198                                    datastart + WithoutHighBit (val),
3199                                    dataend, rva_bias, entry);
3200     }
3201
3202   entry->is_dir = FALSE;
3203   entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3204   if (entry->value.leaf == NULL)
3205     return dataend;
3206
3207   addr = bfd_get_32 (abfd, datastart + val);
3208   size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
3209   entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
3210
3211   entry->value.leaf->data = bfd_malloc (size);
3212   if (entry->value.leaf->data == NULL)
3213     return dataend;
3214
3215   memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3216   return datastart + (addr - rva_bias) + size;
3217 }
3218
3219 static bfd_byte *
3220 rsrc_parse_entries (bfd *            abfd,
3221                     rsrc_dir_chain * chain,
3222                     bfd_boolean      is_name,
3223                     bfd_byte *       highest_data,
3224                     bfd_byte *       datastart,
3225                     bfd_byte *       data,
3226                     bfd_byte *       dataend,
3227                     bfd_vma          rva_bias,
3228                     rsrc_directory * parent)
3229 {
3230   unsigned int i;
3231   rsrc_entry * entry;
3232
3233   if (chain->num_entries == 0)
3234     {
3235       chain->first_entry = chain->last_entry = NULL;
3236       return highest_data;
3237     }
3238
3239   entry = bfd_malloc (sizeof * entry);
3240   if (entry == NULL)
3241     return dataend;
3242
3243   chain->first_entry = entry;
3244
3245   for (i = chain->num_entries; i--;)
3246     {
3247       bfd_byte * entry_end;
3248
3249       entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3250                                     data, dataend, rva_bias, parent);
3251       data += 8;
3252       highest_data = max (entry_end, highest_data);
3253       if (entry_end > dataend)
3254         return dataend;
3255
3256       if (i)
3257         {
3258           entry->next_entry = bfd_malloc (sizeof * entry);
3259           entry = entry->next_entry;
3260           if (entry == NULL)
3261             return dataend;
3262         }
3263       else
3264         entry->next_entry = NULL;
3265     }
3266
3267   chain->last_entry = entry;
3268
3269   return highest_data;
3270 }
3271
3272 static bfd_byte *
3273 rsrc_parse_directory (bfd *            abfd,
3274                       rsrc_directory * table,
3275                       bfd_byte *       datastart,
3276                       bfd_byte *       data,
3277                       bfd_byte *       dataend,
3278                       bfd_vma          rva_bias,
3279                       rsrc_entry *     entry)
3280 {
3281   bfd_byte * highest_data = data;
3282
3283   if (table == NULL)
3284     return dataend;
3285
3286   table->characteristics = bfd_get_32 (abfd, data);
3287   table->time = bfd_get_32 (abfd, data + 4);
3288   table->major = bfd_get_16 (abfd, data + 8);
3289   table->minor = bfd_get_16 (abfd, data + 10);
3290   table->names.num_entries = bfd_get_16 (abfd, data + 12);
3291   table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3292   table->entry = entry;
3293
3294   data += 16;
3295
3296   highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3297                                      datastart, data, dataend, rva_bias, table);
3298   data += table->names.num_entries * 8;
3299
3300   highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3301                                      datastart, data, dataend, rva_bias, table);
3302   data += table->ids.num_entries * 8;
3303
3304   return max (highest_data, data);
3305 }
3306
3307 typedef struct rsrc_write_data
3308 {
3309   bfd *      abfd;
3310   bfd_byte * datastart;
3311   bfd_byte * next_table;
3312   bfd_byte * next_leaf;
3313   bfd_byte * next_string;
3314   bfd_byte * next_data;
3315   bfd_vma    rva_bias;
3316 } rsrc_write_data;
3317
3318 static void
3319 rsrc_write_string (rsrc_write_data * data,
3320                    rsrc_string *     string)
3321 {
3322   bfd_put_16 (data->abfd, string->len, data->next_string);
3323   memcpy (data->next_string + 2, string->string, string->len * 2);
3324   data->next_string += (string->len + 1) * 2;
3325 }
3326
3327 static inline unsigned int
3328 rsrc_compute_rva (rsrc_write_data * data,
3329                   bfd_byte *        addr)
3330 {
3331   return (addr - data->datastart) + data->rva_bias;
3332 }
3333
3334 static void
3335 rsrc_write_leaf (rsrc_write_data * data,
3336                  rsrc_leaf *       leaf)
3337 {
3338   bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3339               data->next_leaf);
3340   bfd_put_32 (data->abfd, leaf->size,     data->next_leaf + 4);
3341   bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3342   bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3343   data->next_leaf += 16;
3344
3345   memcpy (data->next_data, leaf->data, leaf->size);
3346   /* An undocumented feature of Windows resources is that each unit
3347      of raw data is 8-byte aligned...  */
3348   data->next_data += ((leaf->size + 7) & ~7);
3349 }
3350
3351 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3352
3353 static void
3354 rsrc_write_entry (rsrc_write_data *  data,
3355                   bfd_byte *         where,
3356                   rsrc_entry *       entry)
3357 {
3358   if (entry->is_name)
3359     {
3360       bfd_put_32 (data->abfd,
3361                   SetHighBit (data->next_string - data->datastart),
3362                   where);
3363       rsrc_write_string (data, & entry->name_id.name);
3364     }
3365   else
3366     bfd_put_32 (data->abfd, entry->name_id.id, where);
3367
3368   if (entry->is_dir)
3369     {
3370       bfd_put_32 (data->abfd,
3371                   SetHighBit (data->next_table - data->datastart),
3372                   where + 4);
3373       rsrc_write_directory (data, entry->value.directory);
3374     }
3375   else
3376     {
3377       bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3378       rsrc_write_leaf (data, entry->value.leaf);
3379     }
3380 }
3381
3382 static void
3383 rsrc_compute_region_sizes (rsrc_directory * dir)
3384 {
3385   struct rsrc_entry * entry;
3386
3387   if (dir == NULL)
3388     return;
3389
3390   sizeof_tables_and_entries += 16;
3391
3392   for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3393     {
3394       sizeof_tables_and_entries += 8;
3395
3396       sizeof_strings += (entry->name_id.name.len + 1) * 2;
3397           
3398       if (entry->is_dir)
3399         rsrc_compute_region_sizes (entry->value.directory);
3400       else
3401         sizeof_leaves += 16;
3402     }
3403
3404   for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3405     {
3406       sizeof_tables_and_entries += 8;
3407
3408       if (entry->is_dir)
3409         rsrc_compute_region_sizes (entry->value.directory);
3410       else
3411         sizeof_leaves += 16;
3412     }
3413 }
3414
3415 static void
3416 rsrc_write_directory (rsrc_write_data * data,
3417                       rsrc_directory *  dir)
3418 {
3419   rsrc_entry * entry;
3420   unsigned int i;
3421   bfd_byte * next_entry;
3422   bfd_byte * nt;
3423
3424   bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3425   bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3426   bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3427   bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3428   bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3429   bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3430
3431   /* Compute where the entries and the next table will be placed.  */
3432   next_entry = data->next_table + 16;
3433   data->next_table = next_entry + (dir->names.num_entries * 8)
3434     + (dir->ids.num_entries * 8);
3435   nt = data->next_table;
3436
3437   /* Write the entries.  */
3438   for (i = dir->names.num_entries, entry = dir->names.first_entry;
3439        i > 0 && entry != NULL;
3440        i--, entry = entry->next_entry)
3441     {
3442       BFD_ASSERT (entry->is_name);
3443       rsrc_write_entry (data, next_entry, entry);
3444       next_entry += 8;
3445     }
3446   BFD_ASSERT (i == 0);
3447   BFD_ASSERT (entry == NULL);
3448
3449   for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3450        i > 0 && entry != NULL;
3451        i--, entry = entry->next_entry)
3452     {
3453       BFD_ASSERT (! entry->is_name);
3454       rsrc_write_entry (data, next_entry, entry);
3455       next_entry += 8;
3456     }
3457   BFD_ASSERT (i == 0);
3458   BFD_ASSERT (entry == NULL);
3459   BFD_ASSERT (nt == next_entry);
3460 }
3461
3462 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3463 /* Return the length (number of units) of the first character in S,
3464    putting its 'ucs4_t' representation in *PUC.  */
3465
3466 static unsigned int
3467 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3468 {
3469   unsigned short c = * s;
3470
3471   if (c < 0xd800 || c >= 0xe000)
3472     {
3473       *puc = c;
3474       return 1;
3475     }
3476
3477   if (c < 0xdc00)
3478     {
3479       if (n >= 2)
3480         {
3481           if (s[1] >= 0xdc00 && s[1] < 0xe000)
3482             {
3483               *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3484               return 2;
3485             }
3486         }
3487       else
3488         {
3489           /* Incomplete multibyte character.  */
3490           *puc = 0xfffd;
3491           return n;
3492         }
3493     }
3494
3495   /* Invalid multibyte character.  */
3496   *puc = 0xfffd;
3497   return 1;
3498 }
3499 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3500
3501 /* Perform a comparison of two entries.  */
3502 static signed int
3503 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3504 {
3505   signed int    res;
3506   bfd_byte *    astring;
3507   unsigned int  alen;
3508   bfd_byte *    bstring;
3509   unsigned int  blen;
3510
3511   if (! is_name)
3512     return a->name_id.id - b->name_id.id;
3513
3514   /* We have to perform a case insenstive, unicode string comparison...  */
3515   astring = a->name_id.name.string;
3516   alen    = a->name_id.name.len;
3517   bstring = b->name_id.name.string;
3518   blen    = b->name_id.name.len;
3519
3520 #if defined  __CYGWIN__ || defined __MINGW32__
3521   /* Under Windows hosts (both Cygwin and Mingw types),
3522      unicode == UTF-16 == wchar_t.  The case insensitive string comparison
3523      function however goes by different names in the two environments...  */
3524
3525 #undef rscpcmp
3526 #ifdef __CYGWIN__
3527 #define rscpcmp wcsncasecmp
3528 #endif
3529 #ifdef __MINGW32__
3530 #define rscpcmp wcsnicmp
3531 #endif
3532
3533   res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3534                  min (alen, blen));
3535
3536 #elif defined HAVE_WCHAR_H
3537   {
3538     unsigned int  i;
3539     res = 0;
3540     for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3541       {
3542         wchar_t awc;
3543         wchar_t bwc;
3544
3545         /* Convert UTF-16 unicode characters into wchar_t characters so
3546            that we can then perform a case insensitive comparison.  */
3547         int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3548         int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3549
3550         if (Alen != Blen)
3551           return Alen - Blen;
3552         res = wcsncasecmp (& awc, & bwc, 1);
3553         if (res)
3554           break;
3555       }
3556   }
3557 #else
3558   /* Do the best we can - a case sensitive, untranslated comparison.  */
3559   res = memcmp (astring, bstring, min (alen, blen) * 2);
3560 #endif
3561
3562   if (res == 0)
3563     res = alen - blen;
3564
3565   return res;
3566 }
3567
3568 static void
3569 rsrc_print_name (char * buffer, rsrc_string string)
3570 {
3571   unsigned int  i;
3572   bfd_byte *    name = string.string;
3573
3574   for (i = string.len; i--; name += 2)
3575     sprintf (buffer + strlen (buffer), "%.1s", name);
3576 }
3577
3578 static const char *
3579 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3580 {
3581   static char buffer [256];
3582   bfd_boolean is_string = FALSE;
3583
3584   buffer[0] = 0;
3585
3586   if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3587       && dir->entry->parent->entry != NULL)
3588     {
3589       strcpy (buffer, "type: ");
3590       if (dir->entry->parent->entry->is_name)
3591         rsrc_print_name (buffer + strlen (buffer),
3592                          dir->entry->parent->entry->name_id.name);
3593       else
3594         {
3595           unsigned int id = dir->entry->parent->entry->name_id.id;
3596
3597           sprintf (buffer + strlen (buffer), "%x", id);
3598           switch (id)
3599             {
3600             case 1: strcat (buffer, " (CURSOR)"); break;
3601             case 2: strcat (buffer, " (BITMAP)"); break;
3602             case 3: strcat (buffer, " (ICON)"); break;
3603             case 4: strcat (buffer, " (MENU)"); break;
3604             case 5: strcat (buffer, " (DIALOG)"); break;
3605             case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3606             case 7: strcat (buffer, " (FONTDIR)"); break;
3607             case 8: strcat (buffer, " (FONT)"); break;
3608             case 9: strcat (buffer, " (ACCELERATOR)"); break;
3609             case 10: strcat (buffer, " (RCDATA)"); break;
3610             case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3611             case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3612             case 14: strcat (buffer, " (GROUP_ICON)"); break;
3613             case 16: strcat (buffer, " (VERSION)"); break;
3614             case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3615             case 19: strcat (buffer, " (PLUGPLAY)"); break;
3616             case 20: strcat (buffer, " (VXD)"); break;
3617             case 21: strcat (buffer, " (ANICURSOR)"); break;
3618             case 22: strcat (buffer, " (ANIICON)"); break;
3619             case 23: strcat (buffer, " (HTML)"); break;
3620             case 24: strcat (buffer, " (MANIFEST)"); break;
3621             case 240: strcat (buffer, " (DLGINIT)"); break;
3622             case 241: strcat (buffer, " (TOOLBAR)"); break;
3623             }
3624         }
3625     }
3626
3627   if (dir != NULL && dir->entry != NULL)
3628     {
3629       strcat (buffer, " name: ");
3630       if (dir->entry->is_name)
3631         rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3632       else
3633         {
3634           unsigned int id = dir->entry->name_id.id;
3635
3636           sprintf (buffer + strlen (buffer), "%x", id);
3637
3638           if (is_string)
3639             sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3640                      (id - 1) << 4, (id << 4) - 1);
3641         }
3642     }
3643
3644   if (entry != NULL)
3645     {
3646       strcat (buffer, " lang: ");
3647
3648       if (entry->is_name)
3649         rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3650       else
3651         sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3652     }
3653
3654   return buffer;
3655 }
3656
3657 /* *sigh* Windows resource strings are special.  Only the top 28-bits of
3658    their ID is stored in the NAME entry.  The bottom four bits are used as
3659    an index into unicode string table that makes up the data of the leaf.
3660    So identical type-name-lang string resources may not actually be
3661    identical at all.
3662
3663    This function is called when we have detected two string resources with
3664    match top-28-bit IDs.  We have to scan the string tables inside the leaves
3665    and discover if there are any real collisions.  If there are then we report
3666    them and return FALSE.  Otherwise we copy any strings from B into A and
3667    then return TRUE.  */
3668
3669 static bfd_boolean
3670 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3671                            rsrc_entry * b ATTRIBUTE_UNUSED)
3672 {
3673   unsigned int copy_needed = 0;
3674   unsigned int i;
3675   bfd_byte * astring;
3676   bfd_byte * bstring;
3677   bfd_byte * new_data;
3678   bfd_byte * nstring;
3679
3680   /* Step one: Find out what we have to do.  */
3681   BFD_ASSERT (! a->is_dir);
3682   astring = a->value.leaf->data;
3683
3684   BFD_ASSERT (! b->is_dir);
3685   bstring = b->value.leaf->data;
3686
3687   for (i = 0; i < 16; i++)
3688     {
3689       unsigned int alen = astring[0] + (astring[1] << 8);
3690       unsigned int blen = bstring[0] + (bstring[1] << 8);
3691
3692       if (alen == 0)
3693         {
3694           copy_needed += blen * 2;
3695         }
3696       else if (blen == 0)
3697         ;
3698       else if (alen != blen)
3699         /* FIXME: Should we continue the loop in order to report other duplicates ?  */
3700         break;
3701       /* alen == blen != 0.  We might have two identical strings.  If so we
3702          can ignore the second one.  There is no need for wchar_t vs UTF-16
3703          theatrics here - we are only interested in (case sensitive) equality.  */
3704       else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3705         break;
3706
3707       astring += (alen + 1) * 2;
3708       bstring += (blen + 1) * 2;
3709     }
3710
3711   if (i != 16)
3712     {
3713       if (a->parent != NULL
3714           && a->parent->entry != NULL
3715           && a->parent->entry->is_name == FALSE)
3716         _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3717                             ((a->parent->entry->name_id.id - 1) << 4) + i);
3718       return FALSE;
3719     }
3720
3721   if (copy_needed == 0)
3722     return TRUE;
3723
3724   /* If we reach here then A and B must both have non-colliding strings.
3725      (We never get string resources with fully empty string tables).
3726      We need to allocate an extra COPY_NEEDED bytes in A and then bring
3727      in B's strings.  */
3728   new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3729   if (new_data == NULL)
3730     return FALSE;
3731
3732   nstring = new_data;
3733   astring = a->value.leaf->data;
3734   bstring = b->value.leaf->data;
3735
3736   for (i = 0; i < 16; i++)
3737     {
3738       unsigned int alen = astring[0] + (astring[1] << 8);
3739       unsigned int blen = bstring[0] + (bstring[1] << 8);
3740
3741       if (alen != 0)
3742         {
3743           memcpy (nstring, astring, (alen + 1) * 2);
3744           nstring += (alen + 1) * 2;
3745         }
3746       else if (blen != 0)
3747         {
3748           memcpy (nstring, bstring, (blen + 1) * 2);
3749           nstring += (blen + 1) * 2;
3750         }
3751       else
3752         {
3753           * nstring++ = 0;
3754           * nstring++ = 0;
3755         }
3756
3757       astring += (alen + 1) * 2;
3758       bstring += (blen + 1) * 2;
3759     }
3760
3761   BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3762
3763   free (a->value.leaf->data);
3764   a->value.leaf->data = new_data;
3765   a->value.leaf->size += copy_needed;
3766
3767   return TRUE;
3768 }
3769
3770 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3771
3772 /* Sort the entries in given part of the directory.
3773    We use an old fashioned bubble sort because we are dealing
3774    with lists and we want to handle matches specially.  */
3775
3776 static void
3777 rsrc_sort_entries (rsrc_dir_chain *  chain,
3778                    bfd_boolean       is_name,
3779                    rsrc_directory *  dir)
3780 {
3781   rsrc_entry * entry;
3782   rsrc_entry * next;
3783   rsrc_entry ** points_to_entry;
3784   bfd_boolean swapped;
3785
3786   if (chain->num_entries < 2)
3787     return;
3788
3789   do
3790     {
3791       swapped = FALSE;
3792       points_to_entry = & chain->first_entry;
3793       entry = * points_to_entry;
3794       next  = entry->next_entry;
3795
3796       do
3797         {
3798           signed int cmp = rsrc_cmp (is_name, entry, next);
3799
3800           if (cmp > 0)
3801             {
3802               entry->next_entry = next->next_entry;
3803               next->next_entry = entry;
3804               * points_to_entry = next;
3805               points_to_entry = & next->next_entry;
3806               next = entry->next_entry;
3807               swapped = TRUE;
3808             }
3809           else if (cmp == 0)
3810             {
3811               if (entry->is_dir && next->is_dir)
3812                 {
3813                   /* When we encounter identical directory entries we have to
3814                      merge them together.  The exception to this rule is for
3815                      resource manifests - there can only be one of these,
3816                      even if they differ in language.  Zero-language manifests
3817                      are assumed to be default manifests (provided by the
3818                      Cygwin/MinGW build system) and these can be silently dropped,
3819                      unless that would reduce the number of manifests to zero.
3820                      There should only ever be one non-zero lang manifest -
3821                      if there are more it is an error.  A non-zero lang
3822                      manifest takes precedence over a default manifest.  */
3823                   if (entry->is_name == FALSE
3824                       && entry->name_id.id == 1
3825                       && dir != NULL
3826                       && dir->entry != NULL
3827                       && dir->entry->is_name == FALSE
3828                       && dir->entry->name_id.id == 0x18)
3829                     {
3830                       if (next->value.directory->names.num_entries == 0
3831                           && next->value.directory->ids.num_entries == 1
3832                           && next->value.directory->ids.first_entry->is_name == FALSE
3833                           && next->value.directory->ids.first_entry->name_id.id == 0)
3834                         /* Fall through so that NEXT is dropped.  */
3835                         ;
3836                       else if (entry->value.directory->names.num_entries == 0
3837                                && entry->value.directory->ids.num_entries == 1
3838                                && entry->value.directory->ids.first_entry->is_name == FALSE
3839                                && entry->value.directory->ids.first_entry->name_id.id == 0)
3840                         {
3841                           /* Swap ENTRY and NEXT.  Then fall through so that the old ENTRY is dropped.  */
3842                           entry->next_entry = next->next_entry;
3843                           next->next_entry = entry;
3844                           * points_to_entry = next;
3845                           points_to_entry = & next->next_entry;
3846                           next = entry->next_entry;
3847                           swapped = TRUE;
3848                         }
3849                       else
3850                         {
3851                           _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3852                           bfd_set_error (bfd_error_file_truncated);
3853                           return;
3854                         }
3855
3856                       /* Unhook NEXT from the chain.  */
3857                       /* FIXME: memory loss here.  */
3858                       entry->next_entry = next->next_entry;
3859                       chain->num_entries --;
3860                       if (chain->num_entries < 2)
3861                         return;
3862                       next = next->next_entry;
3863                     }
3864                   else
3865                     rsrc_merge (entry, next);
3866                 }
3867               else if (entry->is_dir != next->is_dir)
3868                 {
3869                   _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3870                   bfd_set_error (bfd_error_file_truncated);
3871                   return;
3872                 }
3873               else
3874                 {
3875                   /* Otherwise with identical leaves we issue an error
3876                      message - because there should never be duplicates.
3877                      The exception is Type 18/Name 1/Lang 0 which is the
3878                      defaul manifest - this can just be dropped.  */
3879                   if (entry->is_name == FALSE
3880                       && entry->name_id.id == 0
3881                       && dir != NULL
3882                       && dir->entry != NULL
3883                       && dir->entry->is_name == FALSE
3884                       && dir->entry->name_id.id == 1
3885                       && dir->entry->parent != NULL
3886                       && dir->entry->parent->entry != NULL
3887                       && dir->entry->parent->entry->is_name == FALSE
3888                       && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3889                     ;
3890                   else if (dir != NULL
3891                            && dir->entry != NULL
3892                            && dir->entry->parent != NULL
3893                            && dir->entry->parent->entry != NULL
3894                            && dir->entry->parent->entry->is_name == FALSE
3895                            && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3896                     {
3897                       /* Strings need special handling.  */
3898                       if (! rsrc_merge_string_entries (entry, next))
3899                         {
3900                           /* _bfd_error_handler should have been called inside merge_strings.  */
3901                           bfd_set_error (bfd_error_file_truncated);
3902                           return;
3903                         }
3904                     }
3905                   else
3906                     {
3907                       if (dir == NULL
3908                           || dir->entry == NULL
3909                           || dir->entry->parent == NULL
3910                           || dir->entry->parent->entry == NULL)
3911                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3912                       else
3913                         _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3914                                             rsrc_resource_name (entry, dir));
3915                       bfd_set_error (bfd_error_file_truncated);
3916                       return;
3917                     }
3918                 }
3919
3920               /* Unhook NEXT from the chain.  */
3921               entry->next_entry = next->next_entry;
3922               chain->num_entries --;
3923               if (chain->num_entries < 2)
3924                 return;
3925               next = next->next_entry;
3926             }
3927           else
3928             {
3929               points_to_entry = & entry->next_entry;
3930               entry = next;
3931               next = next->next_entry;
3932             }
3933         }
3934       while (next);
3935
3936       chain->last_entry = entry;
3937     }
3938   while (swapped);
3939 }
3940
3941 /* Attach B's chain onto A.  */
3942 static void
3943 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
3944 {
3945   if (bchain->num_entries == 0)
3946     return;
3947
3948   achain->num_entries += bchain->num_entries;
3949
3950   if (achain->first_entry == NULL)
3951     {
3952       achain->first_entry = bchain->first_entry;
3953       achain->last_entry  = bchain->last_entry;
3954     }
3955   else
3956     {
3957       achain->last_entry->next_entry = bchain->first_entry;
3958       achain->last_entry = bchain->last_entry;
3959     }
3960
3961   bchain->num_entries = 0;
3962   bchain->first_entry = bchain->last_entry = NULL;
3963 }
3964
3965 static void
3966 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
3967 {
3968   rsrc_directory * adir;
3969   rsrc_directory * bdir;
3970
3971   BFD_ASSERT (a->is_dir);
3972   BFD_ASSERT (b->is_dir);
3973
3974   adir = a->value.directory;
3975   bdir = b->value.directory;
3976
3977   if (adir->characteristics != bdir->characteristics)
3978     {
3979       _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3980       bfd_set_error (bfd_error_file_truncated);
3981       return;
3982     }
3983
3984   if (adir->major != bdir->major || adir->minor != bdir->minor)
3985     {
3986       _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3987       bfd_set_error (bfd_error_file_truncated);
3988       return;
3989     }
3990
3991   /* Attach B's name chain to A.  */
3992   rsrc_attach_chain (& adir->names, & bdir->names);
3993
3994   /* Attach B's ID chain to A.  */
3995   rsrc_attach_chain (& adir->ids, & bdir->ids);
3996
3997   /* Now sort A's entries.  */
3998   rsrc_sort_entries (& adir->names, TRUE, adir);
3999   rsrc_sort_entries (& adir->ids, FALSE, adir);
4000 }
4001
4002 /* Check the .rsrc section.  If it contains multiple concatenated
4003    resources then we must merge them properly.  Otherwise Windows
4004    will ignore all but the first set.  */
4005
4006 static void
4007 rsrc_process_section (bfd * abfd,
4008                       struct coff_final_link_info * pfinfo)
4009 {
4010   rsrc_directory    new_table;
4011   bfd_size_type     size;
4012   asection *        sec;
4013   pe_data_type *    pe;
4014   bfd_vma           rva_bias;
4015   bfd_byte *        data;
4016   bfd_byte *        datastart;
4017   bfd_byte *        dataend;
4018   bfd_byte *        new_data;
4019   unsigned int      num_resource_sets;
4020   rsrc_directory *  type_tables;
4021   rsrc_write_data   write_data;
4022   unsigned int      indx;
4023   bfd *             input;
4024   unsigned int      num_input_rsrc = 0;
4025   unsigned int      max_num_input_rsrc = 4;
4026   ptrdiff_t *       rsrc_sizes = NULL;
4027
4028   new_table.names.num_entries = 0;
4029   new_table.ids.num_entries = 0;
4030
4031   sec = bfd_get_section_by_name (abfd, ".rsrc");
4032   if (sec == NULL || (size = sec->rawsize) == 0)
4033     return;
4034
4035   pe = pe_data (abfd);
4036   if (pe == NULL)
4037     return;
4038
4039   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4040
4041   data = bfd_malloc (size);
4042   if (data == NULL)
4043     return;
4044
4045   datastart = data;
4046
4047   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4048     goto end;
4049
4050   /* Step zero: Scan the input bfds looking for .rsrc sections and record
4051      their lengths.  Note - we rely upon the fact that the linker script
4052      does *not* sort the input .rsrc sections, so that the order in the
4053      linkinfo list matches the order in the output .rsrc section.
4054
4055      We need to know the lengths because each input .rsrc section has padding
4056      at the end of a variable amount.  (It does not appear to be based upon
4057      the section alignment or the file alignment).  We need to skip any
4058      padding bytes when parsing the input .rsrc sections.  */
4059   rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4060   if (rsrc_sizes == NULL)
4061     goto end;
4062
4063   for (input = pfinfo->info->input_bfds;
4064        input != NULL;
4065        input = input->link.next)
4066     {
4067       asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4068
4069       if (rsrc_sec != NULL)
4070         {
4071           if (num_input_rsrc == max_num_input_rsrc)
4072             {
4073               max_num_input_rsrc += 10;
4074               rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4075                                         * sizeof * rsrc_sizes);
4076               if (rsrc_sizes == NULL)
4077                 goto end;
4078             }
4079
4080           BFD_ASSERT (rsrc_sec->size > 0);
4081           rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4082         }
4083     }
4084
4085   if (num_input_rsrc < 2)
4086     goto end;
4087
4088   /* Step one: Walk the section, computing the size of the tables,
4089      leaves and data and decide if we need to do anything.  */
4090   dataend = data + size;
4091   num_resource_sets = 0;
4092
4093   while (data < dataend)
4094     {
4095       bfd_byte * p = data;
4096
4097       data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4098
4099       if (data > dataend)
4100         {
4101           /* Corrupted .rsrc section - cannot merge.  */
4102           _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4103                               bfd_get_filename (abfd));
4104           bfd_set_error (bfd_error_file_truncated);
4105           goto end;
4106         }
4107
4108       if ((data - p) > rsrc_sizes [num_resource_sets])
4109         {
4110           _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4111                               bfd_get_filename (abfd));
4112           bfd_set_error (bfd_error_file_truncated);
4113           goto end;
4114         }
4115       /* FIXME: Should we add a check for "data - p" being much smaller
4116          than rsrc_sizes[num_resource_sets] ?  */
4117
4118       data = p + rsrc_sizes[num_resource_sets];
4119       rva_bias += data - p;
4120       ++ num_resource_sets;
4121     }
4122   BFD_ASSERT (num_resource_sets == num_input_rsrc);
4123
4124   /* Step two: Walk the data again, building trees of the resources.  */
4125   data = datastart;
4126   rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4127
4128   type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4129   if (type_tables == NULL)
4130     goto end;
4131
4132   indx = 0;
4133   while (data < dataend)
4134     {
4135       bfd_byte * p = data;
4136
4137       (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4138                                    dataend, rva_bias, NULL);
4139       data = p + rsrc_sizes[indx];
4140       rva_bias += data - p;
4141       ++ indx;
4142     }
4143   BFD_ASSERT (indx == num_resource_sets);
4144
4145   /* Step three: Merge the top level tables (there can be only one).
4146
4147      We must ensure that the merged entries are in ascending order.
4148
4149      We also thread the top level table entries from the old tree onto
4150      the new table, so that they can be pulled off later.  */
4151
4152   /* FIXME: Should we verify that all type tables are the same ?  */
4153   new_table.characteristics = type_tables[0].characteristics;
4154   new_table.time            = type_tables[0].time;
4155   new_table.major           = type_tables[0].major;
4156   new_table.minor           = type_tables[0].minor;
4157
4158   /* Chain the NAME entries onto the table.  */
4159   new_table.names.first_entry = NULL;
4160   new_table.names.last_entry = NULL;
4161
4162   for (indx = 0; indx < num_resource_sets; indx++)
4163     rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4164
4165   rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4166
4167   /* Chain the ID entries onto the table.  */
4168   new_table.ids.first_entry = NULL;
4169   new_table.ids.last_entry = NULL;
4170
4171   for (indx = 0; indx < num_resource_sets; indx++)
4172     rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4173
4174   rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4175
4176   /* Step four: Create new contents for the .rsrc section.  */
4177   /* Step four point one: Compute the size of each region of the .rsrc section.
4178      We do this now, rather than earlier, as the merging above may have dropped
4179      some entries.  */
4180   sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4181   rsrc_compute_region_sizes (& new_table);
4182   /* We increment sizeof_strings to make sure that resource data
4183      starts on an 8-byte boundary.  FIXME: Is this correct ?  */
4184   sizeof_strings = (sizeof_strings + 7) & ~ 7;
4185
4186   new_data = bfd_zalloc (abfd, size);
4187   if (new_data == NULL)
4188     goto end;
4189
4190   write_data.abfd        = abfd;
4191   write_data.datastart   = new_data;
4192   write_data.next_table  = new_data;
4193   write_data.next_leaf   = new_data + sizeof_tables_and_entries;
4194   write_data.next_string = write_data.next_leaf + sizeof_leaves;
4195   write_data.next_data   = write_data.next_string + sizeof_strings;
4196   write_data.rva_bias    = sec->vma - pe->pe_opthdr.ImageBase;
4197
4198   rsrc_write_directory (& write_data, & new_table);
4199
4200   /* Step five: Replace the old contents with the new.
4201      We recompute the size as we may have lost entries due to mergeing.  */
4202   size = ((write_data.next_data - new_data) + 3) & ~ 3;
4203
4204   {
4205     int page_size;
4206
4207     if (coff_data (abfd)->link_info)
4208       {
4209         page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
4210
4211         /* If no file alignment has been set, default to one.
4212            This repairs 'ld -r' for arm-wince-pe target.  */
4213         if (page_size == 0)
4214           page_size = 1;
4215       }
4216     else
4217       page_size = PE_DEF_FILE_ALIGNMENT;
4218     size = (size + page_size - 1) & - page_size;
4219   }
4220
4221   bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4222   sec->size = sec->rawsize = size;
4223
4224  end:
4225   /* Step six: Free all the memory that we have used.  */
4226   /* FIXME: Free the resource tree, if we have one.  */
4227   free (datastart);
4228   free (rsrc_sizes);
4229 }
4230
4231 /* Handle the .idata section and other things that need symbol table
4232    access.  */
4233
4234 bfd_boolean
4235 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4236 {
4237   struct coff_link_hash_entry *h1;
4238   struct bfd_link_info *info = pfinfo->info;
4239   bfd_boolean result = TRUE;
4240
4241   /* There are a few fields that need to be filled in now while we
4242      have symbol table access.
4243
4244      The .idata subsections aren't directly available as sections, but
4245      they are in the symbol table, so get them from there.  */
4246
4247   /* The import directory.  This is the address of .idata$2, with size
4248      of .idata$2 + .idata$3.  */
4249   h1 = coff_link_hash_lookup (coff_hash_table (info),
4250                               ".idata$2", FALSE, FALSE, TRUE);
4251   if (h1 != NULL)
4252     {
4253       /* PR ld/2729: We cannot rely upon all the output sections having been
4254          created properly, so check before referencing them.  Issue a warning
4255          message for any sections tht could not be found.  */
4256       if ((h1->root.type == bfd_link_hash_defined
4257            || h1->root.type == bfd_link_hash_defweak)
4258           && h1->root.u.def.section != NULL
4259           && h1->root.u.def.section->output_section != NULL)
4260         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4261           (h1->root.u.def.value
4262            + h1->root.u.def.section->output_section->vma
4263            + h1->root.u.def.section->output_offset);
4264       else
4265         {
4266           _bfd_error_handler
4267             (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4268              abfd);
4269           result = FALSE;
4270         }
4271
4272       h1 = coff_link_hash_lookup (coff_hash_table (info),
4273                                   ".idata$4", FALSE, FALSE, TRUE);
4274       if (h1 != NULL
4275           && (h1->root.type == bfd_link_hash_defined
4276            || h1->root.type == bfd_link_hash_defweak)
4277           && h1->root.u.def.section != NULL
4278           && h1->root.u.def.section->output_section != NULL)
4279         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4280           ((h1->root.u.def.value
4281             + h1->root.u.def.section->output_section->vma
4282             + h1->root.u.def.section->output_offset)
4283            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4284       else
4285         {
4286           _bfd_error_handler
4287             (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4288              abfd);
4289           result = FALSE;
4290         }
4291
4292       /* The import address table.  This is the size/address of
4293          .idata$5.  */
4294       h1 = coff_link_hash_lookup (coff_hash_table (info),
4295                                   ".idata$5", FALSE, FALSE, TRUE);
4296       if (h1 != NULL
4297           && (h1->root.type == bfd_link_hash_defined
4298            || h1->root.type == bfd_link_hash_defweak)
4299           && h1->root.u.def.section != NULL
4300           && h1->root.u.def.section->output_section != NULL)
4301         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4302           (h1->root.u.def.value
4303            + h1->root.u.def.section->output_section->vma
4304            + h1->root.u.def.section->output_offset);
4305       else
4306         {
4307           _bfd_error_handler
4308             (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4309              abfd);
4310           result = FALSE;
4311         }
4312
4313       h1 = coff_link_hash_lookup (coff_hash_table (info),
4314                                   ".idata$6", FALSE, FALSE, TRUE);
4315       if (h1 != NULL
4316           && (h1->root.type == bfd_link_hash_defined
4317            || h1->root.type == bfd_link_hash_defweak)
4318           && h1->root.u.def.section != NULL
4319           && h1->root.u.def.section->output_section != NULL)
4320         pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4321           ((h1->root.u.def.value
4322             + h1->root.u.def.section->output_section->vma
4323             + h1->root.u.def.section->output_offset)
4324            - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4325       else
4326         {
4327           _bfd_error_handler
4328             (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4329              abfd);
4330           result = FALSE;
4331         }
4332     }
4333   else
4334     {
4335       h1 = coff_link_hash_lookup (coff_hash_table (info),
4336                                   "__IAT_start__", FALSE, FALSE, TRUE);
4337       if (h1 != NULL
4338           && (h1->root.type == bfd_link_hash_defined
4339            || h1->root.type == bfd_link_hash_defweak)
4340           && h1->root.u.def.section != NULL
4341           && h1->root.u.def.section->output_section != NULL)
4342         {
4343           bfd_vma iat_va;
4344
4345           iat_va =
4346             (h1->root.u.def.value
4347              + h1->root.u.def.section->output_section->vma
4348              + h1->root.u.def.section->output_offset);
4349
4350           h1 = coff_link_hash_lookup (coff_hash_table (info),
4351                                       "__IAT_end__", FALSE, FALSE, TRUE);
4352           if (h1 != NULL
4353               && (h1->root.type == bfd_link_hash_defined
4354                || h1->root.type == bfd_link_hash_defweak)
4355               && h1->root.u.def.section != NULL
4356               && h1->root.u.def.section->output_section != NULL)
4357             {
4358               pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4359                 ((h1->root.u.def.value
4360                   + h1->root.u.def.section->output_section->vma
4361                   + h1->root.u.def.section->output_offset)
4362                  - iat_va);
4363               if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4364                 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4365                   iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4366             }
4367           else
4368             {
4369               _bfd_error_handler
4370                 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4371                    " because .idata$6 is missing"), abfd);
4372               result = FALSE;
4373             }
4374         }
4375     }
4376
4377   h1 = coff_link_hash_lookup (coff_hash_table (info),
4378                               (bfd_get_symbol_leading_char (abfd) != 0
4379                                ? "__tls_used" : "_tls_used"),
4380                               FALSE, FALSE, TRUE);
4381   if (h1 != NULL)
4382     {
4383       if ((h1->root.type == bfd_link_hash_defined
4384            || h1->root.type == bfd_link_hash_defweak)
4385           && h1->root.u.def.section != NULL
4386           && h1->root.u.def.section->output_section != NULL)
4387         pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4388           (h1->root.u.def.value
4389            + h1->root.u.def.section->output_section->vma
4390            + h1->root.u.def.section->output_offset
4391            - pe_data (abfd)->pe_opthdr.ImageBase);
4392       else
4393         {
4394           _bfd_error_handler
4395             (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4396              abfd);
4397           result = FALSE;
4398         }
4399      /* According to PECOFF sepcifications by Microsoft version 8.2
4400         the TLS data directory consists of 4 pointers, followed
4401         by two 4-byte integer. This implies that the total size
4402         is different for 32-bit and 64-bit executables.  */
4403 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4404       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4405 #else
4406       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4407 #endif
4408     }
4409
4410 /* If there is a .pdata section and we have linked pdata finally, we
4411      need to sort the entries ascending.  */
4412 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4413   {
4414     asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4415
4416     if (sec)
4417       {
4418         bfd_size_type x = sec->rawsize;
4419         bfd_byte *tmp_data = NULL;
4420
4421         if (x)
4422           tmp_data = bfd_malloc (x);
4423
4424         if (tmp_data != NULL)
4425           {
4426             if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4427               {
4428                 qsort (tmp_data,
4429                        (size_t) (x / 12),
4430                        12, sort_x64_pdata);
4431                 bfd_set_section_contents (pfinfo->output_bfd, sec,
4432                                           tmp_data, 0, x);
4433               }
4434             free (tmp_data);
4435           }
4436       }
4437   }
4438 #endif
4439
4440   rsrc_process_section (abfd, pfinfo);
4441
4442   /* If we couldn't find idata$2, we either have an excessively
4443      trivial program or are in DEEP trouble; we have to assume trivial
4444      program....  */
4445   return result;
4446 }