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