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
);
1469 /* PR binutils/17512: Handle corrupt PE data. */
1470 else if (member
- adj
+ 2 >= datasize
)
1471 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1477 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1478 member_name
= (char *) data
+ member
- adj
+ 2;
1479 fprintf (file
, "\t%04lx\t %4d %s",member
, ordinal
, member_name
);
1482 /* If the time stamp is not zero, the import address
1483 table holds actual addresses. */
1486 && first_thunk
!= hint_addr
1487 && j
+ 4 <= ft_datasize
)
1488 fprintf (file
, "\t%04lx",
1489 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1490 fprintf (file
, "\n");
1493 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1495 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1497 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1501 if (HighBitSet (member
))
1502 fprintf (file
, "\t%04lx\t %4lu <none>",
1503 member
, WithoutHighBit (member
));
1504 /* PR binutils/17512: Handle corrupt PE data. */
1505 else if (member
- adj
+ 2 >= datasize
)
1506 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1512 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1513 member_name
= (char *) data
+ member
- adj
+ 2;
1514 fprintf (file
, "\t%04lx\t %4d %s",
1515 member
, ordinal
, member_name
);
1518 /* If the time stamp is not zero, the import address
1519 table holds actual addresses. */
1522 && first_thunk
!= hint_addr
1523 && j
+ 4 <= ft_datasize
)
1524 fprintf (file
, "\t%04lx",
1525 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1527 fprintf (file
, "\n");
1534 fprintf (file
, "\n");
1543 pe_print_edata (bfd
* abfd
, void * vfile
)
1545 FILE *file
= (FILE *) vfile
;
1548 bfd_size_type datasize
= 0;
1549 bfd_size_type dataoff
;
1554 long export_flags
; /* Reserved - should be zero. */
1558 bfd_vma name
; /* RVA - relative to image base. */
1559 long base
; /* Ordinal base. */
1560 unsigned long num_functions
;/* Number in the export address table. */
1561 unsigned long num_names
; /* Number in the name pointer table. */
1562 bfd_vma eat_addr
; /* RVA to the export address table. */
1563 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1564 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1567 pe_data_type
*pe
= pe_data (abfd
);
1568 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1572 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1574 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1576 /* Maybe the extra header isn't there. Look for the section. */
1577 section
= bfd_get_section_by_name (abfd
, ".edata");
1578 if (section
== NULL
)
1581 addr
= section
->vma
;
1583 datasize
= section
->size
;
1589 addr
+= extra
->ImageBase
;
1591 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1592 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1595 if (section
== NULL
)
1598 _("\nThere is an export table, but the section containing it could not be found\n"));
1601 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1604 _("\nThere is an export table in %s, but that section has no contents\n"),
1609 dataoff
= addr
- section
->vma
;
1610 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1611 if (datasize
> section
->size
- dataoff
)
1614 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1620 /* PR 17512: Handle corrupt PE binaries. */
1624 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1625 section
->name
, (int) datasize
);
1629 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1630 section
->name
, (unsigned long) addr
);
1632 data
= (bfd_byte
*) bfd_malloc (datasize
);
1636 if (! bfd_get_section_contents (abfd
, section
, data
,
1637 (file_ptr
) dataoff
, datasize
))
1640 /* Go get Export Directory Table. */
1641 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1642 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1643 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1644 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1645 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1646 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1647 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1648 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1649 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1650 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1651 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1653 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1655 /* Dump the EDT first. */
1657 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1661 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1664 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1667 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1670 _("Name \t\t\t\t"));
1671 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1673 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1674 fprintf (file
, " %s\n", data
+ edt
.name
- adj
);
1676 fprintf (file
, "(outside .edata section)\n");
1679 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1685 _("\tExport Address Table \t\t%08lx\n"),
1689 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1692 _("Table Addresses\n"));
1695 _("\tExport Address Table \t\t"));
1696 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1697 fprintf (file
, "\n");
1700 _("\tName Pointer Table \t\t"));
1701 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1702 fprintf (file
, "\n");
1705 _("\tOrdinal Table \t\t\t"));
1706 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1707 fprintf (file
, "\n");
1709 /* The next table to find is the Export Address Table. It's basically
1710 a list of pointers that either locate a function in this dll, or
1711 forward the call to another dll. Something like:
1716 } export_address_table_entry; */
1719 _("\nExport Address Table -- Ordinal Base %ld\n"),
1722 /* PR 17512: Handle corrupt PE binaries. */
1723 if (edt
.eat_addr
+ (edt
.num_functions
* 4) - adj
>= datasize
)
1724 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1725 (long) edt
.eat_addr
,
1726 (long) edt
.num_functions
);
1727 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1729 bfd_vma eat_member
= bfd_get_32 (abfd
,
1730 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1731 if (eat_member
== 0)
1734 if (eat_member
- adj
<= datasize
)
1736 /* This rva is to a name (forwarding function) in our section. */
1737 /* Should locate a function descriptor. */
1739 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1741 (long) (i
+ edt
.base
),
1742 (unsigned long) eat_member
,
1744 data
+ eat_member
- adj
);
1748 /* Should locate a function descriptor in the reldata section. */
1750 "\t[%4ld] +base[%4ld] %04lx %s\n",
1752 (long) (i
+ edt
.base
),
1753 (unsigned long) eat_member
,
1758 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1759 /* Dump them in parallel for clarity. */
1761 _("\n[Ordinal/Name Pointer] Table\n"));
1763 /* PR 17512: Handle corrupt PE binaries. */
1764 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
)
1765 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1766 (long) edt
.npt_addr
,
1767 (long) edt
.num_names
);
1768 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
)
1769 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1771 (long) edt
.num_names
);
1772 else for (i
= 0; i
< edt
.num_names
; ++i
)
1777 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1778 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1780 if ((name_ptr
- adj
) >= datasize
)
1782 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1783 (long) ord
, (long) name_ptr
);
1787 char * name
= (char *) data
+ name_ptr
- adj
;
1789 fprintf (file
, "\t[%4ld] %s\n", (long) ord
, name
);
1798 /* This really is architecture dependent. On IA-64, a .pdata entry
1799 consists of three dwords containing relative virtual addresses that
1800 specify the start and end address of the code range the entry
1801 covers and the address of the corresponding unwind info data.
1803 On ARM and SH-4, a compressed PDATA structure is used :
1804 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1805 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1806 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1808 This is the version for uncompressed data. */
1811 pe_print_pdata (bfd
* abfd
, void * vfile
)
1813 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1814 # define PDATA_ROW_SIZE (3 * 8)
1816 # define PDATA_ROW_SIZE (5 * 4)
1818 FILE *file
= (FILE *) vfile
;
1820 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1821 bfd_size_type datasize
= 0;
1823 bfd_size_type start
, stop
;
1824 int onaline
= PDATA_ROW_SIZE
;
1827 || coff_section_data (abfd
, section
) == NULL
1828 || pei_section_data (abfd
, section
) == NULL
)
1831 stop
= pei_section_data (abfd
, section
)->virt_size
;
1832 if ((stop
% onaline
) != 0)
1834 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1835 (long) stop
, onaline
);
1838 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1839 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1841 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1844 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1845 \t\tAddress Address Handler Data Address Mask\n"));
1848 datasize
= section
->size
;
1852 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1861 for (i
= start
; i
< stop
; i
+= onaline
)
1867 bfd_vma prolog_end_addr
;
1868 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1872 if (i
+ PDATA_ROW_SIZE
> stop
)
1875 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1876 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1877 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1878 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1879 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1881 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1882 && eh_data
== 0 && prolog_end_addr
== 0)
1883 /* We are probably into the padding of the section now. */
1886 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1887 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1889 eh_handler
&= ~(bfd_vma
) 0x3;
1890 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1893 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1894 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1895 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1896 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1897 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1899 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1900 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1901 fprintf (file
, " %x", em_data
);
1904 #ifdef POWERPC_LE_PE
1905 if (eh_handler
== 0 && eh_data
!= 0)
1907 /* Special bits here, although the meaning may be a little
1908 mysterious. The only one I know for sure is 0x03
1911 0x01 Register Save Millicode
1912 0x02 Register Restore Millicode
1913 0x03 Glue Code Sequence. */
1917 fprintf (file
, _(" Register save millicode"));
1920 fprintf (file
, _(" Register restore millicode"));
1923 fprintf (file
, _(" Glue code sequence"));
1930 fprintf (file
, "\n");
1936 #undef PDATA_ROW_SIZE
1939 typedef struct sym_cache
1946 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1948 asymbol
** sy
= NULL
;
1951 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1957 storage
= bfd_get_symtab_upper_bound (abfd
);
1961 sy
= (asymbol
**) bfd_malloc (storage
);
1963 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1964 if (psc
->symcount
< 0)
1970 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1975 psc
->syms
= slurp_symtab (abfd
, psc
);
1977 for (i
= 0; i
< psc
->symcount
; i
++)
1979 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1980 return psc
->syms
[i
]->name
;
1987 cleanup_syms (sym_cache
*psc
)
1994 /* This is the version for "compressed" pdata. */
1997 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1999 # define PDATA_ROW_SIZE (2 * 4)
2000 FILE *file
= (FILE *) vfile
;
2001 bfd_byte
*data
= NULL
;
2002 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2003 bfd_size_type datasize
= 0;
2005 bfd_size_type start
, stop
;
2006 int onaline
= PDATA_ROW_SIZE
;
2007 struct sym_cache cache
= {0, 0} ;
2010 || coff_section_data (abfd
, section
) == NULL
2011 || pei_section_data (abfd
, section
) == NULL
)
2014 stop
= pei_section_data (abfd
, section
)->virt_size
;
2015 if ((stop
% onaline
) != 0)
2017 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2018 (long) stop
, onaline
);
2021 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2024 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2025 \t\tAddress Length Length 32b exc Handler Data\n"));
2027 datasize
= section
->size
;
2031 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2040 for (i
= start
; i
< stop
; i
+= onaline
)
2044 bfd_vma prolog_length
, function_length
;
2045 int flag32bit
, exception_flag
;
2048 if (i
+ PDATA_ROW_SIZE
> stop
)
2051 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2052 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2054 if (begin_addr
== 0 && other_data
== 0)
2055 /* We are probably into the padding of the section now. */
2058 prolog_length
= (other_data
& 0x000000FF);
2059 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2060 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2061 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2064 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2065 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2066 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2067 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2068 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2070 /* Get the exception handler's address and the data passed from the
2071 .text section. This is really the data that belongs with the .pdata
2072 but got "compressed" out for the ARM and SH4 architectures. */
2073 tsection
= bfd_get_section_by_name (abfd
, ".text");
2074 if (tsection
&& coff_section_data (abfd
, tsection
)
2075 && pei_section_data (abfd
, tsection
))
2077 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2080 tdata
= (bfd_byte
*) bfd_malloc (8);
2083 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2085 bfd_vma eh
, eh_data
;
2087 eh
= bfd_get_32 (abfd
, tdata
);
2088 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2089 fprintf (file
, "%08x ", (unsigned int) eh
);
2090 fprintf (file
, "%08x", (unsigned int) eh_data
);
2093 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2096 fprintf (file
, " (%s) ", s
);
2103 fprintf (file
, "\n");
2108 cleanup_syms (& cache
);
2111 #undef PDATA_ROW_SIZE
2115 #define IMAGE_REL_BASED_HIGHADJ 4
2116 static const char * const tbl
[] =
2130 "UNKNOWN", /* MUST be last. */
2134 pe_print_reloc (bfd
* abfd
, void * vfile
)
2136 FILE *file
= (FILE *) vfile
;
2138 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2141 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2145 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2147 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2155 end
= data
+ section
->size
;
2156 while (p
+ 8 <= end
)
2159 bfd_vma virtual_address
;
2161 bfd_byte
*chunk_end
;
2163 /* The .reloc section is a sequence of blocks, with a header consisting
2164 of two 32 bit quantities, followed by a number of 16 bit entries. */
2165 virtual_address
= bfd_get_32 (abfd
, p
);
2166 size
= bfd_get_32 (abfd
, p
+ 4);
2168 number
= (size
- 8) / 2;
2174 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2175 (unsigned long) virtual_address
, size
, (unsigned long) size
, number
);
2177 chunk_end
= p
+ size
;
2178 if (chunk_end
> end
)
2181 while (p
+ 2 <= chunk_end
)
2183 unsigned short e
= bfd_get_16 (abfd
, p
);
2184 unsigned int t
= (e
& 0xF000) >> 12;
2185 int off
= e
& 0x0FFF;
2187 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2188 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2191 _("\treloc %4d offset %4x [%4lx] %s"),
2192 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2197 /* HIGHADJ takes an argument, - the next record *is* the
2198 low 16 bits of addend. */
2199 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2201 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2206 fprintf (file
, "\n");
2215 /* A data structure describing the regions of a .rsrc section.
2216 Some fields are filled in as the section is parsed. */
2218 typedef struct rsrc_regions
2220 bfd_byte
* section_start
;
2221 bfd_byte
* section_end
;
2222 bfd_byte
* strings_start
;
2223 bfd_byte
* resource_start
;
2227 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2228 rsrc_regions
*, bfd_vma
);
2230 /* Print the resource entry at DATA, with the text indented by INDENT.
2231 Recusively calls rsrc_print_resource_directory to print the contents
2232 of directory entries.
2233 Returns the address of the end of the data associated with the entry
2234 or section_end + 1 upon failure. */
2237 rsrc_print_resource_entries (FILE * file
,
2239 unsigned int indent
,
2240 bfd_boolean is_name
,
2242 rsrc_regions
* regions
,
2245 unsigned long entry
, addr
, size
;
2247 if (data
+ 8 >= regions
->section_end
)
2248 return regions
->section_end
+ 1;
2250 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2252 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2257 /* Note - the documentation says that this field is an RVA value
2258 but windres appears to produce a section relative offset with
2259 the top bit set. Support both styles for now. */
2260 if (HighBitSet (entry
))
2261 name
= regions
->section_start
+ WithoutHighBit (entry
);
2263 name
= regions
->section_start
+ entry
- rva_bias
;
2265 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2269 if (regions
->strings_start
== NULL
)
2270 regions
->strings_start
= name
;
2272 len
= bfd_get_16 (abfd
, name
);
2274 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2276 if (name
+ 2 + len
* 2 < regions
->section_end
)
2278 /* This strange loop is to cope with multibyte characters. */
2285 /* Avoid printing control characters. */
2286 if (c
> 0 && c
< 32)
2287 fprintf (file
, "^%c", c
+ 64);
2289 fprintf (file
, "%.1s", name
);
2294 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2295 /* PR binutils/17512: Do not try to continue decoding a
2296 corrupted resource section. It is likely to end up with
2297 reams of extraneous output. FIXME: We could probably
2298 continue if we disable the printing of strings... */
2299 return regions
->section_end
+ 1;
2304 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2305 return regions
->section_end
+ 1;
2309 fprintf (file
, _("ID: %#08lx"), entry
);
2311 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2312 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2314 if (HighBitSet (entry
))
2316 data
= regions
->section_start
+ WithoutHighBit (entry
);
2317 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2318 return regions
->section_end
+ 1;
2320 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2321 in the resource table. We need some way to detect this. */
2322 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2326 if (regions
->section_start
+ entry
+ 16 >= regions
->section_end
)
2327 return regions
->section_end
+ 1;
2329 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2332 addr
= (long) bfd_get_32 (abfd
, regions
->section_start
+ entry
),
2333 size
= (long) bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 4),
2334 (int) bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 8));
2336 /* Check that the reserved entry is 0. */
2337 if (bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 12) != 0
2338 /* And that the data address/size is valid too. */
2339 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2340 return regions
->section_end
+ 1;
2342 if (regions
->resource_start
== NULL
)
2343 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2345 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2348 #define max(a,b) ((a) > (b) ? (a) : (b))
2349 #define min(a,b) ((a) < (b) ? (a) : (b))
2352 rsrc_print_resource_directory (FILE * file
,
2354 unsigned int indent
,
2356 rsrc_regions
* regions
,
2359 unsigned int num_names
, num_ids
;
2360 bfd_byte
* highest_data
= data
;
2362 if (data
+ 16 >= regions
->section_end
)
2363 return regions
->section_end
+ 1;
2365 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2368 case 0: fprintf (file
, "Type"); break;
2369 case 2: fprintf (file
, "Name"); break;
2370 case 4: fprintf (file
, "Language"); break;
2372 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2373 /* FIXME: For now we end the printing here. If in the
2374 future more directory types are added to the RSRC spec
2375 then we will need to change this. */
2376 return regions
->section_end
+ 1;
2379 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2380 (int) bfd_get_32 (abfd
, data
),
2381 (long) bfd_get_32 (abfd
, data
+ 4),
2382 (int) bfd_get_16 (abfd
, data
+ 8),
2383 (int) bfd_get_16 (abfd
, data
+ 10),
2384 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2385 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2388 while (num_names
--)
2390 bfd_byte
* entry_end
;
2392 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2393 data
, regions
, rva_bias
);
2395 highest_data
= max (highest_data
, entry_end
);
2396 if (entry_end
>= regions
->section_end
)
2402 bfd_byte
* entry_end
;
2404 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2405 data
, regions
, rva_bias
);
2407 highest_data
= max (highest_data
, entry_end
);
2408 if (entry_end
>= regions
->section_end
)
2412 return max (highest_data
, data
);
2415 /* Display the contents of a .rsrc section. We do not try to
2416 reproduce the resources, windres does that. Instead we dump
2417 the tables in a human readable format. */
2420 rsrc_print_section (bfd
* abfd
, void * vfile
)
2424 FILE * file
= (FILE *) vfile
;
2425 bfd_size_type datasize
;
2428 rsrc_regions regions
;
2430 pe
= pe_data (abfd
);
2434 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2435 if (section
== NULL
)
2437 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2440 datasize
= section
->size
;
2444 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2446 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2453 regions
.section_start
= data
;
2454 regions
.section_end
= data
+ datasize
;
2455 regions
.strings_start
= NULL
;
2456 regions
.resource_start
= NULL
;
2459 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2461 while (data
< regions
.section_end
)
2463 bfd_byte
* p
= data
;
2465 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2467 if (data
== regions
.section_end
+ 1)
2468 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2471 /* Align data before continuing. */
2472 int align
= (1 << section
->alignment_power
) - 1;
2474 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2475 rva_bias
+= data
- p
;
2477 /* For reasons that are unclear .rsrc sections are sometimes created
2478 aligned to a 1^3 boundary even when their alignment is set at
2479 1^2. Catch that case here before we issue a spurious warning
2481 if (data
== (regions
.section_end
- 4))
2482 data
= regions
.section_end
;
2483 else if (data
< regions
.section_end
)
2485 /* If the extra data is all zeros then do not complain.
2486 This is just padding so that the section meets the
2487 page size requirements. */
2488 while (data
++ < regions
.section_end
)
2491 if (data
< regions
.section_end
)
2492 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2497 if (regions
.strings_start
!= NULL
)
2498 fprintf (file
, " String table starts at offset: %#03x\n",
2499 (int) (regions
.strings_start
- regions
.section_start
));
2500 if (regions
.resource_start
!= NULL
)
2501 fprintf (file
, " Resources start at offset: %#03x\n",
2502 (int) (regions
.resource_start
- regions
.section_start
));
2504 free (regions
.section_start
);
2508 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2510 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2527 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2529 FILE *file
= (FILE *) vfile
;
2530 pe_data_type
*pe
= pe_data (abfd
);
2531 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2534 bfd_size_type dataoff
;
2537 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2538 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2543 addr
+= extra
->ImageBase
;
2544 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2546 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2550 if (section
== NULL
)
2553 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2556 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2559 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2563 else if (section
->size
< size
)
2566 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2571 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2572 section
->name
, (unsigned long) addr
);
2574 dataoff
= addr
- section
->vma
;
2577 _("Type Size Rva Offset\n"));
2579 /* Read the whole section. */
2580 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2587 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2589 const char *type_name
;
2590 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2591 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2592 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2594 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2596 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2597 type_name
= debug_type_names
[0];
2599 type_name
= debug_type_names
[idd
.Type
];
2601 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2602 idd
.Type
, type_name
, idd
.SizeOfData
,
2603 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2605 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2607 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2608 char buffer
[256 + 1];
2609 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2611 /* The debug entry doesn't have to have to be in a section,
2612 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2613 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2614 idd
.SizeOfData
, cvinfo
))
2617 for (i
= 0; i
< cvinfo
->SignatureLength
; i
++)
2618 sprintf (&signature
[i
*2], "%02x", cvinfo
->Signature
[i
] & 0xff);
2620 fprintf (file
, "(format %c%c%c%c signature %s age %ld)\n",
2621 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2622 signature
, cvinfo
->Age
);
2626 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2628 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2633 /* Print out the program headers. */
2636 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2638 FILE *file
= (FILE *) vfile
;
2640 pe_data_type
*pe
= pe_data (abfd
);
2641 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2642 const char *subsystem_name
= NULL
;
2645 /* The MS dumpbin program reportedly ands with 0xff0f before
2646 printing the characteristics field. Not sure why. No reason to
2648 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2650 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2651 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2652 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2653 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2654 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2655 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2656 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2657 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2658 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2659 PF (IMAGE_FILE_SYSTEM
, "system file");
2660 PF (IMAGE_FILE_DLL
, "DLL");
2661 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2664 /* ctime implies '\n'. */
2666 time_t t
= pe
->coff
.timestamp
;
2667 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2670 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2671 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2673 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2674 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2676 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2677 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2682 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2685 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2688 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2695 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2697 fprintf (file
, "\t(%s)",name
);
2698 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2699 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2700 fprintf (file
, "SizeOfCode\t\t%08lx\n", (unsigned long) i
->SizeOfCode
);
2701 fprintf (file
, "SizeOfInitializedData\t%08lx\n",
2702 (unsigned long) i
->SizeOfInitializedData
);
2703 fprintf (file
, "SizeOfUninitializedData\t%08lx\n",
2704 (unsigned long) i
->SizeOfUninitializedData
);
2705 fprintf (file
, "AddressOfEntryPoint\t");
2706 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2707 fprintf (file
, "\nBaseOfCode\t\t");
2708 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2709 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2710 /* PE32+ does not have BaseOfData member! */
2711 fprintf (file
, "\nBaseOfData\t\t");
2712 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2715 fprintf (file
, "\nImageBase\t\t");
2716 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2717 fprintf (file
, "\nSectionAlignment\t");
2718 bfd_fprintf_vma (abfd
, file
, i
->SectionAlignment
);
2719 fprintf (file
, "\nFileAlignment\t\t");
2720 bfd_fprintf_vma (abfd
, file
, i
->FileAlignment
);
2721 fprintf (file
, "\nMajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2722 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2723 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2724 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2725 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2726 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2727 fprintf (file
, "Win32Version\t\t%08lx\n", (unsigned long) i
->Reserved1
);
2728 fprintf (file
, "SizeOfImage\t\t%08lx\n", (unsigned long) i
->SizeOfImage
);
2729 fprintf (file
, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i
->SizeOfHeaders
);
2730 fprintf (file
, "CheckSum\t\t%08lx\n", (unsigned long) i
->CheckSum
);
2732 switch (i
->Subsystem
)
2734 case IMAGE_SUBSYSTEM_UNKNOWN
:
2735 subsystem_name
= "unspecified";
2737 case IMAGE_SUBSYSTEM_NATIVE
:
2738 subsystem_name
= "NT native";
2740 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2741 subsystem_name
= "Windows GUI";
2743 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2744 subsystem_name
= "Windows CUI";
2746 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2747 subsystem_name
= "POSIX CUI";
2749 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2750 subsystem_name
= "Wince CUI";
2752 // These are from UEFI Platform Initialization Specification 1.1.
2753 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2754 subsystem_name
= "EFI application";
2756 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2757 subsystem_name
= "EFI boot service driver";
2759 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2760 subsystem_name
= "EFI runtime driver";
2762 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2763 subsystem_name
= "SAL runtime driver";
2765 // This is from revision 8.0 of the MS PE/COFF spec
2766 case IMAGE_SUBSYSTEM_XBOX
:
2767 subsystem_name
= "XBOX";
2769 // Added default case for clarity - subsystem_name is NULL anyway.
2771 subsystem_name
= NULL
;
2774 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2776 fprintf (file
, "\t(%s)", subsystem_name
);
2777 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2778 fprintf (file
, "SizeOfStackReserve\t");
2779 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2780 fprintf (file
, "\nSizeOfStackCommit\t");
2781 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2782 fprintf (file
, "\nSizeOfHeapReserve\t");
2783 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2784 fprintf (file
, "\nSizeOfHeapCommit\t");
2785 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2786 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2787 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2788 (unsigned long) i
->NumberOfRvaAndSizes
);
2790 fprintf (file
, "\nThe Data Directory\n");
2791 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2793 fprintf (file
, "Entry %1x ", j
);
2794 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2795 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2796 fprintf (file
, "%s\n", dir_names
[j
]);
2799 pe_print_idata (abfd
, vfile
);
2800 pe_print_edata (abfd
, vfile
);
2801 if (bfd_coff_have_print_pdata (abfd
))
2802 bfd_coff_print_pdata (abfd
, vfile
);
2804 pe_print_pdata (abfd
, vfile
);
2805 pe_print_reloc (abfd
, vfile
);
2806 pe_print_debugdata (abfd
, file
);
2808 rsrc_print_section (abfd
, vfile
);
2814 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2816 bfd_vma addr
= * (bfd_vma
*) obj
;
2817 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2821 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2823 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2826 /* Copy any private info we understand from the input bfd
2827 to the output bfd. */
2830 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2832 pe_data_type
*ipe
, *ope
;
2834 /* One day we may try to grok other private data. */
2835 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2836 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2839 ipe
= pe_data (ibfd
);
2840 ope
= pe_data (obfd
);
2842 /* pe_opthdr is copied in copy_object. */
2843 ope
->dll
= ipe
->dll
;
2845 /* Don't copy input subsystem if output is different from input. */
2846 if (obfd
->xvec
!= ibfd
->xvec
)
2847 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2849 /* For strip: if we removed .reloc, we'll make a real mess of things
2850 if we don't remove this entry as well. */
2851 if (! pe_data (obfd
)->has_reloc_section
)
2853 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2854 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2857 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2858 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2860 if (! pe_data (ibfd
)->has_reloc_section
2861 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2862 pe_data (obfd
)->dont_strip_reloc
= 1;
2864 /* The file offsets contained in the debug directory need rewriting. */
2865 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2867 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2868 + ope
->pe_opthdr
.ImageBase
;
2869 asection
*section
= find_section_by_vma (obfd
, addr
);
2872 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2875 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2876 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2878 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2879 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2881 asection
*ddsection
;
2882 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
2883 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2885 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
2887 if (idd
.AddressOfRawData
== 0)
2888 continue; /* RVA 0 means only offset is valid, not handled yet. */
2890 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
2892 continue; /* Not in a section! */
2894 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
2895 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
2897 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
2900 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
2901 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2908 /* Copy private section data. */
2911 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
2916 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
2917 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
2920 if (coff_section_data (ibfd
, isec
) != NULL
2921 && pei_section_data (ibfd
, isec
) != NULL
)
2923 if (coff_section_data (obfd
, osec
) == NULL
)
2925 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
2926 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
2927 if (osec
->used_by_bfd
== NULL
)
2931 if (pei_section_data (obfd
, osec
) == NULL
)
2933 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
2934 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
2935 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
2939 pei_section_data (obfd
, osec
)->virt_size
=
2940 pei_section_data (ibfd
, isec
)->virt_size
;
2941 pei_section_data (obfd
, osec
)->pe_flags
=
2942 pei_section_data (ibfd
, isec
)->pe_flags
;
2949 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
2951 coff_get_symbol_info (abfd
, symbol
, ret
);
2954 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2956 sort_x64_pdata (const void *l
, const void *r
)
2958 const char *lp
= (const char *) l
;
2959 const char *rp
= (const char *) r
;
2961 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
2963 return (vl
< vr
? -1 : 1);
2964 /* We compare just begin address. */
2969 /* Functions to process a .rsrc section. */
2971 static unsigned int sizeof_leaves
;
2972 static unsigned int sizeof_strings
;
2973 static unsigned int sizeof_tables_and_entries
;
2976 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
2979 rsrc_count_entries (bfd
* abfd
,
2980 bfd_boolean is_name
,
2981 bfd_byte
* datastart
,
2986 unsigned long entry
, addr
, size
;
2988 if (data
+ 8 >= dataend
)
2995 entry
= (long) bfd_get_32 (abfd
, data
);
2997 if (HighBitSet (entry
))
2998 name
= datastart
+ WithoutHighBit (entry
);
3000 name
= datastart
+ entry
- rva_bias
;
3002 if (name
+ 2 >= dataend
|| name
< datastart
)
3005 unsigned int len
= bfd_get_16 (abfd
, name
);
3006 if (len
== 0 || len
> 256)
3010 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3012 if (HighBitSet (entry
))
3014 data
= datastart
+ WithoutHighBit (entry
);
3016 if (data
<= datastart
|| data
>= dataend
)
3019 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3022 if (datastart
+ entry
+ 16 >= dataend
)
3025 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3026 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3028 return datastart
+ addr
- rva_bias
+ size
;
3032 rsrc_count_directory (bfd
* abfd
,
3033 bfd_byte
* datastart
,
3038 unsigned int num_entries
, num_ids
;
3039 bfd_byte
* highest_data
= data
;
3041 if (data
+ 16 >= dataend
)
3044 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3045 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3047 num_entries
+= num_ids
;
3051 while (num_entries
--)
3053 bfd_byte
* entry_end
;
3055 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3056 datastart
, data
, dataend
, rva_bias
);
3058 highest_data
= max (highest_data
, entry_end
);
3059 if (entry_end
>= dataend
)
3063 return max (highest_data
, data
);
3066 typedef struct rsrc_dir_chain
3068 unsigned int num_entries
;
3069 struct rsrc_entry
* first_entry
;
3070 struct rsrc_entry
* last_entry
;
3073 typedef struct rsrc_directory
3075 unsigned int characteristics
;
3080 rsrc_dir_chain names
;
3083 struct rsrc_entry
* entry
;
3086 typedef struct rsrc_string
3092 typedef struct rsrc_leaf
3095 unsigned int codepage
;
3099 typedef struct rsrc_entry
3101 bfd_boolean is_name
;
3105 struct rsrc_string name
;
3111 struct rsrc_directory
* directory
;
3112 struct rsrc_leaf
* leaf
;
3115 struct rsrc_entry
* next_entry
;
3116 struct rsrc_directory
* parent
;
3120 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3121 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3124 rsrc_parse_entry (bfd
* abfd
,
3125 bfd_boolean is_name
,
3127 bfd_byte
* datastart
,
3131 rsrc_directory
* parent
)
3133 unsigned long val
, addr
, size
;
3135 val
= bfd_get_32 (abfd
, data
);
3137 entry
->parent
= parent
;
3138 entry
->is_name
= is_name
;
3144 if (HighBitSet (val
))
3146 val
= WithoutHighBit (val
);
3148 address
= datastart
+ val
;
3152 address
= datastart
+ val
- rva_bias
;
3155 if (address
+ 3 > dataend
)
3158 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3159 entry
->name_id
.name
.string
= address
+ 2;
3162 entry
->name_id
.id
= val
;
3164 val
= bfd_get_32 (abfd
, data
+ 4);
3166 if (HighBitSet (val
))
3168 entry
->is_dir
= TRUE
;
3169 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3170 if (entry
->value
.directory
== NULL
)
3173 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3175 datastart
+ WithoutHighBit (val
),
3176 dataend
, rva_bias
, entry
);
3179 entry
->is_dir
= FALSE
;
3180 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3181 if (entry
->value
.leaf
== NULL
)
3184 addr
= bfd_get_32 (abfd
, datastart
+ val
);
3185 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, datastart
+ val
+ 4);
3186 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, datastart
+ val
+ 8);
3188 entry
->value
.leaf
->data
= bfd_malloc (size
);
3189 if (entry
->value
.leaf
->data
== NULL
)
3192 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3193 return datastart
+ (addr
- rva_bias
) + size
;
3197 rsrc_parse_entries (bfd
* abfd
,
3198 rsrc_dir_chain
* chain
,
3199 bfd_boolean is_name
,
3200 bfd_byte
* highest_data
,
3201 bfd_byte
* datastart
,
3205 rsrc_directory
* parent
)
3210 if (chain
->num_entries
== 0)
3212 chain
->first_entry
= chain
->last_entry
= NULL
;
3213 return highest_data
;
3216 entry
= bfd_malloc (sizeof * entry
);
3220 chain
->first_entry
= entry
;
3222 for (i
= chain
->num_entries
; i
--;)
3224 bfd_byte
* entry_end
;
3226 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3227 data
, dataend
, rva_bias
, parent
);
3229 highest_data
= max (entry_end
, highest_data
);
3230 if (entry_end
> dataend
)
3235 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3236 entry
= entry
->next_entry
;
3241 entry
->next_entry
= NULL
;
3244 chain
->last_entry
= entry
;
3246 return highest_data
;
3250 rsrc_parse_directory (bfd
* abfd
,
3251 rsrc_directory
* table
,
3252 bfd_byte
* datastart
,
3258 bfd_byte
* highest_data
= data
;
3263 table
->characteristics
= bfd_get_32 (abfd
, data
);
3264 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3265 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3266 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3267 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3268 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3269 table
->entry
= entry
;
3273 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3274 datastart
, data
, dataend
, rva_bias
, table
);
3275 data
+= table
->names
.num_entries
* 8;
3277 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3278 datastart
, data
, dataend
, rva_bias
, table
);
3279 data
+= table
->ids
.num_entries
* 8;
3281 return max (highest_data
, data
);
3284 typedef struct rsrc_write_data
3287 bfd_byte
* datastart
;
3288 bfd_byte
* next_table
;
3289 bfd_byte
* next_leaf
;
3290 bfd_byte
* next_string
;
3291 bfd_byte
* next_data
;
3296 rsrc_write_string (rsrc_write_data
* data
,
3297 rsrc_string
* string
)
3299 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3300 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3301 data
->next_string
+= (string
->len
+ 1) * 2;
3304 static inline unsigned int
3305 rsrc_compute_rva (rsrc_write_data
* data
,
3308 return (addr
- data
->datastart
) + data
->rva_bias
;
3312 rsrc_write_leaf (rsrc_write_data
* data
,
3315 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3317 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3318 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3319 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3320 data
->next_leaf
+= 16;
3322 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3323 /* An undocumented feature of Windows resources is that each unit
3324 of raw data is 8-byte aligned... */
3325 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3328 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3331 rsrc_write_entry (rsrc_write_data
* data
,
3337 bfd_put_32 (data
->abfd
,
3338 SetHighBit (data
->next_string
- data
->datastart
),
3340 rsrc_write_string (data
, & entry
->name_id
.name
);
3343 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3347 bfd_put_32 (data
->abfd
,
3348 SetHighBit (data
->next_table
- data
->datastart
),
3350 rsrc_write_directory (data
, entry
->value
.directory
);
3354 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3355 rsrc_write_leaf (data
, entry
->value
.leaf
);
3360 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3362 struct rsrc_entry
* entry
;
3367 sizeof_tables_and_entries
+= 16;
3369 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3371 sizeof_tables_and_entries
+= 8;
3373 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3376 rsrc_compute_region_sizes (entry
->value
.directory
);
3378 sizeof_leaves
+= 16;
3381 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3383 sizeof_tables_and_entries
+= 8;
3386 rsrc_compute_region_sizes (entry
->value
.directory
);
3388 sizeof_leaves
+= 16;
3393 rsrc_write_directory (rsrc_write_data
* data
,
3394 rsrc_directory
* dir
)
3398 bfd_byte
* next_entry
;
3401 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3402 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3403 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3404 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3405 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3406 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3408 /* Compute where the entries and the next table will be placed. */
3409 next_entry
= data
->next_table
+ 16;
3410 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3411 + (dir
->ids
.num_entries
* 8);
3412 nt
= data
->next_table
;
3414 /* Write the entries. */
3415 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3416 i
> 0 && entry
!= NULL
;
3417 i
--, entry
= entry
->next_entry
)
3419 BFD_ASSERT (entry
->is_name
);
3420 rsrc_write_entry (data
, next_entry
, entry
);
3423 BFD_ASSERT (i
== 0);
3424 BFD_ASSERT (entry
== NULL
);
3426 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3427 i
> 0 && entry
!= NULL
;
3428 i
--, entry
= entry
->next_entry
)
3430 BFD_ASSERT (! entry
->is_name
);
3431 rsrc_write_entry (data
, next_entry
, entry
);
3434 BFD_ASSERT (i
== 0);
3435 BFD_ASSERT (entry
== NULL
);
3436 BFD_ASSERT (nt
== next_entry
);
3439 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3440 /* Return the length (number of units) of the first character in S,
3441 putting its 'ucs4_t' representation in *PUC. */
3444 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3446 unsigned short c
= * s
;
3448 if (c
< 0xd800 || c
>= 0xe000)
3458 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3460 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3466 /* Incomplete multibyte character. */
3472 /* Invalid multibyte character. */
3476 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3478 /* Perform a comparison of two entries. */
3480 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3489 return a
->name_id
.id
- b
->name_id
.id
;
3491 /* We have to perform a case insenstive, unicode string comparison... */
3492 astring
= a
->name_id
.name
.string
;
3493 alen
= a
->name_id
.name
.len
;
3494 bstring
= b
->name_id
.name
.string
;
3495 blen
= b
->name_id
.name
.len
;
3497 #if defined __CYGWIN__ || defined __MINGW32__
3498 /* Under Windows hosts (both Cygwin and Mingw types),
3499 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3500 function however goes by different names in the two environments... */
3504 #define rscpcmp wcsncasecmp
3507 #define rscpcmp wcsnicmp
3510 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3513 #elif defined HAVE_WCHAR_H
3517 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3522 /* Convert UTF-16 unicode characters into wchar_t characters so
3523 that we can then perform a case insensitive comparison. */
3524 int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3525 int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3529 res
= wcsncasecmp (& awc
, & bwc
, 1);
3535 /* Do the best we can - a case sensitive, untranslated comparison. */
3536 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3546 rsrc_print_name (char * buffer
, rsrc_string string
)
3549 bfd_byte
* name
= string
.string
;
3551 for (i
= string
.len
; i
--; name
+= 2)
3552 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3556 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3558 static char buffer
[256];
3559 bfd_boolean is_string
= FALSE
;
3563 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3564 && dir
->entry
->parent
->entry
!= NULL
)
3566 strcpy (buffer
, "type: ");
3567 if (dir
->entry
->parent
->entry
->is_name
)
3568 rsrc_print_name (buffer
+ strlen (buffer
),
3569 dir
->entry
->parent
->entry
->name_id
.name
);
3572 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3574 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3577 case 1: strcat (buffer
, " (CURSOR)"); break;
3578 case 2: strcat (buffer
, " (BITMAP)"); break;
3579 case 3: strcat (buffer
, " (ICON)"); break;
3580 case 4: strcat (buffer
, " (MENU)"); break;
3581 case 5: strcat (buffer
, " (DIALOG)"); break;
3582 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3583 case 7: strcat (buffer
, " (FONTDIR)"); break;
3584 case 8: strcat (buffer
, " (FONT)"); break;
3585 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3586 case 10: strcat (buffer
, " (RCDATA)"); break;
3587 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3588 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3589 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3590 case 16: strcat (buffer
, " (VERSION)"); break;
3591 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3592 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3593 case 20: strcat (buffer
, " (VXD)"); break;
3594 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3595 case 22: strcat (buffer
, " (ANIICON)"); break;
3596 case 23: strcat (buffer
, " (HTML)"); break;
3597 case 24: strcat (buffer
, " (MANIFEST)"); break;
3598 case 240: strcat (buffer
, " (DLGINIT)"); break;
3599 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3604 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3606 strcat (buffer
, " name: ");
3607 if (dir
->entry
->is_name
)
3608 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3611 unsigned int id
= dir
->entry
->name_id
.id
;
3613 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3616 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3617 (id
- 1) << 4, (id
<< 4) - 1);
3623 strcat (buffer
, " lang: ");
3626 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3628 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3634 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3635 their ID is stored in the NAME entry. The bottom four bits are used as
3636 an index into unicode string table that makes up the data of the leaf.
3637 So identical type-name-lang string resources may not actually be
3640 This function is called when we have detected two string resources with
3641 match top-28-bit IDs. We have to scan the string tables inside the leaves
3642 and discover if there are any real collisions. If there are then we report
3643 them and return FALSE. Otherwise we copy any strings from B into A and
3644 then return TRUE. */
3647 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3648 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3650 unsigned int copy_needed
= 0;
3654 bfd_byte
* new_data
;
3657 /* Step one: Find out what we have to do. */
3658 BFD_ASSERT (! a
->is_dir
);
3659 astring
= a
->value
.leaf
->data
;
3661 BFD_ASSERT (! b
->is_dir
);
3662 bstring
= b
->value
.leaf
->data
;
3664 for (i
= 0; i
< 16; i
++)
3666 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3667 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3671 copy_needed
+= blen
* 2;
3675 else if (alen
!= blen
)
3676 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3678 /* alen == blen != 0. We might have two identical strings. If so we
3679 can ignore the second one. There is no need for wchar_t vs UTF-16
3680 theatrics here - we are only interested in (case sensitive) equality. */
3681 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3684 astring
+= (alen
+ 1) * 2;
3685 bstring
+= (blen
+ 1) * 2;
3690 if (a
->parent
!= NULL
3691 && a
->parent
->entry
!= NULL
3692 && a
->parent
->entry
->is_name
== FALSE
)
3693 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3694 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3698 if (copy_needed
== 0)
3701 /* If we reach here then A and B must both have non-colliding strings.
3702 (We never get string resources with fully empty string tables).
3703 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3705 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3706 if (new_data
== NULL
)
3710 astring
= a
->value
.leaf
->data
;
3711 bstring
= b
->value
.leaf
->data
;
3713 for (i
= 0; i
< 16; i
++)
3715 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3716 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3720 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3721 nstring
+= (alen
+ 1) * 2;
3725 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3726 nstring
+= (blen
+ 1) * 2;
3734 astring
+= (alen
+ 1) * 2;
3735 bstring
+= (blen
+ 1) * 2;
3738 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3740 free (a
->value
.leaf
->data
);
3741 a
->value
.leaf
->data
= new_data
;
3742 a
->value
.leaf
->size
+= copy_needed
;
3747 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3749 /* Sort the entries in given part of the directory.
3750 We use an old fashioned bubble sort because we are dealing
3751 with lists and we want to handle matches specially. */
3754 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3755 bfd_boolean is_name
,
3756 rsrc_directory
* dir
)
3760 rsrc_entry
** points_to_entry
;
3761 bfd_boolean swapped
;
3763 if (chain
->num_entries
< 2)
3769 points_to_entry
= & chain
->first_entry
;
3770 entry
= * points_to_entry
;
3771 next
= entry
->next_entry
;
3775 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3779 entry
->next_entry
= next
->next_entry
;
3780 next
->next_entry
= entry
;
3781 * points_to_entry
= next
;
3782 points_to_entry
= & next
->next_entry
;
3783 next
= entry
->next_entry
;
3788 if (entry
->is_dir
&& next
->is_dir
)
3790 /* When we encounter identical directory entries we have to
3791 merge them together. The exception to this rule is for
3792 resource manifests - there can only be one of these,
3793 even if they differ in language. Zero-language manifests
3794 are assumed to be default manifests (provided by the
3795 Cygwin/MinGW build system) and these can be silently dropped,
3796 unless that would reduce the number of manifests to zero.
3797 There should only ever be one non-zero lang manifest -
3798 if there are more it is an error. A non-zero lang
3799 manifest takes precedence over a default manifest. */
3800 if (entry
->is_name
== FALSE
3801 && entry
->name_id
.id
== 1
3803 && dir
->entry
!= NULL
3804 && dir
->entry
->is_name
== FALSE
3805 && dir
->entry
->name_id
.id
== 0x18)
3807 if (next
->value
.directory
->names
.num_entries
== 0
3808 && next
->value
.directory
->ids
.num_entries
== 1
3809 && next
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3810 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3811 /* Fall through so that NEXT is dropped. */
3813 else if (entry
->value
.directory
->names
.num_entries
== 0
3814 && entry
->value
.directory
->ids
.num_entries
== 1
3815 && entry
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3816 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3818 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3819 entry
->next_entry
= next
->next_entry
;
3820 next
->next_entry
= entry
;
3821 * points_to_entry
= next
;
3822 points_to_entry
= & next
->next_entry
;
3823 next
= entry
->next_entry
;
3828 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3829 bfd_set_error (bfd_error_file_truncated
);
3833 /* Unhook NEXT from the chain. */
3834 /* FIXME: memory loss here. */
3835 entry
->next_entry
= next
->next_entry
;
3836 chain
->num_entries
--;
3837 if (chain
->num_entries
< 2)
3839 next
= next
->next_entry
;
3842 rsrc_merge (entry
, next
);
3844 else if (entry
->is_dir
!= next
->is_dir
)
3846 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3847 bfd_set_error (bfd_error_file_truncated
);
3852 /* Otherwise with identical leaves we issue an error
3853 message - because there should never be duplicates.
3854 The exception is Type 18/Name 1/Lang 0 which is the
3855 defaul manifest - this can just be dropped. */
3856 if (entry
->is_name
== FALSE
3857 && entry
->name_id
.id
== 0
3859 && dir
->entry
!= NULL
3860 && dir
->entry
->is_name
== FALSE
3861 && dir
->entry
->name_id
.id
== 1
3862 && dir
->entry
->parent
!= NULL
3863 && dir
->entry
->parent
->entry
!= NULL
3864 && dir
->entry
->parent
->entry
->is_name
== FALSE
3865 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
3867 else if (dir
!= NULL
3868 && dir
->entry
!= NULL
3869 && dir
->entry
->parent
!= NULL
3870 && dir
->entry
->parent
->entry
!= NULL
3871 && dir
->entry
->parent
->entry
->is_name
== FALSE
3872 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
3874 /* Strings need special handling. */
3875 if (! rsrc_merge_string_entries (entry
, next
))
3877 /* _bfd_error_handler should have been called inside merge_strings. */
3878 bfd_set_error (bfd_error_file_truncated
);
3885 || dir
->entry
== NULL
3886 || dir
->entry
->parent
== NULL
3887 || dir
->entry
->parent
->entry
== NULL
)
3888 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3890 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3891 rsrc_resource_name (entry
, dir
));
3892 bfd_set_error (bfd_error_file_truncated
);
3897 /* Unhook NEXT from the chain. */
3898 entry
->next_entry
= next
->next_entry
;
3899 chain
->num_entries
--;
3900 if (chain
->num_entries
< 2)
3902 next
= next
->next_entry
;
3906 points_to_entry
= & entry
->next_entry
;
3908 next
= next
->next_entry
;
3913 chain
->last_entry
= entry
;
3918 /* Attach B's chain onto A. */
3920 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
3922 if (bchain
->num_entries
== 0)
3925 achain
->num_entries
+= bchain
->num_entries
;
3927 if (achain
->first_entry
== NULL
)
3929 achain
->first_entry
= bchain
->first_entry
;
3930 achain
->last_entry
= bchain
->last_entry
;
3934 achain
->last_entry
->next_entry
= bchain
->first_entry
;
3935 achain
->last_entry
= bchain
->last_entry
;
3938 bchain
->num_entries
= 0;
3939 bchain
->first_entry
= bchain
->last_entry
= NULL
;
3943 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
3945 rsrc_directory
* adir
;
3946 rsrc_directory
* bdir
;
3948 BFD_ASSERT (a
->is_dir
);
3949 BFD_ASSERT (b
->is_dir
);
3951 adir
= a
->value
.directory
;
3952 bdir
= b
->value
.directory
;
3954 if (adir
->characteristics
!= bdir
->characteristics
)
3956 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3957 bfd_set_error (bfd_error_file_truncated
);
3961 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
3963 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3964 bfd_set_error (bfd_error_file_truncated
);
3968 /* Attach B's name chain to A. */
3969 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
3971 /* Attach B's ID chain to A. */
3972 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
3974 /* Now sort A's entries. */
3975 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
3976 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
3979 /* Check the .rsrc section. If it contains multiple concatenated
3980 resources then we must merge them properly. Otherwise Windows
3981 will ignore all but the first set. */
3984 rsrc_process_section (bfd
* abfd
,
3985 struct coff_final_link_info
* pfinfo
)
3987 rsrc_directory new_table
;
3993 bfd_byte
* datastart
;
3995 bfd_byte
* new_data
;
3996 unsigned int num_resource_sets
;
3997 rsrc_directory
* type_tables
;
3998 rsrc_write_data write_data
;
4001 unsigned int num_input_rsrc
= 0;
4002 unsigned int max_num_input_rsrc
= 4;
4003 ptrdiff_t * rsrc_sizes
= NULL
;
4005 new_table
.names
.num_entries
= 0;
4006 new_table
.ids
.num_entries
= 0;
4008 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4009 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4012 pe
= pe_data (abfd
);
4016 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4018 data
= bfd_malloc (size
);
4024 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4027 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4028 their lengths. Note - we rely upon the fact that the linker script
4029 does *not* sort the input .rsrc sections, so that the order in the
4030 linkinfo list matches the order in the output .rsrc section.
4032 We need to know the lengths because each input .rsrc section has padding
4033 at the end of a variable amount. (It does not appear to be based upon
4034 the section alignment or the file alignment). We need to skip any
4035 padding bytes when parsing the input .rsrc sections. */
4036 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4037 if (rsrc_sizes
== NULL
)
4040 for (input
= pfinfo
->info
->input_bfds
;
4042 input
= input
->link
.next
)
4044 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4046 if (rsrc_sec
!= NULL
)
4048 if (num_input_rsrc
== max_num_input_rsrc
)
4050 max_num_input_rsrc
+= 10;
4051 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4052 * sizeof * rsrc_sizes
);
4053 if (rsrc_sizes
== NULL
)
4057 BFD_ASSERT (rsrc_sec
->size
> 0);
4058 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4062 if (num_input_rsrc
< 2)
4065 /* Step one: Walk the section, computing the size of the tables,
4066 leaves and data and decide if we need to do anything. */
4067 dataend
= data
+ size
;
4068 num_resource_sets
= 0;
4070 while (data
< dataend
)
4072 bfd_byte
* p
= data
;
4074 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4078 /* Corrupted .rsrc section - cannot merge. */
4079 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4080 bfd_get_filename (abfd
));
4081 bfd_set_error (bfd_error_file_truncated
);
4085 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4087 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4088 bfd_get_filename (abfd
));
4089 bfd_set_error (bfd_error_file_truncated
);
4092 /* FIXME: Should we add a check for "data - p" being much smaller
4093 than rsrc_sizes[num_resource_sets] ? */
4095 data
= p
+ rsrc_sizes
[num_resource_sets
];
4096 rva_bias
+= data
- p
;
4097 ++ num_resource_sets
;
4099 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4101 /* Step two: Walk the data again, building trees of the resources. */
4103 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4105 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4106 if (type_tables
== NULL
)
4110 while (data
< dataend
)
4112 bfd_byte
* p
= data
;
4114 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4115 dataend
, rva_bias
, NULL
);
4116 data
= p
+ rsrc_sizes
[indx
];
4117 rva_bias
+= data
- p
;
4120 BFD_ASSERT (indx
== num_resource_sets
);
4122 /* Step three: Merge the top level tables (there can be only one).
4124 We must ensure that the merged entries are in ascending order.
4126 We also thread the top level table entries from the old tree onto
4127 the new table, so that they can be pulled off later. */
4129 /* FIXME: Should we verify that all type tables are the same ? */
4130 new_table
.characteristics
= type_tables
[0].characteristics
;
4131 new_table
.time
= type_tables
[0].time
;
4132 new_table
.major
= type_tables
[0].major
;
4133 new_table
.minor
= type_tables
[0].minor
;
4135 /* Chain the NAME entries onto the table. */
4136 new_table
.names
.first_entry
= NULL
;
4137 new_table
.names
.last_entry
= NULL
;
4139 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4140 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4142 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4144 /* Chain the ID entries onto the table. */
4145 new_table
.ids
.first_entry
= NULL
;
4146 new_table
.ids
.last_entry
= NULL
;
4148 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4149 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4151 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4153 /* Step four: Create new contents for the .rsrc section. */
4154 /* Step four point one: Compute the size of each region of the .rsrc section.
4155 We do this now, rather than earlier, as the merging above may have dropped
4157 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4158 rsrc_compute_region_sizes (& new_table
);
4159 /* We increment sizeof_strings to make sure that resource data
4160 starts on an 8-byte boundary. FIXME: Is this correct ? */
4161 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4163 new_data
= bfd_zalloc (abfd
, size
);
4164 if (new_data
== NULL
)
4167 write_data
.abfd
= abfd
;
4168 write_data
.datastart
= new_data
;
4169 write_data
.next_table
= new_data
;
4170 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4171 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4172 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4173 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4175 rsrc_write_directory (& write_data
, & new_table
);
4177 /* Step five: Replace the old contents with the new.
4178 We recompute the size as we may have lost entries due to mergeing. */
4179 size
= ((write_data
.next_data
- new_data
) + 3) & ~ 3;
4184 if (coff_data (abfd
)->link_info
)
4186 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
4188 /* If no file alignment has been set, default to one.
4189 This repairs 'ld -r' for arm-wince-pe target. */
4194 page_size
= PE_DEF_FILE_ALIGNMENT
;
4195 size
= (size
+ page_size
- 1) & - page_size
;
4198 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4199 sec
->size
= sec
->rawsize
= size
;
4202 /* Step six: Free all the memory that we have used. */
4203 /* FIXME: Free the resource tree, if we have one. */
4208 /* Handle the .idata section and other things that need symbol table
4212 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4214 struct coff_link_hash_entry
*h1
;
4215 struct bfd_link_info
*info
= pfinfo
->info
;
4216 bfd_boolean result
= TRUE
;
4218 /* There are a few fields that need to be filled in now while we
4219 have symbol table access.
4221 The .idata subsections aren't directly available as sections, but
4222 they are in the symbol table, so get them from there. */
4224 /* The import directory. This is the address of .idata$2, with size
4225 of .idata$2 + .idata$3. */
4226 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4227 ".idata$2", FALSE
, FALSE
, TRUE
);
4230 /* PR ld/2729: We cannot rely upon all the output sections having been
4231 created properly, so check before referencing them. Issue a warning
4232 message for any sections tht could not be found. */
4233 if ((h1
->root
.type
== bfd_link_hash_defined
4234 || h1
->root
.type
== bfd_link_hash_defweak
)
4235 && h1
->root
.u
.def
.section
!= NULL
4236 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4237 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4238 (h1
->root
.u
.def
.value
4239 + h1
->root
.u
.def
.section
->output_section
->vma
4240 + h1
->root
.u
.def
.section
->output_offset
);
4244 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4249 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4250 ".idata$4", FALSE
, FALSE
, TRUE
);
4252 && (h1
->root
.type
== bfd_link_hash_defined
4253 || h1
->root
.type
== bfd_link_hash_defweak
)
4254 && h1
->root
.u
.def
.section
!= NULL
4255 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4256 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4257 ((h1
->root
.u
.def
.value
4258 + h1
->root
.u
.def
.section
->output_section
->vma
4259 + h1
->root
.u
.def
.section
->output_offset
)
4260 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4264 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4269 /* The import address table. This is the size/address of
4271 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4272 ".idata$5", FALSE
, FALSE
, TRUE
);
4274 && (h1
->root
.type
== bfd_link_hash_defined
4275 || h1
->root
.type
== bfd_link_hash_defweak
)
4276 && h1
->root
.u
.def
.section
!= NULL
4277 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4278 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4279 (h1
->root
.u
.def
.value
4280 + h1
->root
.u
.def
.section
->output_section
->vma
4281 + h1
->root
.u
.def
.section
->output_offset
);
4285 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4290 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4291 ".idata$6", FALSE
, FALSE
, TRUE
);
4293 && (h1
->root
.type
== bfd_link_hash_defined
4294 || h1
->root
.type
== bfd_link_hash_defweak
)
4295 && h1
->root
.u
.def
.section
!= NULL
4296 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4297 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4298 ((h1
->root
.u
.def
.value
4299 + h1
->root
.u
.def
.section
->output_section
->vma
4300 + h1
->root
.u
.def
.section
->output_offset
)
4301 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4305 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4312 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4313 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4315 && (h1
->root
.type
== bfd_link_hash_defined
4316 || h1
->root
.type
== bfd_link_hash_defweak
)
4317 && h1
->root
.u
.def
.section
!= NULL
4318 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4323 (h1
->root
.u
.def
.value
4324 + h1
->root
.u
.def
.section
->output_section
->vma
4325 + h1
->root
.u
.def
.section
->output_offset
);
4327 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4328 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4330 && (h1
->root
.type
== bfd_link_hash_defined
4331 || h1
->root
.type
== bfd_link_hash_defweak
)
4332 && h1
->root
.u
.def
.section
!= NULL
4333 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4335 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4336 ((h1
->root
.u
.def
.value
4337 + h1
->root
.u
.def
.section
->output_section
->vma
4338 + h1
->root
.u
.def
.section
->output_offset
)
4340 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4341 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4342 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4347 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4348 " because .idata$6 is missing"), abfd
);
4354 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4355 (bfd_get_symbol_leading_char (abfd
) != 0
4356 ? "__tls_used" : "_tls_used"),
4357 FALSE
, FALSE
, TRUE
);
4360 if ((h1
->root
.type
== bfd_link_hash_defined
4361 || h1
->root
.type
== bfd_link_hash_defweak
)
4362 && h1
->root
.u
.def
.section
!= NULL
4363 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4364 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4365 (h1
->root
.u
.def
.value
4366 + h1
->root
.u
.def
.section
->output_section
->vma
4367 + h1
->root
.u
.def
.section
->output_offset
4368 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4372 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4376 /* According to PECOFF sepcifications by Microsoft version 8.2
4377 the TLS data directory consists of 4 pointers, followed
4378 by two 4-byte integer. This implies that the total size
4379 is different for 32-bit and 64-bit executables. */
4380 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4381 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4383 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4387 /* If there is a .pdata section and we have linked pdata finally, we
4388 need to sort the entries ascending. */
4389 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4391 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4395 bfd_size_type x
= sec
->rawsize
;
4396 bfd_byte
*tmp_data
= NULL
;
4399 tmp_data
= bfd_malloc (x
);
4401 if (tmp_data
!= NULL
)
4403 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4407 12, sort_x64_pdata
);
4408 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4417 rsrc_process_section (abfd
, pfinfo
);
4419 /* If we couldn't find idata$2, we either have an excessively
4420 trivial program or are in DEEP trouble; we have to assume trivial