1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2014 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
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"
69 /* NOTE: it's strange to be including an architecture specific header
70 in what's supposed to be general (to PE/PEI) code. However, that's
71 where the definitions are, and they don't vary per architecture
72 within PE/PEI, so we get them from there. FIXME: The lack of
73 variance is an assumption which may prove to be incorrect if new
74 PE/PEI targets are created. */
75 #if defined COFF_WITH_pex64
76 # include "coff/x86_64.h"
77 #elif defined COFF_WITH_pep
78 # include "coff/ia64.h"
80 # include "coff/i386.h"
86 #include "safe-ctype.h"
88 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
90 # define AOUTSZ PEPAOUTSZ
91 # define PEAOUTHDR PEPAOUTHDR
94 #define HighBitSet(val) ((val) & 0x80000000)
95 #define SetHighBit(val) ((val) | 0x80000000)
96 #define WithoutHighBit(val) ((val) & 0x7fffffff)
98 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
99 worked when the code was in peicode.h, but no longer work now that
100 the code is in peigen.c. PowerPC NT is said to be dead. If
101 anybody wants to revive the code, you will have to figure out how
102 to handle those issues. */
105 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
107 SYMENT
*ext
= (SYMENT
*) ext1
;
108 struct internal_syment
*in
= (struct internal_syment
*) in1
;
110 if (ext
->e
.e_name
[0] == 0)
112 in
->_n
._n_n
._n_zeroes
= 0;
113 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
116 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
118 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
119 in
->n_scnum
= H_GET_16 (abfd
, ext
->e_scnum
);
121 if (sizeof (ext
->e_type
) == 2)
122 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
124 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
126 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
127 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
129 #ifndef STRICT_PE_FORMAT
130 /* This is for Gnu-created DLLs. */
132 /* The section symbols for the .idata$ sections have class 0x68
133 (C_SECTION), which MS documentation indicates is a section
134 symbol. Unfortunately, the value field in the symbol is simply a
135 copy of the .idata section's flags rather than something useful.
136 When these symbols are encountered, change the value to 0 so that
137 they will be handled somewhat correctly in the bfd code. */
138 if (in
->n_sclass
== C_SECTION
)
140 char namebuf
[SYMNMLEN
+ 1];
141 const char *name
= NULL
;
145 /* Create synthetic empty sections as needed. DJ */
146 if (in
->n_scnum
== 0)
150 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
152 /* FIXME: Return error. */
154 sec
= bfd_get_section_by_name (abfd
, name
);
156 in
->n_scnum
= sec
->target_index
;
159 if (in
->n_scnum
== 0)
161 int unused_section_number
= 0;
165 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
166 if (unused_section_number
<= sec
->target_index
)
167 unused_section_number
= sec
->target_index
+ 1;
171 name
= (const char *) bfd_alloc (abfd
, strlen (namebuf
) + 1);
173 /* FIXME: Return error. */
175 strcpy ((char *) name
, namebuf
);
177 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
178 sec
= bfd_make_section_anyway_with_flags (abfd
, name
, flags
);
180 /* FIXME: Return error. */
187 sec
->rel_filepos
= 0;
188 sec
->reloc_count
= 0;
189 sec
->line_filepos
= 0;
190 sec
->lineno_count
= 0;
191 sec
->userdata
= NULL
;
193 sec
->alignment_power
= 2;
195 sec
->target_index
= unused_section_number
;
197 in
->n_scnum
= unused_section_number
;
199 in
->n_sclass
= C_STAT
;
203 #ifdef coff_swap_sym_in_hook
204 /* This won't work in peigen.c, but since it's for PPC PE, it's not
206 coff_swap_sym_in_hook (abfd
, ext1
, in1
);
211 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
213 bfd_vma abs_val
= * (bfd_vma
*) data
;
215 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
219 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
221 struct internal_syment
*in
= (struct internal_syment
*) inp
;
222 SYMENT
*ext
= (SYMENT
*) extp
;
224 if (in
->_n
._n_name
[0] == 0)
226 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
227 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
230 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
232 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
233 symbol. This is a problem on 64-bit targets where we can generate
234 absolute symbols with values >= 1^32. We try to work around this
235 problem by finding a section whose base address is sufficient to
236 reduce the absolute value to < 1^32, and then transforming the
237 symbol into a section relative symbol. This of course is a hack. */
238 if (sizeof (in
->n_value
) > 4
239 /* The strange computation of the shift amount is here in order to
240 avoid a compile time warning about the comparison always being
241 false. It does not matter if this test fails to work as expected
242 as the worst that can happen is that some absolute symbols are
243 needlessly converted into section relative symbols. */
244 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
245 && in
->n_scnum
== -1)
249 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
252 in
->n_value
-= sec
->vma
;
253 in
->n_scnum
= sec
->target_index
;
255 /* else: FIXME: The value is outside the range of any section. This
256 happens for __image_base__ and __ImageBase and maybe some other
257 symbols as well. We should find a way to handle these values. */
260 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
261 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
263 if (sizeof (ext
->e_type
) == 2)
264 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
266 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
268 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
269 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
275 _bfd_XXi_swap_aux_in (bfd
* abfd
,
279 int indx ATTRIBUTE_UNUSED
,
280 int numaux ATTRIBUTE_UNUSED
,
283 AUXENT
*ext
= (AUXENT
*) ext1
;
284 union internal_auxent
*in
= (union internal_auxent
*) in1
;
289 if (ext
->x_file
.x_fname
[0] == 0)
291 in
->x_file
.x_n
.x_zeroes
= 0;
292 in
->x_file
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
295 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
303 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
304 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
305 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
306 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
307 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
308 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
314 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
315 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
317 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
320 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
321 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
325 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
326 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
327 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
328 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
329 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
330 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
331 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
332 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
337 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
341 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
342 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
347 _bfd_XXi_swap_aux_out (bfd
* abfd
,
351 int indx ATTRIBUTE_UNUSED
,
352 int numaux ATTRIBUTE_UNUSED
,
355 union internal_auxent
*in
= (union internal_auxent
*) inp
;
356 AUXENT
*ext
= (AUXENT
*) extp
;
358 memset (ext
, 0, AUXESZ
);
363 if (in
->x_file
.x_fname
[0] == 0)
365 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
366 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
369 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
378 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
379 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
380 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
381 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
382 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
383 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
389 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
390 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
392 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
395 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
396 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
400 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
401 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
402 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
403 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
404 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
405 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
406 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
407 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
411 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
414 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
415 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
422 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
424 LINENO
*ext
= (LINENO
*) ext1
;
425 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
427 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
428 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
432 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
434 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
435 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
436 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
438 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
443 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
447 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
448 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
449 struct internal_aouthdr
*aouthdr_int
450 = (struct internal_aouthdr
*) aouthdr_int1
;
451 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
453 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
454 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
455 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
456 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
457 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
458 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
459 aouthdr_int
->text_start
=
460 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
461 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
462 /* PE32+ does not have data_start member! */
463 aouthdr_int
->data_start
=
464 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
465 a
->BaseOfData
= aouthdr_int
->data_start
;
468 a
->Magic
= aouthdr_int
->magic
;
469 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
470 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
471 a
->SizeOfCode
= aouthdr_int
->tsize
;
472 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
473 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
474 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
475 a
->BaseOfCode
= aouthdr_int
->text_start
;
476 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
477 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
478 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
479 a
->MajorOperatingSystemVersion
=
480 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
481 a
->MinorOperatingSystemVersion
=
482 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
483 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
484 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
485 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
486 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
487 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
488 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
489 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
490 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
491 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
492 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
493 a
->SizeOfStackReserve
=
494 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
495 a
->SizeOfStackCommit
=
496 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
497 a
->SizeOfHeapReserve
=
498 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
499 a
->SizeOfHeapCommit
=
500 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
501 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
502 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
507 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
508 if (a
->NumberOfRvaAndSizes
> 16)
510 (*_bfd_error_handler
)
511 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
512 abfd
, a
->NumberOfRvaAndSizes
);
513 /* Paranoia: If the number is corrupt, then assume that the
514 actual entries themselves might be corrupt as well. */
515 a
->NumberOfRvaAndSizes
= 0;
518 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
520 /* If data directory is empty, rva also should be 0. */
522 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
524 a
->DataDirectory
[idx
].Size
= size
;
527 a
->DataDirectory
[idx
].VirtualAddress
=
528 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
530 a
->DataDirectory
[idx
].VirtualAddress
= 0;
534 if (aouthdr_int
->entry
)
536 aouthdr_int
->entry
+= a
->ImageBase
;
537 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
538 aouthdr_int
->entry
&= 0xffffffff;
542 if (aouthdr_int
->tsize
)
544 aouthdr_int
->text_start
+= a
->ImageBase
;
545 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
546 aouthdr_int
->text_start
&= 0xffffffff;
550 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
551 /* PE32+ does not have data_start member! */
552 if (aouthdr_int
->dsize
)
554 aouthdr_int
->data_start
+= a
->ImageBase
;
555 aouthdr_int
->data_start
&= 0xffffffff;
560 /* These three fields are normally set up by ppc_relocate_section.
561 In the case of reading a file in, we can pick them up from the
563 first_thunk_address
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
;
564 thunk_size
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
;
565 import_table_size
= a
->DataDirectory
[PE_IMPORT_TABLE
].Size
;
569 /* A support function for below. */
572 add_data_entry (bfd
* abfd
,
573 struct internal_extra_pe_aouthdr
*aout
,
578 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
580 /* Add import directory information if it exists. */
582 && (coff_section_data (abfd
, sec
) != NULL
)
583 && (pei_section_data (abfd
, sec
) != NULL
))
585 /* If data directory is empty, rva also should be 0. */
586 int size
= pei_section_data (abfd
, sec
)->virt_size
;
587 aout
->DataDirectory
[idx
].Size
= size
;
591 aout
->DataDirectory
[idx
].VirtualAddress
=
592 (sec
->vma
- base
) & 0xffffffff;
593 sec
->flags
|= SEC_DATA
;
599 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
601 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
602 pe_data_type
*pe
= pe_data (abfd
);
603 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
604 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
606 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
608 sa
= extra
->SectionAlignment
;
609 fa
= extra
->FileAlignment
;
610 ib
= extra
->ImageBase
;
612 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
613 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
614 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
616 if (aouthdr_in
->tsize
)
618 aouthdr_in
->text_start
-= ib
;
619 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
620 aouthdr_in
->text_start
&= 0xffffffff;
624 if (aouthdr_in
->dsize
)
626 aouthdr_in
->data_start
-= ib
;
627 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
628 aouthdr_in
->data_start
&= 0xffffffff;
632 if (aouthdr_in
->entry
)
634 aouthdr_in
->entry
-= ib
;
635 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
636 aouthdr_in
->entry
&= 0xffffffff;
640 #define FA(x) (((x) + fa -1 ) & (- fa))
641 #define SA(x) (((x) + sa -1 ) & (- sa))
643 /* We like to have the sizes aligned. */
644 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
646 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
648 add_data_entry (abfd
, extra
, 0, ".edata", ib
);
649 add_data_entry (abfd
, extra
, 2, ".rsrc", ib
);
650 add_data_entry (abfd
, extra
, 3, ".pdata", ib
);
652 /* In theory we do not need to call add_data_entry for .idata$2 or
653 .idata$5. It will be done in bfd_coff_final_link where all the
654 required information is available. If however, we are not going
655 to perform a final link, eg because we have been invoked by objcopy
656 or strip, then we need to make sure that these Data Directory
657 entries are initialised properly.
659 So - we copy the input values into the output values, and then, if
660 a final link is going to be performed, it can overwrite them. */
661 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
662 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
663 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
665 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
666 /* Until other .idata fixes are made (pending patch), the entry for
667 .idata is needed for backwards compatibility. FIXME. */
668 add_data_entry (abfd
, extra
, 1, ".idata", ib
);
670 /* For some reason, the virtual size (which is what's set by
671 add_data_entry) for .reloc is not the same as the size recorded
672 in this slot by MSVC; it doesn't seem to cause problems (so far),
673 but since it's the best we've got, use it. It does do the right
675 if (pe
->has_reloc_section
)
676 add_data_entry (abfd
, extra
, 5, ".reloc", ib
);
685 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
687 int rounded
= FA (sec
->size
);
689 /* The first non-zero section filepos is the header size.
690 Sections without contents will have a filepos of 0. */
692 hsize
= sec
->filepos
;
693 if (sec
->flags
& SEC_DATA
)
695 if (sec
->flags
& SEC_CODE
)
697 /* The image size is the total VIRTUAL size (which is what is
698 in the virt_size field). Files have been seen (from MSVC
699 5.0 link.exe) where the file size of the .data segment is
700 quite small compared to the virtual size. Without this
701 fix, strip munges the file.
703 FIXME: We need to handle holes between sections, which may
704 happpen when we covert from another format. We just use
705 the virtual address and virtual size of the last section
706 for the image size. */
707 if (coff_section_data (abfd
, sec
) != NULL
708 && pei_section_data (abfd
, sec
) != NULL
)
709 isize
= (sec
->vma
- extra
->ImageBase
710 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
713 aouthdr_in
->dsize
= dsize
;
714 aouthdr_in
->tsize
= tsize
;
715 extra
->SizeOfHeaders
= hsize
;
716 extra
->SizeOfImage
= isize
;
719 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
721 /* e.g. 219510000 is linker version 2.19 */
722 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
724 /* This piece of magic sets the "linker version" field to
726 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
727 aouthdr_out
->standard
.vstamp
);
729 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
730 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
731 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
732 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
733 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
734 aouthdr_out
->standard
.text_start
);
736 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
737 /* PE32+ does not have data_start member! */
738 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
739 aouthdr_out
->standard
.data_start
);
742 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
743 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
744 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
745 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
746 aouthdr_out
->MajorOperatingSystemVersion
);
747 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
748 aouthdr_out
->MinorOperatingSystemVersion
);
749 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
750 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
751 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
752 aouthdr_out
->MajorSubsystemVersion
);
753 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
754 aouthdr_out
->MinorSubsystemVersion
);
755 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
756 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
757 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
758 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
759 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
760 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
761 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
762 aouthdr_out
->SizeOfStackReserve
);
763 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
764 aouthdr_out
->SizeOfStackCommit
);
765 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
766 aouthdr_out
->SizeOfHeapReserve
);
767 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
768 aouthdr_out
->SizeOfHeapCommit
);
769 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
770 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
771 aouthdr_out
->NumberOfRvaAndSizes
);
775 for (idx
= 0; idx
< 16; idx
++)
777 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
778 aouthdr_out
->DataDirectory
[idx
][0]);
779 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
780 aouthdr_out
->DataDirectory
[idx
][1]);
788 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
791 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
792 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
794 if (pe_data (abfd
)->has_reloc_section
795 || pe_data (abfd
)->dont_strip_reloc
)
796 filehdr_in
->f_flags
&= ~F_RELFLG
;
798 if (pe_data (abfd
)->dll
)
799 filehdr_in
->f_flags
|= F_DLL
;
801 filehdr_in
->pe
.e_magic
= DOSMAGIC
;
802 filehdr_in
->pe
.e_cblp
= 0x90;
803 filehdr_in
->pe
.e_cp
= 0x3;
804 filehdr_in
->pe
.e_crlc
= 0x0;
805 filehdr_in
->pe
.e_cparhdr
= 0x4;
806 filehdr_in
->pe
.e_minalloc
= 0x0;
807 filehdr_in
->pe
.e_maxalloc
= 0xffff;
808 filehdr_in
->pe
.e_ss
= 0x0;
809 filehdr_in
->pe
.e_sp
= 0xb8;
810 filehdr_in
->pe
.e_csum
= 0x0;
811 filehdr_in
->pe
.e_ip
= 0x0;
812 filehdr_in
->pe
.e_cs
= 0x0;
813 filehdr_in
->pe
.e_lfarlc
= 0x40;
814 filehdr_in
->pe
.e_ovno
= 0x0;
816 for (idx
= 0; idx
< 4; idx
++)
817 filehdr_in
->pe
.e_res
[idx
] = 0x0;
819 filehdr_in
->pe
.e_oemid
= 0x0;
820 filehdr_in
->pe
.e_oeminfo
= 0x0;
822 for (idx
= 0; idx
< 10; idx
++)
823 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
825 filehdr_in
->pe
.e_lfanew
= 0x80;
827 /* This next collection of data are mostly just characters. It
828 appears to be constant within the headers put on NT exes. */
829 filehdr_in
->pe
.dos_message
[0] = 0x0eba1f0e;
830 filehdr_in
->pe
.dos_message
[1] = 0xcd09b400;
831 filehdr_in
->pe
.dos_message
[2] = 0x4c01b821;
832 filehdr_in
->pe
.dos_message
[3] = 0x685421cd;
833 filehdr_in
->pe
.dos_message
[4] = 0x70207369;
834 filehdr_in
->pe
.dos_message
[5] = 0x72676f72;
835 filehdr_in
->pe
.dos_message
[6] = 0x63206d61;
836 filehdr_in
->pe
.dos_message
[7] = 0x6f6e6e61;
837 filehdr_in
->pe
.dos_message
[8] = 0x65622074;
838 filehdr_in
->pe
.dos_message
[9] = 0x6e757220;
839 filehdr_in
->pe
.dos_message
[10] = 0x206e6920;
840 filehdr_in
->pe
.dos_message
[11] = 0x20534f44;
841 filehdr_in
->pe
.dos_message
[12] = 0x65646f6d;
842 filehdr_in
->pe
.dos_message
[13] = 0x0a0d0d2e;
843 filehdr_in
->pe
.dos_message
[14] = 0x24;
844 filehdr_in
->pe
.dos_message
[15] = 0x0;
845 filehdr_in
->pe
.nt_signature
= NT_SIGNATURE
;
847 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
848 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
850 /* Only use a real timestamp if the option was chosen. */
851 if ((pe_data (abfd
)->insert_timestamp
))
852 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
854 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
855 filehdr_out
->f_symptr
);
856 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
857 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
858 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
860 /* Put in extra dos header stuff. This data remains essentially
861 constant, it just has to be tacked on to the beginning of all exes
863 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
864 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
865 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
866 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
867 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
868 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
869 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
870 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
871 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
874 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
878 for (idx
= 0; idx
< 4; idx
++)
879 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
881 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
882 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
884 for (idx
= 0; idx
< 10; idx
++)
885 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
887 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
889 for (idx
= 0; idx
< 16; idx
++)
890 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
891 filehdr_out
->dos_message
[idx
]);
893 /* Also put in the NT signature. */
894 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
900 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
902 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
903 FILHDR
*filehdr_out
= (FILHDR
*) out
;
905 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
906 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
907 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
908 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
909 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
910 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
911 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
917 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
919 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
920 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
921 unsigned int ret
= SCNHSZ
;
925 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
927 PUT_SCNHDR_VADDR (abfd
,
928 ((scnhdr_int
->s_vaddr
929 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
931 scnhdr_ext
->s_vaddr
);
933 /* NT wants the size data to be rounded up to the next
934 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
936 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
938 if (bfd_pei_p (abfd
))
940 ps
= scnhdr_int
->s_size
;
946 ss
= scnhdr_int
->s_size
;
951 if (bfd_pei_p (abfd
))
952 ps
= scnhdr_int
->s_paddr
;
956 ss
= scnhdr_int
->s_size
;
959 PUT_SCNHDR_SIZE (abfd
, ss
,
962 /* s_paddr in PE is really the virtual size. */
963 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
965 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
966 scnhdr_ext
->s_scnptr
);
967 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
968 scnhdr_ext
->s_relptr
);
969 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
970 scnhdr_ext
->s_lnnoptr
);
973 /* Extra flags must be set when dealing with PE. All sections should also
974 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
975 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
976 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
977 (this is especially important when dealing with the .idata section since
978 the addresses for routines from .dlls must be overwritten). If .reloc
979 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
980 (0x02000000). Also, the resource data should also be read and
983 /* FIXME: Alignment is also encoded in this field, at least on PPC and
984 ARM-WINCE. Although - how do we get the original alignment field
989 const char * section_name
;
990 unsigned long must_have
;
992 pe_required_section_flags
;
994 pe_required_section_flags known_sections
[] =
996 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
997 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
998 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
999 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1000 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1001 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1002 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1003 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1004 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1005 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1006 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1007 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1011 pe_required_section_flags
* p
;
1013 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1014 we know exactly what this specific section wants so we remove it
1015 and then allow the must_have field to add it back in if necessary.
1016 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1017 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1018 by ld --enable-auto-import (if auto-import is actually needed),
1019 by ld --omagic, or by obcopy --writable-text. */
1021 for (p
= known_sections
; p
->section_name
; p
++)
1022 if (strcmp (scnhdr_int
->s_name
, p
->section_name
) == 0)
1024 if (strcmp (scnhdr_int
->s_name
, ".text")
1025 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1026 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1027 scnhdr_int
->s_flags
|= p
->must_have
;
1031 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1034 if (coff_data (abfd
)->link_info
1035 && ! coff_data (abfd
)->link_info
->relocatable
1036 && ! coff_data (abfd
)->link_info
->shared
1037 && strcmp (scnhdr_int
->s_name
, ".text") == 0)
1039 /* By inference from looking at MS output, the 32 bit field
1040 which is the combination of the number_of_relocs and
1041 number_of_linenos is used for the line number count in
1042 executables. A 16-bit field won't do for cc1. The MS
1043 document says that the number of relocs is zero for
1044 executables, but the 17-th bit has been observed to be there.
1045 Overflow is not an issue: a 4G-line program will overflow a
1046 bunch of other fields long before this! */
1047 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1048 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1052 if (scnhdr_int
->s_nlnno
<= 0xffff)
1053 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1056 (*_bfd_error_handler
) (_("%s: line number overflow: 0x%lx > 0xffff"),
1057 bfd_get_filename (abfd
),
1058 scnhdr_int
->s_nlnno
);
1059 bfd_set_error (bfd_error_file_truncated
);
1060 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1064 /* Although we could encode 0xffff relocs here, we do not, to be
1065 consistent with other parts of bfd. Also it lets us warn, as
1066 we should never see 0xffff here w/o having the overflow flag
1068 if (scnhdr_int
->s_nreloc
< 0xffff)
1069 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1072 /* PE can deal with large #s of relocs, but not here. */
1073 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1074 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1075 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1082 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1084 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1085 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1087 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1088 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1089 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1090 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1091 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1092 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1093 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1094 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1098 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1100 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1101 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1103 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1104 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1105 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1106 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1107 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1108 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1109 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1110 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1112 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1115 static CODEVIEW_INFO
*
1116 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1120 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1123 if (bfd_bread (buffer
, 256, abfd
) < 4)
1126 /* Ensure null termination of filename. */
1129 cvinfo
->CVSignature
= H_GET_32(abfd
, buffer
);
1132 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1133 && (length
> sizeof (CV_INFO_PDB70
)))
1135 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1137 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1139 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1140 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1141 as 16 bytes in big-endian order. */
1142 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1143 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1144 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1145 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1147 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1148 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1152 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1153 && (length
> sizeof (CV_INFO_PDB20
)))
1155 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1156 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1157 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1158 cvinfo
->SignatureLength
= 4;
1159 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1168 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1170 unsigned int size
= sizeof (CV_INFO_PDB70
) + 1;
1171 CV_INFO_PDB70
*cvinfo70
;
1174 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1177 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1178 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1180 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1181 in little-endian order, followed by 8 single bytes. */
1182 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1183 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1184 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1185 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1187 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1188 cvinfo70
->PdbFileName
[0] = '\0';
1190 if (bfd_bwrite (buffer
, size
, abfd
) != size
)
1196 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1198 N_("Export Directory [.edata (or where ever we found it)]"),
1199 N_("Import Directory [parts of .idata]"),
1200 N_("Resource Directory [.rsrc]"),
1201 N_("Exception Directory [.pdata]"),
1202 N_("Security Directory"),
1203 N_("Base Relocation Directory [.reloc]"),
1204 N_("Debug Directory"),
1205 N_("Description Directory"),
1206 N_("Special Directory"),
1207 N_("Thread Storage Directory [.tls]"),
1208 N_("Load Configuration Directory"),
1209 N_("Bound Import Directory"),
1210 N_("Import Address Table Directory"),
1211 N_("Delay Import Directory"),
1212 N_("CLR Runtime Header"),
1216 #ifdef POWERPC_LE_PE
1217 /* The code for the PPC really falls in the "architecture dependent"
1218 category. However, it's not clear that anyone will ever care, so
1219 we're ignoring the issue for now; if/when PPC matters, some of this
1220 may need to go into peicode.h, or arguments passed to enable the
1221 PPC- specific code. */
1225 pe_print_idata (bfd
* abfd
, void * vfile
)
1227 FILE *file
= (FILE *) vfile
;
1232 #ifdef POWERPC_LE_PE
1233 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1236 bfd_size_type datasize
= 0;
1237 bfd_size_type dataoff
;
1241 pe_data_type
*pe
= pe_data (abfd
);
1242 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1246 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1248 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1250 /* Maybe the extra header isn't there. Look for the section. */
1251 section
= bfd_get_section_by_name (abfd
, ".idata");
1252 if (section
== NULL
)
1255 addr
= section
->vma
;
1256 datasize
= section
->size
;
1262 addr
+= extra
->ImageBase
;
1263 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1265 datasize
= section
->size
;
1266 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1270 if (section
== NULL
)
1273 _("\nThere is an import table, but the section containing it could not be found\n"));
1276 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1279 _("\nThere is an import table in %s, but that section has no contents\n"),
1285 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1286 section
->name
, (unsigned long) addr
);
1288 dataoff
= addr
- section
->vma
;
1290 #ifdef POWERPC_LE_PE
1291 if (rel_section
!= 0 && rel_section
->size
!= 0)
1293 /* The toc address can be found by taking the starting address,
1294 which on the PPC locates a function descriptor. The
1295 descriptor consists of the function code starting address
1296 followed by the address of the toc. The starting address we
1297 get from the bfd, and the descriptor is supposed to be in the
1298 .reldata section. */
1300 bfd_vma loadable_toc_address
;
1301 bfd_vma toc_address
;
1302 bfd_vma start_address
;
1306 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1313 offset
= abfd
->start_address
- rel_section
->vma
;
1315 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1322 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1323 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1324 toc_address
= loadable_toc_address
- 32768;
1327 _("\nFunction descriptor located at the start address: %04lx\n"),
1328 (unsigned long int) (abfd
->start_address
));
1330 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1331 start_address
, loadable_toc_address
, toc_address
);
1338 _("\nNo reldata section! Function descriptor not decoded.\n"));
1343 _("\nThe Import Tables (interpreted %s section contents)\n"),
1347 vma: Hint Time Forward DLL First\n\
1348 Table Stamp Chain Name Thunk\n"));
1350 /* Read the whole section. Some of the fields might be before dataoff. */
1351 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1358 adj
= section
->vma
- extra
->ImageBase
;
1360 /* Print all image import descriptors. */
1361 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1365 bfd_vma forward_chain
;
1367 bfd_vma first_thunk
;
1372 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1373 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1374 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1375 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1376 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1377 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1378 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1380 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1381 (unsigned long) hint_addr
,
1382 (unsigned long) time_stamp
,
1383 (unsigned long) forward_chain
,
1384 (unsigned long) dll_name
,
1385 (unsigned long) first_thunk
);
1387 if (hint_addr
== 0 && first_thunk
== 0)
1390 if (dll_name
- adj
>= section
->size
)
1393 dll
= (char *) data
+ dll_name
- adj
;
1394 fprintf (file
, _("\n\tDLL Name: %s\n"), dll
);
1399 asection
*ft_section
;
1401 bfd_size_type ft_datasize
;
1405 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1407 idx
= hint_addr
- adj
;
1409 ft_addr
= first_thunk
+ extra
->ImageBase
;
1410 ft_idx
= first_thunk
- adj
;
1411 ft_data
= data
+ ft_idx
;
1412 ft_datasize
= datasize
- ft_idx
;
1415 if (first_thunk
!= hint_addr
)
1417 /* Find the section which contains the first thunk. */
1418 for (ft_section
= abfd
->sections
;
1420 ft_section
= ft_section
->next
)
1422 if (ft_addr
>= ft_section
->vma
1423 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1427 if (ft_section
== NULL
)
1430 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1434 /* Now check to see if this section is the same as our current
1435 section. If it is not then we will have to load its data in. */
1436 if (ft_section
!= section
)
1438 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1439 ft_datasize
= ft_section
->size
- ft_idx
;
1440 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1441 if (ft_data
== NULL
)
1444 /* Read ft_datasize bytes starting at offset ft_idx. */
1445 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1446 (bfd_vma
) ft_idx
, ft_datasize
))
1455 /* Print HintName vector entries. */
1456 #ifdef COFF_WITH_pex64
1457 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1459 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1460 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1462 if (!member
&& !member_high
)
1465 if (HighBitSet (member_high
))
1466 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1467 member_high
, member
,
1468 WithoutHighBit (member_high
), member
);
1474 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1475 member_name
= (char *) data
+ member
- adj
+ 2;
1476 fprintf (file
, "\t%04lx\t %4d %s",member
, ordinal
, member_name
);
1479 /* If the time stamp is not zero, the import address
1480 table holds actual addresses. */
1483 && first_thunk
!= hint_addr
1484 && j
+ 4 <= ft_datasize
)
1485 fprintf (file
, "\t%04lx",
1486 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1487 fprintf (file
, "\n");
1490 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1492 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1494 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1498 if (HighBitSet (member
))
1499 fprintf (file
, "\t%04lx\t %4lu <none>",
1500 member
, WithoutHighBit (member
));
1506 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1507 member_name
= (char *) data
+ member
- adj
+ 2;
1508 fprintf (file
, "\t%04lx\t %4d %s",
1509 member
, ordinal
, member_name
);
1512 /* If the time stamp is not zero, the import address
1513 table holds actual addresses. */
1516 && first_thunk
!= hint_addr
1517 && j
+ 4 <= ft_datasize
)
1518 fprintf (file
, "\t%04lx",
1519 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1521 fprintf (file
, "\n");
1528 fprintf (file
, "\n");
1537 pe_print_edata (bfd
* abfd
, void * vfile
)
1539 FILE *file
= (FILE *) vfile
;
1542 bfd_size_type datasize
= 0;
1543 bfd_size_type dataoff
;
1548 long export_flags
; /* Reserved - should be zero. */
1552 bfd_vma name
; /* RVA - relative to image base. */
1553 long base
; /* Ordinal base. */
1554 unsigned long num_functions
;/* Number in the export address table. */
1555 unsigned long num_names
; /* Number in the name pointer table. */
1556 bfd_vma eat_addr
; /* RVA to the export address table. */
1557 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1558 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1561 pe_data_type
*pe
= pe_data (abfd
);
1562 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1566 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1568 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1570 /* Maybe the extra header isn't there. Look for the section. */
1571 section
= bfd_get_section_by_name (abfd
, ".edata");
1572 if (section
== NULL
)
1575 addr
= section
->vma
;
1577 datasize
= section
->size
;
1583 addr
+= extra
->ImageBase
;
1585 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1586 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1589 if (section
== NULL
)
1592 _("\nThere is an export table, but the section containing it could not be found\n"));
1595 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1598 _("\nThere is an export table in %s, but that section has no contents\n"),
1603 dataoff
= addr
- section
->vma
;
1604 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1605 if (datasize
> section
->size
- dataoff
)
1608 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1614 /* PR 17512: Handle corrupt PE binaries. */
1618 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1619 section
->name
, (int) datasize
);
1623 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1624 section
->name
, (unsigned long) addr
);
1626 data
= (bfd_byte
*) bfd_malloc (datasize
);
1630 if (! bfd_get_section_contents (abfd
, section
, data
,
1631 (file_ptr
) dataoff
, datasize
))
1634 /* Go get Export Directory Table. */
1635 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1636 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1637 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1638 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1639 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1640 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1641 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1642 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1643 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1644 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1645 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1647 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1649 /* Dump the EDT first. */
1651 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1655 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1658 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1661 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1664 _("Name \t\t\t\t"));
1665 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1667 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1668 fprintf (file
, " %s\n", data
+ edt
.name
- adj
);
1670 fprintf (file
, "(outside .edata section)\n");
1673 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1679 _("\tExport Address Table \t\t%08lx\n"),
1683 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1686 _("Table Addresses\n"));
1689 _("\tExport Address Table \t\t"));
1690 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1691 fprintf (file
, "\n");
1694 _("\tName Pointer Table \t\t"));
1695 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1696 fprintf (file
, "\n");
1699 _("\tOrdinal Table \t\t\t"));
1700 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1701 fprintf (file
, "\n");
1703 /* The next table to find is the Export Address Table. It's basically
1704 a list of pointers that either locate a function in this dll, or
1705 forward the call to another dll. Something like:
1710 } export_address_table_entry; */
1713 _("\nExport Address Table -- Ordinal Base %ld\n"),
1716 /* PR 17512: Handle corrupt PE binaries. */
1717 if (edt
.eat_addr
+ (edt
.num_functions
* 4) - adj
>= datasize
)
1718 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1719 (long) edt
.eat_addr
,
1720 (long) edt
.num_functions
);
1721 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1723 bfd_vma eat_member
= bfd_get_32 (abfd
,
1724 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1725 if (eat_member
== 0)
1728 if (eat_member
- adj
<= datasize
)
1730 /* This rva is to a name (forwarding function) in our section. */
1731 /* Should locate a function descriptor. */
1733 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1735 (long) (i
+ edt
.base
),
1736 (unsigned long) eat_member
,
1738 data
+ eat_member
- adj
);
1742 /* Should locate a function descriptor in the reldata section. */
1744 "\t[%4ld] +base[%4ld] %04lx %s\n",
1746 (long) (i
+ edt
.base
),
1747 (unsigned long) eat_member
,
1752 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1753 /* Dump them in parallel for clarity. */
1755 _("\n[Ordinal/Name Pointer] Table\n"));
1757 /* PR 17512: Handle corrupt PE binaries. */
1758 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
)
1759 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1760 (long) edt
.npt_addr
,
1761 (long) edt
.num_names
);
1762 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
)
1763 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1765 (long) edt
.num_names
);
1766 else for (i
= 0; i
< edt
.num_names
; ++i
)
1768 bfd_vma name_ptr
= bfd_get_32 (abfd
,
1773 char *name
= (char *) data
+ name_ptr
- adj
;
1775 bfd_vma ord
= bfd_get_16 (abfd
,
1780 "\t[%4ld] %s\n", (long) ord
, name
);
1788 /* This really is architecture dependent. On IA-64, a .pdata entry
1789 consists of three dwords containing relative virtual addresses that
1790 specify the start and end address of the code range the entry
1791 covers and the address of the corresponding unwind info data.
1793 On ARM and SH-4, a compressed PDATA structure is used :
1794 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1795 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1796 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1798 This is the version for uncompressed data. */
1801 pe_print_pdata (bfd
* abfd
, void * vfile
)
1803 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1804 # define PDATA_ROW_SIZE (3 * 8)
1806 # define PDATA_ROW_SIZE (5 * 4)
1808 FILE *file
= (FILE *) vfile
;
1810 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1811 bfd_size_type datasize
= 0;
1813 bfd_size_type start
, stop
;
1814 int onaline
= PDATA_ROW_SIZE
;
1817 || coff_section_data (abfd
, section
) == NULL
1818 || pei_section_data (abfd
, section
) == NULL
)
1821 stop
= pei_section_data (abfd
, section
)->virt_size
;
1822 if ((stop
% onaline
) != 0)
1824 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1825 (long) stop
, onaline
);
1828 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1829 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1831 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1834 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1835 \t\tAddress Address Handler Data Address Mask\n"));
1838 datasize
= section
->size
;
1842 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1851 for (i
= start
; i
< stop
; i
+= onaline
)
1857 bfd_vma prolog_end_addr
;
1858 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1862 if (i
+ PDATA_ROW_SIZE
> stop
)
1865 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1866 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1867 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1868 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1869 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1871 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1872 && eh_data
== 0 && prolog_end_addr
== 0)
1873 /* We are probably into the padding of the section now. */
1876 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1877 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1879 eh_handler
&= ~(bfd_vma
) 0x3;
1880 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1883 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1884 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1885 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1886 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1887 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1889 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1890 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1891 fprintf (file
, " %x", em_data
);
1894 #ifdef POWERPC_LE_PE
1895 if (eh_handler
== 0 && eh_data
!= 0)
1897 /* Special bits here, although the meaning may be a little
1898 mysterious. The only one I know for sure is 0x03
1901 0x01 Register Save Millicode
1902 0x02 Register Restore Millicode
1903 0x03 Glue Code Sequence. */
1907 fprintf (file
, _(" Register save millicode"));
1910 fprintf (file
, _(" Register restore millicode"));
1913 fprintf (file
, _(" Glue code sequence"));
1920 fprintf (file
, "\n");
1926 #undef PDATA_ROW_SIZE
1929 typedef struct sym_cache
1936 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1938 asymbol
** sy
= NULL
;
1941 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1947 storage
= bfd_get_symtab_upper_bound (abfd
);
1951 sy
= (asymbol
**) bfd_malloc (storage
);
1953 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1954 if (psc
->symcount
< 0)
1960 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1965 psc
->syms
= slurp_symtab (abfd
, psc
);
1967 for (i
= 0; i
< psc
->symcount
; i
++)
1969 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1970 return psc
->syms
[i
]->name
;
1977 cleanup_syms (sym_cache
*psc
)
1984 /* This is the version for "compressed" pdata. */
1987 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1989 # define PDATA_ROW_SIZE (2 * 4)
1990 FILE *file
= (FILE *) vfile
;
1991 bfd_byte
*data
= NULL
;
1992 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1993 bfd_size_type datasize
= 0;
1995 bfd_size_type start
, stop
;
1996 int onaline
= PDATA_ROW_SIZE
;
1997 struct sym_cache cache
= {0, 0} ;
2000 || coff_section_data (abfd
, section
) == NULL
2001 || pei_section_data (abfd
, section
) == NULL
)
2004 stop
= pei_section_data (abfd
, section
)->virt_size
;
2005 if ((stop
% onaline
) != 0)
2007 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2008 (long) stop
, onaline
);
2011 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2014 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2015 \t\tAddress Length Length 32b exc Handler Data\n"));
2017 datasize
= section
->size
;
2021 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2030 for (i
= start
; i
< stop
; i
+= onaline
)
2034 bfd_vma prolog_length
, function_length
;
2035 int flag32bit
, exception_flag
;
2038 if (i
+ PDATA_ROW_SIZE
> stop
)
2041 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2042 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2044 if (begin_addr
== 0 && other_data
== 0)
2045 /* We are probably into the padding of the section now. */
2048 prolog_length
= (other_data
& 0x000000FF);
2049 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2050 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2051 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2054 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2055 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2056 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2057 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2058 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2060 /* Get the exception handler's address and the data passed from the
2061 .text section. This is really the data that belongs with the .pdata
2062 but got "compressed" out for the ARM and SH4 architectures. */
2063 tsection
= bfd_get_section_by_name (abfd
, ".text");
2064 if (tsection
&& coff_section_data (abfd
, tsection
)
2065 && pei_section_data (abfd
, tsection
))
2067 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2070 tdata
= (bfd_byte
*) bfd_malloc (8);
2073 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2075 bfd_vma eh
, eh_data
;
2077 eh
= bfd_get_32 (abfd
, tdata
);
2078 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2079 fprintf (file
, "%08x ", (unsigned int) eh
);
2080 fprintf (file
, "%08x", (unsigned int) eh_data
);
2083 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2086 fprintf (file
, " (%s) ", s
);
2093 fprintf (file
, "\n");
2098 cleanup_syms (& cache
);
2101 #undef PDATA_ROW_SIZE
2105 #define IMAGE_REL_BASED_HIGHADJ 4
2106 static const char * const tbl
[] =
2120 "UNKNOWN", /* MUST be last. */
2124 pe_print_reloc (bfd
* abfd
, void * vfile
)
2126 FILE *file
= (FILE *) vfile
;
2128 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2131 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2135 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2137 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2145 end
= data
+ section
->size
;
2146 while (p
+ 8 <= end
)
2149 bfd_vma virtual_address
;
2151 bfd_byte
*chunk_end
;
2153 /* The .reloc section is a sequence of blocks, with a header consisting
2154 of two 32 bit quantities, followed by a number of 16 bit entries. */
2155 virtual_address
= bfd_get_32 (abfd
, p
);
2156 size
= bfd_get_32 (abfd
, p
+ 4);
2158 number
= (size
- 8) / 2;
2164 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2165 (unsigned long) virtual_address
, size
, (unsigned long) size
, number
);
2167 chunk_end
= p
+ size
;
2168 if (chunk_end
> end
)
2171 while (p
+ 2 <= chunk_end
)
2173 unsigned short e
= bfd_get_16 (abfd
, p
);
2174 unsigned int t
= (e
& 0xF000) >> 12;
2175 int off
= e
& 0x0FFF;
2177 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2178 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2181 _("\treloc %4d offset %4x [%4lx] %s"),
2182 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2187 /* HIGHADJ takes an argument, - the next record *is* the
2188 low 16 bits of addend. */
2189 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2191 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2196 fprintf (file
, "\n");
2205 /* A data structure describing the regions of a .rsrc section.
2206 Some fields are filled in as the section is parsed. */
2208 typedef struct rsrc_regions
2210 bfd_byte
* section_start
;
2211 bfd_byte
* section_end
;
2212 bfd_byte
* strings_start
;
2213 bfd_byte
* resource_start
;
2217 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2218 rsrc_regions
*, bfd_vma
);
2221 rsrc_print_resource_entries (FILE * file
,
2223 unsigned int indent
,
2224 bfd_boolean is_name
,
2226 rsrc_regions
* regions
,
2229 unsigned long entry
, addr
, size
;
2231 if (data
+ 8 >= regions
->section_end
)
2232 return regions
->section_end
+ 1;
2234 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2236 entry
= (long) bfd_get_32 (abfd
, data
);
2241 /* Note - the documentation says that this field is an RVA value
2242 but windres appears to produce a section relative offset with
2243 the top bit set. Support both styles for now. */
2244 if (HighBitSet (entry
))
2245 name
= regions
->section_start
+ WithoutHighBit (entry
);
2247 name
= regions
->section_start
+ entry
- rva_bias
;
2249 if (name
+ 2 < regions
->section_end
)
2253 if (regions
->strings_start
== NULL
)
2254 regions
->strings_start
= name
;
2256 len
= bfd_get_16 (abfd
, name
);
2258 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2259 if (name
+ 2 + len
* 2 < regions
->section_end
)
2261 /* This strange loop is to cope with multibyte characters. */
2265 fprintf (file
, "%.1s", name
);
2269 fprintf (file
, _("<corrupt string length: %#x>"), len
);
2272 fprintf (file
, _("<corrupt string offset: %#lx>"), entry
);
2275 fprintf (file
, _("ID: %#08lx"), entry
);
2277 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2278 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2280 if (HighBitSet (entry
))
2281 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1,
2282 regions
->section_start
+ WithoutHighBit (entry
),
2285 if (regions
->section_start
+ entry
+ 16 >= regions
->section_end
)
2286 return regions
->section_end
+ 1;
2288 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2291 addr
= (long) bfd_get_32 (abfd
, regions
->section_start
+ entry
),
2292 size
= (long) bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 4),
2293 (int) bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 8));
2295 /* Check that the reserved entry is 0. */
2296 if (bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 12) != 0
2297 /* And that the data address/size is valid too. */
2298 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2299 return regions
->section_end
+ 1;
2301 if (regions
->resource_start
== NULL
)
2302 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2304 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2307 #define max(a,b) ((a) > (b) ? (a) : (b))
2308 #define min(a,b) ((a) < (b) ? (a) : (b))
2311 rsrc_print_resource_directory (FILE * file
,
2313 unsigned int indent
,
2315 rsrc_regions
* regions
,
2318 unsigned int num_names
, num_ids
;
2319 bfd_byte
* highest_data
= data
;
2321 if (data
+ 16 >= regions
->section_end
)
2322 return regions
->section_end
+ 1;
2324 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2327 case 0: fprintf (file
, "Type"); break;
2328 case 2: fprintf (file
, "Name"); break;
2329 case 4: fprintf (file
, "Language"); break;
2330 default: fprintf (file
, "<unknown>"); break;
2333 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2334 (int) bfd_get_32 (abfd
, data
),
2335 (long) bfd_get_32 (abfd
, data
+ 4),
2336 (int) bfd_get_16 (abfd
, data
+ 8),
2337 (int) bfd_get_16 (abfd
, data
+ 10),
2338 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2339 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2342 while (num_names
--)
2344 bfd_byte
* entry_end
;
2346 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2347 data
, regions
, rva_bias
);
2349 highest_data
= max (highest_data
, entry_end
);
2350 if (entry_end
>= regions
->section_end
)
2356 bfd_byte
* entry_end
;
2358 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2359 data
, regions
, rva_bias
);
2361 highest_data
= max (highest_data
, entry_end
);
2362 if (entry_end
>= regions
->section_end
)
2366 return max (highest_data
, data
);
2369 /* Display the contents of a .rsrc section. We do not try to
2370 reproduce the resources, windres does that. Instead we dump
2371 the tables in a human readable format. */
2374 rsrc_print_section (bfd
* abfd
, void * vfile
)
2378 FILE * file
= (FILE *) vfile
;
2379 bfd_size_type datasize
;
2382 rsrc_regions regions
;
2384 pe
= pe_data (abfd
);
2388 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2389 if (section
== NULL
)
2391 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2394 datasize
= section
->size
;
2398 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2400 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2407 regions
.section_start
= data
;
2408 regions
.section_end
= data
+ datasize
;
2409 regions
.strings_start
= NULL
;
2410 regions
.resource_start
= NULL
;
2413 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2415 while (data
< regions
.section_end
)
2417 bfd_byte
* p
= data
;
2419 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2421 if (data
== regions
.section_end
+ 1)
2422 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2425 /* Align data before continuing. */
2426 int align
= (1 << section
->alignment_power
) - 1;
2428 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2429 rva_bias
+= data
- p
;
2431 /* For reasons that are unclear .rsrc sections are sometimes created
2432 aligned to a 1^3 boundary even when their alignment is set at
2433 1^2. Catch that case here before we issue a spurious warning
2435 if (data
== (regions
.section_end
- 4))
2436 data
= regions
.section_end
;
2437 else if (data
< regions
.section_end
)
2439 /* If the extra data is all zeros then do not complain.
2440 This is just padding so that the section meets the
2441 page size requirements. */
2442 while (data
++ < regions
.section_end
)
2445 if (data
< regions
.section_end
)
2446 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2451 if (regions
.strings_start
!= NULL
)
2452 fprintf (file
, " String table starts at %03x\n",
2453 (int) (regions
.strings_start
- regions
.section_start
));
2454 if (regions
.resource_start
!= NULL
)
2455 fprintf (file
, " Resources start at %03xx\n",
2456 (int) (regions
.resource_start
- regions
.section_start
));
2458 free (regions
.section_start
);
2462 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2464 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2481 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2483 FILE *file
= (FILE *) vfile
;
2484 pe_data_type
*pe
= pe_data (abfd
);
2485 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2488 bfd_size_type dataoff
;
2491 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2492 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2497 addr
+= extra
->ImageBase
;
2498 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2500 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2504 if (section
== NULL
)
2507 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2510 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2513 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2518 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2519 section
->name
, (unsigned long) addr
);
2521 dataoff
= addr
- section
->vma
;
2524 _("Type Size Rva Offset\n"));
2526 /* Read the whole section. */
2527 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2534 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2536 const char *type_name
;
2537 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2538 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2539 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2541 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2543 if ((idd
.Type
) > IMAGE_NUMBEROF_DEBUG_TYPES
)
2544 type_name
= debug_type_names
[0];
2546 type_name
= debug_type_names
[idd
.Type
];
2548 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2549 idd
.Type
, type_name
, idd
.SizeOfData
,
2550 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2552 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2554 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2555 char buffer
[256 + 1];
2556 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2558 /* The debug entry doesn't have to have to be in a section,
2559 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2560 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2561 idd
.SizeOfData
, cvinfo
))
2564 for (i
= 0; i
< cvinfo
->SignatureLength
; i
++)
2565 sprintf (&signature
[i
*2], "%02x", cvinfo
->Signature
[i
] & 0xff);
2567 fprintf (file
, "(format %c%c%c%c signature %s age %ld)\n",
2568 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2569 signature
, cvinfo
->Age
);
2573 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2575 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2580 /* Print out the program headers. */
2583 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2585 FILE *file
= (FILE *) vfile
;
2587 pe_data_type
*pe
= pe_data (abfd
);
2588 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2589 const char *subsystem_name
= NULL
;
2592 /* The MS dumpbin program reportedly ands with 0xff0f before
2593 printing the characteristics field. Not sure why. No reason to
2595 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2597 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2598 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2599 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2600 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2601 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2602 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2603 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2604 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2605 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2606 PF (IMAGE_FILE_SYSTEM
, "system file");
2607 PF (IMAGE_FILE_DLL
, "DLL");
2608 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2611 /* ctime implies '\n'. */
2613 time_t t
= pe
->coff
.timestamp
;
2614 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2617 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2618 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2620 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2621 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2623 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2624 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2629 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2632 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2635 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2642 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2644 fprintf (file
, "\t(%s)",name
);
2645 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2646 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2647 fprintf (file
, "SizeOfCode\t\t%08lx\n", (unsigned long) i
->SizeOfCode
);
2648 fprintf (file
, "SizeOfInitializedData\t%08lx\n",
2649 (unsigned long) i
->SizeOfInitializedData
);
2650 fprintf (file
, "SizeOfUninitializedData\t%08lx\n",
2651 (unsigned long) i
->SizeOfUninitializedData
);
2652 fprintf (file
, "AddressOfEntryPoint\t");
2653 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2654 fprintf (file
, "\nBaseOfCode\t\t");
2655 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2656 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2657 /* PE32+ does not have BaseOfData member! */
2658 fprintf (file
, "\nBaseOfData\t\t");
2659 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2662 fprintf (file
, "\nImageBase\t\t");
2663 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2664 fprintf (file
, "\nSectionAlignment\t");
2665 bfd_fprintf_vma (abfd
, file
, i
->SectionAlignment
);
2666 fprintf (file
, "\nFileAlignment\t\t");
2667 bfd_fprintf_vma (abfd
, file
, i
->FileAlignment
);
2668 fprintf (file
, "\nMajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2669 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2670 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2671 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2672 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2673 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2674 fprintf (file
, "Win32Version\t\t%08lx\n", (unsigned long) i
->Reserved1
);
2675 fprintf (file
, "SizeOfImage\t\t%08lx\n", (unsigned long) i
->SizeOfImage
);
2676 fprintf (file
, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i
->SizeOfHeaders
);
2677 fprintf (file
, "CheckSum\t\t%08lx\n", (unsigned long) i
->CheckSum
);
2679 switch (i
->Subsystem
)
2681 case IMAGE_SUBSYSTEM_UNKNOWN
:
2682 subsystem_name
= "unspecified";
2684 case IMAGE_SUBSYSTEM_NATIVE
:
2685 subsystem_name
= "NT native";
2687 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2688 subsystem_name
= "Windows GUI";
2690 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2691 subsystem_name
= "Windows CUI";
2693 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2694 subsystem_name
= "POSIX CUI";
2696 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2697 subsystem_name
= "Wince CUI";
2699 // These are from UEFI Platform Initialization Specification 1.1.
2700 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2701 subsystem_name
= "EFI application";
2703 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2704 subsystem_name
= "EFI boot service driver";
2706 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2707 subsystem_name
= "EFI runtime driver";
2709 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2710 subsystem_name
= "SAL runtime driver";
2712 // This is from revision 8.0 of the MS PE/COFF spec
2713 case IMAGE_SUBSYSTEM_XBOX
:
2714 subsystem_name
= "XBOX";
2716 // Added default case for clarity - subsystem_name is NULL anyway.
2718 subsystem_name
= NULL
;
2721 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2723 fprintf (file
, "\t(%s)", subsystem_name
);
2724 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2725 fprintf (file
, "SizeOfStackReserve\t");
2726 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2727 fprintf (file
, "\nSizeOfStackCommit\t");
2728 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2729 fprintf (file
, "\nSizeOfHeapReserve\t");
2730 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2731 fprintf (file
, "\nSizeOfHeapCommit\t");
2732 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2733 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2734 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2735 (unsigned long) i
->NumberOfRvaAndSizes
);
2737 fprintf (file
, "\nThe Data Directory\n");
2738 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2740 fprintf (file
, "Entry %1x ", j
);
2741 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2742 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2743 fprintf (file
, "%s\n", dir_names
[j
]);
2746 pe_print_idata (abfd
, vfile
);
2747 pe_print_edata (abfd
, vfile
);
2748 if (bfd_coff_have_print_pdata (abfd
))
2749 bfd_coff_print_pdata (abfd
, vfile
);
2751 pe_print_pdata (abfd
, vfile
);
2752 pe_print_reloc (abfd
, vfile
);
2753 pe_print_debugdata (abfd
, file
);
2755 rsrc_print_section (abfd
, vfile
);
2761 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2763 bfd_vma addr
= * (bfd_vma
*) obj
;
2764 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2768 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2770 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2773 /* Copy any private info we understand from the input bfd
2774 to the output bfd. */
2777 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2779 pe_data_type
*ipe
, *ope
;
2781 /* One day we may try to grok other private data. */
2782 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2783 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2786 ipe
= pe_data (ibfd
);
2787 ope
= pe_data (obfd
);
2789 /* pe_opthdr is copied in copy_object. */
2790 ope
->dll
= ipe
->dll
;
2792 /* Don't copy input subsystem if output is different from input. */
2793 if (obfd
->xvec
!= ibfd
->xvec
)
2794 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2796 /* For strip: if we removed .reloc, we'll make a real mess of things
2797 if we don't remove this entry as well. */
2798 if (! pe_data (obfd
)->has_reloc_section
)
2800 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2801 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2804 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2805 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2807 if (! pe_data (ibfd
)->has_reloc_section
2808 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2809 pe_data (obfd
)->dont_strip_reloc
= 1;
2811 /* The file offsets contained in the debug directory need rewriting. */
2812 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2814 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2815 + ope
->pe_opthdr
.ImageBase
;
2816 asection
*section
= find_section_by_vma (obfd
, addr
);
2819 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2822 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2823 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2825 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2826 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2828 asection
*ddsection
;
2829 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
2830 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2832 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
2834 if (idd
.AddressOfRawData
== 0)
2835 continue; /* RVA 0 means only offset is valid, not handled yet. */
2837 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
2839 continue; /* Not in a section! */
2841 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
2842 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
2844 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
2847 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
2848 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2855 /* Copy private section data. */
2858 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
2863 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
2864 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
2867 if (coff_section_data (ibfd
, isec
) != NULL
2868 && pei_section_data (ibfd
, isec
) != NULL
)
2870 if (coff_section_data (obfd
, osec
) == NULL
)
2872 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
2873 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
2874 if (osec
->used_by_bfd
== NULL
)
2878 if (pei_section_data (obfd
, osec
) == NULL
)
2880 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
2881 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
2882 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
2886 pei_section_data (obfd
, osec
)->virt_size
=
2887 pei_section_data (ibfd
, isec
)->virt_size
;
2888 pei_section_data (obfd
, osec
)->pe_flags
=
2889 pei_section_data (ibfd
, isec
)->pe_flags
;
2896 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
2898 coff_get_symbol_info (abfd
, symbol
, ret
);
2901 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2903 sort_x64_pdata (const void *l
, const void *r
)
2905 const char *lp
= (const char *) l
;
2906 const char *rp
= (const char *) r
;
2908 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
2910 return (vl
< vr
? -1 : 1);
2911 /* We compare just begin address. */
2916 /* Functions to process a .rsrc section. */
2918 static unsigned int sizeof_leaves
;
2919 static unsigned int sizeof_strings
;
2920 static unsigned int sizeof_tables_and_entries
;
2923 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
2926 rsrc_count_entries (bfd
* abfd
,
2927 bfd_boolean is_name
,
2928 bfd_byte
* datastart
,
2933 unsigned long entry
, addr
, size
;
2935 if (data
+ 8 >= dataend
)
2942 entry
= (long) bfd_get_32 (abfd
, data
);
2944 if (HighBitSet (entry
))
2945 name
= datastart
+ WithoutHighBit (entry
);
2947 name
= datastart
+ entry
- rva_bias
;
2949 if (name
+ 2 >= dataend
)
2952 unsigned int len
= bfd_get_16 (abfd
, name
);
2953 if (len
== 0 || len
> 256)
2957 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2959 if (HighBitSet (entry
))
2960 return rsrc_count_directory (abfd
,
2962 datastart
+ WithoutHighBit (entry
),
2965 if (datastart
+ entry
+ 16 >= dataend
)
2968 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
2969 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
2971 return datastart
+ addr
- rva_bias
+ size
;
2975 rsrc_count_directory (bfd
* abfd
,
2976 bfd_byte
* datastart
,
2981 unsigned int num_entries
, num_ids
;
2982 bfd_byte
* highest_data
= data
;
2984 if (data
+ 16 >= dataend
)
2987 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
2988 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
2990 num_entries
+= num_ids
;
2994 while (num_entries
--)
2996 bfd_byte
* entry_end
;
2998 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
2999 datastart
, data
, dataend
, rva_bias
);
3001 highest_data
= max (highest_data
, entry_end
);
3002 if (entry_end
>= dataend
)
3006 return max (highest_data
, data
);
3009 typedef struct rsrc_dir_chain
3011 unsigned int num_entries
;
3012 struct rsrc_entry
* first_entry
;
3013 struct rsrc_entry
* last_entry
;
3016 typedef struct rsrc_directory
3018 unsigned int characteristics
;
3023 rsrc_dir_chain names
;
3026 struct rsrc_entry
* entry
;
3029 typedef struct rsrc_string
3035 typedef struct rsrc_leaf
3038 unsigned int codepage
;
3042 typedef struct rsrc_entry
3044 bfd_boolean is_name
;
3048 struct rsrc_string name
;
3054 struct rsrc_directory
* directory
;
3055 struct rsrc_leaf
* leaf
;
3058 struct rsrc_entry
* next_entry
;
3059 struct rsrc_directory
* parent
;
3063 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3064 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3067 rsrc_parse_entry (bfd
* abfd
,
3068 bfd_boolean is_name
,
3070 bfd_byte
* datastart
,
3074 rsrc_directory
* parent
)
3076 unsigned long val
, addr
, size
;
3078 val
= bfd_get_32 (abfd
, data
);
3080 entry
->parent
= parent
;
3081 entry
->is_name
= is_name
;
3085 /* FIXME: Add range checking ? */
3086 if (HighBitSet (val
))
3088 val
= WithoutHighBit (val
);
3090 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, datastart
+ val
);
3091 entry
->name_id
.name
.string
= datastart
+ val
+ 2;
3095 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, datastart
+ val
3097 entry
->name_id
.name
.string
= datastart
+ val
- rva_bias
+ 2;
3101 entry
->name_id
.id
= val
;
3103 val
= bfd_get_32 (abfd
, data
+ 4);
3105 if (HighBitSet (val
))
3107 entry
->is_dir
= TRUE
;
3108 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3109 if (entry
->value
.directory
== NULL
)
3112 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3114 datastart
+ WithoutHighBit (val
),
3115 dataend
, rva_bias
, entry
);
3118 entry
->is_dir
= FALSE
;
3119 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3120 if (entry
->value
.leaf
== NULL
)
3123 addr
= bfd_get_32 (abfd
, datastart
+ val
);
3124 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, datastart
+ val
+ 4);
3125 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, datastart
+ val
+ 8);
3127 entry
->value
.leaf
->data
= bfd_malloc (size
);
3128 if (entry
->value
.leaf
->data
== NULL
)
3131 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3132 return datastart
+ (addr
- rva_bias
) + size
;
3136 rsrc_parse_entries (bfd
* abfd
,
3137 rsrc_dir_chain
* chain
,
3138 bfd_boolean is_name
,
3139 bfd_byte
* highest_data
,
3140 bfd_byte
* datastart
,
3144 rsrc_directory
* parent
)
3149 if (chain
->num_entries
== 0)
3151 chain
->first_entry
= chain
->last_entry
= NULL
;
3152 return highest_data
;
3155 entry
= bfd_malloc (sizeof * entry
);
3159 chain
->first_entry
= entry
;
3161 for (i
= chain
->num_entries
; i
--;)
3163 bfd_byte
* entry_end
;
3165 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3166 data
, dataend
, rva_bias
, parent
);
3168 highest_data
= max (entry_end
, highest_data
);
3169 if (entry_end
> dataend
)
3174 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3175 entry
= entry
->next_entry
;
3180 entry
->next_entry
= NULL
;
3183 chain
->last_entry
= entry
;
3185 return highest_data
;
3189 rsrc_parse_directory (bfd
* abfd
,
3190 rsrc_directory
* table
,
3191 bfd_byte
* datastart
,
3197 bfd_byte
* highest_data
= data
;
3202 table
->characteristics
= bfd_get_32 (abfd
, data
);
3203 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3204 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3205 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3206 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3207 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3208 table
->entry
= entry
;
3212 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3213 datastart
, data
, dataend
, rva_bias
, table
);
3214 data
+= table
->names
.num_entries
* 8;
3216 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3217 datastart
, data
, dataend
, rva_bias
, table
);
3218 data
+= table
->ids
.num_entries
* 8;
3220 return max (highest_data
, data
);
3223 typedef struct rsrc_write_data
3226 bfd_byte
* datastart
;
3227 bfd_byte
* next_table
;
3228 bfd_byte
* next_leaf
;
3229 bfd_byte
* next_string
;
3230 bfd_byte
* next_data
;
3235 rsrc_write_string (rsrc_write_data
* data
,
3236 rsrc_string
* string
)
3238 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3239 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3240 data
->next_string
+= (string
->len
+ 1) * 2;
3243 static inline unsigned int
3244 rsrc_compute_rva (rsrc_write_data
* data
,
3247 return (addr
- data
->datastart
) + data
->rva_bias
;
3251 rsrc_write_leaf (rsrc_write_data
* data
,
3254 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3256 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3257 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3258 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3259 data
->next_leaf
+= 16;
3261 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3262 /* An undocumented feature of Windows resources is that each unit
3263 of raw data is 8-byte aligned... */
3264 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3267 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3270 rsrc_write_entry (rsrc_write_data
* data
,
3276 bfd_put_32 (data
->abfd
,
3277 SetHighBit (data
->next_string
- data
->datastart
),
3279 rsrc_write_string (data
, & entry
->name_id
.name
);
3282 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3286 bfd_put_32 (data
->abfd
,
3287 SetHighBit (data
->next_table
- data
->datastart
),
3289 rsrc_write_directory (data
, entry
->value
.directory
);
3293 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3294 rsrc_write_leaf (data
, entry
->value
.leaf
);
3299 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3301 struct rsrc_entry
* entry
;
3306 sizeof_tables_and_entries
+= 16;
3308 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3310 sizeof_tables_and_entries
+= 8;
3312 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3315 rsrc_compute_region_sizes (entry
->value
.directory
);
3317 sizeof_leaves
+= 16;
3320 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3322 sizeof_tables_and_entries
+= 8;
3325 rsrc_compute_region_sizes (entry
->value
.directory
);
3327 sizeof_leaves
+= 16;
3332 rsrc_write_directory (rsrc_write_data
* data
,
3333 rsrc_directory
* dir
)
3337 bfd_byte
* next_entry
;
3340 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3341 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3342 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3343 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3344 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3345 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3347 /* Compute where the entries and the next table will be placed. */
3348 next_entry
= data
->next_table
+ 16;
3349 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3350 + (dir
->ids
.num_entries
* 8);
3351 nt
= data
->next_table
;
3353 /* Write the entries. */
3354 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3355 i
> 0 && entry
!= NULL
;
3356 i
--, entry
= entry
->next_entry
)
3358 BFD_ASSERT (entry
->is_name
);
3359 rsrc_write_entry (data
, next_entry
, entry
);
3362 BFD_ASSERT (i
== 0);
3363 BFD_ASSERT (entry
== NULL
);
3365 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3366 i
> 0 && entry
!= NULL
;
3367 i
--, entry
= entry
->next_entry
)
3369 BFD_ASSERT (! entry
->is_name
);
3370 rsrc_write_entry (data
, next_entry
, entry
);
3373 BFD_ASSERT (i
== 0);
3374 BFD_ASSERT (entry
== NULL
);
3375 BFD_ASSERT (nt
== next_entry
);
3378 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3379 /* Return the length (number of units) of the first character in S,
3380 putting its 'ucs4_t' representation in *PUC. */
3383 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3385 unsigned short c
= * s
;
3387 if (c
< 0xd800 || c
>= 0xe000)
3397 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3399 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3405 /* Incomplete multibyte character. */
3411 /* Invalid multibyte character. */
3415 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3417 /* Perform a comparison of two entries. */
3419 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3428 return a
->name_id
.id
- b
->name_id
.id
;
3430 /* We have to perform a case insenstive, unicode string comparison... */
3431 astring
= a
->name_id
.name
.string
;
3432 alen
= a
->name_id
.name
.len
;
3433 bstring
= b
->name_id
.name
.string
;
3434 blen
= b
->name_id
.name
.len
;
3436 #if defined __CYGWIN__ || defined __MINGW32__
3437 /* Under Windows hosts (both Cygwin and Mingw types),
3438 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3439 function however goes by different names in the two environments... */
3443 #define rscpcmp wcsncasecmp
3446 #define rscpcmp wcsnicmp
3449 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3452 #elif defined HAVE_WCHAR_H
3456 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3461 /* Convert UTF-16 unicode characters into wchar_t characters so
3462 that we can then perform a case insensitive comparison. */
3463 int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3464 int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3468 res
= wcsncasecmp (& awc
, & bwc
, 1);
3474 /* Do the best we can - a case sensitive, untranslated comparison. */
3475 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3485 rsrc_print_name (char * buffer
, rsrc_string string
)
3488 bfd_byte
* name
= string
.string
;
3490 for (i
= string
.len
; i
--; name
+= 2)
3491 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3495 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3497 static char buffer
[256];
3498 bfd_boolean is_string
= FALSE
;
3502 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3503 && dir
->entry
->parent
->entry
!= NULL
)
3505 strcpy (buffer
, "type: ");
3506 if (dir
->entry
->parent
->entry
->is_name
)
3507 rsrc_print_name (buffer
+ strlen (buffer
),
3508 dir
->entry
->parent
->entry
->name_id
.name
);
3511 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3513 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3516 case 1: strcat (buffer
, " (CURSOR)"); break;
3517 case 2: strcat (buffer
, " (BITMAP)"); break;
3518 case 3: strcat (buffer
, " (ICON)"); break;
3519 case 4: strcat (buffer
, " (MENU)"); break;
3520 case 5: strcat (buffer
, " (DIALOG)"); break;
3521 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3522 case 7: strcat (buffer
, " (FONTDIR)"); break;
3523 case 8: strcat (buffer
, " (FONT)"); break;
3524 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3525 case 10: strcat (buffer
, " (RCDATA)"); break;
3526 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3527 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3528 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3529 case 16: strcat (buffer
, " (VERSION)"); break;
3530 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3531 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3532 case 20: strcat (buffer
, " (VXD)"); break;
3533 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3534 case 22: strcat (buffer
, " (ANIICON)"); break;
3535 case 23: strcat (buffer
, " (HTML)"); break;
3536 case 24: strcat (buffer
, " (MANIFEST)"); break;
3537 case 240: strcat (buffer
, " (DLGINIT)"); break;
3538 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3543 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3545 strcat (buffer
, " name: ");
3546 if (dir
->entry
->is_name
)
3547 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3550 unsigned int id
= dir
->entry
->name_id
.id
;
3552 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3555 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3556 (id
- 1) << 4, (id
<< 4) - 1);
3562 strcat (buffer
, " lang: ");
3565 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3567 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3573 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3574 their ID is stored in the NAME entry. The bottom four bits are used as
3575 an index into unicode string table that makes up the data of the leaf.
3576 So identical type-name-lang string resources may not actually be
3579 This function is called when we have detected two string resources with
3580 match top-28-bit IDs. We have to scan the string tables inside the leaves
3581 and discover if there are any real collisions. If there are then we report
3582 them and return FALSE. Otherwise we copy any strings from B into A and
3583 then return TRUE. */
3586 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3587 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3589 unsigned int copy_needed
= 0;
3593 bfd_byte
* new_data
;
3596 /* Step one: Find out what we have to do. */
3597 BFD_ASSERT (! a
->is_dir
);
3598 astring
= a
->value
.leaf
->data
;
3600 BFD_ASSERT (! b
->is_dir
);
3601 bstring
= b
->value
.leaf
->data
;
3603 for (i
= 0; i
< 16; i
++)
3605 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3606 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3610 copy_needed
+= blen
* 2;
3614 else if (alen
!= blen
)
3615 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3617 /* alen == blen != 0. We might have two identical strings. If so we
3618 can ignore the second one. There is no need for wchar_t vs UTF-16
3619 theatrics here - we are only interested in (case sensitive) equality. */
3620 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3623 astring
+= (alen
+ 1) * 2;
3624 bstring
+= (blen
+ 1) * 2;
3629 if (a
->parent
!= NULL
3630 && a
->parent
->entry
!= NULL
3631 && a
->parent
->entry
->is_name
== FALSE
)
3632 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3633 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3637 if (copy_needed
== 0)
3640 /* If we reach here then A and B must both have non-colliding strings.
3641 (We never get string resources with fully empty string tables).
3642 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3644 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3645 if (new_data
== NULL
)
3649 astring
= a
->value
.leaf
->data
;
3650 bstring
= b
->value
.leaf
->data
;
3652 for (i
= 0; i
< 16; i
++)
3654 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3655 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3659 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3660 nstring
+= (alen
+ 1) * 2;
3664 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3665 nstring
+= (blen
+ 1) * 2;
3673 astring
+= (alen
+ 1) * 2;
3674 bstring
+= (blen
+ 1) * 2;
3677 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3679 free (a
->value
.leaf
->data
);
3680 a
->value
.leaf
->data
= new_data
;
3681 a
->value
.leaf
->size
+= copy_needed
;
3686 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3688 /* Sort the entries in given part of the directory.
3689 We use an old fashioned bubble sort because we are dealing
3690 with lists and we want to handle matches specially. */
3693 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3694 bfd_boolean is_name
,
3695 rsrc_directory
* dir
)
3699 rsrc_entry
** points_to_entry
;
3700 bfd_boolean swapped
;
3702 if (chain
->num_entries
< 2)
3708 points_to_entry
= & chain
->first_entry
;
3709 entry
= * points_to_entry
;
3710 next
= entry
->next_entry
;
3714 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3718 entry
->next_entry
= next
->next_entry
;
3719 next
->next_entry
= entry
;
3720 * points_to_entry
= next
;
3721 points_to_entry
= & next
->next_entry
;
3722 next
= entry
->next_entry
;
3727 if (entry
->is_dir
&& next
->is_dir
)
3729 /* When we encounter identical directory entries we have to
3730 merge them together. The exception to this rule is for
3731 resource manifests - there can only be one of these,
3732 even if they differ in language. Zero-language manifests
3733 are assumed to be default manifests (provided by the
3734 Cygwin/MinGW build system) and these can be silently dropped,
3735 unless that would reduce the number of manifests to zero.
3736 There should only ever be one non-zero lang manifest -
3737 if there are more it is an error. A non-zero lang
3738 manifest takes precedence over a default manifest. */
3739 if (entry
->is_name
== FALSE
3740 && entry
->name_id
.id
== 1
3742 && dir
->entry
!= NULL
3743 && dir
->entry
->is_name
== FALSE
3744 && dir
->entry
->name_id
.id
== 0x18)
3746 if (next
->value
.directory
->names
.num_entries
== 0
3747 && next
->value
.directory
->ids
.num_entries
== 1
3748 && next
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3749 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3750 /* Fall through so that NEXT is dropped. */
3752 else if (entry
->value
.directory
->names
.num_entries
== 0
3753 && entry
->value
.directory
->ids
.num_entries
== 1
3754 && entry
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3755 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3757 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3758 entry
->next_entry
= next
->next_entry
;
3759 next
->next_entry
= entry
;
3760 * points_to_entry
= next
;
3761 points_to_entry
= & next
->next_entry
;
3762 next
= entry
->next_entry
;
3767 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3768 bfd_set_error (bfd_error_file_truncated
);
3772 /* Unhook NEXT from the chain. */
3773 /* FIXME: memory loss here. */
3774 entry
->next_entry
= next
->next_entry
;
3775 chain
->num_entries
--;
3776 if (chain
->num_entries
< 2)
3778 next
= next
->next_entry
;
3781 rsrc_merge (entry
, next
);
3783 else if (entry
->is_dir
!= next
->is_dir
)
3785 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3786 bfd_set_error (bfd_error_file_truncated
);
3791 /* Otherwise with identical leaves we issue an error
3792 message - because there should never be duplicates.
3793 The exception is Type 18/Name 1/Lang 0 which is the
3794 defaul manifest - this can just be dropped. */
3795 if (entry
->is_name
== FALSE
3796 && entry
->name_id
.id
== 0
3798 && dir
->entry
!= NULL
3799 && dir
->entry
->is_name
== FALSE
3800 && dir
->entry
->name_id
.id
== 1
3801 && dir
->entry
->parent
!= NULL
3802 && dir
->entry
->parent
->entry
!= NULL
3803 && dir
->entry
->parent
->entry
->is_name
== FALSE
3804 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
3806 else if (dir
!= NULL
3807 && dir
->entry
!= NULL
3808 && dir
->entry
->parent
!= NULL
3809 && dir
->entry
->parent
->entry
!= NULL
3810 && dir
->entry
->parent
->entry
->is_name
== FALSE
3811 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
3813 /* Strings need special handling. */
3814 if (! rsrc_merge_string_entries (entry
, next
))
3816 /* _bfd_error_handler should have been called inside merge_strings. */
3817 bfd_set_error (bfd_error_file_truncated
);
3824 || dir
->entry
== NULL
3825 || dir
->entry
->parent
== NULL
3826 || dir
->entry
->parent
->entry
== NULL
)
3827 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3829 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3830 rsrc_resource_name (entry
, dir
));
3831 bfd_set_error (bfd_error_file_truncated
);
3836 /* Unhook NEXT from the chain. */
3837 entry
->next_entry
= next
->next_entry
;
3838 chain
->num_entries
--;
3839 if (chain
->num_entries
< 2)
3841 next
= next
->next_entry
;
3845 points_to_entry
= & entry
->next_entry
;
3847 next
= next
->next_entry
;
3852 chain
->last_entry
= entry
;
3857 /* Attach B's chain onto A. */
3859 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
3861 if (bchain
->num_entries
== 0)
3864 achain
->num_entries
+= bchain
->num_entries
;
3866 if (achain
->first_entry
== NULL
)
3868 achain
->first_entry
= bchain
->first_entry
;
3869 achain
->last_entry
= bchain
->last_entry
;
3873 achain
->last_entry
->next_entry
= bchain
->first_entry
;
3874 achain
->last_entry
= bchain
->last_entry
;
3877 bchain
->num_entries
= 0;
3878 bchain
->first_entry
= bchain
->last_entry
= NULL
;
3882 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
3884 rsrc_directory
* adir
;
3885 rsrc_directory
* bdir
;
3887 BFD_ASSERT (a
->is_dir
);
3888 BFD_ASSERT (b
->is_dir
);
3890 adir
= a
->value
.directory
;
3891 bdir
= b
->value
.directory
;
3893 if (adir
->characteristics
!= bdir
->characteristics
)
3895 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3896 bfd_set_error (bfd_error_file_truncated
);
3900 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
3902 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3903 bfd_set_error (bfd_error_file_truncated
);
3907 /* Attach B's name chain to A. */
3908 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
3910 /* Attach B's ID chain to A. */
3911 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
3913 /* Now sort A's entries. */
3914 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
3915 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
3918 /* Check the .rsrc section. If it contains multiple concatenated
3919 resources then we must merge them properly. Otherwise Windows
3920 will ignore all but the first set. */
3923 rsrc_process_section (bfd
* abfd
,
3924 struct coff_final_link_info
* pfinfo
)
3926 rsrc_directory new_table
;
3932 bfd_byte
* datastart
;
3934 bfd_byte
* new_data
;
3935 unsigned int num_resource_sets
;
3936 rsrc_directory
* type_tables
;
3937 rsrc_write_data write_data
;
3940 unsigned int num_input_rsrc
= 0;
3941 unsigned int max_num_input_rsrc
= 4;
3942 ptrdiff_t * rsrc_sizes
= NULL
;
3944 new_table
.names
.num_entries
= 0;
3945 new_table
.ids
.num_entries
= 0;
3947 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
3948 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
3951 pe
= pe_data (abfd
);
3955 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
3957 data
= bfd_malloc (size
);
3963 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
3966 /* Step zero: Scan the input bfds looking for .rsrc sections and record
3967 their lengths. Note - we rely upon the fact that the linker script
3968 does *not* sort the input .rsrc sections, so that the order in the
3969 linkinfo list matches the order in the output .rsrc section.
3971 We need to know the lengths because each input .rsrc section has padding
3972 at the end of a variable amount. (It does not appear to be based upon
3973 the section alignment or the file alignment). We need to skip any
3974 padding bytes when parsing the input .rsrc sections. */
3975 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
3976 if (rsrc_sizes
== NULL
)
3979 for (input
= pfinfo
->info
->input_bfds
;
3981 input
= input
->link
.next
)
3983 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
3985 if (rsrc_sec
!= NULL
)
3987 if (num_input_rsrc
== max_num_input_rsrc
)
3989 max_num_input_rsrc
+= 10;
3990 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
3991 * sizeof * rsrc_sizes
);
3992 if (rsrc_sizes
== NULL
)
3996 BFD_ASSERT (rsrc_sec
->size
> 0);
3997 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4001 if (num_input_rsrc
< 2)
4004 /* Step one: Walk the section, computing the size of the tables,
4005 leaves and data and decide if we need to do anything. */
4006 dataend
= data
+ size
;
4007 num_resource_sets
= 0;
4009 while (data
< dataend
)
4011 bfd_byte
* p
= data
;
4013 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4017 /* Corrupted .rsrc section - cannot merge. */
4018 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4019 bfd_get_filename (abfd
));
4020 bfd_set_error (bfd_error_file_truncated
);
4024 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4026 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4027 bfd_get_filename (abfd
));
4028 bfd_set_error (bfd_error_file_truncated
);
4031 /* FIXME: Should we add a check for "data - p" being much smaller
4032 than rsrc_sizes[num_resource_sets] ? */
4034 data
= p
+ rsrc_sizes
[num_resource_sets
];
4035 rva_bias
+= data
- p
;
4036 ++ num_resource_sets
;
4038 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4040 /* Step two: Walk the data again, building trees of the resources. */
4042 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4044 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4045 if (type_tables
== NULL
)
4049 while (data
< dataend
)
4051 bfd_byte
* p
= data
;
4053 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4054 dataend
, rva_bias
, NULL
);
4055 data
= p
+ rsrc_sizes
[indx
];
4056 rva_bias
+= data
- p
;
4059 BFD_ASSERT (indx
== num_resource_sets
);
4061 /* Step three: Merge the top level tables (there can be only one).
4063 We must ensure that the merged entries are in ascending order.
4065 We also thread the top level table entries from the old tree onto
4066 the new table, so that they can be pulled off later. */
4068 /* FIXME: Should we verify that all type tables are the same ? */
4069 new_table
.characteristics
= type_tables
[0].characteristics
;
4070 new_table
.time
= type_tables
[0].time
;
4071 new_table
.major
= type_tables
[0].major
;
4072 new_table
.minor
= type_tables
[0].minor
;
4074 /* Chain the NAME entries onto the table. */
4075 new_table
.names
.first_entry
= NULL
;
4076 new_table
.names
.last_entry
= NULL
;
4078 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4079 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4081 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4083 /* Chain the ID entries onto the table. */
4084 new_table
.ids
.first_entry
= NULL
;
4085 new_table
.ids
.last_entry
= NULL
;
4087 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4088 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4090 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4092 /* Step four: Create new contents for the .rsrc section. */
4093 /* Step four point one: Compute the size of each region of the .rsrc section.
4094 We do this now, rather than earlier, as the merging above may have dropped
4096 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4097 rsrc_compute_region_sizes (& new_table
);
4098 /* We increment sizeof_strings to make sure that resource data
4099 starts on an 8-byte boundary. FIXME: Is this correct ? */
4100 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4102 new_data
= bfd_zalloc (abfd
, size
);
4103 if (new_data
== NULL
)
4106 write_data
.abfd
= abfd
;
4107 write_data
.datastart
= new_data
;
4108 write_data
.next_table
= new_data
;
4109 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4110 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4111 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4112 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4114 rsrc_write_directory (& write_data
, & new_table
);
4116 /* Step five: Replace the old contents with the new.
4117 We recompute the size as we may have lost entries due to mergeing. */
4118 size
= ((write_data
.next_data
- new_data
) + 3) & ~ 3;
4123 if (coff_data (abfd
)->link_info
)
4125 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
4127 /* If no file alignment has been set, default to one.
4128 This repairs 'ld -r' for arm-wince-pe target. */
4133 page_size
= PE_DEF_FILE_ALIGNMENT
;
4134 size
= (size
+ page_size
- 1) & - page_size
;
4137 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4138 sec
->size
= sec
->rawsize
= size
;
4141 /* Step six: Free all the memory that we have used. */
4142 /* FIXME: Free the resource tree, if we have one. */
4147 /* Handle the .idata section and other things that need symbol table
4151 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4153 struct coff_link_hash_entry
*h1
;
4154 struct bfd_link_info
*info
= pfinfo
->info
;
4155 bfd_boolean result
= TRUE
;
4157 /* There are a few fields that need to be filled in now while we
4158 have symbol table access.
4160 The .idata subsections aren't directly available as sections, but
4161 they are in the symbol table, so get them from there. */
4163 /* The import directory. This is the address of .idata$2, with size
4164 of .idata$2 + .idata$3. */
4165 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4166 ".idata$2", FALSE
, FALSE
, TRUE
);
4169 /* PR ld/2729: We cannot rely upon all the output sections having been
4170 created properly, so check before referencing them. Issue a warning
4171 message for any sections tht could not be found. */
4172 if ((h1
->root
.type
== bfd_link_hash_defined
4173 || h1
->root
.type
== bfd_link_hash_defweak
)
4174 && h1
->root
.u
.def
.section
!= NULL
4175 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4176 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4177 (h1
->root
.u
.def
.value
4178 + h1
->root
.u
.def
.section
->output_section
->vma
4179 + h1
->root
.u
.def
.section
->output_offset
);
4183 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4188 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4189 ".idata$4", FALSE
, FALSE
, TRUE
);
4191 && (h1
->root
.type
== bfd_link_hash_defined
4192 || h1
->root
.type
== bfd_link_hash_defweak
)
4193 && h1
->root
.u
.def
.section
!= NULL
4194 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4195 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4196 ((h1
->root
.u
.def
.value
4197 + h1
->root
.u
.def
.section
->output_section
->vma
4198 + h1
->root
.u
.def
.section
->output_offset
)
4199 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4203 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4208 /* The import address table. This is the size/address of
4210 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4211 ".idata$5", FALSE
, FALSE
, TRUE
);
4213 && (h1
->root
.type
== bfd_link_hash_defined
4214 || h1
->root
.type
== bfd_link_hash_defweak
)
4215 && h1
->root
.u
.def
.section
!= NULL
4216 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4217 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4218 (h1
->root
.u
.def
.value
4219 + h1
->root
.u
.def
.section
->output_section
->vma
4220 + h1
->root
.u
.def
.section
->output_offset
);
4224 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4229 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4230 ".idata$6", FALSE
, FALSE
, TRUE
);
4232 && (h1
->root
.type
== bfd_link_hash_defined
4233 || h1
->root
.type
== bfd_link_hash_defweak
)
4234 && h1
->root
.u
.def
.section
!= NULL
4235 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4236 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4237 ((h1
->root
.u
.def
.value
4238 + h1
->root
.u
.def
.section
->output_section
->vma
4239 + h1
->root
.u
.def
.section
->output_offset
)
4240 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4244 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4251 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4252 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4254 && (h1
->root
.type
== bfd_link_hash_defined
4255 || h1
->root
.type
== bfd_link_hash_defweak
)
4256 && h1
->root
.u
.def
.section
!= NULL
4257 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4262 (h1
->root
.u
.def
.value
4263 + h1
->root
.u
.def
.section
->output_section
->vma
4264 + h1
->root
.u
.def
.section
->output_offset
);
4266 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4267 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4269 && (h1
->root
.type
== bfd_link_hash_defined
4270 || h1
->root
.type
== bfd_link_hash_defweak
)
4271 && h1
->root
.u
.def
.section
!= NULL
4272 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4274 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4275 ((h1
->root
.u
.def
.value
4276 + h1
->root
.u
.def
.section
->output_section
->vma
4277 + h1
->root
.u
.def
.section
->output_offset
)
4279 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4280 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4281 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4286 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4287 " because .idata$6 is missing"), abfd
);
4293 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4294 (bfd_get_symbol_leading_char (abfd
) != 0
4295 ? "__tls_used" : "_tls_used"),
4296 FALSE
, FALSE
, TRUE
);
4299 if ((h1
->root
.type
== bfd_link_hash_defined
4300 || h1
->root
.type
== bfd_link_hash_defweak
)
4301 && h1
->root
.u
.def
.section
!= NULL
4302 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4303 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4304 (h1
->root
.u
.def
.value
4305 + h1
->root
.u
.def
.section
->output_section
->vma
4306 + h1
->root
.u
.def
.section
->output_offset
4307 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4311 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4315 /* According to PECOFF sepcifications by Microsoft version 8.2
4316 the TLS data directory consists of 4 pointers, followed
4317 by two 4-byte integer. This implies that the total size
4318 is different for 32-bit and 64-bit executables. */
4319 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4320 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4322 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4326 /* If there is a .pdata section and we have linked pdata finally, we
4327 need to sort the entries ascending. */
4328 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4330 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4334 bfd_size_type x
= sec
->rawsize
;
4335 bfd_byte
*tmp_data
= NULL
;
4338 tmp_data
= bfd_malloc (x
);
4340 if (tmp_data
!= NULL
)
4342 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4346 12, sort_x64_pdata
);
4347 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4356 rsrc_process_section (abfd
, pfinfo
);
4358 /* If we couldn't find idata$2, we either have an excessively
4359 trivial program or are in DEEP trouble; we have to assume trivial