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