1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2017 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25 PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc. */
28 /* Hey look, some documentation [and in a place you expect to find it]!
30 The main reference for the pei format is "Microsoft Portable Executable
31 and Common Object File Format Specification 4.1". Get it if you need to
32 do some serious hacking on this code.
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
38 The *sole* difference between the pe format and the pei format is that the
39 latter has an MSDOS 2.0 .exe header on the front that prints the message
40 "This app must be run under Windows." (or some such).
41 (FIXME: Whether that statement is *really* true or not is unknown.
42 Are there more subtle differences between pe and pei formats?
43 For now assume there aren't. If you find one, then for God sakes
46 The Microsoft docs use the word "image" instead of "executable" because
47 the former can also refer to a DLL (shared library). Confusion can arise
48 because the `i' in `pei' also refers to "image". The `pe' format can
49 also create images (i.e. executables), it's just that to run on a win32
50 system you need to use the pei format.
52 FIXME: Please add more docs here so the next poor fool that has to hack
53 on this code has a chance of getting something accomplished without
54 wasting too much time. */
56 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
57 depending on whether we're compiling for straight PE or PE+. */
63 #include "coff/internal.h"
65 #include "libiberty.h"
73 /* NOTE: it's strange to be including an architecture specific header
74 in what's supposed to be general (to PE/PEI) code. However, that's
75 where the definitions are, and they don't vary per architecture
76 within PE/PEI, so we get them from there. FIXME: The lack of
77 variance is an assumption which may prove to be incorrect if new
78 PE/PEI targets are created. */
79 #if defined COFF_WITH_pex64
80 # include "coff/x86_64.h"
81 #elif defined COFF_WITH_pep
82 # include "coff/ia64.h"
84 # include "coff/i386.h"
90 #include "safe-ctype.h"
92 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
94 # define AOUTSZ PEPAOUTSZ
95 # define PEAOUTHDR PEPAOUTHDR
98 #define HighBitSet(val) ((val) & 0x80000000)
99 #define SetHighBit(val) ((val) | 0x80000000)
100 #define WithoutHighBit(val) ((val) & 0x7fffffff)
102 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
103 worked when the code was in peicode.h, but no longer work now that
104 the code is in peigen.c. PowerPC NT is said to be dead. If
105 anybody wants to revive the code, you will have to figure out how
106 to handle those issues. */
109 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
111 SYMENT *ext = (SYMENT *) ext1;
112 struct internal_syment *in = (struct internal_syment *) in1;
114 if (ext->e.e_name[0] == 0)
116 in->_n._n_n._n_zeroes = 0;
117 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
120 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
122 in->n_value = H_GET_32 (abfd, ext->e_value);
123 in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum);
125 if (sizeof (ext->e_type) == 2)
126 in->n_type = H_GET_16 (abfd, ext->e_type);
128 in->n_type = H_GET_32 (abfd, ext->e_type);
130 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
131 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
133 #ifndef STRICT_PE_FORMAT
134 /* This is for Gnu-created DLLs. */
136 /* The section symbols for the .idata$ sections have class 0x68
137 (C_SECTION), which MS documentation indicates is a section
138 symbol. Unfortunately, the value field in the symbol is simply a
139 copy of the .idata section's flags rather than something useful.
140 When these symbols are encountered, change the value to 0 so that
141 they will be handled somewhat correctly in the bfd code. */
142 if (in->n_sclass == C_SECTION)
144 char namebuf[SYMNMLEN + 1];
145 const char *name = NULL;
149 /* Create synthetic empty sections as needed. DJ */
150 if (in->n_scnum == 0)
154 name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
157 _bfd_error_handler (_("%B: unable to find name for empty section"),
159 bfd_set_error (bfd_error_invalid_target);
163 sec = bfd_get_section_by_name (abfd, name);
165 in->n_scnum = sec->target_index;
168 if (in->n_scnum == 0)
170 int unused_section_number = 0;
174 for (sec = abfd->sections; sec; sec = sec->next)
175 if (unused_section_number <= sec->target_index)
176 unused_section_number = sec->target_index + 1;
180 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
183 _bfd_error_handler (_("%B: out of memory creating name for empty section"),
187 strcpy ((char *) name, namebuf);
190 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
191 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
194 _bfd_error_handler (_("%B: unable to create fake empty section"),
203 sec->rel_filepos = 0;
204 sec->reloc_count = 0;
205 sec->line_filepos = 0;
206 sec->lineno_count = 0;
207 sec->userdata = NULL;
209 sec->alignment_power = 2;
211 sec->target_index = unused_section_number;
213 in->n_scnum = unused_section_number;
215 in->n_sclass = C_STAT;
219 #ifdef coff_swap_sym_in_hook
220 /* This won't work in peigen.c, but since it's for PPC PE, it's not
222 coff_swap_sym_in_hook (abfd, ext1, in1);
227 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
229 bfd_vma abs_val = * (bfd_vma *) data;
231 return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
235 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
237 struct internal_syment *in = (struct internal_syment *) inp;
238 SYMENT *ext = (SYMENT *) extp;
240 if (in->_n._n_name[0] == 0)
242 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
243 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
246 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
248 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
249 symbol. This is a problem on 64-bit targets where we can generate
250 absolute symbols with values >= 1^32. We try to work around this
251 problem by finding a section whose base address is sufficient to
252 reduce the absolute value to < 1^32, and then transforming the
253 symbol into a section relative symbol. This of course is a hack. */
254 if (sizeof (in->n_value) > 4
255 /* The strange computation of the shift amount is here in order to
256 avoid a compile time warning about the comparison always being
257 false. It does not matter if this test fails to work as expected
258 as the worst that can happen is that some absolute symbols are
259 needlessly converted into section relative symbols. */
260 && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)
261 && in->n_scnum == N_ABS)
265 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
268 in->n_value -= sec->vma;
269 in->n_scnum = sec->target_index;
271 /* else: FIXME: The value is outside the range of any section. This
272 happens for __image_base__ and __ImageBase and maybe some other
273 symbols as well. We should find a way to handle these values. */
276 H_PUT_32 (abfd, in->n_value, ext->e_value);
277 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
279 if (sizeof (ext->e_type) == 2)
280 H_PUT_16 (abfd, in->n_type, ext->e_type);
282 H_PUT_32 (abfd, in->n_type, ext->e_type);
284 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
285 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
291 _bfd_XXi_swap_aux_in (bfd * abfd,
295 int indx ATTRIBUTE_UNUSED,
296 int numaux ATTRIBUTE_UNUSED,
299 AUXENT *ext = (AUXENT *) ext1;
300 union internal_auxent *in = (union internal_auxent *) in1;
302 /* PR 17521: Make sure that all fields in the aux structure
304 memset (in, 0, sizeof * in);
308 if (ext->x_file.x_fname[0] == 0)
310 in->x_file.x_n.x_zeroes = 0;
311 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
314 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
322 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
323 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
324 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
325 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
326 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
327 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
333 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
334 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
336 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
339 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
340 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
344 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
345 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
346 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
347 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
348 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
349 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
350 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
351 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
356 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
360 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
361 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
366 _bfd_XXi_swap_aux_out (bfd * abfd,
370 int indx ATTRIBUTE_UNUSED,
371 int numaux ATTRIBUTE_UNUSED,
374 union internal_auxent *in = (union internal_auxent *) inp;
375 AUXENT *ext = (AUXENT *) extp;
377 memset (ext, 0, AUXESZ);
382 if (in->x_file.x_fname[0] == 0)
384 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
385 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
388 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
397 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
398 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
399 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
400 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
401 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
402 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
408 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
409 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
411 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
414 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
415 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
419 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
420 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
421 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
422 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
423 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
424 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
425 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
426 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
430 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
433 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
434 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
441 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
443 LINENO *ext = (LINENO *) ext1;
444 struct internal_lineno *in = (struct internal_lineno *) in1;
446 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
447 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
451 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
453 struct internal_lineno *in = (struct internal_lineno *) inp;
454 struct external_lineno *ext = (struct external_lineno *) outp;
455 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
457 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
462 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
466 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
467 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
468 struct internal_aouthdr *aouthdr_int
469 = (struct internal_aouthdr *) aouthdr_int1;
470 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
472 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
473 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
474 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
475 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
476 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
477 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
478 aouthdr_int->text_start =
479 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
481 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
482 /* PE32+ does not have data_start member! */
483 aouthdr_int->data_start =
484 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
485 a->BaseOfData = aouthdr_int->data_start;
488 a->Magic = aouthdr_int->magic;
489 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
490 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
491 a->SizeOfCode = aouthdr_int->tsize ;
492 a->SizeOfInitializedData = aouthdr_int->dsize ;
493 a->SizeOfUninitializedData = aouthdr_int->bsize ;
494 a->AddressOfEntryPoint = aouthdr_int->entry;
495 a->BaseOfCode = aouthdr_int->text_start;
496 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
497 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
498 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
499 a->MajorOperatingSystemVersion =
500 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
501 a->MinorOperatingSystemVersion =
502 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
503 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
504 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
505 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
506 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
507 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
508 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
509 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
510 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
511 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
512 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
513 a->SizeOfStackReserve =
514 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
515 a->SizeOfStackCommit =
516 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
517 a->SizeOfHeapReserve =
518 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
519 a->SizeOfHeapCommit =
520 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
521 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
522 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
527 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
528 if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
530 /* xgettext:c-format */
532 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
533 abfd, a->NumberOfRvaAndSizes);
534 bfd_set_error (bfd_error_bad_value);
536 /* Paranoia: If the number is corrupt, then assume that the
537 actual entries themselves might be corrupt as well. */
538 a->NumberOfRvaAndSizes = 0;
541 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
543 /* If data directory is empty, rva also should be 0. */
545 H_GET_32 (abfd, src->DataDirectory[idx][1]);
547 a->DataDirectory[idx].Size = size;
550 a->DataDirectory[idx].VirtualAddress =
551 H_GET_32 (abfd, src->DataDirectory[idx][0]);
553 a->DataDirectory[idx].VirtualAddress = 0;
556 while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
558 a->DataDirectory[idx].Size = 0;
559 a->DataDirectory[idx].VirtualAddress = 0;
564 if (aouthdr_int->entry)
566 aouthdr_int->entry += a->ImageBase;
567 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
568 aouthdr_int->entry &= 0xffffffff;
572 if (aouthdr_int->tsize)
574 aouthdr_int->text_start += a->ImageBase;
575 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
576 aouthdr_int->text_start &= 0xffffffff;
580 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
581 /* PE32+ does not have data_start member! */
582 if (aouthdr_int->dsize)
584 aouthdr_int->data_start += a->ImageBase;
585 aouthdr_int->data_start &= 0xffffffff;
590 /* These three fields are normally set up by ppc_relocate_section.
591 In the case of reading a file in, we can pick them up from the
593 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
594 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
595 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
599 /* A support function for below. */
602 add_data_entry (bfd * abfd,
603 struct internal_extra_pe_aouthdr *aout,
608 asection *sec = bfd_get_section_by_name (abfd, name);
610 /* Add import directory information if it exists. */
612 && (coff_section_data (abfd, sec) != NULL)
613 && (pei_section_data (abfd, sec) != NULL))
615 /* If data directory is empty, rva also should be 0. */
616 int size = pei_section_data (abfd, sec)->virt_size;
617 aout->DataDirectory[idx].Size = size;
621 aout->DataDirectory[idx].VirtualAddress =
622 (sec->vma - base) & 0xffffffff;
623 sec->flags |= SEC_DATA;
629 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
631 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
632 pe_data_type *pe = pe_data (abfd);
633 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
634 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
636 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
638 sa = extra->SectionAlignment;
639 fa = extra->FileAlignment;
640 ib = extra->ImageBase;
642 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
643 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
644 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
646 if (aouthdr_in->tsize)
648 aouthdr_in->text_start -= ib;
649 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
650 aouthdr_in->text_start &= 0xffffffff;
654 if (aouthdr_in->dsize)
656 aouthdr_in->data_start -= ib;
657 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
658 aouthdr_in->data_start &= 0xffffffff;
662 if (aouthdr_in->entry)
664 aouthdr_in->entry -= ib;
665 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
666 aouthdr_in->entry &= 0xffffffff;
670 #define FA(x) (((x) + fa -1 ) & (- fa))
671 #define SA(x) (((x) + sa -1 ) & (- sa))
673 /* We like to have the sizes aligned. */
674 aouthdr_in->bsize = FA (aouthdr_in->bsize);
676 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
678 add_data_entry (abfd, extra, PE_EXPORT_TABLE, ".edata", ib);
679 add_data_entry (abfd, extra, PE_RESOURCE_TABLE, ".rsrc", ib);
680 add_data_entry (abfd, extra, PE_EXCEPTION_TABLE, ".pdata", ib);
682 /* In theory we do not need to call add_data_entry for .idata$2 or
683 .idata$5. It will be done in bfd_coff_final_link where all the
684 required information is available. If however, we are not going
685 to perform a final link, eg because we have been invoked by objcopy
686 or strip, then we need to make sure that these Data Directory
687 entries are initialised properly.
689 So - we copy the input values into the output values, and then, if
690 a final link is going to be performed, it can overwrite them. */
691 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
692 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
693 extra->DataDirectory[PE_TLS_TABLE] = tls;
695 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
696 /* Until other .idata fixes are made (pending patch), the entry for
697 .idata is needed for backwards compatibility. FIXME. */
698 add_data_entry (abfd, extra, PE_IMPORT_TABLE, ".idata", ib);
700 /* For some reason, the virtual size (which is what's set by
701 add_data_entry) for .reloc is not the same as the size recorded
702 in this slot by MSVC; it doesn't seem to cause problems (so far),
703 but since it's the best we've got, use it. It does do the right
705 if (pe->has_reloc_section)
706 add_data_entry (abfd, extra, PE_BASE_RELOCATION_TABLE, ".reloc", ib);
715 for (sec = abfd->sections; sec; sec = sec->next)
717 int rounded = FA (sec->size);
719 /* The first non-zero section filepos is the header size.
720 Sections without contents will have a filepos of 0. */
722 hsize = sec->filepos;
723 if (sec->flags & SEC_DATA)
725 if (sec->flags & SEC_CODE)
727 /* The image size is the total VIRTUAL size (which is what is
728 in the virt_size field). Files have been seen (from MSVC
729 5.0 link.exe) where the file size of the .data segment is
730 quite small compared to the virtual size. Without this
731 fix, strip munges the file.
733 FIXME: We need to handle holes between sections, which may
734 happpen when we covert from another format. We just use
735 the virtual address and virtual size of the last section
736 for the image size. */
737 if (coff_section_data (abfd, sec) != NULL
738 && pei_section_data (abfd, sec) != NULL)
739 isize = (sec->vma - extra->ImageBase
740 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
743 aouthdr_in->dsize = dsize;
744 aouthdr_in->tsize = tsize;
745 extra->SizeOfHeaders = hsize;
746 extra->SizeOfImage = isize;
749 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
751 /* e.g. 219510000 is linker version 2.19 */
752 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
754 /* This piece of magic sets the "linker version" field to
756 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
757 aouthdr_out->standard.vstamp);
759 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
760 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
761 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
762 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
763 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
764 aouthdr_out->standard.text_start);
766 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
767 /* PE32+ does not have data_start member! */
768 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
769 aouthdr_out->standard.data_start);
772 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
773 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
774 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
775 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
776 aouthdr_out->MajorOperatingSystemVersion);
777 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
778 aouthdr_out->MinorOperatingSystemVersion);
779 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
780 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
781 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
782 aouthdr_out->MajorSubsystemVersion);
783 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
784 aouthdr_out->MinorSubsystemVersion);
785 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
786 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
787 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
788 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
789 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
790 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
791 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
792 aouthdr_out->SizeOfStackReserve);
793 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
794 aouthdr_out->SizeOfStackCommit);
795 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
796 aouthdr_out->SizeOfHeapReserve);
797 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
798 aouthdr_out->SizeOfHeapCommit);
799 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
800 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
801 aouthdr_out->NumberOfRvaAndSizes);
805 for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)
807 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
808 aouthdr_out->DataDirectory[idx][0]);
809 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
810 aouthdr_out->DataDirectory[idx][1]);
818 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
821 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
822 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
824 if (pe_data (abfd)->has_reloc_section
825 || pe_data (abfd)->dont_strip_reloc)
826 filehdr_in->f_flags &= ~F_RELFLG;
828 if (pe_data (abfd)->dll)
829 filehdr_in->f_flags |= F_DLL;
831 filehdr_in->pe.e_magic = DOSMAGIC;
832 filehdr_in->pe.e_cblp = 0x90;
833 filehdr_in->pe.e_cp = 0x3;
834 filehdr_in->pe.e_crlc = 0x0;
835 filehdr_in->pe.e_cparhdr = 0x4;
836 filehdr_in->pe.e_minalloc = 0x0;
837 filehdr_in->pe.e_maxalloc = 0xffff;
838 filehdr_in->pe.e_ss = 0x0;
839 filehdr_in->pe.e_sp = 0xb8;
840 filehdr_in->pe.e_csum = 0x0;
841 filehdr_in->pe.e_ip = 0x0;
842 filehdr_in->pe.e_cs = 0x0;
843 filehdr_in->pe.e_lfarlc = 0x40;
844 filehdr_in->pe.e_ovno = 0x0;
846 for (idx = 0; idx < 4; idx++)
847 filehdr_in->pe.e_res[idx] = 0x0;
849 filehdr_in->pe.e_oemid = 0x0;
850 filehdr_in->pe.e_oeminfo = 0x0;
852 for (idx = 0; idx < 10; idx++)
853 filehdr_in->pe.e_res2[idx] = 0x0;
855 filehdr_in->pe.e_lfanew = 0x80;
857 /* This next collection of data are mostly just characters. It
858 appears to be constant within the headers put on NT exes. */
859 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
860 filehdr_in->pe.dos_message[1] = 0xcd09b400;
861 filehdr_in->pe.dos_message[2] = 0x4c01b821;
862 filehdr_in->pe.dos_message[3] = 0x685421cd;
863 filehdr_in->pe.dos_message[4] = 0x70207369;
864 filehdr_in->pe.dos_message[5] = 0x72676f72;
865 filehdr_in->pe.dos_message[6] = 0x63206d61;
866 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
867 filehdr_in->pe.dos_message[8] = 0x65622074;
868 filehdr_in->pe.dos_message[9] = 0x6e757220;
869 filehdr_in->pe.dos_message[10] = 0x206e6920;
870 filehdr_in->pe.dos_message[11] = 0x20534f44;
871 filehdr_in->pe.dos_message[12] = 0x65646f6d;
872 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
873 filehdr_in->pe.dos_message[14] = 0x24;
874 filehdr_in->pe.dos_message[15] = 0x0;
875 filehdr_in->pe.nt_signature = NT_SIGNATURE;
877 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
878 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
880 /* Only use a real timestamp if the option was chosen. */
881 if ((pe_data (abfd)->insert_timestamp))
882 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
884 H_PUT_32 (abfd, 0, filehdr_out->f_timdat);
886 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
887 filehdr_out->f_symptr);
888 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
889 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
890 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
892 /* Put in extra dos header stuff. This data remains essentially
893 constant, it just has to be tacked on to the beginning of all exes
895 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
896 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
897 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
898 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
899 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
900 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
901 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
902 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
903 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
904 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
905 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
906 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
907 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
908 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
910 for (idx = 0; idx < 4; idx++)
911 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
913 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
914 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
916 for (idx = 0; idx < 10; idx++)
917 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
919 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
921 for (idx = 0; idx < 16; idx++)
922 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
923 filehdr_out->dos_message[idx]);
925 /* Also put in the NT signature. */
926 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
932 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
934 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
935 FILHDR *filehdr_out = (FILHDR *) out;
937 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
938 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
939 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
940 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
941 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
942 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
943 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
949 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
951 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
952 SCNHDR *scnhdr_ext = (SCNHDR *) out;
953 unsigned int ret = SCNHSZ;
957 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
959 PUT_SCNHDR_VADDR (abfd,
960 ((scnhdr_int->s_vaddr
961 - pe_data (abfd)->pe_opthdr.ImageBase)
963 scnhdr_ext->s_vaddr);
965 /* NT wants the size data to be rounded up to the next
966 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
968 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
970 if (bfd_pei_p (abfd))
972 ps = scnhdr_int->s_size;
978 ss = scnhdr_int->s_size;
983 if (bfd_pei_p (abfd))
984 ps = scnhdr_int->s_paddr;
988 ss = scnhdr_int->s_size;
991 PUT_SCNHDR_SIZE (abfd, ss,
994 /* s_paddr in PE is really the virtual size. */
995 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
997 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
998 scnhdr_ext->s_scnptr);
999 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
1000 scnhdr_ext->s_relptr);
1001 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
1002 scnhdr_ext->s_lnnoptr);
1005 /* Extra flags must be set when dealing with PE. All sections should also
1006 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
1007 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1008 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1009 (this is especially important when dealing with the .idata section since
1010 the addresses for routines from .dlls must be overwritten). If .reloc
1011 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1012 (0x02000000). Also, the resource data should also be read and
1015 /* FIXME: Alignment is also encoded in this field, at least on PPC and
1016 ARM-WINCE. Although - how do we get the original alignment field
1021 const char * section_name;
1022 unsigned long must_have;
1024 pe_required_section_flags;
1026 pe_required_section_flags known_sections [] =
1028 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1029 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1030 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1031 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1032 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1033 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1034 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1035 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1036 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1037 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1038 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1039 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1043 pe_required_section_flags * p;
1045 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1046 we know exactly what this specific section wants so we remove it
1047 and then allow the must_have field to add it back in if necessary.
1048 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1049 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1050 by ld --enable-auto-import (if auto-import is actually needed),
1051 by ld --omagic, or by obcopy --writable-text. */
1053 for (p = known_sections; p->section_name; p++)
1054 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1056 if (strcmp (scnhdr_int->s_name, ".text")
1057 || (bfd_get_file_flags (abfd) & WP_TEXT))
1058 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1059 scnhdr_int->s_flags |= p->must_have;
1063 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1066 if (coff_data (abfd)->link_info
1067 && ! bfd_link_relocatable (coff_data (abfd)->link_info)
1068 && ! bfd_link_pic (coff_data (abfd)->link_info)
1069 && strcmp (scnhdr_int->s_name, ".text") == 0)
1071 /* By inference from looking at MS output, the 32 bit field
1072 which is the combination of the number_of_relocs and
1073 number_of_linenos is used for the line number count in
1074 executables. A 16-bit field won't do for cc1. The MS
1075 document says that the number of relocs is zero for
1076 executables, but the 17-th bit has been observed to be there.
1077 Overflow is not an issue: a 4G-line program will overflow a
1078 bunch of other fields long before this! */
1079 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1080 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1084 if (scnhdr_int->s_nlnno <= 0xffff)
1085 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1088 /* xgettext:c-format */
1089 _bfd_error_handler (_("%B: line number overflow: 0x%lx > 0xffff"),
1090 abfd, scnhdr_int->s_nlnno);
1091 bfd_set_error (bfd_error_file_truncated);
1092 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1096 /* Although we could encode 0xffff relocs here, we do not, to be
1097 consistent with other parts of bfd. Also it lets us warn, as
1098 we should never see 0xffff here w/o having the overflow flag
1100 if (scnhdr_int->s_nreloc < 0xffff)
1101 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1104 /* PE can deal with large #s of relocs, but not here. */
1105 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1106 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1107 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1114 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1116 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1117 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1119 in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1120 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1121 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1122 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1123 in->Type = H_GET_32(abfd, ext->Type);
1124 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1125 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1126 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1130 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1132 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1133 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1135 H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1136 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1137 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1138 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1139 H_PUT_32(abfd, in->Type, ext->Type);
1140 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1141 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1142 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1144 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1148 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1152 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1155 if (bfd_bread (buffer, 256, abfd) < 4)
1158 /* Ensure null termination of filename. */
1161 cvinfo->CVSignature = H_GET_32 (abfd, buffer);
1164 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1165 && (length > sizeof (CV_INFO_PDB70)))
1167 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1169 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1171 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1172 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1173 as 16 bytes in big-endian order. */
1174 bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1175 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1176 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1177 memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1179 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1180 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1184 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1185 && (length > sizeof (CV_INFO_PDB20)))
1187 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1188 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1189 memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1190 cvinfo->SignatureLength = 4;
1191 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1200 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1202 const bfd_size_type size = sizeof (CV_INFO_PDB70) + 1;
1203 bfd_size_type written;
1204 CV_INFO_PDB70 *cvinfo70;
1207 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1210 buffer = xmalloc (size);
1211 cvinfo70 = (CV_INFO_PDB70 *) buffer;
1212 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1214 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1215 in little-endian order, followed by 8 single bytes. */
1216 bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1217 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1218 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1219 memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1221 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1222 cvinfo70->PdbFileName[0] = '\0';
1224 written = bfd_bwrite (buffer, size, abfd);
1228 return written == size ? size : 0;
1231 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1233 N_("Export Directory [.edata (or where ever we found it)]"),
1234 N_("Import Directory [parts of .idata]"),
1235 N_("Resource Directory [.rsrc]"),
1236 N_("Exception Directory [.pdata]"),
1237 N_("Security Directory"),
1238 N_("Base Relocation Directory [.reloc]"),
1239 N_("Debug Directory"),
1240 N_("Description Directory"),
1241 N_("Special Directory"),
1242 N_("Thread Storage Directory [.tls]"),
1243 N_("Load Configuration Directory"),
1244 N_("Bound Import Directory"),
1245 N_("Import Address Table Directory"),
1246 N_("Delay Import Directory"),
1247 N_("CLR Runtime Header"),
1251 #ifdef POWERPC_LE_PE
1252 /* The code for the PPC really falls in the "architecture dependent"
1253 category. However, it's not clear that anyone will ever care, so
1254 we're ignoring the issue for now; if/when PPC matters, some of this
1255 may need to go into peicode.h, or arguments passed to enable the
1256 PPC- specific code. */
1260 pe_print_idata (bfd * abfd, void * vfile)
1262 FILE *file = (FILE *) vfile;
1267 #ifdef POWERPC_LE_PE
1268 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1271 bfd_size_type datasize = 0;
1272 bfd_size_type dataoff;
1276 pe_data_type *pe = pe_data (abfd);
1277 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1281 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1283 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1285 /* Maybe the extra header isn't there. Look for the section. */
1286 section = bfd_get_section_by_name (abfd, ".idata");
1287 if (section == NULL)
1290 addr = section->vma;
1291 datasize = section->size;
1297 addr += extra->ImageBase;
1298 for (section = abfd->sections; section != NULL; section = section->next)
1300 datasize = section->size;
1301 if (addr >= section->vma && addr < section->vma + datasize)
1305 if (section == NULL)
1308 _("\nThere is an import table, but the section containing it could not be found\n"));
1311 else if (!(section->flags & SEC_HAS_CONTENTS))
1314 _("\nThere is an import table in %s, but that section has no contents\n"),
1320 /* xgettext:c-format */
1321 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1322 section->name, (unsigned long) addr);
1324 dataoff = addr - section->vma;
1326 #ifdef POWERPC_LE_PE
1327 if (rel_section != 0 && rel_section->size != 0)
1329 /* The toc address can be found by taking the starting address,
1330 which on the PPC locates a function descriptor. The
1331 descriptor consists of the function code starting address
1332 followed by the address of the toc. The starting address we
1333 get from the bfd, and the descriptor is supposed to be in the
1334 .reldata section. */
1336 bfd_vma loadable_toc_address;
1337 bfd_vma toc_address;
1338 bfd_vma start_address;
1342 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1349 offset = abfd->start_address - rel_section->vma;
1351 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1358 start_address = bfd_get_32 (abfd, data + offset);
1359 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1360 toc_address = loadable_toc_address - 32768;
1363 _("\nFunction descriptor located at the start address: %04lx\n"),
1364 (unsigned long int) (abfd->start_address));
1366 /* xgettext:c-format */
1367 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1368 start_address, loadable_toc_address, toc_address);
1375 _("\nNo reldata section! Function descriptor not decoded.\n"));
1380 _("\nThe Import Tables (interpreted %s section contents)\n"),
1384 vma: Hint Time Forward DLL First\n\
1385 Table Stamp Chain Name Thunk\n"));
1387 /* Read the whole section. Some of the fields might be before dataoff. */
1388 if (!bfd_malloc_and_get_section (abfd, section, &data))
1395 adj = section->vma - extra->ImageBase;
1397 /* Print all image import descriptors. */
1398 for (i = dataoff; i + onaline <= datasize; i += onaline)
1402 bfd_vma forward_chain;
1404 bfd_vma first_thunk;
1409 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1410 fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1411 hint_addr = bfd_get_32 (abfd, data + i);
1412 time_stamp = bfd_get_32 (abfd, data + i + 4);
1413 forward_chain = bfd_get_32 (abfd, data + i + 8);
1414 dll_name = bfd_get_32 (abfd, data + i + 12);
1415 first_thunk = bfd_get_32 (abfd, data + i + 16);
1417 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1418 (unsigned long) hint_addr,
1419 (unsigned long) time_stamp,
1420 (unsigned long) forward_chain,
1421 (unsigned long) dll_name,
1422 (unsigned long) first_thunk);
1424 if (hint_addr == 0 && first_thunk == 0)
1427 if (dll_name - adj >= section->size)
1430 dll = (char *) data + dll_name - adj;
1431 /* PR 17512 file: 078-12277-0.004. */
1432 bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1433 fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
1435 /* PR 21546: When the Hint Address is zero,
1436 we try the First Thunk instead. */
1438 hint_addr = first_thunk;
1443 asection *ft_section;
1445 bfd_size_type ft_datasize;
1449 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1451 idx = hint_addr - adj;
1453 ft_addr = first_thunk + extra->ImageBase;
1454 ft_idx = first_thunk - adj;
1455 ft_data = data + ft_idx;
1456 ft_datasize = datasize - ft_idx;
1459 if (first_thunk != hint_addr)
1461 /* Find the section which contains the first thunk. */
1462 for (ft_section = abfd->sections;
1464 ft_section = ft_section->next)
1466 if (ft_addr >= ft_section->vma
1467 && ft_addr < ft_section->vma + ft_section->size)
1471 if (ft_section == NULL)
1474 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1478 /* Now check to see if this section is the same as our current
1479 section. If it is not then we will have to load its data in. */
1480 if (ft_section != section)
1482 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1483 ft_datasize = ft_section->size - ft_idx;
1484 ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1485 if (ft_data == NULL)
1488 /* Read ft_datasize bytes starting at offset ft_idx. */
1489 if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1490 (bfd_vma) ft_idx, ft_datasize))
1499 /* Print HintName vector entries. */
1500 #ifdef COFF_WITH_pex64
1501 for (j = 0; idx + j + 8 <= datasize; j += 8)
1504 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1505 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1507 if (!member && !member_high)
1512 if (HighBitSet (member_high))
1513 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1514 member_high, member,
1515 WithoutHighBit (member_high), member);
1516 /* PR binutils/17512: Handle corrupt PE data. */
1517 else if (amt + 2 >= datasize)
1518 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1524 ordinal = bfd_get_16 (abfd, data + amt);
1525 member_name = (char *) data + amt + 2;
1526 fprintf (file, "\t%04lx\t %4d %.*s",member, ordinal,
1527 (int) (datasize - (amt + 2)), member_name);
1530 /* If the time stamp is not zero, the import address
1531 table holds actual addresses. */
1534 && first_thunk != hint_addr
1535 && j + 4 <= ft_datasize)
1536 fprintf (file, "\t%04lx",
1537 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1538 fprintf (file, "\n");
1541 for (j = 0; idx + j + 4 <= datasize; j += 4)
1544 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1546 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1551 if (HighBitSet (member))
1552 fprintf (file, "\t%04lx\t %4lu <none>",
1553 member, WithoutHighBit (member));
1554 /* PR binutils/17512: Handle corrupt PE data. */
1555 else if (amt + 2 >= datasize)
1556 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1562 ordinal = bfd_get_16 (abfd, data + amt);
1563 member_name = (char *) data + amt + 2;
1564 fprintf (file, "\t%04lx\t %4d %.*s",
1566 (int) (datasize - (amt + 2)), member_name);
1569 /* If the time stamp is not zero, the import address
1570 table holds actual addresses. */
1573 && first_thunk != hint_addr
1574 && j + 4 <= ft_datasize)
1575 fprintf (file, "\t%04lx",
1576 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1578 fprintf (file, "\n");
1585 fprintf (file, "\n");
1594 pe_print_edata (bfd * abfd, void * vfile)
1596 FILE *file = (FILE *) vfile;
1599 bfd_size_type datasize = 0;
1600 bfd_size_type dataoff;
1605 long export_flags; /* Reserved - should be zero. */
1609 bfd_vma name; /* RVA - relative to image base. */
1610 long base; /* Ordinal base. */
1611 unsigned long num_functions;/* Number in the export address table. */
1612 unsigned long num_names; /* Number in the name pointer table. */
1613 bfd_vma eat_addr; /* RVA to the export address table. */
1614 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1615 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1618 pe_data_type *pe = pe_data (abfd);
1619 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1623 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1625 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1627 /* Maybe the extra header isn't there. Look for the section. */
1628 section = bfd_get_section_by_name (abfd, ".edata");
1629 if (section == NULL)
1632 addr = section->vma;
1634 datasize = section->size;
1640 addr += extra->ImageBase;
1642 for (section = abfd->sections; section != NULL; section = section->next)
1643 if (addr >= section->vma && addr < section->vma + section->size)
1646 if (section == NULL)
1649 _("\nThere is an export table, but the section containing it could not be found\n"));
1652 else if (!(section->flags & SEC_HAS_CONTENTS))
1655 _("\nThere is an export table in %s, but that section has no contents\n"),
1660 dataoff = addr - section->vma;
1661 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1662 if (datasize > section->size - dataoff)
1665 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1671 /* PR 17512: Handle corrupt PE binaries. */
1675 /* xgettext:c-format */
1676 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1677 section->name, (int) datasize);
1681 /* xgettext:c-format */
1682 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1683 section->name, (unsigned long) addr);
1685 data = (bfd_byte *) bfd_malloc (datasize);
1689 if (! bfd_get_section_contents (abfd, section, data,
1690 (file_ptr) dataoff, datasize))
1693 /* Go get Export Directory Table. */
1694 edt.export_flags = bfd_get_32 (abfd, data + 0);
1695 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1696 edt.major_ver = bfd_get_16 (abfd, data + 8);
1697 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1698 edt.name = bfd_get_32 (abfd, data + 12);
1699 edt.base = bfd_get_32 (abfd, data + 16);
1700 edt.num_functions = bfd_get_32 (abfd, data + 20);
1701 edt.num_names = bfd_get_32 (abfd, data + 24);
1702 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1703 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1704 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1706 adj = section->vma - extra->ImageBase + dataoff;
1708 /* Dump the EDT first. */
1710 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1714 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1717 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1720 /* xgettext:c-format */
1721 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1724 _("Name \t\t\t\t"));
1725 bfd_fprintf_vma (abfd, file, edt.name);
1727 if ((edt.name >= adj) && (edt.name < adj + datasize))
1728 fprintf (file, " %.*s\n",
1729 (int) (datasize - (edt.name - adj)),
1730 data + edt.name - adj);
1732 fprintf (file, "(outside .edata section)\n");
1735 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1741 _("\tExport Address Table \t\t%08lx\n"),
1745 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1748 _("Table Addresses\n"));
1751 _("\tExport Address Table \t\t"));
1752 bfd_fprintf_vma (abfd, file, edt.eat_addr);
1753 fprintf (file, "\n");
1756 _("\tName Pointer Table \t\t"));
1757 bfd_fprintf_vma (abfd, file, edt.npt_addr);
1758 fprintf (file, "\n");
1761 _("\tOrdinal Table \t\t\t"));
1762 bfd_fprintf_vma (abfd, file, edt.ot_addr);
1763 fprintf (file, "\n");
1765 /* The next table to find is the Export Address Table. It's basically
1766 a list of pointers that either locate a function in this dll, or
1767 forward the call to another dll. Something like:
1772 } export_address_table_entry; */
1775 _("\nExport Address Table -- Ordinal Base %ld\n"),
1778 /* PR 17512: Handle corrupt PE binaries. */
1779 if (edt.eat_addr + (edt.num_functions * 4) - adj >= datasize
1780 /* PR 17512: file: 092b1829 */
1781 || (edt.num_functions * 4) < edt.num_functions
1782 /* PR 17512 file: 140-165018-0.004. */
1783 || data + edt.eat_addr - adj < data)
1784 fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1785 (long) edt.eat_addr,
1786 (long) edt.num_functions);
1787 else for (i = 0; i < edt.num_functions; ++i)
1789 bfd_vma eat_member = bfd_get_32 (abfd,
1790 data + edt.eat_addr + (i * 4) - adj);
1791 if (eat_member == 0)
1794 if (eat_member - adj <= datasize)
1796 /* This rva is to a name (forwarding function) in our section. */
1797 /* Should locate a function descriptor. */
1799 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1801 (long) (i + edt.base),
1802 (unsigned long) eat_member,
1804 (int)(datasize - (eat_member - adj)),
1805 data + eat_member - adj);
1809 /* Should locate a function descriptor in the reldata section. */
1811 "\t[%4ld] +base[%4ld] %04lx %s\n",
1813 (long) (i + edt.base),
1814 (unsigned long) eat_member,
1819 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1820 /* Dump them in parallel for clarity. */
1822 _("\n[Ordinal/Name Pointer] Table\n"));
1824 /* PR 17512: Handle corrupt PE binaries. */
1825 if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1826 /* PR 17512: file: bb68816e. */
1827 || edt.num_names * 4 < edt.num_names
1828 || (data + edt.npt_addr - adj) < data)
1829 /* xgettext:c-format */
1830 fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1831 (long) edt.npt_addr,
1832 (long) edt.num_names);
1833 /* PR 17512: file: 140-147171-0.004. */
1834 else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1835 || data + edt.ot_addr - adj < data)
1836 /* xgettext:c-format */
1837 fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1839 (long) edt.num_names);
1840 else for (i = 0; i < edt.num_names; ++i)
1845 ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1846 name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1848 if ((name_ptr - adj) >= datasize)
1850 /* xgettext:c-format */
1851 fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1852 (long) ord, (long) name_ptr);
1856 char * name = (char *) data + name_ptr - adj;
1858 fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1859 (int)((char *)(data + datasize) - name), name);
1868 /* This really is architecture dependent. On IA-64, a .pdata entry
1869 consists of three dwords containing relative virtual addresses that
1870 specify the start and end address of the code range the entry
1871 covers and the address of the corresponding unwind info data.
1873 On ARM and SH-4, a compressed PDATA structure is used :
1874 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1875 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1876 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1878 This is the version for uncompressed data. */
1881 pe_print_pdata (bfd * abfd, void * vfile)
1883 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1884 # define PDATA_ROW_SIZE (3 * 8)
1886 # define PDATA_ROW_SIZE (5 * 4)
1888 FILE *file = (FILE *) vfile;
1890 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1891 bfd_size_type datasize = 0;
1893 bfd_size_type start, stop;
1894 int onaline = PDATA_ROW_SIZE;
1897 || coff_section_data (abfd, section) == NULL
1898 || pei_section_data (abfd, section) == NULL)
1901 stop = pei_section_data (abfd, section)->virt_size;
1902 if ((stop % onaline) != 0)
1904 /* xgettext:c-format */
1905 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1906 (long) stop, onaline);
1909 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1910 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1912 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1915 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1916 \t\tAddress Address Handler Data Address Mask\n"));
1919 datasize = section->size;
1923 /* PR 17512: file: 002-193900-0.004. */
1924 if (datasize < stop)
1926 /* xgettext:c-format */
1927 fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1928 (long) stop, (long) datasize);
1932 if (! bfd_malloc_and_get_section (abfd, section, &data))
1941 for (i = start; i < stop; i += onaline)
1947 bfd_vma prolog_end_addr;
1948 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1952 if (i + PDATA_ROW_SIZE > stop)
1955 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1956 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1957 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1958 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1959 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1961 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1962 && eh_data == 0 && prolog_end_addr == 0)
1963 /* We are probably into the padding of the section now. */
1966 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1967 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1969 eh_handler &= ~(bfd_vma) 0x3;
1970 prolog_end_addr &= ~(bfd_vma) 0x3;
1973 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1974 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1975 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1976 bfd_fprintf_vma (abfd, file, eh_handler);
1977 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1979 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1980 bfd_fprintf_vma (abfd, file, prolog_end_addr);
1981 fprintf (file, " %x", em_data);
1984 #ifdef POWERPC_LE_PE
1985 if (eh_handler == 0 && eh_data != 0)
1987 /* Special bits here, although the meaning may be a little
1988 mysterious. The only one I know for sure is 0x03
1991 0x01 Register Save Millicode
1992 0x02 Register Restore Millicode
1993 0x03 Glue Code Sequence. */
1997 fprintf (file, _(" Register save millicode"));
2000 fprintf (file, _(" Register restore millicode"));
2003 fprintf (file, _(" Glue code sequence"));
2010 fprintf (file, "\n");
2016 #undef PDATA_ROW_SIZE
2019 typedef struct sym_cache
2026 slurp_symtab (bfd *abfd, sym_cache *psc)
2028 asymbol ** sy = NULL;
2031 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2037 storage = bfd_get_symtab_upper_bound (abfd);
2042 sy = (asymbol **) bfd_malloc (storage);
2047 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2048 if (psc->symcount < 0)
2054 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2059 psc->syms = slurp_symtab (abfd, psc);
2061 for (i = 0; i < psc->symcount; i++)
2063 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2064 return psc->syms[i]->name;
2071 cleanup_syms (sym_cache *psc)
2078 /* This is the version for "compressed" pdata. */
2081 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2083 # define PDATA_ROW_SIZE (2 * 4)
2084 FILE *file = (FILE *) vfile;
2085 bfd_byte *data = NULL;
2086 asection *section = bfd_get_section_by_name (abfd, ".pdata");
2087 bfd_size_type datasize = 0;
2089 bfd_size_type start, stop;
2090 int onaline = PDATA_ROW_SIZE;
2091 struct sym_cache cache = {0, 0} ;
2094 || coff_section_data (abfd, section) == NULL
2095 || pei_section_data (abfd, section) == NULL)
2098 stop = pei_section_data (abfd, section)->virt_size;
2099 if ((stop % onaline) != 0)
2101 /* xgettext:c-format */
2102 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2103 (long) stop, onaline);
2106 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2109 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2110 \t\tAddress Length Length 32b exc Handler Data\n"));
2112 datasize = section->size;
2116 if (! bfd_malloc_and_get_section (abfd, section, &data))
2125 for (i = start; i < stop; i += onaline)
2129 bfd_vma prolog_length, function_length;
2130 int flag32bit, exception_flag;
2133 if (i + PDATA_ROW_SIZE > stop)
2136 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
2137 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
2139 if (begin_addr == 0 && other_data == 0)
2140 /* We are probably into the padding of the section now. */
2143 prolog_length = (other_data & 0x000000FF);
2144 function_length = (other_data & 0x3FFFFF00) >> 8;
2145 flag32bit = (int)((other_data & 0x40000000) >> 30);
2146 exception_flag = (int)((other_data & 0x80000000) >> 31);
2149 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2150 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2151 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2152 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2153 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
2155 /* Get the exception handler's address and the data passed from the
2156 .text section. This is really the data that belongs with the .pdata
2157 but got "compressed" out for the ARM and SH4 architectures. */
2158 tsection = bfd_get_section_by_name (abfd, ".text");
2159 if (tsection && coff_section_data (abfd, tsection)
2160 && pei_section_data (abfd, tsection))
2162 bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2165 tdata = (bfd_byte *) bfd_malloc (8);
2168 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2170 bfd_vma eh, eh_data;
2172 eh = bfd_get_32 (abfd, tdata);
2173 eh_data = bfd_get_32 (abfd, tdata + 4);
2174 fprintf (file, "%08x ", (unsigned int) eh);
2175 fprintf (file, "%08x", (unsigned int) eh_data);
2178 const char *s = my_symbol_for_address (abfd, eh, &cache);
2181 fprintf (file, " (%s) ", s);
2188 fprintf (file, "\n");
2193 cleanup_syms (& cache);
2196 #undef PDATA_ROW_SIZE
2200 #define IMAGE_REL_BASED_HIGHADJ 4
2201 static const char * const tbl[] =
2215 "UNKNOWN", /* MUST be last. */
2219 pe_print_reloc (bfd * abfd, void * vfile)
2221 FILE *file = (FILE *) vfile;
2223 asection *section = bfd_get_section_by_name (abfd, ".reloc");
2226 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2230 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2232 if (! bfd_malloc_and_get_section (abfd, section, &data))
2240 end = data + section->size;
2241 while (p + 8 <= end)
2244 bfd_vma virtual_address;
2245 unsigned long number, size;
2246 bfd_byte *chunk_end;
2248 /* The .reloc section is a sequence of blocks, with a header consisting
2249 of two 32 bit quantities, followed by a number of 16 bit entries. */
2250 virtual_address = bfd_get_32 (abfd, p);
2251 size = bfd_get_32 (abfd, p + 4);
2253 number = (size - 8) / 2;
2259 /* xgettext:c-format */
2260 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2261 (unsigned long) virtual_address, size, size, number);
2263 chunk_end = p - 8 + size;
2264 if (chunk_end > end)
2267 while (p + 2 <= chunk_end)
2269 unsigned short e = bfd_get_16 (abfd, p);
2270 unsigned int t = (e & 0xF000) >> 12;
2271 int off = e & 0x0FFF;
2273 if (t >= sizeof (tbl) / sizeof (tbl[0]))
2274 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2277 /* xgettext:c-format */
2278 _("\treloc %4d offset %4x [%4lx] %s"),
2279 j, off, (unsigned long) (off + virtual_address), tbl[t]);
2284 /* HIGHADJ takes an argument, - the next record *is* the
2285 low 16 bits of addend. */
2286 if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2288 fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2293 fprintf (file, "\n");
2302 /* A data structure describing the regions of a .rsrc section.
2303 Some fields are filled in as the section is parsed. */
2305 typedef struct rsrc_regions
2307 bfd_byte * section_start;
2308 bfd_byte * section_end;
2309 bfd_byte * strings_start;
2310 bfd_byte * resource_start;
2314 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2315 rsrc_regions *, bfd_vma);
2317 /* Print the resource entry at DATA, with the text indented by INDENT.
2318 Recusively calls rsrc_print_resource_directory to print the contents
2319 of directory entries.
2320 Returns the address of the end of the data associated with the entry
2321 or section_end + 1 upon failure. */
2324 rsrc_print_resource_entries (FILE * file,
2326 unsigned int indent,
2327 bfd_boolean is_name,
2329 rsrc_regions * regions,
2332 unsigned long entry, addr, size;
2335 if (data + 8 >= regions->section_end)
2336 return regions->section_end + 1;
2338 /* xgettext:c-format */
2339 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2341 entry = (unsigned long) bfd_get_32 (abfd, data);
2346 /* Note - the documentation says that this field is an RVA value
2347 but windres appears to produce a section relative offset with
2348 the top bit set. Support both styles for now. */
2349 if (HighBitSet (entry))
2350 name = regions->section_start + WithoutHighBit (entry);
2352 name = regions->section_start + entry - rva_bias;
2354 if (name + 2 < regions->section_end && name > regions->section_start)
2358 if (regions->strings_start == NULL)
2359 regions->strings_start = name;
2361 len = bfd_get_16 (abfd, name);
2363 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2365 if (name + 2 + len * 2 < regions->section_end)
2367 /* This strange loop is to cope with multibyte characters. */
2374 /* Avoid printing control characters. */
2375 if (c > 0 && c < 32)
2376 fprintf (file, "^%c", c + 64);
2378 fprintf (file, "%.1s", name);
2383 fprintf (file, _("<corrupt string length: %#x>\n"), len);
2384 /* PR binutils/17512: Do not try to continue decoding a
2385 corrupted resource section. It is likely to end up with
2386 reams of extraneous output. FIXME: We could probably
2387 continue if we disable the printing of strings... */
2388 return regions->section_end + 1;
2393 fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2394 return regions->section_end + 1;
2398 fprintf (file, _("ID: %#08lx"), entry);
2400 entry = (long) bfd_get_32 (abfd, data + 4);
2401 fprintf (file, _(", Value: %#08lx\n"), entry);
2403 if (HighBitSet (entry))
2405 data = regions->section_start + WithoutHighBit (entry);
2406 if (data <= regions->section_start || data > regions->section_end)
2407 return regions->section_end + 1;
2409 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2410 in the resource table. We need some way to detect this. */
2411 return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2415 leaf = regions->section_start + entry;
2417 if (leaf + 16 >= regions->section_end
2418 /* PR 17512: file: 055dff7e. */
2419 || leaf < regions->section_start)
2420 return regions->section_end + 1;
2422 /* xgettext:c-format */
2423 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2424 (int) (entry), indent, " ",
2425 addr = (long) bfd_get_32 (abfd, leaf),
2426 size = (long) bfd_get_32 (abfd, leaf + 4),
2427 (int) bfd_get_32 (abfd, leaf + 8));
2429 /* Check that the reserved entry is 0. */
2430 if (bfd_get_32 (abfd, leaf + 12) != 0
2431 /* And that the data address/size is valid too. */
2432 || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2433 return regions->section_end + 1;
2435 if (regions->resource_start == NULL)
2436 regions->resource_start = regions->section_start + (addr - rva_bias);
2438 return regions->section_start + (addr - rva_bias) + size;
2441 #define max(a,b) ((a) > (b) ? (a) : (b))
2442 #define min(a,b) ((a) < (b) ? (a) : (b))
2445 rsrc_print_resource_directory (FILE * file,
2447 unsigned int indent,
2449 rsrc_regions * regions,
2452 unsigned int num_names, num_ids;
2453 bfd_byte * highest_data = data;
2455 if (data + 16 >= regions->section_end)
2456 return regions->section_end + 1;
2458 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2461 case 0: fprintf (file, "Type"); break;
2462 case 2: fprintf (file, "Name"); break;
2463 case 4: fprintf (file, "Language"); break;
2465 fprintf (file, _("<unknown directory type: %d>\n"), indent);
2466 /* FIXME: For now we end the printing here. If in the
2467 future more directory types are added to the RSRC spec
2468 then we will need to change this. */
2469 return regions->section_end + 1;
2472 /* xgettext:c-format */
2473 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2474 (int) bfd_get_32 (abfd, data),
2475 (long) bfd_get_32 (abfd, data + 4),
2476 (int) bfd_get_16 (abfd, data + 8),
2477 (int) bfd_get_16 (abfd, data + 10),
2478 num_names = (int) bfd_get_16 (abfd, data + 12),
2479 num_ids = (int) bfd_get_16 (abfd, data + 14));
2482 while (num_names --)
2484 bfd_byte * entry_end;
2486 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2487 data, regions, rva_bias);
2489 highest_data = max (highest_data, entry_end);
2490 if (entry_end >= regions->section_end)
2496 bfd_byte * entry_end;
2498 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2499 data, regions, rva_bias);
2501 highest_data = max (highest_data, entry_end);
2502 if (entry_end >= regions->section_end)
2506 return max (highest_data, data);
2509 /* Display the contents of a .rsrc section. We do not try to
2510 reproduce the resources, windres does that. Instead we dump
2511 the tables in a human readable format. */
2514 rsrc_print_section (bfd * abfd, void * vfile)
2518 FILE * file = (FILE *) vfile;
2519 bfd_size_type datasize;
2522 rsrc_regions regions;
2524 pe = pe_data (abfd);
2528 section = bfd_get_section_by_name (abfd, ".rsrc");
2529 if (section == NULL)
2531 if (!(section->flags & SEC_HAS_CONTENTS))
2534 datasize = section->size;
2538 rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2540 if (! bfd_malloc_and_get_section (abfd, section, & data))
2547 regions.section_start = data;
2548 regions.section_end = data + datasize;
2549 regions.strings_start = NULL;
2550 regions.resource_start = NULL;
2553 fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2555 while (data < regions.section_end)
2557 bfd_byte * p = data;
2559 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2561 if (data == regions.section_end + 1)
2562 fprintf (file, _("Corrupt .rsrc section detected!\n"));
2565 /* Align data before continuing. */
2566 int align = (1 << section->alignment_power) - 1;
2568 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2569 rva_bias += data - p;
2571 /* For reasons that are unclear .rsrc sections are sometimes created
2572 aligned to a 1^3 boundary even when their alignment is set at
2573 1^2. Catch that case here before we issue a spurious warning
2575 if (data == (regions.section_end - 4))
2576 data = regions.section_end;
2577 else if (data < regions.section_end)
2579 /* If the extra data is all zeros then do not complain.
2580 This is just padding so that the section meets the
2581 page size requirements. */
2582 while (++ data < regions.section_end)
2585 if (data < regions.section_end)
2586 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2591 if (regions.strings_start != NULL)
2592 fprintf (file, _(" String table starts at offset: %#03x\n"),
2593 (int) (regions.strings_start - regions.section_start));
2594 if (regions.resource_start != NULL)
2595 fprintf (file, _(" Resources start at offset: %#03x\n"),
2596 (int) (regions.resource_start - regions.section_start));
2598 free (regions.section_start);
2602 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2604 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2621 pe_print_debugdata (bfd * abfd, void * vfile)
2623 FILE *file = (FILE *) vfile;
2624 pe_data_type *pe = pe_data (abfd);
2625 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2628 bfd_size_type dataoff;
2631 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2632 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2637 addr += extra->ImageBase;
2638 for (section = abfd->sections; section != NULL; section = section->next)
2640 if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2644 if (section == NULL)
2647 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2650 else if (!(section->flags & SEC_HAS_CONTENTS))
2653 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2657 else if (section->size < size)
2660 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2665 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2666 section->name, (unsigned long) addr);
2668 dataoff = addr - section->vma;
2670 if (size > (section->size - dataoff))
2672 fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2677 _("Type Size Rva Offset\n"));
2679 /* Read the whole section. */
2680 if (!bfd_malloc_and_get_section (abfd, section, &data))
2687 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2689 const char *type_name;
2690 struct external_IMAGE_DEBUG_DIRECTORY *ext
2691 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2692 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2694 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2696 if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2697 type_name = debug_type_names[0];
2699 type_name = debug_type_names[idd.Type];
2701 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
2702 idd.Type, type_name, idd.SizeOfData,
2703 idd.AddressOfRawData, idd.PointerToRawData);
2705 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2707 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2708 /* PR 17512: file: 065-29434-0.001:0.1
2709 We need to use a 32-bit aligned buffer
2710 to safely read in a codeview record. */
2711 char buffer[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO);
2713 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2715 /* The debug entry doesn't have to have to be in a section,
2716 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2717 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2718 idd.SizeOfData, cvinfo))
2721 for (i = 0; i < cvinfo->SignatureLength; i++)
2722 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2724 /* xgettext:c-format */
2725 fprintf (file, _("(format %c%c%c%c signature %s age %ld)\n"),
2726 buffer[0], buffer[1], buffer[2], buffer[3],
2727 signature, cvinfo->Age);
2731 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2733 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2738 /* Print out the program headers. */
2741 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2743 FILE *file = (FILE *) vfile;
2745 pe_data_type *pe = pe_data (abfd);
2746 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2747 const char *subsystem_name = NULL;
2750 /* The MS dumpbin program reportedly ands with 0xff0f before
2751 printing the characteristics field. Not sure why. No reason to
2753 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2755 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2756 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2757 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2758 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2759 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2760 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2761 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2762 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2763 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2764 PF (IMAGE_FILE_SYSTEM, "system file");
2765 PF (IMAGE_FILE_DLL, "DLL");
2766 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2769 /* ctime implies '\n'. */
2771 time_t t = pe->coff.timestamp;
2772 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2775 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2776 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2778 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2779 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2781 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2782 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2787 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2790 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2793 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2800 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2802 fprintf (file, "\t(%s)",name);
2803 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2804 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2805 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2806 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2807 (unsigned long) i->SizeOfInitializedData);
2808 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2809 (unsigned long) i->SizeOfUninitializedData);
2810 fprintf (file, "AddressOfEntryPoint\t");
2811 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2812 fprintf (file, "\nBaseOfCode\t\t");
2813 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2814 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2815 /* PE32+ does not have BaseOfData member! */
2816 fprintf (file, "\nBaseOfData\t\t");
2817 bfd_fprintf_vma (abfd, file, i->BaseOfData);
2820 fprintf (file, "\nImageBase\t\t");
2821 bfd_fprintf_vma (abfd, file, i->ImageBase);
2822 fprintf (file, "\nSectionAlignment\t");
2823 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2824 fprintf (file, "\nFileAlignment\t\t");
2825 bfd_fprintf_vma (abfd, file, i->FileAlignment);
2826 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2827 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2828 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2829 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2830 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2831 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2832 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2833 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2834 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2835 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2837 switch (i->Subsystem)
2839 case IMAGE_SUBSYSTEM_UNKNOWN:
2840 subsystem_name = "unspecified";
2842 case IMAGE_SUBSYSTEM_NATIVE:
2843 subsystem_name = "NT native";
2845 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2846 subsystem_name = "Windows GUI";
2848 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2849 subsystem_name = "Windows CUI";
2851 case IMAGE_SUBSYSTEM_POSIX_CUI:
2852 subsystem_name = "POSIX CUI";
2854 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2855 subsystem_name = "Wince CUI";
2857 // These are from UEFI Platform Initialization Specification 1.1.
2858 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2859 subsystem_name = "EFI application";
2861 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2862 subsystem_name = "EFI boot service driver";
2864 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2865 subsystem_name = "EFI runtime driver";
2867 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2868 subsystem_name = "SAL runtime driver";
2870 // This is from revision 8.0 of the MS PE/COFF spec
2871 case IMAGE_SUBSYSTEM_XBOX:
2872 subsystem_name = "XBOX";
2874 // Added default case for clarity - subsystem_name is NULL anyway.
2876 subsystem_name = NULL;
2879 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2881 fprintf (file, "\t(%s)", subsystem_name);
2882 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2883 fprintf (file, "SizeOfStackReserve\t");
2884 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2885 fprintf (file, "\nSizeOfStackCommit\t");
2886 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2887 fprintf (file, "\nSizeOfHeapReserve\t");
2888 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2889 fprintf (file, "\nSizeOfHeapCommit\t");
2890 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2891 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2892 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2893 (unsigned long) i->NumberOfRvaAndSizes);
2895 fprintf (file, "\nThe Data Directory\n");
2896 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2898 fprintf (file, "Entry %1x ", j);
2899 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2900 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2901 fprintf (file, "%s\n", dir_names[j]);
2904 pe_print_idata (abfd, vfile);
2905 pe_print_edata (abfd, vfile);
2906 if (bfd_coff_have_print_pdata (abfd))
2907 bfd_coff_print_pdata (abfd, vfile);
2909 pe_print_pdata (abfd, vfile);
2910 pe_print_reloc (abfd, vfile);
2911 pe_print_debugdata (abfd, file);
2913 rsrc_print_section (abfd, vfile);
2919 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2921 bfd_vma addr = * (bfd_vma *) obj;
2922 return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2926 find_section_by_vma (bfd *abfd, bfd_vma addr)
2928 return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2931 /* Copy any private info we understand from the input bfd
2932 to the output bfd. */
2935 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2937 pe_data_type *ipe, *ope;
2939 /* One day we may try to grok other private data. */
2940 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2941 || obfd->xvec->flavour != bfd_target_coff_flavour)
2944 ipe = pe_data (ibfd);
2945 ope = pe_data (obfd);
2947 /* pe_opthdr is copied in copy_object. */
2948 ope->dll = ipe->dll;
2950 /* Don't copy input subsystem if output is different from input. */
2951 if (obfd->xvec != ibfd->xvec)
2952 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2954 /* For strip: if we removed .reloc, we'll make a real mess of things
2955 if we don't remove this entry as well. */
2956 if (! pe_data (obfd)->has_reloc_section)
2958 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2959 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2962 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2963 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2965 if (! pe_data (ibfd)->has_reloc_section
2966 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2967 pe_data (obfd)->dont_strip_reloc = 1;
2969 /* The file offsets contained in the debug directory need rewriting. */
2970 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2972 bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2973 + ope->pe_opthdr.ImageBase;
2974 asection *section = find_section_by_vma (obfd, addr);
2977 if (section && bfd_malloc_and_get_section (obfd, section, &data))
2980 struct external_IMAGE_DEBUG_DIRECTORY *dd =
2981 (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2983 /* PR 17512: file: 0f15796a. */
2984 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size + (addr - section->vma)
2985 > bfd_get_section_size (section))
2987 /* xgettext:c-format */
2988 _bfd_error_handler (_("%B: Data Directory size (%lx) exceeds space left in section (%lx)"),
2989 obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
2990 bfd_get_section_size (section) - (addr - section->vma));
2994 for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2995 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2997 asection *ddsection;
2998 struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
2999 struct internal_IMAGE_DEBUG_DIRECTORY idd;
3001 _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
3003 if (idd.AddressOfRawData == 0)
3004 continue; /* RVA 0 means only offset is valid, not handled yet. */
3006 ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
3008 continue; /* Not in a section! */
3010 idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
3011 + ope->pe_opthdr.ImageBase) - ddsection->vma;
3013 _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
3016 if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
3018 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
3024 _bfd_error_handler (_("%B: Failed to read debug data section"), obfd);
3032 /* Copy private section data. */
3035 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
3040 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
3041 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
3044 if (coff_section_data (ibfd, isec) != NULL
3045 && pei_section_data (ibfd, isec) != NULL)
3047 if (coff_section_data (obfd, osec) == NULL)
3049 bfd_size_type amt = sizeof (struct coff_section_tdata);
3050 osec->used_by_bfd = bfd_zalloc (obfd, amt);
3051 if (osec->used_by_bfd == NULL)
3055 if (pei_section_data (obfd, osec) == NULL)
3057 bfd_size_type amt = sizeof (struct pei_section_tdata);
3058 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
3059 if (coff_section_data (obfd, osec)->tdata == NULL)
3063 pei_section_data (obfd, osec)->virt_size =
3064 pei_section_data (ibfd, isec)->virt_size;
3065 pei_section_data (obfd, osec)->pe_flags =
3066 pei_section_data (ibfd, isec)->pe_flags;
3073 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
3075 coff_get_symbol_info (abfd, symbol, ret);
3078 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3080 sort_x64_pdata (const void *l, const void *r)
3082 const char *lp = (const char *) l;
3083 const char *rp = (const char *) r;
3085 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
3087 return (vl < vr ? -1 : 1);
3088 /* We compare just begin address. */
3093 /* Functions to process a .rsrc section. */
3095 static unsigned int sizeof_leaves;
3096 static unsigned int sizeof_strings;
3097 static unsigned int sizeof_tables_and_entries;
3100 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3103 rsrc_count_entries (bfd * abfd,
3104 bfd_boolean is_name,
3105 bfd_byte * datastart,
3110 unsigned long entry, addr, size;
3112 if (data + 8 >= dataend)
3119 entry = (long) bfd_get_32 (abfd, data);
3121 if (HighBitSet (entry))
3122 name = datastart + WithoutHighBit (entry);
3124 name = datastart + entry - rva_bias;
3126 if (name + 2 >= dataend || name < datastart)
3129 unsigned int len = bfd_get_16 (abfd, name);
3130 if (len == 0 || len > 256)
3134 entry = (long) bfd_get_32 (abfd, data + 4);
3136 if (HighBitSet (entry))
3138 data = datastart + WithoutHighBit (entry);
3140 if (data <= datastart || data >= dataend)
3143 return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3146 if (datastart + entry + 16 >= dataend)
3149 addr = (long) bfd_get_32 (abfd, datastart + entry);
3150 size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3152 return datastart + addr - rva_bias + size;
3156 rsrc_count_directory (bfd * abfd,
3157 bfd_byte * datastart,
3162 unsigned int num_entries, num_ids;
3163 bfd_byte * highest_data = data;
3165 if (data + 16 >= dataend)
3168 num_entries = (int) bfd_get_16 (abfd, data + 12);
3169 num_ids = (int) bfd_get_16 (abfd, data + 14);
3171 num_entries += num_ids;
3175 while (num_entries --)
3177 bfd_byte * entry_end;
3179 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3180 datastart, data, dataend, rva_bias);
3182 highest_data = max (highest_data, entry_end);
3183 if (entry_end >= dataend)
3187 return max (highest_data, data);
3190 typedef struct rsrc_dir_chain
3192 unsigned int num_entries;
3193 struct rsrc_entry * first_entry;
3194 struct rsrc_entry * last_entry;
3197 typedef struct rsrc_directory
3199 unsigned int characteristics;
3204 rsrc_dir_chain names;
3207 struct rsrc_entry * entry;
3210 typedef struct rsrc_string
3216 typedef struct rsrc_leaf
3219 unsigned int codepage;
3223 typedef struct rsrc_entry
3225 bfd_boolean is_name;
3229 struct rsrc_string name;
3235 struct rsrc_directory * directory;
3236 struct rsrc_leaf * leaf;
3239 struct rsrc_entry * next_entry;
3240 struct rsrc_directory * parent;
3244 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3245 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3248 rsrc_parse_entry (bfd * abfd,
3249 bfd_boolean is_name,
3251 bfd_byte * datastart,
3255 rsrc_directory * parent)
3257 unsigned long val, addr, size;
3259 val = bfd_get_32 (abfd, data);
3261 entry->parent = parent;
3262 entry->is_name = is_name;
3268 if (HighBitSet (val))
3270 val = WithoutHighBit (val);
3272 address = datastart + val;
3276 address = datastart + val - rva_bias;
3279 if (address + 3 > dataend)
3282 entry->name_id.name.len = bfd_get_16 (abfd, address);
3283 entry->name_id.name.string = address + 2;
3286 entry->name_id.id = val;
3288 val = bfd_get_32 (abfd, data + 4);
3290 if (HighBitSet (val))
3292 entry->is_dir = TRUE;
3293 entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3294 if (entry->value.directory == NULL)
3297 return rsrc_parse_directory (abfd, entry->value.directory,
3299 datastart + WithoutHighBit (val),
3300 dataend, rva_bias, entry);
3303 entry->is_dir = FALSE;
3304 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3305 if (entry->value.leaf == NULL)
3308 data = datastart + val;
3309 if (data < datastart || data >= dataend)
3312 addr = bfd_get_32 (abfd, data);
3313 size = entry->value.leaf->size = bfd_get_32 (abfd, data + 4);
3314 entry->value.leaf->codepage = bfd_get_32 (abfd, data + 8);
3315 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3317 entry->value.leaf->data = bfd_malloc (size);
3318 if (entry->value.leaf->data == NULL)
3321 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3322 return datastart + (addr - rva_bias) + size;
3326 rsrc_parse_entries (bfd * abfd,
3327 rsrc_dir_chain * chain,
3328 bfd_boolean is_name,
3329 bfd_byte * highest_data,
3330 bfd_byte * datastart,
3334 rsrc_directory * parent)
3339 if (chain->num_entries == 0)
3341 chain->first_entry = chain->last_entry = NULL;
3342 return highest_data;
3345 entry = bfd_malloc (sizeof * entry);
3349 chain->first_entry = entry;
3351 for (i = chain->num_entries; i--;)
3353 bfd_byte * entry_end;
3355 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3356 data, dataend, rva_bias, parent);
3358 highest_data = max (entry_end, highest_data);
3359 if (entry_end > dataend)
3364 entry->next_entry = bfd_malloc (sizeof * entry);
3365 entry = entry->next_entry;
3370 entry->next_entry = NULL;
3373 chain->last_entry = entry;
3375 return highest_data;
3379 rsrc_parse_directory (bfd * abfd,
3380 rsrc_directory * table,
3381 bfd_byte * datastart,
3387 bfd_byte * highest_data = data;
3392 table->characteristics = bfd_get_32 (abfd, data);
3393 table->time = bfd_get_32 (abfd, data + 4);
3394 table->major = bfd_get_16 (abfd, data + 8);
3395 table->minor = bfd_get_16 (abfd, data + 10);
3396 table->names.num_entries = bfd_get_16 (abfd, data + 12);
3397 table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3398 table->entry = entry;
3402 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3403 datastart, data, dataend, rva_bias, table);
3404 data += table->names.num_entries * 8;
3406 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3407 datastart, data, dataend, rva_bias, table);
3408 data += table->ids.num_entries * 8;
3410 return max (highest_data, data);
3413 typedef struct rsrc_write_data
3416 bfd_byte * datastart;
3417 bfd_byte * next_table;
3418 bfd_byte * next_leaf;
3419 bfd_byte * next_string;
3420 bfd_byte * next_data;
3425 rsrc_write_string (rsrc_write_data * data,
3426 rsrc_string * string)
3428 bfd_put_16 (data->abfd, string->len, data->next_string);
3429 memcpy (data->next_string + 2, string->string, string->len * 2);
3430 data->next_string += (string->len + 1) * 2;
3433 static inline unsigned int
3434 rsrc_compute_rva (rsrc_write_data * data,
3437 return (addr - data->datastart) + data->rva_bias;
3441 rsrc_write_leaf (rsrc_write_data * data,
3444 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3446 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4);
3447 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3448 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3449 data->next_leaf += 16;
3451 memcpy (data->next_data, leaf->data, leaf->size);
3452 /* An undocumented feature of Windows resources is that each unit
3453 of raw data is 8-byte aligned... */
3454 data->next_data += ((leaf->size + 7) & ~7);
3457 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3460 rsrc_write_entry (rsrc_write_data * data,
3466 bfd_put_32 (data->abfd,
3467 SetHighBit (data->next_string - data->datastart),
3469 rsrc_write_string (data, & entry->name_id.name);
3472 bfd_put_32 (data->abfd, entry->name_id.id, where);
3476 bfd_put_32 (data->abfd,
3477 SetHighBit (data->next_table - data->datastart),
3479 rsrc_write_directory (data, entry->value.directory);
3483 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3484 rsrc_write_leaf (data, entry->value.leaf);
3489 rsrc_compute_region_sizes (rsrc_directory * dir)
3491 struct rsrc_entry * entry;
3496 sizeof_tables_and_entries += 16;
3498 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3500 sizeof_tables_and_entries += 8;
3502 sizeof_strings += (entry->name_id.name.len + 1) * 2;
3505 rsrc_compute_region_sizes (entry->value.directory);
3507 sizeof_leaves += 16;
3510 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3512 sizeof_tables_and_entries += 8;
3515 rsrc_compute_region_sizes (entry->value.directory);
3517 sizeof_leaves += 16;
3522 rsrc_write_directory (rsrc_write_data * data,
3523 rsrc_directory * dir)
3527 bfd_byte * next_entry;
3530 bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3531 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3532 bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3533 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3534 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3535 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3537 /* Compute where the entries and the next table will be placed. */
3538 next_entry = data->next_table + 16;
3539 data->next_table = next_entry + (dir->names.num_entries * 8)
3540 + (dir->ids.num_entries * 8);
3541 nt = data->next_table;
3543 /* Write the entries. */
3544 for (i = dir->names.num_entries, entry = dir->names.first_entry;
3545 i > 0 && entry != NULL;
3546 i--, entry = entry->next_entry)
3548 BFD_ASSERT (entry->is_name);
3549 rsrc_write_entry (data, next_entry, entry);
3552 BFD_ASSERT (i == 0);
3553 BFD_ASSERT (entry == NULL);
3555 for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3556 i > 0 && entry != NULL;
3557 i--, entry = entry->next_entry)
3559 BFD_ASSERT (! entry->is_name);
3560 rsrc_write_entry (data, next_entry, entry);
3563 BFD_ASSERT (i == 0);
3564 BFD_ASSERT (entry == NULL);
3565 BFD_ASSERT (nt == next_entry);
3568 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3569 /* Return the length (number of units) of the first character in S,
3570 putting its 'ucs4_t' representation in *PUC. */
3573 #if defined HAVE_WCTYPE_H
3574 u16_mbtouc (wint_t * puc, const unsigned short * s, unsigned int n)
3576 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3579 unsigned short c = * s;
3581 if (c < 0xd800 || c >= 0xe000)
3591 if (s[1] >= 0xdc00 && s[1] < 0xe000)
3593 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3599 /* Incomplete multibyte character. */
3605 /* Invalid multibyte character. */
3609 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3611 /* Perform a comparison of two entries. */
3613 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3622 return a->name_id.id - b->name_id.id;
3624 /* We have to perform a case insenstive, unicode string comparison... */
3625 astring = a->name_id.name.string;
3626 alen = a->name_id.name.len;
3627 bstring = b->name_id.name.string;
3628 blen = b->name_id.name.len;
3630 #if defined __CYGWIN__ || defined __MINGW32__
3631 /* Under Windows hosts (both Cygwin and Mingw types),
3632 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3633 function however goes by different names in the two environments... */
3637 #define rscpcmp wcsncasecmp
3640 #define rscpcmp wcsnicmp
3643 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3646 #elif defined HAVE_WCHAR_H
3651 for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3653 #if defined HAVE_WCTYPE_H
3661 /* Convert UTF-16 unicode characters into wchar_t characters
3662 so that we can then perform a case insensitive comparison. */
3663 unsigned int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3664 unsigned int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3669 #ifdef HAVE_WCTYPE_H
3670 awc = towlower (awc);
3671 bwc = towlower (bwc);
3675 res = wcsncasecmp (& awc, & bwc, 1);
3682 /* Do the best we can - a case sensitive, untranslated comparison. */
3683 res = memcmp (astring, bstring, min (alen, blen) * 2);
3693 rsrc_print_name (char * buffer, rsrc_string string)
3696 bfd_byte * name = string.string;
3698 for (i = string.len; i--; name += 2)
3699 sprintf (buffer + strlen (buffer), "%.1s", name);
3703 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3705 static char buffer [256];
3706 bfd_boolean is_string = FALSE;
3710 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3711 && dir->entry->parent->entry != NULL)
3713 strcpy (buffer, "type: ");
3714 if (dir->entry->parent->entry->is_name)
3715 rsrc_print_name (buffer + strlen (buffer),
3716 dir->entry->parent->entry->name_id.name);
3719 unsigned int id = dir->entry->parent->entry->name_id.id;
3721 sprintf (buffer + strlen (buffer), "%x", id);
3724 case 1: strcat (buffer, " (CURSOR)"); break;
3725 case 2: strcat (buffer, " (BITMAP)"); break;
3726 case 3: strcat (buffer, " (ICON)"); break;
3727 case 4: strcat (buffer, " (MENU)"); break;
3728 case 5: strcat (buffer, " (DIALOG)"); break;
3729 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3730 case 7: strcat (buffer, " (FONTDIR)"); break;
3731 case 8: strcat (buffer, " (FONT)"); break;
3732 case 9: strcat (buffer, " (ACCELERATOR)"); break;
3733 case 10: strcat (buffer, " (RCDATA)"); break;
3734 case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3735 case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3736 case 14: strcat (buffer, " (GROUP_ICON)"); break;
3737 case 16: strcat (buffer, " (VERSION)"); break;
3738 case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3739 case 19: strcat (buffer, " (PLUGPLAY)"); break;
3740 case 20: strcat (buffer, " (VXD)"); break;
3741 case 21: strcat (buffer, " (ANICURSOR)"); break;
3742 case 22: strcat (buffer, " (ANIICON)"); break;
3743 case 23: strcat (buffer, " (HTML)"); break;
3744 case 24: strcat (buffer, " (MANIFEST)"); break;
3745 case 240: strcat (buffer, " (DLGINIT)"); break;
3746 case 241: strcat (buffer, " (TOOLBAR)"); break;
3751 if (dir != NULL && dir->entry != NULL)
3753 strcat (buffer, " name: ");
3754 if (dir->entry->is_name)
3755 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3758 unsigned int id = dir->entry->name_id.id;
3760 sprintf (buffer + strlen (buffer), "%x", id);
3763 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3764 (id - 1) << 4, (id << 4) - 1);
3770 strcat (buffer, " lang: ");
3773 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3775 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3781 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3782 their ID is stored in the NAME entry. The bottom four bits are used as
3783 an index into unicode string table that makes up the data of the leaf.
3784 So identical type-name-lang string resources may not actually be
3787 This function is called when we have detected two string resources with
3788 match top-28-bit IDs. We have to scan the string tables inside the leaves
3789 and discover if there are any real collisions. If there are then we report
3790 them and return FALSE. Otherwise we copy any strings from B into A and
3791 then return TRUE. */
3794 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3795 rsrc_entry * b ATTRIBUTE_UNUSED)
3797 unsigned int copy_needed = 0;
3801 bfd_byte * new_data;
3804 /* Step one: Find out what we have to do. */
3805 BFD_ASSERT (! a->is_dir);
3806 astring = a->value.leaf->data;
3808 BFD_ASSERT (! b->is_dir);
3809 bstring = b->value.leaf->data;
3811 for (i = 0; i < 16; i++)
3813 unsigned int alen = astring[0] + (astring[1] << 8);
3814 unsigned int blen = bstring[0] + (bstring[1] << 8);
3818 copy_needed += blen * 2;
3822 else if (alen != blen)
3823 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3825 /* alen == blen != 0. We might have two identical strings. If so we
3826 can ignore the second one. There is no need for wchar_t vs UTF-16
3827 theatrics here - we are only interested in (case sensitive) equality. */
3828 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3831 astring += (alen + 1) * 2;
3832 bstring += (blen + 1) * 2;
3837 if (a->parent != NULL
3838 && a->parent->entry != NULL
3839 && !a->parent->entry->is_name)
3840 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3841 ((a->parent->entry->name_id.id - 1) << 4) + i);
3845 if (copy_needed == 0)
3848 /* If we reach here then A and B must both have non-colliding strings.
3849 (We never get string resources with fully empty string tables).
3850 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3852 new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3853 if (new_data == NULL)
3857 astring = a->value.leaf->data;
3858 bstring = b->value.leaf->data;
3860 for (i = 0; i < 16; i++)
3862 unsigned int alen = astring[0] + (astring[1] << 8);
3863 unsigned int blen = bstring[0] + (bstring[1] << 8);
3867 memcpy (nstring, astring, (alen + 1) * 2);
3868 nstring += (alen + 1) * 2;
3872 memcpy (nstring, bstring, (blen + 1) * 2);
3873 nstring += (blen + 1) * 2;
3881 astring += (alen + 1) * 2;
3882 bstring += (blen + 1) * 2;
3885 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3887 free (a->value.leaf->data);
3888 a->value.leaf->data = new_data;
3889 a->value.leaf->size += copy_needed;
3894 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3896 /* Sort the entries in given part of the directory.
3897 We use an old fashioned bubble sort because we are dealing
3898 with lists and we want to handle matches specially. */
3901 rsrc_sort_entries (rsrc_dir_chain * chain,
3902 bfd_boolean is_name,
3903 rsrc_directory * dir)
3907 rsrc_entry ** points_to_entry;
3908 bfd_boolean swapped;
3910 if (chain->num_entries < 2)
3916 points_to_entry = & chain->first_entry;
3917 entry = * points_to_entry;
3918 next = entry->next_entry;
3922 signed int cmp = rsrc_cmp (is_name, entry, next);
3926 entry->next_entry = next->next_entry;
3927 next->next_entry = entry;
3928 * points_to_entry = next;
3929 points_to_entry = & next->next_entry;
3930 next = entry->next_entry;
3935 if (entry->is_dir && next->is_dir)
3937 /* When we encounter identical directory entries we have to
3938 merge them together. The exception to this rule is for
3939 resource manifests - there can only be one of these,
3940 even if they differ in language. Zero-language manifests
3941 are assumed to be default manifests (provided by the
3942 Cygwin/MinGW build system) and these can be silently dropped,
3943 unless that would reduce the number of manifests to zero.
3944 There should only ever be one non-zero lang manifest -
3945 if there are more it is an error. A non-zero lang
3946 manifest takes precedence over a default manifest. */
3948 && entry->name_id.id == 1
3950 && dir->entry != NULL
3951 && !dir->entry->is_name
3952 && dir->entry->name_id.id == 0x18)
3954 if (next->value.directory->names.num_entries == 0
3955 && next->value.directory->ids.num_entries == 1
3956 && !next->value.directory->ids.first_entry->is_name
3957 && next->value.directory->ids.first_entry->name_id.id == 0)
3958 /* Fall through so that NEXT is dropped. */
3960 else if (entry->value.directory->names.num_entries == 0
3961 && entry->value.directory->ids.num_entries == 1
3962 && !entry->value.directory->ids.first_entry->is_name
3963 && entry->value.directory->ids.first_entry->name_id.id == 0)
3965 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3966 entry->next_entry = next->next_entry;
3967 next->next_entry = entry;
3968 * points_to_entry = next;
3969 points_to_entry = & next->next_entry;
3970 next = entry->next_entry;
3975 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3976 bfd_set_error (bfd_error_file_truncated);
3980 /* Unhook NEXT from the chain. */
3981 /* FIXME: memory loss here. */
3982 entry->next_entry = next->next_entry;
3983 chain->num_entries --;
3984 if (chain->num_entries < 2)
3986 next = next->next_entry;
3989 rsrc_merge (entry, next);
3991 else if (entry->is_dir != next->is_dir)
3993 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3994 bfd_set_error (bfd_error_file_truncated);
3999 /* Otherwise with identical leaves we issue an error
4000 message - because there should never be duplicates.
4001 The exception is Type 18/Name 1/Lang 0 which is the
4002 defaul manifest - this can just be dropped. */
4004 && entry->name_id.id == 0
4006 && dir->entry != NULL
4007 && !dir->entry->is_name
4008 && dir->entry->name_id.id == 1
4009 && dir->entry->parent != NULL
4010 && dir->entry->parent->entry != NULL
4011 && !dir->entry->parent->entry->is_name
4012 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
4014 else if (dir != NULL
4015 && dir->entry != NULL
4016 && dir->entry->parent != NULL
4017 && dir->entry->parent->entry != NULL
4018 && !dir->entry->parent->entry->is_name
4019 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
4021 /* Strings need special handling. */
4022 if (! rsrc_merge_string_entries (entry, next))
4024 /* _bfd_error_handler should have been called inside merge_strings. */
4025 bfd_set_error (bfd_error_file_truncated);
4032 || dir->entry == NULL
4033 || dir->entry->parent == NULL
4034 || dir->entry->parent->entry == NULL)
4035 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4037 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4038 rsrc_resource_name (entry, dir));
4039 bfd_set_error (bfd_error_file_truncated);
4044 /* Unhook NEXT from the chain. */
4045 entry->next_entry = next->next_entry;
4046 chain->num_entries --;
4047 if (chain->num_entries < 2)
4049 next = next->next_entry;
4053 points_to_entry = & entry->next_entry;
4055 next = next->next_entry;
4060 chain->last_entry = entry;
4065 /* Attach B's chain onto A. */
4067 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
4069 if (bchain->num_entries == 0)
4072 achain->num_entries += bchain->num_entries;
4074 if (achain->first_entry == NULL)
4076 achain->first_entry = bchain->first_entry;
4077 achain->last_entry = bchain->last_entry;
4081 achain->last_entry->next_entry = bchain->first_entry;
4082 achain->last_entry = bchain->last_entry;
4085 bchain->num_entries = 0;
4086 bchain->first_entry = bchain->last_entry = NULL;
4090 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
4092 rsrc_directory * adir;
4093 rsrc_directory * bdir;
4095 BFD_ASSERT (a->is_dir);
4096 BFD_ASSERT (b->is_dir);
4098 adir = a->value.directory;
4099 bdir = b->value.directory;
4101 if (adir->characteristics != bdir->characteristics)
4103 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
4104 bfd_set_error (bfd_error_file_truncated);
4108 if (adir->major != bdir->major || adir->minor != bdir->minor)
4110 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
4111 bfd_set_error (bfd_error_file_truncated);
4115 /* Attach B's name chain to A. */
4116 rsrc_attach_chain (& adir->names, & bdir->names);
4118 /* Attach B's ID chain to A. */
4119 rsrc_attach_chain (& adir->ids, & bdir->ids);
4121 /* Now sort A's entries. */
4122 rsrc_sort_entries (& adir->names, TRUE, adir);
4123 rsrc_sort_entries (& adir->ids, FALSE, adir);
4126 /* Check the .rsrc section. If it contains multiple concatenated
4127 resources then we must merge them properly. Otherwise Windows
4128 will ignore all but the first set. */
4131 rsrc_process_section (bfd * abfd,
4132 struct coff_final_link_info * pfinfo)
4134 rsrc_directory new_table;
4140 bfd_byte * datastart;
4142 bfd_byte * new_data;
4143 unsigned int num_resource_sets;
4144 rsrc_directory * type_tables;
4145 rsrc_write_data write_data;
4148 unsigned int num_input_rsrc = 0;
4149 unsigned int max_num_input_rsrc = 4;
4150 ptrdiff_t * rsrc_sizes = NULL;
4152 new_table.names.num_entries = 0;
4153 new_table.ids.num_entries = 0;
4155 sec = bfd_get_section_by_name (abfd, ".rsrc");
4156 if (sec == NULL || (size = sec->rawsize) == 0)
4159 pe = pe_data (abfd);
4163 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4165 data = bfd_malloc (size);
4171 if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4174 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4175 their lengths. Note - we rely upon the fact that the linker script
4176 does *not* sort the input .rsrc sections, so that the order in the
4177 linkinfo list matches the order in the output .rsrc section.
4179 We need to know the lengths because each input .rsrc section has padding
4180 at the end of a variable amount. (It does not appear to be based upon
4181 the section alignment or the file alignment). We need to skip any
4182 padding bytes when parsing the input .rsrc sections. */
4183 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4184 if (rsrc_sizes == NULL)
4187 for (input = pfinfo->info->input_bfds;
4189 input = input->link.next)
4191 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4193 /* PR 18372 - skip discarded .rsrc sections. */
4194 if (rsrc_sec != NULL && !discarded_section (rsrc_sec))
4196 if (num_input_rsrc == max_num_input_rsrc)
4198 max_num_input_rsrc += 10;
4199 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4200 * sizeof * rsrc_sizes);
4201 if (rsrc_sizes == NULL)
4205 BFD_ASSERT (rsrc_sec->size > 0);
4206 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4210 if (num_input_rsrc < 2)
4213 /* Step one: Walk the section, computing the size of the tables,
4214 leaves and data and decide if we need to do anything. */
4215 dataend = data + size;
4216 num_resource_sets = 0;
4218 while (data < dataend)
4220 bfd_byte * p = data;
4222 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4226 /* Corrupted .rsrc section - cannot merge. */
4227 _bfd_error_handler (_("%B: .rsrc merge failure: corrupt .rsrc section"),
4229 bfd_set_error (bfd_error_file_truncated);
4233 if ((data - p) > rsrc_sizes [num_resource_sets])
4235 _bfd_error_handler (_("%B: .rsrc merge failure: unexpected .rsrc size"),
4237 bfd_set_error (bfd_error_file_truncated);
4240 /* FIXME: Should we add a check for "data - p" being much smaller
4241 than rsrc_sizes[num_resource_sets] ? */
4243 data = p + rsrc_sizes[num_resource_sets];
4244 rva_bias += data - p;
4245 ++ num_resource_sets;
4247 BFD_ASSERT (num_resource_sets == num_input_rsrc);
4249 /* Step two: Walk the data again, building trees of the resources. */
4251 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4253 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4254 if (type_tables == NULL)
4258 while (data < dataend)
4260 bfd_byte * p = data;
4262 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4263 dataend, rva_bias, NULL);
4264 data = p + rsrc_sizes[indx];
4265 rva_bias += data - p;
4268 BFD_ASSERT (indx == num_resource_sets);
4270 /* Step three: Merge the top level tables (there can be only one).
4272 We must ensure that the merged entries are in ascending order.
4274 We also thread the top level table entries from the old tree onto
4275 the new table, so that they can be pulled off later. */
4277 /* FIXME: Should we verify that all type tables are the same ? */
4278 new_table.characteristics = type_tables[0].characteristics;
4279 new_table.time = type_tables[0].time;
4280 new_table.major = type_tables[0].major;
4281 new_table.minor = type_tables[0].minor;
4283 /* Chain the NAME entries onto the table. */
4284 new_table.names.first_entry = NULL;
4285 new_table.names.last_entry = NULL;
4287 for (indx = 0; indx < num_resource_sets; indx++)
4288 rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4290 rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4292 /* Chain the ID entries onto the table. */
4293 new_table.ids.first_entry = NULL;
4294 new_table.ids.last_entry = NULL;
4296 for (indx = 0; indx < num_resource_sets; indx++)
4297 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4299 rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4301 /* Step four: Create new contents for the .rsrc section. */
4302 /* Step four point one: Compute the size of each region of the .rsrc section.
4303 We do this now, rather than earlier, as the merging above may have dropped
4305 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4306 rsrc_compute_region_sizes (& new_table);
4307 /* We increment sizeof_strings to make sure that resource data
4308 starts on an 8-byte boundary. FIXME: Is this correct ? */
4309 sizeof_strings = (sizeof_strings + 7) & ~ 7;
4311 new_data = bfd_zalloc (abfd, size);
4312 if (new_data == NULL)
4315 write_data.abfd = abfd;
4316 write_data.datastart = new_data;
4317 write_data.next_table = new_data;
4318 write_data.next_leaf = new_data + sizeof_tables_and_entries;
4319 write_data.next_string = write_data.next_leaf + sizeof_leaves;
4320 write_data.next_data = write_data.next_string + sizeof_strings;
4321 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4323 rsrc_write_directory (& write_data, & new_table);
4325 /* Step five: Replace the old contents with the new.
4326 We don't recompute the size as it's too late here to shrink section.
4327 See PR ld/20193 for more details. */
4328 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4329 sec->size = sec->rawsize = size;
4332 /* Step six: Free all the memory that we have used. */
4333 /* FIXME: Free the resource tree, if we have one. */
4338 /* Handle the .idata section and other things that need symbol table
4342 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4344 struct coff_link_hash_entry *h1;
4345 struct bfd_link_info *info = pfinfo->info;
4346 bfd_boolean result = TRUE;
4348 /* There are a few fields that need to be filled in now while we
4349 have symbol table access.
4351 The .idata subsections aren't directly available as sections, but
4352 they are in the symbol table, so get them from there. */
4354 /* The import directory. This is the address of .idata$2, with size
4355 of .idata$2 + .idata$3. */
4356 h1 = coff_link_hash_lookup (coff_hash_table (info),
4357 ".idata$2", FALSE, FALSE, TRUE);
4360 /* PR ld/2729: We cannot rely upon all the output sections having been
4361 created properly, so check before referencing them. Issue a warning
4362 message for any sections tht could not be found. */
4363 if ((h1->root.type == bfd_link_hash_defined
4364 || h1->root.type == bfd_link_hash_defweak)
4365 && h1->root.u.def.section != NULL
4366 && h1->root.u.def.section->output_section != NULL)
4367 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4368 (h1->root.u.def.value
4369 + h1->root.u.def.section->output_section->vma
4370 + h1->root.u.def.section->output_offset);
4374 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4379 h1 = coff_link_hash_lookup (coff_hash_table (info),
4380 ".idata$4", FALSE, FALSE, TRUE);
4382 && (h1->root.type == bfd_link_hash_defined
4383 || h1->root.type == bfd_link_hash_defweak)
4384 && h1->root.u.def.section != NULL
4385 && h1->root.u.def.section->output_section != NULL)
4386 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4387 ((h1->root.u.def.value
4388 + h1->root.u.def.section->output_section->vma
4389 + h1->root.u.def.section->output_offset)
4390 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4394 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4399 /* The import address table. This is the size/address of
4401 h1 = coff_link_hash_lookup (coff_hash_table (info),
4402 ".idata$5", FALSE, FALSE, TRUE);
4404 && (h1->root.type == bfd_link_hash_defined
4405 || h1->root.type == bfd_link_hash_defweak)
4406 && h1->root.u.def.section != NULL
4407 && h1->root.u.def.section->output_section != NULL)
4408 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4409 (h1->root.u.def.value
4410 + h1->root.u.def.section->output_section->vma
4411 + h1->root.u.def.section->output_offset);
4415 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4420 h1 = coff_link_hash_lookup (coff_hash_table (info),
4421 ".idata$6", FALSE, FALSE, TRUE);
4423 && (h1->root.type == bfd_link_hash_defined
4424 || h1->root.type == bfd_link_hash_defweak)
4425 && h1->root.u.def.section != NULL
4426 && h1->root.u.def.section->output_section != NULL)
4427 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4428 ((h1->root.u.def.value
4429 + h1->root.u.def.section->output_section->vma
4430 + h1->root.u.def.section->output_offset)
4431 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4435 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4442 h1 = coff_link_hash_lookup (coff_hash_table (info),
4443 "__IAT_start__", FALSE, FALSE, TRUE);
4445 && (h1->root.type == bfd_link_hash_defined
4446 || h1->root.type == bfd_link_hash_defweak)
4447 && h1->root.u.def.section != NULL
4448 && h1->root.u.def.section->output_section != NULL)
4453 (h1->root.u.def.value
4454 + h1->root.u.def.section->output_section->vma
4455 + h1->root.u.def.section->output_offset);
4457 h1 = coff_link_hash_lookup (coff_hash_table (info),
4458 "__IAT_end__", FALSE, FALSE, TRUE);
4460 && (h1->root.type == bfd_link_hash_defined
4461 || h1->root.type == bfd_link_hash_defweak)
4462 && h1->root.u.def.section != NULL
4463 && h1->root.u.def.section->output_section != NULL)
4465 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4466 ((h1->root.u.def.value
4467 + h1->root.u.def.section->output_section->vma
4468 + h1->root.u.def.section->output_offset)
4470 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4471 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4472 iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4477 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4478 " because .idata$6 is missing"), abfd);
4484 h1 = coff_link_hash_lookup (coff_hash_table (info),
4485 (bfd_get_symbol_leading_char (abfd) != 0
4486 ? "__tls_used" : "_tls_used"),
4487 FALSE, FALSE, TRUE);
4490 if ((h1->root.type == bfd_link_hash_defined
4491 || h1->root.type == bfd_link_hash_defweak)
4492 && h1->root.u.def.section != NULL
4493 && h1->root.u.def.section->output_section != NULL)
4494 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4495 (h1->root.u.def.value
4496 + h1->root.u.def.section->output_section->vma
4497 + h1->root.u.def.section->output_offset
4498 - pe_data (abfd)->pe_opthdr.ImageBase);
4502 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4506 /* According to PECOFF sepcifications by Microsoft version 8.2
4507 the TLS data directory consists of 4 pointers, followed
4508 by two 4-byte integer. This implies that the total size
4509 is different for 32-bit and 64-bit executables. */
4510 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4511 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4513 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4517 /* If there is a .pdata section and we have linked pdata finally, we
4518 need to sort the entries ascending. */
4519 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4521 asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4525 bfd_size_type x = sec->rawsize;
4526 bfd_byte *tmp_data = NULL;
4529 tmp_data = bfd_malloc (x);
4531 if (tmp_data != NULL)
4533 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4537 12, sort_x64_pdata);
4538 bfd_set_section_contents (pfinfo->output_bfd, sec,
4549 rsrc_process_section (abfd, pfinfo);
4551 /* If we couldn't find idata$2, we either have an excessively
4552 trivial program or are in DEEP trouble; we have to assume trivial