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