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
);
462 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
463 /* PE32+ does not have data_start member! */
464 aouthdr_int
->data_start
=
465 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
466 a
->BaseOfData
= aouthdr_int
->data_start
;
469 a
->Magic
= aouthdr_int
->magic
;
470 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
471 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
472 a
->SizeOfCode
= aouthdr_int
->tsize
;
473 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
474 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
475 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
476 a
->BaseOfCode
= aouthdr_int
->text_start
;
477 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
478 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
479 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
480 a
->MajorOperatingSystemVersion
=
481 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
482 a
->MinorOperatingSystemVersion
=
483 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
484 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
485 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
486 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
487 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
488 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
489 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
490 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
491 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
492 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
493 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
494 a
->SizeOfStackReserve
=
495 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
496 a
->SizeOfStackCommit
=
497 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
498 a
->SizeOfHeapReserve
=
499 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
500 a
->SizeOfHeapCommit
=
501 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
502 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
503 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
508 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
509 if (a
->NumberOfRvaAndSizes
> IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
511 (*_bfd_error_handler
)
512 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
513 abfd
, a
->NumberOfRvaAndSizes
);
514 /* Paranoia: If the number is corrupt, then assume that the
515 actual entries themselves might be corrupt as well. */
516 a
->NumberOfRvaAndSizes
= 0;
519 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
521 /* If data directory is empty, rva also should be 0. */
523 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
525 a
->DataDirectory
[idx
].Size
= size
;
528 a
->DataDirectory
[idx
].VirtualAddress
=
529 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
531 a
->DataDirectory
[idx
].VirtualAddress
= 0;
534 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
536 a
->DataDirectory
[idx
].Size
= 0;
537 a
->DataDirectory
[idx
].VirtualAddress
= 0;
542 if (aouthdr_int
->entry
)
544 aouthdr_int
->entry
+= a
->ImageBase
;
545 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
546 aouthdr_int
->entry
&= 0xffffffff;
550 if (aouthdr_int
->tsize
)
552 aouthdr_int
->text_start
+= a
->ImageBase
;
553 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
554 aouthdr_int
->text_start
&= 0xffffffff;
558 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
559 /* PE32+ does not have data_start member! */
560 if (aouthdr_int
->dsize
)
562 aouthdr_int
->data_start
+= a
->ImageBase
;
563 aouthdr_int
->data_start
&= 0xffffffff;
568 /* These three fields are normally set up by ppc_relocate_section.
569 In the case of reading a file in, we can pick them up from the
571 first_thunk_address
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
;
572 thunk_size
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
;
573 import_table_size
= a
->DataDirectory
[PE_IMPORT_TABLE
].Size
;
577 /* A support function for below. */
580 add_data_entry (bfd
* abfd
,
581 struct internal_extra_pe_aouthdr
*aout
,
586 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
588 /* Add import directory information if it exists. */
590 && (coff_section_data (abfd
, sec
) != NULL
)
591 && (pei_section_data (abfd
, sec
) != NULL
))
593 /* If data directory is empty, rva also should be 0. */
594 int size
= pei_section_data (abfd
, sec
)->virt_size
;
595 aout
->DataDirectory
[idx
].Size
= size
;
599 aout
->DataDirectory
[idx
].VirtualAddress
=
600 (sec
->vma
- base
) & 0xffffffff;
601 sec
->flags
|= SEC_DATA
;
607 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
609 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
610 pe_data_type
*pe
= pe_data (abfd
);
611 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
612 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
614 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
616 sa
= extra
->SectionAlignment
;
617 fa
= extra
->FileAlignment
;
618 ib
= extra
->ImageBase
;
620 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
621 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
622 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
624 if (aouthdr_in
->tsize
)
626 aouthdr_in
->text_start
-= ib
;
627 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
628 aouthdr_in
->text_start
&= 0xffffffff;
632 if (aouthdr_in
->dsize
)
634 aouthdr_in
->data_start
-= ib
;
635 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
636 aouthdr_in
->data_start
&= 0xffffffff;
640 if (aouthdr_in
->entry
)
642 aouthdr_in
->entry
-= ib
;
643 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
644 aouthdr_in
->entry
&= 0xffffffff;
648 #define FA(x) (((x) + fa -1 ) & (- fa))
649 #define SA(x) (((x) + sa -1 ) & (- sa))
651 /* We like to have the sizes aligned. */
652 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
654 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
656 add_data_entry (abfd
, extra
, 0, ".edata", ib
);
657 add_data_entry (abfd
, extra
, 2, ".rsrc", ib
);
658 add_data_entry (abfd
, extra
, 3, ".pdata", ib
);
660 /* In theory we do not need to call add_data_entry for .idata$2 or
661 .idata$5. It will be done in bfd_coff_final_link where all the
662 required information is available. If however, we are not going
663 to perform a final link, eg because we have been invoked by objcopy
664 or strip, then we need to make sure that these Data Directory
665 entries are initialised properly.
667 So - we copy the input values into the output values, and then, if
668 a final link is going to be performed, it can overwrite them. */
669 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
670 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
671 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
673 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
674 /* Until other .idata fixes are made (pending patch), the entry for
675 .idata is needed for backwards compatibility. FIXME. */
676 add_data_entry (abfd
, extra
, 1, ".idata", ib
);
678 /* For some reason, the virtual size (which is what's set by
679 add_data_entry) for .reloc is not the same as the size recorded
680 in this slot by MSVC; it doesn't seem to cause problems (so far),
681 but since it's the best we've got, use it. It does do the right
683 if (pe
->has_reloc_section
)
684 add_data_entry (abfd
, extra
, 5, ".reloc", ib
);
693 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
695 int rounded
= FA (sec
->size
);
697 /* The first non-zero section filepos is the header size.
698 Sections without contents will have a filepos of 0. */
700 hsize
= sec
->filepos
;
701 if (sec
->flags
& SEC_DATA
)
703 if (sec
->flags
& SEC_CODE
)
705 /* The image size is the total VIRTUAL size (which is what is
706 in the virt_size field). Files have been seen (from MSVC
707 5.0 link.exe) where the file size of the .data segment is
708 quite small compared to the virtual size. Without this
709 fix, strip munges the file.
711 FIXME: We need to handle holes between sections, which may
712 happpen when we covert from another format. We just use
713 the virtual address and virtual size of the last section
714 for the image size. */
715 if (coff_section_data (abfd
, sec
) != NULL
716 && pei_section_data (abfd
, sec
) != NULL
)
717 isize
= (sec
->vma
- extra
->ImageBase
718 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
721 aouthdr_in
->dsize
= dsize
;
722 aouthdr_in
->tsize
= tsize
;
723 extra
->SizeOfHeaders
= hsize
;
724 extra
->SizeOfImage
= isize
;
727 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
729 /* e.g. 219510000 is linker version 2.19 */
730 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
732 /* This piece of magic sets the "linker version" field to
734 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
735 aouthdr_out
->standard
.vstamp
);
737 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
738 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
739 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
740 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
741 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
742 aouthdr_out
->standard
.text_start
);
744 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
745 /* PE32+ does not have data_start member! */
746 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
747 aouthdr_out
->standard
.data_start
);
750 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
751 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
752 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
753 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
754 aouthdr_out
->MajorOperatingSystemVersion
);
755 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
756 aouthdr_out
->MinorOperatingSystemVersion
);
757 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
758 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
759 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
760 aouthdr_out
->MajorSubsystemVersion
);
761 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
762 aouthdr_out
->MinorSubsystemVersion
);
763 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
764 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
765 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
766 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
767 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
768 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
769 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
770 aouthdr_out
->SizeOfStackReserve
);
771 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
772 aouthdr_out
->SizeOfStackCommit
);
773 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
774 aouthdr_out
->SizeOfHeapReserve
);
775 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
776 aouthdr_out
->SizeOfHeapCommit
);
777 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
778 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
779 aouthdr_out
->NumberOfRvaAndSizes
);
783 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
785 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
786 aouthdr_out
->DataDirectory
[idx
][0]);
787 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
788 aouthdr_out
->DataDirectory
[idx
][1]);
796 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
799 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
800 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
802 if (pe_data (abfd
)->has_reloc_section
803 || pe_data (abfd
)->dont_strip_reloc
)
804 filehdr_in
->f_flags
&= ~F_RELFLG
;
806 if (pe_data (abfd
)->dll
)
807 filehdr_in
->f_flags
|= F_DLL
;
809 filehdr_in
->pe
.e_magic
= DOSMAGIC
;
810 filehdr_in
->pe
.e_cblp
= 0x90;
811 filehdr_in
->pe
.e_cp
= 0x3;
812 filehdr_in
->pe
.e_crlc
= 0x0;
813 filehdr_in
->pe
.e_cparhdr
= 0x4;
814 filehdr_in
->pe
.e_minalloc
= 0x0;
815 filehdr_in
->pe
.e_maxalloc
= 0xffff;
816 filehdr_in
->pe
.e_ss
= 0x0;
817 filehdr_in
->pe
.e_sp
= 0xb8;
818 filehdr_in
->pe
.e_csum
= 0x0;
819 filehdr_in
->pe
.e_ip
= 0x0;
820 filehdr_in
->pe
.e_cs
= 0x0;
821 filehdr_in
->pe
.e_lfarlc
= 0x40;
822 filehdr_in
->pe
.e_ovno
= 0x0;
824 for (idx
= 0; idx
< 4; idx
++)
825 filehdr_in
->pe
.e_res
[idx
] = 0x0;
827 filehdr_in
->pe
.e_oemid
= 0x0;
828 filehdr_in
->pe
.e_oeminfo
= 0x0;
830 for (idx
= 0; idx
< 10; idx
++)
831 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
833 filehdr_in
->pe
.e_lfanew
= 0x80;
835 /* This next collection of data are mostly just characters. It
836 appears to be constant within the headers put on NT exes. */
837 filehdr_in
->pe
.dos_message
[0] = 0x0eba1f0e;
838 filehdr_in
->pe
.dos_message
[1] = 0xcd09b400;
839 filehdr_in
->pe
.dos_message
[2] = 0x4c01b821;
840 filehdr_in
->pe
.dos_message
[3] = 0x685421cd;
841 filehdr_in
->pe
.dos_message
[4] = 0x70207369;
842 filehdr_in
->pe
.dos_message
[5] = 0x72676f72;
843 filehdr_in
->pe
.dos_message
[6] = 0x63206d61;
844 filehdr_in
->pe
.dos_message
[7] = 0x6f6e6e61;
845 filehdr_in
->pe
.dos_message
[8] = 0x65622074;
846 filehdr_in
->pe
.dos_message
[9] = 0x6e757220;
847 filehdr_in
->pe
.dos_message
[10] = 0x206e6920;
848 filehdr_in
->pe
.dos_message
[11] = 0x20534f44;
849 filehdr_in
->pe
.dos_message
[12] = 0x65646f6d;
850 filehdr_in
->pe
.dos_message
[13] = 0x0a0d0d2e;
851 filehdr_in
->pe
.dos_message
[14] = 0x24;
852 filehdr_in
->pe
.dos_message
[15] = 0x0;
853 filehdr_in
->pe
.nt_signature
= NT_SIGNATURE
;
855 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
856 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
858 /* Only use a real timestamp if the option was chosen. */
859 if ((pe_data (abfd
)->insert_timestamp
))
860 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
862 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
863 filehdr_out
->f_symptr
);
864 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
865 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
866 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
868 /* Put in extra dos header stuff. This data remains essentially
869 constant, it just has to be tacked on to the beginning of all exes
871 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
874 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
877 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
878 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
879 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
880 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
881 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
882 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
883 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
884 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
886 for (idx
= 0; idx
< 4; idx
++)
887 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
889 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
890 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
892 for (idx
= 0; idx
< 10; idx
++)
893 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
895 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
897 for (idx
= 0; idx
< 16; idx
++)
898 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
899 filehdr_out
->dos_message
[idx
]);
901 /* Also put in the NT signature. */
902 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
908 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
910 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
911 FILHDR
*filehdr_out
= (FILHDR
*) out
;
913 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
914 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
915 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
916 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
917 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
918 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
919 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
925 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
927 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
928 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
929 unsigned int ret
= SCNHSZ
;
933 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
935 PUT_SCNHDR_VADDR (abfd
,
936 ((scnhdr_int
->s_vaddr
937 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
939 scnhdr_ext
->s_vaddr
);
941 /* NT wants the size data to be rounded up to the next
942 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
944 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
946 if (bfd_pei_p (abfd
))
948 ps
= scnhdr_int
->s_size
;
954 ss
= scnhdr_int
->s_size
;
959 if (bfd_pei_p (abfd
))
960 ps
= scnhdr_int
->s_paddr
;
964 ss
= scnhdr_int
->s_size
;
967 PUT_SCNHDR_SIZE (abfd
, ss
,
970 /* s_paddr in PE is really the virtual size. */
971 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
973 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
974 scnhdr_ext
->s_scnptr
);
975 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
976 scnhdr_ext
->s_relptr
);
977 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
978 scnhdr_ext
->s_lnnoptr
);
981 /* Extra flags must be set when dealing with PE. All sections should also
982 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
983 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
984 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
985 (this is especially important when dealing with the .idata section since
986 the addresses for routines from .dlls must be overwritten). If .reloc
987 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
988 (0x02000000). Also, the resource data should also be read and
991 /* FIXME: Alignment is also encoded in this field, at least on PPC and
992 ARM-WINCE. Although - how do we get the original alignment field
997 const char * section_name
;
998 unsigned long must_have
;
1000 pe_required_section_flags
;
1002 pe_required_section_flags known_sections
[] =
1004 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1005 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1006 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1007 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1008 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1009 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1010 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1011 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1012 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1013 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1014 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1015 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1019 pe_required_section_flags
* p
;
1021 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1022 we know exactly what this specific section wants so we remove it
1023 and then allow the must_have field to add it back in if necessary.
1024 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1025 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1026 by ld --enable-auto-import (if auto-import is actually needed),
1027 by ld --omagic, or by obcopy --writable-text. */
1029 for (p
= known_sections
; p
->section_name
; p
++)
1030 if (strcmp (scnhdr_int
->s_name
, p
->section_name
) == 0)
1032 if (strcmp (scnhdr_int
->s_name
, ".text")
1033 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1034 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1035 scnhdr_int
->s_flags
|= p
->must_have
;
1039 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1042 if (coff_data (abfd
)->link_info
1043 && ! coff_data (abfd
)->link_info
->relocatable
1044 && ! coff_data (abfd
)->link_info
->shared
1045 && strcmp (scnhdr_int
->s_name
, ".text") == 0)
1047 /* By inference from looking at MS output, the 32 bit field
1048 which is the combination of the number_of_relocs and
1049 number_of_linenos is used for the line number count in
1050 executables. A 16-bit field won't do for cc1. The MS
1051 document says that the number of relocs is zero for
1052 executables, but the 17-th bit has been observed to be there.
1053 Overflow is not an issue: a 4G-line program will overflow a
1054 bunch of other fields long before this! */
1055 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1056 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1060 if (scnhdr_int
->s_nlnno
<= 0xffff)
1061 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1064 (*_bfd_error_handler
) (_("%s: line number overflow: 0x%lx > 0xffff"),
1065 bfd_get_filename (abfd
),
1066 scnhdr_int
->s_nlnno
);
1067 bfd_set_error (bfd_error_file_truncated
);
1068 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1072 /* Although we could encode 0xffff relocs here, we do not, to be
1073 consistent with other parts of bfd. Also it lets us warn, as
1074 we should never see 0xffff here w/o having the overflow flag
1076 if (scnhdr_int
->s_nreloc
< 0xffff)
1077 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1080 /* PE can deal with large #s of relocs, but not here. */
1081 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1082 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1083 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1090 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1092 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1093 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1095 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1096 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1097 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1098 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1099 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1100 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1101 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1102 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1106 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1108 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1109 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1111 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1112 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1113 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1114 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1115 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1116 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1117 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1118 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1120 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1123 static CODEVIEW_INFO
*
1124 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1128 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1131 if (bfd_bread (buffer
, 256, abfd
) < 4)
1134 /* Ensure null termination of filename. */
1137 cvinfo
->CVSignature
= H_GET_32(abfd
, buffer
);
1140 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1141 && (length
> sizeof (CV_INFO_PDB70
)))
1143 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1145 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1147 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1148 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1149 as 16 bytes in big-endian order. */
1150 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1151 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1152 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1153 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1155 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1156 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1160 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1161 && (length
> sizeof (CV_INFO_PDB20
)))
1163 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1164 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1165 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1166 cvinfo
->SignatureLength
= 4;
1167 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1176 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1178 unsigned int size
= sizeof (CV_INFO_PDB70
) + 1;
1179 CV_INFO_PDB70
*cvinfo70
;
1182 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1185 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1186 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1188 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1189 in little-endian order, followed by 8 single bytes. */
1190 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1191 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1192 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1193 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1195 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1196 cvinfo70
->PdbFileName
[0] = '\0';
1198 if (bfd_bwrite (buffer
, size
, abfd
) != size
)
1204 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1206 N_("Export Directory [.edata (or where ever we found it)]"),
1207 N_("Import Directory [parts of .idata]"),
1208 N_("Resource Directory [.rsrc]"),
1209 N_("Exception Directory [.pdata]"),
1210 N_("Security Directory"),
1211 N_("Base Relocation Directory [.reloc]"),
1212 N_("Debug Directory"),
1213 N_("Description Directory"),
1214 N_("Special Directory"),
1215 N_("Thread Storage Directory [.tls]"),
1216 N_("Load Configuration Directory"),
1217 N_("Bound Import Directory"),
1218 N_("Import Address Table Directory"),
1219 N_("Delay Import Directory"),
1220 N_("CLR Runtime Header"),
1224 #ifdef POWERPC_LE_PE
1225 /* The code for the PPC really falls in the "architecture dependent"
1226 category. However, it's not clear that anyone will ever care, so
1227 we're ignoring the issue for now; if/when PPC matters, some of this
1228 may need to go into peicode.h, or arguments passed to enable the
1229 PPC- specific code. */
1233 pe_print_idata (bfd
* abfd
, void * vfile
)
1235 FILE *file
= (FILE *) vfile
;
1240 #ifdef POWERPC_LE_PE
1241 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1244 bfd_size_type datasize
= 0;
1245 bfd_size_type dataoff
;
1249 pe_data_type
*pe
= pe_data (abfd
);
1250 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1254 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1256 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1258 /* Maybe the extra header isn't there. Look for the section. */
1259 section
= bfd_get_section_by_name (abfd
, ".idata");
1260 if (section
== NULL
)
1263 addr
= section
->vma
;
1264 datasize
= section
->size
;
1270 addr
+= extra
->ImageBase
;
1271 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1273 datasize
= section
->size
;
1274 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1278 if (section
== NULL
)
1281 _("\nThere is an import table, but the section containing it could not be found\n"));
1284 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1287 _("\nThere is an import table in %s, but that section has no contents\n"),
1293 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1294 section
->name
, (unsigned long) addr
);
1296 dataoff
= addr
- section
->vma
;
1298 #ifdef POWERPC_LE_PE
1299 if (rel_section
!= 0 && rel_section
->size
!= 0)
1301 /* The toc address can be found by taking the starting address,
1302 which on the PPC locates a function descriptor. The
1303 descriptor consists of the function code starting address
1304 followed by the address of the toc. The starting address we
1305 get from the bfd, and the descriptor is supposed to be in the
1306 .reldata section. */
1308 bfd_vma loadable_toc_address
;
1309 bfd_vma toc_address
;
1310 bfd_vma start_address
;
1314 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1321 offset
= abfd
->start_address
- rel_section
->vma
;
1323 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1330 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1331 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1332 toc_address
= loadable_toc_address
- 32768;
1335 _("\nFunction descriptor located at the start address: %04lx\n"),
1336 (unsigned long int) (abfd
->start_address
));
1338 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1339 start_address
, loadable_toc_address
, toc_address
);
1346 _("\nNo reldata section! Function descriptor not decoded.\n"));
1351 _("\nThe Import Tables (interpreted %s section contents)\n"),
1355 vma: Hint Time Forward DLL First\n\
1356 Table Stamp Chain Name Thunk\n"));
1358 /* Read the whole section. Some of the fields might be before dataoff. */
1359 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1366 adj
= section
->vma
- extra
->ImageBase
;
1368 /* Print all image import descriptors. */
1369 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1373 bfd_vma forward_chain
;
1375 bfd_vma first_thunk
;
1380 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1381 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1382 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1383 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1384 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1385 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1386 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1388 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1389 (unsigned long) hint_addr
,
1390 (unsigned long) time_stamp
,
1391 (unsigned long) forward_chain
,
1392 (unsigned long) dll_name
,
1393 (unsigned long) first_thunk
);
1395 if (hint_addr
== 0 && first_thunk
== 0)
1398 if (dll_name
- adj
>= section
->size
)
1401 dll
= (char *) data
+ dll_name
- adj
;
1402 /* PR 17512 file: 078-12277-0.004. */
1403 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1404 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1409 asection
*ft_section
;
1411 bfd_size_type ft_datasize
;
1415 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1417 idx
= hint_addr
- adj
;
1419 ft_addr
= first_thunk
+ extra
->ImageBase
;
1420 ft_idx
= first_thunk
- adj
;
1421 ft_data
= data
+ ft_idx
;
1422 ft_datasize
= datasize
- ft_idx
;
1425 if (first_thunk
!= hint_addr
)
1427 /* Find the section which contains the first thunk. */
1428 for (ft_section
= abfd
->sections
;
1430 ft_section
= ft_section
->next
)
1432 if (ft_addr
>= ft_section
->vma
1433 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1437 if (ft_section
== NULL
)
1440 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1444 /* Now check to see if this section is the same as our current
1445 section. If it is not then we will have to load its data in. */
1446 if (ft_section
!= section
)
1448 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1449 ft_datasize
= ft_section
->size
- ft_idx
;
1450 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1451 if (ft_data
== NULL
)
1454 /* Read ft_datasize bytes starting at offset ft_idx. */
1455 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1456 (bfd_vma
) ft_idx
, ft_datasize
))
1465 /* Print HintName vector entries. */
1466 #ifdef COFF_WITH_pex64
1467 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1469 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1470 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1472 if (!member
&& !member_high
)
1475 if (HighBitSet (member_high
))
1476 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1477 member_high
, member
,
1478 WithoutHighBit (member_high
), member
);
1479 /* PR binutils/17512: Handle corrupt PE data. */
1480 else if ((bfd_vma
) member
- adj
+ 2 >= datasize
)
1481 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1487 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1488 member_name
= (char *) data
+ member
- adj
+ 2;
1489 fprintf (file
, "\t%04lx\t %4d %s",member
, ordinal
, member_name
);
1492 /* If the time stamp is not zero, the import address
1493 table holds actual addresses. */
1496 && first_thunk
!= hint_addr
1497 && j
+ 4 <= ft_datasize
)
1498 fprintf (file
, "\t%04lx",
1499 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1500 fprintf (file
, "\n");
1503 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1505 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1507 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1511 if (HighBitSet (member
))
1512 fprintf (file
, "\t%04lx\t %4lu <none>",
1513 member
, WithoutHighBit (member
));
1514 /* PR binutils/17512: Handle corrupt PE data. */
1515 else if ((bfd_vma
) member
- adj
+ 2 >= datasize
)
1516 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1522 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1523 member_name
= (char *) data
+ member
- adj
+ 2;
1524 fprintf (file
, "\t%04lx\t %4d %s",
1525 member
, ordinal
, member_name
);
1528 /* If the time stamp is not zero, the import address
1529 table holds actual addresses. */
1532 && first_thunk
!= hint_addr
1533 && j
+ 4 <= ft_datasize
)
1534 fprintf (file
, "\t%04lx",
1535 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1537 fprintf (file
, "\n");
1544 fprintf (file
, "\n");
1553 pe_print_edata (bfd
* abfd
, void * vfile
)
1555 FILE *file
= (FILE *) vfile
;
1558 bfd_size_type datasize
= 0;
1559 bfd_size_type dataoff
;
1564 long export_flags
; /* Reserved - should be zero. */
1568 bfd_vma name
; /* RVA - relative to image base. */
1569 long base
; /* Ordinal base. */
1570 unsigned long num_functions
;/* Number in the export address table. */
1571 unsigned long num_names
; /* Number in the name pointer table. */
1572 bfd_vma eat_addr
; /* RVA to the export address table. */
1573 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1574 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1577 pe_data_type
*pe
= pe_data (abfd
);
1578 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1582 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1584 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1586 /* Maybe the extra header isn't there. Look for the section. */
1587 section
= bfd_get_section_by_name (abfd
, ".edata");
1588 if (section
== NULL
)
1591 addr
= section
->vma
;
1593 datasize
= section
->size
;
1599 addr
+= extra
->ImageBase
;
1601 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1602 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1605 if (section
== NULL
)
1608 _("\nThere is an export table, but the section containing it could not be found\n"));
1611 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1614 _("\nThere is an export table in %s, but that section has no contents\n"),
1619 dataoff
= addr
- section
->vma
;
1620 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1621 if (datasize
> section
->size
- dataoff
)
1624 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1630 /* PR 17512: Handle corrupt PE binaries. */
1634 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1635 section
->name
, (int) datasize
);
1639 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1640 section
->name
, (unsigned long) addr
);
1642 data
= (bfd_byte
*) bfd_malloc (datasize
);
1646 if (! bfd_get_section_contents (abfd
, section
, data
,
1647 (file_ptr
) dataoff
, datasize
))
1650 /* Go get Export Directory Table. */
1651 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1652 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1653 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1654 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1655 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1656 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1657 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1658 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1659 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1660 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1661 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1663 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1665 /* Dump the EDT first. */
1667 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1671 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1674 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1677 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1680 _("Name \t\t\t\t"));
1681 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1683 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1684 fprintf (file
, " %s\n", data
+ edt
.name
- adj
);
1686 fprintf (file
, "(outside .edata section)\n");
1689 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1695 _("\tExport Address Table \t\t%08lx\n"),
1699 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1702 _("Table Addresses\n"));
1705 _("\tExport Address Table \t\t"));
1706 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1707 fprintf (file
, "\n");
1710 _("\tName Pointer Table \t\t"));
1711 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1712 fprintf (file
, "\n");
1715 _("\tOrdinal Table \t\t\t"));
1716 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1717 fprintf (file
, "\n");
1719 /* The next table to find is the Export Address Table. It's basically
1720 a list of pointers that either locate a function in this dll, or
1721 forward the call to another dll. Something like:
1726 } export_address_table_entry; */
1729 _("\nExport Address Table -- Ordinal Base %ld\n"),
1732 /* PR 17512: Handle corrupt PE binaries. */
1733 if (edt
.eat_addr
+ (edt
.num_functions
* 4) - adj
>= datasize
1734 /* PR 17512 file: 140-165018-0.004. */
1735 || data
+ edt
.eat_addr
- adj
< data
)
1736 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1737 (long) edt
.eat_addr
,
1738 (long) edt
.num_functions
);
1739 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1741 bfd_vma eat_member
= bfd_get_32 (abfd
,
1742 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1743 if (eat_member
== 0)
1746 if (eat_member
- adj
<= datasize
)
1748 /* This rva is to a name (forwarding function) in our section. */
1749 /* Should locate a function descriptor. */
1751 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1753 (long) (i
+ edt
.base
),
1754 (unsigned long) eat_member
,
1756 (int)(datasize
- (eat_member
- adj
)),
1757 data
+ eat_member
- adj
);
1761 /* Should locate a function descriptor in the reldata section. */
1763 "\t[%4ld] +base[%4ld] %04lx %s\n",
1765 (long) (i
+ edt
.base
),
1766 (unsigned long) eat_member
,
1771 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1772 /* Dump them in parallel for clarity. */
1774 _("\n[Ordinal/Name Pointer] Table\n"));
1776 /* PR 17512: Handle corrupt PE binaries. */
1777 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1778 || (data
+ edt
.npt_addr
- adj
) < data
)
1779 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1780 (long) edt
.npt_addr
,
1781 (long) edt
.num_names
);
1782 /* PR 17512: file: 140-147171-0.004. */
1783 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1784 || data
+ edt
.ot_addr
- adj
< data
)
1785 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1787 (long) edt
.num_names
);
1788 else for (i
= 0; i
< edt
.num_names
; ++i
)
1793 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1794 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1796 if ((name_ptr
- adj
) >= datasize
)
1798 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1799 (long) ord
, (long) name_ptr
);
1803 char * name
= (char *) data
+ name_ptr
- adj
;
1805 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1806 (int)((char *)(data
+ datasize
) - name
), name
);
1815 /* This really is architecture dependent. On IA-64, a .pdata entry
1816 consists of three dwords containing relative virtual addresses that
1817 specify the start and end address of the code range the entry
1818 covers and the address of the corresponding unwind info data.
1820 On ARM and SH-4, a compressed PDATA structure is used :
1821 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1822 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1823 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1825 This is the version for uncompressed data. */
1828 pe_print_pdata (bfd
* abfd
, void * vfile
)
1830 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1831 # define PDATA_ROW_SIZE (3 * 8)
1833 # define PDATA_ROW_SIZE (5 * 4)
1835 FILE *file
= (FILE *) vfile
;
1837 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1838 bfd_size_type datasize
= 0;
1840 bfd_size_type start
, stop
;
1841 int onaline
= PDATA_ROW_SIZE
;
1844 || coff_section_data (abfd
, section
) == NULL
1845 || pei_section_data (abfd
, section
) == NULL
)
1848 stop
= pei_section_data (abfd
, section
)->virt_size
;
1849 if ((stop
% onaline
) != 0)
1851 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1852 (long) stop
, onaline
);
1855 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1856 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1858 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1861 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1862 \t\tAddress Address Handler Data Address Mask\n"));
1865 datasize
= section
->size
;
1869 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1878 for (i
= start
; i
< stop
; i
+= onaline
)
1884 bfd_vma prolog_end_addr
;
1885 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1889 if (i
+ PDATA_ROW_SIZE
> stop
)
1892 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1893 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1894 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1895 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1896 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1898 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1899 && eh_data
== 0 && prolog_end_addr
== 0)
1900 /* We are probably into the padding of the section now. */
1903 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1904 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1906 eh_handler
&= ~(bfd_vma
) 0x3;
1907 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1910 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1911 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1912 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1913 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1914 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1916 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1917 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1918 fprintf (file
, " %x", em_data
);
1921 #ifdef POWERPC_LE_PE
1922 if (eh_handler
== 0 && eh_data
!= 0)
1924 /* Special bits here, although the meaning may be a little
1925 mysterious. The only one I know for sure is 0x03
1928 0x01 Register Save Millicode
1929 0x02 Register Restore Millicode
1930 0x03 Glue Code Sequence. */
1934 fprintf (file
, _(" Register save millicode"));
1937 fprintf (file
, _(" Register restore millicode"));
1940 fprintf (file
, _(" Glue code sequence"));
1947 fprintf (file
, "\n");
1953 #undef PDATA_ROW_SIZE
1956 typedef struct sym_cache
1963 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1965 asymbol
** sy
= NULL
;
1968 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1974 storage
= bfd_get_symtab_upper_bound (abfd
);
1978 sy
= (asymbol
**) bfd_malloc (storage
);
1980 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1981 if (psc
->symcount
< 0)
1987 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1992 psc
->syms
= slurp_symtab (abfd
, psc
);
1994 for (i
= 0; i
< psc
->symcount
; i
++)
1996 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1997 return psc
->syms
[i
]->name
;
2004 cleanup_syms (sym_cache
*psc
)
2011 /* This is the version for "compressed" pdata. */
2014 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
2016 # define PDATA_ROW_SIZE (2 * 4)
2017 FILE *file
= (FILE *) vfile
;
2018 bfd_byte
*data
= NULL
;
2019 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
2020 bfd_size_type datasize
= 0;
2022 bfd_size_type start
, stop
;
2023 int onaline
= PDATA_ROW_SIZE
;
2024 struct sym_cache cache
= {0, 0} ;
2027 || coff_section_data (abfd
, section
) == NULL
2028 || pei_section_data (abfd
, section
) == NULL
)
2031 stop
= pei_section_data (abfd
, section
)->virt_size
;
2032 if ((stop
% onaline
) != 0)
2034 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2035 (long) stop
, onaline
);
2038 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2041 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2042 \t\tAddress Length Length 32b exc Handler Data\n"));
2044 datasize
= section
->size
;
2048 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2057 for (i
= start
; i
< stop
; i
+= onaline
)
2061 bfd_vma prolog_length
, function_length
;
2062 int flag32bit
, exception_flag
;
2065 if (i
+ PDATA_ROW_SIZE
> stop
)
2068 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2069 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2071 if (begin_addr
== 0 && other_data
== 0)
2072 /* We are probably into the padding of the section now. */
2075 prolog_length
= (other_data
& 0x000000FF);
2076 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2077 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2078 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2081 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2082 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2083 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2084 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2085 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2087 /* Get the exception handler's address and the data passed from the
2088 .text section. This is really the data that belongs with the .pdata
2089 but got "compressed" out for the ARM and SH4 architectures. */
2090 tsection
= bfd_get_section_by_name (abfd
, ".text");
2091 if (tsection
&& coff_section_data (abfd
, tsection
)
2092 && pei_section_data (abfd
, tsection
))
2094 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2097 tdata
= (bfd_byte
*) bfd_malloc (8);
2100 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2102 bfd_vma eh
, eh_data
;
2104 eh
= bfd_get_32 (abfd
, tdata
);
2105 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2106 fprintf (file
, "%08x ", (unsigned int) eh
);
2107 fprintf (file
, "%08x", (unsigned int) eh_data
);
2110 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2113 fprintf (file
, " (%s) ", s
);
2120 fprintf (file
, "\n");
2125 cleanup_syms (& cache
);
2128 #undef PDATA_ROW_SIZE
2132 #define IMAGE_REL_BASED_HIGHADJ 4
2133 static const char * const tbl
[] =
2147 "UNKNOWN", /* MUST be last. */
2151 pe_print_reloc (bfd
* abfd
, void * vfile
)
2153 FILE *file
= (FILE *) vfile
;
2155 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2158 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2162 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2164 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2172 end
= data
+ section
->size
;
2173 while (p
+ 8 <= end
)
2176 bfd_vma virtual_address
;
2178 bfd_byte
*chunk_end
;
2180 /* The .reloc section is a sequence of blocks, with a header consisting
2181 of two 32 bit quantities, followed by a number of 16 bit entries. */
2182 virtual_address
= bfd_get_32 (abfd
, p
);
2183 size
= bfd_get_32 (abfd
, p
+ 4);
2185 number
= (size
- 8) / 2;
2191 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2192 (unsigned long) virtual_address
, size
, (unsigned long) size
, number
);
2194 chunk_end
= p
+ size
;
2195 if (chunk_end
> end
)
2198 while (p
+ 2 <= chunk_end
)
2200 unsigned short e
= bfd_get_16 (abfd
, p
);
2201 unsigned int t
= (e
& 0xF000) >> 12;
2202 int off
= e
& 0x0FFF;
2204 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2205 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2208 _("\treloc %4d offset %4x [%4lx] %s"),
2209 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2214 /* HIGHADJ takes an argument, - the next record *is* the
2215 low 16 bits of addend. */
2216 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2218 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2223 fprintf (file
, "\n");
2232 /* A data structure describing the regions of a .rsrc section.
2233 Some fields are filled in as the section is parsed. */
2235 typedef struct rsrc_regions
2237 bfd_byte
* section_start
;
2238 bfd_byte
* section_end
;
2239 bfd_byte
* strings_start
;
2240 bfd_byte
* resource_start
;
2244 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2245 rsrc_regions
*, bfd_vma
);
2247 /* Print the resource entry at DATA, with the text indented by INDENT.
2248 Recusively calls rsrc_print_resource_directory to print the contents
2249 of directory entries.
2250 Returns the address of the end of the data associated with the entry
2251 or section_end + 1 upon failure. */
2254 rsrc_print_resource_entries (FILE * file
,
2256 unsigned int indent
,
2257 bfd_boolean is_name
,
2259 rsrc_regions
* regions
,
2262 unsigned long entry
, addr
, size
;
2264 if (data
+ 8 >= regions
->section_end
)
2265 return regions
->section_end
+ 1;
2267 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2269 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2274 /* Note - the documentation says that this field is an RVA value
2275 but windres appears to produce a section relative offset with
2276 the top bit set. Support both styles for now. */
2277 if (HighBitSet (entry
))
2278 name
= regions
->section_start
+ WithoutHighBit (entry
);
2280 name
= regions
->section_start
+ entry
- rva_bias
;
2282 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2286 if (regions
->strings_start
== NULL
)
2287 regions
->strings_start
= name
;
2289 len
= bfd_get_16 (abfd
, name
);
2291 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2293 if (name
+ 2 + len
* 2 < regions
->section_end
)
2295 /* This strange loop is to cope with multibyte characters. */
2302 /* Avoid printing control characters. */
2303 if (c
> 0 && c
< 32)
2304 fprintf (file
, "^%c", c
+ 64);
2306 fprintf (file
, "%.1s", name
);
2311 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2312 /* PR binutils/17512: Do not try to continue decoding a
2313 corrupted resource section. It is likely to end up with
2314 reams of extraneous output. FIXME: We could probably
2315 continue if we disable the printing of strings... */
2316 return regions
->section_end
+ 1;
2321 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2322 return regions
->section_end
+ 1;
2326 fprintf (file
, _("ID: %#08lx"), entry
);
2328 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2329 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2331 if (HighBitSet (entry
))
2333 data
= regions
->section_start
+ WithoutHighBit (entry
);
2334 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2335 return regions
->section_end
+ 1;
2337 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2338 in the resource table. We need some way to detect this. */
2339 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2343 if (regions
->section_start
+ entry
+ 16 >= regions
->section_end
)
2344 return regions
->section_end
+ 1;
2346 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2349 addr
= (long) bfd_get_32 (abfd
, regions
->section_start
+ entry
),
2350 size
= (long) bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 4),
2351 (int) bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 8));
2353 /* Check that the reserved entry is 0. */
2354 if (bfd_get_32 (abfd
, regions
->section_start
+ entry
+ 12) != 0
2355 /* And that the data address/size is valid too. */
2356 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2357 return regions
->section_end
+ 1;
2359 if (regions
->resource_start
== NULL
)
2360 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2362 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2365 #define max(a,b) ((a) > (b) ? (a) : (b))
2366 #define min(a,b) ((a) < (b) ? (a) : (b))
2369 rsrc_print_resource_directory (FILE * file
,
2371 unsigned int indent
,
2373 rsrc_regions
* regions
,
2376 unsigned int num_names
, num_ids
;
2377 bfd_byte
* highest_data
= data
;
2379 if (data
+ 16 >= regions
->section_end
)
2380 return regions
->section_end
+ 1;
2382 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2385 case 0: fprintf (file
, "Type"); break;
2386 case 2: fprintf (file
, "Name"); break;
2387 case 4: fprintf (file
, "Language"); break;
2389 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2390 /* FIXME: For now we end the printing here. If in the
2391 future more directory types are added to the RSRC spec
2392 then we will need to change this. */
2393 return regions
->section_end
+ 1;
2396 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2397 (int) bfd_get_32 (abfd
, data
),
2398 (long) bfd_get_32 (abfd
, data
+ 4),
2399 (int) bfd_get_16 (abfd
, data
+ 8),
2400 (int) bfd_get_16 (abfd
, data
+ 10),
2401 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2402 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2405 while (num_names
--)
2407 bfd_byte
* entry_end
;
2409 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2410 data
, regions
, rva_bias
);
2412 highest_data
= max (highest_data
, entry_end
);
2413 if (entry_end
>= regions
->section_end
)
2419 bfd_byte
* entry_end
;
2421 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2422 data
, regions
, rva_bias
);
2424 highest_data
= max (highest_data
, entry_end
);
2425 if (entry_end
>= regions
->section_end
)
2429 return max (highest_data
, data
);
2432 /* Display the contents of a .rsrc section. We do not try to
2433 reproduce the resources, windres does that. Instead we dump
2434 the tables in a human readable format. */
2437 rsrc_print_section (bfd
* abfd
, void * vfile
)
2441 FILE * file
= (FILE *) vfile
;
2442 bfd_size_type datasize
;
2445 rsrc_regions regions
;
2447 pe
= pe_data (abfd
);
2451 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2452 if (section
== NULL
)
2454 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2457 datasize
= section
->size
;
2461 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2463 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2470 regions
.section_start
= data
;
2471 regions
.section_end
= data
+ datasize
;
2472 regions
.strings_start
= NULL
;
2473 regions
.resource_start
= NULL
;
2476 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2478 while (data
< regions
.section_end
)
2480 bfd_byte
* p
= data
;
2482 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2484 if (data
== regions
.section_end
+ 1)
2485 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2488 /* Align data before continuing. */
2489 int align
= (1 << section
->alignment_power
) - 1;
2491 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2492 rva_bias
+= data
- p
;
2494 /* For reasons that are unclear .rsrc sections are sometimes created
2495 aligned to a 1^3 boundary even when their alignment is set at
2496 1^2. Catch that case here before we issue a spurious warning
2498 if (data
== (regions
.section_end
- 4))
2499 data
= regions
.section_end
;
2500 else if (data
< regions
.section_end
)
2502 /* If the extra data is all zeros then do not complain.
2503 This is just padding so that the section meets the
2504 page size requirements. */
2505 while (data
++ < regions
.section_end
)
2508 if (data
< regions
.section_end
)
2509 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2514 if (regions
.strings_start
!= NULL
)
2515 fprintf (file
, " String table starts at offset: %#03x\n",
2516 (int) (regions
.strings_start
- regions
.section_start
));
2517 if (regions
.resource_start
!= NULL
)
2518 fprintf (file
, " Resources start at offset: %#03x\n",
2519 (int) (regions
.resource_start
- regions
.section_start
));
2521 free (regions
.section_start
);
2525 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2527 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2544 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2546 FILE *file
= (FILE *) vfile
;
2547 pe_data_type
*pe
= pe_data (abfd
);
2548 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2551 bfd_size_type dataoff
;
2554 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2555 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2560 addr
+= extra
->ImageBase
;
2561 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2563 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2567 if (section
== NULL
)
2570 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2573 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2576 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2580 else if (section
->size
< size
)
2583 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2588 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2589 section
->name
, (unsigned long) addr
);
2591 dataoff
= addr
- section
->vma
;
2593 if (size
> (section
->size
- dataoff
))
2595 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2600 _("Type Size Rva Offset\n"));
2602 /* Read the whole section. */
2603 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2610 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2612 const char *type_name
;
2613 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2614 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2615 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2617 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2619 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2620 type_name
= debug_type_names
[0];
2622 type_name
= debug_type_names
[idd
.Type
];
2624 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2625 idd
.Type
, type_name
, idd
.SizeOfData
,
2626 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2628 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2630 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2631 char buffer
[256 + 1];
2632 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2634 /* The debug entry doesn't have to have to be in a section,
2635 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2636 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2637 idd
.SizeOfData
, cvinfo
))
2640 for (i
= 0; i
< cvinfo
->SignatureLength
; i
++)
2641 sprintf (&signature
[i
*2], "%02x", cvinfo
->Signature
[i
] & 0xff);
2643 fprintf (file
, "(format %c%c%c%c signature %s age %ld)\n",
2644 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2645 signature
, cvinfo
->Age
);
2649 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2651 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2656 /* Print out the program headers. */
2659 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2661 FILE *file
= (FILE *) vfile
;
2663 pe_data_type
*pe
= pe_data (abfd
);
2664 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2665 const char *subsystem_name
= NULL
;
2668 /* The MS dumpbin program reportedly ands with 0xff0f before
2669 printing the characteristics field. Not sure why. No reason to
2671 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2673 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2674 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2675 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2676 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2677 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2678 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2679 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2680 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2681 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2682 PF (IMAGE_FILE_SYSTEM
, "system file");
2683 PF (IMAGE_FILE_DLL
, "DLL");
2684 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2687 /* ctime implies '\n'. */
2689 time_t t
= pe
->coff
.timestamp
;
2690 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2693 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2694 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2696 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2697 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2699 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2700 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2705 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2708 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2711 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2718 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2720 fprintf (file
, "\t(%s)",name
);
2721 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2722 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2723 fprintf (file
, "SizeOfCode\t\t%08lx\n", (unsigned long) i
->SizeOfCode
);
2724 fprintf (file
, "SizeOfInitializedData\t%08lx\n",
2725 (unsigned long) i
->SizeOfInitializedData
);
2726 fprintf (file
, "SizeOfUninitializedData\t%08lx\n",
2727 (unsigned long) i
->SizeOfUninitializedData
);
2728 fprintf (file
, "AddressOfEntryPoint\t");
2729 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2730 fprintf (file
, "\nBaseOfCode\t\t");
2731 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2732 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2733 /* PE32+ does not have BaseOfData member! */
2734 fprintf (file
, "\nBaseOfData\t\t");
2735 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2738 fprintf (file
, "\nImageBase\t\t");
2739 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2740 fprintf (file
, "\nSectionAlignment\t");
2741 bfd_fprintf_vma (abfd
, file
, i
->SectionAlignment
);
2742 fprintf (file
, "\nFileAlignment\t\t");
2743 bfd_fprintf_vma (abfd
, file
, i
->FileAlignment
);
2744 fprintf (file
, "\nMajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2745 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2746 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2747 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2748 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2749 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2750 fprintf (file
, "Win32Version\t\t%08lx\n", (unsigned long) i
->Reserved1
);
2751 fprintf (file
, "SizeOfImage\t\t%08lx\n", (unsigned long) i
->SizeOfImage
);
2752 fprintf (file
, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i
->SizeOfHeaders
);
2753 fprintf (file
, "CheckSum\t\t%08lx\n", (unsigned long) i
->CheckSum
);
2755 switch (i
->Subsystem
)
2757 case IMAGE_SUBSYSTEM_UNKNOWN
:
2758 subsystem_name
= "unspecified";
2760 case IMAGE_SUBSYSTEM_NATIVE
:
2761 subsystem_name
= "NT native";
2763 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2764 subsystem_name
= "Windows GUI";
2766 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2767 subsystem_name
= "Windows CUI";
2769 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2770 subsystem_name
= "POSIX CUI";
2772 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2773 subsystem_name
= "Wince CUI";
2775 // These are from UEFI Platform Initialization Specification 1.1.
2776 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2777 subsystem_name
= "EFI application";
2779 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2780 subsystem_name
= "EFI boot service driver";
2782 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2783 subsystem_name
= "EFI runtime driver";
2785 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2786 subsystem_name
= "SAL runtime driver";
2788 // This is from revision 8.0 of the MS PE/COFF spec
2789 case IMAGE_SUBSYSTEM_XBOX
:
2790 subsystem_name
= "XBOX";
2792 // Added default case for clarity - subsystem_name is NULL anyway.
2794 subsystem_name
= NULL
;
2797 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2799 fprintf (file
, "\t(%s)", subsystem_name
);
2800 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2801 fprintf (file
, "SizeOfStackReserve\t");
2802 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2803 fprintf (file
, "\nSizeOfStackCommit\t");
2804 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2805 fprintf (file
, "\nSizeOfHeapReserve\t");
2806 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2807 fprintf (file
, "\nSizeOfHeapCommit\t");
2808 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2809 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2810 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2811 (unsigned long) i
->NumberOfRvaAndSizes
);
2813 fprintf (file
, "\nThe Data Directory\n");
2814 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2816 fprintf (file
, "Entry %1x ", j
);
2817 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2818 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2819 fprintf (file
, "%s\n", dir_names
[j
]);
2822 pe_print_idata (abfd
, vfile
);
2823 pe_print_edata (abfd
, vfile
);
2824 if (bfd_coff_have_print_pdata (abfd
))
2825 bfd_coff_print_pdata (abfd
, vfile
);
2827 pe_print_pdata (abfd
, vfile
);
2828 pe_print_reloc (abfd
, vfile
);
2829 pe_print_debugdata (abfd
, file
);
2831 rsrc_print_section (abfd
, vfile
);
2837 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2839 bfd_vma addr
= * (bfd_vma
*) obj
;
2840 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2844 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2846 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2849 /* Copy any private info we understand from the input bfd
2850 to the output bfd. */
2853 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2855 pe_data_type
*ipe
, *ope
;
2857 /* One day we may try to grok other private data. */
2858 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2859 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2862 ipe
= pe_data (ibfd
);
2863 ope
= pe_data (obfd
);
2865 /* pe_opthdr is copied in copy_object. */
2866 ope
->dll
= ipe
->dll
;
2868 /* Don't copy input subsystem if output is different from input. */
2869 if (obfd
->xvec
!= ibfd
->xvec
)
2870 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2872 /* For strip: if we removed .reloc, we'll make a real mess of things
2873 if we don't remove this entry as well. */
2874 if (! pe_data (obfd
)->has_reloc_section
)
2876 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2877 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2880 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2881 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2883 if (! pe_data (ibfd
)->has_reloc_section
2884 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2885 pe_data (obfd
)->dont_strip_reloc
= 1;
2887 /* The file offsets contained in the debug directory need rewriting. */
2888 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2890 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2891 + ope
->pe_opthdr
.ImageBase
;
2892 asection
*section
= find_section_by_vma (obfd
, addr
);
2895 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
2898 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
2899 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
2901 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
2902 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2904 asection
*ddsection
;
2905 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
2906 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2908 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
2910 if (idd
.AddressOfRawData
== 0)
2911 continue; /* RVA 0 means only offset is valid, not handled yet. */
2913 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
2915 continue; /* Not in a section! */
2917 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
2918 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
2920 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
2923 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
2924 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2931 /* Copy private section data. */
2934 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
2939 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
2940 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
2943 if (coff_section_data (ibfd
, isec
) != NULL
2944 && pei_section_data (ibfd
, isec
) != NULL
)
2946 if (coff_section_data (obfd
, osec
) == NULL
)
2948 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
2949 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
2950 if (osec
->used_by_bfd
== NULL
)
2954 if (pei_section_data (obfd
, osec
) == NULL
)
2956 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
2957 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
2958 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
2962 pei_section_data (obfd
, osec
)->virt_size
=
2963 pei_section_data (ibfd
, isec
)->virt_size
;
2964 pei_section_data (obfd
, osec
)->pe_flags
=
2965 pei_section_data (ibfd
, isec
)->pe_flags
;
2972 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
2974 coff_get_symbol_info (abfd
, symbol
, ret
);
2977 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2979 sort_x64_pdata (const void *l
, const void *r
)
2981 const char *lp
= (const char *) l
;
2982 const char *rp
= (const char *) r
;
2984 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
2986 return (vl
< vr
? -1 : 1);
2987 /* We compare just begin address. */
2992 /* Functions to process a .rsrc section. */
2994 static unsigned int sizeof_leaves
;
2995 static unsigned int sizeof_strings
;
2996 static unsigned int sizeof_tables_and_entries
;
2999 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3002 rsrc_count_entries (bfd
* abfd
,
3003 bfd_boolean is_name
,
3004 bfd_byte
* datastart
,
3009 unsigned long entry
, addr
, size
;
3011 if (data
+ 8 >= dataend
)
3018 entry
= (long) bfd_get_32 (abfd
, data
);
3020 if (HighBitSet (entry
))
3021 name
= datastart
+ WithoutHighBit (entry
);
3023 name
= datastart
+ entry
- rva_bias
;
3025 if (name
+ 2 >= dataend
|| name
< datastart
)
3028 unsigned int len
= bfd_get_16 (abfd
, name
);
3029 if (len
== 0 || len
> 256)
3033 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3035 if (HighBitSet (entry
))
3037 data
= datastart
+ WithoutHighBit (entry
);
3039 if (data
<= datastart
|| data
>= dataend
)
3042 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3045 if (datastart
+ entry
+ 16 >= dataend
)
3048 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3049 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3051 return datastart
+ addr
- rva_bias
+ size
;
3055 rsrc_count_directory (bfd
* abfd
,
3056 bfd_byte
* datastart
,
3061 unsigned int num_entries
, num_ids
;
3062 bfd_byte
* highest_data
= data
;
3064 if (data
+ 16 >= dataend
)
3067 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3068 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3070 num_entries
+= num_ids
;
3074 while (num_entries
--)
3076 bfd_byte
* entry_end
;
3078 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3079 datastart
, data
, dataend
, rva_bias
);
3081 highest_data
= max (highest_data
, entry_end
);
3082 if (entry_end
>= dataend
)
3086 return max (highest_data
, data
);
3089 typedef struct rsrc_dir_chain
3091 unsigned int num_entries
;
3092 struct rsrc_entry
* first_entry
;
3093 struct rsrc_entry
* last_entry
;
3096 typedef struct rsrc_directory
3098 unsigned int characteristics
;
3103 rsrc_dir_chain names
;
3106 struct rsrc_entry
* entry
;
3109 typedef struct rsrc_string
3115 typedef struct rsrc_leaf
3118 unsigned int codepage
;
3122 typedef struct rsrc_entry
3124 bfd_boolean is_name
;
3128 struct rsrc_string name
;
3134 struct rsrc_directory
* directory
;
3135 struct rsrc_leaf
* leaf
;
3138 struct rsrc_entry
* next_entry
;
3139 struct rsrc_directory
* parent
;
3143 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3144 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3147 rsrc_parse_entry (bfd
* abfd
,
3148 bfd_boolean is_name
,
3150 bfd_byte
* datastart
,
3154 rsrc_directory
* parent
)
3156 unsigned long val
, addr
, size
;
3158 val
= bfd_get_32 (abfd
, data
);
3160 entry
->parent
= parent
;
3161 entry
->is_name
= is_name
;
3167 if (HighBitSet (val
))
3169 val
= WithoutHighBit (val
);
3171 address
= datastart
+ val
;
3175 address
= datastart
+ val
- rva_bias
;
3178 if (address
+ 3 > dataend
)
3181 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3182 entry
->name_id
.name
.string
= address
+ 2;
3185 entry
->name_id
.id
= val
;
3187 val
= bfd_get_32 (abfd
, data
+ 4);
3189 if (HighBitSet (val
))
3191 entry
->is_dir
= TRUE
;
3192 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3193 if (entry
->value
.directory
== NULL
)
3196 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3198 datastart
+ WithoutHighBit (val
),
3199 dataend
, rva_bias
, entry
);
3202 entry
->is_dir
= FALSE
;
3203 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3204 if (entry
->value
.leaf
== NULL
)
3207 addr
= bfd_get_32 (abfd
, datastart
+ val
);
3208 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, datastart
+ val
+ 4);
3209 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, datastart
+ val
+ 8);
3211 entry
->value
.leaf
->data
= bfd_malloc (size
);
3212 if (entry
->value
.leaf
->data
== NULL
)
3215 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3216 return datastart
+ (addr
- rva_bias
) + size
;
3220 rsrc_parse_entries (bfd
* abfd
,
3221 rsrc_dir_chain
* chain
,
3222 bfd_boolean is_name
,
3223 bfd_byte
* highest_data
,
3224 bfd_byte
* datastart
,
3228 rsrc_directory
* parent
)
3233 if (chain
->num_entries
== 0)
3235 chain
->first_entry
= chain
->last_entry
= NULL
;
3236 return highest_data
;
3239 entry
= bfd_malloc (sizeof * entry
);
3243 chain
->first_entry
= entry
;
3245 for (i
= chain
->num_entries
; i
--;)
3247 bfd_byte
* entry_end
;
3249 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3250 data
, dataend
, rva_bias
, parent
);
3252 highest_data
= max (entry_end
, highest_data
);
3253 if (entry_end
> dataend
)
3258 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3259 entry
= entry
->next_entry
;
3264 entry
->next_entry
= NULL
;
3267 chain
->last_entry
= entry
;
3269 return highest_data
;
3273 rsrc_parse_directory (bfd
* abfd
,
3274 rsrc_directory
* table
,
3275 bfd_byte
* datastart
,
3281 bfd_byte
* highest_data
= data
;
3286 table
->characteristics
= bfd_get_32 (abfd
, data
);
3287 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3288 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3289 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3290 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3291 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3292 table
->entry
= entry
;
3296 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
3297 datastart
, data
, dataend
, rva_bias
, table
);
3298 data
+= table
->names
.num_entries
* 8;
3300 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
3301 datastart
, data
, dataend
, rva_bias
, table
);
3302 data
+= table
->ids
.num_entries
* 8;
3304 return max (highest_data
, data
);
3307 typedef struct rsrc_write_data
3310 bfd_byte
* datastart
;
3311 bfd_byte
* next_table
;
3312 bfd_byte
* next_leaf
;
3313 bfd_byte
* next_string
;
3314 bfd_byte
* next_data
;
3319 rsrc_write_string (rsrc_write_data
* data
,
3320 rsrc_string
* string
)
3322 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3323 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3324 data
->next_string
+= (string
->len
+ 1) * 2;
3327 static inline unsigned int
3328 rsrc_compute_rva (rsrc_write_data
* data
,
3331 return (addr
- data
->datastart
) + data
->rva_bias
;
3335 rsrc_write_leaf (rsrc_write_data
* data
,
3338 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3340 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3341 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3342 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3343 data
->next_leaf
+= 16;
3345 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3346 /* An undocumented feature of Windows resources is that each unit
3347 of raw data is 8-byte aligned... */
3348 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3351 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3354 rsrc_write_entry (rsrc_write_data
* data
,
3360 bfd_put_32 (data
->abfd
,
3361 SetHighBit (data
->next_string
- data
->datastart
),
3363 rsrc_write_string (data
, & entry
->name_id
.name
);
3366 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3370 bfd_put_32 (data
->abfd
,
3371 SetHighBit (data
->next_table
- data
->datastart
),
3373 rsrc_write_directory (data
, entry
->value
.directory
);
3377 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3378 rsrc_write_leaf (data
, entry
->value
.leaf
);
3383 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3385 struct rsrc_entry
* entry
;
3390 sizeof_tables_and_entries
+= 16;
3392 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3394 sizeof_tables_and_entries
+= 8;
3396 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3399 rsrc_compute_region_sizes (entry
->value
.directory
);
3401 sizeof_leaves
+= 16;
3404 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3406 sizeof_tables_and_entries
+= 8;
3409 rsrc_compute_region_sizes (entry
->value
.directory
);
3411 sizeof_leaves
+= 16;
3416 rsrc_write_directory (rsrc_write_data
* data
,
3417 rsrc_directory
* dir
)
3421 bfd_byte
* next_entry
;
3424 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3425 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3426 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3427 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3428 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3429 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3431 /* Compute where the entries and the next table will be placed. */
3432 next_entry
= data
->next_table
+ 16;
3433 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3434 + (dir
->ids
.num_entries
* 8);
3435 nt
= data
->next_table
;
3437 /* Write the entries. */
3438 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3439 i
> 0 && entry
!= NULL
;
3440 i
--, entry
= entry
->next_entry
)
3442 BFD_ASSERT (entry
->is_name
);
3443 rsrc_write_entry (data
, next_entry
, entry
);
3446 BFD_ASSERT (i
== 0);
3447 BFD_ASSERT (entry
== NULL
);
3449 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3450 i
> 0 && entry
!= NULL
;
3451 i
--, entry
= entry
->next_entry
)
3453 BFD_ASSERT (! entry
->is_name
);
3454 rsrc_write_entry (data
, next_entry
, entry
);
3457 BFD_ASSERT (i
== 0);
3458 BFD_ASSERT (entry
== NULL
);
3459 BFD_ASSERT (nt
== next_entry
);
3462 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3463 /* Return the length (number of units) of the first character in S,
3464 putting its 'ucs4_t' representation in *PUC. */
3467 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
3469 unsigned short c
= * s
;
3471 if (c
< 0xd800 || c
>= 0xe000)
3481 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3483 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3489 /* Incomplete multibyte character. */
3495 /* Invalid multibyte character. */
3499 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3501 /* Perform a comparison of two entries. */
3503 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3512 return a
->name_id
.id
- b
->name_id
.id
;
3514 /* We have to perform a case insenstive, unicode string comparison... */
3515 astring
= a
->name_id
.name
.string
;
3516 alen
= a
->name_id
.name
.len
;
3517 bstring
= b
->name_id
.name
.string
;
3518 blen
= b
->name_id
.name
.len
;
3520 #if defined __CYGWIN__ || defined __MINGW32__
3521 /* Under Windows hosts (both Cygwin and Mingw types),
3522 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3523 function however goes by different names in the two environments... */
3527 #define rscpcmp wcsncasecmp
3530 #define rscpcmp wcsnicmp
3533 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3536 #elif defined HAVE_WCHAR_H
3540 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3545 /* Convert UTF-16 unicode characters into wchar_t characters so
3546 that we can then perform a case insensitive comparison. */
3547 int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3548 int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3552 res
= wcsncasecmp (& awc
, & bwc
, 1);
3558 /* Do the best we can - a case sensitive, untranslated comparison. */
3559 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3569 rsrc_print_name (char * buffer
, rsrc_string string
)
3572 bfd_byte
* name
= string
.string
;
3574 for (i
= string
.len
; i
--; name
+= 2)
3575 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3579 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3581 static char buffer
[256];
3582 bfd_boolean is_string
= FALSE
;
3586 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3587 && dir
->entry
->parent
->entry
!= NULL
)
3589 strcpy (buffer
, "type: ");
3590 if (dir
->entry
->parent
->entry
->is_name
)
3591 rsrc_print_name (buffer
+ strlen (buffer
),
3592 dir
->entry
->parent
->entry
->name_id
.name
);
3595 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3597 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3600 case 1: strcat (buffer
, " (CURSOR)"); break;
3601 case 2: strcat (buffer
, " (BITMAP)"); break;
3602 case 3: strcat (buffer
, " (ICON)"); break;
3603 case 4: strcat (buffer
, " (MENU)"); break;
3604 case 5: strcat (buffer
, " (DIALOG)"); break;
3605 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3606 case 7: strcat (buffer
, " (FONTDIR)"); break;
3607 case 8: strcat (buffer
, " (FONT)"); break;
3608 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3609 case 10: strcat (buffer
, " (RCDATA)"); break;
3610 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3611 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3612 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3613 case 16: strcat (buffer
, " (VERSION)"); break;
3614 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3615 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3616 case 20: strcat (buffer
, " (VXD)"); break;
3617 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3618 case 22: strcat (buffer
, " (ANIICON)"); break;
3619 case 23: strcat (buffer
, " (HTML)"); break;
3620 case 24: strcat (buffer
, " (MANIFEST)"); break;
3621 case 240: strcat (buffer
, " (DLGINIT)"); break;
3622 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3627 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3629 strcat (buffer
, " name: ");
3630 if (dir
->entry
->is_name
)
3631 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3634 unsigned int id
= dir
->entry
->name_id
.id
;
3636 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3639 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3640 (id
- 1) << 4, (id
<< 4) - 1);
3646 strcat (buffer
, " lang: ");
3649 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3651 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3657 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3658 their ID is stored in the NAME entry. The bottom four bits are used as
3659 an index into unicode string table that makes up the data of the leaf.
3660 So identical type-name-lang string resources may not actually be
3663 This function is called when we have detected two string resources with
3664 match top-28-bit IDs. We have to scan the string tables inside the leaves
3665 and discover if there are any real collisions. If there are then we report
3666 them and return FALSE. Otherwise we copy any strings from B into A and
3667 then return TRUE. */
3670 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3671 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3673 unsigned int copy_needed
= 0;
3677 bfd_byte
* new_data
;
3680 /* Step one: Find out what we have to do. */
3681 BFD_ASSERT (! a
->is_dir
);
3682 astring
= a
->value
.leaf
->data
;
3684 BFD_ASSERT (! b
->is_dir
);
3685 bstring
= b
->value
.leaf
->data
;
3687 for (i
= 0; i
< 16; i
++)
3689 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3690 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3694 copy_needed
+= blen
* 2;
3698 else if (alen
!= blen
)
3699 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3701 /* alen == blen != 0. We might have two identical strings. If so we
3702 can ignore the second one. There is no need for wchar_t vs UTF-16
3703 theatrics here - we are only interested in (case sensitive) equality. */
3704 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3707 astring
+= (alen
+ 1) * 2;
3708 bstring
+= (blen
+ 1) * 2;
3713 if (a
->parent
!= NULL
3714 && a
->parent
->entry
!= NULL
3715 && a
->parent
->entry
->is_name
== FALSE
)
3716 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3717 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3721 if (copy_needed
== 0)
3724 /* If we reach here then A and B must both have non-colliding strings.
3725 (We never get string resources with fully empty string tables).
3726 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3728 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3729 if (new_data
== NULL
)
3733 astring
= a
->value
.leaf
->data
;
3734 bstring
= b
->value
.leaf
->data
;
3736 for (i
= 0; i
< 16; i
++)
3738 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3739 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3743 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3744 nstring
+= (alen
+ 1) * 2;
3748 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3749 nstring
+= (blen
+ 1) * 2;
3757 astring
+= (alen
+ 1) * 2;
3758 bstring
+= (blen
+ 1) * 2;
3761 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3763 free (a
->value
.leaf
->data
);
3764 a
->value
.leaf
->data
= new_data
;
3765 a
->value
.leaf
->size
+= copy_needed
;
3770 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3772 /* Sort the entries in given part of the directory.
3773 We use an old fashioned bubble sort because we are dealing
3774 with lists and we want to handle matches specially. */
3777 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3778 bfd_boolean is_name
,
3779 rsrc_directory
* dir
)
3783 rsrc_entry
** points_to_entry
;
3784 bfd_boolean swapped
;
3786 if (chain
->num_entries
< 2)
3792 points_to_entry
= & chain
->first_entry
;
3793 entry
= * points_to_entry
;
3794 next
= entry
->next_entry
;
3798 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3802 entry
->next_entry
= next
->next_entry
;
3803 next
->next_entry
= entry
;
3804 * points_to_entry
= next
;
3805 points_to_entry
= & next
->next_entry
;
3806 next
= entry
->next_entry
;
3811 if (entry
->is_dir
&& next
->is_dir
)
3813 /* When we encounter identical directory entries we have to
3814 merge them together. The exception to this rule is for
3815 resource manifests - there can only be one of these,
3816 even if they differ in language. Zero-language manifests
3817 are assumed to be default manifests (provided by the
3818 Cygwin/MinGW build system) and these can be silently dropped,
3819 unless that would reduce the number of manifests to zero.
3820 There should only ever be one non-zero lang manifest -
3821 if there are more it is an error. A non-zero lang
3822 manifest takes precedence over a default manifest. */
3823 if (entry
->is_name
== FALSE
3824 && entry
->name_id
.id
== 1
3826 && dir
->entry
!= NULL
3827 && dir
->entry
->is_name
== FALSE
3828 && dir
->entry
->name_id
.id
== 0x18)
3830 if (next
->value
.directory
->names
.num_entries
== 0
3831 && next
->value
.directory
->ids
.num_entries
== 1
3832 && next
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3833 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3834 /* Fall through so that NEXT is dropped. */
3836 else if (entry
->value
.directory
->names
.num_entries
== 0
3837 && entry
->value
.directory
->ids
.num_entries
== 1
3838 && entry
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3839 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3841 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3842 entry
->next_entry
= next
->next_entry
;
3843 next
->next_entry
= entry
;
3844 * points_to_entry
= next
;
3845 points_to_entry
= & next
->next_entry
;
3846 next
= entry
->next_entry
;
3851 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3852 bfd_set_error (bfd_error_file_truncated
);
3856 /* Unhook NEXT from the chain. */
3857 /* FIXME: memory loss here. */
3858 entry
->next_entry
= next
->next_entry
;
3859 chain
->num_entries
--;
3860 if (chain
->num_entries
< 2)
3862 next
= next
->next_entry
;
3865 rsrc_merge (entry
, next
);
3867 else if (entry
->is_dir
!= next
->is_dir
)
3869 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3870 bfd_set_error (bfd_error_file_truncated
);
3875 /* Otherwise with identical leaves we issue an error
3876 message - because there should never be duplicates.
3877 The exception is Type 18/Name 1/Lang 0 which is the
3878 defaul manifest - this can just be dropped. */
3879 if (entry
->is_name
== FALSE
3880 && entry
->name_id
.id
== 0
3882 && dir
->entry
!= NULL
3883 && dir
->entry
->is_name
== FALSE
3884 && dir
->entry
->name_id
.id
== 1
3885 && dir
->entry
->parent
!= NULL
3886 && dir
->entry
->parent
->entry
!= NULL
3887 && dir
->entry
->parent
->entry
->is_name
== FALSE
3888 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
3890 else if (dir
!= NULL
3891 && dir
->entry
!= NULL
3892 && dir
->entry
->parent
!= NULL
3893 && dir
->entry
->parent
->entry
!= NULL
3894 && dir
->entry
->parent
->entry
->is_name
== FALSE
3895 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
3897 /* Strings need special handling. */
3898 if (! rsrc_merge_string_entries (entry
, next
))
3900 /* _bfd_error_handler should have been called inside merge_strings. */
3901 bfd_set_error (bfd_error_file_truncated
);
3908 || dir
->entry
== NULL
3909 || dir
->entry
->parent
== NULL
3910 || dir
->entry
->parent
->entry
== NULL
)
3911 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3913 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3914 rsrc_resource_name (entry
, dir
));
3915 bfd_set_error (bfd_error_file_truncated
);
3920 /* Unhook NEXT from the chain. */
3921 entry
->next_entry
= next
->next_entry
;
3922 chain
->num_entries
--;
3923 if (chain
->num_entries
< 2)
3925 next
= next
->next_entry
;
3929 points_to_entry
= & entry
->next_entry
;
3931 next
= next
->next_entry
;
3936 chain
->last_entry
= entry
;
3941 /* Attach B's chain onto A. */
3943 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
3945 if (bchain
->num_entries
== 0)
3948 achain
->num_entries
+= bchain
->num_entries
;
3950 if (achain
->first_entry
== NULL
)
3952 achain
->first_entry
= bchain
->first_entry
;
3953 achain
->last_entry
= bchain
->last_entry
;
3957 achain
->last_entry
->next_entry
= bchain
->first_entry
;
3958 achain
->last_entry
= bchain
->last_entry
;
3961 bchain
->num_entries
= 0;
3962 bchain
->first_entry
= bchain
->last_entry
= NULL
;
3966 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
3968 rsrc_directory
* adir
;
3969 rsrc_directory
* bdir
;
3971 BFD_ASSERT (a
->is_dir
);
3972 BFD_ASSERT (b
->is_dir
);
3974 adir
= a
->value
.directory
;
3975 bdir
= b
->value
.directory
;
3977 if (adir
->characteristics
!= bdir
->characteristics
)
3979 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3980 bfd_set_error (bfd_error_file_truncated
);
3984 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
3986 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3987 bfd_set_error (bfd_error_file_truncated
);
3991 /* Attach B's name chain to A. */
3992 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
3994 /* Attach B's ID chain to A. */
3995 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
3997 /* Now sort A's entries. */
3998 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
3999 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
4002 /* Check the .rsrc section. If it contains multiple concatenated
4003 resources then we must merge them properly. Otherwise Windows
4004 will ignore all but the first set. */
4007 rsrc_process_section (bfd
* abfd
,
4008 struct coff_final_link_info
* pfinfo
)
4010 rsrc_directory new_table
;
4016 bfd_byte
* datastart
;
4018 bfd_byte
* new_data
;
4019 unsigned int num_resource_sets
;
4020 rsrc_directory
* type_tables
;
4021 rsrc_write_data write_data
;
4024 unsigned int num_input_rsrc
= 0;
4025 unsigned int max_num_input_rsrc
= 4;
4026 ptrdiff_t * rsrc_sizes
= NULL
;
4028 new_table
.names
.num_entries
= 0;
4029 new_table
.ids
.num_entries
= 0;
4031 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4032 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4035 pe
= pe_data (abfd
);
4039 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4041 data
= bfd_malloc (size
);
4047 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4050 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4051 their lengths. Note - we rely upon the fact that the linker script
4052 does *not* sort the input .rsrc sections, so that the order in the
4053 linkinfo list matches the order in the output .rsrc section.
4055 We need to know the lengths because each input .rsrc section has padding
4056 at the end of a variable amount. (It does not appear to be based upon
4057 the section alignment or the file alignment). We need to skip any
4058 padding bytes when parsing the input .rsrc sections. */
4059 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4060 if (rsrc_sizes
== NULL
)
4063 for (input
= pfinfo
->info
->input_bfds
;
4065 input
= input
->link
.next
)
4067 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4069 if (rsrc_sec
!= NULL
)
4071 if (num_input_rsrc
== max_num_input_rsrc
)
4073 max_num_input_rsrc
+= 10;
4074 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4075 * sizeof * rsrc_sizes
);
4076 if (rsrc_sizes
== NULL
)
4080 BFD_ASSERT (rsrc_sec
->size
> 0);
4081 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4085 if (num_input_rsrc
< 2)
4088 /* Step one: Walk the section, computing the size of the tables,
4089 leaves and data and decide if we need to do anything. */
4090 dataend
= data
+ size
;
4091 num_resource_sets
= 0;
4093 while (data
< dataend
)
4095 bfd_byte
* p
= data
;
4097 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4101 /* Corrupted .rsrc section - cannot merge. */
4102 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4103 bfd_get_filename (abfd
));
4104 bfd_set_error (bfd_error_file_truncated
);
4108 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4110 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4111 bfd_get_filename (abfd
));
4112 bfd_set_error (bfd_error_file_truncated
);
4115 /* FIXME: Should we add a check for "data - p" being much smaller
4116 than rsrc_sizes[num_resource_sets] ? */
4118 data
= p
+ rsrc_sizes
[num_resource_sets
];
4119 rva_bias
+= data
- p
;
4120 ++ num_resource_sets
;
4122 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4124 /* Step two: Walk the data again, building trees of the resources. */
4126 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4128 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4129 if (type_tables
== NULL
)
4133 while (data
< dataend
)
4135 bfd_byte
* p
= data
;
4137 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4138 dataend
, rva_bias
, NULL
);
4139 data
= p
+ rsrc_sizes
[indx
];
4140 rva_bias
+= data
- p
;
4143 BFD_ASSERT (indx
== num_resource_sets
);
4145 /* Step three: Merge the top level tables (there can be only one).
4147 We must ensure that the merged entries are in ascending order.
4149 We also thread the top level table entries from the old tree onto
4150 the new table, so that they can be pulled off later. */
4152 /* FIXME: Should we verify that all type tables are the same ? */
4153 new_table
.characteristics
= type_tables
[0].characteristics
;
4154 new_table
.time
= type_tables
[0].time
;
4155 new_table
.major
= type_tables
[0].major
;
4156 new_table
.minor
= type_tables
[0].minor
;
4158 /* Chain the NAME entries onto the table. */
4159 new_table
.names
.first_entry
= NULL
;
4160 new_table
.names
.last_entry
= NULL
;
4162 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4163 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4165 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
4167 /* Chain the ID entries onto the table. */
4168 new_table
.ids
.first_entry
= NULL
;
4169 new_table
.ids
.last_entry
= NULL
;
4171 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4172 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4174 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
4176 /* Step four: Create new contents for the .rsrc section. */
4177 /* Step four point one: Compute the size of each region of the .rsrc section.
4178 We do this now, rather than earlier, as the merging above may have dropped
4180 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4181 rsrc_compute_region_sizes (& new_table
);
4182 /* We increment sizeof_strings to make sure that resource data
4183 starts on an 8-byte boundary. FIXME: Is this correct ? */
4184 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4186 new_data
= bfd_zalloc (abfd
, size
);
4187 if (new_data
== NULL
)
4190 write_data
.abfd
= abfd
;
4191 write_data
.datastart
= new_data
;
4192 write_data
.next_table
= new_data
;
4193 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4194 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4195 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4196 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4198 rsrc_write_directory (& write_data
, & new_table
);
4200 /* Step five: Replace the old contents with the new.
4201 We recompute the size as we may have lost entries due to mergeing. */
4202 size
= ((write_data
.next_data
- new_data
) + 3) & ~ 3;
4207 if (coff_data (abfd
)->link_info
)
4209 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
4211 /* If no file alignment has been set, default to one.
4212 This repairs 'ld -r' for arm-wince-pe target. */
4217 page_size
= PE_DEF_FILE_ALIGNMENT
;
4218 size
= (size
+ page_size
- 1) & - page_size
;
4221 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4222 sec
->size
= sec
->rawsize
= size
;
4225 /* Step six: Free all the memory that we have used. */
4226 /* FIXME: Free the resource tree, if we have one. */
4231 /* Handle the .idata section and other things that need symbol table
4235 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4237 struct coff_link_hash_entry
*h1
;
4238 struct bfd_link_info
*info
= pfinfo
->info
;
4239 bfd_boolean result
= TRUE
;
4241 /* There are a few fields that need to be filled in now while we
4242 have symbol table access.
4244 The .idata subsections aren't directly available as sections, but
4245 they are in the symbol table, so get them from there. */
4247 /* The import directory. This is the address of .idata$2, with size
4248 of .idata$2 + .idata$3. */
4249 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4250 ".idata$2", FALSE
, FALSE
, TRUE
);
4253 /* PR ld/2729: We cannot rely upon all the output sections having been
4254 created properly, so check before referencing them. Issue a warning
4255 message for any sections tht could not be found. */
4256 if ((h1
->root
.type
== bfd_link_hash_defined
4257 || h1
->root
.type
== bfd_link_hash_defweak
)
4258 && h1
->root
.u
.def
.section
!= NULL
4259 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4260 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4261 (h1
->root
.u
.def
.value
4262 + h1
->root
.u
.def
.section
->output_section
->vma
4263 + h1
->root
.u
.def
.section
->output_offset
);
4267 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4272 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4273 ".idata$4", FALSE
, FALSE
, TRUE
);
4275 && (h1
->root
.type
== bfd_link_hash_defined
4276 || h1
->root
.type
== bfd_link_hash_defweak
)
4277 && h1
->root
.u
.def
.section
!= NULL
4278 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4279 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4280 ((h1
->root
.u
.def
.value
4281 + h1
->root
.u
.def
.section
->output_section
->vma
4282 + h1
->root
.u
.def
.section
->output_offset
)
4283 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4287 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4292 /* The import address table. This is the size/address of
4294 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4295 ".idata$5", FALSE
, FALSE
, TRUE
);
4297 && (h1
->root
.type
== bfd_link_hash_defined
4298 || h1
->root
.type
== bfd_link_hash_defweak
)
4299 && h1
->root
.u
.def
.section
!= NULL
4300 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4301 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4302 (h1
->root
.u
.def
.value
4303 + h1
->root
.u
.def
.section
->output_section
->vma
4304 + h1
->root
.u
.def
.section
->output_offset
);
4308 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4313 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4314 ".idata$6", FALSE
, FALSE
, TRUE
);
4316 && (h1
->root
.type
== bfd_link_hash_defined
4317 || h1
->root
.type
== bfd_link_hash_defweak
)
4318 && h1
->root
.u
.def
.section
!= NULL
4319 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4320 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4321 ((h1
->root
.u
.def
.value
4322 + h1
->root
.u
.def
.section
->output_section
->vma
4323 + h1
->root
.u
.def
.section
->output_offset
)
4324 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4328 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4335 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4336 "__IAT_start__", FALSE
, FALSE
, TRUE
);
4338 && (h1
->root
.type
== bfd_link_hash_defined
4339 || h1
->root
.type
== bfd_link_hash_defweak
)
4340 && h1
->root
.u
.def
.section
!= NULL
4341 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4346 (h1
->root
.u
.def
.value
4347 + h1
->root
.u
.def
.section
->output_section
->vma
4348 + h1
->root
.u
.def
.section
->output_offset
);
4350 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4351 "__IAT_end__", FALSE
, FALSE
, TRUE
);
4353 && (h1
->root
.type
== bfd_link_hash_defined
4354 || h1
->root
.type
== bfd_link_hash_defweak
)
4355 && h1
->root
.u
.def
.section
!= NULL
4356 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4358 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4359 ((h1
->root
.u
.def
.value
4360 + h1
->root
.u
.def
.section
->output_section
->vma
4361 + h1
->root
.u
.def
.section
->output_offset
)
4363 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4364 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4365 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4370 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4371 " because .idata$6 is missing"), abfd
);
4377 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4378 (bfd_get_symbol_leading_char (abfd
) != 0
4379 ? "__tls_used" : "_tls_used"),
4380 FALSE
, FALSE
, TRUE
);
4383 if ((h1
->root
.type
== bfd_link_hash_defined
4384 || h1
->root
.type
== bfd_link_hash_defweak
)
4385 && h1
->root
.u
.def
.section
!= NULL
4386 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4387 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4388 (h1
->root
.u
.def
.value
4389 + h1
->root
.u
.def
.section
->output_section
->vma
4390 + h1
->root
.u
.def
.section
->output_offset
4391 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4395 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4399 /* According to PECOFF sepcifications by Microsoft version 8.2
4400 the TLS data directory consists of 4 pointers, followed
4401 by two 4-byte integer. This implies that the total size
4402 is different for 32-bit and 64-bit executables. */
4403 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4404 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4406 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4410 /* If there is a .pdata section and we have linked pdata finally, we
4411 need to sort the entries ascending. */
4412 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4414 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4418 bfd_size_type x
= sec
->rawsize
;
4419 bfd_byte
*tmp_data
= NULL
;
4422 tmp_data
= bfd_malloc (x
);
4424 if (tmp_data
!= NULL
)
4426 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4430 12, sort_x64_pdata
);
4431 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4440 rsrc_process_section (abfd
, pfinfo
);
4442 /* If we couldn't find idata$2, we either have an excessively
4443 trivial program or are in DEEP trouble; we have to assume trivial