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 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
213 struct internal_syment
*in
= (struct internal_syment
*) inp
;
214 SYMENT
*ext
= (SYMENT
*) extp
;
216 if (in
->_n
._n_name
[0] == 0)
218 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
219 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
222 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
224 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
225 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
227 if (sizeof (ext
->e_type
) == 2)
228 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
230 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
232 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
233 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
239 _bfd_XXi_swap_aux_in (bfd
* abfd
,
243 int indx ATTRIBUTE_UNUSED
,
244 int numaux ATTRIBUTE_UNUSED
,
247 AUXENT
*ext
= (AUXENT
*) ext1
;
248 union internal_auxent
*in
= (union internal_auxent
*) in1
;
253 if (ext
->x_file
.x_fname
[0] == 0)
255 in
->x_file
.x_n
.x_zeroes
= 0;
256 in
->x_file
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
259 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
267 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
268 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
269 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
270 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
271 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
272 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
278 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
279 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
281 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
284 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
285 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
289 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
290 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
291 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
292 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
293 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
294 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
295 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
296 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
301 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
305 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
306 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
311 _bfd_XXi_swap_aux_out (bfd
* abfd
,
315 int indx ATTRIBUTE_UNUSED
,
316 int numaux ATTRIBUTE_UNUSED
,
319 union internal_auxent
*in
= (union internal_auxent
*) inp
;
320 AUXENT
*ext
= (AUXENT
*) extp
;
322 memset (ext
, 0, AUXESZ
);
327 if (in
->x_file
.x_fname
[0] == 0)
329 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
330 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
333 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
342 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
343 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
344 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
345 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
346 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
347 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
353 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
354 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
356 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
359 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
360 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
364 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
365 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
366 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
367 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
368 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
369 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
370 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
371 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
375 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
378 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
379 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
386 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
388 LINENO
*ext
= (LINENO
*) ext1
;
389 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
391 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
392 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
396 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
398 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
399 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
400 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
402 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
407 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
411 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
412 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
413 struct internal_aouthdr
*aouthdr_int
414 = (struct internal_aouthdr
*) aouthdr_int1
;
415 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
417 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
418 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
419 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
420 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
421 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
422 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
423 aouthdr_int
->text_start
=
424 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
425 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
426 /* PE32+ does not have data_start member! */
427 aouthdr_int
->data_start
=
428 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
429 a
->BaseOfData
= aouthdr_int
->data_start
;
432 a
->Magic
= aouthdr_int
->magic
;
433 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
434 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
435 a
->SizeOfCode
= aouthdr_int
->tsize
;
436 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
437 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
438 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
439 a
->BaseOfCode
= aouthdr_int
->text_start
;
440 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
441 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
442 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
443 a
->MajorOperatingSystemVersion
=
444 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
445 a
->MinorOperatingSystemVersion
=
446 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
447 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
448 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
449 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
450 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
451 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
452 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
453 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
454 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
455 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
456 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
457 a
->SizeOfStackReserve
=
458 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
459 a
->SizeOfStackCommit
=
460 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
461 a
->SizeOfHeapReserve
=
462 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
463 a
->SizeOfHeapCommit
=
464 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
465 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
466 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
471 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
473 /* If data directory is empty, rva also should be 0. */
475 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
477 a
->DataDirectory
[idx
].Size
= size
;
480 a
->DataDirectory
[idx
].VirtualAddress
=
481 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
483 a
->DataDirectory
[idx
].VirtualAddress
= 0;
487 if (aouthdr_int
->entry
)
489 aouthdr_int
->entry
+= a
->ImageBase
;
490 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
491 aouthdr_int
->entry
&= 0xffffffff;
495 if (aouthdr_int
->tsize
)
497 aouthdr_int
->text_start
+= a
->ImageBase
;
498 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
499 aouthdr_int
->text_start
&= 0xffffffff;
503 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
504 /* PE32+ does not have data_start member! */
505 if (aouthdr_int
->dsize
)
507 aouthdr_int
->data_start
+= a
->ImageBase
;
508 aouthdr_int
->data_start
&= 0xffffffff;
513 /* These three fields are normally set up by ppc_relocate_section.
514 In the case of reading a file in, we can pick them up from the
516 first_thunk_address
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
;
517 thunk_size
= a
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
;
518 import_table_size
= a
->DataDirectory
[PE_IMPORT_TABLE
].Size
;
522 /* A support function for below. */
525 add_data_entry (bfd
* abfd
,
526 struct internal_extra_pe_aouthdr
*aout
,
531 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
533 /* Add import directory information if it exists. */
535 && (coff_section_data (abfd
, sec
) != NULL
)
536 && (pei_section_data (abfd
, sec
) != NULL
))
538 /* If data directory is empty, rva also should be 0. */
539 int size
= pei_section_data (abfd
, sec
)->virt_size
;
540 aout
->DataDirectory
[idx
].Size
= size
;
544 aout
->DataDirectory
[idx
].VirtualAddress
=
545 (sec
->vma
- base
) & 0xffffffff;
546 sec
->flags
|= SEC_DATA
;
552 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
554 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
555 pe_data_type
*pe
= pe_data (abfd
);
556 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
557 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
559 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
561 sa
= extra
->SectionAlignment
;
562 fa
= extra
->FileAlignment
;
563 ib
= extra
->ImageBase
;
565 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
566 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
567 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
569 if (aouthdr_in
->tsize
)
571 aouthdr_in
->text_start
-= ib
;
572 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
573 aouthdr_in
->text_start
&= 0xffffffff;
577 if (aouthdr_in
->dsize
)
579 aouthdr_in
->data_start
-= ib
;
580 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
581 aouthdr_in
->data_start
&= 0xffffffff;
585 if (aouthdr_in
->entry
)
587 aouthdr_in
->entry
-= ib
;
588 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
589 aouthdr_in
->entry
&= 0xffffffff;
593 #define FA(x) (((x) + fa -1 ) & (- fa))
594 #define SA(x) (((x) + sa -1 ) & (- sa))
596 /* We like to have the sizes aligned. */
597 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
599 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
601 add_data_entry (abfd
, extra
, 0, ".edata", ib
);
602 add_data_entry (abfd
, extra
, 2, ".rsrc", ib
);
603 add_data_entry (abfd
, extra
, 3, ".pdata", ib
);
605 /* In theory we do not need to call add_data_entry for .idata$2 or
606 .idata$5. It will be done in bfd_coff_final_link where all the
607 required information is available. If however, we are not going
608 to perform a final link, eg because we have been invoked by objcopy
609 or strip, then we need to make sure that these Data Directory
610 entries are initialised properly.
612 So - we copy the input values into the output values, and then, if
613 a final link is going to be performed, it can overwrite them. */
614 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
615 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
616 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
618 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
619 /* Until other .idata fixes are made (pending patch), the entry for
620 .idata is needed for backwards compatibility. FIXME. */
621 add_data_entry (abfd
, extra
, 1, ".idata", ib
);
623 /* For some reason, the virtual size (which is what's set by
624 add_data_entry) for .reloc is not the same as the size recorded
625 in this slot by MSVC; it doesn't seem to cause problems (so far),
626 but since it's the best we've got, use it. It does do the right
628 if (pe
->has_reloc_section
)
629 add_data_entry (abfd
, extra
, 5, ".reloc", ib
);
638 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
640 int rounded
= FA (sec
->size
);
642 /* The first non-zero section filepos is the header size.
643 Sections without contents will have a filepos of 0. */
645 hsize
= sec
->filepos
;
646 if (sec
->flags
& SEC_DATA
)
648 if (sec
->flags
& SEC_CODE
)
650 /* The image size is the total VIRTUAL size (which is what is
651 in the virt_size field). Files have been seen (from MSVC
652 5.0 link.exe) where the file size of the .data segment is
653 quite small compared to the virtual size. Without this
654 fix, strip munges the file.
656 FIXME: We need to handle holes between sections, which may
657 happpen when we covert from another format. We just use
658 the virtual address and virtual size of the last section
659 for the image size. */
660 if (coff_section_data (abfd
, sec
) != NULL
661 && pei_section_data (abfd
, sec
) != NULL
)
662 isize
= (sec
->vma
- extra
->ImageBase
663 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
666 aouthdr_in
->dsize
= dsize
;
667 aouthdr_in
->tsize
= tsize
;
668 extra
->SizeOfHeaders
= hsize
;
669 extra
->SizeOfImage
= isize
;
672 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
674 /* e.g. 219510000 is linker version 2.19 */
675 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
677 /* This piece of magic sets the "linker version" field to
679 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
680 aouthdr_out
->standard
.vstamp
);
682 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
683 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
684 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
685 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
686 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
687 aouthdr_out
->standard
.text_start
);
689 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
690 /* PE32+ does not have data_start member! */
691 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
692 aouthdr_out
->standard
.data_start
);
695 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
696 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
697 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
698 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
699 aouthdr_out
->MajorOperatingSystemVersion
);
700 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
701 aouthdr_out
->MinorOperatingSystemVersion
);
702 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
703 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
704 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
705 aouthdr_out
->MajorSubsystemVersion
);
706 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
707 aouthdr_out
->MinorSubsystemVersion
);
708 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
709 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
710 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
711 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
712 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
713 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
714 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
715 aouthdr_out
->SizeOfStackReserve
);
716 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
717 aouthdr_out
->SizeOfStackCommit
);
718 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
719 aouthdr_out
->SizeOfHeapReserve
);
720 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
721 aouthdr_out
->SizeOfHeapCommit
);
722 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
723 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
724 aouthdr_out
->NumberOfRvaAndSizes
);
728 for (idx
= 0; idx
< 16; idx
++)
730 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
731 aouthdr_out
->DataDirectory
[idx
][0]);
732 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
733 aouthdr_out
->DataDirectory
[idx
][1]);
741 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
744 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
745 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
747 if (pe_data (abfd
)->has_reloc_section
748 || pe_data (abfd
)->dont_strip_reloc
)
749 filehdr_in
->f_flags
&= ~F_RELFLG
;
751 if (pe_data (abfd
)->dll
)
752 filehdr_in
->f_flags
|= F_DLL
;
754 filehdr_in
->pe
.e_magic
= DOSMAGIC
;
755 filehdr_in
->pe
.e_cblp
= 0x90;
756 filehdr_in
->pe
.e_cp
= 0x3;
757 filehdr_in
->pe
.e_crlc
= 0x0;
758 filehdr_in
->pe
.e_cparhdr
= 0x4;
759 filehdr_in
->pe
.e_minalloc
= 0x0;
760 filehdr_in
->pe
.e_maxalloc
= 0xffff;
761 filehdr_in
->pe
.e_ss
= 0x0;
762 filehdr_in
->pe
.e_sp
= 0xb8;
763 filehdr_in
->pe
.e_csum
= 0x0;
764 filehdr_in
->pe
.e_ip
= 0x0;
765 filehdr_in
->pe
.e_cs
= 0x0;
766 filehdr_in
->pe
.e_lfarlc
= 0x40;
767 filehdr_in
->pe
.e_ovno
= 0x0;
769 for (idx
= 0; idx
< 4; idx
++)
770 filehdr_in
->pe
.e_res
[idx
] = 0x0;
772 filehdr_in
->pe
.e_oemid
= 0x0;
773 filehdr_in
->pe
.e_oeminfo
= 0x0;
775 for (idx
= 0; idx
< 10; idx
++)
776 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
778 filehdr_in
->pe
.e_lfanew
= 0x80;
780 /* This next collection of data are mostly just characters. It
781 appears to be constant within the headers put on NT exes. */
782 filehdr_in
->pe
.dos_message
[0] = 0x0eba1f0e;
783 filehdr_in
->pe
.dos_message
[1] = 0xcd09b400;
784 filehdr_in
->pe
.dos_message
[2] = 0x4c01b821;
785 filehdr_in
->pe
.dos_message
[3] = 0x685421cd;
786 filehdr_in
->pe
.dos_message
[4] = 0x70207369;
787 filehdr_in
->pe
.dos_message
[5] = 0x72676f72;
788 filehdr_in
->pe
.dos_message
[6] = 0x63206d61;
789 filehdr_in
->pe
.dos_message
[7] = 0x6f6e6e61;
790 filehdr_in
->pe
.dos_message
[8] = 0x65622074;
791 filehdr_in
->pe
.dos_message
[9] = 0x6e757220;
792 filehdr_in
->pe
.dos_message
[10] = 0x206e6920;
793 filehdr_in
->pe
.dos_message
[11] = 0x20534f44;
794 filehdr_in
->pe
.dos_message
[12] = 0x65646f6d;
795 filehdr_in
->pe
.dos_message
[13] = 0x0a0d0d2e;
796 filehdr_in
->pe
.dos_message
[14] = 0x24;
797 filehdr_in
->pe
.dos_message
[15] = 0x0;
798 filehdr_in
->pe
.nt_signature
= NT_SIGNATURE
;
800 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
801 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
803 /* Only use a real timestamp if the option was chosen. */
804 if ((pe_data (abfd
)->insert_timestamp
))
805 H_PUT_32 (abfd
, time(0), filehdr_out
->f_timdat
);
807 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
808 filehdr_out
->f_symptr
);
809 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
810 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
811 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
813 /* Put in extra dos header stuff. This data remains essentially
814 constant, it just has to be tacked on to the beginning of all exes
816 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
817 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
818 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
819 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
820 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
821 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
822 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
823 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
824 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
825 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
826 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
827 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
828 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
829 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
831 for (idx
= 0; idx
< 4; idx
++)
832 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
834 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
835 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
837 for (idx
= 0; idx
< 10; idx
++)
838 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
840 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
842 for (idx
= 0; idx
< 16; idx
++)
843 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
844 filehdr_out
->dos_message
[idx
]);
846 /* Also put in the NT signature. */
847 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
853 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
855 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
856 FILHDR
*filehdr_out
= (FILHDR
*) out
;
858 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
859 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
860 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
861 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
862 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
863 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
864 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
870 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
872 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
873 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
874 unsigned int ret
= SCNHSZ
;
878 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
880 PUT_SCNHDR_VADDR (abfd
,
881 ((scnhdr_int
->s_vaddr
882 - pe_data (abfd
)->pe_opthdr
.ImageBase
)
884 scnhdr_ext
->s_vaddr
);
886 /* NT wants the size data to be rounded up to the next
887 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
889 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
891 if (bfd_pei_p (abfd
))
893 ps
= scnhdr_int
->s_size
;
899 ss
= scnhdr_int
->s_size
;
904 if (bfd_pei_p (abfd
))
905 ps
= scnhdr_int
->s_paddr
;
909 ss
= scnhdr_int
->s_size
;
912 PUT_SCNHDR_SIZE (abfd
, ss
,
915 /* s_paddr in PE is really the virtual size. */
916 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
918 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
919 scnhdr_ext
->s_scnptr
);
920 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
921 scnhdr_ext
->s_relptr
);
922 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
923 scnhdr_ext
->s_lnnoptr
);
926 /* Extra flags must be set when dealing with PE. All sections should also
927 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
928 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
929 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
930 (this is especially important when dealing with the .idata section since
931 the addresses for routines from .dlls must be overwritten). If .reloc
932 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
933 (0x02000000). Also, the resource data should also be read and
936 /* FIXME: Alignment is also encoded in this field, at least on PPC and
937 ARM-WINCE. Although - how do we get the original alignment field
942 const char * section_name
;
943 unsigned long must_have
;
945 pe_required_section_flags
;
947 pe_required_section_flags known_sections
[] =
949 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
950 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
951 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
952 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
953 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
954 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
955 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
956 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
957 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
958 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
959 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
960 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
964 pe_required_section_flags
* p
;
966 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
967 we know exactly what this specific section wants so we remove it
968 and then allow the must_have field to add it back in if necessary.
969 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
970 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
971 by ld --enable-auto-import (if auto-import is actually needed),
972 by ld --omagic, or by obcopy --writable-text. */
974 for (p
= known_sections
; p
->section_name
; p
++)
975 if (strcmp (scnhdr_int
->s_name
, p
->section_name
) == 0)
977 if (strcmp (scnhdr_int
->s_name
, ".text")
978 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
979 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
980 scnhdr_int
->s_flags
|= p
->must_have
;
984 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
987 if (coff_data (abfd
)->link_info
988 && ! coff_data (abfd
)->link_info
->relocatable
989 && ! coff_data (abfd
)->link_info
->shared
990 && strcmp (scnhdr_int
->s_name
, ".text") == 0)
992 /* By inference from looking at MS output, the 32 bit field
993 which is the combination of the number_of_relocs and
994 number_of_linenos is used for the line number count in
995 executables. A 16-bit field won't do for cc1. The MS
996 document says that the number of relocs is zero for
997 executables, but the 17-th bit has been observed to be there.
998 Overflow is not an issue: a 4G-line program will overflow a
999 bunch of other fields long before this! */
1000 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1001 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1005 if (scnhdr_int
->s_nlnno
<= 0xffff)
1006 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1009 (*_bfd_error_handler
) (_("%s: line number overflow: 0x%lx > 0xffff"),
1010 bfd_get_filename (abfd
),
1011 scnhdr_int
->s_nlnno
);
1012 bfd_set_error (bfd_error_file_truncated
);
1013 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1017 /* Although we could encode 0xffff relocs here, we do not, to be
1018 consistent with other parts of bfd. Also it lets us warn, as
1019 we should never see 0xffff here w/o having the overflow flag
1021 if (scnhdr_int
->s_nreloc
< 0xffff)
1022 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1025 /* PE can deal with large #s of relocs, but not here. */
1026 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1027 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1028 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1034 static char * dir_names
[IMAGE_NUMBEROF_DIRECTORY_ENTRIES
] =
1036 N_("Export Directory [.edata (or where ever we found it)]"),
1037 N_("Import Directory [parts of .idata]"),
1038 N_("Resource Directory [.rsrc]"),
1039 N_("Exception Directory [.pdata]"),
1040 N_("Security Directory"),
1041 N_("Base Relocation Directory [.reloc]"),
1042 N_("Debug Directory"),
1043 N_("Description Directory"),
1044 N_("Special Directory"),
1045 N_("Thread Storage Directory [.tls]"),
1046 N_("Load Configuration Directory"),
1047 N_("Bound Import Directory"),
1048 N_("Import Address Table Directory"),
1049 N_("Delay Import Directory"),
1050 N_("CLR Runtime Header"),
1054 #ifdef POWERPC_LE_PE
1055 /* The code for the PPC really falls in the "architecture dependent"
1056 category. However, it's not clear that anyone will ever care, so
1057 we're ignoring the issue for now; if/when PPC matters, some of this
1058 may need to go into peicode.h, or arguments passed to enable the
1059 PPC- specific code. */
1063 pe_print_idata (bfd
* abfd
, void * vfile
)
1065 FILE *file
= (FILE *) vfile
;
1070 #ifdef POWERPC_LE_PE
1071 asection
*rel_section
= bfd_get_section_by_name (abfd
, ".reldata");
1074 bfd_size_type datasize
= 0;
1075 bfd_size_type dataoff
;
1079 pe_data_type
*pe
= pe_data (abfd
);
1080 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1084 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1086 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1088 /* Maybe the extra header isn't there. Look for the section. */
1089 section
= bfd_get_section_by_name (abfd
, ".idata");
1090 if (section
== NULL
)
1093 addr
= section
->vma
;
1094 datasize
= section
->size
;
1100 addr
+= extra
->ImageBase
;
1101 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1103 datasize
= section
->size
;
1104 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1108 if (section
== NULL
)
1111 _("\nThere is an import table, but the section containing it could not be found\n"));
1114 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1117 _("\nThere is an import table in %s, but that section has no contents\n"),
1123 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1124 section
->name
, (unsigned long) addr
);
1126 dataoff
= addr
- section
->vma
;
1128 #ifdef POWERPC_LE_PE
1129 if (rel_section
!= 0 && rel_section
->size
!= 0)
1131 /* The toc address can be found by taking the starting address,
1132 which on the PPC locates a function descriptor. The
1133 descriptor consists of the function code starting address
1134 followed by the address of the toc. The starting address we
1135 get from the bfd, and the descriptor is supposed to be in the
1136 .reldata section. */
1138 bfd_vma loadable_toc_address
;
1139 bfd_vma toc_address
;
1140 bfd_vma start_address
;
1144 if (!bfd_malloc_and_get_section (abfd
, rel_section
, &data
))
1151 offset
= abfd
->start_address
- rel_section
->vma
;
1153 if (offset
>= rel_section
->size
|| offset
+ 8 > rel_section
->size
)
1160 start_address
= bfd_get_32 (abfd
, data
+ offset
);
1161 loadable_toc_address
= bfd_get_32 (abfd
, data
+ offset
+ 4);
1162 toc_address
= loadable_toc_address
- 32768;
1165 _("\nFunction descriptor located at the start address: %04lx\n"),
1166 (unsigned long int) (abfd
->start_address
));
1168 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1169 start_address
, loadable_toc_address
, toc_address
);
1176 _("\nNo reldata section! Function descriptor not decoded.\n"));
1181 _("\nThe Import Tables (interpreted %s section contents)\n"),
1185 vma: Hint Time Forward DLL First\n\
1186 Table Stamp Chain Name Thunk\n"));
1188 /* Read the whole section. Some of the fields might be before dataoff. */
1189 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1196 adj
= section
->vma
- extra
->ImageBase
;
1198 /* Print all image import descriptors. */
1199 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1203 bfd_vma forward_chain
;
1205 bfd_vma first_thunk
;
1210 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1211 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1212 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1213 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1214 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1215 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1216 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1218 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1219 (unsigned long) hint_addr
,
1220 (unsigned long) time_stamp
,
1221 (unsigned long) forward_chain
,
1222 (unsigned long) dll_name
,
1223 (unsigned long) first_thunk
);
1225 if (hint_addr
== 0 && first_thunk
== 0)
1228 if (dll_name
- adj
>= section
->size
)
1231 dll
= (char *) data
+ dll_name
- adj
;
1232 fprintf (file
, _("\n\tDLL Name: %s\n"), dll
);
1237 asection
*ft_section
;
1239 bfd_size_type ft_datasize
;
1243 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1245 idx
= hint_addr
- adj
;
1247 ft_addr
= first_thunk
+ extra
->ImageBase
;
1248 ft_idx
= first_thunk
- adj
;
1249 ft_data
= data
+ ft_idx
;
1250 ft_datasize
= datasize
- ft_idx
;
1253 if (first_thunk
!= hint_addr
)
1255 /* Find the section which contains the first thunk. */
1256 for (ft_section
= abfd
->sections
;
1258 ft_section
= ft_section
->next
)
1260 if (ft_addr
>= ft_section
->vma
1261 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1265 if (ft_section
== NULL
)
1268 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1272 /* Now check to see if this section is the same as our current
1273 section. If it is not then we will have to load its data in. */
1274 if (ft_section
!= section
)
1276 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1277 ft_datasize
= ft_section
->size
- ft_idx
;
1278 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1279 if (ft_data
== NULL
)
1282 /* Read ft_datasize bytes starting at offset ft_idx. */
1283 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1284 (bfd_vma
) ft_idx
, ft_datasize
))
1293 /* Print HintName vector entries. */
1294 #ifdef COFF_WITH_pex64
1295 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1297 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1298 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1300 if (!member
&& !member_high
)
1303 if (HighBitSet (member_high
))
1304 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1305 member_high
, member
,
1306 WithoutHighBit (member_high
), member
);
1312 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1313 member_name
= (char *) data
+ member
- adj
+ 2;
1314 fprintf (file
, "\t%04lx\t %4d %s",member
, ordinal
, member_name
);
1317 /* If the time stamp is not zero, the import address
1318 table holds actual addresses. */
1321 && first_thunk
!= hint_addr
1322 && j
+ 4 <= ft_datasize
)
1323 fprintf (file
, "\t%04lx",
1324 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1325 fprintf (file
, "\n");
1328 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1330 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1332 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1336 if (HighBitSet (member
))
1337 fprintf (file
, "\t%04lx\t %4lu <none>",
1338 member
, WithoutHighBit (member
));
1344 ordinal
= bfd_get_16 (abfd
, data
+ member
- adj
);
1345 member_name
= (char *) data
+ member
- adj
+ 2;
1346 fprintf (file
, "\t%04lx\t %4d %s",
1347 member
, ordinal
, member_name
);
1350 /* If the time stamp is not zero, the import address
1351 table holds actual addresses. */
1354 && first_thunk
!= hint_addr
1355 && j
+ 4 <= ft_datasize
)
1356 fprintf (file
, "\t%04lx",
1357 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1359 fprintf (file
, "\n");
1366 fprintf (file
, "\n");
1375 pe_print_edata (bfd
* abfd
, void * vfile
)
1377 FILE *file
= (FILE *) vfile
;
1380 bfd_size_type datasize
= 0;
1381 bfd_size_type dataoff
;
1386 long export_flags
; /* Reserved - should be zero. */
1390 bfd_vma name
; /* RVA - relative to image base. */
1391 long base
; /* Ordinal base. */
1392 unsigned long num_functions
;/* Number in the export address table. */
1393 unsigned long num_names
; /* Number in the name pointer table. */
1394 bfd_vma eat_addr
; /* RVA to the export address table. */
1395 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1396 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1399 pe_data_type
*pe
= pe_data (abfd
);
1400 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1404 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1406 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1408 /* Maybe the extra header isn't there. Look for the section. */
1409 section
= bfd_get_section_by_name (abfd
, ".edata");
1410 if (section
== NULL
)
1413 addr
= section
->vma
;
1415 datasize
= section
->size
;
1421 addr
+= extra
->ImageBase
;
1423 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1424 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1427 if (section
== NULL
)
1430 _("\nThere is an export table, but the section containing it could not be found\n"));
1433 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1436 _("\nThere is an export table in %s, but that section has no contents\n"),
1441 dataoff
= addr
- section
->vma
;
1442 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1443 if (datasize
> section
->size
- dataoff
)
1446 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1452 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1453 section
->name
, (unsigned long) addr
);
1455 data
= (bfd_byte
*) bfd_malloc (datasize
);
1459 if (! bfd_get_section_contents (abfd
, section
, data
,
1460 (file_ptr
) dataoff
, datasize
))
1463 /* Go get Export Directory Table. */
1464 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1465 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1466 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1467 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1468 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1469 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1470 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1471 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1472 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1473 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1474 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1476 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1478 /* Dump the EDT first. */
1480 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1484 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1487 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1490 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1493 _("Name \t\t\t\t"));
1494 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1496 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1497 fprintf (file
, " %s\n", data
+ edt
.name
- adj
);
1499 fprintf (file
, "(outside .edata section)\n");
1502 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1508 _("\tExport Address Table \t\t%08lx\n"),
1512 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1515 _("Table Addresses\n"));
1518 _("\tExport Address Table \t\t"));
1519 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1520 fprintf (file
, "\n");
1523 _("\tName Pointer Table \t\t"));
1524 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1525 fprintf (file
, "\n");
1528 _("\tOrdinal Table \t\t\t"));
1529 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1530 fprintf (file
, "\n");
1532 /* The next table to find is the Export Address Table. It's basically
1533 a list of pointers that either locate a function in this dll, or
1534 forward the call to another dll. Something like:
1539 } export_address_table_entry; */
1542 _("\nExport Address Table -- Ordinal Base %ld\n"),
1545 for (i
= 0; i
< edt
.num_functions
; ++i
)
1547 bfd_vma eat_member
= bfd_get_32 (abfd
,
1548 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1549 if (eat_member
== 0)
1552 if (eat_member
- adj
<= datasize
)
1554 /* This rva is to a name (forwarding function) in our section. */
1555 /* Should locate a function descriptor. */
1557 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1559 (long) (i
+ edt
.base
),
1560 (unsigned long) eat_member
,
1562 data
+ eat_member
- adj
);
1566 /* Should locate a function descriptor in the reldata section. */
1568 "\t[%4ld] +base[%4ld] %04lx %s\n",
1570 (long) (i
+ edt
.base
),
1571 (unsigned long) eat_member
,
1576 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1577 /* Dump them in parallel for clarity. */
1579 _("\n[Ordinal/Name Pointer] Table\n"));
1581 for (i
= 0; i
< edt
.num_names
; ++i
)
1583 bfd_vma name_ptr
= bfd_get_32 (abfd
,
1588 char *name
= (char *) data
+ name_ptr
- adj
;
1590 bfd_vma ord
= bfd_get_16 (abfd
,
1595 "\t[%4ld] %s\n", (long) ord
, name
);
1603 /* This really is architecture dependent. On IA-64, a .pdata entry
1604 consists of three dwords containing relative virtual addresses that
1605 specify the start and end address of the code range the entry
1606 covers and the address of the corresponding unwind info data.
1608 On ARM and SH-4, a compressed PDATA structure is used :
1609 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1610 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1611 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1613 This is the version for uncompressed data. */
1616 pe_print_pdata (bfd
* abfd
, void * vfile
)
1618 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1619 # define PDATA_ROW_SIZE (3 * 8)
1621 # define PDATA_ROW_SIZE (5 * 4)
1623 FILE *file
= (FILE *) vfile
;
1625 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1626 bfd_size_type datasize
= 0;
1628 bfd_size_type start
, stop
;
1629 int onaline
= PDATA_ROW_SIZE
;
1632 || coff_section_data (abfd
, section
) == NULL
1633 || pei_section_data (abfd
, section
) == NULL
)
1636 stop
= pei_section_data (abfd
, section
)->virt_size
;
1637 if ((stop
% onaline
) != 0)
1639 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1640 (long) stop
, onaline
);
1643 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1644 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1646 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1649 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1650 \t\tAddress Address Handler Data Address Mask\n"));
1653 datasize
= section
->size
;
1657 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1666 for (i
= start
; i
< stop
; i
+= onaline
)
1672 bfd_vma prolog_end_addr
;
1673 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1677 if (i
+ PDATA_ROW_SIZE
> stop
)
1680 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1681 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1682 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1683 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1684 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1686 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1687 && eh_data
== 0 && prolog_end_addr
== 0)
1688 /* We are probably into the padding of the section now. */
1691 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1692 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1694 eh_handler
&= ~(bfd_vma
) 0x3;
1695 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1698 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1699 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1700 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1701 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1702 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1704 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1705 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1706 fprintf (file
, " %x", em_data
);
1709 #ifdef POWERPC_LE_PE
1710 if (eh_handler
== 0 && eh_data
!= 0)
1712 /* Special bits here, although the meaning may be a little
1713 mysterious. The only one I know for sure is 0x03
1716 0x01 Register Save Millicode
1717 0x02 Register Restore Millicode
1718 0x03 Glue Code Sequence. */
1722 fprintf (file
, _(" Register save millicode"));
1725 fprintf (file
, _(" Register restore millicode"));
1728 fprintf (file
, _(" Glue code sequence"));
1735 fprintf (file
, "\n");
1741 #undef PDATA_ROW_SIZE
1744 typedef struct sym_cache
1751 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1753 asymbol
** sy
= NULL
;
1756 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1762 storage
= bfd_get_symtab_upper_bound (abfd
);
1766 sy
= (asymbol
**) bfd_malloc (storage
);
1768 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1769 if (psc
->symcount
< 0)
1775 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1780 psc
->syms
= slurp_symtab (abfd
, psc
);
1782 for (i
= 0; i
< psc
->symcount
; i
++)
1784 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1785 return psc
->syms
[i
]->name
;
1792 cleanup_syms (sym_cache
*psc
)
1799 /* This is the version for "compressed" pdata. */
1802 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1804 # define PDATA_ROW_SIZE (2 * 4)
1805 FILE *file
= (FILE *) vfile
;
1806 bfd_byte
*data
= NULL
;
1807 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1808 bfd_size_type datasize
= 0;
1810 bfd_size_type start
, stop
;
1811 int onaline
= PDATA_ROW_SIZE
;
1812 struct sym_cache cache
= {0, 0} ;
1815 || coff_section_data (abfd
, section
) == NULL
1816 || pei_section_data (abfd
, section
) == NULL
)
1819 stop
= pei_section_data (abfd
, section
)->virt_size
;
1820 if ((stop
% onaline
) != 0)
1822 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1823 (long) stop
, onaline
);
1826 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1829 vma:\t\tBegin Prolog Function Flags Exception EH\n\
1830 \t\tAddress Length Length 32b exc Handler Data\n"));
1832 datasize
= section
->size
;
1836 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1845 for (i
= start
; i
< stop
; i
+= onaline
)
1849 bfd_vma prolog_length
, function_length
;
1850 int flag32bit
, exception_flag
;
1853 if (i
+ PDATA_ROW_SIZE
> stop
)
1856 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1857 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1859 if (begin_addr
== 0 && other_data
== 0)
1860 /* We are probably into the padding of the section now. */
1863 prolog_length
= (other_data
& 0x000000FF);
1864 function_length
= (other_data
& 0x3FFFFF00) >> 8;
1865 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
1866 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
1869 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1870 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1871 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
1872 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
1873 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
1875 /* Get the exception handler's address and the data passed from the
1876 .text section. This is really the data that belongs with the .pdata
1877 but got "compressed" out for the ARM and SH4 architectures. */
1878 tsection
= bfd_get_section_by_name (abfd
, ".text");
1879 if (tsection
&& coff_section_data (abfd
, tsection
)
1880 && pei_section_data (abfd
, tsection
))
1882 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
1885 tdata
= (bfd_byte
*) bfd_malloc (8);
1888 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
1890 bfd_vma eh
, eh_data
;
1892 eh
= bfd_get_32 (abfd
, tdata
);
1893 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
1894 fprintf (file
, "%08x ", (unsigned int) eh
);
1895 fprintf (file
, "%08x", (unsigned int) eh_data
);
1898 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
1901 fprintf (file
, " (%s) ", s
);
1908 fprintf (file
, "\n");
1913 cleanup_syms (& cache
);
1916 #undef PDATA_ROW_SIZE
1920 #define IMAGE_REL_BASED_HIGHADJ 4
1921 static const char * const tbl
[] =
1935 "UNKNOWN", /* MUST be last. */
1939 pe_print_reloc (bfd
* abfd
, void * vfile
)
1941 FILE *file
= (FILE *) vfile
;
1943 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
1945 bfd_size_type start
, stop
;
1947 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
1951 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1953 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1962 stop
= section
->size
;
1964 for (i
= start
; i
< stop
;)
1967 bfd_vma virtual_address
;
1970 /* The .reloc section is a sequence of blocks, with a header consisting
1971 of two 32 bit quantities, followed by a number of 16 bit entries. */
1972 virtual_address
= bfd_get_32 (abfd
, data
+i
);
1973 size
= bfd_get_32 (abfd
, data
+i
+4);
1974 number
= (size
- 8) / 2;
1980 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1981 (unsigned long) virtual_address
, size
, (unsigned long) size
, number
);
1983 for (j
= 0; j
< number
; ++j
)
1985 unsigned short e
= bfd_get_16 (abfd
, data
+ i
+ 8 + j
* 2);
1986 unsigned int t
= (e
& 0xF000) >> 12;
1987 int off
= e
& 0x0FFF;
1989 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
1990 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
1993 _("\treloc %4d offset %4x [%4lx] %s"),
1994 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
1996 /* HIGHADJ takes an argument, - the next record *is* the
1997 low 16 bits of addend. */
1998 if (t
== IMAGE_REL_BASED_HIGHADJ
)
2000 fprintf (file
, " (%4x)",
2002 bfd_get_16 (abfd
, data
+ i
+ 8 + j
* 2 + 2)));
2006 fprintf (file
, "\n");
2019 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int,
2020 bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
2023 rsrc_print_resource_entries (FILE * file
,
2025 unsigned int indent
,
2026 bfd_boolean is_name
,
2027 bfd_byte
* datastart
,
2032 unsigned long entry
, addr
, size
;
2034 if (data
+ 8 >= dataend
)
2037 fprintf (file
, _("%*.s Entry: "), indent
, " ");
2039 entry
= (long) bfd_get_32 (abfd
, data
);
2044 /* Note - the documenation says that this field is an RVA value
2045 but windres appears to produce a section relative offset with
2046 the top bit set. Support both styles for now. */
2047 if (HighBitSet (entry
))
2048 name
= datastart
+ WithoutHighBit (entry
);
2050 name
= datastart
+ entry
- rva_bias
;
2052 if (name
+ 2 < dataend
)
2055 len
= bfd_get_16 (abfd
, name
);
2057 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2058 if (name
+ 2 + len
* 2 < dataend
)
2060 /* This strange loop is to cope with multibyte characters. */
2064 fprintf (file
, "%.1s", name
);
2068 fprintf (file
, _("<corrupt string length: %#x>"), len
);
2071 fprintf (file
, _("<corrupt string offset: %#lx>"), entry
);
2074 fprintf (file
, _("ID: %#08lx"), entry
);
2076 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2077 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2079 if (HighBitSet (entry
))
2080 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1,
2082 datastart
+ WithoutHighBit (entry
),
2085 if (datastart
+ entry
+ 16 >= dataend
)
2088 fprintf (file
, _("%*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2090 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
),
2091 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4),
2092 (int) bfd_get_32 (abfd
, datastart
+ entry
+ 8));
2094 /* Check that the reserved entry is 0. */
2095 if (bfd_get_32 (abfd
, datastart
+ entry
+ 12) != 0
2096 /* And that the data address/size is valid too. */
2097 || (datastart
+ (addr
- rva_bias
) + size
> dataend
))
2100 return datastart
+ (addr
- rva_bias
) + size
;
2103 #define max(a,b) ((a) > (b) ? (a) : (b))
2104 #define min(a,b) ((a) < (b) ? (a) : (b))
2107 rsrc_print_resource_directory (FILE * file
,
2109 unsigned int indent
,
2110 bfd_byte
* datastart
,
2115 unsigned int num_names
, num_ids
;
2116 bfd_byte
* highest_data
= data
;
2118 if (data
+ 16 >= dataend
)
2121 fprintf (file
, "%*.s ", indent
, " ");
2124 case 0: fprintf (file
, "Type"); break;
2125 case 2: fprintf (file
, "Name"); break;
2126 case 4: fprintf (file
, "Language"); break;
2127 default: fprintf (file
, "<unknown>"); break;
2130 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2131 (int) bfd_get_32 (abfd
, data
),
2132 (long) bfd_get_32 (abfd
, data
+ 4),
2133 (int) bfd_get_16 (abfd
, data
+ 8),
2134 (int) bfd_get_16 (abfd
, data
+ 10),
2135 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2136 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2139 while (num_names
--)
2141 bfd_byte
* entry_end
;
2143 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, TRUE
,
2144 datastart
, data
, dataend
, rva_bias
);
2146 highest_data
= max (highest_data
, entry_end
);
2147 if (entry_end
>= dataend
)
2153 bfd_byte
* entry_end
;
2155 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, FALSE
,
2156 datastart
, data
, dataend
,
2159 highest_data
= max (highest_data
, entry_end
);
2160 if (entry_end
>= dataend
)
2164 return max (highest_data
, data
);
2167 /* Display the contents of a .rsrc section. We do not try to
2168 reproduce the resources, windres does that. Instead we dump
2169 the tables in a human readable format. */
2172 rsrc_print_section (bfd
* abfd
, void * vfile
)
2176 FILE * file
= (FILE *) vfile
;
2177 bfd_size_type datasize
;
2181 bfd_byte
* datastart
;
2183 pe
= pe_data (abfd
);
2187 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2188 if (section
== NULL
)
2190 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2193 datasize
= section
->size
;
2197 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2199 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2206 dataend
= data
+ datasize
;
2209 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2211 while (data
< dataend
)
2213 bfd_byte
* p
= data
;
2215 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, data
,
2218 if (data
== dataend
+ 1)
2219 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2222 /* Align data before continuing. */
2223 int align
= (1 << section
->alignment_power
) - 1;
2225 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2226 rva_bias
+= data
- p
;
2228 /* For reasons that are unclear .rsrc sections are sometimes created
2229 aligned to a 1^3 boundary even when their alignment is set at
2230 1^2. Catch that case here before we issue a spurious warning
2232 if (data
== (dataend
- 4))
2234 else if (data
< dataend
)
2235 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2243 /* Print out the program headers. */
2246 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2248 FILE *file
= (FILE *) vfile
;
2250 pe_data_type
*pe
= pe_data (abfd
);
2251 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2252 const char *subsystem_name
= NULL
;
2255 /* The MS dumpbin program reportedly ands with 0xff0f before
2256 printing the characteristics field. Not sure why. No reason to
2258 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2260 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2261 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2262 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2263 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2264 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2265 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2266 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2267 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2268 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2269 PF (IMAGE_FILE_SYSTEM
, "system file");
2270 PF (IMAGE_FILE_DLL
, "DLL");
2271 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2274 /* ctime implies '\n'. */
2276 time_t t
= pe
->coff
.timestamp
;
2277 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2280 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2281 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2283 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2284 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2286 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2287 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2292 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2295 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2298 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2305 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2307 fprintf (file
, "\t(%s)",name
);
2308 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2309 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2310 fprintf (file
, "SizeOfCode\t\t%08lx\n", (unsigned long) i
->SizeOfCode
);
2311 fprintf (file
, "SizeOfInitializedData\t%08lx\n",
2312 (unsigned long) i
->SizeOfInitializedData
);
2313 fprintf (file
, "SizeOfUninitializedData\t%08lx\n",
2314 (unsigned long) i
->SizeOfUninitializedData
);
2315 fprintf (file
, "AddressOfEntryPoint\t");
2316 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2317 fprintf (file
, "\nBaseOfCode\t\t");
2318 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2319 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2320 /* PE32+ does not have BaseOfData member! */
2321 fprintf (file
, "\nBaseOfData\t\t");
2322 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2325 fprintf (file
, "\nImageBase\t\t");
2326 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2327 fprintf (file
, "\nSectionAlignment\t");
2328 bfd_fprintf_vma (abfd
, file
, i
->SectionAlignment
);
2329 fprintf (file
, "\nFileAlignment\t\t");
2330 bfd_fprintf_vma (abfd
, file
, i
->FileAlignment
);
2331 fprintf (file
, "\nMajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2332 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2333 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2334 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2335 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2336 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2337 fprintf (file
, "Win32Version\t\t%08lx\n", (unsigned long) i
->Reserved1
);
2338 fprintf (file
, "SizeOfImage\t\t%08lx\n", (unsigned long) i
->SizeOfImage
);
2339 fprintf (file
, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i
->SizeOfHeaders
);
2340 fprintf (file
, "CheckSum\t\t%08lx\n", (unsigned long) i
->CheckSum
);
2342 switch (i
->Subsystem
)
2344 case IMAGE_SUBSYSTEM_UNKNOWN
:
2345 subsystem_name
= "unspecified";
2347 case IMAGE_SUBSYSTEM_NATIVE
:
2348 subsystem_name
= "NT native";
2350 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2351 subsystem_name
= "Windows GUI";
2353 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2354 subsystem_name
= "Windows CUI";
2356 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2357 subsystem_name
= "POSIX CUI";
2359 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2360 subsystem_name
= "Wince CUI";
2362 // These are from UEFI Platform Initialization Specification 1.1.
2363 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2364 subsystem_name
= "EFI application";
2366 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2367 subsystem_name
= "EFI boot service driver";
2369 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2370 subsystem_name
= "EFI runtime driver";
2372 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2373 subsystem_name
= "SAL runtime driver";
2375 // This is from revision 8.0 of the MS PE/COFF spec
2376 case IMAGE_SUBSYSTEM_XBOX
:
2377 subsystem_name
= "XBOX";
2379 // Added default case for clarity - subsystem_name is NULL anyway.
2381 subsystem_name
= NULL
;
2384 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2386 fprintf (file
, "\t(%s)", subsystem_name
);
2387 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2388 fprintf (file
, "SizeOfStackReserve\t");
2389 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2390 fprintf (file
, "\nSizeOfStackCommit\t");
2391 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2392 fprintf (file
, "\nSizeOfHeapReserve\t");
2393 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2394 fprintf (file
, "\nSizeOfHeapCommit\t");
2395 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2396 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2397 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2398 (unsigned long) i
->NumberOfRvaAndSizes
);
2400 fprintf (file
, "\nThe Data Directory\n");
2401 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2403 fprintf (file
, "Entry %1x ", j
);
2404 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2405 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2406 fprintf (file
, "%s\n", dir_names
[j
]);
2409 pe_print_idata (abfd
, vfile
);
2410 pe_print_edata (abfd
, vfile
);
2411 if (bfd_coff_have_print_pdata (abfd
))
2412 bfd_coff_print_pdata (abfd
, vfile
);
2414 pe_print_pdata (abfd
, vfile
);
2415 pe_print_reloc (abfd
, vfile
);
2417 rsrc_print_section (abfd
, vfile
);
2422 /* Copy any private info we understand from the input bfd
2423 to the output bfd. */
2426 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2428 pe_data_type
*ipe
, *ope
;
2430 /* One day we may try to grok other private data. */
2431 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2432 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2435 ipe
= pe_data (ibfd
);
2436 ope
= pe_data (obfd
);
2438 /* pe_opthdr is copied in copy_object. */
2439 ope
->dll
= ipe
->dll
;
2441 /* Don't copy input subsystem if output is different from input. */
2442 if (obfd
->xvec
!= ibfd
->xvec
)
2443 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2445 /* For strip: if we removed .reloc, we'll make a real mess of things
2446 if we don't remove this entry as well. */
2447 if (! pe_data (obfd
)->has_reloc_section
)
2449 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2450 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2453 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2454 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2456 if (! pe_data (ibfd
)->has_reloc_section
2457 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2458 pe_data (obfd
)->dont_strip_reloc
= 1;
2463 /* Copy private section data. */
2466 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
2471 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
2472 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
2475 if (coff_section_data (ibfd
, isec
) != NULL
2476 && pei_section_data (ibfd
, isec
) != NULL
)
2478 if (coff_section_data (obfd
, osec
) == NULL
)
2480 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
2481 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
2482 if (osec
->used_by_bfd
== NULL
)
2486 if (pei_section_data (obfd
, osec
) == NULL
)
2488 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
2489 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
2490 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
2494 pei_section_data (obfd
, osec
)->virt_size
=
2495 pei_section_data (ibfd
, isec
)->virt_size
;
2496 pei_section_data (obfd
, osec
)->pe_flags
=
2497 pei_section_data (ibfd
, isec
)->pe_flags
;
2504 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
2506 coff_get_symbol_info (abfd
, symbol
, ret
);
2509 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2511 sort_x64_pdata (const void *l
, const void *r
)
2513 const char *lp
= (const char *) l
;
2514 const char *rp
= (const char *) r
;
2516 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
2518 return (vl
< vr
? -1 : 1);
2519 /* We compare just begin address. */
2524 /* Functions to process a .rsrc section. */
2526 static unsigned int sizeof_leaves
;
2527 static unsigned int sizeof_strings
;
2528 static unsigned int sizeof_tables_and_entries
;
2531 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
2534 rsrc_count_entries (bfd
* abfd
,
2535 bfd_boolean is_name
,
2536 bfd_byte
* datastart
,
2541 unsigned long entry
, addr
, size
;
2543 if (data
+ 8 >= dataend
)
2550 entry
= (long) bfd_get_32 (abfd
, data
);
2552 if (HighBitSet (entry
))
2553 name
= datastart
+ WithoutHighBit (entry
);
2555 name
= datastart
+ entry
- rva_bias
;
2557 if (name
+ 2 >= dataend
)
2560 unsigned int len
= bfd_get_16 (abfd
, name
);
2561 if (len
== 0 || len
> 256)
2564 sizeof_strings
+= (len
+ 1) * 2;
2567 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2569 if (HighBitSet (entry
))
2570 return rsrc_count_directory (abfd
,
2572 datastart
+ WithoutHighBit (entry
),
2575 if (datastart
+ entry
+ 16 >= dataend
)
2578 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
2579 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
2581 sizeof_leaves
+= 16;
2583 return datastart
+ addr
- rva_bias
+ size
;
2587 rsrc_count_directory (bfd
* abfd
,
2588 bfd_byte
* datastart
,
2593 unsigned int num_entries
, num_ids
;
2594 bfd_byte
* highest_data
= data
;
2596 if (data
+ 16 >= dataend
)
2599 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
2600 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
2602 num_entries
+= num_ids
;
2605 sizeof_tables_and_entries
+= 16;
2607 while (num_entries
--)
2609 bfd_byte
* entry_end
;
2611 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
2612 datastart
, data
, dataend
, rva_bias
);
2614 sizeof_tables_and_entries
+= 8;
2615 highest_data
= max (highest_data
, entry_end
);
2616 if (entry_end
>= dataend
)
2620 return max (highest_data
, data
);
2623 typedef struct rsrc_dir_chain
2625 unsigned int num_entries
;
2626 struct rsrc_entry
* first_entry
;
2627 struct rsrc_entry
* last_entry
;
2630 typedef struct rsrc_directory
2632 unsigned int characteristics
;
2637 rsrc_dir_chain names
;
2640 struct rsrc_entry
* entry
;
2643 typedef struct rsrc_string
2649 typedef struct rsrc_leaf
2652 unsigned int codepage
;
2656 typedef struct rsrc_entry
2658 bfd_boolean is_name
;
2662 struct rsrc_string name
;
2668 struct rsrc_directory
* directory
;
2669 struct rsrc_leaf
* leaf
;
2672 struct rsrc_entry
* next_entry
;
2673 struct rsrc_directory
* parent
;
2677 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
2678 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
2681 rsrc_parse_entry (bfd
* abfd
,
2682 bfd_boolean is_name
,
2684 bfd_byte
* datastart
,
2688 rsrc_directory
* parent
)
2690 unsigned long val
, addr
, size
;
2692 val
= bfd_get_32 (abfd
, data
);
2694 entry
->parent
= parent
;
2695 entry
->is_name
= is_name
;
2699 /* FIXME: Add range checking ? */
2700 if (HighBitSet (val
))
2702 val
= WithoutHighBit (val
);
2704 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, datastart
+ val
);
2705 entry
->name_id
.name
.string
= datastart
+ val
+ 2;
2709 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, datastart
+ val
2711 entry
->name_id
.name
.string
= datastart
+ val
- rva_bias
+ 2;
2715 entry
->name_id
.id
= val
;
2717 val
= bfd_get_32 (abfd
, data
+ 4);
2719 if (HighBitSet (val
))
2721 entry
->is_dir
= TRUE
;
2722 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
2723 if (entry
->value
.directory
== NULL
)
2726 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
2728 datastart
+ WithoutHighBit (val
),
2729 dataend
, rva_bias
, entry
);
2732 entry
->is_dir
= FALSE
;
2733 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
2734 if (entry
->value
.leaf
== NULL
)
2737 addr
= bfd_get_32 (abfd
, datastart
+ val
);
2738 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, datastart
+ val
+ 4);
2739 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, datastart
+ val
+ 8);
2741 entry
->value
.leaf
->data
= bfd_malloc (size
);
2742 if (entry
->value
.leaf
->data
== NULL
)
2745 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
2746 return datastart
+ (addr
- rva_bias
) + size
;
2750 rsrc_parse_entries (bfd
* abfd
,
2751 rsrc_dir_chain
* chain
,
2752 bfd_boolean is_name
,
2753 bfd_byte
* highest_data
,
2754 bfd_byte
* datastart
,
2758 rsrc_directory
* parent
)
2763 if (chain
->num_entries
== 0)
2765 chain
->first_entry
= chain
->last_entry
= NULL
;
2766 return highest_data
;
2769 entry
= bfd_malloc (sizeof * entry
);
2773 chain
->first_entry
= entry
;
2775 for (i
= chain
->num_entries
; i
--;)
2777 bfd_byte
* entry_end
;
2779 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
2780 data
, dataend
, rva_bias
, parent
);
2782 highest_data
= max (entry_end
, highest_data
);
2783 if (entry_end
> dataend
)
2788 entry
->next_entry
= bfd_malloc (sizeof * entry
);
2789 entry
= entry
->next_entry
;
2794 entry
->next_entry
= NULL
;
2797 chain
->last_entry
= entry
;
2799 return highest_data
;
2803 rsrc_parse_directory (bfd
* abfd
,
2804 rsrc_directory
* table
,
2805 bfd_byte
* datastart
,
2811 bfd_byte
* highest_data
= data
;
2816 table
->characteristics
= bfd_get_32 (abfd
, data
);
2817 table
->time
= bfd_get_32 (abfd
, data
+ 4);
2818 table
->major
= bfd_get_16 (abfd
, data
+ 8);
2819 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
2820 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
2821 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
2822 table
->entry
= entry
;
2826 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, TRUE
, data
,
2827 datastart
, data
, dataend
, rva_bias
, table
);
2828 data
+= table
->names
.num_entries
* 8;
2830 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, FALSE
, highest_data
,
2831 datastart
, data
, dataend
, rva_bias
, table
);
2832 data
+= table
->ids
.num_entries
* 8;
2834 return max (highest_data
, data
);
2837 typedef struct rsrc_write_data
2840 bfd_byte
* datastart
;
2841 bfd_byte
* next_table
;
2842 bfd_byte
* next_leaf
;
2843 bfd_byte
* next_string
;
2844 bfd_byte
* next_data
;
2849 rsrc_write_string (rsrc_write_data
* data
,
2850 rsrc_string
* string
)
2852 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
2853 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
2854 data
->next_string
+= (string
->len
+ 1) * 2;
2857 static inline unsigned int
2858 rsrc_compute_rva (rsrc_write_data
* data
,
2861 return (addr
- data
->datastart
) + data
->rva_bias
;
2865 rsrc_write_leaf (rsrc_write_data
* data
,
2868 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
2870 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
2871 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
2872 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
2873 data
->next_leaf
+= 16;
2875 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
2876 data
->next_data
+= leaf
->size
;
2879 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
2882 rsrc_write_entry (rsrc_write_data
* data
,
2888 bfd_put_32 (data
->abfd
,
2889 SetHighBit (data
->next_string
- data
->datastart
),
2891 rsrc_write_string (data
, & entry
->name_id
.name
);
2894 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
2898 bfd_put_32 (data
->abfd
,
2899 SetHighBit (data
->next_table
- data
->datastart
),
2901 rsrc_write_directory (data
, entry
->value
.directory
);
2905 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
2906 rsrc_write_leaf (data
, entry
->value
.leaf
);
2911 rsrc_write_directory (rsrc_write_data
* data
,
2912 rsrc_directory
* dir
)
2916 bfd_byte
* next_entry
;
2919 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
2920 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
2921 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
2922 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
2923 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
2924 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
2926 /* Compute where the entries and the next table will be placed. */
2927 next_entry
= data
->next_table
+ 16;
2928 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
2929 + (dir
->ids
.num_entries
* 8);
2930 nt
= data
->next_table
;
2932 /* Write the entries. */
2933 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
2934 i
> 0 && entry
!= NULL
;
2935 i
--, entry
= entry
->next_entry
)
2937 rsrc_write_entry (data
, next_entry
, entry
);
2940 BFD_ASSERT (i
== 0);
2941 BFD_ASSERT (entry
== NULL
);
2943 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
2944 i
> 0 && entry
!= NULL
;
2945 i
--, entry
= entry
->next_entry
)
2947 rsrc_write_entry (data
, next_entry
, entry
);
2950 BFD_ASSERT (i
== 0);
2951 BFD_ASSERT (entry
== NULL
);
2952 BFD_ASSERT (nt
== next_entry
);
2955 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
2956 /* Return the length (number of units) of the first character in S,
2957 putting its 'ucs4_t' representation in *PUC. */
2960 u16_mbtouc (wchar_t * puc
, const unsigned short * s
, unsigned int n
)
2962 unsigned short c
= * s
;
2964 if (c
< 0xd800 || c
>= 0xe000)
2974 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
2976 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
2982 /* Incomplete multibyte character. */
2988 /* Invalid multibyte character. */
2992 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
2994 /* Perform a comparison of two entries. */
2996 rsrc_cmp (bfd_boolean is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3005 return a
->name_id
.id
- b
->name_id
.id
;
3007 /* We have to perform a case insenstive, unicode string comparison... */
3008 astring
= a
->name_id
.name
.string
;
3009 alen
= a
->name_id
.name
.len
;
3010 bstring
= b
->name_id
.name
.string
;
3011 blen
= b
->name_id
.name
.len
;
3013 #if defined __CYGWIN__ || defined __MINGW32__
3014 /* Under Windows hosts (both Cygwin and Mingw types),
3015 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3016 function however goes by different names in the two environments... */
3020 #define rscpcmp wcsncasecmp
3023 #define rscpcmp wcsnicmp
3026 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3029 #elif defined HAVE_WCHAR_H
3033 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3038 /* Convert UTF-16 unicode characters into wchar_t characters so
3039 that we can then perform a case insensitive comparison. */
3040 int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3041 int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3045 res
= wcsncasecmp (& awc
, & bwc
, 1);
3051 /* Do the best we can - a case sensitive, untranslated comparison. */
3052 res
= memcmp (astring
, bstring
, min (alen
, blen
) * 2);
3062 rsrc_print_name (char * buffer
, rsrc_string string
)
3065 bfd_byte
* name
= string
.string
;
3067 for (i
= string
.len
; i
--; name
+= 2)
3068 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3072 rsrc_resource_name (rsrc_entry
* entry
, rsrc_directory
* dir
)
3074 static char buffer
[256];
3075 bfd_boolean is_string
= FALSE
;
3079 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3080 && dir
->entry
->parent
->entry
!= NULL
)
3082 strcpy (buffer
, "type: ");
3083 if (dir
->entry
->parent
->entry
->is_name
)
3084 rsrc_print_name (buffer
+ strlen (buffer
),
3085 dir
->entry
->parent
->entry
->name_id
.name
);
3088 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3090 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3093 case 1: strcat (buffer
, " (CURSOR)"); break;
3094 case 2: strcat (buffer
, " (BITMAP)"); break;
3095 case 3: strcat (buffer
, " (ICON)"); break;
3096 case 4: strcat (buffer
, " (MENU)"); break;
3097 case 5: strcat (buffer
, " (DIALOG)"); break;
3098 case 6: strcat (buffer
, " (STRING)"); is_string
= TRUE
; break;
3099 case 7: strcat (buffer
, " (FONTDIR)"); break;
3100 case 8: strcat (buffer
, " (FONT)"); break;
3101 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3102 case 10: strcat (buffer
, " (RCDATA)"); break;
3103 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3104 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3105 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3106 case 16: strcat (buffer
, " (VERSION)"); break;
3107 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3108 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3109 case 20: strcat (buffer
, " (VXD)"); break;
3110 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3111 case 22: strcat (buffer
, " (ANIICON)"); break;
3112 case 23: strcat (buffer
, " (HTML)"); break;
3113 case 24: strcat (buffer
, " (MANIFEST)"); break;
3114 case 240: strcat (buffer
, " (DLGINIT)"); break;
3115 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3120 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3122 strcat (buffer
, " name: ");
3123 if (dir
->entry
->is_name
)
3124 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3127 unsigned int id
= dir
->entry
->name_id
.id
;
3129 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3132 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3133 (id
- 1) << 4, (id
<< 4) - 1);
3139 strcat (buffer
, " lang: ");
3142 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3144 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3150 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3151 their ID is stored in the NAME entry. The bottom four bits are used as
3152 an index into unicode string table that makes up the data of the leaf.
3153 So identical type-name-lang string resources may not actually be
3156 This function is called when we have detected two string resources with
3157 match top-28-bit IDs. We have to scan the string tables inside the leaves
3158 and discover if there are any real collisions. If there are then we report
3159 them and return FALSE. Otherwise we copy any strings from B into A and
3160 then return TRUE. */
3163 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3164 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3166 unsigned int copy_needed
= 0;
3170 bfd_byte
* new_data
;
3173 /* Step one: Find out what we have to do. */
3174 BFD_ASSERT (! a
->is_dir
);
3175 astring
= a
->value
.leaf
->data
;
3177 BFD_ASSERT (! b
->is_dir
);
3178 bstring
= b
->value
.leaf
->data
;
3180 for (i
= 0; i
< 16; i
++)
3182 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3183 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3187 copy_needed
+= blen
* 2;
3191 else if (alen
!= blen
)
3192 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3194 /* alen == blen != 0. We might have two identical strings. If so we
3195 can ignore the second one. There is no need for wchar_t vs UTF-16
3196 theatrics here - we are only interested in (case sensitive) equality. */
3197 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3200 astring
+= (alen
+ 1) * 2;
3201 bstring
+= (blen
+ 1) * 2;
3206 if (a
->parent
!= NULL
3207 && a
->parent
->entry
!= NULL
3208 && a
->parent
->entry
->is_name
== FALSE
)
3209 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3210 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3214 if (copy_needed
== 0)
3217 /* If we reach here then A and B must both have non-colliding strings.
3218 (We never get string resources with fully empty string tables).
3219 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3221 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3222 if (new_data
== NULL
)
3226 astring
= a
->value
.leaf
->data
;
3227 bstring
= b
->value
.leaf
->data
;
3229 for (i
= 0; i
< 16; i
++)
3231 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3232 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3236 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3237 nstring
+= (alen
+ 1) * 2;
3241 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3242 nstring
+= (blen
+ 1) * 2;
3250 astring
+= (alen
+ 1) * 2;
3251 bstring
+= (blen
+ 1) * 2;
3254 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3256 free (a
->value
.leaf
->data
);
3257 a
->value
.leaf
->data
= new_data
;
3258 a
->value
.leaf
->size
+= copy_needed
;
3263 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3265 /* Sort the entries in given part of the directory.
3266 We use an old fashioned bubble sort because we are dealing
3267 with lists and we want to handle matches specially. */
3270 rsrc_sort_entries (rsrc_dir_chain
* chain
,
3271 bfd_boolean is_name
,
3272 rsrc_directory
* dir
)
3276 rsrc_entry
** points_to_entry
;
3277 bfd_boolean swapped
;
3279 if (chain
->num_entries
< 2)
3285 points_to_entry
= & chain
->first_entry
;
3286 entry
= * points_to_entry
;
3287 next
= entry
->next_entry
;
3291 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3295 entry
->next_entry
= next
->next_entry
;
3296 next
->next_entry
= entry
;
3297 * points_to_entry
= next
;
3298 points_to_entry
= & next
->next_entry
;
3299 next
= entry
->next_entry
;
3304 if (entry
->is_dir
&& next
->is_dir
)
3306 /* When we encounter identical directory entries we have to
3307 merge them together. The exception to this rule is for
3308 resource manifests - there can only be one of these,
3309 even if they differ in language. Zero-language manifests
3310 are assumed to be default manifests (provided by the
3311 cygwin build system) and these can be silently dropped,
3312 unless that would reduce the number of manifests to zero.
3313 There should only ever be one non-zero lang manifest -
3314 if there are more it is an error. A non-zero lang
3315 manifest takes precedence over a default manifest. */
3316 if (entry
->is_name
== FALSE
3317 && entry
->name_id
.id
== 1
3319 && dir
->entry
!= NULL
3320 && dir
->entry
->is_name
== FALSE
3321 && dir
->entry
->name_id
.id
== 0x18)
3323 if (next
->value
.directory
->names
.num_entries
== 0
3324 && next
->value
.directory
->ids
.num_entries
== 1
3325 && next
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3326 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3327 /* Fall through so that NEXT is dropped. */
3329 else if (entry
->value
.directory
->names
.num_entries
== 0
3330 && entry
->value
.directory
->ids
.num_entries
== 1
3331 && entry
->value
.directory
->ids
.first_entry
->is_name
== FALSE
3332 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3334 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3335 entry
->next_entry
= next
->next_entry
;
3336 next
->next_entry
= entry
;
3337 * points_to_entry
= next
;
3338 points_to_entry
= & next
->next_entry
;
3339 next
= entry
->next_entry
;
3344 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3345 bfd_set_error (bfd_error_file_truncated
);
3349 /* Unhook NEXT from the chain. */
3350 /* FIXME: memory loss here. */
3351 entry
->next_entry
= next
->next_entry
;
3352 chain
->num_entries
--;
3353 if (chain
->num_entries
< 2)
3355 next
= next
->next_entry
;
3358 rsrc_merge (entry
, next
);
3360 else if (entry
->is_dir
!= next
->is_dir
)
3362 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3363 bfd_set_error (bfd_error_file_truncated
);
3368 /* Otherwise with identical leaves we issue an error
3369 message - because there should never be duplicates.
3370 The exception is Type 18/Name 1/Lang 0 which is the
3371 defaul manifest - this can just be dropped. */
3372 if (entry
->is_name
== FALSE
3373 && entry
->name_id
.id
== 0
3375 && dir
->entry
!= NULL
3376 && dir
->entry
->is_name
== FALSE
3377 && dir
->entry
->name_id
.id
== 1
3378 && dir
->entry
->parent
!= NULL
3379 && dir
->entry
->parent
->entry
!= NULL
3380 && dir
->entry
->parent
->entry
->is_name
== FALSE
3381 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
3383 else if (dir
!= NULL
3384 && dir
->entry
!= NULL
3385 && dir
->entry
->parent
!= NULL
3386 && dir
->entry
->parent
->entry
!= NULL
3387 && dir
->entry
->parent
->entry
->is_name
== FALSE
3388 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
3390 /* Strings need special handling. */
3391 if (! rsrc_merge_string_entries (entry
, next
))
3393 /* _bfd_error_handler should have been called inside merge_strings. */
3394 bfd_set_error (bfd_error_file_truncated
);
3401 || dir
->entry
== NULL
3402 || dir
->entry
->parent
== NULL
3403 || dir
->entry
->parent
->entry
== NULL
)
3404 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3406 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3407 rsrc_resource_name (entry
, dir
));
3408 bfd_set_error (bfd_error_file_truncated
);
3413 /* Unhook NEXT from the chain. */
3414 entry
->next_entry
= next
->next_entry
;
3415 chain
->num_entries
--;
3416 if (chain
->num_entries
< 2)
3418 next
= next
->next_entry
;
3422 points_to_entry
= & entry
->next_entry
;
3424 next
= next
->next_entry
;
3429 chain
->last_entry
= entry
;
3434 /* Attach B's chain onto A. */
3436 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
3438 if (bchain
->num_entries
== 0)
3441 achain
->num_entries
+= bchain
->num_entries
;
3443 if (achain
->first_entry
== NULL
)
3445 achain
->first_entry
= bchain
->first_entry
;
3446 achain
->last_entry
= bchain
->last_entry
;
3450 achain
->last_entry
->next_entry
= bchain
->first_entry
;
3451 achain
->last_entry
= bchain
->last_entry
;
3454 bchain
->num_entries
= 0;
3455 bchain
->first_entry
= bchain
->last_entry
= NULL
;
3459 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
3461 rsrc_directory
* adir
;
3462 rsrc_directory
* bdir
;
3464 BFD_ASSERT (a
->is_dir
);
3465 BFD_ASSERT (b
->is_dir
);
3467 adir
= a
->value
.directory
;
3468 bdir
= b
->value
.directory
;
3470 if (adir
->characteristics
!= bdir
->characteristics
)
3472 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3473 bfd_set_error (bfd_error_file_truncated
);
3477 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
3479 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3480 bfd_set_error (bfd_error_file_truncated
);
3484 /* Attach B's name chain to A. */
3485 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
3487 /* Attach B's ID chain to A. */
3488 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
3490 /* Now sort A's entries. */
3491 rsrc_sort_entries (& adir
->names
, TRUE
, adir
);
3492 rsrc_sort_entries (& adir
->ids
, FALSE
, adir
);
3495 /* Check the .rsrc section. If it contains multiple concatenated
3496 resources then we must merge them properly. Otherwise Windows
3497 will ignore all but the first set. */
3500 rsrc_process_section (bfd
* abfd
,
3501 struct coff_final_link_info
* pfinfo
)
3503 rsrc_directory new_table
;
3509 bfd_byte
* datastart
;
3511 bfd_byte
* new_data
;
3512 unsigned int num_resource_sets
;
3513 rsrc_directory
* type_tables
;
3514 rsrc_write_data write_data
;
3517 unsigned int num_input_rsrc
= 0;
3518 unsigned int max_num_input_rsrc
= 4;
3519 ptrdiff_t * rsrc_sizes
= NULL
;
3521 new_table
.names
.num_entries
= 0;
3522 new_table
.ids
.num_entries
= 0;
3524 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
3525 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
3528 pe
= pe_data (abfd
);
3532 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
3534 data
= bfd_malloc (size
);
3539 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
3542 /* Step zero: Scan the input bfds looking for .rsrc sections and record
3543 their lengths. Note - we rely upon the fact that the linker script
3544 does *not* sort the input .rsrc sections, so that the order in the
3545 linkinfo list matches the order in the output .rsrc section.
3547 We need to know the lengths because each input .rsrc section has padding
3548 at the end of a variable amount. (It does not appear to be based upon
3549 the section alignment or the file alignment). We need to skip any
3550 padding bytes when parsing the input .rsrc sections. */
3551 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
3552 if (rsrc_sizes
== NULL
)
3555 for (input
= pfinfo
->info
->input_bfds
;
3557 input
= input
->link_next
)
3559 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
3561 if (rsrc_sec
!= NULL
)
3563 if (num_input_rsrc
== max_num_input_rsrc
)
3565 max_num_input_rsrc
+= 10;
3566 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
3567 * sizeof * rsrc_sizes
);
3568 if (rsrc_sizes
== NULL
)
3572 BFD_ASSERT (rsrc_sec
->size
> 0);
3573 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
3577 if (num_input_rsrc
< 2)
3580 /* Step one: Walk the section, computing the size of the tables,
3581 leaves and data and decide if we need to do anything. */
3582 dataend
= data
+ size
;
3583 num_resource_sets
= 0;
3584 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
3586 while (data
< dataend
)
3588 bfd_byte
* p
= data
;
3590 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
3594 /* Corrupted .rsrc section - cannot merge. */
3595 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
3596 bfd_get_filename (abfd
));
3597 bfd_set_error (bfd_error_file_truncated
);
3601 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
3603 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
3604 bfd_get_filename (abfd
));
3605 bfd_set_error (bfd_error_file_truncated
);
3608 /* FIXME: Should we add a check for "data - p" being much smaller
3609 than rsrc_sizes[num_resource_sets] ? */
3611 data
= p
+ rsrc_sizes
[num_resource_sets
];
3612 rva_bias
+= data
- p
;
3613 ++ num_resource_sets
;
3615 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
3617 /* Step two: Walk the data again, building trees of the resources. */
3619 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
3621 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
3622 if (type_tables
== NULL
)
3626 while (data
< dataend
)
3628 bfd_byte
* p
= data
;
3630 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
3631 dataend
, rva_bias
, NULL
);
3632 data
= p
+ rsrc_sizes
[indx
];
3633 rva_bias
+= data
- p
;
3636 BFD_ASSERT (indx
== num_resource_sets
);
3638 /* Step three: Merge the top level tables (there can be only one).
3640 We must ensure that the merged entries are in ascending order.
3642 We also thread the top level table entries from the old tree onto
3643 the new table, so that they can be pulled off later. */
3645 /* FIXME: Should we verify that all type tables are the same ? */
3646 new_table
.characteristics
= type_tables
[0].characteristics
;
3647 new_table
.time
= type_tables
[0].time
;
3648 new_table
.major
= type_tables
[0].major
;
3649 new_table
.minor
= type_tables
[0].minor
;
3651 /* Chain the NAME entries onto the table. */
3652 new_table
.names
.first_entry
= NULL
;
3653 new_table
.names
.last_entry
= NULL
;
3655 for (indx
= 0; indx
< num_resource_sets
; indx
++)
3656 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
3658 rsrc_sort_entries (& new_table
.names
, TRUE
, & new_table
);
3660 /* Chain the ID entries onto the table. */
3661 new_table
.ids
.first_entry
= NULL
;
3662 new_table
.ids
.last_entry
= NULL
;
3664 for (indx
= 0; indx
< num_resource_sets
; indx
++)
3665 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
3667 rsrc_sort_entries (& new_table
.ids
, FALSE
, & new_table
);
3669 /* Step four: Create new contents for the .rsrc section. */
3670 new_data
= bfd_malloc (size
);
3671 if (new_data
== NULL
)
3674 write_data
.abfd
= abfd
;
3675 write_data
.datastart
= new_data
;
3676 write_data
.next_table
= new_data
;
3677 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
3678 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
3679 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
3680 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
3682 rsrc_write_directory (& write_data
, & new_table
);
3684 /* Step five: Replace the old contents with the new.
3685 We recompute the size as we may have lost entries due to mergeing. */
3686 size
= ((write_data
.next_data
- new_data
) + 3) & ~ 3;
3687 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
3688 sec
->size
= sec
->rawsize
= size
;
3691 /* Step size: Free all the memory that we have used. */
3692 /* FIXME: Free the resource tree, if we have one. */
3697 /* Handle the .idata section and other things that need symbol table
3701 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
3703 struct coff_link_hash_entry
*h1
;
3704 struct bfd_link_info
*info
= pfinfo
->info
;
3705 bfd_boolean result
= TRUE
;
3707 /* There are a few fields that need to be filled in now while we
3708 have symbol table access.
3710 The .idata subsections aren't directly available as sections, but
3711 they are in the symbol table, so get them from there. */
3713 /* The import directory. This is the address of .idata$2, with size
3714 of .idata$2 + .idata$3. */
3715 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3716 ".idata$2", FALSE
, FALSE
, TRUE
);
3719 /* PR ld/2729: We cannot rely upon all the output sections having been
3720 created properly, so check before referencing them. Issue a warning
3721 message for any sections tht could not be found. */
3722 if ((h1
->root
.type
== bfd_link_hash_defined
3723 || h1
->root
.type
== bfd_link_hash_defweak
)
3724 && h1
->root
.u
.def
.section
!= NULL
3725 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3726 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
3727 (h1
->root
.u
.def
.value
3728 + h1
->root
.u
.def
.section
->output_section
->vma
3729 + h1
->root
.u
.def
.section
->output_offset
);
3733 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
3738 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3739 ".idata$4", FALSE
, FALSE
, TRUE
);
3741 && (h1
->root
.type
== bfd_link_hash_defined
3742 || h1
->root
.type
== bfd_link_hash_defweak
)
3743 && h1
->root
.u
.def
.section
!= NULL
3744 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3745 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
3746 ((h1
->root
.u
.def
.value
3747 + h1
->root
.u
.def
.section
->output_section
->vma
3748 + h1
->root
.u
.def
.section
->output_offset
)
3749 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
3753 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
3758 /* The import address table. This is the size/address of
3760 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3761 ".idata$5", FALSE
, FALSE
, TRUE
);
3763 && (h1
->root
.type
== bfd_link_hash_defined
3764 || h1
->root
.type
== bfd_link_hash_defweak
)
3765 && h1
->root
.u
.def
.section
!= NULL
3766 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3767 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
3768 (h1
->root
.u
.def
.value
3769 + h1
->root
.u
.def
.section
->output_section
->vma
3770 + h1
->root
.u
.def
.section
->output_offset
);
3774 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
3779 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3780 ".idata$6", FALSE
, FALSE
, TRUE
);
3782 && (h1
->root
.type
== bfd_link_hash_defined
3783 || h1
->root
.type
== bfd_link_hash_defweak
)
3784 && h1
->root
.u
.def
.section
!= NULL
3785 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3786 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
3787 ((h1
->root
.u
.def
.value
3788 + h1
->root
.u
.def
.section
->output_section
->vma
3789 + h1
->root
.u
.def
.section
->output_offset
)
3790 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
3794 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
3801 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3802 "__IAT_start__", FALSE
, FALSE
, TRUE
);
3804 && (h1
->root
.type
== bfd_link_hash_defined
3805 || h1
->root
.type
== bfd_link_hash_defweak
)
3806 && h1
->root
.u
.def
.section
!= NULL
3807 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3812 (h1
->root
.u
.def
.value
3813 + h1
->root
.u
.def
.section
->output_section
->vma
3814 + h1
->root
.u
.def
.section
->output_offset
);
3816 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3817 "__IAT_end__", FALSE
, FALSE
, TRUE
);
3819 && (h1
->root
.type
== bfd_link_hash_defined
3820 || h1
->root
.type
== bfd_link_hash_defweak
)
3821 && h1
->root
.u
.def
.section
!= NULL
3822 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3824 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
3825 ((h1
->root
.u
.def
.value
3826 + h1
->root
.u
.def
.section
->output_section
->vma
3827 + h1
->root
.u
.def
.section
->output_offset
)
3829 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
3830 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
3831 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
3836 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
3837 " because .idata$6 is missing"), abfd
);
3843 h1
= coff_link_hash_lookup (coff_hash_table (info
),
3844 (bfd_get_symbol_leading_char(abfd
) != 0
3845 ? "__tls_used" : "_tls_used"),
3846 FALSE
, FALSE
, TRUE
);
3849 if ((h1
->root
.type
== bfd_link_hash_defined
3850 || h1
->root
.type
== bfd_link_hash_defweak
)
3851 && h1
->root
.u
.def
.section
!= NULL
3852 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
3853 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
3854 (h1
->root
.u
.def
.value
3855 + h1
->root
.u
.def
.section
->output_section
->vma
3856 + h1
->root
.u
.def
.section
->output_offset
3857 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
3861 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
3865 /* According to PECOFF sepcifications by Microsoft version 8.2
3866 the TLS data directory consists of 4 pointers, followed
3867 by two 4-byte integer. This implies that the total size
3868 is different for 32-bit and 64-bit executables. */
3869 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
3870 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
3872 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
3876 /* If there is a .pdata section and we have linked pdata finally, we
3877 need to sort the entries ascending. */
3878 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3880 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
3884 bfd_size_type x
= sec
->rawsize
;
3885 bfd_byte
*tmp_data
= NULL
;
3888 tmp_data
= bfd_malloc (x
);
3890 if (tmp_data
!= NULL
)
3892 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
3896 12, sort_x64_pdata
);
3897 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
3906 rsrc_process_section (abfd
, pfinfo
);
3908 /* If we couldn't find idata$2, we either have an excessively
3909 trivial program or are in DEEP trouble; we have to assume trivial