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 && in->n_value > ((1ULL << 32) - 1)
240 && in->n_scnum == -1)
244 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
247 in->n_value -= sec->vma;
248 in->n_scnum = sec->target_index;
250 /* else: FIXME: The value is outside the range of any section. This
251 happens for __image_base__ and __ImageBase__ and maybe some other
252 symbols as well. We should find a way to handle these values. */
255 H_PUT_32 (abfd, in->n_value, ext->e_value);
256 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
258 if (sizeof (ext->e_type) == 2)
259 H_PUT_16 (abfd, in->n_type, ext->e_type);
261 H_PUT_32 (abfd, in->n_type, ext->e_type);
263 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
264 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
270 _bfd_XXi_swap_aux_in (bfd * abfd,
274 int indx ATTRIBUTE_UNUSED,
275 int numaux ATTRIBUTE_UNUSED,
278 AUXENT *ext = (AUXENT *) ext1;
279 union internal_auxent *in = (union internal_auxent *) in1;
284 if (ext->x_file.x_fname[0] == 0)
286 in->x_file.x_n.x_zeroes = 0;
287 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
290 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
298 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
299 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
300 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
301 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
302 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
303 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
309 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
310 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
312 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
315 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
316 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
320 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
321 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
322 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
323 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
324 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
325 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
326 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
327 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
332 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
336 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
337 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
342 _bfd_XXi_swap_aux_out (bfd * abfd,
346 int indx ATTRIBUTE_UNUSED,
347 int numaux ATTRIBUTE_UNUSED,
350 union internal_auxent *in = (union internal_auxent *) inp;
351 AUXENT *ext = (AUXENT *) extp;
353 memset (ext, 0, AUXESZ);
358 if (in->x_file.x_fname[0] == 0)
360 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
361 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
364 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
373 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
374 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
375 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
376 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
377 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
378 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
384 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
385 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
387 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
390 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
391 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
395 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
396 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
397 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
398 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
399 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
400 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
401 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
402 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
406 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
409 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
410 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
417 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
419 LINENO *ext = (LINENO *) ext1;
420 struct internal_lineno *in = (struct internal_lineno *) in1;
422 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
423 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
427 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
429 struct internal_lineno *in = (struct internal_lineno *) inp;
430 struct external_lineno *ext = (struct external_lineno *) outp;
431 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
433 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
438 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
442 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
443 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
444 struct internal_aouthdr *aouthdr_int
445 = (struct internal_aouthdr *) aouthdr_int1;
446 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
448 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
449 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
450 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
451 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
452 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
453 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
454 aouthdr_int->text_start =
455 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
456 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
457 /* PE32+ does not have data_start member! */
458 aouthdr_int->data_start =
459 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
460 a->BaseOfData = aouthdr_int->data_start;
463 a->Magic = aouthdr_int->magic;
464 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
465 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
466 a->SizeOfCode = aouthdr_int->tsize ;
467 a->SizeOfInitializedData = aouthdr_int->dsize ;
468 a->SizeOfUninitializedData = aouthdr_int->bsize ;
469 a->AddressOfEntryPoint = aouthdr_int->entry;
470 a->BaseOfCode = aouthdr_int->text_start;
471 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
472 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
473 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
474 a->MajorOperatingSystemVersion =
475 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
476 a->MinorOperatingSystemVersion =
477 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
478 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
479 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
480 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
481 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
482 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
483 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
484 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
485 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
486 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
487 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
488 a->SizeOfStackReserve =
489 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
490 a->SizeOfStackCommit =
491 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
492 a->SizeOfHeapReserve =
493 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
494 a->SizeOfHeapCommit =
495 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
496 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
497 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
502 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
504 /* If data directory is empty, rva also should be 0. */
506 H_GET_32 (abfd, src->DataDirectory[idx][1]);
508 a->DataDirectory[idx].Size = size;
511 a->DataDirectory[idx].VirtualAddress =
512 H_GET_32 (abfd, src->DataDirectory[idx][0]);
514 a->DataDirectory[idx].VirtualAddress = 0;
518 if (aouthdr_int->entry)
520 aouthdr_int->entry += a->ImageBase;
521 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
522 aouthdr_int->entry &= 0xffffffff;
526 if (aouthdr_int->tsize)
528 aouthdr_int->text_start += a->ImageBase;
529 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
530 aouthdr_int->text_start &= 0xffffffff;
534 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
535 /* PE32+ does not have data_start member! */
536 if (aouthdr_int->dsize)
538 aouthdr_int->data_start += a->ImageBase;
539 aouthdr_int->data_start &= 0xffffffff;
544 /* These three fields are normally set up by ppc_relocate_section.
545 In the case of reading a file in, we can pick them up from the
547 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
548 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
549 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
553 /* A support function for below. */
556 add_data_entry (bfd * abfd,
557 struct internal_extra_pe_aouthdr *aout,
562 asection *sec = bfd_get_section_by_name (abfd, name);
564 /* Add import directory information if it exists. */
566 && (coff_section_data (abfd, sec) != NULL)
567 && (pei_section_data (abfd, sec) != NULL))
569 /* If data directory is empty, rva also should be 0. */
570 int size = pei_section_data (abfd, sec)->virt_size;
571 aout->DataDirectory[idx].Size = size;
575 aout->DataDirectory[idx].VirtualAddress =
576 (sec->vma - base) & 0xffffffff;
577 sec->flags |= SEC_DATA;
583 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
585 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
586 pe_data_type *pe = pe_data (abfd);
587 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
588 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
590 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
592 sa = extra->SectionAlignment;
593 fa = extra->FileAlignment;
594 ib = extra->ImageBase;
596 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
597 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
598 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
600 if (aouthdr_in->tsize)
602 aouthdr_in->text_start -= ib;
603 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
604 aouthdr_in->text_start &= 0xffffffff;
608 if (aouthdr_in->dsize)
610 aouthdr_in->data_start -= ib;
611 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
612 aouthdr_in->data_start &= 0xffffffff;
616 if (aouthdr_in->entry)
618 aouthdr_in->entry -= ib;
619 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
620 aouthdr_in->entry &= 0xffffffff;
624 #define FA(x) (((x) + fa -1 ) & (- fa))
625 #define SA(x) (((x) + sa -1 ) & (- sa))
627 /* We like to have the sizes aligned. */
628 aouthdr_in->bsize = FA (aouthdr_in->bsize);
630 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
632 add_data_entry (abfd, extra, 0, ".edata", ib);
633 add_data_entry (abfd, extra, 2, ".rsrc", ib);
634 add_data_entry (abfd, extra, 3, ".pdata", ib);
636 /* In theory we do not need to call add_data_entry for .idata$2 or
637 .idata$5. It will be done in bfd_coff_final_link where all the
638 required information is available. If however, we are not going
639 to perform a final link, eg because we have been invoked by objcopy
640 or strip, then we need to make sure that these Data Directory
641 entries are initialised properly.
643 So - we copy the input values into the output values, and then, if
644 a final link is going to be performed, it can overwrite them. */
645 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
646 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
647 extra->DataDirectory[PE_TLS_TABLE] = tls;
649 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
650 /* Until other .idata fixes are made (pending patch), the entry for
651 .idata is needed for backwards compatibility. FIXME. */
652 add_data_entry (abfd, extra, 1, ".idata", ib);
654 /* For some reason, the virtual size (which is what's set by
655 add_data_entry) for .reloc is not the same as the size recorded
656 in this slot by MSVC; it doesn't seem to cause problems (so far),
657 but since it's the best we've got, use it. It does do the right
659 if (pe->has_reloc_section)
660 add_data_entry (abfd, extra, 5, ".reloc", ib);
669 for (sec = abfd->sections; sec; sec = sec->next)
671 int rounded = FA (sec->size);
673 /* The first non-zero section filepos is the header size.
674 Sections without contents will have a filepos of 0. */
676 hsize = sec->filepos;
677 if (sec->flags & SEC_DATA)
679 if (sec->flags & SEC_CODE)
681 /* The image size is the total VIRTUAL size (which is what is
682 in the virt_size field). Files have been seen (from MSVC
683 5.0 link.exe) where the file size of the .data segment is
684 quite small compared to the virtual size. Without this
685 fix, strip munges the file.
687 FIXME: We need to handle holes between sections, which may
688 happpen when we covert from another format. We just use
689 the virtual address and virtual size of the last section
690 for the image size. */
691 if (coff_section_data (abfd, sec) != NULL
692 && pei_section_data (abfd, sec) != NULL)
693 isize = (sec->vma - extra->ImageBase
694 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
697 aouthdr_in->dsize = dsize;
698 aouthdr_in->tsize = tsize;
699 extra->SizeOfHeaders = hsize;
700 extra->SizeOfImage = isize;
703 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
705 /* e.g. 219510000 is linker version 2.19 */
706 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
708 /* This piece of magic sets the "linker version" field to
710 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
711 aouthdr_out->standard.vstamp);
713 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
714 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
715 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
716 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
717 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
718 aouthdr_out->standard.text_start);
720 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
721 /* PE32+ does not have data_start member! */
722 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
723 aouthdr_out->standard.data_start);
726 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
727 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
728 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
729 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
730 aouthdr_out->MajorOperatingSystemVersion);
731 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
732 aouthdr_out->MinorOperatingSystemVersion);
733 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
734 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
735 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
736 aouthdr_out->MajorSubsystemVersion);
737 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
738 aouthdr_out->MinorSubsystemVersion);
739 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
740 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
741 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
742 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
743 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
744 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
745 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
746 aouthdr_out->SizeOfStackReserve);
747 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
748 aouthdr_out->SizeOfStackCommit);
749 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
750 aouthdr_out->SizeOfHeapReserve);
751 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
752 aouthdr_out->SizeOfHeapCommit);
753 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
754 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
755 aouthdr_out->NumberOfRvaAndSizes);
759 for (idx = 0; idx < 16; idx++)
761 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
762 aouthdr_out->DataDirectory[idx][0]);
763 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
764 aouthdr_out->DataDirectory[idx][1]);
772 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
775 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
776 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
778 if (pe_data (abfd)->has_reloc_section
779 || pe_data (abfd)->dont_strip_reloc)
780 filehdr_in->f_flags &= ~F_RELFLG;
782 if (pe_data (abfd)->dll)
783 filehdr_in->f_flags |= F_DLL;
785 filehdr_in->pe.e_magic = DOSMAGIC;
786 filehdr_in->pe.e_cblp = 0x90;
787 filehdr_in->pe.e_cp = 0x3;
788 filehdr_in->pe.e_crlc = 0x0;
789 filehdr_in->pe.e_cparhdr = 0x4;
790 filehdr_in->pe.e_minalloc = 0x0;
791 filehdr_in->pe.e_maxalloc = 0xffff;
792 filehdr_in->pe.e_ss = 0x0;
793 filehdr_in->pe.e_sp = 0xb8;
794 filehdr_in->pe.e_csum = 0x0;
795 filehdr_in->pe.e_ip = 0x0;
796 filehdr_in->pe.e_cs = 0x0;
797 filehdr_in->pe.e_lfarlc = 0x40;
798 filehdr_in->pe.e_ovno = 0x0;
800 for (idx = 0; idx < 4; idx++)
801 filehdr_in->pe.e_res[idx] = 0x0;
803 filehdr_in->pe.e_oemid = 0x0;
804 filehdr_in->pe.e_oeminfo = 0x0;
806 for (idx = 0; idx < 10; idx++)
807 filehdr_in->pe.e_res2[idx] = 0x0;
809 filehdr_in->pe.e_lfanew = 0x80;
811 /* This next collection of data are mostly just characters. It
812 appears to be constant within the headers put on NT exes. */
813 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
814 filehdr_in->pe.dos_message[1] = 0xcd09b400;
815 filehdr_in->pe.dos_message[2] = 0x4c01b821;
816 filehdr_in->pe.dos_message[3] = 0x685421cd;
817 filehdr_in->pe.dos_message[4] = 0x70207369;
818 filehdr_in->pe.dos_message[5] = 0x72676f72;
819 filehdr_in->pe.dos_message[6] = 0x63206d61;
820 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
821 filehdr_in->pe.dos_message[8] = 0x65622074;
822 filehdr_in->pe.dos_message[9] = 0x6e757220;
823 filehdr_in->pe.dos_message[10] = 0x206e6920;
824 filehdr_in->pe.dos_message[11] = 0x20534f44;
825 filehdr_in->pe.dos_message[12] = 0x65646f6d;
826 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
827 filehdr_in->pe.dos_message[14] = 0x24;
828 filehdr_in->pe.dos_message[15] = 0x0;
829 filehdr_in->pe.nt_signature = NT_SIGNATURE;
831 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
832 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
834 /* Only use a real timestamp if the option was chosen. */
835 if ((pe_data (abfd)->insert_timestamp))
836 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
838 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
839 filehdr_out->f_symptr);
840 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
841 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
842 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
844 /* Put in extra dos header stuff. This data remains essentially
845 constant, it just has to be tacked on to the beginning of all exes
847 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
848 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
849 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
850 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
851 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
852 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
853 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
854 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
855 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
856 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
857 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
858 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
859 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
860 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
862 for (idx = 0; idx < 4; idx++)
863 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
865 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
866 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
868 for (idx = 0; idx < 10; idx++)
869 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
871 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
873 for (idx = 0; idx < 16; idx++)
874 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
875 filehdr_out->dos_message[idx]);
877 /* Also put in the NT signature. */
878 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
884 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
886 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
887 FILHDR *filehdr_out = (FILHDR *) out;
889 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
890 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
891 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
892 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
893 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
894 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
895 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
901 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
903 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
904 SCNHDR *scnhdr_ext = (SCNHDR *) out;
905 unsigned int ret = SCNHSZ;
909 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
911 PUT_SCNHDR_VADDR (abfd,
912 ((scnhdr_int->s_vaddr
913 - pe_data (abfd)->pe_opthdr.ImageBase)
915 scnhdr_ext->s_vaddr);
917 /* NT wants the size data to be rounded up to the next
918 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
920 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
922 if (bfd_pei_p (abfd))
924 ps = scnhdr_int->s_size;
930 ss = scnhdr_int->s_size;
935 if (bfd_pei_p (abfd))
936 ps = scnhdr_int->s_paddr;
940 ss = scnhdr_int->s_size;
943 PUT_SCNHDR_SIZE (abfd, ss,
946 /* s_paddr in PE is really the virtual size. */
947 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
949 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
950 scnhdr_ext->s_scnptr);
951 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
952 scnhdr_ext->s_relptr);
953 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
954 scnhdr_ext->s_lnnoptr);
957 /* Extra flags must be set when dealing with PE. All sections should also
958 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
959 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
960 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
961 (this is especially important when dealing with the .idata section since
962 the addresses for routines from .dlls must be overwritten). If .reloc
963 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
964 (0x02000000). Also, the resource data should also be read and
967 /* FIXME: Alignment is also encoded in this field, at least on PPC and
968 ARM-WINCE. Although - how do we get the original alignment field
973 const char * section_name;
974 unsigned long must_have;
976 pe_required_section_flags;
978 pe_required_section_flags known_sections [] =
980 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
981 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
982 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
983 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
984 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
985 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
986 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
987 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
988 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
989 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
990 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
991 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
995 pe_required_section_flags * p;
997 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
998 we know exactly what this specific section wants so we remove it
999 and then allow the must_have field to add it back in if necessary.
1000 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1001 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1002 by ld --enable-auto-import (if auto-import is actually needed),
1003 by ld --omagic, or by obcopy --writable-text. */
1005 for (p = known_sections; p->section_name; p++)
1006 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1008 if (strcmp (scnhdr_int->s_name, ".text")
1009 || (bfd_get_file_flags (abfd) & WP_TEXT))
1010 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1011 scnhdr_int->s_flags |= p->must_have;
1015 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1018 if (coff_data (abfd)->link_info
1019 && ! coff_data (abfd)->link_info->relocatable
1020 && ! coff_data (abfd)->link_info->shared
1021 && strcmp (scnhdr_int->s_name, ".text") == 0)
1023 /* By inference from looking at MS output, the 32 bit field
1024 which is the combination of the number_of_relocs and
1025 number_of_linenos is used for the line number count in
1026 executables. A 16-bit field won't do for cc1. The MS
1027 document says that the number of relocs is zero for
1028 executables, but the 17-th bit has been observed to be there.
1029 Overflow is not an issue: a 4G-line program will overflow a
1030 bunch of other fields long before this! */
1031 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1032 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1036 if (scnhdr_int->s_nlnno <= 0xffff)
1037 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1040 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1041 bfd_get_filename (abfd),
1042 scnhdr_int->s_nlnno);
1043 bfd_set_error (bfd_error_file_truncated);
1044 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1048 /* Although we could encode 0xffff relocs here, we do not, to be
1049 consistent with other parts of bfd. Also it lets us warn, as
1050 we should never see 0xffff here w/o having the overflow flag
1052 if (scnhdr_int->s_nreloc < 0xffff)
1053 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1056 /* PE can deal with large #s of relocs, but not here. */
1057 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1058 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1059 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1066 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1068 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1069 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1071 in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1072 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1073 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1074 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1075 in->Type = H_GET_32(abfd, ext->Type);
1076 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1077 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1078 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1082 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1084 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1085 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1087 H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1088 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1089 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1090 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1091 H_PUT_32(abfd, in->Type, ext->Type);
1092 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1093 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1094 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1096 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1099 static CODEVIEW_INFO *
1100 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1104 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1107 if (bfd_bread (buffer, 256, abfd) < 4)
1110 /* ensure null termination of filename */
1113 cvinfo->CVSignature = H_GET_32(abfd, buffer);
1116 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1117 && (length > sizeof (CV_INFO_PDB70)))
1119 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1121 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1122 memcpy (cvinfo->Signature, cvinfo70->Signature, CV_INFO_SIGNATURE_LENGTH);
1123 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1124 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1128 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1129 && (length > sizeof (CV_INFO_PDB20)))
1131 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1132 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1133 memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1134 cvinfo->SignatureLength = 4;
1135 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1144 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1146 unsigned int size = sizeof (CV_INFO_PDB70) + 1;
1147 CV_INFO_PDB70 *cvinfo70;
1150 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1153 cvinfo70 = (CV_INFO_PDB70 *) buffer;
1154 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1155 memcpy (&(cvinfo70->Signature), cvinfo->Signature, CV_INFO_SIGNATURE_LENGTH);
1156 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1157 cvinfo70->PdbFileName[0] = '\0';
1159 if (bfd_bwrite (buffer, size, abfd) != size)
1165 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1167 N_("Export Directory [.edata (or where ever we found it)]"),
1168 N_("Import Directory [parts of .idata]"),
1169 N_("Resource Directory [.rsrc]"),
1170 N_("Exception Directory [.pdata]"),
1171 N_("Security Directory"),
1172 N_("Base Relocation Directory [.reloc]"),
1173 N_("Debug Directory"),
1174 N_("Description Directory"),
1175 N_("Special Directory"),
1176 N_("Thread Storage Directory [.tls]"),
1177 N_("Load Configuration Directory"),
1178 N_("Bound Import Directory"),
1179 N_("Import Address Table Directory"),
1180 N_("Delay Import Directory"),
1181 N_("CLR Runtime Header"),
1185 #ifdef POWERPC_LE_PE
1186 /* The code for the PPC really falls in the "architecture dependent"
1187 category. However, it's not clear that anyone will ever care, so
1188 we're ignoring the issue for now; if/when PPC matters, some of this
1189 may need to go into peicode.h, or arguments passed to enable the
1190 PPC- specific code. */
1194 pe_print_idata (bfd * abfd, void * vfile)
1196 FILE *file = (FILE *) vfile;
1201 #ifdef POWERPC_LE_PE
1202 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1205 bfd_size_type datasize = 0;
1206 bfd_size_type dataoff;
1210 pe_data_type *pe = pe_data (abfd);
1211 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1215 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1217 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1219 /* Maybe the extra header isn't there. Look for the section. */
1220 section = bfd_get_section_by_name (abfd, ".idata");
1221 if (section == NULL)
1224 addr = section->vma;
1225 datasize = section->size;
1231 addr += extra->ImageBase;
1232 for (section = abfd->sections; section != NULL; section = section->next)
1234 datasize = section->size;
1235 if (addr >= section->vma && addr < section->vma + datasize)
1239 if (section == NULL)
1242 _("\nThere is an import table, but the section containing it could not be found\n"));
1245 else if (!(section->flags & SEC_HAS_CONTENTS))
1248 _("\nThere is an import table in %s, but that section has no contents\n"),
1254 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1255 section->name, (unsigned long) addr);
1257 dataoff = addr - section->vma;
1259 #ifdef POWERPC_LE_PE
1260 if (rel_section != 0 && rel_section->size != 0)
1262 /* The toc address can be found by taking the starting address,
1263 which on the PPC locates a function descriptor. The
1264 descriptor consists of the function code starting address
1265 followed by the address of the toc. The starting address we
1266 get from the bfd, and the descriptor is supposed to be in the
1267 .reldata section. */
1269 bfd_vma loadable_toc_address;
1270 bfd_vma toc_address;
1271 bfd_vma start_address;
1275 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1282 offset = abfd->start_address - rel_section->vma;
1284 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1291 start_address = bfd_get_32 (abfd, data + offset);
1292 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1293 toc_address = loadable_toc_address - 32768;
1296 _("\nFunction descriptor located at the start address: %04lx\n"),
1297 (unsigned long int) (abfd->start_address));
1299 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1300 start_address, loadable_toc_address, toc_address);
1307 _("\nNo reldata section! Function descriptor not decoded.\n"));
1312 _("\nThe Import Tables (interpreted %s section contents)\n"),
1316 vma: Hint Time Forward DLL First\n\
1317 Table Stamp Chain Name Thunk\n"));
1319 /* Read the whole section. Some of the fields might be before dataoff. */
1320 if (!bfd_malloc_and_get_section (abfd, section, &data))
1327 adj = section->vma - extra->ImageBase;
1329 /* Print all image import descriptors. */
1330 for (i = dataoff; i + onaline <= datasize; i += onaline)
1334 bfd_vma forward_chain;
1336 bfd_vma first_thunk;
1341 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1342 fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1343 hint_addr = bfd_get_32 (abfd, data + i);
1344 time_stamp = bfd_get_32 (abfd, data + i + 4);
1345 forward_chain = bfd_get_32 (abfd, data + i + 8);
1346 dll_name = bfd_get_32 (abfd, data + i + 12);
1347 first_thunk = bfd_get_32 (abfd, data + i + 16);
1349 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1350 (unsigned long) hint_addr,
1351 (unsigned long) time_stamp,
1352 (unsigned long) forward_chain,
1353 (unsigned long) dll_name,
1354 (unsigned long) first_thunk);
1356 if (hint_addr == 0 && first_thunk == 0)
1359 if (dll_name - adj >= section->size)
1362 dll = (char *) data + dll_name - adj;
1363 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1368 asection *ft_section;
1370 bfd_size_type ft_datasize;
1374 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1376 idx = hint_addr - adj;
1378 ft_addr = first_thunk + extra->ImageBase;
1379 ft_idx = first_thunk - adj;
1380 ft_data = data + ft_idx;
1381 ft_datasize = datasize - ft_idx;
1384 if (first_thunk != hint_addr)
1386 /* Find the section which contains the first thunk. */
1387 for (ft_section = abfd->sections;
1389 ft_section = ft_section->next)
1391 if (ft_addr >= ft_section->vma
1392 && ft_addr < ft_section->vma + ft_section->size)
1396 if (ft_section == NULL)
1399 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1403 /* Now check to see if this section is the same as our current
1404 section. If it is not then we will have to load its data in. */
1405 if (ft_section != section)
1407 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1408 ft_datasize = ft_section->size - ft_idx;
1409 ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1410 if (ft_data == NULL)
1413 /* Read ft_datasize bytes starting at offset ft_idx. */
1414 if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1415 (bfd_vma) ft_idx, ft_datasize))
1424 /* Print HintName vector entries. */
1425 #ifdef COFF_WITH_pex64
1426 for (j = 0; idx + j + 8 <= datasize; j += 8)
1428 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1429 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1431 if (!member && !member_high)
1434 if (HighBitSet (member_high))
1435 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1436 member_high, member,
1437 WithoutHighBit (member_high), member);
1443 ordinal = bfd_get_16 (abfd, data + member - adj);
1444 member_name = (char *) data + member - adj + 2;
1445 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1448 /* If the time stamp is not zero, the import address
1449 table holds actual addresses. */
1452 && first_thunk != hint_addr
1453 && j + 4 <= ft_datasize)
1454 fprintf (file, "\t%04lx",
1455 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1456 fprintf (file, "\n");
1459 for (j = 0; idx + j + 4 <= datasize; j += 4)
1461 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1463 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1467 if (HighBitSet (member))
1468 fprintf (file, "\t%04lx\t %4lu <none>",
1469 member, WithoutHighBit (member));
1475 ordinal = bfd_get_16 (abfd, data + member - adj);
1476 member_name = (char *) data + member - adj + 2;
1477 fprintf (file, "\t%04lx\t %4d %s",
1478 member, ordinal, member_name);
1481 /* If the time stamp is not zero, the import address
1482 table holds actual addresses. */
1485 && first_thunk != hint_addr
1486 && j + 4 <= ft_datasize)
1487 fprintf (file, "\t%04lx",
1488 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1490 fprintf (file, "\n");
1497 fprintf (file, "\n");
1506 pe_print_edata (bfd * abfd, void * vfile)
1508 FILE *file = (FILE *) vfile;
1511 bfd_size_type datasize = 0;
1512 bfd_size_type dataoff;
1517 long export_flags; /* Reserved - should be zero. */
1521 bfd_vma name; /* RVA - relative to image base. */
1522 long base; /* Ordinal base. */
1523 unsigned long num_functions;/* Number in the export address table. */
1524 unsigned long num_names; /* Number in the name pointer table. */
1525 bfd_vma eat_addr; /* RVA to the export address table. */
1526 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1527 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1530 pe_data_type *pe = pe_data (abfd);
1531 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1535 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1537 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1539 /* Maybe the extra header isn't there. Look for the section. */
1540 section = bfd_get_section_by_name (abfd, ".edata");
1541 if (section == NULL)
1544 addr = section->vma;
1546 datasize = section->size;
1552 addr += extra->ImageBase;
1554 for (section = abfd->sections; section != NULL; section = section->next)
1555 if (addr >= section->vma && addr < section->vma + section->size)
1558 if (section == NULL)
1561 _("\nThere is an export table, but the section containing it could not be found\n"));
1564 else if (!(section->flags & SEC_HAS_CONTENTS))
1567 _("\nThere is an export table in %s, but that section has no contents\n"),
1572 dataoff = addr - section->vma;
1573 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1574 if (datasize > section->size - dataoff)
1577 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1583 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1584 section->name, (unsigned long) addr);
1586 data = (bfd_byte *) bfd_malloc (datasize);
1590 if (! bfd_get_section_contents (abfd, section, data,
1591 (file_ptr) dataoff, datasize))
1594 /* Go get Export Directory Table. */
1595 edt.export_flags = bfd_get_32 (abfd, data + 0);
1596 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1597 edt.major_ver = bfd_get_16 (abfd, data + 8);
1598 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1599 edt.name = bfd_get_32 (abfd, data + 12);
1600 edt.base = bfd_get_32 (abfd, data + 16);
1601 edt.num_functions = bfd_get_32 (abfd, data + 20);
1602 edt.num_names = bfd_get_32 (abfd, data + 24);
1603 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1604 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1605 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1607 adj = section->vma - extra->ImageBase + dataoff;
1609 /* Dump the EDT first. */
1611 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1615 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1618 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1621 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1624 _("Name \t\t\t\t"));
1625 bfd_fprintf_vma (abfd, file, edt.name);
1627 if ((edt.name >= adj) && (edt.name < adj + datasize))
1628 fprintf (file, " %s\n", data + edt.name - adj);
1630 fprintf (file, "(outside .edata section)\n");
1633 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1639 _("\tExport Address Table \t\t%08lx\n"),
1643 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1646 _("Table Addresses\n"));
1649 _("\tExport Address Table \t\t"));
1650 bfd_fprintf_vma (abfd, file, edt.eat_addr);
1651 fprintf (file, "\n");
1654 _("\tName Pointer Table \t\t"));
1655 bfd_fprintf_vma (abfd, file, edt.npt_addr);
1656 fprintf (file, "\n");
1659 _("\tOrdinal Table \t\t\t"));
1660 bfd_fprintf_vma (abfd, file, edt.ot_addr);
1661 fprintf (file, "\n");
1663 /* The next table to find is the Export Address Table. It's basically
1664 a list of pointers that either locate a function in this dll, or
1665 forward the call to another dll. Something like:
1670 } export_address_table_entry; */
1673 _("\nExport Address Table -- Ordinal Base %ld\n"),
1676 for (i = 0; i < edt.num_functions; ++i)
1678 bfd_vma eat_member = bfd_get_32 (abfd,
1679 data + edt.eat_addr + (i * 4) - adj);
1680 if (eat_member == 0)
1683 if (eat_member - adj <= datasize)
1685 /* This rva is to a name (forwarding function) in our section. */
1686 /* Should locate a function descriptor. */
1688 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1690 (long) (i + edt.base),
1691 (unsigned long) eat_member,
1693 data + eat_member - adj);
1697 /* Should locate a function descriptor in the reldata section. */
1699 "\t[%4ld] +base[%4ld] %04lx %s\n",
1701 (long) (i + edt.base),
1702 (unsigned long) eat_member,
1707 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1708 /* Dump them in parallel for clarity. */
1710 _("\n[Ordinal/Name Pointer] Table\n"));
1712 for (i = 0; i < edt.num_names; ++i)
1714 bfd_vma name_ptr = bfd_get_32 (abfd,
1719 char *name = (char *) data + name_ptr - adj;
1721 bfd_vma ord = bfd_get_16 (abfd,
1726 "\t[%4ld] %s\n", (long) ord, name);
1734 /* This really is architecture dependent. On IA-64, a .pdata entry
1735 consists of three dwords containing relative virtual addresses that
1736 specify the start and end address of the code range the entry
1737 covers and the address of the corresponding unwind info data.
1739 On ARM and SH-4, a compressed PDATA structure is used :
1740 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1741 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1742 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1744 This is the version for uncompressed data. */
1747 pe_print_pdata (bfd * abfd, void * vfile)
1749 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1750 # define PDATA_ROW_SIZE (3 * 8)
1752 # define PDATA_ROW_SIZE (5 * 4)
1754 FILE *file = (FILE *) vfile;
1756 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1757 bfd_size_type datasize = 0;
1759 bfd_size_type start, stop;
1760 int onaline = PDATA_ROW_SIZE;
1763 || coff_section_data (abfd, section) == NULL
1764 || pei_section_data (abfd, section) == NULL)
1767 stop = pei_section_data (abfd, section)->virt_size;
1768 if ((stop % onaline) != 0)
1770 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1771 (long) stop, onaline);
1774 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1775 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1777 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1780 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1781 \t\tAddress Address Handler Data Address Mask\n"));
1784 datasize = section->size;
1788 if (! bfd_malloc_and_get_section (abfd, section, &data))
1797 for (i = start; i < stop; i += onaline)
1803 bfd_vma prolog_end_addr;
1804 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1808 if (i + PDATA_ROW_SIZE > stop)
1811 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1812 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1813 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1814 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1815 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1817 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1818 && eh_data == 0 && prolog_end_addr == 0)
1819 /* We are probably into the padding of the section now. */
1822 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1823 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1825 eh_handler &= ~(bfd_vma) 0x3;
1826 prolog_end_addr &= ~(bfd_vma) 0x3;
1829 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1830 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1831 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1832 bfd_fprintf_vma (abfd, file, eh_handler);
1833 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1835 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1836 bfd_fprintf_vma (abfd, file, prolog_end_addr);
1837 fprintf (file, " %x", em_data);
1840 #ifdef POWERPC_LE_PE
1841 if (eh_handler == 0 && eh_data != 0)
1843 /* Special bits here, although the meaning may be a little
1844 mysterious. The only one I know for sure is 0x03
1847 0x01 Register Save Millicode
1848 0x02 Register Restore Millicode
1849 0x03 Glue Code Sequence. */
1853 fprintf (file, _(" Register save millicode"));
1856 fprintf (file, _(" Register restore millicode"));
1859 fprintf (file, _(" Glue code sequence"));
1866 fprintf (file, "\n");
1872 #undef PDATA_ROW_SIZE
1875 typedef struct sym_cache
1882 slurp_symtab (bfd *abfd, sym_cache *psc)
1884 asymbol ** sy = NULL;
1887 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1893 storage = bfd_get_symtab_upper_bound (abfd);
1897 sy = (asymbol **) bfd_malloc (storage);
1899 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1900 if (psc->symcount < 0)
1906 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1911 psc->syms = slurp_symtab (abfd, psc);
1913 for (i = 0; i < psc->symcount; i++)
1915 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1916 return psc->syms[i]->name;
1923 cleanup_syms (sym_cache *psc)
1930 /* This is the version for "compressed" pdata. */
1933 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1935 # define PDATA_ROW_SIZE (2 * 4)
1936 FILE *file = (FILE *) vfile;
1937 bfd_byte *data = NULL;
1938 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1939 bfd_size_type datasize = 0;
1941 bfd_size_type start, stop;
1942 int onaline = PDATA_ROW_SIZE;
1943 struct sym_cache cache = {0, 0} ;
1946 || coff_section_data (abfd, section) == NULL
1947 || pei_section_data (abfd, section) == NULL)
1950 stop = pei_section_data (abfd, section)->virt_size;
1951 if ((stop % onaline) != 0)
1953 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1954 (long) stop, onaline);
1957 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1960 vma:\t\tBegin Prolog Function Flags Exception EH\n\
1961 \t\tAddress Length Length 32b exc Handler Data\n"));
1963 datasize = section->size;
1967 if (! bfd_malloc_and_get_section (abfd, section, &data))
1976 for (i = start; i < stop; i += onaline)
1980 bfd_vma prolog_length, function_length;
1981 int flag32bit, exception_flag;
1984 if (i + PDATA_ROW_SIZE > stop)
1987 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1988 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
1990 if (begin_addr == 0 && other_data == 0)
1991 /* We are probably into the padding of the section now. */
1994 prolog_length = (other_data & 0x000000FF);
1995 function_length = (other_data & 0x3FFFFF00) >> 8;
1996 flag32bit = (int)((other_data & 0x40000000) >> 30);
1997 exception_flag = (int)((other_data & 0x80000000) >> 31);
2000 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2001 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2002 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2003 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2004 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
2006 /* Get the exception handler's address and the data passed from the
2007 .text section. This is really the data that belongs with the .pdata
2008 but got "compressed" out for the ARM and SH4 architectures. */
2009 tsection = bfd_get_section_by_name (abfd, ".text");
2010 if (tsection && coff_section_data (abfd, tsection)
2011 && pei_section_data (abfd, tsection))
2013 bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2016 tdata = (bfd_byte *) bfd_malloc (8);
2019 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2021 bfd_vma eh, eh_data;
2023 eh = bfd_get_32 (abfd, tdata);
2024 eh_data = bfd_get_32 (abfd, tdata + 4);
2025 fprintf (file, "%08x ", (unsigned int) eh);
2026 fprintf (file, "%08x", (unsigned int) eh_data);
2029 const char *s = my_symbol_for_address (abfd, eh, &cache);
2032 fprintf (file, " (%s) ", s);
2039 fprintf (file, "\n");
2044 cleanup_syms (& cache);
2047 #undef PDATA_ROW_SIZE
2051 #define IMAGE_REL_BASED_HIGHADJ 4
2052 static const char * const tbl[] =
2066 "UNKNOWN", /* MUST be last. */
2070 pe_print_reloc (bfd * abfd, void * vfile)
2072 FILE *file = (FILE *) vfile;
2074 asection *section = bfd_get_section_by_name (abfd, ".reloc");
2076 bfd_size_type start, stop;
2078 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2082 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2084 if (! bfd_malloc_and_get_section (abfd, section, &data))
2093 stop = section->size;
2095 for (i = start; i < stop;)
2098 bfd_vma virtual_address;
2101 /* The .reloc section is a sequence of blocks, with a header consisting
2102 of two 32 bit quantities, followed by a number of 16 bit entries. */
2103 virtual_address = bfd_get_32 (abfd, data+i);
2104 size = bfd_get_32 (abfd, data+i+4);
2105 number = (size - 8) / 2;
2111 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2112 (unsigned long) virtual_address, size, (unsigned long) size, number);
2114 for (j = 0; j < number; ++j)
2116 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
2117 unsigned int t = (e & 0xF000) >> 12;
2118 int off = e & 0x0FFF;
2120 if (t >= sizeof (tbl) / sizeof (tbl[0]))
2121 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2124 _("\treloc %4d offset %4x [%4lx] %s"),
2125 j, off, (unsigned long) (off + virtual_address), tbl[t]);
2127 /* HIGHADJ takes an argument, - the next record *is* the
2128 low 16 bits of addend. */
2129 if (t == IMAGE_REL_BASED_HIGHADJ)
2131 fprintf (file, " (%4x)",
2133 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
2137 fprintf (file, "\n");
2148 /* A data structure describing the regions of a .rsrc section.
2149 Some fields are filled in as the section is parsed. */
2151 typedef struct rsrc_regions
2153 bfd_byte * section_start;
2154 bfd_byte * section_end;
2155 bfd_byte * strings_start;
2156 bfd_byte * resource_start;
2160 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2161 rsrc_regions *, bfd_vma);
2164 rsrc_print_resource_entries (FILE * file,
2166 unsigned int indent,
2167 bfd_boolean is_name,
2169 rsrc_regions * regions,
2172 unsigned long entry, addr, size;
2174 if (data + 8 >= regions->section_end)
2175 return regions->section_end + 1;
2177 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2179 entry = (long) bfd_get_32 (abfd, data);
2184 /* Note - the documentation says that this field is an RVA value
2185 but windres appears to produce a section relative offset with
2186 the top bit set. Support both styles for now. */
2187 if (HighBitSet (entry))
2188 name = regions->section_start + WithoutHighBit (entry);
2190 name = regions->section_start + entry - rva_bias;
2192 if (name + 2 < regions->section_end)
2196 if (regions->strings_start == NULL)
2197 regions->strings_start = name;
2199 len = bfd_get_16 (abfd, name);
2201 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2202 if (name + 2 + len * 2 < regions->section_end)
2204 /* This strange loop is to cope with multibyte characters. */
2208 fprintf (file, "%.1s", name);
2212 fprintf (file, _("<corrupt string length: %#x>"), len);
2215 fprintf (file, _("<corrupt string offset: %#lx>"), entry);
2218 fprintf (file, _("ID: %#08lx"), entry);
2220 entry = (long) bfd_get_32 (abfd, data + 4);
2221 fprintf (file, _(", Value: %#08lx\n"), entry);
2223 if (HighBitSet (entry))
2224 return rsrc_print_resource_directory (file, abfd, indent + 1,
2225 regions->section_start + WithoutHighBit (entry),
2228 if (regions->section_start + entry + 16 >= regions->section_end)
2229 return regions->section_end + 1;
2231 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2234 addr = (long) bfd_get_32 (abfd, regions->section_start + entry),
2235 size = (long) bfd_get_32 (abfd, regions->section_start + entry + 4),
2236 (int) bfd_get_32 (abfd, regions->section_start + entry + 8));
2238 /* Check that the reserved entry is 0. */
2239 if (bfd_get_32 (abfd, regions->section_start + entry + 12) != 0
2240 /* And that the data address/size is valid too. */
2241 || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2242 return regions->section_end + 1;
2244 if (regions->resource_start == NULL)
2245 regions->resource_start = regions->section_start + (addr - rva_bias);
2247 return regions->section_start + (addr - rva_bias) + size;
2250 #define max(a,b) ((a) > (b) ? (a) : (b))
2251 #define min(a,b) ((a) < (b) ? (a) : (b))
2254 rsrc_print_resource_directory (FILE * file,
2256 unsigned int indent,
2258 rsrc_regions * regions,
2261 unsigned int num_names, num_ids;
2262 bfd_byte * highest_data = data;
2264 if (data + 16 >= regions->section_end)
2265 return regions->section_end + 1;
2267 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2270 case 0: fprintf (file, "Type"); break;
2271 case 2: fprintf (file, "Name"); break;
2272 case 4: fprintf (file, "Language"); break;
2273 default: fprintf (file, "<unknown>"); break;
2276 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2277 (int) bfd_get_32 (abfd, data),
2278 (long) bfd_get_32 (abfd, data + 4),
2279 (int) bfd_get_16 (abfd, data + 8),
2280 (int) bfd_get_16 (abfd, data + 10),
2281 num_names = (int) bfd_get_16 (abfd, data + 12),
2282 num_ids = (int) bfd_get_16 (abfd, data + 14));
2285 while (num_names --)
2287 bfd_byte * entry_end;
2289 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2290 data, regions, rva_bias);
2292 highest_data = max (highest_data, entry_end);
2293 if (entry_end >= regions->section_end)
2299 bfd_byte * entry_end;
2301 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2302 data, regions, rva_bias);
2304 highest_data = max (highest_data, entry_end);
2305 if (entry_end >= regions->section_end)
2309 return max (highest_data, data);
2312 /* Display the contents of a .rsrc section. We do not try to
2313 reproduce the resources, windres does that. Instead we dump
2314 the tables in a human readable format. */
2317 rsrc_print_section (bfd * abfd, void * vfile)
2321 FILE * file = (FILE *) vfile;
2322 bfd_size_type datasize;
2325 rsrc_regions regions;
2327 pe = pe_data (abfd);
2331 section = bfd_get_section_by_name (abfd, ".rsrc");
2332 if (section == NULL)
2334 if (!(section->flags & SEC_HAS_CONTENTS))
2337 datasize = section->size;
2341 rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2343 if (! bfd_malloc_and_get_section (abfd, section, & data))
2350 regions.section_start = data;
2351 regions.section_end = data + datasize;
2352 regions.strings_start = NULL;
2353 regions.resource_start = NULL;
2356 fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2358 while (data < regions.section_end)
2360 bfd_byte * p = data;
2362 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2364 if (data == regions.section_end + 1)
2365 fprintf (file, _("Corrupt .rsrc section detected!\n"));
2368 /* Align data before continuing. */
2369 int align = (1 << section->alignment_power) - 1;
2371 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2372 rva_bias += data - p;
2374 /* For reasons that are unclear .rsrc sections are sometimes created
2375 aligned to a 1^3 boundary even when their alignment is set at
2376 1^2. Catch that case here before we issue a spurious warning
2378 if (data == (regions.section_end - 4))
2379 data = regions.section_end;
2380 else if (data < regions.section_end)
2381 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2385 if (regions.strings_start != NULL)
2386 fprintf (file, " String table starts at %03x\n",
2387 (int) (regions.strings_start - regions.section_start));
2388 if (regions.resource_start != NULL)
2389 fprintf (file, " Resources start at %03xx\n",
2390 (int) (regions.resource_start - regions.section_start));
2392 free (regions.section_start);
2396 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2398 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2415 pe_print_debugdata (bfd * abfd, void * vfile)
2417 FILE *file = (FILE *) vfile;
2418 pe_data_type *pe = pe_data (abfd);
2419 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2422 bfd_size_type dataoff;
2425 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2426 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2431 addr += extra->ImageBase;
2432 for (section = abfd->sections; section != NULL; section = section->next)
2434 if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2438 if (section == NULL)
2441 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2445 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2446 section->name, (unsigned long) addr);
2448 dataoff = addr - section->vma;
2451 _("Type Size Rva Offset\n"));
2453 /* Read the whole section. */
2454 if (!bfd_malloc_and_get_section (abfd, section, &data))
2461 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2463 const char *type_name;
2464 struct external_IMAGE_DEBUG_DIRECTORY *ext
2465 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2466 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2468 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2470 if ((idd.Type) > IMAGE_NUMBEROF_DEBUG_TYPES)
2471 type_name = debug_type_names[0];
2473 type_name = debug_type_names[idd.Type];
2475 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
2476 idd.Type, type_name, idd.SizeOfData,
2477 idd.AddressOfRawData, idd.PointerToRawData);
2479 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2481 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2482 char buffer[256 + 1];
2483 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2485 /* The debug entry doesn't have to have to be in a section,
2486 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2487 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2488 idd.SizeOfData, cvinfo))
2491 for (i = 0; i < cvinfo->SignatureLength; i++)
2492 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2494 fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2495 buffer[0], buffer[1], buffer[2], buffer[3],
2496 signature, cvinfo->Age);
2500 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2502 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2507 /* Print out the program headers. */
2510 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2512 FILE *file = (FILE *) vfile;
2514 pe_data_type *pe = pe_data (abfd);
2515 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2516 const char *subsystem_name = NULL;
2519 /* The MS dumpbin program reportedly ands with 0xff0f before
2520 printing the characteristics field. Not sure why. No reason to
2522 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2524 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2525 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2526 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2527 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2528 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2529 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2530 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2531 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2532 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2533 PF (IMAGE_FILE_SYSTEM, "system file");
2534 PF (IMAGE_FILE_DLL, "DLL");
2535 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2538 /* ctime implies '\n'. */
2540 time_t t = pe->coff.timestamp;
2541 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2544 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2545 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2547 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2548 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2550 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2551 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2556 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2559 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2562 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2569 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2571 fprintf (file, "\t(%s)",name);
2572 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2573 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2574 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2575 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2576 (unsigned long) i->SizeOfInitializedData);
2577 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2578 (unsigned long) i->SizeOfUninitializedData);
2579 fprintf (file, "AddressOfEntryPoint\t");
2580 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2581 fprintf (file, "\nBaseOfCode\t\t");
2582 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2583 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2584 /* PE32+ does not have BaseOfData member! */
2585 fprintf (file, "\nBaseOfData\t\t");
2586 bfd_fprintf_vma (abfd, file, i->BaseOfData);
2589 fprintf (file, "\nImageBase\t\t");
2590 bfd_fprintf_vma (abfd, file, i->ImageBase);
2591 fprintf (file, "\nSectionAlignment\t");
2592 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2593 fprintf (file, "\nFileAlignment\t\t");
2594 bfd_fprintf_vma (abfd, file, i->FileAlignment);
2595 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2596 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2597 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2598 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2599 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2600 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2601 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2602 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2603 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2604 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2606 switch (i->Subsystem)
2608 case IMAGE_SUBSYSTEM_UNKNOWN:
2609 subsystem_name = "unspecified";
2611 case IMAGE_SUBSYSTEM_NATIVE:
2612 subsystem_name = "NT native";
2614 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2615 subsystem_name = "Windows GUI";
2617 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2618 subsystem_name = "Windows CUI";
2620 case IMAGE_SUBSYSTEM_POSIX_CUI:
2621 subsystem_name = "POSIX CUI";
2623 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2624 subsystem_name = "Wince CUI";
2626 // These are from UEFI Platform Initialization Specification 1.1.
2627 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2628 subsystem_name = "EFI application";
2630 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2631 subsystem_name = "EFI boot service driver";
2633 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2634 subsystem_name = "EFI runtime driver";
2636 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2637 subsystem_name = "SAL runtime driver";
2639 // This is from revision 8.0 of the MS PE/COFF spec
2640 case IMAGE_SUBSYSTEM_XBOX:
2641 subsystem_name = "XBOX";
2643 // Added default case for clarity - subsystem_name is NULL anyway.
2645 subsystem_name = NULL;
2648 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2650 fprintf (file, "\t(%s)", subsystem_name);
2651 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2652 fprintf (file, "SizeOfStackReserve\t");
2653 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2654 fprintf (file, "\nSizeOfStackCommit\t");
2655 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2656 fprintf (file, "\nSizeOfHeapReserve\t");
2657 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2658 fprintf (file, "\nSizeOfHeapCommit\t");
2659 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2660 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2661 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2662 (unsigned long) i->NumberOfRvaAndSizes);
2664 fprintf (file, "\nThe Data Directory\n");
2665 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2667 fprintf (file, "Entry %1x ", j);
2668 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2669 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2670 fprintf (file, "%s\n", dir_names[j]);
2673 pe_print_idata (abfd, vfile);
2674 pe_print_edata (abfd, vfile);
2675 if (bfd_coff_have_print_pdata (abfd))
2676 bfd_coff_print_pdata (abfd, vfile);
2678 pe_print_pdata (abfd, vfile);
2679 pe_print_reloc (abfd, vfile);
2680 pe_print_debugdata (abfd, file);
2682 rsrc_print_section (abfd, vfile);
2687 /* Copy any private info we understand from the input bfd
2688 to the output bfd. */
2691 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2693 pe_data_type *ipe, *ope;
2695 /* One day we may try to grok other private data. */
2696 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2697 || obfd->xvec->flavour != bfd_target_coff_flavour)
2700 ipe = pe_data (ibfd);
2701 ope = pe_data (obfd);
2703 /* pe_opthdr is copied in copy_object. */
2704 ope->dll = ipe->dll;
2706 /* Don't copy input subsystem if output is different from input. */
2707 if (obfd->xvec != ibfd->xvec)
2708 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2710 /* For strip: if we removed .reloc, we'll make a real mess of things
2711 if we don't remove this entry as well. */
2712 if (! pe_data (obfd)->has_reloc_section)
2714 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2715 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2718 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2719 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2721 if (! pe_data (ibfd)->has_reloc_section
2722 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2723 pe_data (obfd)->dont_strip_reloc = 1;
2728 /* Copy private section data. */
2731 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2736 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2737 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2740 if (coff_section_data (ibfd, isec) != NULL
2741 && pei_section_data (ibfd, isec) != NULL)
2743 if (coff_section_data (obfd, osec) == NULL)
2745 bfd_size_type amt = sizeof (struct coff_section_tdata);
2746 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2747 if (osec->used_by_bfd == NULL)
2751 if (pei_section_data (obfd, osec) == NULL)
2753 bfd_size_type amt = sizeof (struct pei_section_tdata);
2754 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2755 if (coff_section_data (obfd, osec)->tdata == NULL)
2759 pei_section_data (obfd, osec)->virt_size =
2760 pei_section_data (ibfd, isec)->virt_size;
2761 pei_section_data (obfd, osec)->pe_flags =
2762 pei_section_data (ibfd, isec)->pe_flags;
2769 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2771 coff_get_symbol_info (abfd, symbol, ret);
2774 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2776 sort_x64_pdata (const void *l, const void *r)
2778 const char *lp = (const char *) l;
2779 const char *rp = (const char *) r;
2781 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
2783 return (vl < vr ? -1 : 1);
2784 /* We compare just begin address. */
2789 /* Functions to process a .rsrc section. */
2791 static unsigned int sizeof_leaves;
2792 static unsigned int sizeof_strings;
2793 static unsigned int sizeof_tables_and_entries;
2796 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
2799 rsrc_count_entries (bfd * abfd,
2800 bfd_boolean is_name,
2801 bfd_byte * datastart,
2806 unsigned long entry, addr, size;
2808 if (data + 8 >= dataend)
2815 entry = (long) bfd_get_32 (abfd, data);
2817 if (HighBitSet (entry))
2818 name = datastart + WithoutHighBit (entry);
2820 name = datastart + entry - rva_bias;
2822 if (name + 2 >= dataend)
2825 unsigned int len = bfd_get_16 (abfd, name);
2826 if (len == 0 || len > 256)
2830 entry = (long) bfd_get_32 (abfd, data + 4);
2832 if (HighBitSet (entry))
2833 return rsrc_count_directory (abfd,
2835 datastart + WithoutHighBit (entry),
2838 if (datastart + entry + 16 >= dataend)
2841 addr = (long) bfd_get_32 (abfd, datastart + entry);
2842 size = (long) bfd_get_32 (abfd, datastart + entry + 4);
2844 return datastart + addr - rva_bias + size;
2848 rsrc_count_directory (bfd * abfd,
2849 bfd_byte * datastart,
2854 unsigned int num_entries, num_ids;
2855 bfd_byte * highest_data = data;
2857 if (data + 16 >= dataend)
2860 num_entries = (int) bfd_get_16 (abfd, data + 12);
2861 num_ids = (int) bfd_get_16 (abfd, data + 14);
2863 num_entries += num_ids;
2867 while (num_entries --)
2869 bfd_byte * entry_end;
2871 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
2872 datastart, data, dataend, rva_bias);
2874 highest_data = max (highest_data, entry_end);
2875 if (entry_end >= dataend)
2879 return max (highest_data, data);
2882 typedef struct rsrc_dir_chain
2884 unsigned int num_entries;
2885 struct rsrc_entry * first_entry;
2886 struct rsrc_entry * last_entry;
2889 typedef struct rsrc_directory
2891 unsigned int characteristics;
2896 rsrc_dir_chain names;
2899 struct rsrc_entry * entry;
2902 typedef struct rsrc_string
2908 typedef struct rsrc_leaf
2911 unsigned int codepage;
2915 typedef struct rsrc_entry
2917 bfd_boolean is_name;
2921 struct rsrc_string name;
2927 struct rsrc_directory * directory;
2928 struct rsrc_leaf * leaf;
2931 struct rsrc_entry * next_entry;
2932 struct rsrc_directory * parent;
2936 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
2937 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
2940 rsrc_parse_entry (bfd * abfd,
2941 bfd_boolean is_name,
2943 bfd_byte * datastart,
2947 rsrc_directory * parent)
2949 unsigned long val, addr, size;
2951 val = bfd_get_32 (abfd, data);
2953 entry->parent = parent;
2954 entry->is_name = is_name;
2958 /* FIXME: Add range checking ? */
2959 if (HighBitSet (val))
2961 val = WithoutHighBit (val);
2963 entry->name_id.name.len = bfd_get_16 (abfd, datastart + val);
2964 entry->name_id.name.string = datastart + val + 2;
2968 entry->name_id.name.len = bfd_get_16 (abfd, datastart + val
2970 entry->name_id.name.string = datastart + val - rva_bias + 2;
2974 entry->name_id.id = val;
2976 val = bfd_get_32 (abfd, data + 4);
2978 if (HighBitSet (val))
2980 entry->is_dir = TRUE;
2981 entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
2982 if (entry->value.directory == NULL)
2985 return rsrc_parse_directory (abfd, entry->value.directory,
2987 datastart + WithoutHighBit (val),
2988 dataend, rva_bias, entry);
2991 entry->is_dir = FALSE;
2992 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
2993 if (entry->value.leaf == NULL)
2996 addr = bfd_get_32 (abfd, datastart + val);
2997 size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
2998 entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
3000 entry->value.leaf->data = bfd_malloc (size);
3001 if (entry->value.leaf->data == NULL)
3004 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3005 return datastart + (addr - rva_bias) + size;
3009 rsrc_parse_entries (bfd * abfd,
3010 rsrc_dir_chain * chain,
3011 bfd_boolean is_name,
3012 bfd_byte * highest_data,
3013 bfd_byte * datastart,
3017 rsrc_directory * parent)
3022 if (chain->num_entries == 0)
3024 chain->first_entry = chain->last_entry = NULL;
3025 return highest_data;
3028 entry = bfd_malloc (sizeof * entry);
3032 chain->first_entry = entry;
3034 for (i = chain->num_entries; i--;)
3036 bfd_byte * entry_end;
3038 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3039 data, dataend, rva_bias, parent);
3041 highest_data = max (entry_end, highest_data);
3042 if (entry_end > dataend)
3047 entry->next_entry = bfd_malloc (sizeof * entry);
3048 entry = entry->next_entry;
3053 entry->next_entry = NULL;
3056 chain->last_entry = entry;
3058 return highest_data;
3062 rsrc_parse_directory (bfd * abfd,
3063 rsrc_directory * table,
3064 bfd_byte * datastart,
3070 bfd_byte * highest_data = data;
3075 table->characteristics = bfd_get_32 (abfd, data);
3076 table->time = bfd_get_32 (abfd, data + 4);
3077 table->major = bfd_get_16 (abfd, data + 8);
3078 table->minor = bfd_get_16 (abfd, data + 10);
3079 table->names.num_entries = bfd_get_16 (abfd, data + 12);
3080 table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3081 table->entry = entry;
3085 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3086 datastart, data, dataend, rva_bias, table);
3087 data += table->names.num_entries * 8;
3089 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3090 datastart, data, dataend, rva_bias, table);
3091 data += table->ids.num_entries * 8;
3093 return max (highest_data, data);
3096 typedef struct rsrc_write_data
3099 bfd_byte * datastart;
3100 bfd_byte * next_table;
3101 bfd_byte * next_leaf;
3102 bfd_byte * next_string;
3103 bfd_byte * next_data;
3108 rsrc_write_string (rsrc_write_data * data,
3109 rsrc_string * string)
3111 bfd_put_16 (data->abfd, string->len, data->next_string);
3112 memcpy (data->next_string + 2, string->string, string->len * 2);
3113 data->next_string += (string->len + 1) * 2;
3116 static inline unsigned int
3117 rsrc_compute_rva (rsrc_write_data * data,
3120 return (addr - data->datastart) + data->rva_bias;
3124 rsrc_write_leaf (rsrc_write_data * data,
3127 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3129 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4);
3130 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3131 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3132 data->next_leaf += 16;
3134 memcpy (data->next_data, leaf->data, leaf->size);
3135 /* An undocumented feature of Windows resources is that each unit
3136 of raw data is 8-byte aligned... */
3137 data->next_data += ((leaf->size + 7) & ~7);
3140 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3143 rsrc_write_entry (rsrc_write_data * data,
3149 bfd_put_32 (data->abfd,
3150 SetHighBit (data->next_string - data->datastart),
3152 rsrc_write_string (data, & entry->name_id.name);
3155 bfd_put_32 (data->abfd, entry->name_id.id, where);
3159 bfd_put_32 (data->abfd,
3160 SetHighBit (data->next_table - data->datastart),
3162 rsrc_write_directory (data, entry->value.directory);
3166 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3167 rsrc_write_leaf (data, entry->value.leaf);
3172 rsrc_compute_region_sizes (rsrc_directory * dir)
3174 struct rsrc_entry * entry;
3179 sizeof_tables_and_entries += 16;
3181 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3183 sizeof_tables_and_entries += 8;
3185 sizeof_strings += (entry->name_id.name.len + 1) * 2;
3188 rsrc_compute_region_sizes (entry->value.directory);
3190 sizeof_leaves += 16;
3193 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3195 sizeof_tables_and_entries += 8;
3198 rsrc_compute_region_sizes (entry->value.directory);
3200 sizeof_leaves += 16;
3205 rsrc_write_directory (rsrc_write_data * data,
3206 rsrc_directory * dir)
3210 bfd_byte * next_entry;
3213 bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3214 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3215 bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3216 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3217 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3218 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3220 /* Compute where the entries and the next table will be placed. */
3221 next_entry = data->next_table + 16;
3222 data->next_table = next_entry + (dir->names.num_entries * 8)
3223 + (dir->ids.num_entries * 8);
3224 nt = data->next_table;
3226 /* Write the entries. */
3227 for (i = dir->names.num_entries, entry = dir->names.first_entry;
3228 i > 0 && entry != NULL;
3229 i--, entry = entry->next_entry)
3231 BFD_ASSERT (entry->is_name);
3232 rsrc_write_entry (data, next_entry, entry);
3235 BFD_ASSERT (i == 0);
3236 BFD_ASSERT (entry == NULL);
3238 for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3239 i > 0 && entry != NULL;
3240 i--, entry = entry->next_entry)
3242 BFD_ASSERT (! entry->is_name);
3243 rsrc_write_entry (data, next_entry, entry);
3246 BFD_ASSERT (i == 0);
3247 BFD_ASSERT (entry == NULL);
3248 BFD_ASSERT (nt == next_entry);
3251 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3252 /* Return the length (number of units) of the first character in S,
3253 putting its 'ucs4_t' representation in *PUC. */
3256 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3258 unsigned short c = * s;
3260 if (c < 0xd800 || c >= 0xe000)
3270 if (s[1] >= 0xdc00 && s[1] < 0xe000)
3272 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3278 /* Incomplete multibyte character. */
3284 /* Invalid multibyte character. */
3288 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3290 /* Perform a comparison of two entries. */
3292 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3301 return a->name_id.id - b->name_id.id;
3303 /* We have to perform a case insenstive, unicode string comparison... */
3304 astring = a->name_id.name.string;
3305 alen = a->name_id.name.len;
3306 bstring = b->name_id.name.string;
3307 blen = b->name_id.name.len;
3309 #if defined __CYGWIN__ || defined __MINGW32__
3310 /* Under Windows hosts (both Cygwin and Mingw types),
3311 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3312 function however goes by different names in the two environments... */
3316 #define rscpcmp wcsncasecmp
3319 #define rscpcmp wcsnicmp
3322 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3325 #elif defined HAVE_WCHAR_H
3329 for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3334 /* Convert UTF-16 unicode characters into wchar_t characters so
3335 that we can then perform a case insensitive comparison. */
3336 int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3337 int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3341 res = wcsncasecmp (& awc, & bwc, 1);
3347 /* Do the best we can - a case sensitive, untranslated comparison. */
3348 res = memcmp (astring, bstring, min (alen, blen) * 2);
3358 rsrc_print_name (char * buffer, rsrc_string string)
3361 bfd_byte * name = string.string;
3363 for (i = string.len; i--; name += 2)
3364 sprintf (buffer + strlen (buffer), "%.1s", name);
3368 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3370 static char buffer [256];
3371 bfd_boolean is_string = FALSE;
3375 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3376 && dir->entry->parent->entry != NULL)
3378 strcpy (buffer, "type: ");
3379 if (dir->entry->parent->entry->is_name)
3380 rsrc_print_name (buffer + strlen (buffer),
3381 dir->entry->parent->entry->name_id.name);
3384 unsigned int id = dir->entry->parent->entry->name_id.id;
3386 sprintf (buffer + strlen (buffer), "%x", id);
3389 case 1: strcat (buffer, " (CURSOR)"); break;
3390 case 2: strcat (buffer, " (BITMAP)"); break;
3391 case 3: strcat (buffer, " (ICON)"); break;
3392 case 4: strcat (buffer, " (MENU)"); break;
3393 case 5: strcat (buffer, " (DIALOG)"); break;
3394 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3395 case 7: strcat (buffer, " (FONTDIR)"); break;
3396 case 8: strcat (buffer, " (FONT)"); break;
3397 case 9: strcat (buffer, " (ACCELERATOR)"); break;
3398 case 10: strcat (buffer, " (RCDATA)"); break;
3399 case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3400 case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3401 case 14: strcat (buffer, " (GROUP_ICON)"); break;
3402 case 16: strcat (buffer, " (VERSION)"); break;
3403 case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3404 case 19: strcat (buffer, " (PLUGPLAY)"); break;
3405 case 20: strcat (buffer, " (VXD)"); break;
3406 case 21: strcat (buffer, " (ANICURSOR)"); break;
3407 case 22: strcat (buffer, " (ANIICON)"); break;
3408 case 23: strcat (buffer, " (HTML)"); break;
3409 case 24: strcat (buffer, " (MANIFEST)"); break;
3410 case 240: strcat (buffer, " (DLGINIT)"); break;
3411 case 241: strcat (buffer, " (TOOLBAR)"); break;
3416 if (dir != NULL && dir->entry != NULL)
3418 strcat (buffer, " name: ");
3419 if (dir->entry->is_name)
3420 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3423 unsigned int id = dir->entry->name_id.id;
3425 sprintf (buffer + strlen (buffer), "%x", id);
3428 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3429 (id - 1) << 4, (id << 4) - 1);
3435 strcat (buffer, " lang: ");
3438 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3440 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3446 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3447 their ID is stored in the NAME entry. The bottom four bits are used as
3448 an index into unicode string table that makes up the data of the leaf.
3449 So identical type-name-lang string resources may not actually be
3452 This function is called when we have detected two string resources with
3453 match top-28-bit IDs. We have to scan the string tables inside the leaves
3454 and discover if there are any real collisions. If there are then we report
3455 them and return FALSE. Otherwise we copy any strings from B into A and
3456 then return TRUE. */
3459 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3460 rsrc_entry * b ATTRIBUTE_UNUSED)
3462 unsigned int copy_needed = 0;
3466 bfd_byte * new_data;
3469 /* Step one: Find out what we have to do. */
3470 BFD_ASSERT (! a->is_dir);
3471 astring = a->value.leaf->data;
3473 BFD_ASSERT (! b->is_dir);
3474 bstring = b->value.leaf->data;
3476 for (i = 0; i < 16; i++)
3478 unsigned int alen = astring[0] + (astring[1] << 8);
3479 unsigned int blen = bstring[0] + (bstring[1] << 8);
3483 copy_needed += blen * 2;
3487 else if (alen != blen)
3488 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3490 /* alen == blen != 0. We might have two identical strings. If so we
3491 can ignore the second one. There is no need for wchar_t vs UTF-16
3492 theatrics here - we are only interested in (case sensitive) equality. */
3493 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3496 astring += (alen + 1) * 2;
3497 bstring += (blen + 1) * 2;
3502 if (a->parent != NULL
3503 && a->parent->entry != NULL
3504 && a->parent->entry->is_name == FALSE)
3505 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3506 ((a->parent->entry->name_id.id - 1) << 4) + i);
3510 if (copy_needed == 0)
3513 /* If we reach here then A and B must both have non-colliding strings.
3514 (We never get string resources with fully empty string tables).
3515 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3517 new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3518 if (new_data == NULL)
3522 astring = a->value.leaf->data;
3523 bstring = b->value.leaf->data;
3525 for (i = 0; i < 16; i++)
3527 unsigned int alen = astring[0] + (astring[1] << 8);
3528 unsigned int blen = bstring[0] + (bstring[1] << 8);
3532 memcpy (nstring, astring, (alen + 1) * 2);
3533 nstring += (alen + 1) * 2;
3537 memcpy (nstring, bstring, (blen + 1) * 2);
3538 nstring += (blen + 1) * 2;
3546 astring += (alen + 1) * 2;
3547 bstring += (blen + 1) * 2;
3550 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3552 free (a->value.leaf->data);
3553 a->value.leaf->data = new_data;
3554 a->value.leaf->size += copy_needed;
3559 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3561 /* Sort the entries in given part of the directory.
3562 We use an old fashioned bubble sort because we are dealing
3563 with lists and we want to handle matches specially. */
3566 rsrc_sort_entries (rsrc_dir_chain * chain,
3567 bfd_boolean is_name,
3568 rsrc_directory * dir)
3572 rsrc_entry ** points_to_entry;
3573 bfd_boolean swapped;
3575 if (chain->num_entries < 2)
3581 points_to_entry = & chain->first_entry;
3582 entry = * points_to_entry;
3583 next = entry->next_entry;
3587 signed int cmp = rsrc_cmp (is_name, entry, next);
3591 entry->next_entry = next->next_entry;
3592 next->next_entry = entry;
3593 * points_to_entry = next;
3594 points_to_entry = & next->next_entry;
3595 next = entry->next_entry;
3600 if (entry->is_dir && next->is_dir)
3602 /* When we encounter identical directory entries we have to
3603 merge them together. The exception to this rule is for
3604 resource manifests - there can only be one of these,
3605 even if they differ in language. Zero-language manifests
3606 are assumed to be default manifests (provided by the
3607 Cygwin/MinGW build system) and these can be silently dropped,
3608 unless that would reduce the number of manifests to zero.
3609 There should only ever be one non-zero lang manifest -
3610 if there are more it is an error. A non-zero lang
3611 manifest takes precedence over a default manifest. */
3612 if (entry->is_name == FALSE
3613 && entry->name_id.id == 1
3615 && dir->entry != NULL
3616 && dir->entry->is_name == FALSE
3617 && dir->entry->name_id.id == 0x18)
3619 if (next->value.directory->names.num_entries == 0
3620 && next->value.directory->ids.num_entries == 1
3621 && next->value.directory->ids.first_entry->is_name == FALSE
3622 && next->value.directory->ids.first_entry->name_id.id == 0)
3623 /* Fall through so that NEXT is dropped. */
3625 else if (entry->value.directory->names.num_entries == 0
3626 && entry->value.directory->ids.num_entries == 1
3627 && entry->value.directory->ids.first_entry->is_name == FALSE
3628 && entry->value.directory->ids.first_entry->name_id.id == 0)
3630 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3631 entry->next_entry = next->next_entry;
3632 next->next_entry = entry;
3633 * points_to_entry = next;
3634 points_to_entry = & next->next_entry;
3635 next = entry->next_entry;
3640 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3641 bfd_set_error (bfd_error_file_truncated);
3645 /* Unhook NEXT from the chain. */
3646 /* FIXME: memory loss here. */
3647 entry->next_entry = next->next_entry;
3648 chain->num_entries --;
3649 if (chain->num_entries < 2)
3651 next = next->next_entry;
3654 rsrc_merge (entry, next);
3656 else if (entry->is_dir != next->is_dir)
3658 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3659 bfd_set_error (bfd_error_file_truncated);
3664 /* Otherwise with identical leaves we issue an error
3665 message - because there should never be duplicates.
3666 The exception is Type 18/Name 1/Lang 0 which is the
3667 defaul manifest - this can just be dropped. */
3668 if (entry->is_name == FALSE
3669 && entry->name_id.id == 0
3671 && dir->entry != NULL
3672 && dir->entry->is_name == FALSE
3673 && dir->entry->name_id.id == 1
3674 && dir->entry->parent != NULL
3675 && dir->entry->parent->entry != NULL
3676 && dir->entry->parent->entry->is_name == FALSE
3677 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3679 else if (dir != NULL
3680 && dir->entry != NULL
3681 && dir->entry->parent != NULL
3682 && dir->entry->parent->entry != NULL
3683 && dir->entry->parent->entry->is_name == FALSE
3684 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3686 /* Strings need special handling. */
3687 if (! rsrc_merge_string_entries (entry, next))
3689 /* _bfd_error_handler should have been called inside merge_strings. */
3690 bfd_set_error (bfd_error_file_truncated);
3697 || dir->entry == NULL
3698 || dir->entry->parent == NULL
3699 || dir->entry->parent->entry == NULL)
3700 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3702 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3703 rsrc_resource_name (entry, dir));
3704 bfd_set_error (bfd_error_file_truncated);
3709 /* Unhook NEXT from the chain. */
3710 entry->next_entry = next->next_entry;
3711 chain->num_entries --;
3712 if (chain->num_entries < 2)
3714 next = next->next_entry;
3718 points_to_entry = & entry->next_entry;
3720 next = next->next_entry;
3725 chain->last_entry = entry;
3730 /* Attach B's chain onto A. */
3732 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
3734 if (bchain->num_entries == 0)
3737 achain->num_entries += bchain->num_entries;
3739 if (achain->first_entry == NULL)
3741 achain->first_entry = bchain->first_entry;
3742 achain->last_entry = bchain->last_entry;
3746 achain->last_entry->next_entry = bchain->first_entry;
3747 achain->last_entry = bchain->last_entry;
3750 bchain->num_entries = 0;
3751 bchain->first_entry = bchain->last_entry = NULL;
3755 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
3757 rsrc_directory * adir;
3758 rsrc_directory * bdir;
3760 BFD_ASSERT (a->is_dir);
3761 BFD_ASSERT (b->is_dir);
3763 adir = a->value.directory;
3764 bdir = b->value.directory;
3766 if (adir->characteristics != bdir->characteristics)
3768 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3769 bfd_set_error (bfd_error_file_truncated);
3773 if (adir->major != bdir->major || adir->minor != bdir->minor)
3775 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3776 bfd_set_error (bfd_error_file_truncated);
3780 /* Attach B's name chain to A. */
3781 rsrc_attach_chain (& adir->names, & bdir->names);
3783 /* Attach B's ID chain to A. */
3784 rsrc_attach_chain (& adir->ids, & bdir->ids);
3786 /* Now sort A's entries. */
3787 rsrc_sort_entries (& adir->names, TRUE, adir);
3788 rsrc_sort_entries (& adir->ids, FALSE, adir);
3791 /* Check the .rsrc section. If it contains multiple concatenated
3792 resources then we must merge them properly. Otherwise Windows
3793 will ignore all but the first set. */
3796 rsrc_process_section (bfd * abfd,
3797 struct coff_final_link_info * pfinfo)
3799 rsrc_directory new_table;
3805 bfd_byte * datastart;
3807 bfd_byte * new_data;
3808 unsigned int num_resource_sets;
3809 rsrc_directory * type_tables;
3810 rsrc_write_data write_data;
3813 unsigned int num_input_rsrc = 0;
3814 unsigned int max_num_input_rsrc = 4;
3815 ptrdiff_t * rsrc_sizes = NULL;
3817 new_table.names.num_entries = 0;
3818 new_table.ids.num_entries = 0;
3820 sec = bfd_get_section_by_name (abfd, ".rsrc");
3821 if (sec == NULL || (size = sec->rawsize) == 0)
3824 pe = pe_data (abfd);
3828 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3830 data = bfd_malloc (size);
3835 if (! bfd_get_section_contents (abfd, sec, data, 0, size))
3838 /* Step zero: Scan the input bfds looking for .rsrc sections and record
3839 their lengths. Note - we rely upon the fact that the linker script
3840 does *not* sort the input .rsrc sections, so that the order in the
3841 linkinfo list matches the order in the output .rsrc section.
3843 We need to know the lengths because each input .rsrc section has padding
3844 at the end of a variable amount. (It does not appear to be based upon
3845 the section alignment or the file alignment). We need to skip any
3846 padding bytes when parsing the input .rsrc sections. */
3847 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
3848 if (rsrc_sizes == NULL)
3851 for (input = pfinfo->info->input_bfds;
3853 input = input->link_next)
3855 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
3857 if (rsrc_sec != NULL)
3859 if (num_input_rsrc == max_num_input_rsrc)
3861 max_num_input_rsrc += 10;
3862 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
3863 * sizeof * rsrc_sizes);
3864 if (rsrc_sizes == NULL)
3868 BFD_ASSERT (rsrc_sec->size > 0);
3869 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
3873 if (num_input_rsrc < 2)
3876 /* Step one: Walk the section, computing the size of the tables,
3877 leaves and data and decide if we need to do anything. */
3878 dataend = data + size;
3879 num_resource_sets = 0;
3881 while (data < dataend)
3883 bfd_byte * p = data;
3885 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
3889 /* Corrupted .rsrc section - cannot merge. */
3890 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
3891 bfd_get_filename (abfd));
3892 bfd_set_error (bfd_error_file_truncated);
3896 if ((data - p) > rsrc_sizes [num_resource_sets])
3898 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
3899 bfd_get_filename (abfd));
3900 bfd_set_error (bfd_error_file_truncated);
3903 /* FIXME: Should we add a check for "data - p" being much smaller
3904 than rsrc_sizes[num_resource_sets] ? */
3906 data = p + rsrc_sizes[num_resource_sets];
3907 rva_bias += data - p;
3908 ++ num_resource_sets;
3910 BFD_ASSERT (num_resource_sets == num_input_rsrc);
3912 /* Step two: Walk the data again, building trees of the resources. */
3914 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3916 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
3917 if (type_tables == NULL)
3921 while (data < dataend)
3923 bfd_byte * p = data;
3925 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
3926 dataend, rva_bias, NULL);
3927 data = p + rsrc_sizes[indx];
3928 rva_bias += data - p;
3931 BFD_ASSERT (indx == num_resource_sets);
3933 /* Step three: Merge the top level tables (there can be only one).
3935 We must ensure that the merged entries are in ascending order.
3937 We also thread the top level table entries from the old tree onto
3938 the new table, so that they can be pulled off later. */
3940 /* FIXME: Should we verify that all type tables are the same ? */
3941 new_table.characteristics = type_tables[0].characteristics;
3942 new_table.time = type_tables[0].time;
3943 new_table.major = type_tables[0].major;
3944 new_table.minor = type_tables[0].minor;
3946 /* Chain the NAME entries onto the table. */
3947 new_table.names.first_entry = NULL;
3948 new_table.names.last_entry = NULL;
3950 for (indx = 0; indx < num_resource_sets; indx++)
3951 rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
3953 rsrc_sort_entries (& new_table.names, TRUE, & new_table);
3955 /* Chain the ID entries onto the table. */
3956 new_table.ids.first_entry = NULL;
3957 new_table.ids.last_entry = NULL;
3959 for (indx = 0; indx < num_resource_sets; indx++)
3960 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
3962 rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
3964 /* Step four: Create new contents for the .rsrc section. */
3965 /* Step four point one: Compute the size of each region of the .rsrc section.
3966 We do this now, rather than earlier, as the merging above may have dropped
3968 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
3969 rsrc_compute_region_sizes (& new_table);
3970 /* We increment sizeof_strings to make sure that resource data
3971 starts on an 8-byte boundary. FIXME: Is this correct ? */
3972 sizeof_strings = (sizeof_strings + 7) & ~ 7;
3974 new_data = bfd_malloc (size);
3975 if (new_data == NULL)
3978 write_data.abfd = abfd;
3979 write_data.datastart = new_data;
3980 write_data.next_table = new_data;
3981 write_data.next_leaf = new_data + sizeof_tables_and_entries;
3982 write_data.next_string = write_data.next_leaf + sizeof_leaves;
3983 write_data.next_data = write_data.next_string + sizeof_strings;
3984 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3986 rsrc_write_directory (& write_data, & new_table);
3988 /* Step five: Replace the old contents with the new.
3989 We recompute the size as we may have lost entries due to mergeing. */
3990 size = ((write_data.next_data - new_data) + 3) & ~ 3;
3991 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
3992 sec->size = sec->rawsize = size;
3995 /* Step six: Free all the memory that we have used. */
3996 /* FIXME: Free the resource tree, if we have one. */
4001 /* Handle the .idata section and other things that need symbol table
4005 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4007 struct coff_link_hash_entry *h1;
4008 struct bfd_link_info *info = pfinfo->info;
4009 bfd_boolean result = TRUE;
4011 /* There are a few fields that need to be filled in now while we
4012 have symbol table access.
4014 The .idata subsections aren't directly available as sections, but
4015 they are in the symbol table, so get them from there. */
4017 /* The import directory. This is the address of .idata$2, with size
4018 of .idata$2 + .idata$3. */
4019 h1 = coff_link_hash_lookup (coff_hash_table (info),
4020 ".idata$2", FALSE, FALSE, TRUE);
4023 /* PR ld/2729: We cannot rely upon all the output sections having been
4024 created properly, so check before referencing them. Issue a warning
4025 message for any sections tht could not be found. */
4026 if ((h1->root.type == bfd_link_hash_defined
4027 || h1->root.type == bfd_link_hash_defweak)
4028 && h1->root.u.def.section != NULL
4029 && h1->root.u.def.section->output_section != NULL)
4030 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4031 (h1->root.u.def.value
4032 + h1->root.u.def.section->output_section->vma
4033 + h1->root.u.def.section->output_offset);
4037 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4042 h1 = coff_link_hash_lookup (coff_hash_table (info),
4043 ".idata$4", FALSE, FALSE, TRUE);
4045 && (h1->root.type == bfd_link_hash_defined
4046 || h1->root.type == bfd_link_hash_defweak)
4047 && h1->root.u.def.section != NULL
4048 && h1->root.u.def.section->output_section != NULL)
4049 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4050 ((h1->root.u.def.value
4051 + h1->root.u.def.section->output_section->vma
4052 + h1->root.u.def.section->output_offset)
4053 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4057 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4062 /* The import address table. This is the size/address of
4064 h1 = coff_link_hash_lookup (coff_hash_table (info),
4065 ".idata$5", FALSE, FALSE, TRUE);
4067 && (h1->root.type == bfd_link_hash_defined
4068 || h1->root.type == bfd_link_hash_defweak)
4069 && h1->root.u.def.section != NULL
4070 && h1->root.u.def.section->output_section != NULL)
4071 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4072 (h1->root.u.def.value
4073 + h1->root.u.def.section->output_section->vma
4074 + h1->root.u.def.section->output_offset);
4078 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4083 h1 = coff_link_hash_lookup (coff_hash_table (info),
4084 ".idata$6", FALSE, FALSE, TRUE);
4086 && (h1->root.type == bfd_link_hash_defined
4087 || h1->root.type == bfd_link_hash_defweak)
4088 && h1->root.u.def.section != NULL
4089 && h1->root.u.def.section->output_section != NULL)
4090 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4091 ((h1->root.u.def.value
4092 + h1->root.u.def.section->output_section->vma
4093 + h1->root.u.def.section->output_offset)
4094 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4098 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4105 h1 = coff_link_hash_lookup (coff_hash_table (info),
4106 "__IAT_start__", FALSE, FALSE, TRUE);
4108 && (h1->root.type == bfd_link_hash_defined
4109 || h1->root.type == bfd_link_hash_defweak)
4110 && h1->root.u.def.section != NULL
4111 && h1->root.u.def.section->output_section != NULL)
4116 (h1->root.u.def.value
4117 + h1->root.u.def.section->output_section->vma
4118 + h1->root.u.def.section->output_offset);
4120 h1 = coff_link_hash_lookup (coff_hash_table (info),
4121 "__IAT_end__", FALSE, FALSE, TRUE);
4123 && (h1->root.type == bfd_link_hash_defined
4124 || h1->root.type == bfd_link_hash_defweak)
4125 && h1->root.u.def.section != NULL
4126 && h1->root.u.def.section->output_section != NULL)
4128 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4129 ((h1->root.u.def.value
4130 + h1->root.u.def.section->output_section->vma
4131 + h1->root.u.def.section->output_offset)
4133 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4134 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4135 iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4140 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4141 " because .idata$6 is missing"), abfd);
4147 h1 = coff_link_hash_lookup (coff_hash_table (info),
4148 (bfd_get_symbol_leading_char (abfd) != 0
4149 ? "__tls_used" : "_tls_used"),
4150 FALSE, FALSE, TRUE);
4153 if ((h1->root.type == bfd_link_hash_defined
4154 || h1->root.type == bfd_link_hash_defweak)
4155 && h1->root.u.def.section != NULL
4156 && h1->root.u.def.section->output_section != NULL)
4157 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4158 (h1->root.u.def.value
4159 + h1->root.u.def.section->output_section->vma
4160 + h1->root.u.def.section->output_offset
4161 - pe_data (abfd)->pe_opthdr.ImageBase);
4165 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4169 /* According to PECOFF sepcifications by Microsoft version 8.2
4170 the TLS data directory consists of 4 pointers, followed
4171 by two 4-byte integer. This implies that the total size
4172 is different for 32-bit and 64-bit executables. */
4173 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4174 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4176 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4180 /* If there is a .pdata section and we have linked pdata finally, we
4181 need to sort the entries ascending. */
4182 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4184 asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4188 bfd_size_type x = sec->rawsize;
4189 bfd_byte *tmp_data = NULL;
4192 tmp_data = bfd_malloc (x);
4194 if (tmp_data != NULL)
4196 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4200 12, sort_x64_pdata);
4201 bfd_set_section_contents (pfinfo->output_bfd, sec,
4210 rsrc_process_section (abfd, pfinfo);
4212 /* If we couldn't find idata$2, we either have an excessively
4213 trivial program or are in DEEP trouble; we have to assume trivial