1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
4 Written by Cygnus Solutions.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21
22 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
23
24 PE/PEI rearrangement (and code added): Donn Terry
25 Softway Systems, Inc. */
26
27 /* Hey look, some documentation [and in a place you expect to find it]!
28
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.
32
33 Another reference:
34 "Peering Inside the PE: A Tour of the Win32 Portable Executable
35 File Format", MSJ 1994, Volume 9.
36
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!)
44
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.
50
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. */
54
55 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
56 depending on whether we're compiling for straight PE or PE+. */
57 #define COFF_WITH_XX
58
59 #include "sysdep.h"
60 #include "bfd.h"
61 #include "libbfd.h"
62 #include "coff/internal.h"
63
64 /* NOTE: it's strange to be including an architecture specific header
65 in what's supposed to be general (to PE/PEI) code. However, that's
66 where the definitions are, and they don't vary per architecture
67 within PE/PEI, so we get them from there. FIXME: The lack of
68 variance is an assumption which may prove to be incorrect if new
69 PE/PEI targets are created. */
70 #if defined COFF_WITH_pex64
71 # include "coff/x86_64.h"
72 #elif defined COFF_WITH_pep
73 # include "coff/ia64.h"
74 #else
75 # include "coff/i386.h"
76 #endif
77
78 #include "coff/pe.h"
79 #include "libcoff.h"
80 #include "libpei.h"
81
82 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
83 # undef AOUTSZ
84 # define AOUTSZ PEPAOUTSZ
85 # define PEAOUTHDR PEPAOUTHDR
86 #endif
87
88 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
89 worked when the code was in peicode.h, but no longer work now that
90 the code is in peigen.c. PowerPC NT is said to be dead. If
91 anybody wants to revive the code, you will have to figure out how
92 to handle those issues. */
93
94 void
_bfd_XXi_swap_sym_in(bfd * abfd,void * ext1,void * in1)95 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
96 {
97 SYMENT *ext = (SYMENT *) ext1;
98 struct internal_syment *in = (struct internal_syment *) in1;
99
100 if (ext->e.e_name[0] == 0)
101 {
102 in->_n._n_n._n_zeroes = 0;
103 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
104 }
105 else
106 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
107
108 in->n_value = H_GET_32 (abfd, ext->e_value);
109 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
110
111 if (sizeof (ext->e_type) == 2)
112 in->n_type = H_GET_16 (abfd, ext->e_type);
113 else
114 in->n_type = H_GET_32 (abfd, ext->e_type);
115
116 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
117 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
118
119 #ifndef STRICT_PE_FORMAT
120 /* This is for Gnu-created DLLs. */
121
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)
129 {
130 in->n_value = 0x0;
131
132 /* Create synthetic empty sections as needed. DJ */
133 if (in->n_scnum == 0)
134 {
135 asection *sec;
136
137 for (sec = abfd->sections; sec; sec = sec->next)
138 {
139 if (strcmp (sec->name, in->n_name) == 0)
140 {
141 in->n_scnum = sec->target_index;
142 break;
143 }
144 }
145 }
146
147 if (in->n_scnum == 0)
148 {
149 int unused_section_number = 0;
150 asection *sec;
151 char *name;
152 flagword flags;
153
154 for (sec = abfd->sections; sec; sec = sec->next)
155 if (unused_section_number <= sec->target_index)
156 unused_section_number = sec->target_index + 1;
157
158 name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
159 if (name == NULL)
160 return;
161 strcpy (name, in->n_name);
162 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
163 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
164
165 sec->vma = 0;
166 sec->lma = 0;
167 sec->size = 0;
168 sec->filepos = 0;
169 sec->rel_filepos = 0;
170 sec->reloc_count = 0;
171 sec->line_filepos = 0;
172 sec->lineno_count = 0;
173 sec->userdata = NULL;
174 sec->next = NULL;
175 sec->alignment_power = 2;
176
177 sec->target_index = unused_section_number;
178
179 in->n_scnum = unused_section_number;
180 }
181 in->n_sclass = C_STAT;
182 }
183 #endif
184
185 #ifdef coff_swap_sym_in_hook
186 /* This won't work in peigen.c, but since it's for PPC PE, it's not
187 worth fixing. */
188 coff_swap_sym_in_hook (abfd, ext1, in1);
189 #endif
190 }
191
192 unsigned int
_bfd_XXi_swap_sym_out(bfd * abfd,void * inp,void * extp)193 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
194 {
195 struct internal_syment *in = (struct internal_syment *) inp;
196 SYMENT *ext = (SYMENT *) extp;
197
198 if (in->_n._n_name[0] == 0)
199 {
200 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
201 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
202 }
203 else
204 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
205
206 H_PUT_32 (abfd, in->n_value, ext->e_value);
207 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
208
209 if (sizeof (ext->e_type) == 2)
210 H_PUT_16 (abfd, in->n_type, ext->e_type);
211 else
212 H_PUT_32 (abfd, in->n_type, ext->e_type);
213
214 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
215 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
216
217 return SYMESZ;
218 }
219
220 void
_bfd_XXi_swap_aux_in(bfd * abfd,void * ext1,int type,int class,int indx ATTRIBUTE_UNUSED,int numaux ATTRIBUTE_UNUSED,void * in1)221 _bfd_XXi_swap_aux_in (bfd * abfd,
222 void * ext1,
223 int type,
224 int class,
225 int indx ATTRIBUTE_UNUSED,
226 int numaux ATTRIBUTE_UNUSED,
227 void * in1)
228 {
229 AUXENT *ext = (AUXENT *) ext1;
230 union internal_auxent *in = (union internal_auxent *) in1;
231
232 switch (class)
233 {
234 case C_FILE:
235 if (ext->x_file.x_fname[0] == 0)
236 {
237 in->x_file.x_n.x_zeroes = 0;
238 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
239 }
240 else
241 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
242 return;
243
244 case C_STAT:
245 case C_LEAFSTAT:
246 case C_HIDDEN:
247 if (type == T_NULL)
248 {
249 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
250 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
251 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
252 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
253 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
254 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
255 return;
256 }
257 break;
258 }
259
260 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
261 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
262
263 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
264 {
265 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
266 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
267 }
268 else
269 {
270 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
271 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
272 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
273 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
274 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
275 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
276 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
277 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
278 }
279
280 if (ISFCN (type))
281 {
282 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
283 }
284 else
285 {
286 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
287 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
288 }
289 }
290
291 unsigned int
_bfd_XXi_swap_aux_out(bfd * abfd,void * inp,int type,int class,int indx ATTRIBUTE_UNUSED,int numaux ATTRIBUTE_UNUSED,void * extp)292 _bfd_XXi_swap_aux_out (bfd * abfd,
293 void * inp,
294 int type,
295 int class,
296 int indx ATTRIBUTE_UNUSED,
297 int numaux ATTRIBUTE_UNUSED,
298 void * extp)
299 {
300 union internal_auxent *in = (union internal_auxent *) inp;
301 AUXENT *ext = (AUXENT *) extp;
302
303 memset (ext, 0, AUXESZ);
304
305 switch (class)
306 {
307 case C_FILE:
308 if (in->x_file.x_fname[0] == 0)
309 {
310 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
311 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
312 }
313 else
314 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
315
316 return AUXESZ;
317
318 case C_STAT:
319 case C_LEAFSTAT:
320 case C_HIDDEN:
321 if (type == T_NULL)
322 {
323 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
324 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
325 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
326 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
327 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
328 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
329 return AUXESZ;
330 }
331 break;
332 }
333
334 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
335 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
336
337 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
338 {
339 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
340 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
341 }
342 else
343 {
344 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
345 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
346 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
347 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
348 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
349 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
350 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
351 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
352 }
353
354 if (ISFCN (type))
355 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
356 else
357 {
358 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
359 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
360 }
361
362 return AUXESZ;
363 }
364
365 void
_bfd_XXi_swap_lineno_in(bfd * abfd,void * ext1,void * in1)366 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
367 {
368 LINENO *ext = (LINENO *) ext1;
369 struct internal_lineno *in = (struct internal_lineno *) in1;
370
371 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
372 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
373 }
374
375 unsigned int
_bfd_XXi_swap_lineno_out(bfd * abfd,void * inp,void * outp)376 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
377 {
378 struct internal_lineno *in = (struct internal_lineno *) inp;
379 struct external_lineno *ext = (struct external_lineno *) outp;
380 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
381
382 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
383 return LINESZ;
384 }
385
386 void
_bfd_XXi_swap_aouthdr_in(bfd * abfd,void * aouthdr_ext1,void * aouthdr_int1)387 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
388 void * aouthdr_ext1,
389 void * aouthdr_int1)
390 {
391 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
392 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
393 struct internal_aouthdr *aouthdr_int
394 = (struct internal_aouthdr *) aouthdr_int1;
395 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
396
397 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
398 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
399 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
400 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
401 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
402 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
403 aouthdr_int->text_start =
404 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
405 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
406 /* PE32+ does not have data_start member! */
407 aouthdr_int->data_start =
408 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
409 a->BaseOfData = aouthdr_int->data_start;
410 #endif
411
412 a->Magic = aouthdr_int->magic;
413 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
414 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
415 a->SizeOfCode = aouthdr_int->tsize ;
416 a->SizeOfInitializedData = aouthdr_int->dsize ;
417 a->SizeOfUninitializedData = aouthdr_int->bsize ;
418 a->AddressOfEntryPoint = aouthdr_int->entry;
419 a->BaseOfCode = aouthdr_int->text_start;
420 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
421 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
422 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
423 a->MajorOperatingSystemVersion =
424 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
425 a->MinorOperatingSystemVersion =
426 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
427 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
428 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
429 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
430 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
431 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
432 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
433 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
434 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
435 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
436 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
437 a->SizeOfStackReserve =
438 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
439 a->SizeOfStackCommit =
440 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
441 a->SizeOfHeapReserve =
442 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
443 a->SizeOfHeapCommit =
444 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
445 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
446 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
447
448 {
449 int idx;
450
451 for (idx = 0; idx < 16; idx++)
452 {
453 /* If data directory is empty, rva also should be 0. */
454 int size =
455 H_GET_32 (abfd, src->DataDirectory[idx][1]);
456
457 a->DataDirectory[idx].Size = size;
458
459 if (size)
460 a->DataDirectory[idx].VirtualAddress =
461 H_GET_32 (abfd, src->DataDirectory[idx][0]);
462 else
463 a->DataDirectory[idx].VirtualAddress = 0;
464 }
465 }
466
467 if (aouthdr_int->entry)
468 {
469 aouthdr_int->entry += a->ImageBase;
470 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
471 aouthdr_int->entry &= 0xffffffff;
472 #endif
473 }
474
475 if (aouthdr_int->tsize)
476 {
477 aouthdr_int->text_start += a->ImageBase;
478 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
479 aouthdr_int->text_start &= 0xffffffff;
480 #endif
481 }
482
483 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
484 /* PE32+ does not have data_start member! */
485 if (aouthdr_int->dsize)
486 {
487 aouthdr_int->data_start += a->ImageBase;
488 aouthdr_int->data_start &= 0xffffffff;
489 }
490 #endif
491
492 #ifdef POWERPC_LE_PE
493 /* These three fields are normally set up by ppc_relocate_section.
494 In the case of reading a file in, we can pick them up from the
495 DataDirectory. */
496 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
497 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
498 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
499 #endif
500 }
501
502 /* A support function for below. */
503
504 static void
add_data_entry(bfd * abfd,struct internal_extra_pe_aouthdr * aout,int idx,char * name,bfd_vma base)505 add_data_entry (bfd * abfd,
506 struct internal_extra_pe_aouthdr *aout,
507 int idx,
508 char *name,
509 bfd_vma base)
510 {
511 asection *sec = bfd_get_section_by_name (abfd, name);
512
513 /* Add import directory information if it exists. */
514 if ((sec != NULL)
515 && (coff_section_data (abfd, sec) != NULL)
516 && (pei_section_data (abfd, sec) != NULL))
517 {
518 /* If data directory is empty, rva also should be 0. */
519 int size = pei_section_data (abfd, sec)->virt_size;
520 aout->DataDirectory[idx].Size = size;
521
522 if (size)
523 {
524 aout->DataDirectory[idx].VirtualAddress =
525 (sec->vma - base) & 0xffffffff;
526 sec->flags |= SEC_DATA;
527 }
528 }
529 }
530
531 unsigned int
_bfd_XXi_swap_aouthdr_out(bfd * abfd,void * in,void * out)532 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
533 {
534 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
535 pe_data_type *pe = pe_data (abfd);
536 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
537 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
538 bfd_vma sa, fa, ib;
539 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
540
541 if (pe->force_minimum_alignment)
542 {
543 if (!extra->FileAlignment)
544 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
545 if (!extra->SectionAlignment)
546 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
547 }
548
549 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
550 extra->Subsystem = pe->target_subsystem;
551
552 sa = extra->SectionAlignment;
553 fa = extra->FileAlignment;
554 ib = extra->ImageBase;
555
556 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
557 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
558 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
559
560 if (aouthdr_in->tsize)
561 {
562 aouthdr_in->text_start -= ib;
563 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
564 aouthdr_in->text_start &= 0xffffffff;
565 #endif
566 }
567
568 if (aouthdr_in->dsize)
569 {
570 aouthdr_in->data_start -= ib;
571 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
572 aouthdr_in->data_start &= 0xffffffff;
573 #endif
574 }
575
576 if (aouthdr_in->entry)
577 {
578 aouthdr_in->entry -= ib;
579 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
580 aouthdr_in->entry &= 0xffffffff;
581 #endif
582 }
583
584 #define FA(x) (((x) + fa -1 ) & (- fa))
585 #define SA(x) (((x) + sa -1 ) & (- sa))
586
587 /* We like to have the sizes aligned. */
588 aouthdr_in->bsize = FA (aouthdr_in->bsize);
589
590 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
591
592 /* First null out all data directory entries. */
593 memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
594
595 add_data_entry (abfd, extra, 0, ".edata", ib);
596 add_data_entry (abfd, extra, 2, ".rsrc", ib);
597 add_data_entry (abfd, extra, 3, ".pdata", ib);
598
599 /* In theory we do not need to call add_data_entry for .idata$2 or
600 .idata$5. It will be done in bfd_coff_final_link where all the
601 required information is available. If however, we are not going
602 to perform a final link, eg because we have been invoked by objcopy
603 or strip, then we need to make sure that these Data Directory
604 entries are initialised properly.
605
606 So - we copy the input values into the output values, and then, if
607 a final link is going to be performed, it can overwrite them. */
608 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
609 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
610 extra->DataDirectory[PE_TLS_TABLE] = tls;
611
612 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
613 /* Until other .idata fixes are made (pending patch), the entry for
614 .idata is needed for backwards compatibility. FIXME. */
615 add_data_entry (abfd, extra, 1, ".idata", ib);
616
617 /* For some reason, the virtual size (which is what's set by
618 add_data_entry) for .reloc is not the same as the size recorded
619 in this slot by MSVC; it doesn't seem to cause problems (so far),
620 but since it's the best we've got, use it. It does do the right
621 thing for .pdata. */
622 if (pe->has_reloc_section)
623 add_data_entry (abfd, extra, 5, ".reloc", ib);
624
625 {
626 asection *sec;
627 bfd_vma hsize = 0;
628 bfd_vma dsize = 0;
629 bfd_vma isize = 0;
630 bfd_vma tsize = 0;
631
632 for (sec = abfd->sections; sec; sec = sec->next)
633 {
634 int rounded = FA (sec->size);
635
636 /* The first non-zero section filepos is the header size.
637 Sections without contents will have a filepos of 0. */
638 if (hsize == 0)
639 hsize = sec->filepos;
640 if (sec->flags & SEC_DATA)
641 dsize += rounded;
642 if (sec->flags & SEC_CODE)
643 tsize += rounded;
644 /* The image size is the total VIRTUAL size (which is what is
645 in the virt_size field). Files have been seen (from MSVC
646 5.0 link.exe) where the file size of the .data segment is
647 quite small compared to the virtual size. Without this
648 fix, strip munges the file.
649
650 FIXME: We need to handle holes between sections, which may
651 happpen when we covert from another format. We just use
652 the virtual address and virtual size of the last section
653 for the image size. */
654 if (coff_section_data (abfd, sec) != NULL
655 && pei_section_data (abfd, sec) != NULL)
656 isize = (sec->vma - extra->ImageBase
657 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
658 }
659
660 aouthdr_in->dsize = dsize;
661 aouthdr_in->tsize = tsize;
662 extra->SizeOfHeaders = hsize;
663 extra->SizeOfImage = isize;
664 }
665
666 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
667
668 #define LINKER_VERSION 256 /* That is, 2.56 */
669
670 /* This piece of magic sets the "linker version" field to
671 LINKER_VERSION. */
672 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
673 aouthdr_out->standard.vstamp);
674
675 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
676 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
677 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
678 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
679 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
680 aouthdr_out->standard.text_start);
681
682 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
683 /* PE32+ does not have data_start member! */
684 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
685 aouthdr_out->standard.data_start);
686 #endif
687
688 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
689 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
690 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
691 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
692 aouthdr_out->MajorOperatingSystemVersion);
693 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
694 aouthdr_out->MinorOperatingSystemVersion);
695 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
696 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
697 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
698 aouthdr_out->MajorSubsystemVersion);
699 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
700 aouthdr_out->MinorSubsystemVersion);
701 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
702 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
703 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
704 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
705 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
706 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
707 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
708 aouthdr_out->SizeOfStackReserve);
709 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
710 aouthdr_out->SizeOfStackCommit);
711 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
712 aouthdr_out->SizeOfHeapReserve);
713 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
714 aouthdr_out->SizeOfHeapCommit);
715 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
716 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
717 aouthdr_out->NumberOfRvaAndSizes);
718 {
719 int idx;
720
721 for (idx = 0; idx < 16; idx++)
722 {
723 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
724 aouthdr_out->DataDirectory[idx][0]);
725 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
726 aouthdr_out->DataDirectory[idx][1]);
727 }
728 }
729
730 return AOUTSZ;
731 }
732
733 unsigned int
_bfd_XXi_only_swap_filehdr_out(bfd * abfd,void * in,void * out)734 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
735 {
736 int idx;
737 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
738 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
739
740 if (pe_data (abfd)->has_reloc_section)
741 filehdr_in->f_flags &= ~F_RELFLG;
742
743 if (pe_data (abfd)->dll)
744 filehdr_in->f_flags |= F_DLL;
745
746 filehdr_in->pe.e_magic = DOSMAGIC;
747 filehdr_in->pe.e_cblp = 0x90;
748 filehdr_in->pe.e_cp = 0x3;
749 filehdr_in->pe.e_crlc = 0x0;
750 filehdr_in->pe.e_cparhdr = 0x4;
751 filehdr_in->pe.e_minalloc = 0x0;
752 filehdr_in->pe.e_maxalloc = 0xffff;
753 filehdr_in->pe.e_ss = 0x0;
754 filehdr_in->pe.e_sp = 0xb8;
755 filehdr_in->pe.e_csum = 0x0;
756 filehdr_in->pe.e_ip = 0x0;
757 filehdr_in->pe.e_cs = 0x0;
758 filehdr_in->pe.e_lfarlc = 0x40;
759 filehdr_in->pe.e_ovno = 0x0;
760
761 for (idx = 0; idx < 4; idx++)
762 filehdr_in->pe.e_res[idx] = 0x0;
763
764 filehdr_in->pe.e_oemid = 0x0;
765 filehdr_in->pe.e_oeminfo = 0x0;
766
767 for (idx = 0; idx < 10; idx++)
768 filehdr_in->pe.e_res2[idx] = 0x0;
769
770 filehdr_in->pe.e_lfanew = 0x80;
771
772 /* This next collection of data are mostly just characters. It
773 appears to be constant within the headers put on NT exes. */
774 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
775 filehdr_in->pe.dos_message[1] = 0xcd09b400;
776 filehdr_in->pe.dos_message[2] = 0x4c01b821;
777 filehdr_in->pe.dos_message[3] = 0x685421cd;
778 filehdr_in->pe.dos_message[4] = 0x70207369;
779 filehdr_in->pe.dos_message[5] = 0x72676f72;
780 filehdr_in->pe.dos_message[6] = 0x63206d61;
781 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
782 filehdr_in->pe.dos_message[8] = 0x65622074;
783 filehdr_in->pe.dos_message[9] = 0x6e757220;
784 filehdr_in->pe.dos_message[10] = 0x206e6920;
785 filehdr_in->pe.dos_message[11] = 0x20534f44;
786 filehdr_in->pe.dos_message[12] = 0x65646f6d;
787 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
788 filehdr_in->pe.dos_message[14] = 0x24;
789 filehdr_in->pe.dos_message[15] = 0x0;
790 filehdr_in->pe.nt_signature = NT_SIGNATURE;
791
792 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
793 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
794
795 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
796 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
797 filehdr_out->f_symptr);
798 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
799 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
800 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
801
802 /* Put in extra dos header stuff. This data remains essentially
803 constant, it just has to be tacked on to the beginning of all exes
804 for NT. */
805 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
806 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
807 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
808 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
809 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
810 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
811 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
812 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
813 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
814 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
815 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
816 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
817 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
818 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
819
820 for (idx = 0; idx < 4; idx++)
821 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
822
823 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
824 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
825
826 for (idx = 0; idx < 10; idx++)
827 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
828
829 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
830
831 for (idx = 0; idx < 16; idx++)
832 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
833 filehdr_out->dos_message[idx]);
834
835 /* Also put in the NT signature. */
836 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
837
838 return FILHSZ;
839 }
840
841 unsigned int
_bfd_XX_only_swap_filehdr_out(bfd * abfd,void * in,void * out)842 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
843 {
844 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
845 FILHDR *filehdr_out = (FILHDR *) out;
846
847 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
848 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
849 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
850 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
851 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
852 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
853 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
854
855 return FILHSZ;
856 }
857
858 unsigned int
_bfd_XXi_swap_scnhdr_out(bfd * abfd,void * in,void * out)859 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
860 {
861 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
862 SCNHDR *scnhdr_ext = (SCNHDR *) out;
863 unsigned int ret = SCNHSZ;
864 bfd_vma ps;
865 bfd_vma ss;
866
867 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
868
869 PUT_SCNHDR_VADDR (abfd,
870 ((scnhdr_int->s_vaddr
871 - pe_data (abfd)->pe_opthdr.ImageBase)
872 & 0xffffffff),
873 scnhdr_ext->s_vaddr);
874
875 /* NT wants the size data to be rounded up to the next
876 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
877 sometimes). */
878 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
879 {
880 if (bfd_pe_executable_p (abfd))
881 {
882 ps = scnhdr_int->s_size;
883 ss = 0;
884 }
885 else
886 {
887 ps = 0;
888 ss = scnhdr_int->s_size;
889 }
890 }
891 else
892 {
893 if (bfd_pe_executable_p (abfd))
894 ps = scnhdr_int->s_paddr;
895 else
896 ps = 0;
897
898 ss = scnhdr_int->s_size;
899 }
900
901 PUT_SCNHDR_SIZE (abfd, ss,
902 scnhdr_ext->s_size);
903
904 /* s_paddr in PE is really the virtual size. */
905 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
906
907 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
908 scnhdr_ext->s_scnptr);
909 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
910 scnhdr_ext->s_relptr);
911 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
912 scnhdr_ext->s_lnnoptr);
913
914 {
915 /* Extra flags must be set when dealing with PE. All sections should also
916 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
917 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
918 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
919 (this is especially important when dealing with the .idata section since
920 the addresses for routines from .dlls must be overwritten). If .reloc
921 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
922 (0x02000000). Also, the resource data should also be read and
923 writable. */
924
925 /* FIXME: Alignment is also encoded in this field, at least on PPC and
926 ARM-WINCE. Although - how do we get the original alignment field
927 back ? */
928
929 typedef struct
930 {
931 const char * section_name;
932 unsigned long must_have;
933 }
934 pe_required_section_flags;
935
936 pe_required_section_flags known_sections [] =
937 {
938 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
939 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
940 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
941 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
942 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
943 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
944 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
945 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
946 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
947 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
948 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
949 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
950 { NULL, 0}
951 };
952
953 pe_required_section_flags * p;
954
955 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
956 we know exactly what this specific section wants so we remove it
957 and then allow the must_have field to add it back in if necessary.
958 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
959 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
960 by ld --enable-auto-import (if auto-import is actually needed),
961 by ld --omagic, or by obcopy --writable-text. */
962
963 for (p = known_sections; p->section_name; p++)
964 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
965 {
966 if (strcmp (scnhdr_int->s_name, ".text")
967 || (bfd_get_file_flags (abfd) & WP_TEXT))
968 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
969 scnhdr_int->s_flags |= p->must_have;
970 break;
971 }
972
973 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
974 }
975
976 if (coff_data (abfd)->link_info
977 && ! coff_data (abfd)->link_info->relocatable
978 && ! coff_data (abfd)->link_info->shared
979 && strcmp (scnhdr_int->s_name, ".text") == 0)
980 {
981 /* By inference from looking at MS output, the 32 bit field
982 which is the combination of the number_of_relocs and
983 number_of_linenos is used for the line number count in
984 executables. A 16-bit field won't do for cc1. The MS
985 document says that the number of relocs is zero for
986 executables, but the 17-th bit has been observed to be there.
987 Overflow is not an issue: a 4G-line program will overflow a
988 bunch of other fields long before this! */
989 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
990 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
991 }
992 else
993 {
994 if (scnhdr_int->s_nlnno <= 0xffff)
995 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
996 else
997 {
998 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
999 bfd_get_filename (abfd),
1000 scnhdr_int->s_nlnno);
1001 bfd_set_error (bfd_error_file_truncated);
1002 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1003 ret = 0;
1004 }
1005
1006 /* Although we could encode 0xffff relocs here, we do not, to be
1007 consistent with other parts of bfd. Also it lets us warn, as
1008 we should never see 0xffff here w/o having the overflow flag
1009 set. */
1010 if (scnhdr_int->s_nreloc < 0xffff)
1011 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1012 else
1013 {
1014 /* PE can deal with large #s of relocs, but not here. */
1015 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1016 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1017 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1018 }
1019 }
1020 return ret;
1021 }
1022
1023 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1024 {
1025 N_("Export Directory [.edata (or where ever we found it)]"),
1026 N_("Import Directory [parts of .idata]"),
1027 N_("Resource Directory [.rsrc]"),
1028 N_("Exception Directory [.pdata]"),
1029 N_("Security Directory"),
1030 N_("Base Relocation Directory [.reloc]"),
1031 N_("Debug Directory"),
1032 N_("Description Directory"),
1033 N_("Special Directory"),
1034 N_("Thread Storage Directory [.tls]"),
1035 N_("Load Configuration Directory"),
1036 N_("Bound Import Directory"),
1037 N_("Import Address Table Directory"),
1038 N_("Delay Import Directory"),
1039 N_("CLR Runtime Header"),
1040 N_("Reserved")
1041 };
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
1050
1051 static bfd_boolean
pe_print_idata(bfd * abfd,void * vfile)1052 pe_print_idata (bfd * abfd, void * vfile)
1053 {
1054 FILE *file = (FILE *) vfile;
1055 bfd_byte *data;
1056 asection *section;
1057 bfd_signed_vma adj;
1058
1059 #ifdef POWERPC_LE_PE
1060 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1061 #endif
1062
1063 bfd_size_type datasize = 0;
1064 bfd_size_type dataoff;
1065 bfd_size_type i;
1066 int onaline = 20;
1067
1068 pe_data_type *pe = pe_data (abfd);
1069 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1070
1071 bfd_vma addr;
1072
1073 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1074
1075 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1076 {
1077 /* Maybe the extra header isn't there. Look for the section. */
1078 section = bfd_get_section_by_name (abfd, ".idata");
1079 if (section == NULL)
1080 return TRUE;
1081
1082 addr = section->vma;
1083 datasize = section->size;
1084 if (datasize == 0)
1085 return TRUE;
1086 }
1087 else
1088 {
1089 addr += extra->ImageBase;
1090 for (section = abfd->sections; section != NULL; section = section->next)
1091 {
1092 datasize = section->size;
1093 if (addr >= section->vma && addr < section->vma + datasize)
1094 break;
1095 }
1096
1097 if (section == NULL)
1098 {
1099 fprintf (file,
1100 _("\nThere is an import table, but the section containing it could not be found\n"));
1101 return TRUE;
1102 }
1103 }
1104
1105 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1106 section->name, (unsigned long) addr);
1107
1108 dataoff = addr - section->vma;
1109 datasize -= dataoff;
1110
1111 #ifdef POWERPC_LE_PE
1112 if (rel_section != 0 && rel_section->size != 0)
1113 {
1114 /* The toc address can be found by taking the starting address,
1115 which on the PPC locates a function descriptor. The
1116 descriptor consists of the function code starting address
1117 followed by the address of the toc. The starting address we
1118 get from the bfd, and the descriptor is supposed to be in the
1119 .reldata section. */
1120
1121 bfd_vma loadable_toc_address;
1122 bfd_vma toc_address;
1123 bfd_vma start_address;
1124 bfd_byte *data;
1125 bfd_vma offset;
1126
1127 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1128 {
1129 if (data != NULL)
1130 free (data);
1131 return FALSE;
1132 }
1133
1134 offset = abfd->start_address - rel_section->vma;
1135
1136 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1137 {
1138 if (data != NULL)
1139 free (data);
1140 return FALSE;
1141 }
1142
1143 start_address = bfd_get_32 (abfd, data + offset);
1144 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1145 toc_address = loadable_toc_address - 32768;
1146
1147 fprintf (file,
1148 _("\nFunction descriptor located at the start address: %04lx\n"),
1149 (unsigned long int) (abfd->start_address));
1150 fprintf (file,
1151 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1152 start_address, loadable_toc_address, toc_address);
1153 if (data != NULL)
1154 free (data);
1155 }
1156 else
1157 {
1158 fprintf (file,
1159 _("\nNo reldata section! Function descriptor not decoded.\n"));
1160 }
1161 #endif
1162
1163 fprintf (file,
1164 _("\nThe Import Tables (interpreted %s section contents)\n"),
1165 section->name);
1166 fprintf (file,
1167 _("\
1168 vma: Hint Time Forward DLL First\n\
1169 Table Stamp Chain Name Thunk\n"));
1170
1171 /* Read the whole section. Some of the fields might be before dataoff. */
1172 if (!bfd_malloc_and_get_section (abfd, section, &data))
1173 {
1174 if (data != NULL)
1175 free (data);
1176 return FALSE;
1177 }
1178
1179 adj = section->vma - extra->ImageBase;
1180
1181 /* Print all image import descriptors. */
1182 for (i = 0; i < datasize; i += onaline)
1183 {
1184 bfd_vma hint_addr;
1185 bfd_vma time_stamp;
1186 bfd_vma forward_chain;
1187 bfd_vma dll_name;
1188 bfd_vma first_thunk;
1189 int idx = 0;
1190 bfd_size_type j;
1191 char *dll;
1192
1193 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1194 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1195 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1196 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1197 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1198 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1199 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1200
1201 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1202 (unsigned long) hint_addr,
1203 (unsigned long) time_stamp,
1204 (unsigned long) forward_chain,
1205 (unsigned long) dll_name,
1206 (unsigned long) first_thunk);
1207
1208 if (hint_addr == 0 && first_thunk == 0)
1209 break;
1210
1211 if (dll_name - adj >= section->size)
1212 break;
1213
1214 dll = (char *) data + dll_name - adj;
1215 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1216
1217 if (hint_addr != 0)
1218 {
1219 bfd_byte *ft_data;
1220 asection *ft_section;
1221 bfd_vma ft_addr;
1222 bfd_size_type ft_datasize;
1223 int ft_idx;
1224 int ft_allocated = 0;
1225
1226 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1227
1228 idx = hint_addr - adj;
1229
1230 ft_addr = first_thunk + extra->ImageBase;
1231 ft_data = data;
1232 ft_idx = first_thunk - adj;
1233 ft_allocated = 0;
1234
1235 if (first_thunk != hint_addr)
1236 {
1237 /* Find the section which contains the first thunk. */
1238 for (ft_section = abfd->sections;
1239 ft_section != NULL;
1240 ft_section = ft_section->next)
1241 {
1242 ft_datasize = ft_section->size;
1243 if (ft_addr >= ft_section->vma
1244 && ft_addr < ft_section->vma + ft_datasize)
1245 break;
1246 }
1247
1248 if (ft_section == NULL)
1249 {
1250 fprintf (file,
1251 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1252 continue;
1253 }
1254
1255 /* Now check to see if this section is the same as our current
1256 section. If it is not then we will have to load its data in. */
1257 if (ft_section == section)
1258 {
1259 ft_data = data;
1260 ft_idx = first_thunk - adj;
1261 }
1262 else
1263 {
1264 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1265 ft_data = bfd_malloc (datasize);
1266 if (ft_data == NULL)
1267 continue;
1268
1269 /* Read datasize bfd_bytes starting at offset ft_idx. */
1270 if (! bfd_get_section_contents
1271 (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1272 {
1273 free (ft_data);
1274 continue;
1275 }
1276
1277 ft_idx = 0;
1278 ft_allocated = 1;
1279 }
1280 }
1281
1282 /* Print HintName vector entries. */
1283 #ifdef COFF_WITH_pex64
1284 for (j = 0; j < datasize; j += 8)
1285 {
1286 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1287 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1288
1289 if (!member && !member_high)
1290 break;
1291
1292 if (member_high & 0x80000000)
1293 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1294 member_high,member, member_high & 0x7fffffff, member);
1295 else
1296 {
1297 int ordinal;
1298 char *member_name;
1299
1300 ordinal = bfd_get_16 (abfd, data + member - adj);
1301 member_name = (char *) data + member - adj + 2;
1302 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1303 }
1304
1305 /* If the time stamp is not zero, the import address
1306 table holds actual addresses. */
1307 if (time_stamp != 0
1308 && first_thunk != 0
1309 && first_thunk != hint_addr)
1310 fprintf (file, "\t%04lx",
1311 (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1312 fprintf (file, "\n");
1313 }
1314 #else
1315 for (j = 0; j < datasize; j += 4)
1316 {
1317 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1318
1319 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1320 if (member == 0)
1321 break;
1322
1323 if (member & 0x80000000)
1324 fprintf (file, "\t%04lx\t %4lu <none>",
1325 member, member & 0x7fffffff);
1326 else
1327 {
1328 int ordinal;
1329 char *member_name;
1330
1331 ordinal = bfd_get_16 (abfd, data + member - adj);
1332 member_name = (char *) data + member - adj + 2;
1333 fprintf (file, "\t%04lx\t %4d %s",
1334 member, ordinal, member_name);
1335 }
1336
1337 /* If the time stamp is not zero, the import address
1338 table holds actual addresses. */
1339 if (time_stamp != 0
1340 && first_thunk != 0
1341 && first_thunk != hint_addr)
1342 fprintf (file, "\t%04lx",
1343 (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1344
1345 fprintf (file, "\n");
1346 }
1347 #endif
1348 if (ft_allocated)
1349 free (ft_data);
1350 }
1351
1352 fprintf (file, "\n");
1353 }
1354
1355 free (data);
1356
1357 return TRUE;
1358 }
1359
1360 static bfd_boolean
pe_print_edata(bfd * abfd,void * vfile)1361 pe_print_edata (bfd * abfd, void * vfile)
1362 {
1363 FILE *file = (FILE *) vfile;
1364 bfd_byte *data;
1365 asection *section;
1366 bfd_size_type datasize = 0;
1367 bfd_size_type dataoff;
1368 bfd_size_type i;
1369 bfd_signed_vma adj;
1370 struct EDT_type
1371 {
1372 long export_flags; /* Reserved - should be zero. */
1373 long time_stamp;
1374 short major_ver;
1375 short minor_ver;
1376 bfd_vma name; /* RVA - relative to image base. */
1377 long base; /* Ordinal base. */
1378 unsigned long num_functions;/* Number in the export address table. */
1379 unsigned long num_names; /* Number in the name pointer table. */
1380 bfd_vma eat_addr; /* RVA to the export address table. */
1381 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1382 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1383 } edt;
1384
1385 pe_data_type *pe = pe_data (abfd);
1386 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1387
1388 bfd_vma addr;
1389
1390 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1391
1392 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1393 {
1394 /* Maybe the extra header isn't there. Look for the section. */
1395 section = bfd_get_section_by_name (abfd, ".edata");
1396 if (section == NULL)
1397 return TRUE;
1398
1399 addr = section->vma;
1400 dataoff = 0;
1401 datasize = section->size;
1402 if (datasize == 0)
1403 return TRUE;
1404 }
1405 else
1406 {
1407 addr += extra->ImageBase;
1408
1409 for (section = abfd->sections; section != NULL; section = section->next)
1410 if (addr >= section->vma && addr < section->vma + section->size)
1411 break;
1412
1413 if (section == NULL)
1414 {
1415 fprintf (file,
1416 _("\nThere is an export table, but the section containing it could not be found\n"));
1417 return TRUE;
1418 }
1419
1420 dataoff = addr - section->vma;
1421 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1422 if (datasize > section->size - dataoff)
1423 {
1424 fprintf (file,
1425 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1426 section->name);
1427 return TRUE;
1428 }
1429 }
1430
1431 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1432 section->name, (unsigned long) addr);
1433
1434 data = bfd_malloc (datasize);
1435 if (data == NULL)
1436 return FALSE;
1437
1438 if (! bfd_get_section_contents (abfd, section, data,
1439 (file_ptr) dataoff, datasize))
1440 return FALSE;
1441
1442 /* Go get Export Directory Table. */
1443 edt.export_flags = bfd_get_32 (abfd, data + 0);
1444 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1445 edt.major_ver = bfd_get_16 (abfd, data + 8);
1446 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1447 edt.name = bfd_get_32 (abfd, data + 12);
1448 edt.base = bfd_get_32 (abfd, data + 16);
1449 edt.num_functions = bfd_get_32 (abfd, data + 20);
1450 edt.num_names = bfd_get_32 (abfd, data + 24);
1451 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1452 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1453 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1454
1455 adj = section->vma - extra->ImageBase + dataoff;
1456
1457 /* Dump the EDT first. */
1458 fprintf (file,
1459 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1460 section->name);
1461
1462 fprintf (file,
1463 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1464
1465 fprintf (file,
1466 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1467
1468 fprintf (file,
1469 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1470
1471 fprintf (file,
1472 _("Name \t\t\t\t"));
1473 fprintf_vma (file, edt.name);
1474 fprintf (file,
1475 " %s\n", data + edt.name - adj);
1476
1477 fprintf (file,
1478 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1479
1480 fprintf (file,
1481 _("Number in:\n"));
1482
1483 fprintf (file,
1484 _("\tExport Address Table \t\t%08lx\n"),
1485 edt.num_functions);
1486
1487 fprintf (file,
1488 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1489
1490 fprintf (file,
1491 _("Table Addresses\n"));
1492
1493 fprintf (file,
1494 _("\tExport Address Table \t\t"));
1495 fprintf_vma (file, edt.eat_addr);
1496 fprintf (file, "\n");
1497
1498 fprintf (file,
1499 _("\tName Pointer Table \t\t"));
1500 fprintf_vma (file, edt.npt_addr);
1501 fprintf (file, "\n");
1502
1503 fprintf (file,
1504 _("\tOrdinal Table \t\t\t"));
1505 fprintf_vma (file, edt.ot_addr);
1506 fprintf (file, "\n");
1507
1508 /* The next table to find is the Export Address Table. It's basically
1509 a list of pointers that either locate a function in this dll, or
1510 forward the call to another dll. Something like:
1511 typedef union
1512 {
1513 long export_rva;
1514 long forwarder_rva;
1515 } export_address_table_entry; */
1516
1517 fprintf (file,
1518 _("\nExport Address Table -- Ordinal Base %ld\n"),
1519 edt.base);
1520
1521 for (i = 0; i < edt.num_functions; ++i)
1522 {
1523 bfd_vma eat_member = bfd_get_32 (abfd,
1524 data + edt.eat_addr + (i * 4) - adj);
1525 if (eat_member == 0)
1526 continue;
1527
1528 if (eat_member - adj <= datasize)
1529 {
1530 /* This rva is to a name (forwarding function) in our section. */
1531 /* Should locate a function descriptor. */
1532 fprintf (file,
1533 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1534 (long) i,
1535 (long) (i + edt.base),
1536 (unsigned long) eat_member,
1537 _("Forwarder RVA"),
1538 data + eat_member - adj);
1539 }
1540 else
1541 {
1542 /* Should locate a function descriptor in the reldata section. */
1543 fprintf (file,
1544 "\t[%4ld] +base[%4ld] %04lx %s\n",
1545 (long) i,
1546 (long) (i + edt.base),
1547 (unsigned long) eat_member,
1548 _("Export RVA"));
1549 }
1550 }
1551
1552 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1553 /* Dump them in parallel for clarity. */
1554 fprintf (file,
1555 _("\n[Ordinal/Name Pointer] Table\n"));
1556
1557 for (i = 0; i < edt.num_names; ++i)
1558 {
1559 bfd_vma name_ptr = bfd_get_32 (abfd,
1560 data +
1561 edt.npt_addr
1562 + (i*4) - adj);
1563
1564 char *name = (char *) data + name_ptr - adj;
1565
1566 bfd_vma ord = bfd_get_16 (abfd,
1567 data +
1568 edt.ot_addr
1569 + (i*2) - adj);
1570 fprintf (file,
1571 "\t[%4ld] %s\n", (long) ord, name);
1572 }
1573
1574 free (data);
1575
1576 return TRUE;
1577 }
1578
1579 /* This really is architecture dependent. On IA-64, a .pdata entry
1580 consists of three dwords containing relative virtual addresses that
1581 specify the start and end address of the code range the entry
1582 covers and the address of the corresponding unwind info data. */
1583
1584 static bfd_boolean
pe_print_pdata(bfd * abfd,void * vfile)1585 pe_print_pdata (bfd * abfd, void * vfile)
1586 {
1587 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1588 # define PDATA_ROW_SIZE (3 * 8)
1589 #else
1590 # define PDATA_ROW_SIZE (5 * 4)
1591 #endif
1592 FILE *file = (FILE *) vfile;
1593 bfd_byte *data = 0;
1594 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1595 bfd_size_type datasize = 0;
1596 bfd_size_type i;
1597 bfd_size_type start, stop;
1598 int onaline = PDATA_ROW_SIZE;
1599
1600 if (section == NULL
1601 || coff_section_data (abfd, section) == NULL
1602 || pei_section_data (abfd, section) == NULL)
1603 return TRUE;
1604
1605 stop = pei_section_data (abfd, section)->virt_size;
1606 if ((stop % onaline) != 0)
1607 fprintf (file,
1608 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1609 (long) stop, onaline);
1610
1611 fprintf (file,
1612 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1613 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1614 fprintf (file,
1615 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1616 #else
1617 fprintf (file, _("\
1618 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1619 \t\tAddress Address Handler Data Address Mask\n"));
1620 #endif
1621
1622 datasize = section->size;
1623 if (datasize == 0)
1624 return TRUE;
1625
1626 if (! bfd_malloc_and_get_section (abfd, section, &data))
1627 {
1628 if (data != NULL)
1629 free (data);
1630 return FALSE;
1631 }
1632
1633 start = 0;
1634
1635 for (i = start; i < stop; i += onaline)
1636 {
1637 bfd_vma begin_addr;
1638 bfd_vma end_addr;
1639 bfd_vma eh_handler;
1640 bfd_vma eh_data;
1641 bfd_vma prolog_end_addr;
1642 int em_data;
1643
1644 if (i + PDATA_ROW_SIZE > stop)
1645 break;
1646
1647 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1648 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1649 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1650 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1651 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1652
1653 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1654 && eh_data == 0 && prolog_end_addr == 0)
1655 /* We are probably into the padding of the section now. */
1656 break;
1657
1658 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1659 eh_handler &= ~(bfd_vma) 0x3;
1660 prolog_end_addr &= ~(bfd_vma) 0x3;
1661
1662 fputc (' ', file);
1663 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1664 fprintf_vma (file, begin_addr); fputc (' ', file);
1665 fprintf_vma (file, end_addr); fputc (' ', file);
1666 fprintf_vma (file, eh_handler);
1667 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1668 fputc (' ', file);
1669 fprintf_vma (file, eh_data); fputc (' ', file);
1670 fprintf_vma (file, prolog_end_addr);
1671 fprintf (file, " %x", em_data);
1672 #endif
1673
1674 #ifdef POWERPC_LE_PE
1675 if (eh_handler == 0 && eh_data != 0)
1676 {
1677 /* Special bits here, although the meaning may be a little
1678 mysterious. The only one I know for sure is 0x03
1679 Code Significance
1680 0x00 None
1681 0x01 Register Save Millicode
1682 0x02 Register Restore Millicode
1683 0x03 Glue Code Sequence. */
1684 switch (eh_data)
1685 {
1686 case 0x01:
1687 fprintf (file, _(" Register save millicode"));
1688 break;
1689 case 0x02:
1690 fprintf (file, _(" Register restore millicode"));
1691 break;
1692 case 0x03:
1693 fprintf (file, _(" Glue code sequence"));
1694 break;
1695 default:
1696 break;
1697 }
1698 }
1699 #endif
1700 fprintf (file, "\n");
1701 }
1702
1703 free (data);
1704
1705 return TRUE;
1706 }
1707
1708 #define IMAGE_REL_BASED_HIGHADJ 4
1709 static const char * const tbl[] =
1710 {
1711 "ABSOLUTE",
1712 "HIGH",
1713 "LOW",
1714 "HIGHLOW",
1715 "HIGHADJ",
1716 "MIPS_JMPADDR",
1717 "SECTION",
1718 "REL32",
1719 "RESERVED1",
1720 "MIPS_JMPADDR16",
1721 "DIR64",
1722 "HIGH3ADJ",
1723 "UNKNOWN", /* MUST be last. */
1724 };
1725
1726 static bfd_boolean
pe_print_reloc(bfd * abfd,void * vfile)1727 pe_print_reloc (bfd * abfd, void * vfile)
1728 {
1729 FILE *file = (FILE *) vfile;
1730 bfd_byte *data = 0;
1731 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1732 bfd_size_type datasize;
1733 bfd_size_type i;
1734 bfd_size_type start, stop;
1735
1736 if (section == NULL)
1737 return TRUE;
1738
1739 if (section->size == 0)
1740 return TRUE;
1741
1742 fprintf (file,
1743 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1744
1745 datasize = section->size;
1746 if (! bfd_malloc_and_get_section (abfd, section, &data))
1747 {
1748 if (data != NULL)
1749 free (data);
1750 return FALSE;
1751 }
1752
1753 start = 0;
1754
1755 stop = section->size;
1756
1757 for (i = start; i < stop;)
1758 {
1759 int j;
1760 bfd_vma virtual_address;
1761 long number, size;
1762
1763 /* The .reloc section is a sequence of blocks, with a header consisting
1764 of two 32 bit quantities, followed by a number of 16 bit entries. */
1765 virtual_address = bfd_get_32 (abfd, data+i);
1766 size = bfd_get_32 (abfd, data+i+4);
1767 number = (size - 8) / 2;
1768
1769 if (size == 0)
1770 break;
1771
1772 fprintf (file,
1773 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1774 (unsigned long) virtual_address, size, size, number);
1775
1776 for (j = 0; j < number; ++j)
1777 {
1778 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1779 unsigned int t = (e & 0xF000) >> 12;
1780 int off = e & 0x0FFF;
1781
1782 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1783 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1784
1785 fprintf (file,
1786 _("\treloc %4d offset %4x [%4lx] %s"),
1787 j, off, (long) (off + virtual_address), tbl[t]);
1788
1789 /* HIGHADJ takes an argument, - the next record *is* the
1790 low 16 bits of addend. */
1791 if (t == IMAGE_REL_BASED_HIGHADJ)
1792 {
1793 fprintf (file, " (%4x)",
1794 ((unsigned int)
1795 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1796 j++;
1797 }
1798
1799 fprintf (file, "\n");
1800 }
1801
1802 i += size;
1803 }
1804
1805 free (data);
1806
1807 return TRUE;
1808 }
1809
1810 /* Print out the program headers. */
1811
1812 bfd_boolean
_bfd_XX_print_private_bfd_data_common(bfd * abfd,void * vfile)1813 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1814 {
1815 FILE *file = (FILE *) vfile;
1816 int j;
1817 pe_data_type *pe = pe_data (abfd);
1818 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1819 const char *subsystem_name = NULL;
1820 const char *name;
1821
1822 /* The MS dumpbin program reportedly ands with 0xff0f before
1823 printing the characteristics field. Not sure why. No reason to
1824 emulate it here. */
1825 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1826 #undef PF
1827 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1828 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
1829 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
1830 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
1831 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
1832 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
1833 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
1834 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
1835 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
1836 PF (IMAGE_FILE_SYSTEM, "system file");
1837 PF (IMAGE_FILE_DLL, "DLL");
1838 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
1839 #undef PF
1840
1841 /* ctime implies '\n'. */
1842 {
1843 time_t t = pe->coff.timestamp;
1844 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1845 }
1846
1847 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
1848 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
1849 #endif
1850 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1851 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
1852 #endif
1853 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
1854 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
1855 #endif
1856
1857 switch (i->Magic)
1858 {
1859 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
1860 name = "PE32";
1861 break;
1862 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
1863 name = "PE32+";
1864 break;
1865 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
1866 name = "ROM";
1867 break;
1868 default:
1869 name = NULL;
1870 break;
1871 }
1872 fprintf (file, "Magic\t\t\t%04x", i->Magic);
1873 if (name)
1874 fprintf (file, "\t(%s)",name);
1875 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
1876 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
1877 fprintf (file, "SizeOfCode\t\t%08lx\n", i->SizeOfCode);
1878 fprintf (file, "SizeOfInitializedData\t%08lx\n",
1879 i->SizeOfInitializedData);
1880 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
1881 i->SizeOfUninitializedData);
1882 fprintf (file, "AddressOfEntryPoint\t");
1883 fprintf_vma (file, i->AddressOfEntryPoint);
1884 fprintf (file, "\nBaseOfCode\t\t");
1885 fprintf_vma (file, i->BaseOfCode);
1886 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1887 /* PE32+ does not have BaseOfData member! */
1888 fprintf (file, "\nBaseOfData\t\t");
1889 fprintf_vma (file, i->BaseOfData);
1890 #endif
1891
1892 fprintf (file, "\nImageBase\t\t");
1893 fprintf_vma (file, i->ImageBase);
1894 fprintf (file, "\nSectionAlignment\t");
1895 fprintf_vma (file, i->SectionAlignment);
1896 fprintf (file, "\nFileAlignment\t\t");
1897 fprintf_vma (file, i->FileAlignment);
1898 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1899 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1900 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1901 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1902 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1903 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1904 fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1905 fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1906 fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1907 fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1908
1909 switch (i->Subsystem)
1910 {
1911 case IMAGE_SUBSYSTEM_UNKNOWN:
1912 subsystem_name = "unspecified";
1913 break;
1914 case IMAGE_SUBSYSTEM_NATIVE:
1915 subsystem_name = "NT native";
1916 break;
1917 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1918 subsystem_name = "Windows GUI";
1919 break;
1920 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1921 subsystem_name = "Windows CUI";
1922 break;
1923 case IMAGE_SUBSYSTEM_POSIX_CUI:
1924 subsystem_name = "POSIX CUI";
1925 break;
1926 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1927 subsystem_name = "Wince CUI";
1928 break;
1929 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1930 subsystem_name = "EFI application";
1931 break;
1932 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1933 subsystem_name = "EFI boot service driver";
1934 break;
1935 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1936 subsystem_name = "EFI runtime driver";
1937 break;
1938 // These are from revision 8.0 of the MS PE/COFF spec
1939 case IMAGE_SUBSYSTEM_EFI_ROM:
1940 subsystem_name = "EFI ROM";
1941 break;
1942 case IMAGE_SUBSYSTEM_XBOX:
1943 subsystem_name = "XBOX";
1944 break;
1945 // Added default case for clarity - subsystem_name is NULL anyway.
1946 default:
1947 subsystem_name = NULL;
1948 }
1949
1950 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1951 if (subsystem_name)
1952 fprintf (file, "\t(%s)", subsystem_name);
1953 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1954 fprintf (file, "SizeOfStackReserve\t");
1955 fprintf_vma (file, i->SizeOfStackReserve);
1956 fprintf (file, "\nSizeOfStackCommit\t");
1957 fprintf_vma (file, i->SizeOfStackCommit);
1958 fprintf (file, "\nSizeOfHeapReserve\t");
1959 fprintf_vma (file, i->SizeOfHeapReserve);
1960 fprintf (file, "\nSizeOfHeapCommit\t");
1961 fprintf_vma (file, i->SizeOfHeapCommit);
1962 fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1963 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1964
1965 fprintf (file, "\nThe Data Directory\n");
1966 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1967 {
1968 fprintf (file, "Entry %1x ", j);
1969 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1970 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1971 fprintf (file, "%s\n", dir_names[j]);
1972 }
1973
1974 pe_print_idata (abfd, vfile);
1975 pe_print_edata (abfd, vfile);
1976 pe_print_pdata (abfd, vfile);
1977 pe_print_reloc (abfd, vfile);
1978
1979 return TRUE;
1980 }
1981
1982 /* Copy any private info we understand from the input bfd
1983 to the output bfd. */
1984
1985 bfd_boolean
_bfd_XX_bfd_copy_private_bfd_data_common(bfd * ibfd,bfd * obfd)1986 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
1987 {
1988 /* One day we may try to grok other private data. */
1989 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1990 || obfd->xvec->flavour != bfd_target_coff_flavour)
1991 return TRUE;
1992
1993 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1994 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1995
1996 /* For strip: if we removed .reloc, we'll make a real mess of things
1997 if we don't remove this entry as well. */
1998 if (! pe_data (obfd)->has_reloc_section)
1999 {
2000 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2001 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2002 }
2003 return TRUE;
2004 }
2005
2006 /* Copy private section data. */
2007
2008 bfd_boolean
_bfd_XX_bfd_copy_private_section_data(bfd * ibfd,asection * isec,bfd * obfd,asection * osec)2009 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2010 asection *isec,
2011 bfd *obfd,
2012 asection *osec)
2013 {
2014 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2015 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2016 return TRUE;
2017
2018 if (coff_section_data (ibfd, isec) != NULL
2019 && pei_section_data (ibfd, isec) != NULL)
2020 {
2021 if (coff_section_data (obfd, osec) == NULL)
2022 {
2023 bfd_size_type amt = sizeof (struct coff_section_tdata);
2024 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2025 if (osec->used_by_bfd == NULL)
2026 return FALSE;
2027 }
2028
2029 if (pei_section_data (obfd, osec) == NULL)
2030 {
2031 bfd_size_type amt = sizeof (struct pei_section_tdata);
2032 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2033 if (coff_section_data (obfd, osec)->tdata == NULL)
2034 return FALSE;
2035 }
2036
2037 pei_section_data (obfd, osec)->virt_size =
2038 pei_section_data (ibfd, isec)->virt_size;
2039 pei_section_data (obfd, osec)->pe_flags =
2040 pei_section_data (ibfd, isec)->pe_flags;
2041 }
2042
2043 return TRUE;
2044 }
2045
2046 void
_bfd_XX_get_symbol_info(bfd * abfd,asymbol * symbol,symbol_info * ret)2047 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2048 {
2049 coff_get_symbol_info (abfd, symbol, ret);
2050 }
2051
2052 /* Handle the .idata section and other things that need symbol table
2053 access. */
2054
2055 bfd_boolean
_bfd_XXi_final_link_postscript(bfd * abfd,struct coff_final_link_info * pfinfo)2056 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2057 {
2058 struct coff_link_hash_entry *h1;
2059 struct bfd_link_info *info = pfinfo->info;
2060 bfd_boolean result = TRUE;
2061
2062 /* There are a few fields that need to be filled in now while we
2063 have symbol table access.
2064
2065 The .idata subsections aren't directly available as sections, but
2066 they are in the symbol table, so get them from there. */
2067
2068 /* The import directory. This is the address of .idata$2, with size
2069 of .idata$2 + .idata$3. */
2070 h1 = coff_link_hash_lookup (coff_hash_table (info),
2071 ".idata$2", FALSE, FALSE, TRUE);
2072 if (h1 != NULL)
2073 {
2074 /* PR ld/2729: We cannot rely upon all the output sections having been
2075 created properly, so check before referencing them. Issue a warning
2076 message for any sections tht could not be found. */
2077 if (h1->root.u.def.section != NULL
2078 && h1->root.u.def.section->output_section != NULL)
2079 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2080 (h1->root.u.def.value
2081 + h1->root.u.def.section->output_section->vma
2082 + h1->root.u.def.section->output_offset);
2083 else
2084 {
2085 _bfd_error_handler
2086 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2087 abfd);
2088 result = FALSE;
2089 }
2090
2091 h1 = coff_link_hash_lookup (coff_hash_table (info),
2092 ".idata$4", FALSE, FALSE, TRUE);
2093 if (h1 != NULL
2094 && h1->root.u.def.section != NULL
2095 && h1->root.u.def.section->output_section != NULL)
2096 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2097 ((h1->root.u.def.value
2098 + h1->root.u.def.section->output_section->vma
2099 + h1->root.u.def.section->output_offset)
2100 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2101 else
2102 {
2103 _bfd_error_handler
2104 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2105 abfd);
2106 result = FALSE;
2107 }
2108
2109 /* The import address table. This is the size/address of
2110 .idata$5. */
2111 h1 = coff_link_hash_lookup (coff_hash_table (info),
2112 ".idata$5", FALSE, FALSE, TRUE);
2113 if (h1 != NULL
2114 && h1->root.u.def.section != NULL
2115 && h1->root.u.def.section->output_section != NULL)
2116 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2117 (h1->root.u.def.value
2118 + h1->root.u.def.section->output_section->vma
2119 + h1->root.u.def.section->output_offset);
2120 else
2121 {
2122 _bfd_error_handler
2123 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2124 abfd);
2125 result = FALSE;
2126 }
2127
2128 h1 = coff_link_hash_lookup (coff_hash_table (info),
2129 ".idata$6", FALSE, FALSE, TRUE);
2130 if (h1 != NULL
2131 && h1->root.u.def.section != NULL
2132 && h1->root.u.def.section->output_section != NULL)
2133 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2134 ((h1->root.u.def.value
2135 + h1->root.u.def.section->output_section->vma
2136 + h1->root.u.def.section->output_offset)
2137 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2138 else
2139 {
2140 _bfd_error_handler
2141 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2142 abfd);
2143 result = FALSE;
2144 }
2145 }
2146
2147 h1 = coff_link_hash_lookup (coff_hash_table (info),
2148 "__tls_used", FALSE, FALSE, TRUE);
2149 if (h1 != NULL)
2150 {
2151 if (h1->root.u.def.section != NULL
2152 && h1->root.u.def.section->output_section != NULL)
2153 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2154 (h1->root.u.def.value
2155 + h1->root.u.def.section->output_section->vma
2156 + h1->root.u.def.section->output_offset
2157 - pe_data (abfd)->pe_opthdr.ImageBase);
2158 else
2159 {
2160 _bfd_error_handler
2161 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2162 abfd);
2163 result = FALSE;
2164 }
2165
2166 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2167 }
2168
2169 /* If we couldn't find idata$2, we either have an excessively
2170 trivial program or are in DEEP trouble; we have to assume trivial
2171 program.... */
2172 return result;
2173 }
2174