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