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