projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
1999-09-11 Donn Terry <donn@interix.com>
[deliverable/binutils-gdb.git] / bfd / peigen.c
CommitLineData
277d1b5e
ILT		 1/* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21/*
22Most of this hacked by Steve Chamberlain,
23 sac@cygnus.com
24
25PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc.
27*/
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
58#include "bfd.h"
59#include "sysdep.h"
60#include "libbfd.h"
61#include "coff/internal.h"
62
63/* NOTE: it's strange to be including an architecture specific header
64 in what's supposed to be general (to PE/PEI) code. However, that's
65 where the definitions are, and they don't vary per architecture
66 within PE/PEI, so we get them from there. FIXME: The lack of
67 variance is an assumption which may prove to be incorrect if new
68 PE/PEI targets are created. */
69#include "coff/i386.h"
70
71#include "coff/pe.h"
72#include "libcoff.h"
73#include "libpei.h"
74
75/* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
76 worked when the code was in peicode.h, but no longer work now that
77 the code is in peigen.c. PowerPC NT is said to be dead. If
78 anybody wants to revive the code, you will have to figure out how
79 to handle those issues. */
80
5933bdc9
ILT		 81static void add_data_entry
82 PARAMS ((bfd *, struct internal_extra_pe_aouthdr *, int, char *, bfd_vma));
83static boolean pe_print_pdata PARAMS ((bfd *, PTR));
84static boolean pe_print_reloc PARAMS ((bfd *, PTR));
277d1b5e
ILT		 85
86/**********************************************************************/
87
88void
89_bfd_pei_swap_sym_in (abfd, ext1, in1)
90 bfd *abfd;
91 PTR ext1;
92 PTR in1;
93{
94 SYMENT *ext = (SYMENT *)ext1;
95 struct internal_syment *in = (struct internal_syment *)in1;
96
97 if( ext->e.e_name[0] == 0) {
98 in->_n._n_n._n_zeroes = 0;
99 in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
100 }
101 else {
102 memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
103 }
104
105 in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
106 in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
107 if (sizeof(ext->e_type) == 2){
108 in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
109 }
110 else {
111 in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
112 }
113 in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
114 in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
115
116#ifndef STRICT_PE_FORMAT
117 /* This is for Gnu-created DLLs */
118
119 /* The section symbols for the .idata$ sections have class 0x68
120 (C_SECTION), which MS documentation indicates is a section
121 symbol. Unfortunately, the value field in the symbol is simply a
122 copy of the .idata section's flags rather than something useful.
123 When these symbols are encountered, change the value to 0 so that
124 they will be handled somewhat correctly in the bfd code. */
125 if (in->n_sclass == C_SECTION)
126 {
127 in->n_value = 0x0;
128
129#if 0
130 /* FIXME: This is clearly wrong. The problem seems to be that
131 undefined C_SECTION symbols appear in the first object of a
132 MS generated .lib file, and the symbols are not defined
133 anywhere. */
134 in->n_scnum = 1;
135
136 /* I have tried setting the class to 3 and using the following
137 to set the section number. This will put the address of the
138 pointer to the string kernel32.dll at addresses 0 and 0x10
139 off start of idata section which is not correct */
140 /* if (strcmp (in->_n._n_name, ".idata$4") == 0) */
141 /* in->n_scnum = 3; */
142 /* else */
143 /* in->n_scnum = 2; */
144#else
145 /* Create synthetic empty sections as needed. DJ */
146 if (in->n_scnum == 0)
147 {
148 asection *sec;
149 for (sec=abfd->sections; sec; sec=sec->next)
150 {
151 if (strcmp (sec->name, in->n_name) == 0)
152 {
153 in->n_scnum = sec->target_index;
154 break;
155 }
156 }
157 }
158 if (in->n_scnum == 0)
159 {
160 int unused_section_number = 0;
161 asection *sec;
162 char *name;
163 for (sec=abfd->sections; sec; sec=sec->next)
164 if (unused_section_number <= sec->target_index)
165 unused_section_number = sec->target_index+1;
166
167 name = bfd_alloc (abfd, strlen (in->n_name) + 10);
168 if (name == NULL)
169 return;
170 strcpy (name, in->n_name);
171 sec = bfd_make_section_anyway (abfd, name);
172
173 sec->vma = 0;
174 sec->lma = 0;
175 sec->_cooked_size = 0;
176 sec->_raw_size = 0;
177 sec->filepos = 0;
178 sec->rel_filepos = 0;
179 sec->reloc_count = 0;
180 sec->line_filepos = 0;
181 sec->lineno_count = 0;
182 sec->userdata = NULL;
183 sec->next = (asection *) NULL;
184 sec->flags = 0;
185 sec->alignment_power = 2;
186 sec->flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
187
188 sec->target_index = unused_section_number;
189
190 in->n_scnum = unused_section_number;
191 }
192 in->n_sclass = C_STAT;
193#endif
194 }
195#endif
196
197#ifdef coff_swap_sym_in_hook
198 /* This won't work in peigen.c, but since it's for PPC PE, it's not
199 worth fixing. */
200 coff_swap_sym_in_hook(abfd, ext1, in1);
201#endif
202}
203
204unsigned int
205_bfd_pei_swap_sym_out (abfd, inp, extp)
206 bfd *abfd;
207 PTR inp;
208 PTR extp;
209{
210 struct internal_syment *in = (struct internal_syment *)inp;
211 SYMENT *ext =(SYMENT *)extp;
212 if(in->_n._n_name[0] == 0) {
213 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
214 bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
215 }
216 else {
217 memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
218 }
219
220 bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value);
221 bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum);
222 if (sizeof(ext->e_type) == 2)
223 {
224 bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type);
225 }
226 else
227 {
228 bfd_h_put_32(abfd, in->n_type , (bfd_byte *) ext->e_type);
229 }
230 bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass);
231 bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux);
232
233 return SYMESZ;
234}
235
236void
237_bfd_pei_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
238 bfd *abfd;
239 PTR ext1;
240 int type;
241 int class;
242 int indx ATTRIBUTE_UNUSED;
243 int numaux ATTRIBUTE_UNUSED;
244 PTR in1;
245{
246 AUXENT *ext = (AUXENT *)ext1;
247 union internal_auxent *in = (union internal_auxent *)in1;
248
249 switch (class) {
250 case C_FILE:
251 if (ext->x_file.x_fname[0] == 0) {
252 in->x_file.x_n.x_zeroes = 0;
253 in->x_file.x_n.x_offset =
254 bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
255 } else {
256 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
257 }
258 return;
259
260
261 case C_STAT:
262 case C_LEAFSTAT:
263 case C_HIDDEN:
264 if (type == T_NULL) {
265 in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
266 in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
267 in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
268 in->x_scn.x_checksum = bfd_h_get_32 (abfd,
269 (bfd_byte *) ext->x_scn.x_checksum);
270 in->x_scn.x_associated =
271 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_scn.x_associated);
272 in->x_scn.x_comdat = bfd_h_get_8 (abfd,
273 (bfd_byte *) ext->x_scn.x_comdat);
274 return;
275 }
276 break;
277 }
278
279 in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
280 in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
281
282 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
283 {
284 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
285 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
286 }
287 else
288 {
289 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
290 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
291 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
292 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
293 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
294 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
295 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
296 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
297 }
298
299 if (ISFCN(type)) {
300 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
301 }
302 else {
303 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
304 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
305 }
306}
307
308unsigned int
309_bfd_pei_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
310 bfd *abfd;
311 PTR inp;
312 int type;
313 int class;
314 int indx ATTRIBUTE_UNUSED;
315 int numaux ATTRIBUTE_UNUSED;
316 PTR extp;
317{
318 union internal_auxent *in = (union internal_auxent *)inp;
319 AUXENT *ext = (AUXENT *)extp;
320
321 memset((PTR)ext, 0, AUXESZ);
322 switch (class) {
323 case C_FILE:
324 if (in->x_file.x_fname[0] == 0) {
325 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
326 bfd_h_put_32(abfd,
327 in->x_file.x_n.x_offset,
328 (bfd_byte *) ext->x_file.x_n.x_offset);
329 }
330 else {
331 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
332 }
333 return AUXESZ;
334
335
336 case C_STAT:
337 case C_LEAFSTAT:
338 case C_HIDDEN:
339 if (type == T_NULL) {
340 PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
341 PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
342 PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
343 bfd_h_put_32 (abfd, in->x_scn.x_checksum,
344 (bfd_byte *) ext->x_scn.x_checksum);
345 bfd_h_put_16 (abfd, in->x_scn.x_associated,
346 (bfd_byte *) ext->x_scn.x_associated);
347 bfd_h_put_8 (abfd, in->x_scn.x_comdat,
348 (bfd_byte *) ext->x_scn.x_comdat);
349 return AUXESZ;
350 }
351 break;
352 }
353
354 bfd_h_put_32(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
355 bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
356
357 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
358 {
359 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
360 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
361 }
362 else
363 {
364 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
365 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
366 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
367 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
368 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
369 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
370 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
371 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
372 }
373
374 if (ISFCN (type))
375 bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
376 (bfd_byte *) ext->x_sym.x_misc.x_fsize);
377 else
378 {
379 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
380 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
381 }
382
383 return AUXESZ;
384}
385
386void
387_bfd_pei_swap_lineno_in (abfd, ext1, in1)
388 bfd *abfd;
389 PTR ext1;
390 PTR in1;
391{
392 LINENO *ext = (LINENO *)ext1;
393 struct internal_lineno *in = (struct internal_lineno *)in1;
394
395 in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
396 in->l_lnno = GET_LINENO_LNNO(abfd, ext);
397}
398
399unsigned int
400_bfd_pei_swap_lineno_out (abfd, inp, outp)
401 bfd *abfd;
402 PTR inp;
403 PTR outp;
404{
405 struct internal_lineno *in = (struct internal_lineno *)inp;
406 struct external_lineno *ext = (struct external_lineno *)outp;
407 bfd_h_put_32(abfd, in->l_addr.l_symndx, (bfd_byte *)
408 ext->l_addr.l_symndx);
409
410 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
411 return LINESZ;
412}
413
414void
415_bfd_pei_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
416 bfd *abfd;
417 PTR aouthdr_ext1;
418 PTR aouthdr_int1;
419{
420 struct internal_extra_pe_aouthdr *a;
421 PEAOUTHDR *src = (PEAOUTHDR *)(aouthdr_ext1);
422 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
423 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
424
425 aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
426 aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
427 aouthdr_int->tsize =
428 GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
429 aouthdr_int->dsize =
430 GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
431 aouthdr_int->bsize =
432 GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
433 aouthdr_int->entry =
434 GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
435 aouthdr_int->text_start =
436 GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
437 aouthdr_int->data_start =
438 GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
439
440 a = &aouthdr_int->pe;
441 a->ImageBase = bfd_h_get_32 (abfd, (bfd_byte *)src->ImageBase);
442 a->SectionAlignment = bfd_h_get_32 (abfd, (bfd_byte *)src->SectionAlignment);
443 a->FileAlignment = bfd_h_get_32 (abfd, (bfd_byte *)src->FileAlignment);
444 a->MajorOperatingSystemVersion =
445 bfd_h_get_16 (abfd, (bfd_byte *)src->MajorOperatingSystemVersion);
446 a->MinorOperatingSystemVersion =
447 bfd_h_get_16 (abfd, (bfd_byte *)src->MinorOperatingSystemVersion);
448 a->MajorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MajorImageVersion);
449 a->MinorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MinorImageVersion);
450 a->MajorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MajorSubsystemVersion);
451 a->MinorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MinorSubsystemVersion);
452 a->Reserved1 = bfd_h_get_32 (abfd, (bfd_byte *)src->Reserved1);
453 a->SizeOfImage = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfImage);
454 a->SizeOfHeaders = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeaders);
455 a->CheckSum = bfd_h_get_32 (abfd, (bfd_byte *)src->CheckSum);
456 a->Subsystem = bfd_h_get_16 (abfd, (bfd_byte *)src->Subsystem);
457 a->DllCharacteristics = bfd_h_get_16 (abfd, (bfd_byte *)src->DllCharacteristics);
458 a->SizeOfStackReserve = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfStackReserve);
459 a->SizeOfStackCommit = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfStackCommit);
460 a->SizeOfHeapReserve = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeapReserve);
461 a->SizeOfHeapCommit = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeapCommit);
462 a->LoaderFlags = bfd_h_get_32 (abfd, (bfd_byte *)src->LoaderFlags);
463 a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, (bfd_byte *)src->NumberOfRvaAndSizes);
464
465 {
466 int idx;
467 for (idx=0; idx < 16; idx++)
468 {
469 a->DataDirectory[idx].VirtualAddress =
470 bfd_h_get_32 (abfd, (bfd_byte *)src->DataDirectory[idx][0]);
471 a->DataDirectory[idx].Size =
472 bfd_h_get_32 (abfd, (bfd_byte *)src->DataDirectory[idx][1]);
473 }
474 }
475
476 if (aouthdr_int->entry)
477 {
478 aouthdr_int->entry += a->ImageBase;
479 aouthdr_int->entry &= 0xffffffff;
480 }
481 if (aouthdr_int->tsize)
482 {
483 aouthdr_int->text_start += a->ImageBase;
484 aouthdr_int->text_start &= 0xffffffff;
485 }
486 if (aouthdr_int->dsize)
487 {
488 aouthdr_int->data_start += a->ImageBase;
489 aouthdr_int->data_start &= 0xffffffff;
490 }
491
492#ifdef POWERPC_LE_PE
493 /* These three fields are normally set up by ppc_relocate_section.
494 In the case of reading a file in, we can pick them up from the
495 DataDirectory. */
496 first_thunk_address = a->DataDirectory[12].VirtualAddress ;
497 thunk_size = a->DataDirectory[12].Size;
498 import_table_size = a->DataDirectory[1].Size;
499#endif
500
501}
502
5933bdc9
ILT		 503/* A support function for below. */
504
505static void
506add_data_entry (abfd, aout, idx, name, base)
277d1b5e
ILT		 507 bfd *abfd;
508 struct internal_extra_pe_aouthdr *aout;
509 int idx;
510 char *name;
511 bfd_vma base;
512{
513 asection *sec = bfd_get_section_by_name (abfd, name);
514
515 /* add import directory information if it exists */
516 if ((sec != NULL)
517 && (coff_section_data (abfd, sec) != NULL)
518 && (pei_section_data (abfd, sec) != NULL))
519 {
520 aout->DataDirectory[idx].VirtualAddress = (sec->vma - base) & 0xffffffff;
521 aout->DataDirectory[idx].Size = pei_section_data (abfd, sec)->virt_size;
522 sec->flags |= SEC_DATA;
523 }
524}
525
526unsigned int
527_bfd_pei_swap_aouthdr_out (abfd, in, out)
528 bfd *abfd;
529 PTR in;
530 PTR out;
531{
532 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
533 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
534 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
535
536 bfd_vma sa = extra->SectionAlignment;
537 bfd_vma fa = extra->FileAlignment;
538 bfd_vma ib = extra->ImageBase ;
539
540 if (aouthdr_in->tsize)
541 {
542 aouthdr_in->text_start -= ib;
543 aouthdr_in->text_start &= 0xffffffff;
544 }
545 if (aouthdr_in->dsize)
546 {
547 aouthdr_in->data_start -= ib;
548 aouthdr_in->data_start &= 0xffffffff;
549 }
550 if (aouthdr_in->entry)
551 {
552 aouthdr_in->entry -= ib;
553 aouthdr_in->entry &= 0xffffffff;
554 }
555
556#define FA(x) (((x) + fa -1 ) & (- fa))
557#define SA(x) (((x) + sa -1 ) & (- sa))
558
559 /* We like to have the sizes aligned */
560
561 aouthdr_in->bsize = FA (aouthdr_in->bsize);
562
563
564 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
565
566 /* first null out all data directory entries .. */
567 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
568
569 add_data_entry (abfd, extra, 0, ".edata", ib);
570 add_data_entry (abfd, extra, 1, ".idata", ib);
571 add_data_entry (abfd, extra, 2, ".rsrc" ,ib);
572
573#ifdef POWERPC_LE_PE
574 /* FIXME: do other PE platforms use this? */
575 add_data_entry (abfd, extra, 3, ".pdata" ,ib);
576#endif
577
578 add_data_entry (abfd, extra, 5, ".reloc", ib);
579
580#ifdef POWERPC_LE_PE
581 /* On the PPC NT system, this field is set up as follows. It is not
582 an "officially" reserved field, so it currently has no title.
583 first_thunk_address is idata$5, and the thunk_size is the size of
584 the idata$5 chunk of the idata section. */
585 extra->DataDirectory[12].VirtualAddress = first_thunk_address;
586 extra->DataDirectory[12].Size = thunk_size;
587
588 /* On the PPC NT system, the size of the directory entry is not the
589 size of the entire section. It's actually offset to the end of
590 the idata$3 component of the idata section. This is the size of
591 the entire import table. (also known as the start of idata$4). */
592 extra->DataDirectory[1].Size = import_table_size;
593#endif
594
595 {
596 asection *sec;
597 bfd_vma dsize= 0;
598 bfd_vma isize = SA(abfd->sections->filepos);
599 bfd_vma tsize= 0;
600
601 for (sec = abfd->sections; sec; sec = sec->next)
602 {
603 int rounded = FA(sec->_raw_size);
604
605 if (sec->flags & SEC_DATA)
606 dsize += rounded;
607 if (sec->flags & SEC_CODE)
608 tsize += rounded;
5933bdc9
ILT		 609 /* The image size is the total VIRTUAL size (which is what is
610 in the virt_size field). Files have been seen (from MSVC
611 5.0 link.exe) where the file size of the .data segment is
612 quite small compared to the virtual size. Without this
613 fix, strip munges the file. */
614 isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
277d1b5e
ILT		 615 }
616
617 aouthdr_in->dsize = dsize;
618 aouthdr_in->tsize = tsize;
619 extra->SizeOfImage = isize;
620 }
621
622 extra->SizeOfHeaders = abfd->sections->filepos;
623 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
624
5933bdc9
ILT		 625#define LINKER_VERSION 256 /* That is, 2.56 */
626
627 /* This piece of magic sets the "linker version" field to
628 LINKER_VERSION. */
629 bfd_h_put_16 (abfd,
630 LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256,
631 (bfd_byte *) aouthdr_out->standard.vstamp);
277d1b5e
ILT		 632
633 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
634 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
635 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
636 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
637 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
638 (bfd_byte *) aouthdr_out->standard.text_start);
639
640 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
641 (bfd_byte *) aouthdr_out->standard.data_start);
642
643
644 bfd_h_put_32 (abfd, extra->ImageBase,
645 (bfd_byte *) aouthdr_out->ImageBase);
646 bfd_h_put_32 (abfd, extra->SectionAlignment,
647 (bfd_byte *) aouthdr_out->SectionAlignment);
648 bfd_h_put_32 (abfd, extra->FileAlignment,
649 (bfd_byte *) aouthdr_out->FileAlignment);
650 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
651 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
652 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
653 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
654 bfd_h_put_16 (abfd, extra->MajorImageVersion,
655 (bfd_byte *) aouthdr_out->MajorImageVersion);
656 bfd_h_put_16 (abfd, extra->MinorImageVersion,
657 (bfd_byte *) aouthdr_out->MinorImageVersion);
658 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
659 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
660 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
661 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
662 bfd_h_put_32 (abfd, extra->Reserved1,
663 (bfd_byte *) aouthdr_out->Reserved1);
664 bfd_h_put_32 (abfd, extra->SizeOfImage,
665 (bfd_byte *) aouthdr_out->SizeOfImage);
666 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
667 (bfd_byte *) aouthdr_out->SizeOfHeaders);
668 bfd_h_put_32 (abfd, extra->CheckSum,
669 (bfd_byte *) aouthdr_out->CheckSum);
670 bfd_h_put_16 (abfd, extra->Subsystem,
671 (bfd_byte *) aouthdr_out->Subsystem);
672 bfd_h_put_16 (abfd, extra->DllCharacteristics,
673 (bfd_byte *) aouthdr_out->DllCharacteristics);
674 bfd_h_put_32 (abfd, extra->SizeOfStackReserve,
675 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
676 bfd_h_put_32 (abfd, extra->SizeOfStackCommit,
677 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
678 bfd_h_put_32 (abfd, extra->SizeOfHeapReserve,
679 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
680 bfd_h_put_32 (abfd, extra->SizeOfHeapCommit,
681 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
682 bfd_h_put_32 (abfd, extra->LoaderFlags,
683 (bfd_byte *) aouthdr_out->LoaderFlags);
684 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
685 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
686 {
687 int idx;
688 for (idx=0; idx < 16; idx++)
689 {
690 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
691 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
692 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
693 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
694 }
695 }
696
697 return AOUTSZ;
698}
699
700unsigned int
701_bfd_pei_only_swap_filehdr_out (abfd, in, out)
702 bfd *abfd;
703 PTR in;
704 PTR out;
705{
706 int idx;
707 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
708 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *)out;
709
710 if (pe_data (abfd)->has_reloc_section)
711 filehdr_in->f_flags &= ~F_RELFLG;
712
713 if (pe_data (abfd)->dll)
714 filehdr_in->f_flags |= F_DLL;
715
716 filehdr_in->pe.e_magic = DOSMAGIC;
717 filehdr_in->pe.e_cblp = 0x90;
718 filehdr_in->pe.e_cp = 0x3;
719 filehdr_in->pe.e_crlc = 0x0;
720 filehdr_in->pe.e_cparhdr = 0x4;
721 filehdr_in->pe.e_minalloc = 0x0;
722 filehdr_in->pe.e_maxalloc = 0xffff;
723 filehdr_in->pe.e_ss = 0x0;
724 filehdr_in->pe.e_sp = 0xb8;
725 filehdr_in->pe.e_csum = 0x0;
726 filehdr_in->pe.e_ip = 0x0;
727 filehdr_in->pe.e_cs = 0x0;
728 filehdr_in->pe.e_lfarlc = 0x40;
729 filehdr_in->pe.e_ovno = 0x0;
730
731 for (idx=0; idx < 4; idx++)
732 filehdr_in->pe.e_res[idx] = 0x0;
733
734 filehdr_in->pe.e_oemid = 0x0;
735 filehdr_in->pe.e_oeminfo = 0x0;
736
737 for (idx=0; idx < 10; idx++)
738 filehdr_in->pe.e_res2[idx] = 0x0;
739
740 filehdr_in->pe.e_lfanew = 0x80;
741
742 /* this next collection of data are mostly just characters. It appears
743 to be constant within the headers put on NT exes */
744 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
745 filehdr_in->pe.dos_message[1] = 0xcd09b400;
746 filehdr_in->pe.dos_message[2] = 0x4c01b821;
747 filehdr_in->pe.dos_message[3] = 0x685421cd;
748 filehdr_in->pe.dos_message[4] = 0x70207369;
749 filehdr_in->pe.dos_message[5] = 0x72676f72;
750 filehdr_in->pe.dos_message[6] = 0x63206d61;
751 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
752 filehdr_in->pe.dos_message[8] = 0x65622074;
753 filehdr_in->pe.dos_message[9] = 0x6e757220;
754 filehdr_in->pe.dos_message[10] = 0x206e6920;
755 filehdr_in->pe.dos_message[11] = 0x20534f44;
756 filehdr_in->pe.dos_message[12] = 0x65646f6d;
757 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
758 filehdr_in->pe.dos_message[14] = 0x24;
759 filehdr_in->pe.dos_message[15] = 0x0;
760 filehdr_in->pe.nt_signature = NT_SIGNATURE;
761
762
763
764 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
765 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
766
767 bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
768 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
769 (bfd_byte *) filehdr_out->f_symptr);
770 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
771 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
772 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
773
774 /* put in extra dos header stuff. This data remains essentially
775 constant, it just has to be tacked on to the beginning of all exes
776 for NT */
777 bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
778 bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
779 bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
780 bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
781 bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr,
782 (bfd_byte *) filehdr_out->e_cparhdr);
783 bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc,
784 (bfd_byte *) filehdr_out->e_minalloc);
785 bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc,
786 (bfd_byte *) filehdr_out->e_maxalloc);
787 bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
788 bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
789 bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
790 bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
791 bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
792 bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
793 bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
794 {
795 int idx;
796 for (idx=0; idx < 4; idx++)
797 bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx],
798 (bfd_byte *) filehdr_out->e_res[idx]);
799 }
800 bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
801 bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo,
802 (bfd_byte *) filehdr_out->e_oeminfo);
803 {
804 int idx;
805 for (idx=0; idx < 10; idx++)
806 bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx],
807 (bfd_byte *) filehdr_out->e_res2[idx]);
808 }
809 bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
810
811 {
812 int idx;
813 for (idx=0; idx < 16; idx++)
814 bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx],
815 (bfd_byte *) filehdr_out->dos_message[idx]);
816 }
817
818 /* also put in the NT signature */
819 bfd_h_put_32(abfd, filehdr_in->pe.nt_signature,
820 (bfd_byte *) filehdr_out->nt_signature);
821
822
823
824
825 return FILHSZ;
826}
827
828unsigned int
829_bfd_pe_only_swap_filehdr_out (abfd, in, out)
830 bfd *abfd;
831 PTR in;
832 PTR out;
833{
834 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
835 FILHDR *filehdr_out = (FILHDR *)out;
836
837 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
838 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
839 bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
840 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
841 (bfd_byte *) filehdr_out->f_symptr);
842 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
843 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
844 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
845
846 return FILHSZ;
847}
848
849unsigned int
850_bfd_pei_swap_scnhdr_out (abfd, in, out)
851 bfd *abfd;
852 PTR in;
853 PTR out;
854{
855 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
856 SCNHDR *scnhdr_ext = (SCNHDR *)out;
857 unsigned int ret = SCNHSZ;
858 bfd_vma ps;
859 bfd_vma ss;
860
861 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
862
863 PUT_SCNHDR_VADDR (abfd,
864 ((scnhdr_int->s_vaddr
865 - pe_data(abfd)->pe_opthdr.ImageBase)
866 & 0xffffffff),
867 (bfd_byte *) scnhdr_ext->s_vaddr);
868
5933bdc9
ILT		 869 /* NT wants the size data to be rounded up to the next
870 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
871 sometimes). */
277d1b5e 872
5933bdc9 873 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
277d1b5e
ILT		 874 {
875 ps = scnhdr_int->s_size;
876 ss = 0;
877 }
878 else
879 {
880 ps = scnhdr_int->s_paddr;
881 ss = scnhdr_int->s_size;
882 }
883
884 PUT_SCNHDR_SIZE (abfd, ss,
885 (bfd_byte *) scnhdr_ext->s_size);
886
887
5933bdc9 888 /* s_paddr in PE is really the virtual size. */
277d1b5e
ILT		 889 PUT_SCNHDR_PADDR (abfd, ps, (bfd_byte *) scnhdr_ext->s_paddr);
890
891 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
892 (bfd_byte *) scnhdr_ext->s_scnptr);
893 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
894 (bfd_byte *) scnhdr_ext->s_relptr);
895 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
896 (bfd_byte *) scnhdr_ext->s_lnnoptr);
897
898 /* Extra flags must be set when dealing with NT. All sections should also
899 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
900 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
901 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
902 (this is especially important when dealing with the .idata section since
903 the addresses for routines from .dlls must be overwritten). If .reloc
904 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
905 (0x02000000). Also, the resource data should also be read and
906 writable. */
907
908 /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */
909 /* FIXME: even worse, I don't see how to get the original alignment field*/
910 /* back... */
911
277d1b5e
ILT		 912 {
913 int flags = scnhdr_int->s_flags;
277d1b5e
ILT		 914 bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
915 }
916
cb43721d
ILT		 917 if (coff_data (abfd)->link_info
918 && ! coff_data (abfd)->link_info->relocateable
919 && ! coff_data (abfd)->link_info->shared
920 && strcmp (scnhdr_int->s_name, ".text") == 0)
277d1b5e 921 {
cb43721d
ILT		 922 /* By inference from looking at MS output, the 32 bit field
923 which is the combintion of the number_of_relocs and
924 number_of_linenos is used for the line number count in
925 executables. A 16-bit field won't do for cc1. The MS
926 document says that the number of relocs is zero for
927 executables, but the 17-th bit has been observed to be there.
928 Overflow is not an issue: a 4G-line program will overflow a
929 bunch of other fields long before this! */
930 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno & 0xffff,
931 (bfd_byte *) scnhdr_ext->s_nlnno);
932 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno >> 16,
933 (bfd_byte *) scnhdr_ext->s_nreloc);
277d1b5e 934 }
277d1b5e
ILT		 935 else
936 {
cb43721d
ILT		 937 if (scnhdr_int->s_nlnno <= 0xffff)
938 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno,
939 (bfd_byte *) scnhdr_ext->s_nlnno);
940 else
941 {
942 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
943 bfd_get_filename (abfd),
944 scnhdr_int->s_nlnno);
945 bfd_set_error (bfd_error_file_truncated);
946 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
947 ret = 0;
948 }
949 if (scnhdr_int->s_nreloc <= 0xffff)
950 bfd_h_put_16 (abfd, scnhdr_int->s_nreloc,
951 (bfd_byte *) scnhdr_ext->s_nreloc);
952 else
953 {
954 (*_bfd_error_handler) (_("%s: reloc overflow: 0x%lx > 0xffff"),
955 bfd_get_filename (abfd),
956 scnhdr_int->s_nreloc);
957 bfd_set_error (bfd_error_file_truncated);
958 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
959 ret = 0;
960 }
277d1b5e
ILT		 961 }
962 return ret;
963}
964
965static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
966{
967 N_ ("Export Directory [.edata (or where ever we found it)]"),
968 N_ ("Import Directory [parts of .idata]"),
969 N_ ("Resource Directory [.rsrc]"),
970 N_ ("Exception Directory [.pdata]"),
971 N_ ("Security Directory"),
972 N_ ("Base Relocation Directory [.reloc]"),
973 N_ ("Debug Directory"),
974 N_ ("Description Directory"),
975 N_ ("Special Directory"),
976 N_ ("Thread Storage Directory [.tls]"),
977 N_ ("Load Configuration Directory"),
978 N_ ("Bound Import Directory"),
979 N_ ("Import Address Table Directory"),
980 N_ ("Reserved"),
981 N_ ("Reserved"),
982 N_ ("Reserved")
983};
984
985/**********************************************************************/
986#ifdef POWERPC_LE_PE
987/* The code for the PPC really falls in the "architecture dependent"
988 category. However, it's not clear that anyone will ever care, so
989 we're ignoring the issue for now; if/when PPC matters, some of this
990 may need to go into peicode.h, or arguments passed to enable the
991 PPC- specific code. */
992#endif
993
994/**********************************************************************/
995static boolean
5933bdc9 996pe_print_idata (abfd, vfile)
277d1b5e
ILT		 997 bfd *abfd;
998 PTR vfile;
999{
1000 FILE *file = (FILE *) vfile;
1001 bfd_byte *data = 0;
1002 asection *section = bfd_get_section_by_name (abfd, ".idata");
1003 unsigned long adj;
1004
1005#ifdef POWERPC_LE_PE
1006 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1007#endif
1008
1009 bfd_size_type datasize;
1010 bfd_size_type dataoff;
1011 bfd_size_type secsize;
1012 bfd_size_type i;
277d1b5e
ILT		 1013 int onaline = 20;
1014
1015 pe_data_type *pe = pe_data (abfd);
1016 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1017
1018 if (section != NULL)
1019 {
1020 datasize = bfd_section_size (abfd, section);
1021 dataoff = 0;
1022
1023 if (datasize == 0)
1024 return true;
5933bdc9
ILT		 1025
1026 fprintf (file, _("\nThe import table is the .idata section\n"));
277d1b5e
ILT		 1027 }
1028 else
1029 {
5933bdc9 1030 /* idata buried in some other section: e.g. KERNEL32.DLL. */
277d1b5e
ILT		 1031 bfd_vma addr, size;
1032
1033 addr = extra->DataDirectory[1].VirtualAddress;
1034 size = extra->DataDirectory[1].Size;
1035
1036 if (addr == 0 || size == 0)
1037 return true;
1038
1039 for (section = abfd->sections; section != NULL; section = section->next)
1040 {
5933bdc9
ILT		 1041 if (addr >= section->vma
1042 && addr < section->vma + bfd_section_size(abfd,section))
1043 break;
277d1b5e
ILT		 1044 }
1045 if (section == NULL)
5933bdc9
ILT		 1046 {
1047 fprintf (file,
1048 _("\nThere is an import table, but the section containing it could not be found\n"));
1049 return true;
1050 }
1051
1052 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1053 section->name, (unsigned long)addr);
277d1b5e 1054
5933bdc9 1055 dataoff = addr - section->vma;
277d1b5e
ILT		 1056 datasize = size;
1057 }
1058
1059#ifdef POWERPC_LE_PE
1060 if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1061 {
1062 /* The toc address can be found by taking the starting address,
1063 which on the PPC locates a function descriptor. The
1064 descriptor consists of the function code starting address
1065 followed by the address of the toc. The starting address we
1066 get from the bfd, and the descriptor is supposed to be in the
1067 .reldata section. */
1068
1069 bfd_vma loadable_toc_address;
1070 bfd_vma toc_address;
1071 bfd_vma start_address;
1072 bfd_byte *data = 0;
1073 int offset;
1074 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd,
1075 rel_section));
1076 if (data == NULL && bfd_section_size (abfd, rel_section) != 0)
1077 return false;
1078
1079 datasize = bfd_section_size (abfd, rel_section);
1080
1081 bfd_get_section_contents (abfd,
1082 rel_section,
1083 (PTR) data, 0,
1084 bfd_section_size (abfd, rel_section));
1085
1086 offset = abfd->start_address - rel_section->vma;
1087
1088 start_address = bfd_get_32(abfd, data+offset);
1089 loadable_toc_address = bfd_get_32(abfd, data+offset+4);
1090 toc_address = loadable_toc_address - 32768;
1091
1092 fprintf(file,
1093 _("\nFunction descriptor located at the start address: %04lx\n"),
1094 (unsigned long int) (abfd->start_address));
1095 fprintf (file,
1096 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1097 start_address, loadable_toc_address, toc_address);
1098 }
1099 else
1100 {
1101 fprintf(file,
1102 _("\nNo reldata section! Function descriptor not decoded.\n"));
1103 }
1104#endif
1105
1106 fprintf(file,
1107 _("\nThe Import Tables (interpreted .idata section contents)\n"));
1108 fprintf(file,
1109 _(" vma: Hint Time Forward DLL First\n"));
1110 fprintf(file,
1111 _(" Table Stamp Chain Name Thunk\n"));
1112
1113 secsize = bfd_section_size (abfd, section);
1114 data = (bfd_byte *) bfd_malloc (secsize);
1115 if (data == NULL && secsize != 0)
1116 return false;
1117
1118 if (! bfd_get_section_contents (abfd, section, (PTR) data, 0, secsize))
1119 return false;
1120
5933bdc9 1121 adj = - section->vma;
277d1b5e 1122
5933bdc9 1123 for (i = 0; i < datasize; i += onaline)
277d1b5e
ILT		 1124 {
1125 bfd_vma hint_addr;
1126 bfd_vma time_stamp;
1127 bfd_vma forward_chain;
1128 bfd_vma dll_name;
1129 bfd_vma first_thunk;
1130 int idx = 0;
1131 bfd_size_type j;
1132 char *dll;
1133
1134 fprintf (file,
1135 " %08lx\t",
1136 (unsigned long int) (i + section->vma + dataoff));
1137
5933bdc9 1138 if (i + 20 > datasize)
277d1b5e
ILT		 1139 {
1140 /* check stuff */
1141 ;
1142 }
5933bdc9
ILT		 1143
1144 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1145 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1146 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1147 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1148 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1149
1150 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1151 hint_addr,
1152 time_stamp,
1153 forward_chain,
1154 dll_name,
1155 first_thunk);
277d1b5e
ILT		 1156
1157 if (hint_addr == 0 && first_thunk == 0)
1158 break;
1159
5933bdc9 1160 dll = (char *) data + dll_name - section->vma + dataoff;
277d1b5e
ILT		 1161 fprintf(file, _("\n\tDLL Name: %s\n"), dll);
1162
1163 if (hint_addr != 0)
1164 {
1165 fprintf (file, _("\tvma: Hint/Ord Member-Name\n"));
1166
1167 idx = hint_addr + adj;
1168
5933bdc9 1169 for (j = 0; j < datasize; j += 4)
277d1b5e
ILT		 1170 {
1171 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1172
1173 if (member == 0)
1174 break;
1175 if (member & 0x80000000)
1176 fprintf (file, "\t%04lx\t %4lu", member,
1177 member & 0x7fffffff);
1178 else
1179 {
1180 int ordinal;
1181 char *member_name;
1182
1183 ordinal = bfd_get_16 (abfd, data + member + adj);
1184 member_name = (char *) data + member + adj + 2;
1185 fprintf (file, "\t%04lx\t %4d %s",
1186 member, ordinal, member_name);
1187 }
1188
1189 /* If the time stamp is not zero, the import address
1190 table holds actual addresses. */
1191 if (time_stamp != 0
1192 && first_thunk != 0
1193 && first_thunk != hint_addr)
1194 fprintf (file, "\t%04lx",
1195 bfd_get_32 (abfd, data + first_thunk + adj + j));
1196
1197 fprintf (file, "\n");
1198 }
1199 }
1200
1201 if (hint_addr != first_thunk && time_stamp == 0)
1202 {
1203 int differ = 0;
1204 int idx2;
1205
1206 idx2 = first_thunk + adj;
1207
5933bdc9 1208 for (j = 0; j < datasize; j += 4)
277d1b5e
ILT		 1209 {
1210 int ordinal;
1211 char *member_name;
1212 bfd_vma hint_member = 0;
1213 bfd_vma iat_member;
1214
1215 if (hint_addr != 0)
1216 hint_member = bfd_get_32 (abfd, data + idx + j);
1217 iat_member = bfd_get_32 (abfd, data + idx2 + j);
1218
1219 if (hint_addr == 0 && iat_member == 0)
1220 break;
1221
1222 if (hint_addr == 0 || hint_member != iat_member)
1223 {
1224 if (differ == 0)
1225 {
1226 fprintf (file,
1227 _("\tThe Import Address Table (difference found)\n"));
1228 fprintf(file, _("\tvma: Hint/Ord Member-Name\n"));
1229 differ = 1;
1230 }
1231 if (iat_member == 0)
1232 {
1233 fprintf(file,
1234 _("\t>>> Ran out of IAT members!\n"));
1235 }
1236 else
1237 {
1238 ordinal = bfd_get_16(abfd,
1239 data + iat_member + adj);
1240 member_name = (char *) data + iat_member + adj + 2;
1241 fprintf(file, "\t%04lx\t %4d %s\n",
1242 iat_member, ordinal, member_name);
1243 }
1244 }
1245
1246 if (hint_addr != 0 && hint_member == 0)
1247 break;
1248 }
1249 if (differ == 0)
1250 {
1251 fprintf(file,
1252 _("\tThe Import Address Table is identical\n"));
1253 }
1254 }
1255
1256 fprintf(file, "\n");
1257
1258 }
1259
1260 free (data);
1261
1262 return true;
1263}
1264
1265static boolean
1266pe_print_edata (abfd, vfile)
1267 bfd *abfd;
1268 PTR vfile;
1269{
1270 FILE *file = (FILE *) vfile;
1271 bfd_byte *data = 0;
1272 asection *section = bfd_get_section_by_name (abfd, ".edata");
1273
1274 bfd_size_type datasize;
1275 bfd_size_type dataoff;
1276 bfd_size_type i;
1277
1278 int adj;
1279 struct EDT_type
1280 {
1281 long export_flags; /* reserved - should be zero */
1282 long time_stamp;
1283 short major_ver;
1284 short minor_ver;
1285 bfd_vma name; /* rva - relative to image base */
1286 long base; /* ordinal base */
1287 unsigned long num_functions; /* Number in the export address table */
1288 unsigned long num_names; /* Number in the name pointer table */
1289 bfd_vma eat_addr; /* rva to the export address table */
1290 bfd_vma npt_addr; /* rva to the Export Name Pointer Table */
1291 bfd_vma ot_addr; /* rva to the Ordinal Table */
1292 } edt;
1293
1294 pe_data_type *pe = pe_data (abfd);
1295 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1296
1297 if (section != NULL)
1298 {
1299 datasize = bfd_section_size (abfd, section);
1300 dataoff = 0;
5933bdc9 1301 fprintf (file, _("\nThe export table is the .edata section\n"));
277d1b5e
ILT		 1302 }
1303 else
1304 {
5933bdc9 1305 /* edata is buried in some other section: e.g. NTDLL.DLL. */
277d1b5e
ILT		 1306 bfd_vma addr, size;
1307
1308 addr = extra->DataDirectory[0].VirtualAddress;
1309 size = extra->DataDirectory[0].Size;
1310
1311 if (addr == 0 || size == 0)
1312 return true;
1313
1314 for (section = abfd->sections; section != NULL; section = section->next)
1315 {
5933bdc9
ILT		 1316 if (addr >= section->vma
1317 && addr < section->vma + bfd_section_size (abfd, section))
1318 break;
277d1b5e
ILT		 1319 }
1320 if (section == NULL)
5933bdc9
ILT		 1321 {
1322 fprintf (file,
1323 _("\nThere is an export table, but the section containing it could not be found\n"));
1324 return true;
1325 }
1326
1327 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1328 section->name, (unsigned long) addr);
277d1b5e
ILT		 1329
1330 datasize = size;
5933bdc9 1331 dataoff = addr - section->vma;
277d1b5e
ILT		 1332 }
1333
1334 data = (bfd_byte *) bfd_malloc (datasize);
1335 if (data == NULL && datasize != 0)
1336 return false;
1337
1338 if (! bfd_get_section_contents (abfd, section, (PTR) data, dataoff,
1339 datasize))
1340 return false;
1341
1342 /* Go get Export Directory Table */
1343 edt.export_flags = bfd_get_32(abfd, data+0);
1344 edt.time_stamp = bfd_get_32(abfd, data+4);
1345 edt.major_ver = bfd_get_16(abfd, data+8);
1346 edt.minor_ver = bfd_get_16(abfd, data+10);
1347 edt.name = bfd_get_32(abfd, data+12);
1348 edt.base = bfd_get_32(abfd, data+16);
1349 edt.num_functions = bfd_get_32(abfd, data+20);
1350 edt.num_names = bfd_get_32(abfd, data+24);
1351 edt.eat_addr = bfd_get_32(abfd, data+28);
1352 edt.npt_addr = bfd_get_32(abfd, data+32);
1353 edt.ot_addr = bfd_get_32(abfd, data+36);
1354
5933bdc9 1355 adj = - (section->vma + dataoff);
277d1b5e
ILT		 1356
1357 /* Dump the EDT first first */
1358 fprintf(file,
1359 _("\nThe Export Tables (interpreted .edata section contents)\n\n"));
1360
1361 fprintf(file,
1362 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1363
1364 fprintf(file,
1365 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1366
1367 fprintf(file,
1368 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1369
1370 fprintf (file,
1371 _("Name \t\t\t\t"));
1372 fprintf_vma (file, edt.name);
1373 fprintf (file,
1374 " %s\n", data + edt.name + adj);
1375
1376 fprintf(file,
1377 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1378
1379 fprintf(file,
1380 _("Number in:\n"));
1381
1382 fprintf(file,
1383 _("\tExport Address Table \t\t%lx\n"),
1384 edt.num_functions);
1385
1386 fprintf(file,
1387 _("\t[Name Pointer/Ordinal] Table\t%lu\n"), edt.num_names);
1388
1389 fprintf(file,
1390 _("Table Addresses\n"));
1391
1392 fprintf (file,
1393 _("\tExport Address Table \t\t"));
1394 fprintf_vma (file, edt.eat_addr);
1395 fprintf (file, "\n");
1396
1397 fprintf (file,
1398 _("\tName Pointer Table \t\t"));
1399 fprintf_vma (file, edt.npt_addr);
1400 fprintf (file, "\n");
1401
1402 fprintf (file,
1403 _("\tOrdinal Table \t\t\t"));
1404 fprintf_vma (file, edt.ot_addr);
1405 fprintf (file, "\n");
1406
1407
5933bdc9 1408 /* The next table to find is the Export Address Table. It's basically
277d1b5e
ILT		 1409 a list of pointers that either locate a function in this dll, or
1410 forward the call to another dll. Something like:
1411 typedef union
1412 {
1413 long export_rva;
1414 long forwarder_rva;
1415 } export_address_table_entry;
1416 */
1417
1418 fprintf(file,
1419 _("\nExport Address Table -- Ordinal Base %ld\n"),
1420 edt.base);
1421
1422 for (i = 0; i < edt.num_functions; ++i)
1423 {
1424 bfd_vma eat_member = bfd_get_32 (abfd,
1425 data + edt.eat_addr + (i * 4) + adj);
5933bdc9
ILT		 1426 bfd_vma eat_actual = eat_member;
1427 bfd_vma edata_start = bfd_get_section_vma (abfd, section);
277d1b5e
ILT		 1428 bfd_vma edata_end = edata_start + datasize;
1429
1430 if (eat_member == 0)
1431 continue;
1432
1433 if (edata_start < eat_actual && eat_actual < edata_end)
1434 {
1435 /* this rva is to a name (forwarding function) in our section */
1436 /* Should locate a function descriptor */
5933bdc9
ILT		 1437 fprintf (file,
1438 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1439 (long) i, (long) (i + edt.base), eat_member,
1440 _("Forwarder RVA"), data + eat_member + adj);
277d1b5e
ILT		 1441 }
1442 else
1443 {
1444 /* Should locate a function descriptor in the reldata section */
5933bdc9
ILT		 1445 fprintf (file,
1446 "\t[%4ld] +base[%4ld] %04lx %s\n",
1447 (long) i, (long) (i + edt.base), eat_member,
1448 _("Export RVA"));
277d1b5e
ILT		 1449 }
1450 }
1451
1452 /* The Export Name Pointer Table is paired with the Export Ordinal Table */
1453 /* Dump them in parallel for clarity */
1454 fprintf(file,
1455 _("\n[Ordinal/Name Pointer] Table\n"));
1456
1457 for (i = 0; i < edt.num_names; ++i)
1458 {
1459 bfd_vma name_ptr = bfd_get_32(abfd,
1460 data +
1461 edt.npt_addr
1462 + (i*4) + adj);
1463
1464 char *name = (char *) data + name_ptr + adj;
1465
1466 bfd_vma ord = bfd_get_16(abfd,
1467 data +
1468 edt.ot_addr
1469 + (i*2) + adj);
1470 fprintf(file,
1471 "\t[%4ld] %s\n", (long) ord, name);
1472
1473 }
1474
1475 free (data);
1476
1477 return true;
1478}
1479
1480static boolean
1481pe_print_pdata (abfd, vfile)
1482 bfd *abfd;
1483 PTR vfile;
1484{
1485 FILE *file = (FILE *) vfile;
1486 bfd_byte *data = 0;
1487 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1488 bfd_size_type datasize = 0;
1489 bfd_size_type i;
1490 bfd_size_type start, stop;
1491 int onaline = 20;
1492
5933bdc9
ILT		 1493 if (section == NULL
1494 || coff_section_data (abfd, section) == NULL
1495 || pei_section_data (abfd, section) == NULL)
1496 return true;
277d1b5e 1497
5933bdc9 1498 stop = pei_section_data (abfd, section)->virt_size;
277d1b5e
ILT		 1499 if ((stop % onaline) != 0)
1500 fprintf (file, _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1501 (long)stop, onaline);
1502
5933bdc9
ILT		 1503 fprintf (file,
1504 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1505 fprintf (file,
1506 _(" vma:\t\tBegin End EH EH PrologEnd Exception\n"));
1507 fprintf (file,
1508 _(" \t\tAddress Address Handler Data Address Mask\n"));
277d1b5e
ILT		 1509
1510 if (bfd_section_size (abfd, section) == 0)
1511 return true;
1512
1513 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1514 datasize = bfd_section_size (abfd, section);
1515 if (data == NULL && datasize != 0)
1516 return false;
1517
1518 bfd_get_section_contents (abfd,
1519 section,
1520 (PTR) data, 0,
1521 bfd_section_size (abfd, section));
1522
1523 start = 0;
1524
1525 for (i = start; i < stop; i += onaline)
1526 {
1527 bfd_vma begin_addr;
1528 bfd_vma end_addr;
1529 bfd_vma eh_handler;
1530 bfd_vma eh_data;
1531 bfd_vma prolog_end_addr;
5933bdc9 1532 int em_data;
277d1b5e 1533
5933bdc9 1534 if (i + 20 > stop)
277d1b5e 1535 break;
5933bdc9 1536
277d1b5e
ILT		 1537 begin_addr = bfd_get_32(abfd, data+i);
1538 end_addr = bfd_get_32(abfd, data+i+4);
1539 eh_handler = bfd_get_32(abfd, data+i+8);
1540 eh_data = bfd_get_32(abfd, data+i+12);
1541 prolog_end_addr = bfd_get_32(abfd, data+i+16);
1542
1543 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1544 && eh_data == 0 && prolog_end_addr == 0)
1545 {
1546 /* We are probably into the padding of the section now. */
1547 break;
1548 }
1549
1550 fprintf (file,
1551 " %08lx\t",
1552 (unsigned long int) (i + section->vma));
1553
5933bdc9
ILT		 1554 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1555 eh_handler &= 0xfffffffc;
1556 prolog_end_addr &= 0xfffffffc;
1557
1558 fprintf (file, "%08lx %08lx %08lx %08lx %08lx %x",
1559 begin_addr,
1560 end_addr,
1561 eh_handler,
1562 eh_data,
1563 prolog_end_addr,
1564 em_data);
277d1b5e
ILT		 1565
1566#ifdef POWERPC_LE_PE
1567 if (eh_handler == 0 && eh_data != 0)
1568 {
1569 /* Special bits here, although the meaning may */
1570 /* be a little mysterious. The only one I know */
1571 /* for sure is 0x03. */
1572 /* Code Significance */
1573 /* 0x00 None */
1574 /* 0x01 Register Save Millicode */
1575 /* 0x02 Register Restore Millicode */
1576 /* 0x03 Glue Code Sequence */
1577 switch (eh_data)
1578 {
1579 case 0x01:
1580 fprintf(file, _(" Register save millicode"));
1581 break;
1582 case 0x02:
1583 fprintf(file, _(" Register restore millicode"));
1584 break;
1585 case 0x03:
1586 fprintf(file, _(" Glue code sequence"));
1587 break;
1588 default:
1589 break;
1590 }
1591 }
1592#endif
1593 fprintf(file, "\n");
1594 }
1595
1596 free (data);
1597
1598 return true;
1599}
1600
5933bdc9
ILT		 1601#define IMAGE_REL_BASED_HIGHADJ 4
1602static const char * const tbl[] =
277d1b5e
ILT		 1603{
1604"ABSOLUTE",
1605"HIGH",
1606"LOW",
1607"HIGHLOW",
1608"HIGHADJ",
5933bdc9
ILT		 1609"MIPS_JMPADDR",
1610"UNKNOWN", /* MUST be last */
277d1b5e
ILT		 1611};
1612
1613static boolean
1614pe_print_reloc (abfd, vfile)
1615 bfd *abfd;
1616 PTR vfile;
1617{
1618 FILE *file = (FILE *) vfile;
1619 bfd_byte *data = 0;
1620 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1621 bfd_size_type datasize = 0;
1622 bfd_size_type i;
1623 bfd_size_type start, stop;
1624
5933bdc9 1625 if (section == NULL)
277d1b5e
ILT		 1626 return true;
1627
1628 if (bfd_section_size (abfd, section) == 0)
1629 return true;
1630
5933bdc9
ILT		 1631 fprintf (file,
1632 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
277d1b5e
ILT		 1633
1634 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1635 datasize = bfd_section_size (abfd, section);
1636 if (data == NULL && datasize != 0)
1637 return false;
1638
1639 bfd_get_section_contents (abfd,
1640 section,
1641 (PTR) data, 0,
1642 bfd_section_size (abfd, section));
1643
1644 start = 0;
1645
1646 stop = bfd_section_size (abfd, section);
1647
1648 for (i = start; i < stop;)
1649 {
1650 int j;
1651 bfd_vma virtual_address;
1652 long number, size;
1653
1654 /* The .reloc section is a sequence of blocks, with a header consisting
1655 of two 32 bit quantities, followed by a number of 16 bit entries */
1656
1657 virtual_address = bfd_get_32(abfd, data+i);
1658 size = bfd_get_32(abfd, data+i+4);
1659 number = (size - 8) / 2;
1660
1661 if (size == 0)
1662 {
1663 break;
1664 }
1665
1666 fprintf (file,
1667 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1668 virtual_address, size, size, number);
1669
1670 for (j = 0; j < number; ++j)
1671 {
5933bdc9
ILT		 1672 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1673 unsigned int t = (e & 0xF000) >> 12;
277d1b5e
ILT		 1674 int off = e & 0x0FFF;
1675
5933bdc9
ILT		 1676 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1677 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
277d1b5e 1678
5933bdc9
ILT		 1679 fprintf (file,
1680 _("\treloc %4d offset %4x [%4lx] %s"),
1681 j, off, (long) (off + virtual_address), tbl[t]);
277d1b5e 1682
5933bdc9
ILT		 1683 /* HIGHADJ takes an argument, but there's no documentation
1684 on what it does, or what it means. Inferred from
1685 DUMPBIN. */
1686 if (t == IMAGE_REL_BASED_HIGHADJ)
1687 {
1688 fprintf (file, " (%4x)\n",
1689 ((unsigned int)
1690 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1691 j++;
1692 }
1693 else
1694 fprintf (file, "\n");
277d1b5e
ILT		 1695 }
1696 i += size;
1697 }
1698
1699 free (data);
1700
1701 return true;
1702}
1703
1704/* Print out the program headers. */
1705
1706boolean
1707_bfd_pe_print_private_bfd_data_common (abfd, vfile)
1708 bfd *abfd;
1709 PTR vfile;
1710{
1711 FILE *file = (FILE *) vfile;
1712 int j;
1713 pe_data_type *pe = pe_data (abfd);
1714 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1715
1716 /* The MS dumpbin program reportedly ands with 0xff0f before
1717 printing the characteristics field. Not sure why. No reason to
1718 emulate it here. */
1719 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1720#undef PF
1721#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1722 PF (F_RELFLG, "relocations stripped");
1723 PF (F_EXEC, "executable");
1724 PF (F_LNNO, "line numbers stripped");
1725 PF (F_LSYMS, "symbols stripped");
1726 PF (0x80, "little endian");
1727 PF (F_AR32WR, "32 bit words");
1728 PF (0x200, "debugging information removed");
1729 PF (0x1000, "system file");
1730 PF (F_DLL, "DLL");
1731 PF (0x8000, "big endian");
1732#undef PF
1733
5933bdc9
ILT		 1734 /* ctime implies '\n'. */
1735 fprintf (file, "\nTime/Date\t\t%s", ctime (&pe->coff.timestamp));
277d1b5e
ILT		 1736 fprintf (file,"\nImageBase\t\t");
1737 fprintf_vma (file, i->ImageBase);
1738 fprintf (file,"\nSectionAlignment\t");
1739 fprintf_vma (file, i->SectionAlignment);
1740 fprintf (file,"\nFileAlignment\t\t");
1741 fprintf_vma (file, i->FileAlignment);
1742 fprintf (file,"\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1743 fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1744 fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1745 fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1746 fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1747 fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1748 fprintf (file,"Reserved1\t\t%08lx\n", i->Reserved1);
1749 fprintf (file,"SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1750 fprintf (file,"SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1751 fprintf (file,"CheckSum\t\t%08lx\n", i->CheckSum);
1752 fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem);
1753 fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics);
1754 fprintf (file,"SizeOfStackReserve\t");
1755 fprintf_vma (file, i->SizeOfStackReserve);
1756 fprintf (file,"\nSizeOfStackCommit\t");
1757 fprintf_vma (file, i->SizeOfStackCommit);
1758 fprintf (file,"\nSizeOfHeapReserve\t");
1759 fprintf_vma (file, i->SizeOfHeapReserve);
1760 fprintf (file,"\nSizeOfHeapCommit\t");
1761 fprintf_vma (file, i->SizeOfHeapCommit);
1762 fprintf (file,"\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1763 fprintf (file,"NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1764
1765 fprintf (file,"\nThe Data Directory\n");
1766 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1767 {
1768 fprintf (file, "Entry %1x ", j);
1769 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1770 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1771 fprintf (file, "%s\n", dir_names[j]);
1772 }
1773
1774 pe_print_idata (abfd, vfile);
1775 pe_print_edata (abfd, vfile);
1776 pe_print_pdata (abfd, vfile);
1777 pe_print_reloc (abfd, vfile);
1778
1779 return true;
1780}
1781
1782/* Copy any private info we understand from the input bfd
1783 to the output bfd. */
1784
1785boolean
1786_bfd_pe_bfd_copy_private_bfd_data_common (ibfd, obfd)
1787 bfd *ibfd, *obfd;
1788{
1789 /* One day we may try to grok other private data. */
1790 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1791 || obfd->xvec->flavour != bfd_target_coff_flavour)
1792 return true;
1793
1794 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1795 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1796
5933bdc9
ILT		 1797 /* for strip: if we removed .reloc, we'll make a real mess of things
1798 if we don't remove this entry as well. */
1799 if (! pe_data (obfd)->has_reloc_section)
1800 {
1801 pe_data(obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1802 pe_data(obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1803 }
277d1b5e
ILT		 1804 return true;
1805}
1806
1807/* Copy private section data. */
1808boolean
1809_bfd_pe_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1810 bfd *ibfd;
1811 asection *isec;
1812 bfd *obfd;
1813 asection *osec;
1814{
1815 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1816 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1817 return true;
1818
1819 if (coff_section_data (ibfd, isec) != NULL
1820 && pei_section_data (ibfd, isec) != NULL)
1821 {
1822 if (coff_section_data (obfd, osec) == NULL)
1823 {
1824 osec->used_by_bfd =
1825 (PTR) bfd_zalloc (obfd, sizeof (struct coff_section_tdata));
1826 if (osec->used_by_bfd == NULL)
1827 return false;
1828 }
1829 if (pei_section_data (obfd, osec) == NULL)
1830 {
1831 coff_section_data (obfd, osec)->tdata =
1832 (PTR) bfd_zalloc (obfd, sizeof (struct pei_section_tdata));
1833 if (coff_section_data (obfd, osec)->tdata == NULL)
1834 return false;
1835 }
1836 pei_section_data (obfd, osec)->virt_size =
1837 pei_section_data (ibfd, isec)->virt_size;
5933bdc9
ILT		 1838 pei_section_data (obfd, osec)->pe_flags =
1839 pei_section_data (ibfd, isec)->pe_flags;
277d1b5e
ILT		 1840 }
1841
1842 return true;
1843}
7d2b58d6
ILT		 1844
1845void
1846_bfd_pe_get_symbol_info (abfd, symbol, ret)
1847 bfd *abfd;
1848 asymbol *symbol;
1849 symbol_info *ret;
1850{
1851 coff_get_symbol_info (abfd, symbol, ret);
1852
1853 if (pe_data (abfd) != NULL
1854 && ((symbol->flags & BSF_DEBUGGING) == 0
1855 || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
1856 && ! bfd_is_abs_section (symbol->section))
1857 ret->value += pe_data (abfd)->pe_opthdr.ImageBase;
1858}
GDB Binutils - Deliverables
This page took 0.145301 seconds and 4 git commands to generate.