projects / deliverable / binutils-gdb.git / blob
? search:


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