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


63ca3c0a3db670071390748d8b079874698ae164
[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 #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 filehdr_in->f_flags &= ~F_RELFLG;
745
746 if (pe_data (abfd)->dll)
747 filehdr_in->f_flags |= F_DLL;
748
749 filehdr_in->pe.e_magic = DOSMAGIC;
750 filehdr_in->pe.e_cblp = 0x90;
751 filehdr_in->pe.e_cp = 0x3;
752 filehdr_in->pe.e_crlc = 0x0;
753 filehdr_in->pe.e_cparhdr = 0x4;
754 filehdr_in->pe.e_minalloc = 0x0;
755 filehdr_in->pe.e_maxalloc = 0xffff;
756 filehdr_in->pe.e_ss = 0x0;
757 filehdr_in->pe.e_sp = 0xb8;
758 filehdr_in->pe.e_csum = 0x0;
759 filehdr_in->pe.e_ip = 0x0;
760 filehdr_in->pe.e_cs = 0x0;
761 filehdr_in->pe.e_lfarlc = 0x40;
762 filehdr_in->pe.e_ovno = 0x0;
763
764 for (idx = 0; idx < 4; idx++)
765 filehdr_in->pe.e_res[idx] = 0x0;
766
767 filehdr_in->pe.e_oemid = 0x0;
768 filehdr_in->pe.e_oeminfo = 0x0;
769
770 for (idx = 0; idx < 10; idx++)
771 filehdr_in->pe.e_res2[idx] = 0x0;
772
773 filehdr_in->pe.e_lfanew = 0x80;
774
775 /* This next collection of data are mostly just characters. It
776 appears to be constant within the headers put on NT exes. */
777 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
778 filehdr_in->pe.dos_message[1] = 0xcd09b400;
779 filehdr_in->pe.dos_message[2] = 0x4c01b821;
780 filehdr_in->pe.dos_message[3] = 0x685421cd;
781 filehdr_in->pe.dos_message[4] = 0x70207369;
782 filehdr_in->pe.dos_message[5] = 0x72676f72;
783 filehdr_in->pe.dos_message[6] = 0x63206d61;
784 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
785 filehdr_in->pe.dos_message[8] = 0x65622074;
786 filehdr_in->pe.dos_message[9] = 0x6e757220;
787 filehdr_in->pe.dos_message[10] = 0x206e6920;
788 filehdr_in->pe.dos_message[11] = 0x20534f44;
789 filehdr_in->pe.dos_message[12] = 0x65646f6d;
790 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
791 filehdr_in->pe.dos_message[14] = 0x24;
792 filehdr_in->pe.dos_message[15] = 0x0;
793 filehdr_in->pe.nt_signature = NT_SIGNATURE;
794
795 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
796 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
797
798 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
799 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
800 filehdr_out->f_symptr);
801 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
802 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
803 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
804
805 /* Put in extra dos header stuff. This data remains essentially
806 constant, it just has to be tacked on to the beginning of all exes
807 for NT. */
808 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
809 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
810 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
811 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
812 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
813 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
814 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
815 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
816 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
817 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
818 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
819 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
820 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
821 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
822
823 for (idx = 0; idx < 4; idx++)
824 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
825
826 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
827 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
828
829 for (idx = 0; idx < 10; idx++)
830 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
831
832 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
833
834 for (idx = 0; idx < 16; idx++)
835 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
836 filehdr_out->dos_message[idx]);
837
838 /* Also put in the NT signature. */
839 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
840
841 return FILHSZ;
842 }
843
844 unsigned int
845 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
846 {
847 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
848 FILHDR *filehdr_out = (FILHDR *) out;
849
850 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
851 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
852 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
853 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
854 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
855 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
856 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
857
858 return FILHSZ;
859 }
860
861 unsigned int
862 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
863 {
864 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
865 SCNHDR *scnhdr_ext = (SCNHDR *) out;
866 unsigned int ret = SCNHSZ;
867 bfd_vma ps;
868 bfd_vma ss;
869
870 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
871
872 PUT_SCNHDR_VADDR (abfd,
873 ((scnhdr_int->s_vaddr
874 - pe_data (abfd)->pe_opthdr.ImageBase)
875 & 0xffffffff),
876 scnhdr_ext->s_vaddr);
877
878 /* NT wants the size data to be rounded up to the next
879 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
880 sometimes). */
881 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
882 {
883 if (bfd_pei_p (abfd))
884 {
885 ps = scnhdr_int->s_size;
886 ss = 0;
887 }
888 else
889 {
890 ps = 0;
891 ss = scnhdr_int->s_size;
892 }
893 }
894 else
895 {
896 if (bfd_pei_p (abfd))
897 ps = scnhdr_int->s_paddr;
898 else
899 ps = 0;
900
901 ss = scnhdr_int->s_size;
902 }
903
904 PUT_SCNHDR_SIZE (abfd, ss,
905 scnhdr_ext->s_size);
906
907 /* s_paddr in PE is really the virtual size. */
908 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
909
910 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
911 scnhdr_ext->s_scnptr);
912 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
913 scnhdr_ext->s_relptr);
914 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
915 scnhdr_ext->s_lnnoptr);
916
917 {
918 /* Extra flags must be set when dealing with PE. All sections should also
919 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
920 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
921 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
922 (this is especially important when dealing with the .idata section since
923 the addresses for routines from .dlls must be overwritten). If .reloc
924 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
925 (0x02000000). Also, the resource data should also be read and
926 writable. */
927
928 /* FIXME: Alignment is also encoded in this field, at least on PPC and
929 ARM-WINCE. Although - how do we get the original alignment field
930 back ? */
931
932 typedef struct
933 {
934 const char * section_name;
935 unsigned long must_have;
936 }
937 pe_required_section_flags;
938
939 pe_required_section_flags known_sections [] =
940 {
941 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
942 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
943 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
944 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
945 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
946 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
947 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
948 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
949 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
950 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
951 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
952 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
953 { NULL, 0}
954 };
955
956 pe_required_section_flags * p;
957
958 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
959 we know exactly what this specific section wants so we remove it
960 and then allow the must_have field to add it back in if necessary.
961 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
962 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
963 by ld --enable-auto-import (if auto-import is actually needed),
964 by ld --omagic, or by obcopy --writable-text. */
965
966 for (p = known_sections; p->section_name; p++)
967 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
968 {
969 if (strcmp (scnhdr_int->s_name, ".text")
970 || (bfd_get_file_flags (abfd) & WP_TEXT))
971 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
972 scnhdr_int->s_flags |= p->must_have;
973 break;
974 }
975
976 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
977 }
978
979 if (coff_data (abfd)->link_info
980 && ! coff_data (abfd)->link_info->relocatable
981 && ! coff_data (abfd)->link_info->shared
982 && strcmp (scnhdr_int->s_name, ".text") == 0)
983 {
984 /* By inference from looking at MS output, the 32 bit field
985 which is the combination of the number_of_relocs and
986 number_of_linenos is used for the line number count in
987 executables. A 16-bit field won't do for cc1. The MS
988 document says that the number of relocs is zero for
989 executables, but the 17-th bit has been observed to be there.
990 Overflow is not an issue: a 4G-line program will overflow a
991 bunch of other fields long before this! */
992 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
993 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
994 }
995 else
996 {
997 if (scnhdr_int->s_nlnno <= 0xffff)
998 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
999 else
1000 {
1001 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1002 bfd_get_filename (abfd),
1003 scnhdr_int->s_nlnno);
1004 bfd_set_error (bfd_error_file_truncated);
1005 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1006 ret = 0;
1007 }
1008
1009 /* Although we could encode 0xffff relocs here, we do not, to be
1010 consistent with other parts of bfd. Also it lets us warn, as
1011 we should never see 0xffff here w/o having the overflow flag
1012 set. */
1013 if (scnhdr_int->s_nreloc < 0xffff)
1014 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1015 else
1016 {
1017 /* PE can deal with large #s of relocs, but not here. */
1018 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1019 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1020 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1021 }
1022 }
1023 return ret;
1024 }
1025
1026 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1027 {
1028 N_("Export Directory [.edata (or where ever we found it)]"),
1029 N_("Import Directory [parts of .idata]"),
1030 N_("Resource Directory [.rsrc]"),
1031 N_("Exception Directory [.pdata]"),
1032 N_("Security Directory"),
1033 N_("Base Relocation Directory [.reloc]"),
1034 N_("Debug Directory"),
1035 N_("Description Directory"),
1036 N_("Special Directory"),
1037 N_("Thread Storage Directory [.tls]"),
1038 N_("Load Configuration Directory"),
1039 N_("Bound Import Directory"),
1040 N_("Import Address Table Directory"),
1041 N_("Delay Import Directory"),
1042 N_("CLR Runtime Header"),
1043 N_("Reserved")
1044 };
1045
1046 #ifdef POWERPC_LE_PE
1047 /* The code for the PPC really falls in the "architecture dependent"
1048 category. However, it's not clear that anyone will ever care, so
1049 we're ignoring the issue for now; if/when PPC matters, some of this
1050 may need to go into peicode.h, or arguments passed to enable the
1051 PPC- specific code. */
1052 #endif
1053
1054 static bfd_boolean
1055 pe_print_idata (bfd * abfd, void * vfile)
1056 {
1057 FILE *file = (FILE *) vfile;
1058 bfd_byte *data;
1059 asection *section;
1060 bfd_signed_vma adj;
1061
1062 #ifdef POWERPC_LE_PE
1063 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1064 #endif
1065
1066 bfd_size_type datasize = 0;
1067 bfd_size_type dataoff;
1068 bfd_size_type i;
1069 int onaline = 20;
1070
1071 pe_data_type *pe = pe_data (abfd);
1072 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1073
1074 bfd_vma addr;
1075
1076 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1077
1078 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1079 {
1080 /* Maybe the extra header isn't there. Look for the section. */
1081 section = bfd_get_section_by_name (abfd, ".idata");
1082 if (section == NULL)
1083 return TRUE;
1084
1085 addr = section->vma;
1086 datasize = section->size;
1087 if (datasize == 0)
1088 return TRUE;
1089 }
1090 else
1091 {
1092 addr += extra->ImageBase;
1093 for (section = abfd->sections; section != NULL; section = section->next)
1094 {
1095 datasize = section->size;
1096 if (addr >= section->vma && addr < section->vma + datasize)
1097 break;
1098 }
1099
1100 if (section == NULL)
1101 {
1102 fprintf (file,
1103 _("\nThere is an import table, but the section containing it could not be found\n"));
1104 return TRUE;
1105 }
1106 }
1107
1108 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1109 section->name, (unsigned long) addr);
1110
1111 dataoff = addr - section->vma;
1112 datasize -= dataoff;
1113
1114 #ifdef POWERPC_LE_PE
1115 if (rel_section != 0 && rel_section->size != 0)
1116 {
1117 /* The toc address can be found by taking the starting address,
1118 which on the PPC locates a function descriptor. The
1119 descriptor consists of the function code starting address
1120 followed by the address of the toc. The starting address we
1121 get from the bfd, and the descriptor is supposed to be in the
1122 .reldata section. */
1123
1124 bfd_vma loadable_toc_address;
1125 bfd_vma toc_address;
1126 bfd_vma start_address;
1127 bfd_byte *data;
1128 bfd_vma offset;
1129
1130 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1131 {
1132 if (data != NULL)
1133 free (data);
1134 return FALSE;
1135 }
1136
1137 offset = abfd->start_address - rel_section->vma;
1138
1139 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1140 {
1141 if (data != NULL)
1142 free (data);
1143 return FALSE;
1144 }
1145
1146 start_address = bfd_get_32 (abfd, data + offset);
1147 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1148 toc_address = loadable_toc_address - 32768;
1149
1150 fprintf (file,
1151 _("\nFunction descriptor located at the start address: %04lx\n"),
1152 (unsigned long int) (abfd->start_address));
1153 fprintf (file,
1154 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1155 start_address, loadable_toc_address, toc_address);
1156 if (data != NULL)
1157 free (data);
1158 }
1159 else
1160 {
1161 fprintf (file,
1162 _("\nNo reldata section! Function descriptor not decoded.\n"));
1163 }
1164 #endif
1165
1166 fprintf (file,
1167 _("\nThe Import Tables (interpreted %s section contents)\n"),
1168 section->name);
1169 fprintf (file,
1170 _("\
1171 vma: Hint Time Forward DLL First\n\
1172 Table Stamp Chain Name Thunk\n"));
1173
1174 /* Read the whole section. Some of the fields might be before dataoff. */
1175 if (!bfd_malloc_and_get_section (abfd, section, &data))
1176 {
1177 if (data != NULL)
1178 free (data);
1179 return FALSE;
1180 }
1181
1182 adj = section->vma - extra->ImageBase;
1183
1184 /* Print all image import descriptors. */
1185 for (i = 0; i < datasize; i += onaline)
1186 {
1187 bfd_vma hint_addr;
1188 bfd_vma time_stamp;
1189 bfd_vma forward_chain;
1190 bfd_vma dll_name;
1191 bfd_vma first_thunk;
1192 int idx = 0;
1193 bfd_size_type j;
1194 char *dll;
1195
1196 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1197 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1198 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1199 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1200 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1201 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1202 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1203
1204 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1205 (unsigned long) hint_addr,
1206 (unsigned long) time_stamp,
1207 (unsigned long) forward_chain,
1208 (unsigned long) dll_name,
1209 (unsigned long) first_thunk);
1210
1211 if (hint_addr == 0 && first_thunk == 0)
1212 break;
1213
1214 if (dll_name - adj >= section->size)
1215 break;
1216
1217 dll = (char *) data + dll_name - adj;
1218 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1219
1220 if (hint_addr != 0)
1221 {
1222 bfd_byte *ft_data;
1223 asection *ft_section;
1224 bfd_vma ft_addr;
1225 bfd_size_type ft_datasize;
1226 int ft_idx;
1227 int ft_allocated = 0;
1228
1229 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1230
1231 idx = hint_addr - adj;
1232
1233 ft_addr = first_thunk + extra->ImageBase;
1234 ft_data = data;
1235 ft_idx = first_thunk - adj;
1236 ft_allocated = 0;
1237
1238 if (first_thunk != hint_addr)
1239 {
1240 /* Find the section which contains the first thunk. */
1241 for (ft_section = abfd->sections;
1242 ft_section != NULL;
1243 ft_section = ft_section->next)
1244 {
1245 ft_datasize = ft_section->size;
1246 if (ft_addr >= ft_section->vma
1247 && ft_addr < ft_section->vma + ft_datasize)
1248 break;
1249 }
1250
1251 if (ft_section == NULL)
1252 {
1253 fprintf (file,
1254 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1255 continue;
1256 }
1257
1258 /* Now check to see if this section is the same as our current
1259 section. If it is not then we will have to load its data in. */
1260 if (ft_section == section)
1261 {
1262 ft_data = data;
1263 ft_idx = first_thunk - adj;
1264 }
1265 else
1266 {
1267 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1268 ft_data = (bfd_byte *) bfd_malloc (datasize);
1269 if (ft_data == NULL)
1270 continue;
1271
1272 /* Read datasize bfd_bytes starting at offset ft_idx. */
1273 if (! bfd_get_section_contents
1274 (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1275 {
1276 free (ft_data);
1277 continue;
1278 }
1279
1280 ft_idx = 0;
1281 ft_allocated = 1;
1282 }
1283 }
1284
1285 /* Print HintName vector entries. */
1286 #ifdef COFF_WITH_pex64
1287 for (j = 0; j < datasize; j += 8)
1288 {
1289 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1290 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1291
1292 if (!member && !member_high)
1293 break;
1294
1295 if (member_high & 0x80000000)
1296 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1297 member_high,member, member_high & 0x7fffffff, member);
1298 else
1299 {
1300 int ordinal;
1301 char *member_name;
1302
1303 ordinal = bfd_get_16 (abfd, data + member - adj);
1304 member_name = (char *) data + member - adj + 2;
1305 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1306 }
1307
1308 /* If the time stamp is not zero, the import address
1309 table holds actual addresses. */
1310 if (time_stamp != 0
1311 && first_thunk != 0
1312 && first_thunk != hint_addr)
1313 fprintf (file, "\t%04lx",
1314 (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1315 fprintf (file, "\n");
1316 }
1317 #else
1318 for (j = 0; j < datasize; j += 4)
1319 {
1320 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1321
1322 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1323 if (member == 0)
1324 break;
1325
1326 if (member & 0x80000000)
1327 fprintf (file, "\t%04lx\t %4lu <none>",
1328 member, member & 0x7fffffff);
1329 else
1330 {
1331 int ordinal;
1332 char *member_name;
1333
1334 ordinal = bfd_get_16 (abfd, data + member - adj);
1335 member_name = (char *) data + member - adj + 2;
1336 fprintf (file, "\t%04lx\t %4d %s",
1337 member, ordinal, member_name);
1338 }
1339
1340 /* If the time stamp is not zero, the import address
1341 table holds actual addresses. */
1342 if (time_stamp != 0
1343 && first_thunk != 0
1344 && first_thunk != hint_addr)
1345 fprintf (file, "\t%04lx",
1346 (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1347
1348 fprintf (file, "\n");
1349 }
1350 #endif
1351 if (ft_allocated)
1352 free (ft_data);
1353 }
1354
1355 fprintf (file, "\n");
1356 }
1357
1358 free (data);
1359
1360 return TRUE;
1361 }
1362
1363 static bfd_boolean
1364 pe_print_edata (bfd * abfd, void * vfile)
1365 {
1366 FILE *file = (FILE *) vfile;
1367 bfd_byte *data;
1368 asection *section;
1369 bfd_size_type datasize = 0;
1370 bfd_size_type dataoff;
1371 bfd_size_type i;
1372 bfd_signed_vma adj;
1373 struct EDT_type
1374 {
1375 long export_flags; /* Reserved - should be zero. */
1376 long time_stamp;
1377 short major_ver;
1378 short minor_ver;
1379 bfd_vma name; /* RVA - relative to image base. */
1380 long base; /* Ordinal base. */
1381 unsigned long num_functions;/* Number in the export address table. */
1382 unsigned long num_names; /* Number in the name pointer table. */
1383 bfd_vma eat_addr; /* RVA to the export address table. */
1384 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1385 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1386 } edt;
1387
1388 pe_data_type *pe = pe_data (abfd);
1389 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1390
1391 bfd_vma addr;
1392
1393 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1394
1395 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1396 {
1397 /* Maybe the extra header isn't there. Look for the section. */
1398 section = bfd_get_section_by_name (abfd, ".edata");
1399 if (section == NULL)
1400 return TRUE;
1401
1402 addr = section->vma;
1403 dataoff = 0;
1404 datasize = section->size;
1405 if (datasize == 0)
1406 return TRUE;
1407 }
1408 else
1409 {
1410 addr += extra->ImageBase;
1411
1412 for (section = abfd->sections; section != NULL; section = section->next)
1413 if (addr >= section->vma && addr < section->vma + section->size)
1414 break;
1415
1416 if (section == NULL)
1417 {
1418 fprintf (file,
1419 _("\nThere is an export table, but the section containing it could not be found\n"));
1420 return TRUE;
1421 }
1422
1423 dataoff = addr - section->vma;
1424 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1425 if (datasize > section->size - dataoff)
1426 {
1427 fprintf (file,
1428 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1429 section->name);
1430 return TRUE;
1431 }
1432 }
1433
1434 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1435 section->name, (unsigned long) addr);
1436
1437 data = (bfd_byte *) bfd_malloc (datasize);
1438 if (data == NULL)
1439 return FALSE;
1440
1441 if (! bfd_get_section_contents (abfd, section, data,
1442 (file_ptr) dataoff, datasize))
1443 return FALSE;
1444
1445 /* Go get Export Directory Table. */
1446 edt.export_flags = bfd_get_32 (abfd, data + 0);
1447 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1448 edt.major_ver = bfd_get_16 (abfd, data + 8);
1449 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1450 edt.name = bfd_get_32 (abfd, data + 12);
1451 edt.base = bfd_get_32 (abfd, data + 16);
1452 edt.num_functions = bfd_get_32 (abfd, data + 20);
1453 edt.num_names = bfd_get_32 (abfd, data + 24);
1454 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1455 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1456 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1457
1458 adj = section->vma - extra->ImageBase + dataoff;
1459
1460 /* Dump the EDT first. */
1461 fprintf (file,
1462 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1463 section->name);
1464
1465 fprintf (file,
1466 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1467
1468 fprintf (file,
1469 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1470
1471 fprintf (file,
1472 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1473
1474 fprintf (file,
1475 _("Name \t\t\t\t"));
1476 bfd_fprintf_vma (abfd, file, edt.name);
1477 fprintf (file,
1478 " %s\n", data + edt.name - adj);
1479
1480 fprintf (file,
1481 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1482
1483 fprintf (file,
1484 _("Number in:\n"));
1485
1486 fprintf (file,
1487 _("\tExport Address Table \t\t%08lx\n"),
1488 edt.num_functions);
1489
1490 fprintf (file,
1491 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1492
1493 fprintf (file,
1494 _("Table Addresses\n"));
1495
1496 fprintf (file,
1497 _("\tExport Address Table \t\t"));
1498 bfd_fprintf_vma (abfd, file, edt.eat_addr);
1499 fprintf (file, "\n");
1500
1501 fprintf (file,
1502 _("\tName Pointer Table \t\t"));
1503 bfd_fprintf_vma (abfd, file, edt.npt_addr);
1504 fprintf (file, "\n");
1505
1506 fprintf (file,
1507 _("\tOrdinal Table \t\t\t"));
1508 bfd_fprintf_vma (abfd, file, edt.ot_addr);
1509 fprintf (file, "\n");
1510
1511 /* The next table to find is the Export Address Table. It's basically
1512 a list of pointers that either locate a function in this dll, or
1513 forward the call to another dll. Something like:
1514 typedef union
1515 {
1516 long export_rva;
1517 long forwarder_rva;
1518 } export_address_table_entry; */
1519
1520 fprintf (file,
1521 _("\nExport Address Table -- Ordinal Base %ld\n"),
1522 edt.base);
1523
1524 for (i = 0; i < edt.num_functions; ++i)
1525 {
1526 bfd_vma eat_member = bfd_get_32 (abfd,
1527 data + edt.eat_addr + (i * 4) - adj);
1528 if (eat_member == 0)
1529 continue;
1530
1531 if (eat_member - adj <= datasize)
1532 {
1533 /* This rva is to a name (forwarding function) in our section. */
1534 /* Should locate a function descriptor. */
1535 fprintf (file,
1536 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1537 (long) i,
1538 (long) (i + edt.base),
1539 (unsigned long) eat_member,
1540 _("Forwarder RVA"),
1541 data + eat_member - adj);
1542 }
1543 else
1544 {
1545 /* Should locate a function descriptor in the reldata section. */
1546 fprintf (file,
1547 "\t[%4ld] +base[%4ld] %04lx %s\n",
1548 (long) i,
1549 (long) (i + edt.base),
1550 (unsigned long) eat_member,
1551 _("Export RVA"));
1552 }
1553 }
1554
1555 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1556 /* Dump them in parallel for clarity. */
1557 fprintf (file,
1558 _("\n[Ordinal/Name Pointer] Table\n"));
1559
1560 for (i = 0; i < edt.num_names; ++i)
1561 {
1562 bfd_vma name_ptr = bfd_get_32 (abfd,
1563 data +
1564 edt.npt_addr
1565 + (i*4) - adj);
1566
1567 char *name = (char *) data + name_ptr - adj;
1568
1569 bfd_vma ord = bfd_get_16 (abfd,
1570 data +
1571 edt.ot_addr
1572 + (i*2) - adj);
1573 fprintf (file,
1574 "\t[%4ld] %s\n", (long) ord, name);
1575 }
1576
1577 free (data);
1578
1579 return TRUE;
1580 }
1581
1582 /* This really is architecture dependent. On IA-64, a .pdata entry
1583 consists of three dwords containing relative virtual addresses that
1584 specify the start and end address of the code range the entry
1585 covers and the address of the corresponding unwind info data.
1586
1587 On ARM and SH-4, a compressed PDATA structure is used :
1588 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1589 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1590 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1591
1592 This is the version for uncompressed data. */
1593
1594 static bfd_boolean
1595 pe_print_pdata (bfd * abfd, void * vfile)
1596 {
1597 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1598 # define PDATA_ROW_SIZE (3 * 8)
1599 #else
1600 # define PDATA_ROW_SIZE (5 * 4)
1601 #endif
1602 FILE *file = (FILE *) vfile;
1603 bfd_byte *data = 0;
1604 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1605 bfd_size_type datasize = 0;
1606 bfd_size_type i;
1607 bfd_size_type start, stop;
1608 int onaline = PDATA_ROW_SIZE;
1609
1610 if (section == NULL
1611 || coff_section_data (abfd, section) == NULL
1612 || pei_section_data (abfd, section) == NULL)
1613 return TRUE;
1614
1615 stop = pei_section_data (abfd, section)->virt_size;
1616 if ((stop % onaline) != 0)
1617 fprintf (file,
1618 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1619 (long) stop, onaline);
1620
1621 fprintf (file,
1622 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1623 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1624 fprintf (file,
1625 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1626 #else
1627 fprintf (file, _("\
1628 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1629 \t\tAddress Address Handler Data Address Mask\n"));
1630 #endif
1631
1632 datasize = section->size;
1633 if (datasize == 0)
1634 return TRUE;
1635
1636 if (! bfd_malloc_and_get_section (abfd, section, &data))
1637 {
1638 if (data != NULL)
1639 free (data);
1640 return FALSE;
1641 }
1642
1643 start = 0;
1644
1645 for (i = start; i < stop; i += onaline)
1646 {
1647 bfd_vma begin_addr;
1648 bfd_vma end_addr;
1649 bfd_vma eh_handler;
1650 bfd_vma eh_data;
1651 bfd_vma prolog_end_addr;
1652 int em_data;
1653
1654 if (i + PDATA_ROW_SIZE > stop)
1655 break;
1656
1657 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1658 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1659 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1660 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1661 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1662
1663 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1664 && eh_data == 0 && prolog_end_addr == 0)
1665 /* We are probably into the padding of the section now. */
1666 break;
1667
1668 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1669 eh_handler &= ~(bfd_vma) 0x3;
1670 prolog_end_addr &= ~(bfd_vma) 0x3;
1671
1672 fputc (' ', file);
1673 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1674 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1675 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1676 bfd_fprintf_vma (abfd, file, eh_handler);
1677 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1678 fputc (' ', file);
1679 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1680 bfd_fprintf_vma (abfd, file, prolog_end_addr);
1681 fprintf (file, " %x", em_data);
1682 #endif
1683
1684 #ifdef POWERPC_LE_PE
1685 if (eh_handler == 0 && eh_data != 0)
1686 {
1687 /* Special bits here, although the meaning may be a little
1688 mysterious. The only one I know for sure is 0x03
1689 Code Significance
1690 0x00 None
1691 0x01 Register Save Millicode
1692 0x02 Register Restore Millicode
1693 0x03 Glue Code Sequence. */
1694 switch (eh_data)
1695 {
1696 case 0x01:
1697 fprintf (file, _(" Register save millicode"));
1698 break;
1699 case 0x02:
1700 fprintf (file, _(" Register restore millicode"));
1701 break;
1702 case 0x03:
1703 fprintf (file, _(" Glue code sequence"));
1704 break;
1705 default:
1706 break;
1707 }
1708 }
1709 #endif
1710 fprintf (file, "\n");
1711 }
1712
1713 free (data);
1714
1715 return TRUE;
1716 #undef PDATA_ROW_SIZE
1717 }
1718
1719 typedef struct sym_cache
1720 {
1721 int symcount;
1722 asymbol ** syms;
1723 } sym_cache;
1724
1725 static asymbol **
1726 slurp_symtab (bfd *abfd, sym_cache *psc)
1727 {
1728 asymbol ** sy = NULL;
1729 long storage;
1730
1731 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1732 {
1733 psc->symcount = 0;
1734 return NULL;
1735 }
1736
1737 storage = bfd_get_symtab_upper_bound (abfd);
1738 if (storage < 0)
1739 return NULL;
1740 if (storage)
1741 sy = (asymbol **) bfd_malloc (storage);
1742
1743 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1744 if (psc->symcount < 0)
1745 return NULL;
1746 return sy;
1747 }
1748
1749 static const char *
1750 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1751 {
1752 int i;
1753
1754 if (psc->syms == 0)
1755 psc->syms = slurp_symtab (abfd, psc);
1756
1757 for (i = 0; i < psc->symcount; i++)
1758 {
1759 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1760 return psc->syms[i]->name;
1761 }
1762
1763 return NULL;
1764 }
1765
1766 static void
1767 cleanup_syms (sym_cache *psc)
1768 {
1769 psc->symcount = 0;
1770 free (psc->syms);
1771 psc->syms = NULL;
1772 }
1773
1774 /* This is the version for "compressed" pdata. */
1775
1776 bfd_boolean
1777 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1778 {
1779 # define PDATA_ROW_SIZE (2 * 4)
1780 FILE *file = (FILE *) vfile;
1781 bfd_byte *data = NULL;
1782 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1783 bfd_size_type datasize = 0;
1784 bfd_size_type i;
1785 bfd_size_type start, stop;
1786 int onaline = PDATA_ROW_SIZE;
1787 struct sym_cache sym_cache = {0, 0} ;
1788
1789 if (section == NULL
1790 || coff_section_data (abfd, section) == NULL
1791 || pei_section_data (abfd, section) == NULL)
1792 return TRUE;
1793
1794 stop = pei_section_data (abfd, section)->virt_size;
1795 if ((stop % onaline) != 0)
1796 fprintf (file,
1797 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1798 (long) stop, onaline);
1799
1800 fprintf (file,
1801 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1802
1803 fprintf (file, _("\
1804 vma:\t\tBegin Prolog Function Flags Exception EH\n\
1805 \t\tAddress Length Length 32b exc Handler Data\n"));
1806
1807 datasize = section->size;
1808 if (datasize == 0)
1809 return TRUE;
1810
1811 if (! bfd_malloc_and_get_section (abfd, section, &data))
1812 {
1813 if (data != NULL)
1814 free (data);
1815 return FALSE;
1816 }
1817
1818 start = 0;
1819
1820 for (i = start; i < stop; i += onaline)
1821 {
1822 bfd_vma begin_addr;
1823 bfd_vma other_data;
1824 bfd_vma prolog_length, function_length;
1825 int flag32bit, exception_flag;
1826 bfd_byte *tdata = 0;
1827 asection *tsection;
1828
1829 if (i + PDATA_ROW_SIZE > stop)
1830 break;
1831
1832 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1833 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
1834
1835 if (begin_addr == 0 && other_data == 0)
1836 /* We are probably into the padding of the section now. */
1837 break;
1838
1839 prolog_length = (other_data & 0x000000FF);
1840 function_length = (other_data & 0x3FFFFF00) >> 8;
1841 flag32bit = (int)((other_data & 0x40000000) >> 30);
1842 exception_flag = (int)((other_data & 0x80000000) >> 31);
1843
1844 fputc (' ', file);
1845 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1846 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1847 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
1848 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
1849 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
1850
1851 /* Get the exception handler's address and the data passed from the
1852 .text section. This is really the data that belongs with the .pdata
1853 but got "compressed" out for the ARM and SH4 architectures. */
1854 tsection = bfd_get_section_by_name (abfd, ".text");
1855 if (tsection && coff_section_data (abfd, tsection)
1856 && pei_section_data (abfd, tsection))
1857 {
1858 if (bfd_malloc_and_get_section (abfd, tsection, & tdata))
1859 {
1860 int xx = (begin_addr - 8) - tsection->vma;
1861
1862 tdata = (bfd_byte *) bfd_malloc (8);
1863 if (bfd_get_section_contents (abfd, tsection, tdata, (bfd_vma) xx, 8))
1864 {
1865 bfd_vma eh, eh_data;
1866
1867 eh = bfd_get_32 (abfd, tdata);
1868 eh_data = bfd_get_32 (abfd, tdata + 4);
1869 fprintf (file, "%08x ", (unsigned int) eh);
1870 fprintf (file, "%08x", (unsigned int) eh_data);
1871 if (eh != 0)
1872 {
1873 const char *s = my_symbol_for_address (abfd, eh, &sym_cache);
1874
1875 if (s)
1876 fprintf (file, " (%s) ", s);
1877 }
1878 }
1879 free (tdata);
1880 }
1881 else
1882 {
1883 if (tdata)
1884 free (tdata);
1885 }
1886 }
1887
1888 fprintf (file, "\n");
1889 }
1890
1891 free (data);
1892
1893 cleanup_syms (& sym_cache);
1894
1895 return TRUE;
1896 #undef PDATA_ROW_SIZE
1897 }
1898
1899 \f
1900 #define IMAGE_REL_BASED_HIGHADJ 4
1901 static const char * const tbl[] =
1902 {
1903 "ABSOLUTE",
1904 "HIGH",
1905 "LOW",
1906 "HIGHLOW",
1907 "HIGHADJ",
1908 "MIPS_JMPADDR",
1909 "SECTION",
1910 "REL32",
1911 "RESERVED1",
1912 "MIPS_JMPADDR16",
1913 "DIR64",
1914 "HIGH3ADJ",
1915 "UNKNOWN", /* MUST be last. */
1916 };
1917
1918 static bfd_boolean
1919 pe_print_reloc (bfd * abfd, void * vfile)
1920 {
1921 FILE *file = (FILE *) vfile;
1922 bfd_byte *data = 0;
1923 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1924 bfd_size_type datasize;
1925 bfd_size_type i;
1926 bfd_size_type start, stop;
1927
1928 if (section == NULL)
1929 return TRUE;
1930
1931 if (section->size == 0)
1932 return TRUE;
1933
1934 fprintf (file,
1935 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1936
1937 datasize = section->size;
1938 if (! bfd_malloc_and_get_section (abfd, section, &data))
1939 {
1940 if (data != NULL)
1941 free (data);
1942 return FALSE;
1943 }
1944
1945 start = 0;
1946
1947 stop = section->size;
1948
1949 for (i = start; i < stop;)
1950 {
1951 int j;
1952 bfd_vma virtual_address;
1953 long number, size;
1954
1955 /* The .reloc section is a sequence of blocks, with a header consisting
1956 of two 32 bit quantities, followed by a number of 16 bit entries. */
1957 virtual_address = bfd_get_32 (abfd, data+i);
1958 size = bfd_get_32 (abfd, data+i+4);
1959 number = (size - 8) / 2;
1960
1961 if (size == 0)
1962 break;
1963
1964 fprintf (file,
1965 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1966 (unsigned long) virtual_address, size, (unsigned long) size, number);
1967
1968 for (j = 0; j < number; ++j)
1969 {
1970 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1971 unsigned int t = (e & 0xF000) >> 12;
1972 int off = e & 0x0FFF;
1973
1974 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1975 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1976
1977 fprintf (file,
1978 _("\treloc %4d offset %4x [%4lx] %s"),
1979 j, off, (unsigned long) (off + virtual_address), tbl[t]);
1980
1981 /* HIGHADJ takes an argument, - the next record *is* the
1982 low 16 bits of addend. */
1983 if (t == IMAGE_REL_BASED_HIGHADJ)
1984 {
1985 fprintf (file, " (%4x)",
1986 ((unsigned int)
1987 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1988 j++;
1989 }
1990
1991 fprintf (file, "\n");
1992 }
1993
1994 i += size;
1995 }
1996
1997 free (data);
1998
1999 return TRUE;
2000 }
2001
2002 /* Print out the program headers. */
2003
2004 bfd_boolean
2005 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2006 {
2007 FILE *file = (FILE *) vfile;
2008 int j;
2009 pe_data_type *pe = pe_data (abfd);
2010 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2011 const char *subsystem_name = NULL;
2012 const char *name;
2013
2014 /* The MS dumpbin program reportedly ands with 0xff0f before
2015 printing the characteristics field. Not sure why. No reason to
2016 emulate it here. */
2017 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2018 #undef PF
2019 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2020 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2021 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2022 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2023 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2024 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2025 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2026 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2027 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2028 PF (IMAGE_FILE_SYSTEM, "system file");
2029 PF (IMAGE_FILE_DLL, "DLL");
2030 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2031 #undef PF
2032
2033 /* ctime implies '\n'. */
2034 {
2035 time_t t = pe->coff.timestamp;
2036 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2037 }
2038
2039 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2040 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2041 #endif
2042 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2043 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2044 #endif
2045 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2046 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2047 #endif
2048
2049 switch (i->Magic)
2050 {
2051 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2052 name = "PE32";
2053 break;
2054 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2055 name = "PE32+";
2056 break;
2057 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2058 name = "ROM";
2059 break;
2060 default:
2061 name = NULL;
2062 break;
2063 }
2064 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2065 if (name)
2066 fprintf (file, "\t(%s)",name);
2067 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2068 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2069 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2070 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2071 (unsigned long) i->SizeOfInitializedData);
2072 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2073 (unsigned long) i->SizeOfUninitializedData);
2074 fprintf (file, "AddressOfEntryPoint\t");
2075 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2076 fprintf (file, "\nBaseOfCode\t\t");
2077 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2078 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2079 /* PE32+ does not have BaseOfData member! */
2080 fprintf (file, "\nBaseOfData\t\t");
2081 bfd_fprintf_vma (abfd, file, i->BaseOfData);
2082 #endif
2083
2084 fprintf (file, "\nImageBase\t\t");
2085 bfd_fprintf_vma (abfd, file, i->ImageBase);
2086 fprintf (file, "\nSectionAlignment\t");
2087 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2088 fprintf (file, "\nFileAlignment\t\t");
2089 bfd_fprintf_vma (abfd, file, i->FileAlignment);
2090 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2091 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2092 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2093 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2094 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2095 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2096 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2097 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2098 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2099 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2100
2101 switch (i->Subsystem)
2102 {
2103 case IMAGE_SUBSYSTEM_UNKNOWN:
2104 subsystem_name = "unspecified";
2105 break;
2106 case IMAGE_SUBSYSTEM_NATIVE:
2107 subsystem_name = "NT native";
2108 break;
2109 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2110 subsystem_name = "Windows GUI";
2111 break;
2112 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2113 subsystem_name = "Windows CUI";
2114 break;
2115 case IMAGE_SUBSYSTEM_POSIX_CUI:
2116 subsystem_name = "POSIX CUI";
2117 break;
2118 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2119 subsystem_name = "Wince CUI";
2120 break;
2121 // These are from UEFI Platform Initialization Specification 1.1.
2122 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2123 subsystem_name = "EFI application";
2124 break;
2125 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2126 subsystem_name = "EFI boot service driver";
2127 break;
2128 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2129 subsystem_name = "EFI runtime driver";
2130 break;
2131 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2132 subsystem_name = "SAL runtime driver";
2133 break;
2134 // This is from revision 8.0 of the MS PE/COFF spec
2135 case IMAGE_SUBSYSTEM_XBOX:
2136 subsystem_name = "XBOX";
2137 break;
2138 // Added default case for clarity - subsystem_name is NULL anyway.
2139 default:
2140 subsystem_name = NULL;
2141 }
2142
2143 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2144 if (subsystem_name)
2145 fprintf (file, "\t(%s)", subsystem_name);
2146 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2147 fprintf (file, "SizeOfStackReserve\t");
2148 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2149 fprintf (file, "\nSizeOfStackCommit\t");
2150 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2151 fprintf (file, "\nSizeOfHeapReserve\t");
2152 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2153 fprintf (file, "\nSizeOfHeapCommit\t");
2154 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2155 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2156 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2157 (unsigned long) i->NumberOfRvaAndSizes);
2158
2159 fprintf (file, "\nThe Data Directory\n");
2160 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2161 {
2162 fprintf (file, "Entry %1x ", j);
2163 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2164 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2165 fprintf (file, "%s\n", dir_names[j]);
2166 }
2167
2168 pe_print_idata (abfd, vfile);
2169 pe_print_edata (abfd, vfile);
2170 if (bfd_coff_have_print_pdata (abfd))
2171 bfd_coff_print_pdata (abfd, vfile);
2172 else
2173 pe_print_pdata (abfd, vfile);
2174 pe_print_reloc (abfd, vfile);
2175
2176 return TRUE;
2177 }
2178
2179 /* Copy any private info we understand from the input bfd
2180 to the output bfd. */
2181
2182 bfd_boolean
2183 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2184 {
2185 pe_data_type *ipe, *ope;
2186
2187 /* One day we may try to grok other private data. */
2188 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2189 || obfd->xvec->flavour != bfd_target_coff_flavour)
2190 return TRUE;
2191
2192 ipe = pe_data (ibfd);
2193 ope = pe_data (obfd);
2194
2195 /* pe_opthdr is copied in copy_object. */
2196 ope->dll = ipe->dll;
2197
2198 /* Don't copy input subsystem if output is different from input. */
2199 if (obfd->xvec != ibfd->xvec)
2200 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2201
2202 /* For strip: if we removed .reloc, we'll make a real mess of things
2203 if we don't remove this entry as well. */
2204 if (! pe_data (obfd)->has_reloc_section)
2205 {
2206 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2207 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2208 }
2209 return TRUE;
2210 }
2211
2212 /* Copy private section data. */
2213
2214 bfd_boolean
2215 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2216 asection *isec,
2217 bfd *obfd,
2218 asection *osec)
2219 {
2220 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2221 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2222 return TRUE;
2223
2224 if (coff_section_data (ibfd, isec) != NULL
2225 && pei_section_data (ibfd, isec) != NULL)
2226 {
2227 if (coff_section_data (obfd, osec) == NULL)
2228 {
2229 bfd_size_type amt = sizeof (struct coff_section_tdata);
2230 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2231 if (osec->used_by_bfd == NULL)
2232 return FALSE;
2233 }
2234
2235 if (pei_section_data (obfd, osec) == NULL)
2236 {
2237 bfd_size_type amt = sizeof (struct pei_section_tdata);
2238 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2239 if (coff_section_data (obfd, osec)->tdata == NULL)
2240 return FALSE;
2241 }
2242
2243 pei_section_data (obfd, osec)->virt_size =
2244 pei_section_data (ibfd, isec)->virt_size;
2245 pei_section_data (obfd, osec)->pe_flags =
2246 pei_section_data (ibfd, isec)->pe_flags;
2247 }
2248
2249 return TRUE;
2250 }
2251
2252 void
2253 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2254 {
2255 coff_get_symbol_info (abfd, symbol, ret);
2256 }
2257
2258 /* Handle the .idata section and other things that need symbol table
2259 access. */
2260
2261 bfd_boolean
2262 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2263 {
2264 struct coff_link_hash_entry *h1;
2265 struct bfd_link_info *info = pfinfo->info;
2266 bfd_boolean result = TRUE;
2267
2268 /* There are a few fields that need to be filled in now while we
2269 have symbol table access.
2270
2271 The .idata subsections aren't directly available as sections, but
2272 they are in the symbol table, so get them from there. */
2273
2274 /* The import directory. This is the address of .idata$2, with size
2275 of .idata$2 + .idata$3. */
2276 h1 = coff_link_hash_lookup (coff_hash_table (info),
2277 ".idata$2", FALSE, FALSE, TRUE);
2278 if (h1 != NULL)
2279 {
2280 /* PR ld/2729: We cannot rely upon all the output sections having been
2281 created properly, so check before referencing them. Issue a warning
2282 message for any sections tht could not be found. */
2283 if ((h1->root.type == bfd_link_hash_defined
2284 || h1->root.type == bfd_link_hash_defweak)
2285 && h1->root.u.def.section != NULL
2286 && h1->root.u.def.section->output_section != NULL)
2287 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2288 (h1->root.u.def.value
2289 + h1->root.u.def.section->output_section->vma
2290 + h1->root.u.def.section->output_offset);
2291 else
2292 {
2293 _bfd_error_handler
2294 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2295 abfd);
2296 result = FALSE;
2297 }
2298
2299 h1 = coff_link_hash_lookup (coff_hash_table (info),
2300 ".idata$4", FALSE, FALSE, TRUE);
2301 if (h1 != NULL
2302 && (h1->root.type == bfd_link_hash_defined
2303 || h1->root.type == bfd_link_hash_defweak)
2304 && h1->root.u.def.section != NULL
2305 && h1->root.u.def.section->output_section != NULL)
2306 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2307 ((h1->root.u.def.value
2308 + h1->root.u.def.section->output_section->vma
2309 + h1->root.u.def.section->output_offset)
2310 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2311 else
2312 {
2313 _bfd_error_handler
2314 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2315 abfd);
2316 result = FALSE;
2317 }
2318
2319 /* The import address table. This is the size/address of
2320 .idata$5. */
2321 h1 = coff_link_hash_lookup (coff_hash_table (info),
2322 ".idata$5", FALSE, FALSE, TRUE);
2323 if (h1 != NULL
2324 && (h1->root.type == bfd_link_hash_defined
2325 || h1->root.type == bfd_link_hash_defweak)
2326 && h1->root.u.def.section != NULL
2327 && h1->root.u.def.section->output_section != NULL)
2328 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2329 (h1->root.u.def.value
2330 + h1->root.u.def.section->output_section->vma
2331 + h1->root.u.def.section->output_offset);
2332 else
2333 {
2334 _bfd_error_handler
2335 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2336 abfd);
2337 result = FALSE;
2338 }
2339
2340 h1 = coff_link_hash_lookup (coff_hash_table (info),
2341 ".idata$6", FALSE, FALSE, TRUE);
2342 if (h1 != NULL
2343 && (h1->root.type == bfd_link_hash_defined
2344 || h1->root.type == bfd_link_hash_defweak)
2345 && h1->root.u.def.section != NULL
2346 && h1->root.u.def.section->output_section != NULL)
2347 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2348 ((h1->root.u.def.value
2349 + h1->root.u.def.section->output_section->vma
2350 + h1->root.u.def.section->output_offset)
2351 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2352 else
2353 {
2354 _bfd_error_handler
2355 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2356 abfd);
2357 result = FALSE;
2358 }
2359 }
2360
2361 h1 = coff_link_hash_lookup (coff_hash_table (info),
2362 "__tls_used", FALSE, FALSE, TRUE);
2363 if (h1 != NULL)
2364 {
2365 if ((h1->root.type == bfd_link_hash_defined
2366 || h1->root.type == bfd_link_hash_defweak)
2367 && h1->root.u.def.section != NULL
2368 && h1->root.u.def.section->output_section != NULL)
2369 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2370 (h1->root.u.def.value
2371 + h1->root.u.def.section->output_section->vma
2372 + h1->root.u.def.section->output_offset
2373 - pe_data (abfd)->pe_opthdr.ImageBase);
2374 else
2375 {
2376 _bfd_error_handler
2377 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2378 abfd);
2379 result = FALSE;
2380 }
2381
2382 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2383 }
2384
2385 /* If we couldn't find idata$2, we either have an excessively
2386 trivial program or are in DEEP trouble; we have to assume trivial
2387 program.... */
2388 return result;
2389 }
GDB Binutils - Deliverables
This page took 0.119527 seconds and 3 git commands to generate.