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