2001-01-01 Philip Blundell <philb@gnu.org>
[binutils.git] / bfd / peigen.c
blob094920cfd4d1c075c9315a94fbc31cac0fe238a8
1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright 1995, 96, 97, 98, 99, 2000 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
23 PE/PEI rearrangement (and code added): Donn Terry
24 Softway Systems, Inc.
27 /* Hey look, some documentation [and in a place you expect to find it]!
29 The main reference for the pei format is "Microsoft Portable Executable
30 and Common Object File Format Specification 4.1". Get it if you need to
31 do some serious hacking on this code.
33 Another reference:
34 "Peering Inside the PE: A Tour of the Win32 Portable Executable
35 File Format", MSJ 1994, Volume 9.
37 The *sole* difference between the pe format and the pei format is that the
38 latter has an MSDOS 2.0 .exe header on the front that prints the message
39 "This app must be run under Windows." (or some such).
40 (FIXME: Whether that statement is *really* true or not is unknown.
41 Are there more subtle differences between pe and pei formats?
42 For now assume there aren't. If you find one, then for God sakes
43 document it here!)
45 The Microsoft docs use the word "image" instead of "executable" because
46 the former can also refer to a DLL (shared library). Confusion can arise
47 because the `i' in `pei' also refers to "image". The `pe' format can
48 also create images (i.e. executables), it's just that to run on a win32
49 system you need to use the pei format.
51 FIXME: Please add more docs here so the next poor fool that has to hack
52 on this code has a chance of getting something accomplished without
53 wasting too much time.
56 #include "bfd.h"
57 #include "sysdep.h"
58 #include "libbfd.h"
59 #include "coff/internal.h"
61 /* NOTE: it's strange to be including an architecture specific header
62 in what's supposed to be general (to PE/PEI) code. However, that's
63 where the definitions are, and they don't vary per architecture
64 within PE/PEI, so we get them from there. FIXME: The lack of
65 variance is an assumption which may prove to be incorrect if new
66 PE/PEI targets are created. */
67 #include "coff/i386.h"
69 #include "coff/pe.h"
70 #include "libcoff.h"
71 #include "libpei.h"
73 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
74 worked when the code was in peicode.h, but no longer work now that
75 the code is in peigen.c. PowerPC NT is said to be dead. If
76 anybody wants to revive the code, you will have to figure out how
77 to handle those issues. */
79 static void add_data_entry
80 PARAMS ((bfd *, struct internal_extra_pe_aouthdr *, int, char *, bfd_vma));
81 static boolean pe_print_pdata PARAMS ((bfd *, PTR));
82 static boolean pe_print_reloc PARAMS ((bfd *, PTR));
84 /**********************************************************************/
86 void
87 _bfd_pei_swap_sym_in (abfd, ext1, in1)
88 bfd *abfd;
89 PTR ext1;
90 PTR in1;
92 SYMENT *ext = (SYMENT *) ext1;
93 struct internal_syment *in = (struct internal_syment *) in1;
95 if (ext->e.e_name[0] == 0)
97 in->_n._n_n._n_zeroes = 0;
98 in->_n._n_n._n_offset =
99 bfd_h_get_32 (abfd, (bfd_byte *) ext->e.e.e_offset);
101 else
103 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
106 in->n_value = bfd_h_get_32 (abfd, (bfd_byte *) ext->e_value);
107 in->n_scnum = bfd_h_get_16 (abfd, (bfd_byte *) ext->e_scnum);
108 if (sizeof (ext->e_type) == 2)
110 in->n_type = bfd_h_get_16 (abfd, (bfd_byte *) ext->e_type);
112 else
114 in->n_type = bfd_h_get_32 (abfd, (bfd_byte *) ext->e_type);
116 in->n_sclass = bfd_h_get_8 (abfd, ext->e_sclass);
117 in->n_numaux = bfd_h_get_8 (abfd, ext->e_numaux);
119 #ifndef STRICT_PE_FORMAT
120 /* This is for Gnu-created DLLs. */
122 /* The section symbols for the .idata$ sections have class 0x68
123 (C_SECTION), which MS documentation indicates is a section
124 symbol. Unfortunately, the value field in the symbol is simply a
125 copy of the .idata section's flags rather than something useful.
126 When these symbols are encountered, change the value to 0 so that
127 they will be handled somewhat correctly in the bfd code. */
128 if (in->n_sclass == C_SECTION)
130 in->n_value = 0x0;
132 #if 0
133 /* FIXME: This is clearly wrong. The problem seems to be that
134 undefined C_SECTION symbols appear in the first object of a
135 MS generated .lib file, and the symbols are not defined
136 anywhere. */
137 in->n_scnum = 1;
139 /* I have tried setting the class to 3 and using the following
140 to set the section number. This will put the address of the
141 pointer to the string kernel32.dll at addresses 0 and 0x10
142 off start of idata section which is not correct. */
143 #if 0
144 if (strcmp (in->_n._n_name, ".idata$4") == 0)
145 in->n_scnum = 3;
146 else
147 in->n_scnum = 2;
148 #endif
149 #else
150 /* Create synthetic empty sections as needed. DJ */
151 if (in->n_scnum == 0)
153 asection *sec;
154 for (sec = abfd->sections; sec; sec = sec->next)
156 if (strcmp (sec->name, in->n_name) == 0)
158 in->n_scnum = sec->target_index;
159 break;
163 if (in->n_scnum == 0)
165 int unused_section_number = 0;
166 asection *sec;
167 char *name;
168 for (sec = abfd->sections; sec; sec = sec->next)
169 if (unused_section_number <= sec->target_index)
170 unused_section_number = sec->target_index + 1;
172 name = bfd_alloc (abfd, strlen (in->n_name) + 10);
173 if (name == NULL)
174 return;
175 strcpy (name, in->n_name);
176 sec = bfd_make_section_anyway (abfd, name);
178 sec->vma = 0;
179 sec->lma = 0;
180 sec->_cooked_size = 0;
181 sec->_raw_size = 0;
182 sec->filepos = 0;
183 sec->rel_filepos = 0;
184 sec->reloc_count = 0;
185 sec->line_filepos = 0;
186 sec->lineno_count = 0;
187 sec->userdata = NULL;
188 sec->next = (asection *) NULL;
189 sec->flags = 0;
190 sec->alignment_power = 2;
191 sec->flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
193 sec->target_index = unused_section_number;
195 in->n_scnum = unused_section_number;
197 in->n_sclass = C_STAT;
198 #endif
200 #endif
202 #ifdef coff_swap_sym_in_hook
203 /* This won't work in peigen.c, but since it's for PPC PE, it's not
204 worth fixing. */
205 coff_swap_sym_in_hook (abfd, ext1, in1);
206 #endif
209 unsigned int
210 _bfd_pei_swap_sym_out (abfd, inp, extp)
211 bfd *abfd;
212 PTR inp;
213 PTR extp;
215 struct internal_syment *in = (struct internal_syment *) inp;
216 SYMENT *ext = (SYMENT *) extp;
217 if (in->_n._n_name[0] == 0)
219 bfd_h_put_32 (abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
220 bfd_h_put_32 (abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
222 else
224 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
227 bfd_h_put_32 (abfd, in->n_value, (bfd_byte *) ext->e_value);
228 bfd_h_put_16 (abfd, in->n_scnum, (bfd_byte *) ext->e_scnum);
229 if (sizeof (ext->e_type) == 2)
231 bfd_h_put_16 (abfd, in->n_type, (bfd_byte *) ext->e_type);
233 else
235 bfd_h_put_32 (abfd, in->n_type, (bfd_byte *) ext->e_type);
237 bfd_h_put_8 (abfd, in->n_sclass, ext->e_sclass);
238 bfd_h_put_8 (abfd, in->n_numaux, ext->e_numaux);
240 return SYMESZ;
243 void
244 _bfd_pei_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
245 bfd *abfd;
246 PTR ext1;
247 int type;
248 int class;
249 int indx ATTRIBUTE_UNUSED;
250 int numaux ATTRIBUTE_UNUSED;
251 PTR in1;
253 AUXENT *ext = (AUXENT *) ext1;
254 union internal_auxent *in = (union internal_auxent *) in1;
256 switch (class)
258 case C_FILE:
259 if (ext->x_file.x_fname[0] == 0)
261 in->x_file.x_n.x_zeroes = 0;
262 in->x_file.x_n.x_offset =
263 bfd_h_get_32 (abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
265 else
267 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
269 return;
271 case C_STAT:
272 case C_LEAFSTAT:
273 case C_HIDDEN:
274 if (type == T_NULL)
276 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
277 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
278 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
279 in->x_scn.x_checksum =
280 bfd_h_get_32 (abfd, (bfd_byte *) ext->x_scn.x_checksum);
281 in->x_scn.x_associated =
282 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_scn.x_associated);
283 in->x_scn.x_comdat =
284 bfd_h_get_8 (abfd, (bfd_byte *) ext->x_scn.x_comdat);
285 return;
287 break;
290 in->x_sym.x_tagndx.l = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_sym.x_tagndx);
291 in->x_sym.x_tvndx = bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_tvndx);
293 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
295 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
296 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
298 else
300 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
301 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
302 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
303 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
304 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
305 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
306 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
307 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
310 if (ISFCN (type))
312 in->x_sym.x_misc.x_fsize =
313 bfd_h_get_32 (abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
315 else
317 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
318 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
322 unsigned int
323 _bfd_pei_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
324 bfd *abfd;
325 PTR inp;
326 int type;
327 int class;
328 int indx ATTRIBUTE_UNUSED;
329 int numaux ATTRIBUTE_UNUSED;
330 PTR extp;
332 union internal_auxent *in = (union internal_auxent *) inp;
333 AUXENT *ext = (AUXENT *) extp;
335 memset ((PTR) ext, 0, AUXESZ);
336 switch (class)
338 case C_FILE:
339 if (in->x_file.x_fname[0] == 0)
341 bfd_h_put_32 (abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
342 bfd_h_put_32 (abfd,
343 in->x_file.x_n.x_offset,
344 (bfd_byte *) ext->x_file.x_n.x_offset);
346 else
348 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
350 return AUXESZ;
352 case C_STAT:
353 case C_LEAFSTAT:
354 case C_HIDDEN:
355 if (type == T_NULL)
357 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
358 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
359 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
360 bfd_h_put_32 (abfd, in->x_scn.x_checksum,
361 (bfd_byte *) ext->x_scn.x_checksum);
362 bfd_h_put_16 (abfd, in->x_scn.x_associated,
363 (bfd_byte *) ext->x_scn.x_associated);
364 bfd_h_put_8 (abfd, in->x_scn.x_comdat,
365 (bfd_byte *) ext->x_scn.x_comdat);
366 return AUXESZ;
368 break;
371 bfd_h_put_32 (abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
372 bfd_h_put_16 (abfd, in->x_sym.x_tvndx, (bfd_byte *) ext->x_sym.x_tvndx);
374 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
376 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
377 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
379 else
381 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
382 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
383 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
384 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
385 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
386 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
387 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
388 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
391 if (ISFCN (type))
392 bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
393 (bfd_byte *) ext->x_sym.x_misc.x_fsize);
394 else
396 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
397 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
400 return AUXESZ;
403 void
404 _bfd_pei_swap_lineno_in (abfd, ext1, in1)
405 bfd *abfd;
406 PTR ext1;
407 PTR in1;
409 LINENO *ext = (LINENO *) ext1;
410 struct internal_lineno *in = (struct internal_lineno *) in1;
412 in->l_addr.l_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext->l_addr.l_symndx);
413 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
416 unsigned int
417 _bfd_pei_swap_lineno_out (abfd, inp, outp)
418 bfd *abfd;
419 PTR inp;
420 PTR outp;
422 struct internal_lineno *in = (struct internal_lineno *) inp;
423 struct external_lineno *ext = (struct external_lineno *) outp;
424 bfd_h_put_32 (abfd, in->l_addr.l_symndx, (bfd_byte *)
425 ext->l_addr.l_symndx);
427 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
428 return LINESZ;
431 void
432 _bfd_pei_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
433 bfd *abfd;
434 PTR aouthdr_ext1;
435 PTR aouthdr_int1;
437 struct internal_extra_pe_aouthdr *a;
438 PEAOUTHDR *src = (PEAOUTHDR *) (aouthdr_ext1);
439 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
440 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
442 aouthdr_int->magic = bfd_h_get_16 (abfd, (bfd_byte *) aouthdr_ext->magic);
443 aouthdr_int->vstamp = bfd_h_get_16 (abfd, (bfd_byte *) aouthdr_ext->vstamp);
444 aouthdr_int->tsize =
445 GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
446 aouthdr_int->dsize =
447 GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
448 aouthdr_int->bsize =
449 GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
450 aouthdr_int->entry =
451 GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
452 aouthdr_int->text_start =
453 GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
454 #ifndef COFF_WITH_PEP64
455 /* PE32+ does not have data_start member! */
456 aouthdr_int->data_start =
457 GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
458 #endif
460 a = &aouthdr_int->pe;
461 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, (bfd_byte *) src->ImageBase);
462 a->SectionAlignment = bfd_h_get_32 (abfd, (bfd_byte *) src->SectionAlignment);
463 a->FileAlignment = bfd_h_get_32 (abfd, (bfd_byte *) src->FileAlignment);
464 a->MajorOperatingSystemVersion =
465 bfd_h_get_16 (abfd, (bfd_byte *) src->MajorOperatingSystemVersion);
466 a->MinorOperatingSystemVersion =
467 bfd_h_get_16 (abfd, (bfd_byte *) src->MinorOperatingSystemVersion);
468 a->MajorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MajorImageVersion);
469 a->MinorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MinorImageVersion);
470 a->MajorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MajorSubsystemVersion);
471 a->MinorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *) src->MinorSubsystemVersion);
472 a->Reserved1 = bfd_h_get_32 (abfd, (bfd_byte *) src->Reserved1);
473 a->SizeOfImage = bfd_h_get_32 (abfd, (bfd_byte *) src->SizeOfImage);
474 a->SizeOfHeaders = bfd_h_get_32 (abfd, (bfd_byte *) src->SizeOfHeaders);
475 a->CheckSum = bfd_h_get_32 (abfd, (bfd_byte *) src->CheckSum);
476 a->Subsystem = bfd_h_get_16 (abfd, (bfd_byte *) src->Subsystem);
477 a->DllCharacteristics = bfd_h_get_16 (abfd, (bfd_byte *) src->DllCharacteristics);
478 a->SizeOfStackReserve = GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, (bfd_byte *) src->SizeOfStackReserve);
479 a->SizeOfStackCommit = GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, (bfd_byte *) src->SizeOfStackCommit);
480 a->SizeOfHeapReserve = GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, (bfd_byte *) src->SizeOfHeapReserve);
481 a->SizeOfHeapCommit = GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, (bfd_byte *) src->SizeOfHeapCommit);
482 a->LoaderFlags = bfd_h_get_32 (abfd, (bfd_byte *) src->LoaderFlags);
483 a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, (bfd_byte *) src->NumberOfRvaAndSizes);
486 int idx;
487 for (idx = 0; idx < 16; idx++)
489 /* If data directory is empty, rva also should be 0. */
490 int size =
491 bfd_h_get_32 (abfd, (bfd_byte *) src->DataDirectory[idx][1]);
492 a->DataDirectory[idx].Size = size;
494 if (size)
496 a->DataDirectory[idx].VirtualAddress =
497 bfd_h_get_32 (abfd, (bfd_byte *) src->DataDirectory[idx][0]);
499 else
500 a->DataDirectory[idx].VirtualAddress = 0;
504 if (aouthdr_int->entry)
506 aouthdr_int->entry += a->ImageBase;
507 #ifndef COFF_WITH_PEP64
508 aouthdr_int->entry &= 0xffffffff;
509 #endif
511 if (aouthdr_int->tsize)
513 aouthdr_int->text_start += a->ImageBase;
514 #ifndef COFF_WITH_PEP64
515 aouthdr_int->text_start &= 0xffffffff;
516 #endif
518 #ifndef COFF_WITH_PEP64
519 /* PE32+ does not have data_start member! */
520 if (aouthdr_int->dsize)
522 aouthdr_int->data_start += a->ImageBase;
523 aouthdr_int->data_start &= 0xffffffff;
525 #endif
527 #ifdef POWERPC_LE_PE
528 /* These three fields are normally set up by ppc_relocate_section.
529 In the case of reading a file in, we can pick them up from the
530 DataDirectory. */
531 first_thunk_address = a->DataDirectory[12].VirtualAddress;
532 thunk_size = a->DataDirectory[12].Size;
533 import_table_size = a->DataDirectory[1].Size;
534 #endif
538 /* A support function for below. */
540 static void
541 add_data_entry (abfd, aout, idx, name, base)
542 bfd *abfd;
543 struct internal_extra_pe_aouthdr *aout;
544 int idx;
545 char *name;
546 bfd_vma base;
548 asection *sec = bfd_get_section_by_name (abfd, name);
550 /* add import directory information if it exists */
551 if ((sec != NULL)
552 && (coff_section_data (abfd, sec) != NULL)
553 && (pei_section_data (abfd, sec) != NULL))
555 /* If data directory is empty, rva also should be 0 */
556 int size = pei_section_data (abfd, sec)->virt_size;
557 aout->DataDirectory[idx].Size = size;
559 if (size)
561 aout->DataDirectory[idx].VirtualAddress =
562 (sec->vma - base) & 0xffffffff;
563 sec->flags |= SEC_DATA;
568 unsigned int
569 _bfd_pei_swap_aouthdr_out (abfd, in, out)
570 bfd *abfd;
571 PTR in;
572 PTR out;
574 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
575 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
576 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
577 bfd_vma sa, fa, ib;
579 /* The following definitely is required for EFI applications.
580 Perhaps it's needed for other PEI targets as well, but I don't
581 know that for a fact, so we play it safe here and tweak the
582 alignments only if PEI_FORCE_MINIMUM_ALIGNMENT is
583 defined. --davidm */
584 #ifdef PEI_FORCE_MINIMUM_ALIGNMENT
585 if (!extra->FileAlignment)
586 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
587 if (!extra->SectionAlignment)
588 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
589 #endif
591 #ifdef PEI_DEFAULT_TARGET_SUBSYSTEM
592 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
593 extra->Subsystem = PEI_DEFAULT_TARGET_SUBSYSTEM;
594 #endif
596 sa = extra->SectionAlignment;
597 fa = extra->FileAlignment;
598 ib = extra->ImageBase;
600 if (aouthdr_in->tsize)
602 aouthdr_in->text_start -= ib;
603 aouthdr_in->text_start &= 0xffffffff;
605 if (aouthdr_in->dsize)
607 aouthdr_in->data_start -= ib;
608 aouthdr_in->data_start &= 0xffffffff;
610 if (aouthdr_in->entry)
612 aouthdr_in->entry -= ib;
613 aouthdr_in->entry &= 0xffffffff;
616 #define FA(x) (((x) + fa -1 ) & (- fa))
617 #define SA(x) (((x) + sa -1 ) & (- sa))
619 /* We like to have the sizes aligned. */
621 aouthdr_in->bsize = FA (aouthdr_in->bsize);
623 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
625 /* first null out all data directory entries .. */
626 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
628 add_data_entry (abfd, extra, 0, ".edata", ib);
630 /* Don't call add_data_entry for .idata$2 or .idata$5. It's done in
631 bfd_coff_final_link where all the required information is
632 available. */
634 /* However, until other .idata fixes are made (pending patch), the
635 entry for .idata is needed for backwards compatability. FIXME. */
636 add_data_entry (abfd, extra, 1, ".idata", ib);
638 add_data_entry (abfd, extra, 2, ".rsrc", ib);
640 add_data_entry (abfd, extra, 3, ".pdata", ib);
642 /* For some reason, the virtual size (which is what's set by
643 add_data_entry) for .reloc is not the same as the size recorded
644 in this slot by MSVC; it doesn't seem to cause problems (so far),
645 but since it's the best we've got, use it. It does do the right
646 thing for .pdata. */
647 if (pe_data (abfd)->has_reloc_section)
648 add_data_entry (abfd, extra, 5, ".reloc", ib);
651 asection *sec;
652 bfd_vma dsize = 0;
653 bfd_vma isize = SA(abfd->sections->filepos);
654 bfd_vma tsize = 0;
656 for (sec = abfd->sections; sec; sec = sec->next)
658 int rounded = FA(sec->_raw_size);
660 if (sec->flags & SEC_DATA)
661 dsize += rounded;
662 if (sec->flags & SEC_CODE)
663 tsize += rounded;
664 /* The image size is the total VIRTUAL size (which is what is
665 in the virt_size field). Files have been seen (from MSVC
666 5.0 link.exe) where the file size of the .data segment is
667 quite small compared to the virtual size. Without this
668 fix, strip munges the file. */
669 isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
672 aouthdr_in->dsize = dsize;
673 aouthdr_in->tsize = tsize;
674 extra->SizeOfImage = isize;
677 extra->SizeOfHeaders = abfd->sections->filepos;
678 bfd_h_put_16 (abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
680 #define LINKER_VERSION 256 /* That is, 2.56 */
682 /* This piece of magic sets the "linker version" field to
683 LINKER_VERSION. */
684 bfd_h_put_16 (abfd,
685 LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256,
686 (bfd_byte *) aouthdr_out->standard.vstamp);
688 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
689 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
690 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
691 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
692 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
693 (bfd_byte *) aouthdr_out->standard.text_start);
695 #ifndef COFF_WITH_PEP64
696 /* PE32+ does not have data_start member! */
697 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
698 (bfd_byte *) aouthdr_out->standard.data_start);
699 #endif
701 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase,
702 (bfd_byte *) aouthdr_out->ImageBase);
703 bfd_h_put_32 (abfd, extra->SectionAlignment,
704 (bfd_byte *) aouthdr_out->SectionAlignment);
705 bfd_h_put_32 (abfd, extra->FileAlignment,
706 (bfd_byte *) aouthdr_out->FileAlignment);
707 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
708 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
709 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
710 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
711 bfd_h_put_16 (abfd, extra->MajorImageVersion,
712 (bfd_byte *) aouthdr_out->MajorImageVersion);
713 bfd_h_put_16 (abfd, extra->MinorImageVersion,
714 (bfd_byte *) aouthdr_out->MinorImageVersion);
715 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
716 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
717 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
718 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
719 bfd_h_put_32 (abfd, extra->Reserved1,
720 (bfd_byte *) aouthdr_out->Reserved1);
721 bfd_h_put_32 (abfd, extra->SizeOfImage,
722 (bfd_byte *) aouthdr_out->SizeOfImage);
723 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
724 (bfd_byte *) aouthdr_out->SizeOfHeaders);
725 bfd_h_put_32 (abfd, extra->CheckSum,
726 (bfd_byte *) aouthdr_out->CheckSum);
727 bfd_h_put_16 (abfd, extra->Subsystem,
728 (bfd_byte *) aouthdr_out->Subsystem);
729 bfd_h_put_16 (abfd, extra->DllCharacteristics,
730 (bfd_byte *) aouthdr_out->DllCharacteristics);
731 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
732 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
733 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
734 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
735 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
736 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
737 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
738 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
739 bfd_h_put_32 (abfd, extra->LoaderFlags,
740 (bfd_byte *) aouthdr_out->LoaderFlags);
741 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
742 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
744 int idx;
745 for (idx = 0; idx < 16; idx++)
747 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
748 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
749 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
750 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
754 return AOUTSZ;
757 unsigned int
758 _bfd_pei_only_swap_filehdr_out (abfd, in, out)
759 bfd *abfd;
760 PTR in;
761 PTR out;
763 int idx;
764 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
765 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
767 if (pe_data (abfd)->has_reloc_section)
768 filehdr_in->f_flags &= ~F_RELFLG;
770 if (pe_data (abfd)->dll)
771 filehdr_in->f_flags |= F_DLL;
773 filehdr_in->pe.e_magic = DOSMAGIC;
774 filehdr_in->pe.e_cblp = 0x90;
775 filehdr_in->pe.e_cp = 0x3;
776 filehdr_in->pe.e_crlc = 0x0;
777 filehdr_in->pe.e_cparhdr = 0x4;
778 filehdr_in->pe.e_minalloc = 0x0;
779 filehdr_in->pe.e_maxalloc = 0xffff;
780 filehdr_in->pe.e_ss = 0x0;
781 filehdr_in->pe.e_sp = 0xb8;
782 filehdr_in->pe.e_csum = 0x0;
783 filehdr_in->pe.e_ip = 0x0;
784 filehdr_in->pe.e_cs = 0x0;
785 filehdr_in->pe.e_lfarlc = 0x40;
786 filehdr_in->pe.e_ovno = 0x0;
788 for (idx = 0; idx < 4; idx++)
789 filehdr_in->pe.e_res[idx] = 0x0;
791 filehdr_in->pe.e_oemid = 0x0;
792 filehdr_in->pe.e_oeminfo = 0x0;
794 for (idx = 0; idx < 10; idx++)
795 filehdr_in->pe.e_res2[idx] = 0x0;
797 filehdr_in->pe.e_lfanew = 0x80;
799 /* This next collection of data are mostly just characters. It
800 appears to be constant within the headers put on NT exes. */
801 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
802 filehdr_in->pe.dos_message[1] = 0xcd09b400;
803 filehdr_in->pe.dos_message[2] = 0x4c01b821;
804 filehdr_in->pe.dos_message[3] = 0x685421cd;
805 filehdr_in->pe.dos_message[4] = 0x70207369;
806 filehdr_in->pe.dos_message[5] = 0x72676f72;
807 filehdr_in->pe.dos_message[6] = 0x63206d61;
808 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
809 filehdr_in->pe.dos_message[8] = 0x65622074;
810 filehdr_in->pe.dos_message[9] = 0x6e757220;
811 filehdr_in->pe.dos_message[10] = 0x206e6920;
812 filehdr_in->pe.dos_message[11] = 0x20534f44;
813 filehdr_in->pe.dos_message[12] = 0x65646f6d;
814 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
815 filehdr_in->pe.dos_message[14] = 0x24;
816 filehdr_in->pe.dos_message[15] = 0x0;
817 filehdr_in->pe.nt_signature = NT_SIGNATURE;
819 bfd_h_put_16 (abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
820 bfd_h_put_16 (abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
822 bfd_h_put_32 (abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
823 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
824 (bfd_byte *) filehdr_out->f_symptr);
825 bfd_h_put_32 (abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
826 bfd_h_put_16 (abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
827 bfd_h_put_16 (abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
829 /* put in extra dos header stuff. This data remains essentially
830 constant, it just has to be tacked on to the beginning of all exes
831 for NT */
832 bfd_h_put_16 (abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
833 bfd_h_put_16 (abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
834 bfd_h_put_16 (abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
835 bfd_h_put_16 (abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
836 bfd_h_put_16 (abfd, filehdr_in->pe.e_cparhdr,
837 (bfd_byte *) filehdr_out->e_cparhdr);
838 bfd_h_put_16 (abfd, filehdr_in->pe.e_minalloc,
839 (bfd_byte *) filehdr_out->e_minalloc);
840 bfd_h_put_16 (abfd, filehdr_in->pe.e_maxalloc,
841 (bfd_byte *) filehdr_out->e_maxalloc);
842 bfd_h_put_16 (abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
843 bfd_h_put_16 (abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
844 bfd_h_put_16 (abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
845 bfd_h_put_16 (abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
846 bfd_h_put_16 (abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
847 bfd_h_put_16 (abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
848 bfd_h_put_16 (abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
850 int idx;
851 for (idx = 0; idx < 4; idx++)
852 bfd_h_put_16 (abfd, filehdr_in->pe.e_res[idx],
853 (bfd_byte *) filehdr_out->e_res[idx]);
855 bfd_h_put_16 (abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
856 bfd_h_put_16 (abfd, filehdr_in->pe.e_oeminfo,
857 (bfd_byte *) filehdr_out->e_oeminfo);
859 int idx;
860 for (idx = 0; idx < 10; idx++)
861 bfd_h_put_16 (abfd, filehdr_in->pe.e_res2[idx],
862 (bfd_byte *) filehdr_out->e_res2[idx]);
864 bfd_h_put_32 (abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
867 int idx;
868 for (idx = 0; idx < 16; idx++)
869 bfd_h_put_32 (abfd, filehdr_in->pe.dos_message[idx],
870 (bfd_byte *) filehdr_out->dos_message[idx]);
873 /* Also put in the NT signature. */
874 bfd_h_put_32 (abfd, filehdr_in->pe.nt_signature,
875 (bfd_byte *) filehdr_out->nt_signature);
877 return FILHSZ;
880 unsigned int
881 _bfd_pe_only_swap_filehdr_out (abfd, in, out)
882 bfd *abfd;
883 PTR in;
884 PTR out;
886 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
887 FILHDR *filehdr_out = (FILHDR *) out;
889 bfd_h_put_16 (abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
890 bfd_h_put_16 (abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
891 bfd_h_put_32 (abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
892 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
893 (bfd_byte *) filehdr_out->f_symptr);
894 bfd_h_put_32 (abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
895 bfd_h_put_16 (abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
896 bfd_h_put_16 (abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
898 return FILHSZ;
901 unsigned int
902 _bfd_pei_swap_scnhdr_out (abfd, in, out)
903 bfd *abfd;
904 PTR in;
905 PTR out;
907 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
908 SCNHDR *scnhdr_ext = (SCNHDR *) out;
909 unsigned int ret = SCNHSZ;
910 bfd_vma ps;
911 bfd_vma ss;
913 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
915 PUT_SCNHDR_VADDR (abfd,
916 ((scnhdr_int->s_vaddr
917 - pe_data (abfd)->pe_opthdr.ImageBase)
918 & 0xffffffff),
919 (bfd_byte *) scnhdr_ext->s_vaddr);
921 /* NT wants the size data to be rounded up to the next
922 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
923 sometimes). */
925 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
927 ps = scnhdr_int->s_size;
928 ss = 0;
930 else
932 ps = scnhdr_int->s_paddr;
933 ss = scnhdr_int->s_size;
936 PUT_SCNHDR_SIZE (abfd, ss,
937 (bfd_byte *) scnhdr_ext->s_size);
939 /* s_paddr in PE is really the virtual size. */
940 PUT_SCNHDR_PADDR (abfd, ps, (bfd_byte *) scnhdr_ext->s_paddr);
942 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
943 (bfd_byte *) scnhdr_ext->s_scnptr);
944 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
945 (bfd_byte *) scnhdr_ext->s_relptr);
946 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
947 (bfd_byte *) scnhdr_ext->s_lnnoptr);
949 /* Extra flags must be set when dealing with NT. All sections should also
950 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
951 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
952 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
953 (this is especially important when dealing with the .idata section since
954 the addresses for routines from .dlls must be overwritten). If .reloc
955 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
956 (0x02000000). Also, the resource data should also be read and
957 writable. */
959 /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */
960 /* FIXME: even worse, I don't see how to get the original alignment field*/
961 /* back... */
964 int flags = scnhdr_int->s_flags;
965 bfd_h_put_32 (abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
968 if (coff_data (abfd)->link_info
969 && ! coff_data (abfd)->link_info->relocateable
970 && ! coff_data (abfd)->link_info->shared
971 && strcmp (scnhdr_int->s_name, ".text") == 0)
973 /* By inference from looking at MS output, the 32 bit field
974 which is the combintion of the number_of_relocs and
975 number_of_linenos is used for the line number count in
976 executables. A 16-bit field won't do for cc1. The MS
977 document says that the number of relocs is zero for
978 executables, but the 17-th bit has been observed to be there.
979 Overflow is not an issue: a 4G-line program will overflow a
980 bunch of other fields long before this! */
981 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno & 0xffff,
982 (bfd_byte *) scnhdr_ext->s_nlnno);
983 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno >> 16,
984 (bfd_byte *) scnhdr_ext->s_nreloc);
986 else
988 if (scnhdr_int->s_nlnno <= 0xffff)
989 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno,
990 (bfd_byte *) scnhdr_ext->s_nlnno);
991 else
993 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
994 bfd_get_filename (abfd),
995 scnhdr_int->s_nlnno);
996 bfd_set_error (bfd_error_file_truncated);
997 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
998 ret = 0;
1000 if (scnhdr_int->s_nreloc <= 0xffff)
1001 bfd_h_put_16 (abfd, scnhdr_int->s_nreloc,
1002 (bfd_byte *) scnhdr_ext->s_nreloc);
1003 else
1005 /* PE can deal with large #s of relocs, but not here */
1006 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
1007 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1008 bfd_h_put_32 (abfd, scnhdr_int->s_flags,
1009 (bfd_byte *) scnhdr_ext->s_flags);
1010 #if 0
1011 (*_bfd_error_handler) (_("%s: reloc overflow 1: 0x%lx > 0xffff"),
1012 bfd_get_filename (abfd),
1013 scnhdr_int->s_nreloc);
1014 bfd_set_error (bfd_error_file_truncated);
1015 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
1016 ret = 0;
1017 #endif
1020 return ret;
1023 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] = {
1024 N_("Export Directory [.edata (or where ever we found it)]"),
1025 N_("Import Directory [parts of .idata]"),
1026 N_("Resource Directory [.rsrc]"),
1027 N_("Exception Directory [.pdata]"),
1028 N_("Security Directory"),
1029 N_("Base Relocation Directory [.reloc]"),
1030 N_("Debug Directory"),
1031 N_("Description Directory"),
1032 N_("Special Directory"),
1033 N_("Thread Storage Directory [.tls]"),
1034 N_("Load Configuration Directory"),
1035 N_("Bound Import Directory"),
1036 N_("Import Address Table Directory"),
1037 N_("Delay Import Directory"),
1038 N_("Reserved"),
1039 N_("Reserved")
1042 /**********************************************************************/
1043 #ifdef POWERPC_LE_PE
1044 /* The code for the PPC really falls in the "architecture dependent"
1045 category. However, it's not clear that anyone will ever care, so
1046 we're ignoring the issue for now; if/when PPC matters, some of this
1047 may need to go into peicode.h, or arguments passed to enable the
1048 PPC- specific code. */
1049 #endif
1051 /**********************************************************************/
1052 static boolean
1053 pe_print_idata (abfd, vfile)
1054 bfd *abfd;
1055 PTR vfile;
1057 FILE *file = (FILE *) vfile;
1058 bfd_byte *data;
1059 asection *section;
1060 bfd_signed_vma adj;
1062 #ifdef POWERPC_LE_PE
1063 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1064 #endif
1066 bfd_size_type datasize = 0;
1067 bfd_size_type dataoff;
1068 bfd_size_type i;
1069 int onaline = 20;
1071 pe_data_type *pe = pe_data (abfd);
1072 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1074 bfd_vma addr;
1076 addr = extra->DataDirectory[1].VirtualAddress;
1078 if (addr == 0 && extra->DataDirectory[1].Size == 0)
1080 /* Maybe the extra header isn't there. Look for the section. */
1081 section = bfd_get_section_by_name (abfd, ".idata");
1082 if (section == NULL)
1083 return true;
1085 addr = section->vma;
1086 datasize = bfd_section_size (abfd, section);
1087 if (datasize == 0)
1088 return true;
1090 else
1092 addr += extra->ImageBase;
1093 for (section = abfd->sections; section != NULL; section = section->next)
1095 datasize = bfd_section_size (abfd, section);
1096 if (addr >= section->vma && addr < section->vma + datasize)
1097 break;
1100 if (section == NULL)
1102 fprintf (file,
1103 _("\nThere is an import table, but the section containing it could not be found\n"));
1104 return true;
1108 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1109 section->name, (unsigned long) addr);
1111 dataoff = addr - section->vma;
1112 datasize -= dataoff;
1114 #ifdef POWERPC_LE_PE
1115 if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1117 /* The toc address can be found by taking the starting address,
1118 which on the PPC locates a function descriptor. The
1119 descriptor consists of the function code starting address
1120 followed by the address of the toc. The starting address we
1121 get from the bfd, and the descriptor is supposed to be in the
1122 .reldata section. */
1124 bfd_vma loadable_toc_address;
1125 bfd_vma toc_address;
1126 bfd_vma start_address;
1127 bfd_byte *data = 0;
1128 int offset;
1130 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd,
1131 rel_section));
1132 if (data == NULL && bfd_section_size (abfd, rel_section) != 0)
1133 return false;
1135 bfd_get_section_contents (abfd,
1136 rel_section,
1137 (PTR) data, 0,
1138 bfd_section_size (abfd, rel_section));
1140 offset = abfd->start_address - rel_section->vma;
1142 start_address = bfd_get_32 (abfd, data + offset);
1143 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1144 toc_address = loadable_toc_address - 32768;
1146 fprintf (file,
1147 _("\nFunction descriptor located at the start address: %04lx\n"),
1148 (unsigned long int) (abfd->start_address));
1149 fprintf (file,
1150 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1151 start_address, loadable_toc_address, toc_address);
1153 else
1155 fprintf (file,
1156 _("\nNo reldata section! Function descriptor not decoded.\n"));
1158 #endif
1160 fprintf (file,
1161 _("\nThe Import Tables (interpreted %s section contents)\n"),
1162 section->name);
1163 fprintf (file,
1164 _(" vma: Hint Time Forward DLL First\n"));
1165 fprintf (file,
1166 _(" Table Stamp Chain Name Thunk\n"));
1168 data = (bfd_byte *) bfd_malloc (dataoff + datasize);
1169 if (data == NULL)
1170 return false;
1172 /* Read the whole section. Some of the fields might be before dataoff. */
1173 if (! bfd_get_section_contents (abfd, section, (PTR) data,
1174 0, dataoff + datasize))
1175 return false;
1177 adj = section->vma - extra->ImageBase;
1179 for (i = 0; i < datasize; i += onaline)
1181 bfd_vma hint_addr;
1182 bfd_vma time_stamp;
1183 bfd_vma forward_chain;
1184 bfd_vma dll_name;
1185 bfd_vma first_thunk;
1186 int idx = 0;
1187 bfd_size_type j;
1188 char *dll;
1190 /* print (i + extra->DataDirectory[1].VirtualAddress) */
1191 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1193 if (i + 20 > datasize)
1195 /* Check stuff. */
1199 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1200 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1201 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1202 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1203 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1205 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1206 (unsigned long) hint_addr,
1207 (unsigned long) time_stamp,
1208 (unsigned long) forward_chain,
1209 (unsigned long) dll_name,
1210 (unsigned long) first_thunk);
1212 if (hint_addr == 0 && first_thunk == 0)
1213 break;
1215 dll = (char *) data + dll_name - adj;
1216 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1218 if (hint_addr != 0)
1220 fprintf (file, _("\tvma: Hint/Ord Member-Name\n"));
1222 idx = hint_addr - adj;
1224 for (j = 0; j < datasize; j += 4)
1226 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1228 if (member == 0)
1229 break;
1230 if (member & 0x80000000)
1231 fprintf (file, "\t%04lx\t %4lu", member,
1232 member & 0x7fffffff);
1233 else
1235 int ordinal;
1236 char *member_name;
1238 ordinal = bfd_get_16 (abfd, data + member - adj);
1239 member_name = (char *) data + member - adj + 2;
1240 fprintf (file, "\t%04lx\t %4d %s",
1241 member, ordinal, member_name);
1244 /* If the time stamp is not zero, the import address
1245 table holds actual addresses. */
1246 if (time_stamp != 0
1247 && first_thunk != 0
1248 && first_thunk != hint_addr)
1249 fprintf (file, "\t%04lx",
1250 (long) bfd_get_32 (abfd, data + first_thunk - adj + j));
1252 fprintf (file, "\n");
1256 if (hint_addr != first_thunk && time_stamp == 0)
1258 int differ = 0;
1259 int idx2;
1261 idx2 = first_thunk - adj;
1263 for (j = 0; j < datasize; j += 4)
1265 int ordinal;
1266 char *member_name;
1267 bfd_vma hint_member = 0;
1268 bfd_vma iat_member;
1270 if (hint_addr != 0)
1271 hint_member = bfd_get_32 (abfd, data + idx + j);
1272 iat_member = bfd_get_32 (abfd, data + idx2 + j);
1274 if (hint_addr == 0 && iat_member == 0)
1275 break;
1277 if (hint_addr == 0 || hint_member != iat_member)
1279 if (differ == 0)
1281 fprintf (file,
1282 _("\tThe Import Address Table (difference found)\n"));
1283 fprintf (file, _("\tvma: Hint/Ord Member-Name\n"));
1284 differ = 1;
1286 if (iat_member == 0)
1288 fprintf (file,
1289 _("\t>>> Ran out of IAT members!\n"));
1291 else
1293 ordinal = bfd_get_16 (abfd, data + iat_member - adj);
1294 member_name = (char *) data + iat_member - adj + 2;
1295 fprintf (file, "\t%04lx\t %4d %s\n",
1296 (unsigned long) iat_member,
1297 ordinal,
1298 member_name);
1302 if (hint_addr != 0 && hint_member == 0)
1303 break;
1305 if (differ == 0)
1307 fprintf (file,
1308 _("\tThe Import Address Table is identical\n"));
1312 fprintf (file, "\n");
1316 free (data);
1318 return true;
1321 static boolean
1322 pe_print_edata (abfd, vfile)
1323 bfd *abfd;
1324 PTR vfile;
1326 FILE *file = (FILE *) vfile;
1327 bfd_byte *data;
1328 asection *section;
1330 bfd_size_type datasize = 0;
1331 bfd_size_type dataoff;
1332 bfd_size_type i;
1334 bfd_signed_vma adj;
1335 struct EDT_type {
1336 long export_flags; /* reserved - should be zero */
1337 long time_stamp;
1338 short major_ver;
1339 short minor_ver;
1340 bfd_vma name; /* rva - relative to image base */
1341 long base; /* ordinal base */
1342 unsigned long num_functions; /* Number in the export address table */
1343 unsigned long num_names; /* Number in the name pointer table */
1344 bfd_vma eat_addr; /* rva to the export address table */
1345 bfd_vma npt_addr; /* rva to the Export Name Pointer Table */
1346 bfd_vma ot_addr; /* rva to the Ordinal Table */
1347 } edt;
1349 pe_data_type *pe = pe_data (abfd);
1350 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1352 bfd_vma addr;
1354 addr = extra->DataDirectory[0].VirtualAddress;
1356 if (addr == 0 && extra->DataDirectory[0].Size == 0)
1358 /* Maybe the extra header isn't there. Look for the section. */
1359 section = bfd_get_section_by_name (abfd, ".edata");
1360 if (section == NULL)
1361 return true;
1363 addr = section->vma;
1364 datasize = bfd_section_size (abfd, section);
1365 if (datasize == 0)
1366 return true;
1368 else
1370 addr += extra->ImageBase;
1371 for (section = abfd->sections; section != NULL; section = section->next)
1373 datasize = bfd_section_size (abfd, section);
1374 if (addr >= section->vma && addr < section->vma + datasize)
1375 break;
1378 if (section == NULL)
1380 fprintf (file,
1381 _("\nThere is an export table, but the section containing it could not be found\n"));
1382 return true;
1386 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1387 section->name, (unsigned long) addr);
1389 dataoff = addr - section->vma;
1390 datasize -= dataoff;
1392 data = (bfd_byte *) bfd_malloc (datasize);
1393 if (data == NULL)
1394 return false;
1396 if (! bfd_get_section_contents (abfd, section, (PTR) data, dataoff,
1397 datasize))
1398 return false;
1400 /* Go get Export Directory Table. */
1401 edt.export_flags = bfd_get_32 (abfd, data + 0);
1402 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1403 edt.major_ver = bfd_get_16 (abfd, data + 8);
1404 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1405 edt.name = bfd_get_32 (abfd, data + 12);
1406 edt.base = bfd_get_32 (abfd, data + 16);
1407 edt.num_functions = bfd_get_32 (abfd, data + 20);
1408 edt.num_names = bfd_get_32 (abfd, data + 24);
1409 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1410 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1411 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1413 adj = section->vma - extra->ImageBase + dataoff;
1415 /* Dump the EDT first first */
1416 fprintf (file,
1417 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1418 section->name);
1420 fprintf (file,
1421 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1423 fprintf (file,
1424 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1426 fprintf (file,
1427 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1429 fprintf (file,
1430 _("Name \t\t\t\t"));
1431 fprintf_vma (file, edt.name);
1432 fprintf (file,
1433 " %s\n", data + edt.name - adj);
1435 fprintf (file,
1436 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1438 fprintf (file,
1439 _("Number in:\n"));
1441 fprintf (file,
1442 _("\tExport Address Table \t\t%08lx\n"),
1443 edt.num_functions);
1445 fprintf (file,
1446 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1448 fprintf (file,
1449 _("Table Addresses\n"));
1451 fprintf (file,
1452 _("\tExport Address Table \t\t"));
1453 fprintf_vma (file, edt.eat_addr);
1454 fprintf (file, "\n");
1456 fprintf (file,
1457 _("\tName Pointer Table \t\t"));
1458 fprintf_vma (file, edt.npt_addr);
1459 fprintf (file, "\n");
1461 fprintf (file,
1462 _("\tOrdinal Table \t\t\t"));
1463 fprintf_vma (file, edt.ot_addr);
1464 fprintf (file, "\n");
1466 /* The next table to find is the Export Address Table. It's basically
1467 a list of pointers that either locate a function in this dll, or
1468 forward the call to another dll. Something like:
1469 typedef union {
1470 long export_rva;
1471 long forwarder_rva;
1472 } export_address_table_entry;
1475 fprintf (file,
1476 _("\nExport Address Table -- Ordinal Base %ld\n"),
1477 edt.base);
1479 for (i = 0; i < edt.num_functions; ++i)
1481 bfd_vma eat_member = bfd_get_32 (abfd,
1482 data + edt.eat_addr + (i * 4) - adj);
1483 if (eat_member == 0)
1484 continue;
1486 if (eat_member - adj <= datasize)
1488 /* This rva is to a name (forwarding function) in our section. */
1489 /* Should locate a function descriptor. */
1490 fprintf (file,
1491 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1492 (long) i,
1493 (long) (i + edt.base),
1494 (unsigned long) eat_member,
1495 _("Forwarder RVA"),
1496 data + eat_member - adj);
1498 else
1500 /* Should locate a function descriptor in the reldata section. */
1501 fprintf (file,
1502 "\t[%4ld] +base[%4ld] %04lx %s\n",
1503 (long) i,
1504 (long) (i + edt.base),
1505 (unsigned long) eat_member,
1506 _("Export RVA"));
1510 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1511 /* Dump them in parallel for clarity. */
1512 fprintf (file,
1513 _("\n[Ordinal/Name Pointer] Table\n"));
1515 for (i = 0; i < edt.num_names; ++i)
1517 bfd_vma name_ptr = bfd_get_32 (abfd,
1518 data +
1519 edt.npt_addr
1520 + (i*4) - adj);
1522 char *name = (char *) data + name_ptr - adj;
1524 bfd_vma ord = bfd_get_16 (abfd,
1525 data +
1526 edt.ot_addr
1527 + (i*2) - adj);
1528 fprintf (file,
1529 "\t[%4ld] %s\n", (long) ord, name);
1532 free (data);
1534 return true;
1537 /* This really is architecture dependent. On IA-64, a .pdata entry
1538 consists of three dwords containing relative virtual addresses that
1539 specify the start and end address of the code range the entry
1540 covers and the address of the corresponding unwind info data. */
1542 static boolean
1543 pe_print_pdata (abfd, vfile)
1544 bfd *abfd;
1545 PTR vfile;
1547 #ifdef COFF_WITH_PEP64
1548 # define PDATA_ROW_SIZE (3*8)
1549 #else
1550 # define PDATA_ROW_SIZE (5*4)
1551 #endif
1552 FILE *file = (FILE *) vfile;
1553 bfd_byte *data = 0;
1554 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1555 bfd_size_type datasize = 0;
1556 bfd_size_type i;
1557 bfd_size_type start, stop;
1558 int onaline = PDATA_ROW_SIZE;
1560 if (section == NULL
1561 || coff_section_data (abfd, section) == NULL
1562 || pei_section_data (abfd, section) == NULL)
1563 return true;
1565 stop = pei_section_data (abfd, section)->virt_size;
1566 if ((stop % onaline) != 0)
1567 fprintf (file,
1568 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1569 (long) stop, onaline);
1571 fprintf (file,
1572 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1573 #ifdef COFF_WITH_PEP64
1574 fprintf (file,
1575 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1576 #else
1577 fprintf (file,
1578 _(" vma:\t\tBegin End EH EH PrologEnd Exception\n"));
1579 fprintf (file,
1580 _(" \t\tAddress Address Handler Data Address Mask\n"));
1581 #endif
1583 if (bfd_section_size (abfd, section) == 0)
1584 return true;
1586 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1587 datasize = bfd_section_size (abfd, section);
1588 if (data == NULL && datasize != 0)
1589 return false;
1591 bfd_get_section_contents (abfd,
1592 section,
1593 (PTR) data, 0,
1594 bfd_section_size (abfd, section));
1596 start = 0;
1598 for (i = start; i < stop; i += onaline)
1600 bfd_vma begin_addr;
1601 bfd_vma end_addr;
1602 bfd_vma eh_handler;
1603 bfd_vma eh_data;
1604 bfd_vma prolog_end_addr;
1605 int em_data;
1607 if (i + PDATA_ROW_SIZE > stop)
1608 break;
1610 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1611 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1612 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1613 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1614 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1616 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1617 && eh_data == 0 && prolog_end_addr == 0)
1619 /* We are probably into the padding of the section now. */
1620 break;
1623 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1624 eh_handler &= ~(bfd_vma) 0x3;
1625 prolog_end_addr &= ~(bfd_vma) 0x3;
1627 fputc (' ', file);
1628 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1629 fprintf_vma (file, begin_addr); fputc (' ', file);
1630 fprintf_vma (file, end_addr); fputc (' ', file);
1631 fprintf_vma (file, eh_handler);
1632 #ifndef COFF_WITH_PEP64
1633 fputc (' ', file);
1634 fprintf_vma (file, eh_data); fputc (' ', file);
1635 fprintf_vma (file, prolog_end_addr);
1636 fprintf (file, " %x", em_data);
1637 #endif
1639 #ifdef POWERPC_LE_PE
1640 if (eh_handler == 0 && eh_data != 0)
1642 /* Special bits here, although the meaning may be a little
1643 mysterious. The only one I know for sure is 0x03. */
1644 /* Code Significance */
1645 /* 0x00 None */
1646 /* 0x01 Register Save Millicode */
1647 /* 0x02 Register Restore Millicode */
1648 /* 0x03 Glue Code Sequence */
1649 switch (eh_data)
1651 case 0x01:
1652 fprintf (file, _(" Register save millicode"));
1653 break;
1654 case 0x02:
1655 fprintf (file, _(" Register restore millicode"));
1656 break;
1657 case 0x03:
1658 fprintf (file, _(" Glue code sequence"));
1659 break;
1660 default:
1661 break;
1664 #endif
1665 fprintf (file, "\n");
1668 free (data);
1670 return true;
1673 #define IMAGE_REL_BASED_HIGHADJ 4
1674 static const char * const tbl[] = {
1675 "ABSOLUTE",
1676 "HIGH",
1677 "LOW",
1678 "HIGHLOW",
1679 "HIGHADJ",
1680 "MIPS_JMPADDR",
1681 "SECTION",
1682 "REL32",
1683 "RESERVED1",
1684 "MIPS_JMPADDR16",
1685 "DIR64",
1686 "HIGH3ADJ"
1687 "UNKNOWN", /* MUST be last */
1690 static boolean
1691 pe_print_reloc (abfd, vfile)
1692 bfd *abfd;
1693 PTR vfile;
1695 FILE *file = (FILE *) vfile;
1696 bfd_byte *data = 0;
1697 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1698 bfd_size_type datasize = 0;
1699 bfd_size_type i;
1700 bfd_size_type start, stop;
1702 if (section == NULL)
1703 return true;
1705 if (bfd_section_size (abfd, section) == 0)
1706 return true;
1708 fprintf (file,
1709 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1711 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1712 datasize = bfd_section_size (abfd, section);
1713 if (data == NULL && datasize != 0)
1714 return false;
1716 bfd_get_section_contents (abfd,
1717 section,
1718 (PTR) data, 0,
1719 bfd_section_size (abfd, section));
1721 start = 0;
1723 stop = bfd_section_size (abfd, section);
1725 for (i = start; i < stop;)
1727 int j;
1728 bfd_vma virtual_address;
1729 long number, size;
1731 /* The .reloc section is a sequence of blocks, with a header consisting
1732 of two 32 bit quantities, followed by a number of 16 bit entries */
1734 virtual_address = bfd_get_32 (abfd, data+i);
1735 size = bfd_get_32 (abfd, data+i+4);
1736 number = (size - 8) / 2;
1738 if (size == 0)
1740 break;
1743 fprintf (file,
1744 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1745 (unsigned long) virtual_address, size, size, number);
1747 for (j = 0; j < number; ++j)
1749 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1750 unsigned int t = (e & 0xF000) >> 12;
1751 int off = e & 0x0FFF;
1753 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1754 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1756 fprintf (file,
1757 _("\treloc %4d offset %4x [%4lx] %s"),
1758 j, off, (long) (off + virtual_address), tbl[t]);
1760 /* HIGHADJ takes an argument, - the next record *is* the
1761 low 16 bits of addend. */
1762 if (t == IMAGE_REL_BASED_HIGHADJ)
1764 fprintf (file, " (%4x)",
1765 ((unsigned int)
1766 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1767 j++;
1770 fprintf (file, "\n");
1772 i += size;
1775 free (data);
1777 return true;
1780 /* Print out the program headers. */
1782 boolean
1783 _bfd_pe_print_private_bfd_data_common (abfd, vfile)
1784 bfd *abfd;
1785 PTR vfile;
1787 FILE *file = (FILE *) vfile;
1788 int j;
1789 pe_data_type *pe = pe_data (abfd);
1790 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1791 const char *subsystem_name = NULL;
1793 /* The MS dumpbin program reportedly ands with 0xff0f before
1794 printing the characteristics field. Not sure why. No reason to
1795 emulate it here. */
1796 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1797 #undef PF
1798 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1799 PF (F_RELFLG, "relocations stripped");
1800 PF (F_EXEC, "executable");
1801 PF (F_LNNO, "line numbers stripped");
1802 PF (F_LSYMS, "symbols stripped");
1803 PF (0x80, "little endian");
1804 PF (F_AR32WR, "32 bit words");
1805 PF (0x200, "debugging information removed");
1806 PF (0x1000, "system file");
1807 PF (F_DLL, "DLL");
1808 PF (0x8000, "big endian");
1809 #undef PF
1811 /* ctime implies '\n'. */
1812 fprintf (file, "\nTime/Date\t\t%s", ctime (&pe->coff.timestamp));
1813 fprintf (file, "\nImageBase\t\t");
1814 fprintf_vma (file, i->ImageBase);
1815 fprintf (file, "\nSectionAlignment\t");
1816 fprintf_vma (file, i->SectionAlignment);
1817 fprintf (file, "\nFileAlignment\t\t");
1818 fprintf_vma (file, i->FileAlignment);
1819 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1820 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1821 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1822 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1823 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1824 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1825 fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1826 fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1827 fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1828 fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1829 switch (i->Subsystem)
1831 case IMAGE_SUBSYSTEM_UNKNOWN:
1832 subsystem_name = "unspecified";
1833 break;
1834 case IMAGE_SUBSYSTEM_NATIVE:
1835 subsystem_name = "NT native";
1836 break;
1837 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1838 subsystem_name = "Windows GUI";
1839 break;
1840 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1841 subsystem_name = "Windows CUI";
1842 break;
1843 case IMAGE_SUBSYSTEM_POSIX_CUI:
1844 subsystem_name = "POSIX CUI";
1845 break;
1846 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1847 subsystem_name = "Wince CUI";
1848 break;
1849 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1850 subsystem_name = "EFI application";
1851 break;
1852 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1853 subsystem_name = "EFI boot service driver";
1854 break;
1855 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1856 subsystem_name = "EFI runtime driver";
1857 break;
1859 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1860 if (subsystem_name)
1861 fprintf (file, "\t(%s)", subsystem_name);
1862 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1863 fprintf (file, "SizeOfStackReserve\t");
1864 fprintf_vma (file, i->SizeOfStackReserve);
1865 fprintf (file, "\nSizeOfStackCommit\t");
1866 fprintf_vma (file, i->SizeOfStackCommit);
1867 fprintf (file, "\nSizeOfHeapReserve\t");
1868 fprintf_vma (file, i->SizeOfHeapReserve);
1869 fprintf (file, "\nSizeOfHeapCommit\t");
1870 fprintf_vma (file, i->SizeOfHeapCommit);
1871 fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1872 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1874 fprintf (file, "\nThe Data Directory\n");
1875 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1877 fprintf (file, "Entry %1x ", j);
1878 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1879 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1880 fprintf (file, "%s\n", dir_names[j]);
1883 pe_print_idata (abfd, vfile);
1884 pe_print_edata (abfd, vfile);
1885 pe_print_pdata (abfd, vfile);
1886 pe_print_reloc (abfd, vfile);
1888 return true;
1891 /* Copy any private info we understand from the input bfd
1892 to the output bfd. */
1894 boolean
1895 _bfd_pe_bfd_copy_private_bfd_data_common (ibfd, obfd)
1896 bfd *ibfd, *obfd;
1898 /* One day we may try to grok other private data. */
1899 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1900 || obfd->xvec->flavour != bfd_target_coff_flavour)
1901 return true;
1903 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1904 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1906 /* for strip: if we removed .reloc, we'll make a real mess of things
1907 if we don't remove this entry as well. */
1908 if (! pe_data (obfd)->has_reloc_section)
1910 pe_data (obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1911 pe_data (obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1913 return true;
1916 /* Copy private section data. */
1917 boolean
1918 _bfd_pe_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1919 bfd *ibfd;
1920 asection *isec;
1921 bfd *obfd;
1922 asection *osec;
1924 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1925 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1926 return true;
1928 if (coff_section_data (ibfd, isec) != NULL
1929 && pei_section_data (ibfd, isec) != NULL)
1931 if (coff_section_data (obfd, osec) == NULL)
1933 osec->used_by_bfd =
1934 (PTR) bfd_zalloc (obfd, sizeof (struct coff_section_tdata));
1935 if (osec->used_by_bfd == NULL)
1936 return false;
1938 if (pei_section_data (obfd, osec) == NULL)
1940 coff_section_data (obfd, osec)->tdata =
1941 (PTR) bfd_zalloc (obfd, sizeof (struct pei_section_tdata));
1942 if (coff_section_data (obfd, osec)->tdata == NULL)
1943 return false;
1945 pei_section_data (obfd, osec)->virt_size =
1946 pei_section_data (ibfd, isec)->virt_size;
1947 pei_section_data (obfd, osec)->pe_flags =
1948 pei_section_data (ibfd, isec)->pe_flags;
1951 return true;
1954 void
1955 _bfd_pe_get_symbol_info (abfd, symbol, ret)
1956 bfd *abfd;
1957 asymbol *symbol;
1958 symbol_info *ret;
1960 coff_get_symbol_info (abfd, symbol, ret);
1962 if (pe_data (abfd) != NULL
1963 && ((symbol->flags & BSF_DEBUGGING) == 0
1964 || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
1965 && ! bfd_is_abs_section (symbol->section))
1966 ret->value += pe_data (abfd)->pe_opthdr.ImageBase;
1969 /* Handle the .idata section and other things that need symbol table
1970 access. */
1972 boolean
1973 _bfd_pei_final_link_postscript (abfd, pfinfo)
1974 bfd *abfd;
1975 struct coff_final_link_info *pfinfo;
1977 struct coff_link_hash_entry *h1;
1978 struct bfd_link_info *info = pfinfo->info;
1980 /* There are a few fields that need to be filled in now while we
1981 have symbol table access.
1983 The .idata subsections aren't directly available as sections, but
1984 they are in the symbol table, so get them from there. */
1986 /* The import directory. This is the address of .idata$2, with size
1987 of .idata$2 + .idata$3. */
1988 h1 = coff_link_hash_lookup (coff_hash_table (info),
1989 ".idata$2", false, false, true);
1990 if (h1 != NULL)
1992 pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
1993 (h1->root.u.def.value
1994 + h1->root.u.def.section->output_section->vma
1995 + h1->root.u.def.section->output_offset);
1996 h1 = coff_link_hash_lookup (coff_hash_table (info),
1997 ".idata$4", false, false, true);
1998 pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
1999 ((h1->root.u.def.value
2000 + h1->root.u.def.section->output_section->vma
2001 + h1->root.u.def.section->output_offset)
2002 - pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
2004 /* The import address table. This is the size/address of
2005 .idata$5. */
2006 h1 = coff_link_hash_lookup (coff_hash_table (info),
2007 ".idata$5", false, false, true);
2008 pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
2009 (h1->root.u.def.value
2010 + h1->root.u.def.section->output_section->vma
2011 + h1->root.u.def.section->output_offset);
2012 h1 = coff_link_hash_lookup (coff_hash_table (info),
2013 ".idata$6", false, false, true);
2014 pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
2015 ((h1->root.u.def.value
2016 + h1->root.u.def.section->output_section->vma
2017 + h1->root.u.def.section->output_offset)
2018 - pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
2021 /* If we couldn't find idata$2, we either have an excessively
2022 trivial program or are in DEEP trouble; we have to assume trivial
2023 program.... */
2024 return true;