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