1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2017 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25 PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc. */
28 /* Hey look, some documentation [and in a place you expect to find it]!
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.
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
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
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.
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. */
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+. */
63 #include "coff/internal.h"
65 #include "libiberty.h"
73 /* NOTE: it's strange to be including an architecture specific header
74 in what's supposed to be general (to PE/PEI) code. However, that's
75 where the definitions are, and they don't vary per architecture
76 within PE/PEI, so we get them from there. FIXME: The lack of
77 variance is an assumption which may prove to be incorrect if new
78 PE/PEI targets are created. */
79 #if defined COFF_WITH_pex64
80 # include "coff/x86_64.h"
81 #elif defined COFF_WITH_pep
82 # include "coff/ia64.h"
84 # include "coff/i386.h"
90 #include "safe-ctype.h"
92 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
94 # define AOUTSZ PEPAOUTSZ
95 # define PEAOUTHDR PEPAOUTHDR
98 #define HighBitSet(val) ((val) & 0x80000000)
99 #define SetHighBit(val) ((val) | 0x80000000)
100 #define WithoutHighBit(val) ((val) & 0x7fffffff)
102 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
103 worked when the code was in peicode.h, but no longer work now that
104 the code is in peigen.c. PowerPC NT is said to be dead. If
105 anybody wants to revive the code, you will have to figure out how
106 to handle those issues. */
109 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
111 SYMENT
*ext
= (SYMENT
*) ext1
;
112 struct internal_syment
*in
= (struct internal_syment
*) in1
;
114 if (ext
->e
.e_name
[0] == 0)
116 in
->_n
._n_n
._n_zeroes
= 0;
117 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
120 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
122 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
123 in
->n_scnum
= (short) H_GET_16 (abfd
, ext
->e_scnum
);
125 if (sizeof (ext
->e_type
) == 2)
126 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
128 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
130 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
131 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
133 #ifndef STRICT_PE_FORMAT
134 /* This is for Gnu-created DLLs. */
136 /* The section symbols for the .idata$ sections have class 0x68
137 (C_SECTION), which MS documentation indicates is a section
138 symbol. Unfortunately, the value field in the symbol is simply a
139 copy of the .idata section's flags rather than something useful.
140 When these symbols are encountered, change the value to 0 so that
141 they will be handled somewhat correctly in the bfd code. */
142 if (in
->n_sclass
== C_SECTION
)
144 char namebuf
[SYMNMLEN
+ 1];
145 const char *name
= NULL
;
149 /* Create synthetic empty sections as needed. DJ */
150 if (in
->n_scnum
== 0)
154 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
157 _bfd_error_handler (_("%B: unable to find name for empty section"),
159 bfd_set_error (bfd_error_invalid_target
);
163 sec
= bfd_get_section_by_name (abfd
, name
);
165 in
->n_scnum
= sec
->target_index
;
168 if (in
->n_scnum
== 0)
170 int unused_section_number
= 0;
174 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
175 if (unused_section_number
<= sec
->target_index
)
176 unused_section_number
= sec
->target_index
+ 1;
180 name
= (const char *) bfd_alloc (abfd
, strlen (namebuf
) + 1);
183 _bfd_error_handler (_("%B: out of memory creating name for empty section"),
187 strcpy ((char *) name
, namebuf
);
190 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
191 sec
= bfd_make_section_anyway_with_flags (abfd
, name
, flags
);
194 _bfd_error_handler (_("%B: unable to create fake empty section"),
203 sec
->rel_filepos
= 0;
204 sec
->reloc_count
= 0;
205 sec
->line_filepos
= 0;
206 sec
->lineno_count
= 0;
207 sec
->userdata
= NULL
;
209 sec
->alignment_power
= 2;
211 sec
->target_index
= unused_section_number
;
213 in
->n_scnum
= unused_section_number
;
215 in
->n_sclass
= C_STAT
;
219 #ifdef coff_swap_sym_in_hook
220 /* This won't work in peigen.c, but since it's for PPC PE, it's not
222 coff_swap_sym_in_hook (abfd
, ext1
, in1
);
227 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
229 bfd_vma abs_val
= * (bfd_vma
*) data
;
231 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
235 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
237 struct internal_syment
*in
= (struct internal_syment
*) inp
;
238 SYMENT
*ext
= (SYMENT
*) extp
;
240 if (in
->_n
._n_name
[0] == 0)
242 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
243 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
246 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
248 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
249 symbol. This is a problem on 64-bit targets where we can generate
250 absolute symbols with values >= 1^32. We try to work around this
251 problem by finding a section whose base address is sufficient to
252 reduce the absolute value to < 1^32, and then transforming the
253 symbol into a section relative symbol. This of course is a hack. */
254 if (sizeof (in
->n_value
) > 4
255 /* The strange computation of the shift amount is here in order to
256 avoid a compile time warning about the comparison always being
257 false. It does not matter if this test fails to work as expected
258 as the worst that can happen is that some absolute symbols are
259 needlessly converted into section relative symbols. */
260 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
261 && in
->n_scnum
== N_ABS
)
265 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
268 in
->n_value
-= sec
->vma
;
269 in
->n_scnum
= sec
->target_index
;
271 /* else: FIXME: The value is outside the range of any section. This
272 happens for __image_base__ and __ImageBase and maybe some other
273 symbols as well. We should find a way to handle these values. */
276 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
277 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
279 if (sizeof (ext
->e_type
) == 2)
280 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
282 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
284 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
285 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
291 _bfd_XXi_swap_aux_in (bfd
* abfd
,
295 int indx ATTRIBUTE_UNUSED
,
296 int numaux ATTRIBUTE_UNUSED
,
299 AUXENT
*ext
= (AUXENT
*) ext1
;
300 union internal_auxent
*in
= (union internal_auxent
*) in1
;
302 /* PR 17521: Make sure that all fields in the aux structure
304 memset (in
, 0, sizeof * in
);
308 if (ext
->x_file
.x_fname
[0] == 0)
310 in
->x_file
.x_n
.x_zeroes
= 0;
311 in
->x_file
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
314 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
322 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
323 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
324 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
325 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
326 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
327 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
333 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
334 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
336 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
339 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
340 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
344 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
345 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
346 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
347 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
348 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
349 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
350 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
351 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
356 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
360 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
361 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
366 _bfd_XXi_swap_aux_out (bfd
* abfd
,
370 int indx ATTRIBUTE_UNUSED
,
371 int numaux ATTRIBUTE_UNUSED
,
374 union internal_auxent
*in
= (union internal_auxent
*) inp
;
375 AUXENT
*ext
= (AUXENT
*) extp
;
377 memset (ext
, 0, AUXESZ
);
382 if (in
->x_file
.x_fname
[0] == 0)
384 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
385 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
388 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
397 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
398 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
399 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
400 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
401 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
402 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
408 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
409 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
411 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
414 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
415 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
419 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
420 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
421 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
422 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
423 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
424 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
425 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
426 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
430 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
433 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
434 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
441 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
443 LINENO
*ext
= (LINENO
*) ext1
;
444 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
446 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
447 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
451 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
453 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
454 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
455 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
457 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
462 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
466 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
467 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
468 struct internal_aouthdr
*aouthdr_int
469 = (struct internal_aouthdr
*) aouthdr_int1
;
470 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
472 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
473 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
474 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
475 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
476 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
477 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
478 aouthdr_int
->text_start
=
479 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
481 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
482 /* PE32+ does not have data_start member! */
483 aouthdr_int
->data_start
=
484 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
485 a
->BaseOfData
= aouthdr_int
->data_start
;
488 a
->Magic
= aouthdr_int
->magic
;
489 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
490 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
491 a
->SizeOfCode
= aouthdr_int
->tsize
;
492 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
493 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
494 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
495 a
->BaseOfCode
= aouthdr_int
->text_start
;
496 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
497 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
498 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
499 a
->MajorOperatingSystemVersion
=
500 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
501 a
->MinorOperatingSystemVersion
=
502 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
503 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
504 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
505 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
506 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
507 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
508 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
509 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
510 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
511 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
512 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
513 a
->SizeOfStackReserve
=
514 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
515 a
->SizeOfStackCommit
=
516 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
517 a
->SizeOfHeapReserve
=
518 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
519 a
->SizeOfHeapCommit
=
520 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
521 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
522 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
527 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
528 if (a
->NumberOfRvaAndSizes
> IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
530 /* xgettext:c-format */
532 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
533 abfd
, a
->NumberOfRvaAndSizes
);
534 bfd_set_error (bfd_error_bad_value
);
536 /* Paranoia: If the number is corrupt, then assume that the
537 actual entries themselves might be corrupt as well. */
538 a
->NumberOfRvaAndSizes
= 0;
541 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
543 /* If data directory is empty, rva also should be 0. */
545 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
547 a
->DataDirectory
[idx
].Size
= size
;
550 a
->DataDirectory
[idx
].VirtualAddress
=
551 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
553 a
->DataDirectory
[idx
].VirtualAddress
= 0;
556 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
558 a
->DataDirectory
[idx
].Size
= 0;
559 a
->DataDirectory
[idx
].VirtualAddress
= 0;
564 if (aouthdr_int
->entry
)
566 aouthdr_int
->entry
+= a
->ImageBase
;
567 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
568 aouthdr_int
->entry
&= 0xffffffff;
572 if (aouthdr_int
->tsize
)
574 aouthdr_int
->text_start
+= a
->ImageBase
;
575 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
576 aouthdr_int
->text_start
&= 0xffffffff;
580 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
581 /* PE32+ does not have data_start member! */
582 if (aouthdr_int
->dsize
)
584 aouthdr_int
->data_start
+= a
->ImageBase
;
585 aouthdr_int
->data_start
&= 0xffffffff;
590 /* These three fields are normally set up by ppc_relocate_section.
591 In the case of reading a file in, we can pick them up from the
593 first_thunk_address
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
;
594 thunk_size
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
;
595 import_table_size
= a
->DataDirectory
[PE_IMPORT_TABLE
].Size
;
599 /* A support function for below. */
602 add_data_entry (bfd
* abfd
,
603 struct internal_extra_pe_aouthdr
*aout
,
608 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
610 /* Add import directory information if it exists. */
612 && (coff_section_data (abfd
, sec
) != NULL
)
613 && (pei_section_data (abfd
, sec
) != NULL
))
615 /* If data directory is empty, rva also should be 0. */
616 int size
= pei_section_data (abfd
, sec
)->virt_size
;
617 aout
->DataDirectory
[idx
].Size
= size
;
621 aout
->DataDirectory
[idx
].VirtualAddress
=
622 (sec
->vma
- base
) & 0xffffffff;
623 sec
->flags
|= SEC_DATA
;
629 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
631 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
632 pe_data_type
*pe
= pe_data (abfd
);
633 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
634 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
636 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
638 sa
= extra
->SectionAlignment
;
639 fa
= extra
->FileAlignment
;
640 ib
= extra
->ImageBase
;
642 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
643 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
644 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
646 if (aouthdr_in
->tsize
)
648 aouthdr_in
->text_start
-= ib
;
649 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
650 aouthdr_in
->text_start
&= 0xffffffff;
654 if (aouthdr_in
->dsize
)
656 aouthdr_in
->data_start
-= ib
;
657 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
658 aouthdr_in
->data_start
&= 0xffffffff;
662 if (aouthdr_in
->entry
)
664 aouthdr_in
->entry
-= ib
;
665 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
666 aouthdr_in
->entry
&= 0xffffffff;
670 #define FA(x) (((x) + fa -1 ) & (- fa))
671 #define SA(x) (((x) + sa -1 ) & (- sa))
673 /* We like to have the sizes aligned. */
674 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
676 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
678 add_data_entry (abfd
, extra
, 0, ".edata", ib
);
679 add_data_entry (abfd
, extra
, 2, ".rsrc", ib
);
680 add_data_entry (abfd
, extra
, 3, ".pdata", ib
);
682 /* In theory we do not need to call add_data_entry for .idata$2 or
683 .idata$5. It will be done in bfd_coff_final_link where all the
684 required information is available. If however, we are not going
685 to perform a final link, eg because we have been invoked by objcopy
686 or strip, then we need to make sure that these Data Directory
687 entries are initialised properly.
689 So - we copy the input values into the output values, and then, if
690 a final link is going to be performed, it can overwrite them. */
691 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
692 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
693 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
695 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
696 /* Until other .idata fixes are made (pending patch), the entry for
697 .idata is needed for backwards compatibility. FIXME. */
698 add_data_entry (abfd
, extra
, 1, ".idata", ib
);
700 /* For some reason, the virtual size (which is what's set by
701 add_data_entry) for .reloc is not the same as the size recorded
702 in this slot by MSVC; it doesn't seem to cause problems (so far),
703 but since it's the best we've got, use it. It does do the right
705 if (pe
->has_reloc_section
)
706 add_data_entry (abfd
, extra
, 5, ".reloc", ib
);
715 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
717 int rounded
= FA (sec
->size
);
719 /* The first non-zero section filepos is the header size.
720 Sections without contents will have a filepos of 0. */
722 hsize
= sec
->filepos
;
723 if (sec
->flags
& SEC_DATA
)
725 if (sec
->flags
& SEC_CODE
)
727 /* The image size is the total VIRTUAL size (which is what is
728 in the virt_size field). Files have been seen (from MSVC
729 5.0 link.exe) where the file size of the .data segment is
730 quite small compared to the virtual size. Without this
731 fix, strip munges the file.
733 FIXME: We need to handle holes between sections, which may
734 happpen when we covert from another format. We just use
735 the virtual address and virtual size of the last section
736 for the image size. */
737 if (coff_section_data (abfd
, sec
) != NULL
738 && pei_section_data (abfd
, sec
) != NULL
)
739 isize
= (sec
->vma
- extra
->ImageBase
740 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
743 aouthdr_in
->dsize
= dsize
;
744 aouthdr_in
->tsize
= tsize
;
745 extra
->SizeOfHeaders
= hsize
;
746 extra
->SizeOfImage
= isize
;
749 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
751 /* e.g. 219510000 is linker version 2.19 */
752 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
754 /* This piece of magic sets the "linker version" field to
756 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
757 aouthdr_out
->standard
.vstamp
);
759 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
760 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
761 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
762 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
763 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
764 aouthdr_out
->standard
.text_start
);
766 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
767 /* PE32+ does not have data_start member! */
768 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
769 aouthdr_out
->standard
.data_start
);
772 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
773 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
774 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
775 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
776 aouthdr_out
->MajorOperatingSystemVersion
);
777 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
778 aouthdr_out
->MinorOperatingSystemVersion
);
779 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
780 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
781 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
782 aouthdr_out
->MajorSubsystemVersion
);
783 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
784 aouthdr_out
->MinorSubsystemVersion
);
785 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
786 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
787 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
788 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
789 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
790 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
791 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
792 aouthdr_out
->SizeOfStackReserve
);
793 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
794 aouthdr_out
->SizeOfStackCommit
);
795 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
796 aouthdr_out
->SizeOfHeapReserve
);
797 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
798 aouthdr_out
->SizeOfHeapCommit
);
799 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
800 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
801 aouthdr_out
->NumberOfRvaAndSizes
);
805 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
807 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
808 aouthdr_out
->DataDirectory
[idx
][0]);
809 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
810 aouthdr_out
->DataDirectory
[idx
][1]);
818 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
821 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
822 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
824 if (pe_data (abfd
)->has_reloc_section
825 || pe_data (abfd
)->dont_strip_reloc
)
826 filehdr_in
->f_flags
&= ~F_RELFLG
;
828 if (pe_data (abfd
)->dll
)
829 filehdr_in
->f_flags
|= F_DLL
;
831 filehdr_in
->pe
.e_magic
= DOSMAGIC
;
832 filehdr_in
->pe
.e_cblp
= 0x90;
833 filehdr_in
->pe
.e_cp
= 0x3;
834 filehdr_in
->pe
.e_crlc
= 0x0;
835 filehdr_in
->pe
.e_cparhdr
= 0x4;
836 filehdr_in
->pe
.e_minalloc
= 0x0;
837 filehdr_in
->pe
.e_maxalloc
= 0xffff;
838 filehdr_in
->pe
.e_ss
= 0x0;
839 filehdr_in
->pe
.e_sp
= 0xb8;
840 filehdr_in
->pe
.e_csum
= 0x0;
841 filehdr_in
->pe
.e_ip
= 0x0;
842 filehdr_in
->pe
.e_cs
= 0x0;
843 filehdr_in
->pe
.e_lfarlc
= 0x40;
844 filehdr_in
->pe
.e_ovno
= 0x0;
846 for (idx
= 0; idx
< 4; idx
++)
847 filehdr_in
->pe
.e_res
[idx
] = 0x0;
849 filehdr_in
->pe
.e_oemid
= 0x0;
850 filehdr_in
->pe
.e_oeminfo
= 0x0;
852 for (idx
= 0; idx
< 10; idx
++)
853 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
855 filehdr_in
->pe
.e_lfanew
= 0x80;
857 /* This next collection of data are mostly just characters. It
858 appears to be constant within the headers put on NT exes. */
859 filehdr_in
->pe
.dos_message
[0] = 0x0eba1f0e;
860 filehdr_in
->pe
.dos_message
[1] = 0xcd09b400;
861 filehdr_in
->pe
.dos_message
[2] = 0x4c01b821;
862 filehdr_in
->pe
.dos_message
[3] = 0x685421cd;
863 filehdr_in
->pe
.dos_message
[4] = 0x70207369;
864 filehdr_in
->pe
.dos_message
[5] = 0x72676f72;
865 filehdr_in
->pe
.dos_message
[6] = 0x63206d61;
866 filehdr_in
->pe
.dos_message
[7] = 0x6f6e6e61;
867 filehdr_in
->pe
.dos_message
[8] = 0x65622074;
868 filehdr_in
->pe
.dos_message
[9] = 0x6e757220;
869 filehdr_in
->pe
.dos_message
[10] = 0x206e6920;
870 filehdr_in
->pe
.dos_message
[11] = 0x20534f44;
871 filehdr_in
->pe
.dos_message
[12] = 0x65646f6d;
872 filehdr_in
->pe
.dos_message
[13] = 0x0a0d0d2e;
873 filehdr_in
->pe
.dos_message
[14] = 0x24;
874 filehdr_in
->pe
.dos_message
[15] = 0x0;
875 filehdr_in
->pe
.nt_signature
= NT_SIGNATURE
;
877 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
878 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
880 /* Only use a real timestamp if the option was chosen. */
881 if ((pe_data (abfd
)->insert_timestamp
))
882 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
884 H_PUT_32 (abfd
, 0, filehdr_out
->f_timdat
);
886 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
887 filehdr_out
->f_symptr
);
888 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
889 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
890 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
892 /* Put in extra dos header stuff. This data remains essentially
893 constant, it just has to be tacked on to the beginning of all exes
895 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
896 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
897 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
898 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
899 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
900 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
901 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
902 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
903 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
904 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
905 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
906 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
907 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
908 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
910 for (idx
= 0; idx
< 4; idx
++)
911 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
913 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
914 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
916 for (idx
= 0; idx
< 10; idx
++)
917 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
919 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
921 for (idx
= 0; idx
< 16; idx
++)
922 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
923 filehdr_out
->dos_message
[idx
]);
925 /* Also put in the NT signature. */
926 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
932 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
934 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
935 FILHDR
*filehdr_out
= (FILHDR
*) out
;
937 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
938 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
939 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
940 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
941 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
942 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
943 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
949 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
951 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
952 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
953 unsigned int ret
= SCNHSZ
;
957 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
959 PUT_SCNHDR_VADDR (abfd
,
960 ((scnhdr_int
->s_vaddr
961 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
963 scnhdr_ext
->s_vaddr
);
965 /* NT wants the size data to be rounded up to the next
966 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
968 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
970 if (bfd_pei_p (abfd
))
972 ps
= scnhdr_int
->s_size
;
978 ss
= scnhdr_int
->s_size
;
983 if (bfd_pei_p (abfd
))
984 ps
= scnhdr_int
->s_paddr
;
988 ss
= scnhdr_int
->s_size
;
991 PUT_SCNHDR_SIZE (abfd
, ss
,
994 /* s_paddr in PE is really the virtual size. */
995 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
997 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
998 scnhdr_ext
->s_scnptr
);
999 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
1000 scnhdr_ext
->s_relptr
);
1001 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
1002 scnhdr_ext
->s_lnnoptr
);
1005 /* Extra flags must be set when dealing with PE. All sections should also
1006 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
1007 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1008 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1009 (this is especially important when dealing with the .idata section since
1010 the addresses for routines from .dlls must be overwritten). If .reloc
1011 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1012 (0x02000000). Also, the resource data should also be read and
1015 /* FIXME: Alignment is also encoded in this field, at least on PPC and
1016 ARM-WINCE. Although - how do we get the original alignment field
1021 const char * section_name
;
1022 unsigned long must_have
;
1024 pe_required_section_flags
;
1026 pe_required_section_flags known_sections
[] =
1028 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1029 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1030 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1031 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1032 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1033 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1034 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1035 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1036 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1037 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1038 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1039 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1043 pe_required_section_flags
* p
;
1045 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1046 we know exactly what this specific section wants so we remove it
1047 and then allow the must_have field to add it back in if necessary.
1048 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1049 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1050 by ld --enable-auto-import (if auto-import is actually needed),
1051 by ld --omagic, or by obcopy --writable-text. */
1053 for (p
= known_sections
; p
->section_name
; p
++)
1054 if (strcmp (scnhdr_int
->s_name
, p
->section_name
) == 0)
1056 if (strcmp (scnhdr_int
->s_name
, ".text")
1057 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1058 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1059 scnhdr_int
->s_flags
|= p
->must_have
;
1063 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1066 if (coff_data (abfd
)->link_info
1067 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1068 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1069 && strcmp (scnhdr_int
->s_name
, ".text") == 0)
1071 /* By inference from looking at MS output, the 32 bit field
1072 which is the combination of the number_of_relocs and
1073 number_of_linenos is used for the line number count in
1074 executables. A 16-bit field won't do for cc1. The MS
1075 document says that the number of relocs is zero for
1076 executables, but the 17-th bit has been observed to be there.
1077 Overflow is not an issue: a 4G-line program will overflow a
1078 bunch of other fields long before this! */
1079 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1080 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1084 if (scnhdr_int
->s_nlnno
<= 0xffff)
1085 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1088 /* xgettext:c-format */
1089 _bfd_error_handler (_("%s: line number overflow: 0x%lx > 0xffff"),
1090 bfd_get_filename (abfd
),
1091 scnhdr_int
->s_nlnno
);
1092 bfd_set_error (bfd_error_file_truncated
);
1093 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1097 /* Although we could encode 0xffff relocs here, we do not, to be
1098 consistent with other parts of bfd. Also it lets us warn, as
1099 we should never see 0xffff here w/o having the overflow flag
1101 if (scnhdr_int
->s_nreloc
< 0xffff)
1102 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1105 /* PE can deal with large #s of relocs, but not here. */
1106 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1107 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1108 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1115 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1117 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1118 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1120 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1121 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1122 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1123 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1124 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1125 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1126 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1127 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1131 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1133 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1134 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1136 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1137 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1138 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1139 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1140 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1141 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1142 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1143 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1145 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1149 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1153 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1156 if (bfd_bread (buffer
, 256, abfd
) < 4)
1159 /* Ensure null termination of filename. */
1162 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1165 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1166 && (length
> sizeof (CV_INFO_PDB70
)))
1168 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1170 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1172 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1173 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1174 as 16 bytes in big-endian order. */
1175 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1176 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1177 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1178 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1180 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1181 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1185 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1186 && (length
> sizeof (CV_INFO_PDB20
)))
1188 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1189 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1190 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1191 cvinfo
->SignatureLength
= 4;
1192 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1201 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1203 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1204 bfd_size_type written
;
1205 CV_INFO_PDB70
*cvinfo70
;
1208 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1211 buffer
= xmalloc (size
);
1212 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1213 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1215 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1216 in little-endian order, followed by 8 single bytes. */
1217 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1218 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1219 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1220 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1222 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1223 cvinfo70
->PdbFileName
[0] = '\0';
1225 written
= bfd_bwrite (buffer
, size
, abfd
);
1229 return written
== size
? size
: 0;
1232 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1234 N_("Export Directory [.edata (or where ever we found it)]"),
1235 N_("Import Directory [parts of .idata]"),
1236 N_("Resource Directory [.rsrc]"),
1237 N_("Exception Directory [.pdata]"),
1238 N_("Security Directory"),
1239 N_("Base Relocation Directory [.reloc]"),
1240 N_("Debug Directory"),
1241 N_("Description Directory"),
1242 N_("Special Directory"),
1243 N_("Thread Storage Directory [.tls]"),
1244 N_("Load Configuration Directory"),
1245 N_("Bound Import Directory"),
1246 N_("Import Address Table Directory"),
1247 N_("Delay Import Directory"),
1248 N_("CLR Runtime Header"),
1252 #ifdef POWERPC_LE_PE
1253 /* The code for the PPC really falls in the "architecture dependent"
1254 category. However, it's not clear that anyone will ever care, so
1255 we're ignoring the issue for now; if/when PPC matters, some of this
1256 may need to go into peicode.h, or arguments passed to enable the
1257 PPC- specific code. */
1261 pe_print_idata (bfd
* abfd
, void * vfile
)
1263 FILE *file
= (FILE *) vfile
;
1268 #ifdef POWERPC_LE_PE
1269 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1272 bfd_size_type datasize
= 0;
1273 bfd_size_type dataoff
;
1277 pe_data_type
*pe
= pe_data (abfd
);
1278 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1282 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1284 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1286 /* Maybe the extra header isn't there. Look for the section. */
1287 section
= bfd_get_section_by_name (abfd
, ".idata");
1288 if (section
== NULL
)
1291 addr
= section
->vma
;
1292 datasize
= section
->size
;
1298 addr
+= extra
->ImageBase
;
1299 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1301 datasize
= section
->size
;
1302 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1306 if (section
== NULL
)
1309 _("\nThere is an import table, but the section containing it could not be found\n"));
1312 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1315 _("\nThere is an import table in %s, but that section has no contents\n"),
1321 /* xgettext:c-format */
1322 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1323 section
->name
, (unsigned long) addr
);
1325 dataoff
= addr
- section
->vma
;
1327 #ifdef POWERPC_LE_PE
1328 if (rel_section
!= 0 && rel_section
->size
!= 0)
1330 /* The toc address can be found by taking the starting address,
1331 which on the PPC locates a function descriptor. The
1332 descriptor consists of the function code starting address
1333 followed by the address of the toc. The starting address we
1334 get from the bfd, and the descriptor is supposed to be in the
1335 .reldata section. */
1337 bfd_vma loadable_toc_address
;
1338 bfd_vma toc_address
;
1339 bfd_vma start_address
;
1343 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1350 offset
= abfd
->start_address
- rel_section
->vma
;
1352 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1359 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1360 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1361 toc_address
= loadable_toc_address
- 32768;
1364 _("\nFunction descriptor located at the start address: %04lx\n"),
1365 (unsigned long int) (abfd
->start_address
));
1367 /* xgettext:c-format */
1368 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1369 start_address
, loadable_toc_address
, toc_address
);
1376 _("\nNo reldata section! Function descriptor not decoded.\n"));
1381 _("\nThe Import Tables (interpreted %s section contents)\n"),
1385 vma: Hint Time Forward DLL First\n\
1386 Table Stamp Chain Name Thunk\n"));
1388 /* Read the whole section. Some of the fields might be before dataoff. */
1389 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1396 adj
= section
->vma
- extra
->ImageBase
;
1398 /* Print all image import descriptors. */
1399 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1403 bfd_vma forward_chain
;
1405 bfd_vma first_thunk
;
1410 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1411 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1412 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1413 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1414 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1415 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1416 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1418 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1419 (unsigned long) hint_addr
,
1420 (unsigned long) time_stamp
,
1421 (unsigned long) forward_chain
,
1422 (unsigned long) dll_name
,
1423 (unsigned long) first_thunk
);
1425 if (hint_addr
== 0 && first_thunk
== 0)
1428 if (dll_name
- adj
>= section
->size
)
1431 dll
= (char *) data
+ dll_name
- adj
;
1432 /* PR 17512 file: 078-12277-0.004. */
1433 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1434 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1439 asection
*ft_section
;
1441 bfd_size_type ft_datasize
;
1445 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1447 idx
= hint_addr
- adj
;
1449 ft_addr
= first_thunk
+ extra
->ImageBase
;
1450 ft_idx
= first_thunk
- adj
;
1451 ft_data
= data
+ ft_idx
;
1452 ft_datasize
= datasize
- ft_idx
;
1455 if (first_thunk
!= hint_addr
)
1457 /* Find the section which contains the first thunk. */
1458 for (ft_section
= abfd
->sections
;
1460 ft_section
= ft_section
->next
)
1462 if (ft_addr
>= ft_section
->vma
1463 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1467 if (ft_section
== NULL
)
1470 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1474 /* Now check to see if this section is the same as our current
1475 section. If it is not then we will have to load its data in. */
1476 if (ft_section
!= section
)
1478 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1479 ft_datasize
= ft_section
->size
- ft_idx
;
1480 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1481 if (ft_data
== NULL
)
1484 /* Read ft_datasize bytes starting at offset ft_idx. */
1485 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1486 (bfd_vma
) ft_idx
, ft_datasize
))
1495 /* Print HintName vector entries. */
1496 #ifdef COFF_WITH_pex64
1497 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1500 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1501 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1503 if (!member
&& !member_high
)
1508 if (HighBitSet (member_high
))
1509 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1510 member_high
, member
,
1511 WithoutHighBit (member_high
), member
);
1512 /* PR binutils/17512: Handle corrupt PE data. */
1513 else if (amt
+ 2 >= datasize
)
1514 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1520 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1521 member_name
= (char *) data
+ amt
+ 2;
1522 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1523 (int) (datasize
- (amt
+ 2)), member_name
);
1526 /* If the time stamp is not zero, the import address
1527 table holds actual addresses. */
1530 && first_thunk
!= hint_addr
1531 && j
+ 4 <= ft_datasize
)
1532 fprintf (file
, "\t%04lx",
1533 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1534 fprintf (file
, "\n");
1537 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1540 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1542 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1547 if (HighBitSet (member
))
1548 fprintf (file
, "\t%04lx\t %4lu <none>",
1549 member
, WithoutHighBit (member
));
1550 /* PR binutils/17512: Handle corrupt PE data. */
1551 else if (amt
+ 2 >= datasize
)
1552 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1558 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1559 member_name
= (char *) data
+ amt
+ 2;
1560 fprintf (file
, "\t%04lx\t %4d %.*s",
1562 (int) (datasize
- (amt
+ 2)), member_name
);
1565 /* If the time stamp is not zero, the import address
1566 table holds actual addresses. */
1569 && first_thunk
!= hint_addr
1570 && j
+ 4 <= ft_datasize
)
1571 fprintf (file
, "\t%04lx",
1572 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1574 fprintf (file
, "\n");
1581 fprintf (file
, "\n");
1590 pe_print_edata (bfd
* abfd
, void * vfile
)
1592 FILE *file
= (FILE *) vfile
;
1595 bfd_size_type datasize
= 0;
1596 bfd_size_type dataoff
;
1601 long export_flags
; /* Reserved - should be zero. */
1605 bfd_vma name
; /* RVA - relative to image base. */
1606 long base
; /* Ordinal base. */
1607 unsigned long num_functions
;/* Number in the export address table. */
1608 unsigned long num_names
; /* Number in the name pointer table. */
1609 bfd_vma eat_addr
; /* RVA to the export address table. */
1610 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1611 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1614 pe_data_type
*pe
= pe_data (abfd
);
1615 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1619 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1621 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1623 /* Maybe the extra header isn't there. Look for the section. */
1624 section
= bfd_get_section_by_name (abfd
, ".edata");
1625 if (section
== NULL
)
1628 addr
= section
->vma
;
1630 datasize
= section
->size
;
1636 addr
+= extra
->ImageBase
;
1638 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1639 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1642 if (section
== NULL
)
1645 _("\nThere is an export table, but the section containing it could not be found\n"));
1648 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1651 _("\nThere is an export table in %s, but that section has no contents\n"),
1656 dataoff
= addr
- section
->vma
;
1657 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1658 if (datasize
> section
->size
- dataoff
)
1661 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1667 /* PR 17512: Handle corrupt PE binaries. */
1671 /* xgettext:c-format */
1672 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1673 section
->name
, (int) datasize
);
1677 /* xgettext:c-format */
1678 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1679 section
->name
, (unsigned long) addr
);
1681 data
= (bfd_byte
*) bfd_malloc (datasize
);
1685 if (! bfd_get_section_contents (abfd
, section
, data
,
1686 (file_ptr
) dataoff
, datasize
))
1689 /* Go get Export Directory Table. */
1690 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1691 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1692 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1693 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1694 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1695 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1696 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1697 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1698 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1699 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1700 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1702 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1704 /* Dump the EDT first. */
1706 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1710 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1713 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1716 /* xgettext:c-format */
1717 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1720 _("Name \t\t\t\t"));
1721 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1723 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1724 fprintf (file
, " %.*s\n",
1725 (int) (datasize
- (edt
.name
- adj
)),
1726 data
+ edt
.name
- adj
);
1728 fprintf (file
, "(outside .edata section)\n");
1731 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1737 _("\tExport Address Table \t\t%08lx\n"),
1741 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1744 _("Table Addresses\n"));
1747 _("\tExport Address Table \t\t"));
1748 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1749 fprintf (file
, "\n");
1752 _("\tName Pointer Table \t\t"));
1753 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1754 fprintf (file
, "\n");
1757 _("\tOrdinal Table \t\t\t"));
1758 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1759 fprintf (file
, "\n");
1761 /* The next table to find is the Export Address Table. It's basically
1762 a list of pointers that either locate a function in this dll, or
1763 forward the call to another dll. Something like:
1768 } export_address_table_entry; */
1771 _("\nExport Address Table -- Ordinal Base %ld\n"),
1774 /* PR 17512: Handle corrupt PE binaries. */
1775 if (edt
.eat_addr
+ (edt
.num_functions
* 4) - adj
>= datasize
1776 /* PR 17512: file: 092b1829 */
1777 || (edt
.num_functions
* 4) < edt
.num_functions
1778 /* PR 17512 file: 140-165018-0.004. */
1779 || data
+ edt
.eat_addr
- adj
< data
)
1780 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1781 (long) edt
.eat_addr
,
1782 (long) edt
.num_functions
);
1783 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1785 bfd_vma eat_member
= bfd_get_32 (abfd
,
1786 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1787 if (eat_member
== 0)
1790 if (eat_member
- adj
<= datasize
)
1792 /* This rva is to a name (forwarding function) in our section. */
1793 /* Should locate a function descriptor. */
1795 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1797 (long) (i
+ edt
.base
),
1798 (unsigned long) eat_member
,
1800 (int)(datasize
- (eat_member
- adj
)),
1801 data
+ eat_member
- adj
);
1805 /* Should locate a function descriptor in the reldata section. */
1807 "\t[%4ld] +base[%4ld] %04lx %s\n",
1809 (long) (i
+ edt
.base
),
1810 (unsigned long) eat_member
,
1815 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1816 /* Dump them in parallel for clarity. */
1818 _("\n[Ordinal/Name Pointer] Table\n"));
1820 /* PR 17512: Handle corrupt PE binaries. */
1821 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1822 /* PR 17512: file: bb68816e. */
1823 || edt
.num_names
* 4 < edt
.num_names
1824 || (data
+ edt
.npt_addr
- adj
) < data
)
1825 /* xgettext:c-format */
1826 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1827 (long) edt
.npt_addr
,
1828 (long) edt
.num_names
);
1829 /* PR 17512: file: 140-147171-0.004. */
1830 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1831 || data
+ edt
.ot_addr
- adj
< data
)
1832 /* xgettext:c-format */
1833 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1835 (long) edt
.num_names
);
1836 else for (i
= 0; i
< edt
.num_names
; ++i
)
1841 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1842 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1844 if ((name_ptr
- adj
) >= datasize
)
1846 /* xgettext:c-format */
1847 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1848 (long) ord
, (long) name_ptr
);
1852 char * name
= (char *) data
+ name_ptr
- adj
;
1854 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1855 (int)((char *)(data
+ datasize
) - name
), name
);
1864 /* This really is architecture dependent. On IA-64, a .pdata entry
1865 consists of three dwords containing relative virtual addresses that
1866 specify the start and end address of the code range the entry
1867 covers and the address of the corresponding unwind info data.
1869 On ARM and SH-4, a compressed PDATA structure is used :
1870 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1871 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1872 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1874 This is the version for uncompressed data. */
1877 pe_print_pdata (bfd
* abfd
, void * vfile
)
1879 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1880 # define PDATA_ROW_SIZE (3 * 8)
1882 # define PDATA_ROW_SIZE (5 * 4)
1884 FILE *file
= (FILE *) vfile
;
1886 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1887 bfd_size_type datasize
= 0;
1889 bfd_size_type start
, stop
;
1890 int onaline
= PDATA_ROW_SIZE
;
1893 || coff_section_data (abfd
, section
) == NULL
1894 || pei_section_data (abfd
, section
) == NULL
)
1897 stop
= pei_section_data (abfd
, section
)->virt_size
;
1898 if ((stop
% onaline
) != 0)
1900 /* xgettext:c-format */
1901 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1902 (long) stop
, onaline
);
1905 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1906 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1908 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1911 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1912 \t\tAddress Address Handler Data Address Mask\n"));
1915 datasize
= section
->size
;
1919 /* PR 17512: file: 002-193900-0.004. */
1920 if (datasize
< stop
)
1922 /* xgettext:c-format */
1923 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1924 (long) stop
, (long) datasize
);
1928 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1937 for (i
= start
; i
< stop
; i
+= onaline
)
1943 bfd_vma prolog_end_addr
;
1944 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1948 if (i
+ PDATA_ROW_SIZE
> stop
)
1951 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1952 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1953 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1954 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1955 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1957 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1958 && eh_data
== 0 && prolog_end_addr
== 0)
1959 /* We are probably into the padding of the section now. */
1962 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1963 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1965 eh_handler
&= ~(bfd_vma
) 0x3;
1966 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1969 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1970 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1971 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1972 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1973 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1975 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1976 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1977 fprintf (file
, " %x", em_data
);
1980 #ifdef POWERPC_LE_PE
1981 if (eh_handler
== 0 && eh_data
!= 0)
1983 /* Special bits here, although the meaning may be a little
1984 mysterious. The only one I know for sure is 0x03
1987 0x01 Register Save Millicode
1988 0x02 Register Restore Millicode
1989 0x03 Glue Code Sequence. */
1993 fprintf (file
, _(" Register save millicode"));
1996 fprintf (file
, _(" Register restore millicode"));
1999 fprintf (file
, _(" Glue code sequence"));
2006 fprintf (file
, "\n");
2012 #undef PDATA_ROW_SIZE
2015 typedef struct sym_cache
2022 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
2024 asymbol
** sy
= NULL
;
2027 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
2033 storage
= bfd_get_symtab_upper_bound (abfd
);
2038 sy
= (asymbol
**) bfd_malloc (storage
);
2043 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
2044 if (psc
->symcount
< 0)
2050 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
2055 psc
->syms
= slurp_symtab (abfd
, psc
);
2057 for (i
= 0; i
< psc
->symcount
; i
++)
2059 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
2060 return psc
->syms
[i
]->name
;
2067 cleanup_syms (sym_cache
*psc
)
2074 /* This is the version for "compressed" pdata. */
2077 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2079 # define PDATA_ROW_SIZE (2 * 4)
2080 FILE *file
= (FILE *) vfile
;
2081 bfd_byte
*data
= NULL
;
2082 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2083 bfd_size_type datasize
= 0;
2085 bfd_size_type start
, stop
;
2086 int onaline
= PDATA_ROW_SIZE
;
2087 struct sym_cache cache
= {0, 0} ;
2090 || coff_section_data (abfd
, section
) == NULL
2091 || pei_section_data (abfd
, section
) == NULL
)
2094 stop
= pei_section_data (abfd
, section
)->virt_size
;
2095 if ((stop
% onaline
) != 0)
2097 /* xgettext:c-format */
2098 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2099 (long) stop
, onaline
);
2102 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2105 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2106 \t\tAddress Length Length 32b exc Handler Data\n"));
2108 datasize
= section
->size
;
2112 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2121 for (i
= start
; i
< stop
; i
+= onaline
)
2125 bfd_vma prolog_length
, function_length
;
2126 int flag32bit
, exception_flag
;
2129 if (i
+ PDATA_ROW_SIZE
> stop
)
2132 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2133 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2135 if (begin_addr
== 0 && other_data
== 0)
2136 /* We are probably into the padding of the section now. */
2139 prolog_length
= (other_data
& 0x000000FF);
2140 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2141 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2142 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2145 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2146 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2147 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2148 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2149 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2151 /* Get the exception handler's address and the data passed from the
2152 .text section. This is really the data that belongs with the .pdata
2153 but got "compressed" out for the ARM and SH4 architectures. */
2154 tsection
= bfd_get_section_by_name (abfd
, ".text");
2155 if (tsection
&& coff_section_data (abfd
, tsection
)
2156 && pei_section_data (abfd
, tsection
))
2158 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2161 tdata
= (bfd_byte
*) bfd_malloc (8);
2164 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2166 bfd_vma eh
, eh_data
;
2168 eh
= bfd_get_32 (abfd
, tdata
);
2169 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2170 fprintf (file
, "%08x ", (unsigned int) eh
);
2171 fprintf (file
, "%08x", (unsigned int) eh_data
);
2174 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2177 fprintf (file
, " (%s) ", s
);
2184 fprintf (file
, "\n");
2189 cleanup_syms (& cache
);
2192 #undef PDATA_ROW_SIZE
2196 #define IMAGE_REL_BASED_HIGHADJ 4
2197 static const char * const tbl
[] =
2211 "UNKNOWN", /* MUST be last. */
2215 pe_print_reloc (bfd
* abfd
, void * vfile
)
2217 FILE *file
= (FILE *) vfile
;
2219 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2222 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2226 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2228 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2236 end
= data
+ section
->size
;
2237 while (p
+ 8 <= end
)
2240 bfd_vma virtual_address
;
2241 unsigned long number
, size
;
2242 bfd_byte
*chunk_end
;
2244 /* The .reloc section is a sequence of blocks, with a header consisting
2245 of two 32 bit quantities, followed by a number of 16 bit entries. */
2246 virtual_address
= bfd_get_32 (abfd
, p
);
2247 size
= bfd_get_32 (abfd
, p
+ 4);
2249 number
= (size
- 8) / 2;
2255 /* xgettext:c-format */
2256 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2257 (unsigned long) virtual_address
, size
, size
, number
);
2259 chunk_end
= p
+ size
;
2260 if (chunk_end
> end
)
2263 while (p
+ 2 <= chunk_end
)
2265 unsigned short e
= bfd_get_16 (abfd
, p
);
2266 unsigned int t
= (e
& 0xF000) >> 12;
2267 int off
= e
& 0x0FFF;
2269 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2270 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2273 /* xgettext:c-format */
2274 _("\treloc %4d offset %4x [%4lx] %s"),
2275 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2280 /* HIGHADJ takes an argument, - the next record *is* the
2281 low 16 bits of addend. */
2282 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2284 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2289 fprintf (file
, "\n");
2298 /* A data structure describing the regions of a .rsrc section.
2299 Some fields are filled in as the section is parsed. */
2301 typedef struct rsrc_regions
2303 bfd_byte
* section_start
;
2304 bfd_byte
* section_end
;
2305 bfd_byte
* strings_start
;
2306 bfd_byte
* resource_start
;
2310 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2311 rsrc_regions
*, bfd_vma
);
2313 /* Print the resource entry at DATA, with the text indented by INDENT.
2314 Recusively calls rsrc_print_resource_directory to print the contents
2315 of directory entries.
2316 Returns the address of the end of the data associated with the entry
2317 or section_end + 1 upon failure. */
2320 rsrc_print_resource_entries (FILE * file
,
2322 unsigned int indent
,
2323 bfd_boolean is_name
,
2325 rsrc_regions
* regions
,
2328 unsigned long entry
, addr
, size
;
2331 if (data
+ 8 >= regions
->section_end
)
2332 return regions
->section_end
+ 1;
2334 /* xgettext:c-format */
2335 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2337 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2342 /* Note - the documentation says that this field is an RVA value
2343 but windres appears to produce a section relative offset with
2344 the top bit set. Support both styles for now. */
2345 if (HighBitSet (entry
))
2346 name
= regions
->section_start
+ WithoutHighBit (entry
);
2348 name
= regions
->section_start
+ entry
- rva_bias
;
2350 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2354 if (regions
->strings_start
== NULL
)
2355 regions
->strings_start
= name
;
2357 len
= bfd_get_16 (abfd
, name
);
2359 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2361 if (name
+ 2 + len
* 2 < regions
->section_end
)
2363 /* This strange loop is to cope with multibyte characters. */
2370 /* Avoid printing control characters. */
2371 if (c
> 0 && c
< 32)
2372 fprintf (file
, "^%c", c
+ 64);
2374 fprintf (file
, "%.1s", name
);
2379 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2380 /* PR binutils/17512: Do not try to continue decoding a
2381 corrupted resource section. It is likely to end up with
2382 reams of extraneous output. FIXME: We could probably
2383 continue if we disable the printing of strings... */
2384 return regions
->section_end
+ 1;
2389 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2390 return regions
->section_end
+ 1;
2394 fprintf (file
, _("ID: %#08lx"), entry
);
2396 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2397 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2399 if (HighBitSet (entry
))
2401 data
= regions
->section_start
+ WithoutHighBit (entry
);
2402 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2403 return regions
->section_end
+ 1;
2405 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2406 in the resource table. We need some way to detect this. */
2407 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2411 leaf
= regions
->section_start
+ entry
;
2413 if (leaf
+ 16 >= regions
->section_end
2414 /* PR 17512: file: 055dff7e. */
2415 || leaf
< regions
->section_start
)
2416 return regions
->section_end
+ 1;
2418 /* xgettext:c-format */
2419 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2420 (int) (entry
), indent
, " ",
2421 addr
= (long) bfd_get_32 (abfd
, leaf
),
2422 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2423 (int) bfd_get_32 (abfd
, leaf
+ 8));
2425 /* Check that the reserved entry is 0. */
2426 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2427 /* And that the data address/size is valid too. */
2428 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2429 return regions
->section_end
+ 1;
2431 if (regions
->resource_start
== NULL
)
2432 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2434 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2437 #define max(a,b) ((a) > (b) ? (a) : (b))
2438 #define min(a,b) ((a) < (b) ? (a) : (b))
2441 rsrc_print_resource_directory (FILE * file
,
2443 unsigned int indent
,
2445 rsrc_regions
* regions
,
2448 unsigned int num_names
, num_ids
;
2449 bfd_byte
* highest_data
= data
;
2451 if (data
+ 16 >= regions
->section_end
)
2452 return regions
->section_end
+ 1;
2454 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2457 case 0: fprintf (file
, "Type"); break;
2458 case 2: fprintf (file
, "Name"); break;
2459 case 4: fprintf (file
, "Language"); break;
2461 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2462 /* FIXME: For now we end the printing here. If in the
2463 future more directory types are added to the RSRC spec
2464 then we will need to change this. */
2465 return regions
->section_end
+ 1;
2468 /* xgettext:c-format */
2469 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2470 (int) bfd_get_32 (abfd
, data
),
2471 (long) bfd_get_32 (abfd
, data
+ 4),
2472 (int) bfd_get_16 (abfd
, data
+ 8),
2473 (int) bfd_get_16 (abfd
, data
+ 10),
2474 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2475 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2478 while (num_names
--)
2480 bfd_byte
* entry_end
;
2482 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2483 data
, regions
, rva_bias
);
2485 highest_data
= max (highest_data
, entry_end
);
2486 if (entry_end
>= regions
->section_end
)
2492 bfd_byte
* entry_end
;
2494 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2495 data
, regions
, rva_bias
);
2497 highest_data
= max (highest_data
, entry_end
);
2498 if (entry_end
>= regions
->section_end
)
2502 return max (highest_data
, data
);
2505 /* Display the contents of a .rsrc section. We do not try to
2506 reproduce the resources, windres does that. Instead we dump
2507 the tables in a human readable format. */
2510 rsrc_print_section (bfd
* abfd
, void * vfile
)
2514 FILE * file
= (FILE *) vfile
;
2515 bfd_size_type datasize
;
2518 rsrc_regions regions
;
2520 pe
= pe_data (abfd
);
2524 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2525 if (section
== NULL
)
2527 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2530 datasize
= section
->size
;
2534 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2536 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2543 regions
.section_start
= data
;
2544 regions
.section_end
= data
+ datasize
;
2545 regions
.strings_start
= NULL
;
2546 regions
.resource_start
= NULL
;
2549 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2551 while (data
< regions
.section_end
)
2553 bfd_byte
* p
= data
;
2555 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2557 if (data
== regions
.section_end
+ 1)
2558 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2561 /* Align data before continuing. */
2562 int align
= (1 << section
->alignment_power
) - 1;
2564 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2565 rva_bias
+= data
- p
;
2567 /* For reasons that are unclear .rsrc sections are sometimes created
2568 aligned to a 1^3 boundary even when their alignment is set at
2569 1^2. Catch that case here before we issue a spurious warning
2571 if (data
== (regions
.section_end
- 4))
2572 data
= regions
.section_end
;
2573 else if (data
< regions
.section_end
)
2575 /* If the extra data is all zeros then do not complain.
2576 This is just padding so that the section meets the
2577 page size requirements. */
2578 while (++ data
< regions
.section_end
)
2581 if (data
< regions
.section_end
)
2582 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2587 if (regions
.strings_start
!= NULL
)
2588 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2589 (int) (regions
.strings_start
- regions
.section_start
));
2590 if (regions
.resource_start
!= NULL
)
2591 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2592 (int) (regions
.resource_start
- regions
.section_start
));
2594 free (regions
.section_start
);
2598 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2600 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2617 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2619 FILE *file
= (FILE *) vfile
;
2620 pe_data_type
*pe
= pe_data (abfd
);
2621 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2624 bfd_size_type dataoff
;
2627 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2628 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2633 addr
+= extra
->ImageBase
;
2634 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2636 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2640 if (section
== NULL
)
2643 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2646 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2649 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2653 else if (section
->size
< size
)
2656 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2661 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2662 section
->name
, (unsigned long) addr
);
2664 dataoff
= addr
- section
->vma
;
2666 if (size
> (section
->size
- dataoff
))
2668 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2673 _("Type Size Rva Offset\n"));
2675 /* Read the whole section. */
2676 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2683 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2685 const char *type_name
;
2686 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2687 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2688 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2690 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2692 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2693 type_name
= debug_type_names
[0];
2695 type_name
= debug_type_names
[idd
.Type
];
2697 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2698 idd
.Type
, type_name
, idd
.SizeOfData
,
2699 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2701 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2703 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2704 /* PR 17512: file: 065-29434-0.001:0.1
2705 We need to use a 32-bit aligned buffer
2706 to safely read in a codeview record. */
2707 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2709 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2711 /* The debug entry doesn't have to have to be in a section,
2712 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2713 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2714 idd
.SizeOfData
, cvinfo
))
2717 for (i
= 0; i
< cvinfo
->SignatureLength
; i
++)
2718 sprintf (&signature
[i
*2], "%02x", cvinfo
->Signature
[i
] & 0xff);
2720 /* xgettext:c-format */
2721 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2722 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2723 signature
, cvinfo
->Age
);
2727 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2729 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2734 /* Print out the program headers. */
2737 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2739 FILE *file
= (FILE *) vfile
;
2741 pe_data_type
*pe
= pe_data (abfd
);
2742 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2743 const char *subsystem_name
= NULL
;
2746 /* The MS dumpbin program reportedly ands with 0xff0f before
2747 printing the characteristics field. Not sure why. No reason to
2749 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2751 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2752 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2753 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2754 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2755 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2756 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2757 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2758 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2759 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2760 PF (IMAGE_FILE_SYSTEM
, "system file");
2761 PF (IMAGE_FILE_DLL
, "DLL");
2762 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2765 /* ctime implies '\n'. */
2767 time_t t
= pe
->coff
.timestamp
;
2768 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2771 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2772 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2774 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2775 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2777 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2778 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2783 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2786 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2789 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2796 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2798 fprintf (file
, "\t(%s)",name
);
2799 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2800 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2801 fprintf (file
, "SizeOfCode\t\t%08lx\n", (unsigned long) i
->SizeOfCode
);
2802 fprintf (file
, "SizeOfInitializedData\t%08lx\n",
2803 (unsigned long) i
->SizeOfInitializedData
);
2804 fprintf (file
, "SizeOfUninitializedData\t%08lx\n",
2805 (unsigned long) i
->SizeOfUninitializedData
);
2806 fprintf (file
, "AddressOfEntryPoint\t");
2807 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2808 fprintf (file
, "\nBaseOfCode\t\t");
2809 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2810 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2811 /* PE32+ does not have BaseOfData member! */
2812 fprintf (file
, "\nBaseOfData\t\t");
2813 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2816 fprintf (file
, "\nImageBase\t\t");
2817 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2818 fprintf (file
, "\nSectionAlignment\t");
2819 bfd_fprintf_vma (abfd
, file
, i
->SectionAlignment
);
2820 fprintf (file
, "\nFileAlignment\t\t");
2821 bfd_fprintf_vma (abfd
, file
, i
->FileAlignment
);
2822 fprintf (file
, "\nMajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2823 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2824 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2825 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2826 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2827 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2828 fprintf (file
, "Win32Version\t\t%08lx\n", (unsigned long) i
->Reserved1
);
2829 fprintf (file
, "SizeOfImage\t\t%08lx\n", (unsigned long) i
->SizeOfImage
);
2830 fprintf (file
, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i
->SizeOfHeaders
);
2831 fprintf (file
, "CheckSum\t\t%08lx\n", (unsigned long) i
->CheckSum
);
2833 switch (i
->Subsystem
)
2835 case IMAGE_SUBSYSTEM_UNKNOWN
:
2836 subsystem_name
= "unspecified";
2838 case IMAGE_SUBSYSTEM_NATIVE
:
2839 subsystem_name
= "NT native";
2841 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2842 subsystem_name
= "Windows GUI";
2844 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2845 subsystem_name
= "Windows CUI";
2847 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2848 subsystem_name
= "POSIX CUI";
2850 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2851 subsystem_name
= "Wince CUI";
2853 // These are from UEFI Platform Initialization Specification 1.1.
2854 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2855 subsystem_name
= "EFI application";
2857 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2858 subsystem_name
= "EFI boot service driver";
2860 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2861 subsystem_name
= "EFI runtime driver";
2863 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2864 subsystem_name
= "SAL runtime driver";
2866 // This is from revision 8.0 of the MS PE/COFF spec
2867 case IMAGE_SUBSYSTEM_XBOX
:
2868 subsystem_name
= "XBOX";
2870 // Added default case for clarity - subsystem_name is NULL anyway.
2872 subsystem_name
= NULL
;
2875 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2877 fprintf (file
, "\t(%s)", subsystem_name
);
2878 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2879 fprintf (file
, "SizeOfStackReserve\t");
2880 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2881 fprintf (file
, "\nSizeOfStackCommit\t");
2882 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2883 fprintf (file
, "\nSizeOfHeapReserve\t");
2884 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2885 fprintf (file
, "\nSizeOfHeapCommit\t");
2886 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2887 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2888 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2889 (unsigned long) i
->NumberOfRvaAndSizes
);
2891 fprintf (file
, "\nThe Data Directory\n");
2892 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2894 fprintf (file
, "Entry %1x ", j
);
2895 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2896 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2897 fprintf (file
, "%s\n", dir_names
[j
]);
2900 pe_print_idata (abfd
, vfile
);
2901 pe_print_edata (abfd
, vfile
);
2902 if (bfd_coff_have_print_pdata (abfd
))
2903 bfd_coff_print_pdata (abfd
, vfile
);
2905 pe_print_pdata (abfd
, vfile
);
2906 pe_print_reloc (abfd
, vfile
);
2907 pe_print_debugdata (abfd
, file
);
2909 rsrc_print_section (abfd
, vfile
);
2915 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2917 bfd_vma addr
= * (bfd_vma
*) obj
;
2918 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2922 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2924 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2927 /* Copy any private info we understand from the input bfd
2928 to the output bfd. */
2931 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2933 pe_data_type
*ipe
, *ope
;
2935 /* One day we may try to grok other private data. */
2936 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2937 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2940 ipe
= pe_data (ibfd
);
2941 ope
= pe_data (obfd
);
2943 /* pe_opthdr is copied in copy_object. */
2944 ope
->dll
= ipe
->dll
;
2946 /* Don't copy input subsystem if output is different from input. */
2947 if (obfd
->xvec
!= ibfd
->xvec
)
2948 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2950 /* For strip: if we removed .reloc, we'll make a real mess of things
2951 if we don't remove this entry as well. */
2952 if (! pe_data (obfd
)->has_reloc_section
)
2954 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2955 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2958 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2959 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2961 if (! pe_data (ibfd
)->has_reloc_section
2962 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2963 pe_data (obfd
)->dont_strip_reloc
= 1;
2965 /* The file offsets contained in the debug directory need rewriting. */
2966 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2968 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2969 + ope
->pe_opthdr
.ImageBase
;
2970 asection
*section
= find_section_by_vma (obfd
, addr
);
2973 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2976 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2977 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2979 /* PR 17512: file: 0f15796a. */
2980 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
+ (addr
- section
->vma
)
2981 > bfd_get_section_size (section
))
2983 /* xgettext:c-format */
2984 _bfd_error_handler (_("%B: Data Directory size (%lx) exceeds space left in section (%lx)"),
2985 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
2986 bfd_get_section_size (section
) - (addr
- section
->vma
));
2990 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2991 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2993 asection
*ddsection
;
2994 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
2995 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2997 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
2999 if (idd
.AddressOfRawData
== 0)
3000 continue; /* RVA 0 means only offset is valid, not handled yet. */
3002 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3004 continue; /* Not in a section! */
3006 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3007 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3009 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3012 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3014 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
3020 _bfd_error_handler (_("%B: Failed to read debug data section"), obfd
);
3028 /* Copy private section data. */
3031 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3036 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3037 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3040 if (coff_section_data (ibfd
, isec
) != NULL
3041 && pei_section_data (ibfd
, isec
) != NULL
)
3043 if (coff_section_data (obfd
, osec
) == NULL
)
3045 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3046 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3047 if (osec
->used_by_bfd
== NULL
)
3051 if (pei_section_data (obfd
, osec
) == NULL
)
3053 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3054 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3055 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3059 pei_section_data (obfd
, osec
)->virt_size
=
3060 pei_section_data (ibfd
, isec
)->virt_size
;
3061 pei_section_data (obfd
, osec
)->pe_flags
=
3062 pei_section_data (ibfd
, isec
)->pe_flags
;
3069 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3071 coff_get_symbol_info (abfd
, symbol
, ret
);
3074 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3076 sort_x64_pdata (const void *l
, const void *r
)
3078 const char *lp
= (const char *) l
;
3079 const char *rp
= (const char *) r
;
3081 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3083 return (vl
< vr
? -1 : 1);
3084 /* We compare just begin address. */
3089 /* Functions to process a .rsrc section. */
3091 static unsigned int sizeof_leaves
;
3092 static unsigned int sizeof_strings
;
3093 static unsigned int sizeof_tables_and_entries
;
3096 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3099 rsrc_count_entries (bfd
* abfd
,
3100 bfd_boolean is_name
,
3101 bfd_byte
* datastart
,
3106 unsigned long entry
, addr
, size
;
3108 if (data
+ 8 >= dataend
)
3115 entry
= (long) bfd_get_32 (abfd
, data
);
3117 if (HighBitSet (entry
))
3118 name
= datastart
+ WithoutHighBit (entry
);
3120 name
= datastart
+ entry
- rva_bias
;
3122 if (name
+ 2 >= dataend
|| name
< datastart
)
3125 unsigned int len
= bfd_get_16 (abfd
, name
);
3126 if (len
== 0 || len
> 256)
3130 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3132 if (HighBitSet (entry
))
3134 data
= datastart
+ WithoutHighBit (entry
);
3136 if (data
<= datastart
|| data
>= dataend
)
3139 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3142 if (datastart
+ entry
+ 16 >= dataend
)
3145 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3146 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3148 return datastart
+ addr
- rva_bias
+ size
;
3152 rsrc_count_directory (bfd
* abfd
,
3153 bfd_byte
* datastart
,
3158 unsigned int num_entries
, num_ids
;
3159 bfd_byte
* highest_data
= data
;
3161 if (data
+ 16 >= dataend
)
3164 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3165 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3167 num_entries
+= num_ids
;
3171 while (num_entries
--)
3173 bfd_byte
* entry_end
;
3175 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3176 datastart
, data
, dataend
, rva_bias
);
3178 highest_data
= max (highest_data
, entry_end
);
3179 if (entry_end
>= dataend
)
3183 return max (highest_data
, data
);
3186 typedef struct rsrc_dir_chain
3188 unsigned int num_entries
;
3189 struct rsrc_entry
* first_entry
;
3190 struct rsrc_entry
* last_entry
;
3193 typedef struct rsrc_directory
3195 unsigned int characteristics
;
3200 rsrc_dir_chain names
;
3203 struct rsrc_entry
* entry
;
3206 typedef struct rsrc_string
3212 typedef struct rsrc_leaf
3215 unsigned int codepage
;
3219 typedef struct rsrc_entry
3221 bfd_boolean is_name
;
3225 struct rsrc_string name
;
3231 struct rsrc_directory
* directory
;
3232 struct rsrc_leaf
* leaf
;
3235 struct rsrc_entry
* next_entry
;
3236 struct rsrc_directory
* parent
;
3240 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3241 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3244 rsrc_parse_entry (bfd
* abfd
,
3245 bfd_boolean is_name
,
3247 bfd_byte
* datastart
,
3251 rsrc_directory
* parent
)
3253 unsigned long val
, addr
, size
;
3255 val
= bfd_get_32 (abfd
, data
);
3257 entry
->parent
= parent
;
3258 entry
->is_name
= is_name
;
3264 if (HighBitSet (val
))
3266 val
= WithoutHighBit (val
);
3268 address
= datastart
+ val
;
3272 address
= datastart
+ val
- rva_bias
;
3275 if (address
+ 3 > dataend
)
3278 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3279 entry
->name_id
.name
.string
= address
+ 2;
3282 entry
->name_id
.id
= val
;
3284 val
= bfd_get_32 (abfd
, data
+ 4);
3286 if (HighBitSet (val
))
3288 entry
->is_dir
= TRUE
;
3289 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3290 if (entry
->value
.directory
== NULL
)
3293 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3295 datastart
+ WithoutHighBit (val
),
3296 dataend
, rva_bias
, entry
);
3299 entry
->is_dir
= FALSE
;
3300 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3301 if (entry
->value
.leaf
== NULL
)
3304 data
= datastart
+ val
;
3305 if (data
< datastart
|| data
>= dataend
)
3308 addr
= bfd_get_32 (abfd
, data
);
3309 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3310 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3311 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3313 entry
->value
.leaf
->data
= bfd_malloc (size
);
3314 if (entry
->value
.leaf
->data
== NULL
)
3317 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3318 return datastart
+ (addr
- rva_bias
) + size
;
3322 rsrc_parse_entries (bfd
* abfd
,
3323 rsrc_dir_chain
* chain
,
3324 bfd_boolean is_name
,
3325 bfd_byte
* highest_data
,
3326 bfd_byte
* datastart
,
3330 rsrc_directory
* parent
)
3335 if (chain
->num_entries
== 0)
3337 chain
->first_entry
= chain
->last_entry
= NULL
;
3338 return highest_data
;
3341 entry
= bfd_malloc (sizeof * entry
);
3345 chain
->first_entry
= entry
;
3347 for (i
= chain
->num_entries
; i
--;)
3349 bfd_byte
* entry_end
;
3351 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3352 data
, dataend
, rva_bias
, parent
);
3354 highest_data
= max (entry_end
, highest_data
);
3355 if (entry_end
> dataend
)
3360 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3361 entry
= entry
->next_entry
;
3366 entry
->next_entry
= NULL
;
3369 chain
->last_entry
= entry
;
3371 return highest_data
;
3375 rsrc_parse_directory (bfd
* abfd
,
3376 rsrc_directory
* table
,
3377 bfd_byte
* datastart
,
3383 bfd_byte
* highest_data
= data
;
3388 table
->characteristics
= bfd_get_32 (abfd
, data
);
3389 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3390 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3391 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3392 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3393 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3394 table
->entry
= entry
;
3398 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3399 datastart
, data
, dataend
, rva_bias
, table
);
3400 data
+= table
->names
.num_entries
* 8;
3402 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3403 datastart
, data
, dataend
, rva_bias
, table
);
3404 data
+= table
->ids
.num_entries
* 8;
3406 return max (highest_data
, data
);
3409 typedef struct rsrc_write_data
3412 bfd_byte
* datastart
;
3413 bfd_byte
* next_table
;
3414 bfd_byte
* next_leaf
;
3415 bfd_byte
* next_string
;
3416 bfd_byte
* next_data
;
3421 rsrc_write_string (rsrc_write_data
* data
,
3422 rsrc_string
* string
)
3424 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3425 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3426 data
->next_string
+= (string
->len
+ 1) * 2;
3429 static inline unsigned int
3430 rsrc_compute_rva (rsrc_write_data
* data
,
3433 return (addr
- data
->datastart
) + data
->rva_bias
;
3437 rsrc_write_leaf (rsrc_write_data
* data
,
3440 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3442 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3443 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3444 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3445 data
->next_leaf
+= 16;
3447 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3448 /* An undocumented feature of Windows resources is that each unit
3449 of raw data is 8-byte aligned... */
3450 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3453 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3456 rsrc_write_entry (rsrc_write_data
* data
,
3462 bfd_put_32 (data
->abfd
,
3463 SetHighBit (data
->next_string
- data
->datastart
),
3465 rsrc_write_string (data
, & entry
->name_id
.name
);
3468 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3472 bfd_put_32 (data
->abfd
,
3473 SetHighBit (data
->next_table
- data
->datastart
),
3475 rsrc_write_directory (data
, entry
->value
.directory
);
3479 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3480 rsrc_write_leaf (data
, entry
->value
.leaf
);
3485 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3487 struct rsrc_entry
* entry
;
3492 sizeof_tables_and_entries
+= 16;
3494 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3496 sizeof_tables_and_entries
+= 8;
3498 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3501 rsrc_compute_region_sizes (entry
->value
.directory
);
3503 sizeof_leaves
+= 16;
3506 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3508 sizeof_tables_and_entries
+= 8;
3511 rsrc_compute_region_sizes (entry
->value
.directory
);
3513 sizeof_leaves
+= 16;
3518 rsrc_write_directory (rsrc_write_data
* data
,
3519 rsrc_directory
* dir
)
3523 bfd_byte
* next_entry
;
3526 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3527 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3528 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3529 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3530 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3531 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3533 /* Compute where the entries and the next table will be placed. */
3534 next_entry
= data
->next_table
+ 16;
3535 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3536 + (dir
->ids
.num_entries
* 8);
3537 nt
= data
->next_table
;
3539 /* Write the entries. */
3540 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3541 i
> 0 && entry
!= NULL
;
3542 i
--, entry
= entry
->next_entry
)
3544 BFD_ASSERT (entry
->is_name
);
3545 rsrc_write_entry (data
, next_entry
, entry
);
3548 BFD_ASSERT (i
== 0);
3549 BFD_ASSERT (entry
== NULL
);
3551 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3552 i
> 0 && entry
!= NULL
;
3553 i
--, entry
= entry
->next_entry
)
3555 BFD_ASSERT (! entry
->is_name
);
3556 rsrc_write_entry (data
, next_entry
, entry
);
3559 BFD_ASSERT (i
== 0);
3560 BFD_ASSERT (entry
== NULL
);
3561 BFD_ASSERT (nt
== next_entry
);
3564 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3565 /* Return the length (number of units) of the first character in S,
3566 putting its 'ucs4_t' representation in *PUC. */
3569 #if defined HAVE_WCTYPE_H
3570 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3572 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3575 unsigned short c
= * s
;
3577 if (c
< 0xd800 || c
>= 0xe000)
3587 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3589 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3595 /* Incomplete multibyte character. */
3601 /* Invalid multibyte character. */
3605 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3607 /* Perform a comparison of two entries. */
3609 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3618 return a
->name_id
.id
- b
->name_id
.id
;
3620 /* We have to perform a case insenstive, unicode string comparison... */
3621 astring
= a
->name_id
.name
.string
;
3622 alen
= a
->name_id
.name
.len
;
3623 bstring
= b
->name_id
.name
.string
;
3624 blen
= b
->name_id
.name
.len
;
3626 #if defined __CYGWIN__ || defined __MINGW32__
3627 /* Under Windows hosts (both Cygwin and Mingw types),
3628 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3629 function however goes by different names in the two environments... */
3633 #define rscpcmp wcsncasecmp
3636 #define rscpcmp wcsnicmp
3639 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3642 #elif defined HAVE_WCHAR_H
3647 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3649 #if defined HAVE_WCTYPE_H
3657 /* Convert UTF-16 unicode characters into wchar_t characters
3658 so that we can then perform a case insensitive comparison. */
3659 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3660 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3665 #ifdef HAVE_WCTYPE_H
3666 awc
= towlower (awc
);
3667 bwc
= towlower (bwc
);
3671 res
= wcsncasecmp (& awc
, & bwc
, 1);
3678 /* Do the best we can - a case sensitive, untranslated comparison. */
3679 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3689 rsrc_print_name (char * buffer
, rsrc_string string
)
3692 bfd_byte
* name
= string
.string
;
3694 for (i
= string
.len
; i
--; name
+= 2)
3695 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3699 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3701 static char buffer
[256];
3702 bfd_boolean is_string
= FALSE
;
3706 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3707 && dir
->entry
->parent
->entry
!= NULL
)
3709 strcpy (buffer
, "type: ");
3710 if (dir
->entry
->parent
->entry
->is_name
)
3711 rsrc_print_name (buffer
+ strlen (buffer
),
3712 dir
->entry
->parent
->entry
->name_id
.name
);
3715 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3717 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3720 case 1: strcat (buffer
, " (CURSOR)"); break;
3721 case 2: strcat (buffer
, " (BITMAP)"); break;
3722 case 3: strcat (buffer
, " (ICON)"); break;
3723 case 4: strcat (buffer
, " (MENU)"); break;
3724 case 5: strcat (buffer
, " (DIALOG)"); break;
3725 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3726 case 7: strcat (buffer
, " (FONTDIR)"); break;
3727 case 8: strcat (buffer
, " (FONT)"); break;
3728 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3729 case 10: strcat (buffer
, " (RCDATA)"); break;
3730 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3731 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3732 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3733 case 16: strcat (buffer
, " (VERSION)"); break;
3734 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3735 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3736 case 20: strcat (buffer
, " (VXD)"); break;
3737 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3738 case 22: strcat (buffer
, " (ANIICON)"); break;
3739 case 23: strcat (buffer
, " (HTML)"); break;
3740 case 24: strcat (buffer
, " (MANIFEST)"); break;
3741 case 240: strcat (buffer
, " (DLGINIT)"); break;
3742 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3747 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3749 strcat (buffer
, " name: ");
3750 if (dir
->entry
->is_name
)
3751 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3754 unsigned int id
= dir
->entry
->name_id
.id
;
3756 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3759 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3760 (id
- 1) << 4, (id
<< 4) - 1);
3766 strcat (buffer
, " lang: ");
3769 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3771 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3777 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3778 their ID is stored in the NAME entry. The bottom four bits are used as
3779 an index into unicode string table that makes up the data of the leaf.
3780 So identical type-name-lang string resources may not actually be
3783 This function is called when we have detected two string resources with
3784 match top-28-bit IDs. We have to scan the string tables inside the leaves
3785 and discover if there are any real collisions. If there are then we report
3786 them and return FALSE. Otherwise we copy any strings from B into A and
3787 then return TRUE. */
3790 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3791 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3793 unsigned int copy_needed
= 0;
3797 bfd_byte
* new_data
;
3800 /* Step one: Find out what we have to do. */
3801 BFD_ASSERT (! a
->is_dir
);
3802 astring
= a
->value
.leaf
->data
;
3804 BFD_ASSERT (! b
->is_dir
);
3805 bstring
= b
->value
.leaf
->data
;
3807 for (i
= 0; i
< 16; i
++)
3809 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3810 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3814 copy_needed
+= blen
* 2;
3818 else if (alen
!= blen
)
3819 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3821 /* alen == blen != 0. We might have two identical strings. If so we
3822 can ignore the second one. There is no need for wchar_t vs UTF-16
3823 theatrics here - we are only interested in (case sensitive) equality. */
3824 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3827 astring
+= (alen
+ 1) * 2;
3828 bstring
+= (blen
+ 1) * 2;
3833 if (a
->parent
!= NULL
3834 && a
->parent
->entry
!= NULL
3835 && a
->parent
->entry
->is_name
== FALSE
)
3836 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3837 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3841 if (copy_needed
== 0)
3844 /* If we reach here then A and B must both have non-colliding strings.
3845 (We never get string resources with fully empty string tables).
3846 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3848 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3849 if (new_data
== NULL
)
3853 astring
= a
->value
.leaf
->data
;
3854 bstring
= b
->value
.leaf
->data
;
3856 for (i
= 0; i
< 16; i
++)
3858 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3859 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3863 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3864 nstring
+= (alen
+ 1) * 2;
3868 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3869 nstring
+= (blen
+ 1) * 2;
3877 astring
+= (alen
+ 1) * 2;
3878 bstring
+= (blen
+ 1) * 2;
3881 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3883 free (a
->value
.leaf
->data
);
3884 a
->value
.leaf
->data
= new_data
;
3885 a
->value
.leaf
->size
+= copy_needed
;
3890 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3892 /* Sort the entries in given part of the directory.
3893 We use an old fashioned bubble sort because we are dealing
3894 with lists and we want to handle matches specially. */
3897 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3898 bfd_boolean is_name
,
3899 rsrc_directory
* dir
)
3903 rsrc_entry
** points_to_entry
;
3904 bfd_boolean swapped
;
3906 if (chain
->num_entries
< 2)
3912 points_to_entry
= & chain
->first_entry
;
3913 entry
= * points_to_entry
;
3914 next
= entry
->next_entry
;
3918 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3922 entry
->next_entry
= next
->next_entry
;
3923 next
->next_entry
= entry
;
3924 * points_to_entry
= next
;
3925 points_to_entry
= & next
->next_entry
;
3926 next
= entry
->next_entry
;
3931 if (entry
->is_dir
&& next
->is_dir
)
3933 /* When we encounter identical directory entries we have to
3934 merge them together. The exception to this rule is for
3935 resource manifests - there can only be one of these,
3936 even if they differ in language. Zero-language manifests
3937 are assumed to be default manifests (provided by the
3938 Cygwin/MinGW build system) and these can be silently dropped,
3939 unless that would reduce the number of manifests to zero.
3940 There should only ever be one non-zero lang manifest -
3941 if there are more it is an error. A non-zero lang
3942 manifest takes precedence over a default manifest. */
3943 if (entry
->is_name
== FALSE
3944 && entry
->name_id
.id
== 1
3946 && dir
->entry
!= NULL
3947 && dir
->entry
->is_name
== FALSE
3948 && dir
->entry
->name_id
.id
== 0x18)
3950 if (next
->value
.directory
->names
.num_entries
== 0
3951 && next
->value
.directory
->ids
.num_entries
== 1
3952 && next
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3953 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3954 /* Fall through so that NEXT is dropped. */
3956 else if (entry
->value
.directory
->names
.num_entries
== 0
3957 && entry
->value
.directory
->ids
.num_entries
== 1
3958 && entry
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3959 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3961 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3962 entry
->next_entry
= next
->next_entry
;
3963 next
->next_entry
= entry
;
3964 * points_to_entry
= next
;
3965 points_to_entry
= & next
->next_entry
;
3966 next
= entry
->next_entry
;
3971 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3972 bfd_set_error (bfd_error_file_truncated
);
3976 /* Unhook NEXT from the chain. */
3977 /* FIXME: memory loss here. */
3978 entry
->next_entry
= next
->next_entry
;
3979 chain
->num_entries
--;
3980 if (chain
->num_entries
< 2)
3982 next
= next
->next_entry
;
3985 rsrc_merge (entry
, next
);
3987 else if (entry
->is_dir
!= next
->is_dir
)
3989 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3990 bfd_set_error (bfd_error_file_truncated
);
3995 /* Otherwise with identical leaves we issue an error
3996 message - because there should never be duplicates.
3997 The exception is Type 18/Name 1/Lang 0 which is the
3998 defaul manifest - this can just be dropped. */
3999 if (entry
->is_name
== FALSE
4000 && entry
->name_id
.id
== 0
4002 && dir
->entry
!= NULL
4003 && dir
->entry
->is_name
== FALSE
4004 && dir
->entry
->name_id
.id
== 1
4005 && dir
->entry
->parent
!= NULL
4006 && dir
->entry
->parent
->entry
!= NULL
4007 && dir
->entry
->parent
->entry
->is_name
== FALSE
4008 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4010 else if (dir
!= NULL
4011 && dir
->entry
!= NULL
4012 && dir
->entry
->parent
!= NULL
4013 && dir
->entry
->parent
->entry
!= NULL
4014 && dir
->entry
->parent
->entry
->is_name
== FALSE
4015 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4017 /* Strings need special handling. */
4018 if (! rsrc_merge_string_entries (entry
, next
))
4020 /* _bfd_error_handler should have been called inside merge_strings. */
4021 bfd_set_error (bfd_error_file_truncated
);
4028 || dir
->entry
== NULL
4029 || dir
->entry
->parent
== NULL
4030 || dir
->entry
->parent
->entry
== NULL
)
4031 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4033 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4034 rsrc_resource_name (entry
, dir
));
4035 bfd_set_error (bfd_error_file_truncated
);
4040 /* Unhook NEXT from the chain. */
4041 entry
->next_entry
= next
->next_entry
;
4042 chain
->num_entries
--;
4043 if (chain
->num_entries
< 2)
4045 next
= next
->next_entry
;
4049 points_to_entry
= & entry
->next_entry
;
4051 next
= next
->next_entry
;
4056 chain
->last_entry
= entry
;
4061 /* Attach B's chain onto A. */
4063 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4065 if (bchain
->num_entries
== 0)
4068 achain
->num_entries
+= bchain
->num_entries
;
4070 if (achain
->first_entry
== NULL
)
4072 achain
->first_entry
= bchain
->first_entry
;
4073 achain
->last_entry
= bchain
->last_entry
;
4077 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4078 achain
->last_entry
= bchain
->last_entry
;
4081 bchain
->num_entries
= 0;
4082 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4086 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4088 rsrc_directory
* adir
;
4089 rsrc_directory
* bdir
;
4091 BFD_ASSERT (a
->is_dir
);
4092 BFD_ASSERT (b
->is_dir
);
4094 adir
= a
->value
.directory
;
4095 bdir
= b
->value
.directory
;
4097 if (adir
->characteristics
!= bdir
->characteristics
)
4099 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
4100 bfd_set_error (bfd_error_file_truncated
);
4104 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4106 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
4107 bfd_set_error (bfd_error_file_truncated
);
4111 /* Attach B's name chain to A. */
4112 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4114 /* Attach B's ID chain to A. */
4115 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4117 /* Now sort A's entries. */
4118 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
4119 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4122 /* Check the .rsrc section. If it contains multiple concatenated
4123 resources then we must merge them properly. Otherwise Windows
4124 will ignore all but the first set. */
4127 rsrc_process_section (bfd
* abfd
,
4128 struct coff_final_link_info
* pfinfo
)
4130 rsrc_directory new_table
;
4136 bfd_byte
* datastart
;
4138 bfd_byte
* new_data
;
4139 unsigned int num_resource_sets
;
4140 rsrc_directory
* type_tables
;
4141 rsrc_write_data write_data
;
4144 unsigned int num_input_rsrc
= 0;
4145 unsigned int max_num_input_rsrc
= 4;
4146 ptrdiff_t * rsrc_sizes
= NULL
;
4148 new_table
.names
.num_entries
= 0;
4149 new_table
.ids
.num_entries
= 0;
4151 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4152 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4155 pe
= pe_data (abfd
);
4159 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4161 data
= bfd_malloc (size
);
4167 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4170 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4171 their lengths. Note - we rely upon the fact that the linker script
4172 does *not* sort the input .rsrc sections, so that the order in the
4173 linkinfo list matches the order in the output .rsrc section.
4175 We need to know the lengths because each input .rsrc section has padding
4176 at the end of a variable amount. (It does not appear to be based upon
4177 the section alignment or the file alignment). We need to skip any
4178 padding bytes when parsing the input .rsrc sections. */
4179 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4180 if (rsrc_sizes
== NULL
)
4183 for (input
= pfinfo
->info
->input_bfds
;
4185 input
= input
->link
.next
)
4187 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4189 /* PR 18372 - skip discarded .rsrc sections. */
4190 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4192 if (num_input_rsrc
== max_num_input_rsrc
)
4194 max_num_input_rsrc
+= 10;
4195 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4196 * sizeof * rsrc_sizes
);
4197 if (rsrc_sizes
== NULL
)
4201 BFD_ASSERT (rsrc_sec
->size
> 0);
4202 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4206 if (num_input_rsrc
< 2)
4209 /* Step one: Walk the section, computing the size of the tables,
4210 leaves and data and decide if we need to do anything. */
4211 dataend
= data
+ size
;
4212 num_resource_sets
= 0;
4214 while (data
< dataend
)
4216 bfd_byte
* p
= data
;
4218 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4222 /* Corrupted .rsrc section - cannot merge. */
4223 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4224 bfd_get_filename (abfd
));
4225 bfd_set_error (bfd_error_file_truncated
);
4229 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4231 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4232 bfd_get_filename (abfd
));
4233 bfd_set_error (bfd_error_file_truncated
);
4236 /* FIXME: Should we add a check for "data - p" being much smaller
4237 than rsrc_sizes[num_resource_sets] ? */
4239 data
= p
+ rsrc_sizes
[num_resource_sets
];
4240 rva_bias
+= data
- p
;
4241 ++ num_resource_sets
;
4243 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4245 /* Step two: Walk the data again, building trees of the resources. */
4247 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4249 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4250 if (type_tables
== NULL
)
4254 while (data
< dataend
)
4256 bfd_byte
* p
= data
;
4258 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4259 dataend
, rva_bias
, NULL
);
4260 data
= p
+ rsrc_sizes
[indx
];
4261 rva_bias
+= data
- p
;
4264 BFD_ASSERT (indx
== num_resource_sets
);
4266 /* Step three: Merge the top level tables (there can be only one).
4268 We must ensure that the merged entries are in ascending order.
4270 We also thread the top level table entries from the old tree onto
4271 the new table, so that they can be pulled off later. */
4273 /* FIXME: Should we verify that all type tables are the same ? */
4274 new_table
.characteristics
= type_tables
[0].characteristics
;
4275 new_table
.time
= type_tables
[0].time
;
4276 new_table
.major
= type_tables
[0].major
;
4277 new_table
.minor
= type_tables
[0].minor
;
4279 /* Chain the NAME entries onto the table. */
4280 new_table
.names
.first_entry
= NULL
;
4281 new_table
.names
.last_entry
= NULL
;
4283 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4284 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4286 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4288 /* Chain the ID entries onto the table. */
4289 new_table
.ids
.first_entry
= NULL
;
4290 new_table
.ids
.last_entry
= NULL
;
4292 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4293 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4295 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4297 /* Step four: Create new contents for the .rsrc section. */
4298 /* Step four point one: Compute the size of each region of the .rsrc section.
4299 We do this now, rather than earlier, as the merging above may have dropped
4301 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4302 rsrc_compute_region_sizes (& new_table
);
4303 /* We increment sizeof_strings to make sure that resource data
4304 starts on an 8-byte boundary. FIXME: Is this correct ? */
4305 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4307 new_data
= bfd_zalloc (abfd
, size
);
4308 if (new_data
== NULL
)
4311 write_data
.abfd
= abfd
;
4312 write_data
.datastart
= new_data
;
4313 write_data
.next_table
= new_data
;
4314 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4315 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4316 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4317 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4319 rsrc_write_directory (& write_data
, & new_table
);
4321 /* Step five: Replace the old contents with the new.
4322 We don't recompute the size as it's too late here to shrink section.
4323 See PR ld/20193 for more details. */
4324 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4325 sec
->size
= sec
->rawsize
= size
;
4328 /* Step six: Free all the memory that we have used. */
4329 /* FIXME: Free the resource tree, if we have one. */
4334 /* Handle the .idata section and other things that need symbol table
4338 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4340 struct coff_link_hash_entry
*h1
;
4341 struct bfd_link_info
*info
= pfinfo
->info
;
4342 bfd_boolean result
= TRUE
;
4344 /* There are a few fields that need to be filled in now while we
4345 have symbol table access.
4347 The .idata subsections aren't directly available as sections, but
4348 they are in the symbol table, so get them from there. */
4350 /* The import directory. This is the address of .idata$2, with size
4351 of .idata$2 + .idata$3. */
4352 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4353 ".idata$2", FALSE
, FALSE
, TRUE
);
4356 /* PR ld/2729: We cannot rely upon all the output sections having been
4357 created properly, so check before referencing them. Issue a warning
4358 message for any sections tht could not be found. */
4359 if ((h1
->root
.type
== bfd_link_hash_defined
4360 || h1
->root
.type
== bfd_link_hash_defweak
)
4361 && h1
->root
.u
.def
.section
!= NULL
4362 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4363 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4364 (h1
->root
.u
.def
.value
4365 + h1
->root
.u
.def
.section
->output_section
->vma
4366 + h1
->root
.u
.def
.section
->output_offset
);
4370 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4375 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4376 ".idata$4", FALSE
, FALSE
, TRUE
);
4378 && (h1
->root
.type
== bfd_link_hash_defined
4379 || h1
->root
.type
== bfd_link_hash_defweak
)
4380 && h1
->root
.u
.def
.section
!= NULL
4381 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4382 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4383 ((h1
->root
.u
.def
.value
4384 + h1
->root
.u
.def
.section
->output_section
->vma
4385 + h1
->root
.u
.def
.section
->output_offset
)
4386 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4390 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4395 /* The import address table. This is the size/address of
4397 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4398 ".idata$5", FALSE
, FALSE
, TRUE
);
4400 && (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_IMPORT_ADDRESS_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
);
4411 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4416 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4417 ".idata$6", FALSE
, FALSE
, TRUE
);
4419 && (h1
->root
.type
== bfd_link_hash_defined
4420 || h1
->root
.type
== bfd_link_hash_defweak
)
4421 && h1
->root
.u
.def
.section
!= NULL
4422 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4423 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4424 ((h1
->root
.u
.def
.value
4425 + h1
->root
.u
.def
.section
->output_section
->vma
4426 + h1
->root
.u
.def
.section
->output_offset
)
4427 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4431 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4438 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4439 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4441 && (h1
->root
.type
== bfd_link_hash_defined
4442 || h1
->root
.type
== bfd_link_hash_defweak
)
4443 && h1
->root
.u
.def
.section
!= NULL
4444 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4449 (h1
->root
.u
.def
.value
4450 + h1
->root
.u
.def
.section
->output_section
->vma
4451 + h1
->root
.u
.def
.section
->output_offset
);
4453 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4454 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4456 && (h1
->root
.type
== bfd_link_hash_defined
4457 || h1
->root
.type
== bfd_link_hash_defweak
)
4458 && h1
->root
.u
.def
.section
!= NULL
4459 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4461 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4462 ((h1
->root
.u
.def
.value
4463 + h1
->root
.u
.def
.section
->output_section
->vma
4464 + h1
->root
.u
.def
.section
->output_offset
)
4466 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4467 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4468 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4473 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4474 " because .idata$6 is missing"), abfd
);
4480 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4481 (bfd_get_symbol_leading_char (abfd
) != 0
4482 ? "__tls_used" : "_tls_used"),
4483 FALSE
, FALSE
, TRUE
);
4486 if ((h1
->root
.type
== bfd_link_hash_defined
4487 || h1
->root
.type
== bfd_link_hash_defweak
)
4488 && h1
->root
.u
.def
.section
!= NULL
4489 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4490 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4491 (h1
->root
.u
.def
.value
4492 + h1
->root
.u
.def
.section
->output_section
->vma
4493 + h1
->root
.u
.def
.section
->output_offset
4494 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4498 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4502 /* According to PECOFF sepcifications by Microsoft version 8.2
4503 the TLS data directory consists of 4 pointers, followed
4504 by two 4-byte integer. This implies that the total size
4505 is different for 32-bit and 64-bit executables. */
4506 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4507 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4509 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4513 /* If there is a .pdata section and we have linked pdata finally, we
4514 need to sort the entries ascending. */
4515 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4517 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4521 bfd_size_type x
= sec
->rawsize
;
4522 bfd_byte
*tmp_data
= NULL
;
4525 tmp_data
= bfd_malloc (x
);
4527 if (tmp_data
!= NULL
)
4529 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4533 12, sort_x64_pdata
);
4534 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4545 rsrc_process_section (abfd
, pfinfo
);
4547 /* If we couldn't find idata$2, we either have an excessively
4548 trivial program or are in DEEP trouble; we have to assume trivial