1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2014 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25 PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc. */
28 /* Hey look, some documentation [and in a place you expect to find it]!
30 The main reference for the pei format is "Microsoft Portable Executable
31 and Common Object File Format Specification 4.1". Get it if you need to
32 do some serious hacking on this code.
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
38 The *sole* difference between the pe format and the pei format is that the
39 latter has an MSDOS 2.0 .exe header on the front that prints the message
40 "This app must be run under Windows." (or some such).
41 (FIXME: Whether that statement is *really* true or not is unknown.
42 Are there more subtle differences between pe and pei formats?
43 For now assume there aren't. If you find one, then for God sakes
46 The Microsoft docs use the word "image" instead of "executable" because
47 the former can also refer to a DLL (shared library). Confusion can arise
48 because the `i' in `pei' also refers to "image". The `pe' format can
49 also create images (i.e. executables), it's just that to run on a win32
50 system you need to use the pei format.
52 FIXME: Please add more docs here so the next poor fool that has to hack
53 on this code has a chance of getting something accomplished without
54 wasting too much time. */
56 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
57 depending on whether we're compiling for straight PE or PE+. */
63 #include "coff/internal.h"
69 /* NOTE: it's strange to be including an architecture specific header
70 in what's supposed to be general (to PE/PEI) code. However, that's
71 where the definitions are, and they don't vary per architecture
72 within PE/PEI, so we get them from there. FIXME: The lack of
73 variance is an assumption which may prove to be incorrect if new
74 PE/PEI targets are created. */
75 #if defined COFF_WITH_pex64
76 # include "coff/x86_64.h"
77 #elif defined COFF_WITH_pep
78 # include "coff/ia64.h"
80 # include "coff/i386.h"
86 #include "safe-ctype.h"
88 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
90 # define AOUTSZ PEPAOUTSZ
91 # define PEAOUTHDR PEPAOUTHDR
94 #define HighBitSet(val) ((val) & 0x80000000)
95 #define SetHighBit(val) ((val) | 0x80000000)
96 #define WithoutHighBit(val) ((val) & 0x7fffffff)
98 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
99 worked when the code was in peicode.h, but no longer work now that
100 the code is in peigen.c. PowerPC NT is said to be dead. If
101 anybody wants to revive the code, you will have to figure out how
102 to handle those issues. */
105 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
107 SYMENT *ext = (SYMENT *) ext1;
108 struct internal_syment *in = (struct internal_syment *) in1;
110 if (ext->e.e_name[0] == 0)
112 in->_n._n_n._n_zeroes = 0;
113 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
116 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
118 in->n_value = H_GET_32 (abfd, ext->e_value);
119 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
121 if (sizeof (ext->e_type) == 2)
122 in->n_type = H_GET_16 (abfd, ext->e_type);
124 in->n_type = H_GET_32 (abfd, ext->e_type);
126 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
127 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
129 #ifndef STRICT_PE_FORMAT
130 /* This is for Gnu-created DLLs. */
132 /* The section symbols for the .idata$ sections have class 0x68
133 (C_SECTION), which MS documentation indicates is a section
134 symbol. Unfortunately, the value field in the symbol is simply a
135 copy of the .idata section's flags rather than something useful.
136 When these symbols are encountered, change the value to 0 so that
137 they will be handled somewhat correctly in the bfd code. */
138 if (in->n_sclass == C_SECTION)
140 char namebuf[SYMNMLEN + 1];
141 const char *name = NULL;
145 /* Create synthetic empty sections as needed. DJ */
146 if (in->n_scnum == 0)
150 name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
152 /* FIXME: Return error. */
154 sec = bfd_get_section_by_name (abfd, name);
156 in->n_scnum = sec->target_index;
159 if (in->n_scnum == 0)
161 int unused_section_number = 0;
165 for (sec = abfd->sections; sec; sec = sec->next)
166 if (unused_section_number <= sec->target_index)
167 unused_section_number = sec->target_index + 1;
171 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
173 /* FIXME: Return error. */
175 strcpy ((char *) name, namebuf);
177 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
178 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
180 /* FIXME: Return error. */
187 sec->rel_filepos = 0;
188 sec->reloc_count = 0;
189 sec->line_filepos = 0;
190 sec->lineno_count = 0;
191 sec->userdata = NULL;
193 sec->alignment_power = 2;
195 sec->target_index = unused_section_number;
197 in->n_scnum = unused_section_number;
199 in->n_sclass = C_STAT;
203 #ifdef coff_swap_sym_in_hook
204 /* This won't work in peigen.c, but since it's for PPC PE, it's not
206 coff_swap_sym_in_hook (abfd, ext1, in1);
211 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
213 bfd_vma abs_val = * (bfd_vma *) data;
215 return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
219 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
221 struct internal_syment *in = (struct internal_syment *) inp;
222 SYMENT *ext = (SYMENT *) extp;
224 if (in->_n._n_name[0] == 0)
226 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
227 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
230 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
232 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
233 symbol. This is a problem on 64-bit targets where we can generate
234 absolute symbols with values >= 1^32. We try to work around this
235 problem by finding a section whose base address is sufficient to
236 reduce the absolute value to < 1^32, and then transforming the
237 symbol into a section relative symbol. This of course is a hack. */
238 if (sizeof (in->n_value) > 4
239 /* GCC 4.6.x erroneously complains about the next test always being
240 false when compiled on a 32-bit host. (The sizeof test above
241 should have made the warning unnecessary). Hence we have to
242 predicate the test. It should not matter if the test is omitted
243 since the worst that can happen is that some absolute symbols
244 are needlessly converted to equivalent section relative symbols. */
245 #if defined BFD64 || ! defined __GNUC__ || __GNUC__ > 4 || __GNUC_MINOR__ > 6
246 && in->n_value > ((1ULL << 32) - 1)
248 && in->n_scnum == -1)
252 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
255 in->n_value -= sec->vma;
256 in->n_scnum = sec->target_index;
258 /* else: FIXME: The value is outside the range of any section. This
259 happens for __image_base__ and __ImageBase and maybe some other
260 symbols as well. We should find a way to handle these values. */
263 H_PUT_32 (abfd, in->n_value, ext->e_value);
264 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
266 if (sizeof (ext->e_type) == 2)
267 H_PUT_16 (abfd, in->n_type, ext->e_type);
269 H_PUT_32 (abfd, in->n_type, ext->e_type);
271 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
272 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
278 _bfd_XXi_swap_aux_in (bfd * abfd,
282 int indx ATTRIBUTE_UNUSED,
283 int numaux ATTRIBUTE_UNUSED,
286 AUXENT *ext = (AUXENT *) ext1;
287 union internal_auxent *in = (union internal_auxent *) in1;
292 if (ext->x_file.x_fname[0] == 0)
294 in->x_file.x_n.x_zeroes = 0;
295 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
298 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
306 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
307 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
308 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
309 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
310 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
311 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
317 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
318 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
320 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
323 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
324 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
328 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
329 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
330 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
331 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
332 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
333 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
334 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
335 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
340 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
344 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
345 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
350 _bfd_XXi_swap_aux_out (bfd * abfd,
354 int indx ATTRIBUTE_UNUSED,
355 int numaux ATTRIBUTE_UNUSED,
358 union internal_auxent *in = (union internal_auxent *) inp;
359 AUXENT *ext = (AUXENT *) extp;
361 memset (ext, 0, AUXESZ);
366 if (in->x_file.x_fname[0] == 0)
368 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
369 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
372 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
381 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
382 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
383 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
384 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
385 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
386 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
392 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
393 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
395 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
398 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
399 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
403 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
404 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
405 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
406 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
407 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
408 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
409 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
410 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
414 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
417 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
418 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
425 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
427 LINENO *ext = (LINENO *) ext1;
428 struct internal_lineno *in = (struct internal_lineno *) in1;
430 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
431 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
435 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
437 struct internal_lineno *in = (struct internal_lineno *) inp;
438 struct external_lineno *ext = (struct external_lineno *) outp;
439 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
441 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
446 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
450 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
451 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
452 struct internal_aouthdr *aouthdr_int
453 = (struct internal_aouthdr *) aouthdr_int1;
454 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
456 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
457 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
458 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
459 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
460 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
461 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
462 aouthdr_int->text_start =
463 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
464 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
465 /* PE32+ does not have data_start member! */
466 aouthdr_int->data_start =
467 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
468 a->BaseOfData = aouthdr_int->data_start;
471 a->Magic = aouthdr_int->magic;
472 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
473 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
474 a->SizeOfCode = aouthdr_int->tsize ;
475 a->SizeOfInitializedData = aouthdr_int->dsize ;
476 a->SizeOfUninitializedData = aouthdr_int->bsize ;
477 a->AddressOfEntryPoint = aouthdr_int->entry;
478 a->BaseOfCode = aouthdr_int->text_start;
479 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
480 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
481 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
482 a->MajorOperatingSystemVersion =
483 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
484 a->MinorOperatingSystemVersion =
485 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
486 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
487 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
488 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
489 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
490 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
491 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
492 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
493 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
494 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
495 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
496 a->SizeOfStackReserve =
497 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
498 a->SizeOfStackCommit =
499 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
500 a->SizeOfHeapReserve =
501 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
502 a->SizeOfHeapCommit =
503 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
504 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
505 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
510 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
512 /* If data directory is empty, rva also should be 0. */
514 H_GET_32 (abfd, src->DataDirectory[idx][1]);
516 a->DataDirectory[idx].Size = size;
519 a->DataDirectory[idx].VirtualAddress =
520 H_GET_32 (abfd, src->DataDirectory[idx][0]);
522 a->DataDirectory[idx].VirtualAddress = 0;
526 if (aouthdr_int->entry)
528 aouthdr_int->entry += a->ImageBase;
529 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
530 aouthdr_int->entry &= 0xffffffff;
534 if (aouthdr_int->tsize)
536 aouthdr_int->text_start += a->ImageBase;
537 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
538 aouthdr_int->text_start &= 0xffffffff;
542 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
543 /* PE32+ does not have data_start member! */
544 if (aouthdr_int->dsize)
546 aouthdr_int->data_start += a->ImageBase;
547 aouthdr_int->data_start &= 0xffffffff;
552 /* These three fields are normally set up by ppc_relocate_section.
553 In the case of reading a file in, we can pick them up from the
555 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
556 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
557 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
561 /* A support function for below. */
564 add_data_entry (bfd * abfd,
565 struct internal_extra_pe_aouthdr *aout,
570 asection *sec = bfd_get_section_by_name (abfd, name);
572 /* Add import directory information if it exists. */
574 && (coff_section_data (abfd, sec) != NULL)
575 && (pei_section_data (abfd, sec) != NULL))
577 /* If data directory is empty, rva also should be 0. */
578 int size = pei_section_data (abfd, sec)->virt_size;
579 aout->DataDirectory[idx].Size = size;
583 aout->DataDirectory[idx].VirtualAddress =
584 (sec->vma - base) & 0xffffffff;
585 sec->flags |= SEC_DATA;
591 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
593 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
594 pe_data_type *pe = pe_data (abfd);
595 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
596 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
598 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
600 sa = extra->SectionAlignment;
601 fa = extra->FileAlignment;
602 ib = extra->ImageBase;
604 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
605 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
606 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
608 if (aouthdr_in->tsize)
610 aouthdr_in->text_start -= ib;
611 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
612 aouthdr_in->text_start &= 0xffffffff;
616 if (aouthdr_in->dsize)
618 aouthdr_in->data_start -= ib;
619 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
620 aouthdr_in->data_start &= 0xffffffff;
624 if (aouthdr_in->entry)
626 aouthdr_in->entry -= ib;
627 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
628 aouthdr_in->entry &= 0xffffffff;
632 #define FA(x) (((x) + fa -1 ) & (- fa))
633 #define SA(x) (((x) + sa -1 ) & (- sa))
635 /* We like to have the sizes aligned. */
636 aouthdr_in->bsize = FA (aouthdr_in->bsize);
638 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
640 add_data_entry (abfd, extra, 0, ".edata", ib);
641 add_data_entry (abfd, extra, 2, ".rsrc", ib);
642 add_data_entry (abfd, extra, 3, ".pdata", ib);
644 /* In theory we do not need to call add_data_entry for .idata$2 or
645 .idata$5. It will be done in bfd_coff_final_link where all the
646 required information is available. If however, we are not going
647 to perform a final link, eg because we have been invoked by objcopy
648 or strip, then we need to make sure that these Data Directory
649 entries are initialised properly.
651 So - we copy the input values into the output values, and then, if
652 a final link is going to be performed, it can overwrite them. */
653 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
654 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
655 extra->DataDirectory[PE_TLS_TABLE] = tls;
657 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
658 /* Until other .idata fixes are made (pending patch), the entry for
659 .idata is needed for backwards compatibility. FIXME. */
660 add_data_entry (abfd, extra, 1, ".idata", ib);
662 /* For some reason, the virtual size (which is what's set by
663 add_data_entry) for .reloc is not the same as the size recorded
664 in this slot by MSVC; it doesn't seem to cause problems (so far),
665 but since it's the best we've got, use it. It does do the right
667 if (pe->has_reloc_section)
668 add_data_entry (abfd, extra, 5, ".reloc", ib);
677 for (sec = abfd->sections; sec; sec = sec->next)
679 int rounded = FA (sec->size);
681 /* The first non-zero section filepos is the header size.
682 Sections without contents will have a filepos of 0. */
684 hsize = sec->filepos;
685 if (sec->flags & SEC_DATA)
687 if (sec->flags & SEC_CODE)
689 /* The image size is the total VIRTUAL size (which is what is
690 in the virt_size field). Files have been seen (from MSVC
691 5.0 link.exe) where the file size of the .data segment is
692 quite small compared to the virtual size. Without this
693 fix, strip munges the file.
695 FIXME: We need to handle holes between sections, which may
696 happpen when we covert from another format. We just use
697 the virtual address and virtual size of the last section
698 for the image size. */
699 if (coff_section_data (abfd, sec) != NULL
700 && pei_section_data (abfd, sec) != NULL)
701 isize = (sec->vma - extra->ImageBase
702 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
705 aouthdr_in->dsize = dsize;
706 aouthdr_in->tsize = tsize;
707 extra->SizeOfHeaders = hsize;
708 extra->SizeOfImage = isize;
711 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
713 /* e.g. 219510000 is linker version 2.19 */
714 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
716 /* This piece of magic sets the "linker version" field to
718 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
719 aouthdr_out->standard.vstamp);
721 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
722 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
723 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
724 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
725 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
726 aouthdr_out->standard.text_start);
728 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
729 /* PE32+ does not have data_start member! */
730 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
731 aouthdr_out->standard.data_start);
734 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
735 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
736 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
737 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
738 aouthdr_out->MajorOperatingSystemVersion);
739 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
740 aouthdr_out->MinorOperatingSystemVersion);
741 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
742 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
743 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
744 aouthdr_out->MajorSubsystemVersion);
745 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
746 aouthdr_out->MinorSubsystemVersion);
747 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
748 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
749 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
750 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
751 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
752 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
753 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
754 aouthdr_out->SizeOfStackReserve);
755 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
756 aouthdr_out->SizeOfStackCommit);
757 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
758 aouthdr_out->SizeOfHeapReserve);
759 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
760 aouthdr_out->SizeOfHeapCommit);
761 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
762 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
763 aouthdr_out->NumberOfRvaAndSizes);
767 for (idx = 0; idx < 16; idx++)
769 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
770 aouthdr_out->DataDirectory[idx][0]);
771 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
772 aouthdr_out->DataDirectory[idx][1]);
780 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
783 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
784 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
786 if (pe_data (abfd)->has_reloc_section
787 || pe_data (abfd)->dont_strip_reloc)
788 filehdr_in->f_flags &= ~F_RELFLG;
790 if (pe_data (abfd)->dll)
791 filehdr_in->f_flags |= F_DLL;
793 filehdr_in->pe.e_magic = DOSMAGIC;
794 filehdr_in->pe.e_cblp = 0x90;
795 filehdr_in->pe.e_cp = 0x3;
796 filehdr_in->pe.e_crlc = 0x0;
797 filehdr_in->pe.e_cparhdr = 0x4;
798 filehdr_in->pe.e_minalloc = 0x0;
799 filehdr_in->pe.e_maxalloc = 0xffff;
800 filehdr_in->pe.e_ss = 0x0;
801 filehdr_in->pe.e_sp = 0xb8;
802 filehdr_in->pe.e_csum = 0x0;
803 filehdr_in->pe.e_ip = 0x0;
804 filehdr_in->pe.e_cs = 0x0;
805 filehdr_in->pe.e_lfarlc = 0x40;
806 filehdr_in->pe.e_ovno = 0x0;
808 for (idx = 0; idx < 4; idx++)
809 filehdr_in->pe.e_res[idx] = 0x0;
811 filehdr_in->pe.e_oemid = 0x0;
812 filehdr_in->pe.e_oeminfo = 0x0;
814 for (idx = 0; idx < 10; idx++)
815 filehdr_in->pe.e_res2[idx] = 0x0;
817 filehdr_in->pe.e_lfanew = 0x80;
819 /* This next collection of data are mostly just characters. It
820 appears to be constant within the headers put on NT exes. */
821 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
822 filehdr_in->pe.dos_message[1] = 0xcd09b400;
823 filehdr_in->pe.dos_message[2] = 0x4c01b821;
824 filehdr_in->pe.dos_message[3] = 0x685421cd;
825 filehdr_in->pe.dos_message[4] = 0x70207369;
826 filehdr_in->pe.dos_message[5] = 0x72676f72;
827 filehdr_in->pe.dos_message[6] = 0x63206d61;
828 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
829 filehdr_in->pe.dos_message[8] = 0x65622074;
830 filehdr_in->pe.dos_message[9] = 0x6e757220;
831 filehdr_in->pe.dos_message[10] = 0x206e6920;
832 filehdr_in->pe.dos_message[11] = 0x20534f44;
833 filehdr_in->pe.dos_message[12] = 0x65646f6d;
834 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
835 filehdr_in->pe.dos_message[14] = 0x24;
836 filehdr_in->pe.dos_message[15] = 0x0;
837 filehdr_in->pe.nt_signature = NT_SIGNATURE;
839 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
840 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
842 /* Only use a real timestamp if the option was chosen. */
843 if ((pe_data (abfd)->insert_timestamp))
844 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
846 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
847 filehdr_out->f_symptr);
848 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
849 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
850 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
852 /* Put in extra dos header stuff. This data remains essentially
853 constant, it just has to be tacked on to the beginning of all exes
855 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
856 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
857 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
858 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
859 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
860 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
861 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
862 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
863 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
864 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
865 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
866 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
867 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
868 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
870 for (idx = 0; idx < 4; idx++)
871 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
873 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
874 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
876 for (idx = 0; idx < 10; idx++)
877 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
879 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
881 for (idx = 0; idx < 16; idx++)
882 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
883 filehdr_out->dos_message[idx]);
885 /* Also put in the NT signature. */
886 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
892 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
894 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
895 FILHDR *filehdr_out = (FILHDR *) out;
897 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
898 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
899 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
900 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
901 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
902 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
903 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
909 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
911 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
912 SCNHDR *scnhdr_ext = (SCNHDR *) out;
913 unsigned int ret = SCNHSZ;
917 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
919 PUT_SCNHDR_VADDR (abfd,
920 ((scnhdr_int->s_vaddr
921 - pe_data (abfd)->pe_opthdr.ImageBase)
923 scnhdr_ext->s_vaddr);
925 /* NT wants the size data to be rounded up to the next
926 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
928 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
930 if (bfd_pei_p (abfd))
932 ps = scnhdr_int->s_size;
938 ss = scnhdr_int->s_size;
943 if (bfd_pei_p (abfd))
944 ps = scnhdr_int->s_paddr;
948 ss = scnhdr_int->s_size;
951 PUT_SCNHDR_SIZE (abfd, ss,
954 /* s_paddr in PE is really the virtual size. */
955 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
957 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
958 scnhdr_ext->s_scnptr);
959 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
960 scnhdr_ext->s_relptr);
961 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
962 scnhdr_ext->s_lnnoptr);
965 /* Extra flags must be set when dealing with PE. All sections should also
966 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
967 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
968 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
969 (this is especially important when dealing with the .idata section since
970 the addresses for routines from .dlls must be overwritten). If .reloc
971 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
972 (0x02000000). Also, the resource data should also be read and
975 /* FIXME: Alignment is also encoded in this field, at least on PPC and
976 ARM-WINCE. Although - how do we get the original alignment field
981 const char * section_name;
982 unsigned long must_have;
984 pe_required_section_flags;
986 pe_required_section_flags known_sections [] =
988 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
989 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
990 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
991 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
992 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
993 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
994 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
995 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
996 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
997 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
998 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
999 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1003 pe_required_section_flags * p;
1005 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1006 we know exactly what this specific section wants so we remove it
1007 and then allow the must_have field to add it back in if necessary.
1008 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1009 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1010 by ld --enable-auto-import (if auto-import is actually needed),
1011 by ld --omagic, or by obcopy --writable-text. */
1013 for (p = known_sections; p->section_name; p++)
1014 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1016 if (strcmp (scnhdr_int->s_name, ".text")
1017 || (bfd_get_file_flags (abfd) & WP_TEXT))
1018 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1019 scnhdr_int->s_flags |= p->must_have;
1023 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1026 if (coff_data (abfd)->link_info
1027 && ! coff_data (abfd)->link_info->relocatable
1028 && ! coff_data (abfd)->link_info->shared
1029 && strcmp (scnhdr_int->s_name, ".text") == 0)
1031 /* By inference from looking at MS output, the 32 bit field
1032 which is the combination of the number_of_relocs and
1033 number_of_linenos is used for the line number count in
1034 executables. A 16-bit field won't do for cc1. The MS
1035 document says that the number of relocs is zero for
1036 executables, but the 17-th bit has been observed to be there.
1037 Overflow is not an issue: a 4G-line program will overflow a
1038 bunch of other fields long before this! */
1039 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1040 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1044 if (scnhdr_int->s_nlnno <= 0xffff)
1045 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1048 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1049 bfd_get_filename (abfd),
1050 scnhdr_int->s_nlnno);
1051 bfd_set_error (bfd_error_file_truncated);
1052 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1056 /* Although we could encode 0xffff relocs here, we do not, to be
1057 consistent with other parts of bfd. Also it lets us warn, as
1058 we should never see 0xffff here w/o having the overflow flag
1060 if (scnhdr_int->s_nreloc < 0xffff)
1061 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1064 /* PE can deal with large #s of relocs, but not here. */
1065 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1066 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1067 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1074 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1076 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1077 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1079 in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1080 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1081 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1082 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1083 in->Type = H_GET_32(abfd, ext->Type);
1084 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1085 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1086 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1090 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1092 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1093 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1095 H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1096 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1097 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1098 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1099 H_PUT_32(abfd, in->Type, ext->Type);
1100 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1101 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1102 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1104 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1107 static CODEVIEW_INFO *
1108 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1112 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1115 if (bfd_bread (buffer, 256, abfd) < 4)
1118 /* ensure null termination of filename */
1121 cvinfo->CVSignature = H_GET_32(abfd, buffer);
1124 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1125 && (length > sizeof (CV_INFO_PDB70)))
1127 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1129 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1130 memcpy (cvinfo->Signature, cvinfo70->Signature, CV_INFO_SIGNATURE_LENGTH);
1131 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1132 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1136 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1137 && (length > sizeof (CV_INFO_PDB20)))
1139 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1140 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1141 memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1142 cvinfo->SignatureLength = 4;
1143 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1152 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1154 unsigned int size = sizeof (CV_INFO_PDB70) + 1;
1155 CV_INFO_PDB70 *cvinfo70;
1158 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1161 cvinfo70 = (CV_INFO_PDB70 *) buffer;
1162 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1163 memcpy (&(cvinfo70->Signature), cvinfo->Signature, CV_INFO_SIGNATURE_LENGTH);
1164 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1165 cvinfo70->PdbFileName[0] = '\0';
1167 if (bfd_bwrite (buffer, size, abfd) != size)
1173 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1175 N_("Export Directory [.edata (or where ever we found it)]"),
1176 N_("Import Directory [parts of .idata]"),
1177 N_("Resource Directory [.rsrc]"),
1178 N_("Exception Directory [.pdata]"),
1179 N_("Security Directory"),
1180 N_("Base Relocation Directory [.reloc]"),
1181 N_("Debug Directory"),
1182 N_("Description Directory"),
1183 N_("Special Directory"),
1184 N_("Thread Storage Directory [.tls]"),
1185 N_("Load Configuration Directory"),
1186 N_("Bound Import Directory"),
1187 N_("Import Address Table Directory"),
1188 N_("Delay Import Directory"),
1189 N_("CLR Runtime Header"),
1193 #ifdef POWERPC_LE_PE
1194 /* The code for the PPC really falls in the "architecture dependent"
1195 category. However, it's not clear that anyone will ever care, so
1196 we're ignoring the issue for now; if/when PPC matters, some of this
1197 may need to go into peicode.h, or arguments passed to enable the
1198 PPC- specific code. */
1202 pe_print_idata (bfd * abfd, void * vfile)
1204 FILE *file = (FILE *) vfile;
1209 #ifdef POWERPC_LE_PE
1210 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1213 bfd_size_type datasize = 0;
1214 bfd_size_type dataoff;
1218 pe_data_type *pe = pe_data (abfd);
1219 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1223 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1225 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1227 /* Maybe the extra header isn't there. Look for the section. */
1228 section = bfd_get_section_by_name (abfd, ".idata");
1229 if (section == NULL)
1232 addr = section->vma;
1233 datasize = section->size;
1239 addr += extra->ImageBase;
1240 for (section = abfd->sections; section != NULL; section = section->next)
1242 datasize = section->size;
1243 if (addr >= section->vma && addr < section->vma + datasize)
1247 if (section == NULL)
1250 _("\nThere is an import table, but the section containing it could not be found\n"));
1253 else if (!(section->flags & SEC_HAS_CONTENTS))
1256 _("\nThere is an import table in %s, but that section has no contents\n"),
1262 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1263 section->name, (unsigned long) addr);
1265 dataoff = addr - section->vma;
1267 #ifdef POWERPC_LE_PE
1268 if (rel_section != 0 && rel_section->size != 0)
1270 /* The toc address can be found by taking the starting address,
1271 which on the PPC locates a function descriptor. The
1272 descriptor consists of the function code starting address
1273 followed by the address of the toc. The starting address we
1274 get from the bfd, and the descriptor is supposed to be in the
1275 .reldata section. */
1277 bfd_vma loadable_toc_address;
1278 bfd_vma toc_address;
1279 bfd_vma start_address;
1283 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1290 offset = abfd->start_address - rel_section->vma;
1292 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1299 start_address = bfd_get_32 (abfd, data + offset);
1300 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1301 toc_address = loadable_toc_address - 32768;
1304 _("\nFunction descriptor located at the start address: %04lx\n"),
1305 (unsigned long int) (abfd->start_address));
1307 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1308 start_address, loadable_toc_address, toc_address);
1315 _("\nNo reldata section! Function descriptor not decoded.\n"));
1320 _("\nThe Import Tables (interpreted %s section contents)\n"),
1324 vma: Hint Time Forward DLL First\n\
1325 Table Stamp Chain Name Thunk\n"));
1327 /* Read the whole section. Some of the fields might be before dataoff. */
1328 if (!bfd_malloc_and_get_section (abfd, section, &data))
1335 adj = section->vma - extra->ImageBase;
1337 /* Print all image import descriptors. */
1338 for (i = dataoff; i + onaline <= datasize; i += onaline)
1342 bfd_vma forward_chain;
1344 bfd_vma first_thunk;
1349 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1350 fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1351 hint_addr = bfd_get_32 (abfd, data + i);
1352 time_stamp = bfd_get_32 (abfd, data + i + 4);
1353 forward_chain = bfd_get_32 (abfd, data + i + 8);
1354 dll_name = bfd_get_32 (abfd, data + i + 12);
1355 first_thunk = bfd_get_32 (abfd, data + i + 16);
1357 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1358 (unsigned long) hint_addr,
1359 (unsigned long) time_stamp,
1360 (unsigned long) forward_chain,
1361 (unsigned long) dll_name,
1362 (unsigned long) first_thunk);
1364 if (hint_addr == 0 && first_thunk == 0)
1367 if (dll_name - adj >= section->size)
1370 dll = (char *) data + dll_name - adj;
1371 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1376 asection *ft_section;
1378 bfd_size_type ft_datasize;
1382 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1384 idx = hint_addr - adj;
1386 ft_addr = first_thunk + extra->ImageBase;
1387 ft_idx = first_thunk - adj;
1388 ft_data = data + ft_idx;
1389 ft_datasize = datasize - ft_idx;
1392 if (first_thunk != hint_addr)
1394 /* Find the section which contains the first thunk. */
1395 for (ft_section = abfd->sections;
1397 ft_section = ft_section->next)
1399 if (ft_addr >= ft_section->vma
1400 && ft_addr < ft_section->vma + ft_section->size)
1404 if (ft_section == NULL)
1407 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1411 /* Now check to see if this section is the same as our current
1412 section. If it is not then we will have to load its data in. */
1413 if (ft_section != section)
1415 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1416 ft_datasize = ft_section->size - ft_idx;
1417 ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1418 if (ft_data == NULL)
1421 /* Read ft_datasize bytes starting at offset ft_idx. */
1422 if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1423 (bfd_vma) ft_idx, ft_datasize))
1432 /* Print HintName vector entries. */
1433 #ifdef COFF_WITH_pex64
1434 for (j = 0; idx + j + 8 <= datasize; j += 8)
1436 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1437 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1439 if (!member && !member_high)
1442 if (HighBitSet (member_high))
1443 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1444 member_high, member,
1445 WithoutHighBit (member_high), member);
1451 ordinal = bfd_get_16 (abfd, data + member - adj);
1452 member_name = (char *) data + member - adj + 2;
1453 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1456 /* If the time stamp is not zero, the import address
1457 table holds actual addresses. */
1460 && first_thunk != hint_addr
1461 && j + 4 <= ft_datasize)
1462 fprintf (file, "\t%04lx",
1463 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1464 fprintf (file, "\n");
1467 for (j = 0; idx + j + 4 <= datasize; j += 4)
1469 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1471 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1475 if (HighBitSet (member))
1476 fprintf (file, "\t%04lx\t %4lu <none>",
1477 member, WithoutHighBit (member));
1483 ordinal = bfd_get_16 (abfd, data + member - adj);
1484 member_name = (char *) data + member - adj + 2;
1485 fprintf (file, "\t%04lx\t %4d %s",
1486 member, ordinal, member_name);
1489 /* If the time stamp is not zero, the import address
1490 table holds actual addresses. */
1493 && first_thunk != hint_addr
1494 && j + 4 <= ft_datasize)
1495 fprintf (file, "\t%04lx",
1496 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1498 fprintf (file, "\n");
1505 fprintf (file, "\n");
1514 pe_print_edata (bfd * abfd, void * vfile)
1516 FILE *file = (FILE *) vfile;
1519 bfd_size_type datasize = 0;
1520 bfd_size_type dataoff;
1525 long export_flags; /* Reserved - should be zero. */
1529 bfd_vma name; /* RVA - relative to image base. */
1530 long base; /* Ordinal base. */
1531 unsigned long num_functions;/* Number in the export address table. */
1532 unsigned long num_names; /* Number in the name pointer table. */
1533 bfd_vma eat_addr; /* RVA to the export address table. */
1534 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1535 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1538 pe_data_type *pe = pe_data (abfd);
1539 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1543 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1545 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1547 /* Maybe the extra header isn't there. Look for the section. */
1548 section = bfd_get_section_by_name (abfd, ".edata");
1549 if (section == NULL)
1552 addr = section->vma;
1554 datasize = section->size;
1560 addr += extra->ImageBase;
1562 for (section = abfd->sections; section != NULL; section = section->next)
1563 if (addr >= section->vma && addr < section->vma + section->size)
1566 if (section == NULL)
1569 _("\nThere is an export table, but the section containing it could not be found\n"));
1572 else if (!(section->flags & SEC_HAS_CONTENTS))
1575 _("\nThere is an export table in %s, but that section has no contents\n"),
1580 dataoff = addr - section->vma;
1581 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1582 if (datasize > section->size - dataoff)
1585 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1591 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1592 section->name, (unsigned long) addr);
1594 data = (bfd_byte *) bfd_malloc (datasize);
1598 if (! bfd_get_section_contents (abfd, section, data,
1599 (file_ptr) dataoff, datasize))
1602 /* Go get Export Directory Table. */
1603 edt.export_flags = bfd_get_32 (abfd, data + 0);
1604 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1605 edt.major_ver = bfd_get_16 (abfd, data + 8);
1606 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1607 edt.name = bfd_get_32 (abfd, data + 12);
1608 edt.base = bfd_get_32 (abfd, data + 16);
1609 edt.num_functions = bfd_get_32 (abfd, data + 20);
1610 edt.num_names = bfd_get_32 (abfd, data + 24);
1611 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1612 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1613 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1615 adj = section->vma - extra->ImageBase + dataoff;
1617 /* Dump the EDT first. */
1619 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1623 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1626 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1629 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1632 _("Name \t\t\t\t"));
1633 bfd_fprintf_vma (abfd, file, edt.name);
1635 if ((edt.name >= adj) && (edt.name < adj + datasize))
1636 fprintf (file, " %s\n", data + edt.name - adj);
1638 fprintf (file, "(outside .edata section)\n");
1641 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1647 _("\tExport Address Table \t\t%08lx\n"),
1651 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1654 _("Table Addresses\n"));
1657 _("\tExport Address Table \t\t"));
1658 bfd_fprintf_vma (abfd, file, edt.eat_addr);
1659 fprintf (file, "\n");
1662 _("\tName Pointer Table \t\t"));
1663 bfd_fprintf_vma (abfd, file, edt.npt_addr);
1664 fprintf (file, "\n");
1667 _("\tOrdinal Table \t\t\t"));
1668 bfd_fprintf_vma (abfd, file, edt.ot_addr);
1669 fprintf (file, "\n");
1671 /* The next table to find is the Export Address Table. It's basically
1672 a list of pointers that either locate a function in this dll, or
1673 forward the call to another dll. Something like:
1678 } export_address_table_entry; */
1681 _("\nExport Address Table -- Ordinal Base %ld\n"),
1684 for (i = 0; i < edt.num_functions; ++i)
1686 bfd_vma eat_member = bfd_get_32 (abfd,
1687 data + edt.eat_addr + (i * 4) - adj);
1688 if (eat_member == 0)
1691 if (eat_member - adj <= datasize)
1693 /* This rva is to a name (forwarding function) in our section. */
1694 /* Should locate a function descriptor. */
1696 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1698 (long) (i + edt.base),
1699 (unsigned long) eat_member,
1701 data + eat_member - adj);
1705 /* Should locate a function descriptor in the reldata section. */
1707 "\t[%4ld] +base[%4ld] %04lx %s\n",
1709 (long) (i + edt.base),
1710 (unsigned long) eat_member,
1715 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1716 /* Dump them in parallel for clarity. */
1718 _("\n[Ordinal/Name Pointer] Table\n"));
1720 for (i = 0; i < edt.num_names; ++i)
1722 bfd_vma name_ptr = bfd_get_32 (abfd,
1727 char *name = (char *) data + name_ptr - adj;
1729 bfd_vma ord = bfd_get_16 (abfd,
1734 "\t[%4ld] %s\n", (long) ord, name);
1742 /* This really is architecture dependent. On IA-64, a .pdata entry
1743 consists of three dwords containing relative virtual addresses that
1744 specify the start and end address of the code range the entry
1745 covers and the address of the corresponding unwind info data.
1747 On ARM and SH-4, a compressed PDATA structure is used :
1748 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1749 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1750 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1752 This is the version for uncompressed data. */
1755 pe_print_pdata (bfd * abfd, void * vfile)
1757 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1758 # define PDATA_ROW_SIZE (3 * 8)
1760 # define PDATA_ROW_SIZE (5 * 4)
1762 FILE *file = (FILE *) vfile;
1764 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1765 bfd_size_type datasize = 0;
1767 bfd_size_type start, stop;
1768 int onaline = PDATA_ROW_SIZE;
1771 || coff_section_data (abfd, section) == NULL
1772 || pei_section_data (abfd, section) == NULL)
1775 stop = pei_section_data (abfd, section)->virt_size;
1776 if ((stop % onaline) != 0)
1778 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1779 (long) stop, onaline);
1782 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1783 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1785 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1788 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1789 \t\tAddress Address Handler Data Address Mask\n"));
1792 datasize = section->size;
1796 if (! bfd_malloc_and_get_section (abfd, section, &data))
1805 for (i = start; i < stop; i += onaline)
1811 bfd_vma prolog_end_addr;
1812 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1816 if (i + PDATA_ROW_SIZE > stop)
1819 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1820 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1821 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1822 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1823 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1825 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1826 && eh_data == 0 && prolog_end_addr == 0)
1827 /* We are probably into the padding of the section now. */
1830 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1831 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1833 eh_handler &= ~(bfd_vma) 0x3;
1834 prolog_end_addr &= ~(bfd_vma) 0x3;
1837 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1838 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1839 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1840 bfd_fprintf_vma (abfd, file, eh_handler);
1841 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1843 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1844 bfd_fprintf_vma (abfd, file, prolog_end_addr);
1845 fprintf (file, " %x", em_data);
1848 #ifdef POWERPC_LE_PE
1849 if (eh_handler == 0 && eh_data != 0)
1851 /* Special bits here, although the meaning may be a little
1852 mysterious. The only one I know for sure is 0x03
1855 0x01 Register Save Millicode
1856 0x02 Register Restore Millicode
1857 0x03 Glue Code Sequence. */
1861 fprintf (file, _(" Register save millicode"));
1864 fprintf (file, _(" Register restore millicode"));
1867 fprintf (file, _(" Glue code sequence"));
1874 fprintf (file, "\n");
1880 #undef PDATA_ROW_SIZE
1883 typedef struct sym_cache
1890 slurp_symtab (bfd *abfd, sym_cache *psc)
1892 asymbol ** sy = NULL;
1895 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1901 storage = bfd_get_symtab_upper_bound (abfd);
1905 sy = (asymbol **) bfd_malloc (storage);
1907 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1908 if (psc->symcount < 0)
1914 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1919 psc->syms = slurp_symtab (abfd, psc);
1921 for (i = 0; i < psc->symcount; i++)
1923 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1924 return psc->syms[i]->name;
1931 cleanup_syms (sym_cache *psc)
1938 /* This is the version for "compressed" pdata. */
1941 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1943 # define PDATA_ROW_SIZE (2 * 4)
1944 FILE *file = (FILE *) vfile;
1945 bfd_byte *data = NULL;
1946 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1947 bfd_size_type datasize = 0;
1949 bfd_size_type start, stop;
1950 int onaline = PDATA_ROW_SIZE;
1951 struct sym_cache cache = {0, 0} ;
1954 || coff_section_data (abfd, section) == NULL
1955 || pei_section_data (abfd, section) == NULL)
1958 stop = pei_section_data (abfd, section)->virt_size;
1959 if ((stop % onaline) != 0)
1961 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1962 (long) stop, onaline);
1965 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1968 vma:\t\tBegin Prolog Function Flags Exception EH\n\
1969 \t\tAddress Length Length 32b exc Handler Data\n"));
1971 datasize = section->size;
1975 if (! bfd_malloc_and_get_section (abfd, section, &data))
1984 for (i = start; i < stop; i += onaline)
1988 bfd_vma prolog_length, function_length;
1989 int flag32bit, exception_flag;
1992 if (i + PDATA_ROW_SIZE > stop)
1995 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1996 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
1998 if (begin_addr == 0 && other_data == 0)
1999 /* We are probably into the padding of the section now. */
2002 prolog_length = (other_data & 0x000000FF);
2003 function_length = (other_data & 0x3FFFFF00) >> 8;
2004 flag32bit = (int)((other_data & 0x40000000) >> 30);
2005 exception_flag = (int)((other_data & 0x80000000) >> 31);
2008 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2009 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2010 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2011 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2012 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
2014 /* Get the exception handler's address and the data passed from the
2015 .text section. This is really the data that belongs with the .pdata
2016 but got "compressed" out for the ARM and SH4 architectures. */
2017 tsection = bfd_get_section_by_name (abfd, ".text");
2018 if (tsection && coff_section_data (abfd, tsection)
2019 && pei_section_data (abfd, tsection))
2021 bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2024 tdata = (bfd_byte *) bfd_malloc (8);
2027 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2029 bfd_vma eh, eh_data;
2031 eh = bfd_get_32 (abfd, tdata);
2032 eh_data = bfd_get_32 (abfd, tdata + 4);
2033 fprintf (file, "%08x ", (unsigned int) eh);
2034 fprintf (file, "%08x", (unsigned int) eh_data);
2037 const char *s = my_symbol_for_address (abfd, eh, &cache);
2040 fprintf (file, " (%s) ", s);
2047 fprintf (file, "\n");
2052 cleanup_syms (& cache);
2055 #undef PDATA_ROW_SIZE
2059 #define IMAGE_REL_BASED_HIGHADJ 4
2060 static const char * const tbl[] =
2074 "UNKNOWN", /* MUST be last. */
2078 pe_print_reloc (bfd * abfd, void * vfile)
2080 FILE *file = (FILE *) vfile;
2082 asection *section = bfd_get_section_by_name (abfd, ".reloc");
2084 bfd_size_type start, stop;
2086 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2090 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2092 if (! bfd_malloc_and_get_section (abfd, section, &data))
2101 stop = section->size;
2103 for (i = start; i < stop;)
2106 bfd_vma virtual_address;
2109 /* The .reloc section is a sequence of blocks, with a header consisting
2110 of two 32 bit quantities, followed by a number of 16 bit entries. */
2111 virtual_address = bfd_get_32 (abfd, data+i);
2112 size = bfd_get_32 (abfd, data+i+4);
2113 number = (size - 8) / 2;
2119 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2120 (unsigned long) virtual_address, size, (unsigned long) size, number);
2122 for (j = 0; j < number; ++j)
2124 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
2125 unsigned int t = (e & 0xF000) >> 12;
2126 int off = e & 0x0FFF;
2128 if (t >= sizeof (tbl) / sizeof (tbl[0]))
2129 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2132 _("\treloc %4d offset %4x [%4lx] %s"),
2133 j, off, (unsigned long) (off + virtual_address), tbl[t]);
2135 /* HIGHADJ takes an argument, - the next record *is* the
2136 low 16 bits of addend. */
2137 if (t == IMAGE_REL_BASED_HIGHADJ)
2139 fprintf (file, " (%4x)",
2141 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
2145 fprintf (file, "\n");
2156 /* A data structure describing the regions of a .rsrc section.
2157 Some fields are filled in as the section is parsed. */
2159 typedef struct rsrc_regions
2161 bfd_byte * section_start;
2162 bfd_byte * section_end;
2163 bfd_byte * strings_start;
2164 bfd_byte * resource_start;
2168 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2169 rsrc_regions *, bfd_vma);
2172 rsrc_print_resource_entries (FILE * file,
2174 unsigned int indent,
2175 bfd_boolean is_name,
2177 rsrc_regions * regions,
2180 unsigned long entry, addr, size;
2182 if (data + 8 >= regions->section_end)
2183 return regions->section_end + 1;
2185 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2187 entry = (long) bfd_get_32 (abfd, data);
2192 /* Note - the documentation says that this field is an RVA value
2193 but windres appears to produce a section relative offset with
2194 the top bit set. Support both styles for now. */
2195 if (HighBitSet (entry))
2196 name = regions->section_start + WithoutHighBit (entry);
2198 name = regions->section_start + entry - rva_bias;
2200 if (name + 2 < regions->section_end)
2204 if (regions->strings_start == NULL)
2205 regions->strings_start = name;
2207 len = bfd_get_16 (abfd, name);
2209 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2210 if (name + 2 + len * 2 < regions->section_end)
2212 /* This strange loop is to cope with multibyte characters. */
2216 fprintf (file, "%.1s", name);
2220 fprintf (file, _("<corrupt string length: %#x>"), len);
2223 fprintf (file, _("<corrupt string offset: %#lx>"), entry);
2226 fprintf (file, _("ID: %#08lx"), entry);
2228 entry = (long) bfd_get_32 (abfd, data + 4);
2229 fprintf (file, _(", Value: %#08lx\n"), entry);
2231 if (HighBitSet (entry))
2232 return rsrc_print_resource_directory (file, abfd, indent + 1,
2233 regions->section_start + WithoutHighBit (entry),
2236 if (regions->section_start + entry + 16 >= regions->section_end)
2237 return regions->section_end + 1;
2239 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2242 addr = (long) bfd_get_32 (abfd, regions->section_start + entry),
2243 size = (long) bfd_get_32 (abfd, regions->section_start + entry + 4),
2244 (int) bfd_get_32 (abfd, regions->section_start + entry + 8));
2246 /* Check that the reserved entry is 0. */
2247 if (bfd_get_32 (abfd, regions->section_start + entry + 12) != 0
2248 /* And that the data address/size is valid too. */
2249 || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2250 return regions->section_end + 1;
2252 if (regions->resource_start == NULL)
2253 regions->resource_start = regions->section_start + (addr - rva_bias);
2255 return regions->section_start + (addr - rva_bias) + size;
2258 #define max(a,b) ((a) > (b) ? (a) : (b))
2259 #define min(a,b) ((a) < (b) ? (a) : (b))
2262 rsrc_print_resource_directory (FILE * file,
2264 unsigned int indent,
2266 rsrc_regions * regions,
2269 unsigned int num_names, num_ids;
2270 bfd_byte * highest_data = data;
2272 if (data + 16 >= regions->section_end)
2273 return regions->section_end + 1;
2275 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2278 case 0: fprintf (file, "Type"); break;
2279 case 2: fprintf (file, "Name"); break;
2280 case 4: fprintf (file, "Language"); break;
2281 default: fprintf (file, "<unknown>"); break;
2284 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2285 (int) bfd_get_32 (abfd, data),
2286 (long) bfd_get_32 (abfd, data + 4),
2287 (int) bfd_get_16 (abfd, data + 8),
2288 (int) bfd_get_16 (abfd, data + 10),
2289 num_names = (int) bfd_get_16 (abfd, data + 12),
2290 num_ids = (int) bfd_get_16 (abfd, data + 14));
2293 while (num_names --)
2295 bfd_byte * entry_end;
2297 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2298 data, regions, rva_bias);
2300 highest_data = max (highest_data, entry_end);
2301 if (entry_end >= regions->section_end)
2307 bfd_byte * entry_end;
2309 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2310 data, regions, rva_bias);
2312 highest_data = max (highest_data, entry_end);
2313 if (entry_end >= regions->section_end)
2317 return max (highest_data, data);
2320 /* Display the contents of a .rsrc section. We do not try to
2321 reproduce the resources, windres does that. Instead we dump
2322 the tables in a human readable format. */
2325 rsrc_print_section (bfd * abfd, void * vfile)
2329 FILE * file = (FILE *) vfile;
2330 bfd_size_type datasize;
2333 rsrc_regions regions;
2335 pe = pe_data (abfd);
2339 section = bfd_get_section_by_name (abfd, ".rsrc");
2340 if (section == NULL)
2342 if (!(section->flags & SEC_HAS_CONTENTS))
2345 datasize = section->size;
2349 rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2351 if (! bfd_malloc_and_get_section (abfd, section, & data))
2358 regions.section_start = data;
2359 regions.section_end = data + datasize;
2360 regions.strings_start = NULL;
2361 regions.resource_start = NULL;
2364 fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2366 while (data < regions.section_end)
2368 bfd_byte * p = data;
2370 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2372 if (data == regions.section_end + 1)
2373 fprintf (file, _("Corrupt .rsrc section detected!\n"));
2376 /* Align data before continuing. */
2377 int align = (1 << section->alignment_power) - 1;
2379 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2380 rva_bias += data - p;
2382 /* For reasons that are unclear .rsrc sections are sometimes created
2383 aligned to a 1^3 boundary even when their alignment is set at
2384 1^2. Catch that case here before we issue a spurious warning
2386 if (data == (regions.section_end - 4))
2387 data = regions.section_end;
2388 else if (data < regions.section_end)
2389 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2393 if (regions.strings_start != NULL)
2394 fprintf (file, " String table starts at %03x\n",
2395 (int) (regions.strings_start - regions.section_start));
2396 if (regions.resource_start != NULL)
2397 fprintf (file, " Resources start at %03xx\n",
2398 (int) (regions.resource_start - regions.section_start));
2400 free (regions.section_start);
2404 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2406 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2423 pe_print_debugdata (bfd * abfd, void * vfile)
2425 FILE *file = (FILE *) vfile;
2426 pe_data_type *pe = pe_data (abfd);
2427 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2430 bfd_size_type dataoff;
2433 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2434 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2439 addr += extra->ImageBase;
2440 for (section = abfd->sections; section != NULL; section = section->next)
2442 if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2446 if (section == NULL)
2449 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2453 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2454 section->name, (unsigned long) addr);
2456 dataoff = addr - section->vma;
2459 _("Type Size Rva Offset\n"));
2461 /* Read the whole section. */
2462 if (!bfd_malloc_and_get_section (abfd, section, &data))
2469 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2471 const char *type_name;
2472 struct external_IMAGE_DEBUG_DIRECTORY *ext
2473 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2474 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2476 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2478 if ((idd.Type) > IMAGE_NUMBEROF_DEBUG_TYPES)
2479 type_name = debug_type_names[0];
2481 type_name = debug_type_names[idd.Type];
2483 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
2484 idd.Type, type_name, idd.SizeOfData,
2485 idd.AddressOfRawData, idd.PointerToRawData);
2487 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2489 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2490 char buffer[256 + 1];
2491 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2493 /* The debug entry doesn't have to have to be in a section,
2494 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2495 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2496 idd.SizeOfData, cvinfo))
2499 for (i = 0; i < cvinfo->SignatureLength; i++)
2500 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2502 fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2503 buffer[0], buffer[1], buffer[2], buffer[3],
2504 signature, cvinfo->Age);
2508 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2510 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2515 /* Print out the program headers. */
2518 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2520 FILE *file = (FILE *) vfile;
2522 pe_data_type *pe = pe_data (abfd);
2523 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2524 const char *subsystem_name = NULL;
2527 /* The MS dumpbin program reportedly ands with 0xff0f before
2528 printing the characteristics field. Not sure why. No reason to
2530 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2532 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2533 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2534 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2535 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2536 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2537 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2538 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2539 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2540 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2541 PF (IMAGE_FILE_SYSTEM, "system file");
2542 PF (IMAGE_FILE_DLL, "DLL");
2543 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2546 /* ctime implies '\n'. */
2548 time_t t = pe->coff.timestamp;
2549 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2552 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2553 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2555 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2556 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2558 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2559 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2564 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2567 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2570 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2577 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2579 fprintf (file, "\t(%s)",name);
2580 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2581 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2582 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2583 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2584 (unsigned long) i->SizeOfInitializedData);
2585 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2586 (unsigned long) i->SizeOfUninitializedData);
2587 fprintf (file, "AddressOfEntryPoint\t");
2588 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2589 fprintf (file, "\nBaseOfCode\t\t");
2590 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2591 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2592 /* PE32+ does not have BaseOfData member! */
2593 fprintf (file, "\nBaseOfData\t\t");
2594 bfd_fprintf_vma (abfd, file, i->BaseOfData);
2597 fprintf (file, "\nImageBase\t\t");
2598 bfd_fprintf_vma (abfd, file, i->ImageBase);
2599 fprintf (file, "\nSectionAlignment\t");
2600 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2601 fprintf (file, "\nFileAlignment\t\t");
2602 bfd_fprintf_vma (abfd, file, i->FileAlignment);
2603 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2604 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2605 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2606 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2607 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2608 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2609 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2610 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2611 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2612 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2614 switch (i->Subsystem)
2616 case IMAGE_SUBSYSTEM_UNKNOWN:
2617 subsystem_name = "unspecified";
2619 case IMAGE_SUBSYSTEM_NATIVE:
2620 subsystem_name = "NT native";
2622 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2623 subsystem_name = "Windows GUI";
2625 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2626 subsystem_name = "Windows CUI";
2628 case IMAGE_SUBSYSTEM_POSIX_CUI:
2629 subsystem_name = "POSIX CUI";
2631 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2632 subsystem_name = "Wince CUI";
2634 // These are from UEFI Platform Initialization Specification 1.1.
2635 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2636 subsystem_name = "EFI application";
2638 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2639 subsystem_name = "EFI boot service driver";
2641 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2642 subsystem_name = "EFI runtime driver";
2644 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2645 subsystem_name = "SAL runtime driver";
2647 // This is from revision 8.0 of the MS PE/COFF spec
2648 case IMAGE_SUBSYSTEM_XBOX:
2649 subsystem_name = "XBOX";
2651 // Added default case for clarity - subsystem_name is NULL anyway.
2653 subsystem_name = NULL;
2656 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2658 fprintf (file, "\t(%s)", subsystem_name);
2659 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2660 fprintf (file, "SizeOfStackReserve\t");
2661 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2662 fprintf (file, "\nSizeOfStackCommit\t");
2663 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2664 fprintf (file, "\nSizeOfHeapReserve\t");
2665 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2666 fprintf (file, "\nSizeOfHeapCommit\t");
2667 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2668 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2669 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2670 (unsigned long) i->NumberOfRvaAndSizes);
2672 fprintf (file, "\nThe Data Directory\n");
2673 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2675 fprintf (file, "Entry %1x ", j);
2676 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2677 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2678 fprintf (file, "%s\n", dir_names[j]);
2681 pe_print_idata (abfd, vfile);
2682 pe_print_edata (abfd, vfile);
2683 if (bfd_coff_have_print_pdata (abfd))
2684 bfd_coff_print_pdata (abfd, vfile);
2686 pe_print_pdata (abfd, vfile);
2687 pe_print_reloc (abfd, vfile);
2688 pe_print_debugdata (abfd, file);
2690 rsrc_print_section (abfd, vfile);
2695 /* Copy any private info we understand from the input bfd
2696 to the output bfd. */
2699 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2701 pe_data_type *ipe, *ope;
2703 /* One day we may try to grok other private data. */
2704 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2705 || obfd->xvec->flavour != bfd_target_coff_flavour)
2708 ipe = pe_data (ibfd);
2709 ope = pe_data (obfd);
2711 /* pe_opthdr is copied in copy_object. */
2712 ope->dll = ipe->dll;
2714 /* Don't copy input subsystem if output is different from input. */
2715 if (obfd->xvec != ibfd->xvec)
2716 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2718 /* For strip: if we removed .reloc, we'll make a real mess of things
2719 if we don't remove this entry as well. */
2720 if (! pe_data (obfd)->has_reloc_section)
2722 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2723 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2726 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2727 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2729 if (! pe_data (ibfd)->has_reloc_section
2730 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2731 pe_data (obfd)->dont_strip_reloc = 1;
2736 /* Copy private section data. */
2739 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2744 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2745 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2748 if (coff_section_data (ibfd, isec) != NULL
2749 && pei_section_data (ibfd, isec) != NULL)
2751 if (coff_section_data (obfd, osec) == NULL)
2753 bfd_size_type amt = sizeof (struct coff_section_tdata);
2754 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2755 if (osec->used_by_bfd == NULL)
2759 if (pei_section_data (obfd, osec) == NULL)
2761 bfd_size_type amt = sizeof (struct pei_section_tdata);
2762 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2763 if (coff_section_data (obfd, osec)->tdata == NULL)
2767 pei_section_data (obfd, osec)->virt_size =
2768 pei_section_data (ibfd, isec)->virt_size;
2769 pei_section_data (obfd, osec)->pe_flags =
2770 pei_section_data (ibfd, isec)->pe_flags;
2777 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2779 coff_get_symbol_info (abfd, symbol, ret);
2782 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2784 sort_x64_pdata (const void *l, const void *r)
2786 const char *lp = (const char *) l;
2787 const char *rp = (const char *) r;
2789 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
2791 return (vl < vr ? -1 : 1);
2792 /* We compare just begin address. */
2797 /* Functions to process a .rsrc section. */
2799 static unsigned int sizeof_leaves;
2800 static unsigned int sizeof_strings;
2801 static unsigned int sizeof_tables_and_entries;
2804 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
2807 rsrc_count_entries (bfd * abfd,
2808 bfd_boolean is_name,
2809 bfd_byte * datastart,
2814 unsigned long entry, addr, size;
2816 if (data + 8 >= dataend)
2823 entry = (long) bfd_get_32 (abfd, data);
2825 if (HighBitSet (entry))
2826 name = datastart + WithoutHighBit (entry);
2828 name = datastart + entry - rva_bias;
2830 if (name + 2 >= dataend)
2833 unsigned int len = bfd_get_16 (abfd, name);
2834 if (len == 0 || len > 256)
2838 entry = (long) bfd_get_32 (abfd, data + 4);
2840 if (HighBitSet (entry))
2841 return rsrc_count_directory (abfd,
2843 datastart + WithoutHighBit (entry),
2846 if (datastart + entry + 16 >= dataend)
2849 addr = (long) bfd_get_32 (abfd, datastart + entry);
2850 size = (long) bfd_get_32 (abfd, datastart + entry + 4);
2852 return datastart + addr - rva_bias + size;
2856 rsrc_count_directory (bfd * abfd,
2857 bfd_byte * datastart,
2862 unsigned int num_entries, num_ids;
2863 bfd_byte * highest_data = data;
2865 if (data + 16 >= dataend)
2868 num_entries = (int) bfd_get_16 (abfd, data + 12);
2869 num_ids = (int) bfd_get_16 (abfd, data + 14);
2871 num_entries += num_ids;
2875 while (num_entries --)
2877 bfd_byte * entry_end;
2879 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
2880 datastart, data, dataend, rva_bias);
2882 highest_data = max (highest_data, entry_end);
2883 if (entry_end >= dataend)
2887 return max (highest_data, data);
2890 typedef struct rsrc_dir_chain
2892 unsigned int num_entries;
2893 struct rsrc_entry * first_entry;
2894 struct rsrc_entry * last_entry;
2897 typedef struct rsrc_directory
2899 unsigned int characteristics;
2904 rsrc_dir_chain names;
2907 struct rsrc_entry * entry;
2910 typedef struct rsrc_string
2916 typedef struct rsrc_leaf
2919 unsigned int codepage;
2923 typedef struct rsrc_entry
2925 bfd_boolean is_name;
2929 struct rsrc_string name;
2935 struct rsrc_directory * directory;
2936 struct rsrc_leaf * leaf;
2939 struct rsrc_entry * next_entry;
2940 struct rsrc_directory * parent;
2944 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
2945 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
2948 rsrc_parse_entry (bfd * abfd,
2949 bfd_boolean is_name,
2951 bfd_byte * datastart,
2955 rsrc_directory * parent)
2957 unsigned long val, addr, size;
2959 val = bfd_get_32 (abfd, data);
2961 entry->parent = parent;
2962 entry->is_name = is_name;
2966 /* FIXME: Add range checking ? */
2967 if (HighBitSet (val))
2969 val = WithoutHighBit (val);
2971 entry->name_id.name.len = bfd_get_16 (abfd, datastart + val);
2972 entry->name_id.name.string = datastart + val + 2;
2976 entry->name_id.name.len = bfd_get_16 (abfd, datastart + val
2978 entry->name_id.name.string = datastart + val - rva_bias + 2;
2982 entry->name_id.id = val;
2984 val = bfd_get_32 (abfd, data + 4);
2986 if (HighBitSet (val))
2988 entry->is_dir = TRUE;
2989 entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
2990 if (entry->value.directory == NULL)
2993 return rsrc_parse_directory (abfd, entry->value.directory,
2995 datastart + WithoutHighBit (val),
2996 dataend, rva_bias, entry);
2999 entry->is_dir = FALSE;
3000 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3001 if (entry->value.leaf == NULL)
3004 addr = bfd_get_32 (abfd, datastart + val);
3005 size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
3006 entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
3008 entry->value.leaf->data = bfd_malloc (size);
3009 if (entry->value.leaf->data == NULL)
3012 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3013 return datastart + (addr - rva_bias) + size;
3017 rsrc_parse_entries (bfd * abfd,
3018 rsrc_dir_chain * chain,
3019 bfd_boolean is_name,
3020 bfd_byte * highest_data,
3021 bfd_byte * datastart,
3025 rsrc_directory * parent)
3030 if (chain->num_entries == 0)
3032 chain->first_entry = chain->last_entry = NULL;
3033 return highest_data;
3036 entry = bfd_malloc (sizeof * entry);
3040 chain->first_entry = entry;
3042 for (i = chain->num_entries; i--;)
3044 bfd_byte * entry_end;
3046 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3047 data, dataend, rva_bias, parent);
3049 highest_data = max (entry_end, highest_data);
3050 if (entry_end > dataend)
3055 entry->next_entry = bfd_malloc (sizeof * entry);
3056 entry = entry->next_entry;
3061 entry->next_entry = NULL;
3064 chain->last_entry = entry;
3066 return highest_data;
3070 rsrc_parse_directory (bfd * abfd,
3071 rsrc_directory * table,
3072 bfd_byte * datastart,
3078 bfd_byte * highest_data = data;
3083 table->characteristics = bfd_get_32 (abfd, data);
3084 table->time = bfd_get_32 (abfd, data + 4);
3085 table->major = bfd_get_16 (abfd, data + 8);
3086 table->minor = bfd_get_16 (abfd, data + 10);
3087 table->names.num_entries = bfd_get_16 (abfd, data + 12);
3088 table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3089 table->entry = entry;
3093 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3094 datastart, data, dataend, rva_bias, table);
3095 data += table->names.num_entries * 8;
3097 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3098 datastart, data, dataend, rva_bias, table);
3099 data += table->ids.num_entries * 8;
3101 return max (highest_data, data);
3104 typedef struct rsrc_write_data
3107 bfd_byte * datastart;
3108 bfd_byte * next_table;
3109 bfd_byte * next_leaf;
3110 bfd_byte * next_string;
3111 bfd_byte * next_data;
3116 rsrc_write_string (rsrc_write_data * data,
3117 rsrc_string * string)
3119 bfd_put_16 (data->abfd, string->len, data->next_string);
3120 memcpy (data->next_string + 2, string->string, string->len * 2);
3121 data->next_string += (string->len + 1) * 2;
3124 static inline unsigned int
3125 rsrc_compute_rva (rsrc_write_data * data,
3128 return (addr - data->datastart) + data->rva_bias;
3132 rsrc_write_leaf (rsrc_write_data * data,
3135 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3137 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4);
3138 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3139 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3140 data->next_leaf += 16;
3142 memcpy (data->next_data, leaf->data, leaf->size);
3143 /* An undocumented feature of Windows resources is that each unit
3144 of raw data is 8-byte aligned... */
3145 data->next_data += ((leaf->size + 7) & ~7);
3148 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3151 rsrc_write_entry (rsrc_write_data * data,
3157 bfd_put_32 (data->abfd,
3158 SetHighBit (data->next_string - data->datastart),
3160 rsrc_write_string (data, & entry->name_id.name);
3163 bfd_put_32 (data->abfd, entry->name_id.id, where);
3167 bfd_put_32 (data->abfd,
3168 SetHighBit (data->next_table - data->datastart),
3170 rsrc_write_directory (data, entry->value.directory);
3174 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3175 rsrc_write_leaf (data, entry->value.leaf);
3180 rsrc_compute_region_sizes (rsrc_directory * dir)
3182 struct rsrc_entry * entry;
3187 sizeof_tables_and_entries += 16;
3189 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3191 sizeof_tables_and_entries += 8;
3193 sizeof_strings += (entry->name_id.name.len + 1) * 2;
3196 rsrc_compute_region_sizes (entry->value.directory);
3198 sizeof_leaves += 16;
3201 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3203 sizeof_tables_and_entries += 8;
3206 rsrc_compute_region_sizes (entry->value.directory);
3208 sizeof_leaves += 16;
3213 rsrc_write_directory (rsrc_write_data * data,
3214 rsrc_directory * dir)
3218 bfd_byte * next_entry;
3221 bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3222 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3223 bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3224 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3225 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3226 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3228 /* Compute where the entries and the next table will be placed. */
3229 next_entry = data->next_table + 16;
3230 data->next_table = next_entry + (dir->names.num_entries * 8)
3231 + (dir->ids.num_entries * 8);
3232 nt = data->next_table;
3234 /* Write the entries. */
3235 for (i = dir->names.num_entries, entry = dir->names.first_entry;
3236 i > 0 && entry != NULL;
3237 i--, entry = entry->next_entry)
3239 BFD_ASSERT (entry->is_name);
3240 rsrc_write_entry (data, next_entry, entry);
3243 BFD_ASSERT (i == 0);
3244 BFD_ASSERT (entry == NULL);
3246 for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3247 i > 0 && entry != NULL;
3248 i--, entry = entry->next_entry)
3250 BFD_ASSERT (! entry->is_name);
3251 rsrc_write_entry (data, next_entry, entry);
3254 BFD_ASSERT (i == 0);
3255 BFD_ASSERT (entry == NULL);
3256 BFD_ASSERT (nt == next_entry);
3259 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3260 /* Return the length (number of units) of the first character in S,
3261 putting its 'ucs4_t' representation in *PUC. */
3264 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3266 unsigned short c = * s;
3268 if (c < 0xd800 || c >= 0xe000)
3278 if (s[1] >= 0xdc00 && s[1] < 0xe000)
3280 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3286 /* Incomplete multibyte character. */
3292 /* Invalid multibyte character. */
3296 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3298 /* Perform a comparison of two entries. */
3300 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3309 return a->name_id.id - b->name_id.id;
3311 /* We have to perform a case insenstive, unicode string comparison... */
3312 astring = a->name_id.name.string;
3313 alen = a->name_id.name.len;
3314 bstring = b->name_id.name.string;
3315 blen = b->name_id.name.len;
3317 #if defined __CYGWIN__ || defined __MINGW32__
3318 /* Under Windows hosts (both Cygwin and Mingw types),
3319 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3320 function however goes by different names in the two environments... */
3324 #define rscpcmp wcsncasecmp
3327 #define rscpcmp wcsnicmp
3330 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3333 #elif defined HAVE_WCHAR_H
3337 for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3342 /* Convert UTF-16 unicode characters into wchar_t characters so
3343 that we can then perform a case insensitive comparison. */
3344 int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3345 int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3349 res = wcsncasecmp (& awc, & bwc, 1);
3355 /* Do the best we can - a case sensitive, untranslated comparison. */
3356 res = memcmp (astring, bstring, min (alen, blen) * 2);
3366 rsrc_print_name (char * buffer, rsrc_string string)
3369 bfd_byte * name = string.string;
3371 for (i = string.len; i--; name += 2)
3372 sprintf (buffer + strlen (buffer), "%.1s", name);
3376 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3378 static char buffer [256];
3379 bfd_boolean is_string = FALSE;
3383 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3384 && dir->entry->parent->entry != NULL)
3386 strcpy (buffer, "type: ");
3387 if (dir->entry->parent->entry->is_name)
3388 rsrc_print_name (buffer + strlen (buffer),
3389 dir->entry->parent->entry->name_id.name);
3392 unsigned int id = dir->entry->parent->entry->name_id.id;
3394 sprintf (buffer + strlen (buffer), "%x", id);
3397 case 1: strcat (buffer, " (CURSOR)"); break;
3398 case 2: strcat (buffer, " (BITMAP)"); break;
3399 case 3: strcat (buffer, " (ICON)"); break;
3400 case 4: strcat (buffer, " (MENU)"); break;
3401 case 5: strcat (buffer, " (DIALOG)"); break;
3402 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3403 case 7: strcat (buffer, " (FONTDIR)"); break;
3404 case 8: strcat (buffer, " (FONT)"); break;
3405 case 9: strcat (buffer, " (ACCELERATOR)"); break;
3406 case 10: strcat (buffer, " (RCDATA)"); break;
3407 case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3408 case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3409 case 14: strcat (buffer, " (GROUP_ICON)"); break;
3410 case 16: strcat (buffer, " (VERSION)"); break;
3411 case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3412 case 19: strcat (buffer, " (PLUGPLAY)"); break;
3413 case 20: strcat (buffer, " (VXD)"); break;
3414 case 21: strcat (buffer, " (ANICURSOR)"); break;
3415 case 22: strcat (buffer, " (ANIICON)"); break;
3416 case 23: strcat (buffer, " (HTML)"); break;
3417 case 24: strcat (buffer, " (MANIFEST)"); break;
3418 case 240: strcat (buffer, " (DLGINIT)"); break;
3419 case 241: strcat (buffer, " (TOOLBAR)"); break;
3424 if (dir != NULL && dir->entry != NULL)
3426 strcat (buffer, " name: ");
3427 if (dir->entry->is_name)
3428 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3431 unsigned int id = dir->entry->name_id.id;
3433 sprintf (buffer + strlen (buffer), "%x", id);
3436 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3437 (id - 1) << 4, (id << 4) - 1);
3443 strcat (buffer, " lang: ");
3446 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3448 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3454 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3455 their ID is stored in the NAME entry. The bottom four bits are used as
3456 an index into unicode string table that makes up the data of the leaf.
3457 So identical type-name-lang string resources may not actually be
3460 This function is called when we have detected two string resources with
3461 match top-28-bit IDs. We have to scan the string tables inside the leaves
3462 and discover if there are any real collisions. If there are then we report
3463 them and return FALSE. Otherwise we copy any strings from B into A and
3464 then return TRUE. */
3467 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3468 rsrc_entry * b ATTRIBUTE_UNUSED)
3470 unsigned int copy_needed = 0;
3474 bfd_byte * new_data;
3477 /* Step one: Find out what we have to do. */
3478 BFD_ASSERT (! a->is_dir);
3479 astring = a->value.leaf->data;
3481 BFD_ASSERT (! b->is_dir);
3482 bstring = b->value.leaf->data;
3484 for (i = 0; i < 16; i++)
3486 unsigned int alen = astring[0] + (astring[1] << 8);
3487 unsigned int blen = bstring[0] + (bstring[1] << 8);
3491 copy_needed += blen * 2;
3495 else if (alen != blen)
3496 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3498 /* alen == blen != 0. We might have two identical strings. If so we
3499 can ignore the second one. There is no need for wchar_t vs UTF-16
3500 theatrics here - we are only interested in (case sensitive) equality. */
3501 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3504 astring += (alen + 1) * 2;
3505 bstring += (blen + 1) * 2;
3510 if (a->parent != NULL
3511 && a->parent->entry != NULL
3512 && a->parent->entry->is_name == FALSE)
3513 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3514 ((a->parent->entry->name_id.id - 1) << 4) + i);
3518 if (copy_needed == 0)
3521 /* If we reach here then A and B must both have non-colliding strings.
3522 (We never get string resources with fully empty string tables).
3523 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3525 new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3526 if (new_data == NULL)
3530 astring = a->value.leaf->data;
3531 bstring = b->value.leaf->data;
3533 for (i = 0; i < 16; i++)
3535 unsigned int alen = astring[0] + (astring[1] << 8);
3536 unsigned int blen = bstring[0] + (bstring[1] << 8);
3540 memcpy (nstring, astring, (alen + 1) * 2);
3541 nstring += (alen + 1) * 2;
3545 memcpy (nstring, bstring, (blen + 1) * 2);
3546 nstring += (blen + 1) * 2;
3554 astring += (alen + 1) * 2;
3555 bstring += (blen + 1) * 2;
3558 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3560 free (a->value.leaf->data);
3561 a->value.leaf->data = new_data;
3562 a->value.leaf->size += copy_needed;
3567 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3569 /* Sort the entries in given part of the directory.
3570 We use an old fashioned bubble sort because we are dealing
3571 with lists and we want to handle matches specially. */
3574 rsrc_sort_entries (rsrc_dir_chain * chain,
3575 bfd_boolean is_name,
3576 rsrc_directory * dir)
3580 rsrc_entry ** points_to_entry;
3581 bfd_boolean swapped;
3583 if (chain->num_entries < 2)
3589 points_to_entry = & chain->first_entry;
3590 entry = * points_to_entry;
3591 next = entry->next_entry;
3595 signed int cmp = rsrc_cmp (is_name, entry, next);
3599 entry->next_entry = next->next_entry;
3600 next->next_entry = entry;
3601 * points_to_entry = next;
3602 points_to_entry = & next->next_entry;
3603 next = entry->next_entry;
3608 if (entry->is_dir && next->is_dir)
3610 /* When we encounter identical directory entries we have to
3611 merge them together. The exception to this rule is for
3612 resource manifests - there can only be one of these,
3613 even if they differ in language. Zero-language manifests
3614 are assumed to be default manifests (provided by the
3615 Cygwin/MinGW build system) and these can be silently dropped,
3616 unless that would reduce the number of manifests to zero.
3617 There should only ever be one non-zero lang manifest -
3618 if there are more it is an error. A non-zero lang
3619 manifest takes precedence over a default manifest. */
3620 if (entry->is_name == FALSE
3621 && entry->name_id.id == 1
3623 && dir->entry != NULL
3624 && dir->entry->is_name == FALSE
3625 && dir->entry->name_id.id == 0x18)
3627 if (next->value.directory->names.num_entries == 0
3628 && next->value.directory->ids.num_entries == 1
3629 && next->value.directory->ids.first_entry->is_name == FALSE
3630 && next->value.directory->ids.first_entry->name_id.id == 0)
3631 /* Fall through so that NEXT is dropped. */
3633 else if (entry->value.directory->names.num_entries == 0
3634 && entry->value.directory->ids.num_entries == 1
3635 && entry->value.directory->ids.first_entry->is_name == FALSE
3636 && entry->value.directory->ids.first_entry->name_id.id == 0)
3638 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3639 entry->next_entry = next->next_entry;
3640 next->next_entry = entry;
3641 * points_to_entry = next;
3642 points_to_entry = & next->next_entry;
3643 next = entry->next_entry;
3648 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3649 bfd_set_error (bfd_error_file_truncated);
3653 /* Unhook NEXT from the chain. */
3654 /* FIXME: memory loss here. */
3655 entry->next_entry = next->next_entry;
3656 chain->num_entries --;
3657 if (chain->num_entries < 2)
3659 next = next->next_entry;
3662 rsrc_merge (entry, next);
3664 else if (entry->is_dir != next->is_dir)
3666 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3667 bfd_set_error (bfd_error_file_truncated);
3672 /* Otherwise with identical leaves we issue an error
3673 message - because there should never be duplicates.
3674 The exception is Type 18/Name 1/Lang 0 which is the
3675 defaul manifest - this can just be dropped. */
3676 if (entry->is_name == FALSE
3677 && entry->name_id.id == 0
3679 && dir->entry != NULL
3680 && dir->entry->is_name == FALSE
3681 && dir->entry->name_id.id == 1
3682 && dir->entry->parent != NULL
3683 && dir->entry->parent->entry != NULL
3684 && dir->entry->parent->entry->is_name == FALSE
3685 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3687 else if (dir != NULL
3688 && dir->entry != NULL
3689 && dir->entry->parent != NULL
3690 && dir->entry->parent->entry != NULL
3691 && dir->entry->parent->entry->is_name == FALSE
3692 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3694 /* Strings need special handling. */
3695 if (! rsrc_merge_string_entries (entry, next))
3697 /* _bfd_error_handler should have been called inside merge_strings. */
3698 bfd_set_error (bfd_error_file_truncated);
3705 || dir->entry == NULL
3706 || dir->entry->parent == NULL
3707 || dir->entry->parent->entry == NULL)
3708 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3710 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3711 rsrc_resource_name (entry, dir));
3712 bfd_set_error (bfd_error_file_truncated);
3717 /* Unhook NEXT from the chain. */
3718 entry->next_entry = next->next_entry;
3719 chain->num_entries --;
3720 if (chain->num_entries < 2)
3722 next = next->next_entry;
3726 points_to_entry = & entry->next_entry;
3728 next = next->next_entry;
3733 chain->last_entry = entry;
3738 /* Attach B's chain onto A. */
3740 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
3742 if (bchain->num_entries == 0)
3745 achain->num_entries += bchain->num_entries;
3747 if (achain->first_entry == NULL)
3749 achain->first_entry = bchain->first_entry;
3750 achain->last_entry = bchain->last_entry;
3754 achain->last_entry->next_entry = bchain->first_entry;
3755 achain->last_entry = bchain->last_entry;
3758 bchain->num_entries = 0;
3759 bchain->first_entry = bchain->last_entry = NULL;
3763 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
3765 rsrc_directory * adir;
3766 rsrc_directory * bdir;
3768 BFD_ASSERT (a->is_dir);
3769 BFD_ASSERT (b->is_dir);
3771 adir = a->value.directory;
3772 bdir = b->value.directory;
3774 if (adir->characteristics != bdir->characteristics)
3776 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3777 bfd_set_error (bfd_error_file_truncated);
3781 if (adir->major != bdir->major || adir->minor != bdir->minor)
3783 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3784 bfd_set_error (bfd_error_file_truncated);
3788 /* Attach B's name chain to A. */
3789 rsrc_attach_chain (& adir->names, & bdir->names);
3791 /* Attach B's ID chain to A. */
3792 rsrc_attach_chain (& adir->ids, & bdir->ids);
3794 /* Now sort A's entries. */
3795 rsrc_sort_entries (& adir->names, TRUE, adir);
3796 rsrc_sort_entries (& adir->ids, FALSE, adir);
3799 /* Check the .rsrc section. If it contains multiple concatenated
3800 resources then we must merge them properly. Otherwise Windows
3801 will ignore all but the first set. */
3804 rsrc_process_section (bfd * abfd,
3805 struct coff_final_link_info * pfinfo)
3807 rsrc_directory new_table;
3813 bfd_byte * datastart;
3815 bfd_byte * new_data;
3816 unsigned int num_resource_sets;
3817 rsrc_directory * type_tables;
3818 rsrc_write_data write_data;
3821 unsigned int num_input_rsrc = 0;
3822 unsigned int max_num_input_rsrc = 4;
3823 ptrdiff_t * rsrc_sizes = NULL;
3825 new_table.names.num_entries = 0;
3826 new_table.ids.num_entries = 0;
3828 sec = bfd_get_section_by_name (abfd, ".rsrc");
3829 if (sec == NULL || (size = sec->rawsize) == 0)
3832 pe = pe_data (abfd);
3836 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3838 data = bfd_malloc (size);
3843 if (! bfd_get_section_contents (abfd, sec, data, 0, size))
3846 /* Step zero: Scan the input bfds looking for .rsrc sections and record
3847 their lengths. Note - we rely upon the fact that the linker script
3848 does *not* sort the input .rsrc sections, so that the order in the
3849 linkinfo list matches the order in the output .rsrc section.
3851 We need to know the lengths because each input .rsrc section has padding
3852 at the end of a variable amount. (It does not appear to be based upon
3853 the section alignment or the file alignment). We need to skip any
3854 padding bytes when parsing the input .rsrc sections. */
3855 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
3856 if (rsrc_sizes == NULL)
3859 for (input = pfinfo->info->input_bfds;
3861 input = input->link_next)
3863 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
3865 if (rsrc_sec != NULL)
3867 if (num_input_rsrc == max_num_input_rsrc)
3869 max_num_input_rsrc += 10;
3870 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
3871 * sizeof * rsrc_sizes);
3872 if (rsrc_sizes == NULL)
3876 BFD_ASSERT (rsrc_sec->size > 0);
3877 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
3881 if (num_input_rsrc < 2)
3884 /* Step one: Walk the section, computing the size of the tables,
3885 leaves and data and decide if we need to do anything. */
3886 dataend = data + size;
3887 num_resource_sets = 0;
3889 while (data < dataend)
3891 bfd_byte * p = data;
3893 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
3897 /* Corrupted .rsrc section - cannot merge. */
3898 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
3899 bfd_get_filename (abfd));
3900 bfd_set_error (bfd_error_file_truncated);
3904 if ((data - p) > rsrc_sizes [num_resource_sets])
3906 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
3907 bfd_get_filename (abfd));
3908 bfd_set_error (bfd_error_file_truncated);
3911 /* FIXME: Should we add a check for "data - p" being much smaller
3912 than rsrc_sizes[num_resource_sets] ? */
3914 data = p + rsrc_sizes[num_resource_sets];
3915 rva_bias += data - p;
3916 ++ num_resource_sets;
3918 BFD_ASSERT (num_resource_sets == num_input_rsrc);
3920 /* Step two: Walk the data again, building trees of the resources. */
3922 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3924 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
3925 if (type_tables == NULL)
3929 while (data < dataend)
3931 bfd_byte * p = data;
3933 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
3934 dataend, rva_bias, NULL);
3935 data = p + rsrc_sizes[indx];
3936 rva_bias += data - p;
3939 BFD_ASSERT (indx == num_resource_sets);
3941 /* Step three: Merge the top level tables (there can be only one).
3943 We must ensure that the merged entries are in ascending order.
3945 We also thread the top level table entries from the old tree onto
3946 the new table, so that they can be pulled off later. */
3948 /* FIXME: Should we verify that all type tables are the same ? */
3949 new_table.characteristics = type_tables[0].characteristics;
3950 new_table.time = type_tables[0].time;
3951 new_table.major = type_tables[0].major;
3952 new_table.minor = type_tables[0].minor;
3954 /* Chain the NAME entries onto the table. */
3955 new_table.names.first_entry = NULL;
3956 new_table.names.last_entry = NULL;
3958 for (indx = 0; indx < num_resource_sets; indx++)
3959 rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
3961 rsrc_sort_entries (& new_table.names, TRUE, & new_table);
3963 /* Chain the ID entries onto the table. */
3964 new_table.ids.first_entry = NULL;
3965 new_table.ids.last_entry = NULL;
3967 for (indx = 0; indx < num_resource_sets; indx++)
3968 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
3970 rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
3972 /* Step four: Create new contents for the .rsrc section. */
3973 /* Step four point one: Compute the size of each region of the .rsrc section.
3974 We do this now, rather than earlier, as the merging above may have dropped
3976 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
3977 rsrc_compute_region_sizes (& new_table);
3978 /* We increment sizeof_strings to make sure that resource data
3979 starts on an 8-byte boundary. FIXME: Is this correct ? */
3980 sizeof_strings = (sizeof_strings + 7) & ~ 7;
3982 new_data = bfd_malloc (size);
3983 if (new_data == NULL)
3986 write_data.abfd = abfd;
3987 write_data.datastart = new_data;
3988 write_data.next_table = new_data;
3989 write_data.next_leaf = new_data + sizeof_tables_and_entries;
3990 write_data.next_string = write_data.next_leaf + sizeof_leaves;
3991 write_data.next_data = write_data.next_string + sizeof_strings;
3992 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3994 rsrc_write_directory (& write_data, & new_table);
3996 /* Step five: Replace the old contents with the new.
3997 We recompute the size as we may have lost entries due to mergeing. */
3998 size = ((write_data.next_data - new_data) + 3) & ~ 3;
3999 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4000 sec->size = sec->rawsize = size;
4003 /* Step six: Free all the memory that we have used. */
4004 /* FIXME: Free the resource tree, if we have one. */
4009 /* Handle the .idata section and other things that need symbol table
4013 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4015 struct coff_link_hash_entry *h1;
4016 struct bfd_link_info *info = pfinfo->info;
4017 bfd_boolean result = TRUE;
4019 /* There are a few fields that need to be filled in now while we
4020 have symbol table access.
4022 The .idata subsections aren't directly available as sections, but
4023 they are in the symbol table, so get them from there. */
4025 /* The import directory. This is the address of .idata$2, with size
4026 of .idata$2 + .idata$3. */
4027 h1 = coff_link_hash_lookup (coff_hash_table (info),
4028 ".idata$2", FALSE, FALSE, TRUE);
4031 /* PR ld/2729: We cannot rely upon all the output sections having been
4032 created properly, so check before referencing them. Issue a warning
4033 message for any sections tht could not be found. */
4034 if ((h1->root.type == bfd_link_hash_defined
4035 || h1->root.type == bfd_link_hash_defweak)
4036 && h1->root.u.def.section != NULL
4037 && h1->root.u.def.section->output_section != NULL)
4038 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4039 (h1->root.u.def.value
4040 + h1->root.u.def.section->output_section->vma
4041 + h1->root.u.def.section->output_offset);
4045 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4050 h1 = coff_link_hash_lookup (coff_hash_table (info),
4051 ".idata$4", FALSE, FALSE, TRUE);
4053 && (h1->root.type == bfd_link_hash_defined
4054 || h1->root.type == bfd_link_hash_defweak)
4055 && h1->root.u.def.section != NULL
4056 && h1->root.u.def.section->output_section != NULL)
4057 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4058 ((h1->root.u.def.value
4059 + h1->root.u.def.section->output_section->vma
4060 + h1->root.u.def.section->output_offset)
4061 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4065 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4070 /* The import address table. This is the size/address of
4072 h1 = coff_link_hash_lookup (coff_hash_table (info),
4073 ".idata$5", FALSE, FALSE, TRUE);
4075 && (h1->root.type == bfd_link_hash_defined
4076 || h1->root.type == bfd_link_hash_defweak)
4077 && h1->root.u.def.section != NULL
4078 && h1->root.u.def.section->output_section != NULL)
4079 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4080 (h1->root.u.def.value
4081 + h1->root.u.def.section->output_section->vma
4082 + h1->root.u.def.section->output_offset);
4086 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4091 h1 = coff_link_hash_lookup (coff_hash_table (info),
4092 ".idata$6", FALSE, FALSE, TRUE);
4094 && (h1->root.type == bfd_link_hash_defined
4095 || h1->root.type == bfd_link_hash_defweak)
4096 && h1->root.u.def.section != NULL
4097 && h1->root.u.def.section->output_section != NULL)
4098 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4099 ((h1->root.u.def.value
4100 + h1->root.u.def.section->output_section->vma
4101 + h1->root.u.def.section->output_offset)
4102 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4106 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4113 h1 = coff_link_hash_lookup (coff_hash_table (info),
4114 "__IAT_start__", FALSE, FALSE, TRUE);
4116 && (h1->root.type == bfd_link_hash_defined
4117 || h1->root.type == bfd_link_hash_defweak)
4118 && h1->root.u.def.section != NULL
4119 && h1->root.u.def.section->output_section != NULL)
4124 (h1->root.u.def.value
4125 + h1->root.u.def.section->output_section->vma
4126 + h1->root.u.def.section->output_offset);
4128 h1 = coff_link_hash_lookup (coff_hash_table (info),
4129 "__IAT_end__", FALSE, FALSE, TRUE);
4131 && (h1->root.type == bfd_link_hash_defined
4132 || h1->root.type == bfd_link_hash_defweak)
4133 && h1->root.u.def.section != NULL
4134 && h1->root.u.def.section->output_section != NULL)
4136 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4137 ((h1->root.u.def.value
4138 + h1->root.u.def.section->output_section->vma
4139 + h1->root.u.def.section->output_offset)
4141 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4142 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4143 iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4148 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4149 " because .idata$6 is missing"), abfd);
4155 h1 = coff_link_hash_lookup (coff_hash_table (info),
4156 (bfd_get_symbol_leading_char (abfd) != 0
4157 ? "__tls_used" : "_tls_used"),
4158 FALSE, FALSE, TRUE);
4161 if ((h1->root.type == bfd_link_hash_defined
4162 || h1->root.type == bfd_link_hash_defweak)
4163 && h1->root.u.def.section != NULL
4164 && h1->root.u.def.section->output_section != NULL)
4165 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4166 (h1->root.u.def.value
4167 + h1->root.u.def.section->output_section->vma
4168 + h1->root.u.def.section->output_offset
4169 - pe_data (abfd)->pe_opthdr.ImageBase);
4173 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4177 /* According to PECOFF sepcifications by Microsoft version 8.2
4178 the TLS data directory consists of 4 pointers, followed
4179 by two 4-byte integer. This implies that the total size
4180 is different for 32-bit and 64-bit executables. */
4181 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4182 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4184 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4188 /* If there is a .pdata section and we have linked pdata finally, we
4189 need to sort the entries ascending. */
4190 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4192 asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4196 bfd_size_type x = sec->rawsize;
4197 bfd_byte *tmp_data = NULL;
4200 tmp_data = bfd_malloc (x);
4202 if (tmp_data != NULL)
4204 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4208 12, sort_x64_pdata);
4209 bfd_set_section_contents (pfinfo->output_bfd, sec,
4218 rsrc_process_section (abfd, pfinfo);
4220 /* If we couldn't find idata$2, we either have an excessively
4221 trivial program or are in DEEP trouble; we have to assume trivial