projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2000-10-06 Dave Brolley <brolley@redhat.com>
[deliverable/binutils-gdb.git] / bfd / peigen.c
CommitLineData
277d1b5e 1/* Support for the generic parts of PE/PEI; the common executable parts.
a76b448c 2 Copyright 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
277d1b5e
ILT		 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);
fac41780
JW		 437#ifndef COFF_WITH_PEP64
438 /* PE32+ does not have data_start member! */
277d1b5e
ILT		 439 aouthdr_int->data_start =
440 GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
fac41780 441#endif
277d1b5e
ILT		 442
443 a = &aouthdr_int->pe;
fac41780 444 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, (bfd_byte *)src->ImageBase);
277d1b5e
ILT		 445 a->SectionAlignment = bfd_h_get_32 (abfd, (bfd_byte *)src->SectionAlignment);
446 a->FileAlignment = bfd_h_get_32 (abfd, (bfd_byte *)src->FileAlignment);
447 a->MajorOperatingSystemVersion =
448 bfd_h_get_16 (abfd, (bfd_byte *)src->MajorOperatingSystemVersion);
449 a->MinorOperatingSystemVersion =
450 bfd_h_get_16 (abfd, (bfd_byte *)src->MinorOperatingSystemVersion);
451 a->MajorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MajorImageVersion);
452 a->MinorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MinorImageVersion);
453 a->MajorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MajorSubsystemVersion);
454 a->MinorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MinorSubsystemVersion);
455 a->Reserved1 = bfd_h_get_32 (abfd, (bfd_byte *)src->Reserved1);
456 a->SizeOfImage = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfImage);
457 a->SizeOfHeaders = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeaders);
458 a->CheckSum = bfd_h_get_32 (abfd, (bfd_byte *)src->CheckSum);
459 a->Subsystem = bfd_h_get_16 (abfd, (bfd_byte *)src->Subsystem);
460 a->DllCharacteristics = bfd_h_get_16 (abfd, (bfd_byte *)src->DllCharacteristics);
fac41780
JW		 461 a->SizeOfStackReserve = GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, (bfd_byte *)src->SizeOfStackReserve);
462 a->SizeOfStackCommit = GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, (bfd_byte *)src->SizeOfStackCommit);
463 a->SizeOfHeapReserve = GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, (bfd_byte *)src->SizeOfHeapReserve);
464 a->SizeOfHeapCommit = GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, (bfd_byte *)src->SizeOfHeapCommit);
277d1b5e
ILT		 465 a->LoaderFlags = bfd_h_get_32 (abfd, (bfd_byte *)src->LoaderFlags);
466 a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, (bfd_byte *)src->NumberOfRvaAndSizes);
467
468 {
469 int idx;
470 for (idx=0; idx < 16; idx++)
471 {
3028b4c0
DD		 472 /* If data directory is empty, rva also should be 0 */
473 int size = bfd_h_get_32 (abfd, (bfd_byte *) src->DataDirectory[idx][1]);
474 a->DataDirectory[idx].Size = size;
475
476 if (size)
477 {
478 a->DataDirectory[idx].VirtualAddress =
479 bfd_h_get_32 (abfd, (bfd_byte *) src->DataDirectory[idx][0]);
480 }
481 else
482 a->DataDirectory[idx].VirtualAddress = 0;
277d1b5e
ILT		 483 }
484 }
485
486 if (aouthdr_int->entry)
487 {
488 aouthdr_int->entry += a->ImageBase;
fac41780 489#ifndef COFF_WITH_PEP64
277d1b5e 490 aouthdr_int->entry &= 0xffffffff;
fac41780 491#endif
277d1b5e
ILT		 492 }
493 if (aouthdr_int->tsize)
494 {
495 aouthdr_int->text_start += a->ImageBase;
fac41780 496#ifndef COFF_WITH_PEP64
277d1b5e 497 aouthdr_int->text_start &= 0xffffffff;
fac41780 498#endif
277d1b5e 499 }
fac41780
JW		 500#ifndef COFF_WITH_PEP64
501 /* PE32+ does not have data_start member! */
277d1b5e
ILT		 502 if (aouthdr_int->dsize)
503 {
504 aouthdr_int->data_start += a->ImageBase;
505 aouthdr_int->data_start &= 0xffffffff;
506 }
fac41780 507#endif
277d1b5e
ILT		 508
509#ifdef POWERPC_LE_PE
510 /* These three fields are normally set up by ppc_relocate_section.
511 In the case of reading a file in, we can pick them up from the
512 DataDirectory. */
513 first_thunk_address = a->DataDirectory[12].VirtualAddress ;
514 thunk_size = a->DataDirectory[12].Size;
515 import_table_size = a->DataDirectory[1].Size;
516#endif
517
518}
519
5933bdc9
ILT		 520/* A support function for below. */
521
522static void
523add_data_entry (abfd, aout, idx, name, base)
277d1b5e
ILT		 524 bfd *abfd;
525 struct internal_extra_pe_aouthdr *aout;
526 int idx;
527 char *name;
528 bfd_vma base;
529{
530 asection *sec = bfd_get_section_by_name (abfd, name);
531
532 /* add import directory information if it exists */
533 if ((sec != NULL)
534 && (coff_section_data (abfd, sec) != NULL)
535 && (pei_section_data (abfd, sec) != NULL))
536 {
3028b4c0
DD		 537 /* If data directory is empty, rva also should be 0 */
538 int size = pei_section_data (abfd, sec)->virt_size;
539 aout->DataDirectory[idx].Size = size;
540
541 if (size)
542 {
543 aout->DataDirectory[idx].VirtualAddress =
544 (sec->vma - base) & 0xffffffff;
545 sec->flags |= SEC_DATA;
546 }
277d1b5e
ILT		 547 }
548}
549
550unsigned int
551_bfd_pei_swap_aouthdr_out (abfd, in, out)
552 bfd *abfd;
553 PTR in;
554 PTR out;
555{
556 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
557 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
558 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
fac41780
JW		 559 bfd_vma sa, fa, ib;
560
561 /* The following definitely is required for EFI applications.
562 Perhaps it's needed for other PEI targets as well, but I don't
563 know that for a fact, so we play it safe here and tweak the
564 alignments only if PEI_FORCE_MINIMUM_ALIGNMENT is
565 defined. --davidm */
566#ifdef PEI_FORCE_MINIMUM_ALIGNMENT
567 if (!extra->FileAlignment)
568 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
569 if (!extra->SectionAlignment)
570 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
571#endif
277d1b5e 572
fac41780
JW		 573#ifdef PEI_DEFAULT_TARGET_SUBSYSTEM
574 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
575 extra->Subsystem = PEI_DEFAULT_TARGET_SUBSYSTEM;
576#endif
577
578 sa = extra->SectionAlignment;
579 fa = extra->FileAlignment;
580 ib = extra->ImageBase;
277d1b5e
ILT		 581
582 if (aouthdr_in->tsize)
583 {
584 aouthdr_in->text_start -= ib;
585 aouthdr_in->text_start &= 0xffffffff;
586 }
587 if (aouthdr_in->dsize)
588 {
589 aouthdr_in->data_start -= ib;
590 aouthdr_in->data_start &= 0xffffffff;
591 }
592 if (aouthdr_in->entry)
593 {
594 aouthdr_in->entry -= ib;
595 aouthdr_in->entry &= 0xffffffff;
596 }
597
598#define FA(x) (((x) + fa -1 ) & (- fa))
599#define SA(x) (((x) + sa -1 ) & (- sa))
600
601 /* We like to have the sizes aligned */
602
603 aouthdr_in->bsize = FA (aouthdr_in->bsize);
604
605
606 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
607
608 /* first null out all data directory entries .. */
609 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
610
8181c403 611 add_data_entry (abfd, extra, 0, ".edata", ib);
277d1b5e 612
2fbadf2c
ILT		 613 /* Don't call add_data_entry for .idata$2 or .idata$5. It's done in
614 bfd_coff_final_link where all the required information is
615 available. */
277d1b5e 616
2fbadf2c
ILT		 617 /* However, until other .idata fixes are made (pending patch), the
618 entry for .idata is needed for backwards compatability. FIXME. */
8181c403 619 add_data_entry (abfd, extra, 1, ".idata" , ib);
277d1b5e 620
8181c403 621 add_data_entry (abfd, extra, 2, ".rsrc" , ib);
2fbadf2c 622
8181c403 623 add_data_entry (abfd, extra, 3, ".pdata", ib);
2fbadf2c
ILT		 624
625 /* For some reason, the virtual size (which is what's set by
626 add_data_entry) for .reloc is not the same as the size recorded
627 in this slot by MSVC; it doesn't seem to cause problems (so far),
628 but since it's the best we've got, use it. It does do the right
629 thing for .pdata. */
630 if (pe_data (abfd)->has_reloc_section)
8181c403 631 add_data_entry (abfd, extra, 5, ".reloc", ib);
277d1b5e
ILT		 632
633 {
634 asection *sec;
635 bfd_vma dsize= 0;
636 bfd_vma isize = SA(abfd->sections->filepos);
637 bfd_vma tsize= 0;
638
639 for (sec = abfd->sections; sec; sec = sec->next)
640 {
641 int rounded = FA(sec->_raw_size);
642
643 if (sec->flags & SEC_DATA)
644 dsize += rounded;
645 if (sec->flags & SEC_CODE)
646 tsize += rounded;
5933bdc9
ILT		 647 /* The image size is the total VIRTUAL size (which is what is
648 in the virt_size field). Files have been seen (from MSVC
649 5.0 link.exe) where the file size of the .data segment is
650 quite small compared to the virtual size. Without this
651 fix, strip munges the file. */
652 isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
277d1b5e
ILT		 653 }
654
655 aouthdr_in->dsize = dsize;
656 aouthdr_in->tsize = tsize;
657 extra->SizeOfImage = isize;
658 }
659
660 extra->SizeOfHeaders = abfd->sections->filepos;
661 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
662
5933bdc9
ILT		 663#define LINKER_VERSION 256 /* That is, 2.56 */
664
665 /* This piece of magic sets the "linker version" field to
666 LINKER_VERSION. */
667 bfd_h_put_16 (abfd,
668 LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256,
669 (bfd_byte *) aouthdr_out->standard.vstamp);
277d1b5e
ILT		 670
671 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
672 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
673 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
674 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
675 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
676 (bfd_byte *) aouthdr_out->standard.text_start);
677
fac41780
JW		 678#ifndef COFF_WITH_PEP64
679 /* PE32+ does not have data_start member! */
277d1b5e
ILT		 680 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
681 (bfd_byte *) aouthdr_out->standard.data_start);
fac41780 682#endif
277d1b5e 683
fac41780
JW		 684 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase,
685 (bfd_byte *) aouthdr_out->ImageBase);
277d1b5e
ILT		 686 bfd_h_put_32 (abfd, extra->SectionAlignment,
687 (bfd_byte *) aouthdr_out->SectionAlignment);
688 bfd_h_put_32 (abfd, extra->FileAlignment,
689 (bfd_byte *) aouthdr_out->FileAlignment);
690 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
691 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
692 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
693 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
694 bfd_h_put_16 (abfd, extra->MajorImageVersion,
695 (bfd_byte *) aouthdr_out->MajorImageVersion);
696 bfd_h_put_16 (abfd, extra->MinorImageVersion,
697 (bfd_byte *) aouthdr_out->MinorImageVersion);
698 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
699 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
700 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
701 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
702 bfd_h_put_32 (abfd, extra->Reserved1,
703 (bfd_byte *) aouthdr_out->Reserved1);
704 bfd_h_put_32 (abfd, extra->SizeOfImage,
705 (bfd_byte *) aouthdr_out->SizeOfImage);
706 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
707 (bfd_byte *) aouthdr_out->SizeOfHeaders);
708 bfd_h_put_32 (abfd, extra->CheckSum,
709 (bfd_byte *) aouthdr_out->CheckSum);
710 bfd_h_put_16 (abfd, extra->Subsystem,
711 (bfd_byte *) aouthdr_out->Subsystem);
712 bfd_h_put_16 (abfd, extra->DllCharacteristics,
713 (bfd_byte *) aouthdr_out->DllCharacteristics);
fac41780
JW		 714 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
715 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
716 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
717 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
718 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
719 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
720 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
721 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
277d1b5e
ILT		 722 bfd_h_put_32 (abfd, extra->LoaderFlags,
723 (bfd_byte *) aouthdr_out->LoaderFlags);
724 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
725 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
726 {
727 int idx;
728 for (idx=0; idx < 16; idx++)
729 {
730 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
731 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
732 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
733 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
734 }
735 }
736
737 return AOUTSZ;
738}
739
740unsigned int
741_bfd_pei_only_swap_filehdr_out (abfd, in, out)
742 bfd *abfd;
743 PTR in;
744 PTR out;
745{
746 int idx;
747 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
748 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *)out;
749
750 if (pe_data (abfd)->has_reloc_section)
751 filehdr_in->f_flags &= ~F_RELFLG;
752
753 if (pe_data (abfd)->dll)
754 filehdr_in->f_flags |= F_DLL;
755
756 filehdr_in->pe.e_magic = DOSMAGIC;
757 filehdr_in->pe.e_cblp = 0x90;
758 filehdr_in->pe.e_cp = 0x3;
759 filehdr_in->pe.e_crlc = 0x0;
760 filehdr_in->pe.e_cparhdr = 0x4;
761 filehdr_in->pe.e_minalloc = 0x0;
762 filehdr_in->pe.e_maxalloc = 0xffff;
763 filehdr_in->pe.e_ss = 0x0;
764 filehdr_in->pe.e_sp = 0xb8;
765 filehdr_in->pe.e_csum = 0x0;
766 filehdr_in->pe.e_ip = 0x0;
767 filehdr_in->pe.e_cs = 0x0;
768 filehdr_in->pe.e_lfarlc = 0x40;
769 filehdr_in->pe.e_ovno = 0x0;
770
771 for (idx=0; idx < 4; idx++)
772 filehdr_in->pe.e_res[idx] = 0x0;
773
774 filehdr_in->pe.e_oemid = 0x0;
775 filehdr_in->pe.e_oeminfo = 0x0;
776
777 for (idx=0; idx < 10; idx++)
778 filehdr_in->pe.e_res2[idx] = 0x0;
779
780 filehdr_in->pe.e_lfanew = 0x80;
781
782 /* this next collection of data are mostly just characters. It appears
783 to be constant within the headers put on NT exes */
784 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
785 filehdr_in->pe.dos_message[1] = 0xcd09b400;
786 filehdr_in->pe.dos_message[2] = 0x4c01b821;
787 filehdr_in->pe.dos_message[3] = 0x685421cd;
788 filehdr_in->pe.dos_message[4] = 0x70207369;
789 filehdr_in->pe.dos_message[5] = 0x72676f72;
790 filehdr_in->pe.dos_message[6] = 0x63206d61;
791 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
792 filehdr_in->pe.dos_message[8] = 0x65622074;
793 filehdr_in->pe.dos_message[9] = 0x6e757220;
794 filehdr_in->pe.dos_message[10] = 0x206e6920;
795 filehdr_in->pe.dos_message[11] = 0x20534f44;
796 filehdr_in->pe.dos_message[12] = 0x65646f6d;
797 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
798 filehdr_in->pe.dos_message[14] = 0x24;
799 filehdr_in->pe.dos_message[15] = 0x0;
800 filehdr_in->pe.nt_signature = NT_SIGNATURE;
801
802
803
804 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
805 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
806
807 bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
808 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
809 (bfd_byte *) filehdr_out->f_symptr);
810 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
811 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
812 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
813
814 /* put in extra dos header stuff. This data remains essentially
815 constant, it just has to be tacked on to the beginning of all exes
816 for NT */
817 bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
818 bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
819 bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
820 bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
821 bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr,
822 (bfd_byte *) filehdr_out->e_cparhdr);
823 bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc,
824 (bfd_byte *) filehdr_out->e_minalloc);
825 bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc,
826 (bfd_byte *) filehdr_out->e_maxalloc);
827 bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
828 bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
829 bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
830 bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
831 bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
832 bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
833 bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
834 {
835 int idx;
836 for (idx=0; idx < 4; idx++)
837 bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx],
838 (bfd_byte *) filehdr_out->e_res[idx]);
839 }
840 bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
841 bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo,
842 (bfd_byte *) filehdr_out->e_oeminfo);
843 {
844 int idx;
845 for (idx=0; idx < 10; idx++)
846 bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx],
847 (bfd_byte *) filehdr_out->e_res2[idx]);
848 }
849 bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
850
851 {
852 int idx;
853 for (idx=0; idx < 16; idx++)
854 bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx],
855 (bfd_byte *) filehdr_out->dos_message[idx]);
856 }
857
858 /* also put in the NT signature */
859 bfd_h_put_32(abfd, filehdr_in->pe.nt_signature,
860 (bfd_byte *) filehdr_out->nt_signature);
861
862
863
864
865 return FILHSZ;
866}
867
868unsigned int
869_bfd_pe_only_swap_filehdr_out (abfd, in, out)
870 bfd *abfd;
871 PTR in;
872 PTR out;
873{
874 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
875 FILHDR *filehdr_out = (FILHDR *)out;
876
877 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
878 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
879 bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
880 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
881 (bfd_byte *) filehdr_out->f_symptr);
882 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
883 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
884 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
885
886 return FILHSZ;
887}
888
889unsigned int
890_bfd_pei_swap_scnhdr_out (abfd, in, out)
891 bfd *abfd;
892 PTR in;
893 PTR out;
894{
895 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
896 SCNHDR *scnhdr_ext = (SCNHDR *)out;
897 unsigned int ret = SCNHSZ;
898 bfd_vma ps;
899 bfd_vma ss;
900
901 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
902
903 PUT_SCNHDR_VADDR (abfd,
904 ((scnhdr_int->s_vaddr
905 - pe_data(abfd)->pe_opthdr.ImageBase)
906 & 0xffffffff),
907 (bfd_byte *) scnhdr_ext->s_vaddr);
908
5933bdc9
ILT		 909 /* NT wants the size data to be rounded up to the next
910 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
911 sometimes). */
277d1b5e 912
5933bdc9 913 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
277d1b5e
ILT		 914 {
915 ps = scnhdr_int->s_size;
916 ss = 0;
917 }
918 else
919 {
920 ps = scnhdr_int->s_paddr;
921 ss = scnhdr_int->s_size;
922 }
923
924 PUT_SCNHDR_SIZE (abfd, ss,
925 (bfd_byte *) scnhdr_ext->s_size);
926
927
5933bdc9 928 /* s_paddr in PE is really the virtual size. */
277d1b5e
ILT		 929 PUT_SCNHDR_PADDR (abfd, ps, (bfd_byte *) scnhdr_ext->s_paddr);
930
931 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
932 (bfd_byte *) scnhdr_ext->s_scnptr);
933 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
934 (bfd_byte *) scnhdr_ext->s_relptr);
935 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
936 (bfd_byte *) scnhdr_ext->s_lnnoptr);
937
938 /* Extra flags must be set when dealing with NT. All sections should also
939 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
940 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
941 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
942 (this is especially important when dealing with the .idata section since
943 the addresses for routines from .dlls must be overwritten). If .reloc
944 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
945 (0x02000000). Also, the resource data should also be read and
946 writable. */
947
948 /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */
949 /* FIXME: even worse, I don't see how to get the original alignment field*/
950 /* back... */
951
277d1b5e
ILT		 952 {
953 int flags = scnhdr_int->s_flags;
277d1b5e
ILT		 954 bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
955 }
956
cb43721d
ILT		 957 if (coff_data (abfd)->link_info
958 && ! coff_data (abfd)->link_info->relocateable
959 && ! coff_data (abfd)->link_info->shared
960 && strcmp (scnhdr_int->s_name, ".text") == 0)
277d1b5e 961 {
cb43721d
ILT		 962 /* By inference from looking at MS output, the 32 bit field
963 which is the combintion of the number_of_relocs and
964 number_of_linenos is used for the line number count in
965 executables. A 16-bit field won't do for cc1. The MS
966 document says that the number of relocs is zero for
967 executables, but the 17-th bit has been observed to be there.
968 Overflow is not an issue: a 4G-line program will overflow a
969 bunch of other fields long before this! */
970 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno & 0xffff,
971 (bfd_byte *) scnhdr_ext->s_nlnno);
972 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno >> 16,
973 (bfd_byte *) scnhdr_ext->s_nreloc);
277d1b5e 974 }
277d1b5e
ILT		 975 else
976 {
cb43721d
ILT		 977 if (scnhdr_int->s_nlnno <= 0xffff)
978 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno,
979 (bfd_byte *) scnhdr_ext->s_nlnno);
980 else
981 {
982 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
983 bfd_get_filename (abfd),
984 scnhdr_int->s_nlnno);
985 bfd_set_error (bfd_error_file_truncated);
986 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
987 ret = 0;
988 }
989 if (scnhdr_int->s_nreloc <= 0xffff)
990 bfd_h_put_16 (abfd, scnhdr_int->s_nreloc,
991 (bfd_byte *) scnhdr_ext->s_nreloc);
992 else
993 {
994 (*_bfd_error_handler) (_("%s: reloc overflow: 0x%lx > 0xffff"),
995 bfd_get_filename (abfd),
996 scnhdr_int->s_nreloc);
997 bfd_set_error (bfd_error_file_truncated);
998 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
999 ret = 0;
1000 }
277d1b5e
ILT		 1001 }
1002 return ret;
1003}
1004
1005static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1006{
1007 N_ ("Export Directory [.edata (or where ever we found it)]"),
1008 N_ ("Import Directory [parts of .idata]"),
1009 N_ ("Resource Directory [.rsrc]"),
1010 N_ ("Exception Directory [.pdata]"),
1011 N_ ("Security Directory"),
1012 N_ ("Base Relocation Directory [.reloc]"),
1013 N_ ("Debug Directory"),
1014 N_ ("Description Directory"),
1015 N_ ("Special Directory"),
1016 N_ ("Thread Storage Directory [.tls]"),
1017 N_ ("Load Configuration Directory"),
1018 N_ ("Bound Import Directory"),
1019 N_ ("Import Address Table Directory"),
8181c403 1020 N_ ("Delay Import Directory"),
277d1b5e
ILT		 1021 N_ ("Reserved"),
1022 N_ ("Reserved")
1023};
1024
1025/**********************************************************************/
1026#ifdef POWERPC_LE_PE
1027/* The code for the PPC really falls in the "architecture dependent"
1028 category. However, it's not clear that anyone will ever care, so
1029 we're ignoring the issue for now; if/when PPC matters, some of this
1030 may need to go into peicode.h, or arguments passed to enable the
1031 PPC- specific code. */
1032#endif
1033
1034/**********************************************************************/
1035static boolean
5933bdc9 1036pe_print_idata (abfd, vfile)
277d1b5e
ILT		 1037 bfd *abfd;
1038 PTR vfile;
1039{
1040 FILE *file = (FILE *) vfile;
a76b448c 1041 bfd_byte *data;
8181c403
AM		 1042 asection *section;
1043 bfd_signed_vma adj;
277d1b5e
ILT		 1044
1045#ifdef POWERPC_LE_PE
1046 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1047#endif
1048
a76b448c 1049 bfd_size_type datasize = 0;
277d1b5e 1050 bfd_size_type dataoff;
277d1b5e 1051 bfd_size_type i;
277d1b5e
ILT		 1052 int onaline = 20;
1053
1054 pe_data_type *pe = pe_data (abfd);
1055 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1056
8181c403 1057 bfd_vma addr;
277d1b5e 1058
8181c403 1059 addr = extra->DataDirectory[1].VirtualAddress;
277d1b5e 1060
a76b448c 1061 if (addr == 0 && extra->DataDirectory[1].Size == 0)
8181c403 1062 {
a76b448c
AM		 1063 /* Maybe the extra header isn't there. Look for the section. */
1064 section = bfd_get_section_by_name (abfd, ".idata");
1065 if (section == NULL)
1066 return true;
1067
1068 addr = section->vma;
1069 datasize = bfd_section_size (abfd, section);
1070 if (datasize == 0)
1071 return true;
8181c403 1072 }
a76b448c 1073 else
8181c403 1074 {
a76b448c
AM		 1075 addr += extra->ImageBase;
1076 for (section = abfd->sections; section != NULL; section = section->next)
1077 {
1078 datasize = bfd_section_size (abfd, section);
1079 if (addr >= section->vma && addr < section->vma + datasize)
1080 break;
1081 }
1082
1083 if (section == NULL)
1084 {
1085 fprintf (file,
1086 _("\nThere is an import table, but the section containing it could not be found\n"));
1087 return true;
1088 }
8181c403 1089 }
5933bdc9 1090
8181c403
AM		 1091 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1092 section->name, (unsigned long) addr);
277d1b5e 1093
8181c403 1094 dataoff = addr - section->vma;
a76b448c 1095 datasize -= dataoff;
277d1b5e
ILT		 1096
1097#ifdef POWERPC_LE_PE
1098 if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1099 {
1100 /* The toc address can be found by taking the starting address,
1101 which on the PPC locates a function descriptor. The
1102 descriptor consists of the function code starting address
1103 followed by the address of the toc. The starting address we
1104 get from the bfd, and the descriptor is supposed to be in the
1105 .reldata section. */
1106
1107 bfd_vma loadable_toc_address;
1108 bfd_vma toc_address;
1109 bfd_vma start_address;
1110 bfd_byte *data = 0;
1111 int offset;
8181c403 1112
277d1b5e
ILT		 1113 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd,
1114 rel_section));
1115 if (data == NULL && bfd_section_size (abfd, rel_section) != 0)
1116 return false;
1117
277d1b5e
ILT		 1118 bfd_get_section_contents (abfd,
1119 rel_section,
1120 (PTR) data, 0,
1121 bfd_section_size (abfd, rel_section));
1122
1123 offset = abfd->start_address - rel_section->vma;
1124
db8503c4
AM		 1125 start_address = bfd_get_32 (abfd, data + offset);
1126 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
277d1b5e
ILT		 1127 toc_address = loadable_toc_address - 32768;
1128
1129 fprintf(file,
1130 _("\nFunction descriptor located at the start address: %04lx\n"),
1131 (unsigned long int) (abfd->start_address));
1132 fprintf (file,
1133 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1134 start_address, loadable_toc_address, toc_address);
1135 }
1136 else
1137 {
1138 fprintf(file,
1139 _("\nNo reldata section! Function descriptor not decoded.\n"));
1140 }
1141#endif
1142
1143 fprintf(file,
8181c403
AM		 1144 _("\nThe Import Tables (interpreted %s section contents)\n"),
1145 section->name);
277d1b5e
ILT		 1146 fprintf(file,
1147 _(" vma: Hint Time Forward DLL First\n"));
1148 fprintf(file,
1149 _(" Table Stamp Chain Name Thunk\n"));
1150
db8503c4 1151 data = (bfd_byte *) bfd_malloc (dataoff + datasize);
a76b448c 1152 if (data == NULL)
277d1b5e
ILT		 1153 return false;
1154
db8503c4
AM		 1155 /* Read the whole section. Some of the fields might be before dataoff. */
1156 if (! bfd_get_section_contents (abfd, section, (PTR) data,
1157 0, dataoff + datasize))
277d1b5e
ILT		 1158 return false;
1159
db8503c4 1160 adj = section->vma - extra->ImageBase;
277d1b5e 1161
5933bdc9 1162 for (i = 0; i < datasize; i += onaline)
277d1b5e
ILT		 1163 {
1164 bfd_vma hint_addr;
1165 bfd_vma time_stamp;
1166 bfd_vma forward_chain;
1167 bfd_vma dll_name;
1168 bfd_vma first_thunk;
1169 int idx = 0;
1170 bfd_size_type j;
1171 char *dll;
1172
8181c403 1173 /* print (i + extra->DataDirectory[1].VirtualAddress) */
db8503c4 1174 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
8181c403 1175
5933bdc9 1176 if (i + 20 > datasize)
277d1b5e
ILT		 1177 {
1178 /* check stuff */
1179 ;
1180 }
5933bdc9 1181
db8503c4
AM		 1182 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1183 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1184 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1185 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1186 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
5933bdc9
ILT		 1187
1188 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
a76b448c
AM		 1189 (unsigned long) hint_addr,
1190 (unsigned long) time_stamp,
1191 (unsigned long) forward_chain,
1192 (unsigned long) dll_name,
1193 (unsigned long) first_thunk);
277d1b5e
ILT		 1194
1195 if (hint_addr == 0 && first_thunk == 0)
1196 break;
1197
8181c403 1198 dll = (char *) data + dll_name - adj;
277d1b5e
ILT		 1199 fprintf(file, _("\n\tDLL Name: %s\n"), dll);
1200
1201 if (hint_addr != 0)
1202 {
1203 fprintf (file, _("\tvma: Hint/Ord Member-Name\n"));
1204
8181c403 1205 idx = hint_addr - adj;
277d1b5e 1206
5933bdc9 1207 for (j = 0; j < datasize; j += 4)
277d1b5e
ILT		 1208 {
1209 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1210
1211 if (member == 0)
1212 break;
1213 if (member & 0x80000000)
1214 fprintf (file, "\t%04lx\t %4lu", member,
1215 member & 0x7fffffff);
1216 else
1217 {
1218 int ordinal;
1219 char *member_name;
1220
8181c403
AM		 1221 ordinal = bfd_get_16 (abfd, data + member - adj);
1222 member_name = (char *) data + member - adj + 2;
277d1b5e
ILT		 1223 fprintf (file, "\t%04lx\t %4d %s",
1224 member, ordinal, member_name);
1225 }
1226
1227 /* If the time stamp is not zero, the import address
1228 table holds actual addresses. */
1229 if (time_stamp != 0
1230 && first_thunk != 0
1231 && first_thunk != hint_addr)
1232 fprintf (file, "\t%04lx",
a76b448c 1233 (long) bfd_get_32 (abfd, data + first_thunk - adj + j));
277d1b5e
ILT		 1234
1235 fprintf (file, "\n");
1236 }
1237 }
1238
1239 if (hint_addr != first_thunk && time_stamp == 0)
1240 {
1241 int differ = 0;
1242 int idx2;
1243
8181c403 1244 idx2 = first_thunk - adj;
277d1b5e 1245
5933bdc9 1246 for (j = 0; j < datasize; j += 4)
277d1b5e
ILT		 1247 {
1248 int ordinal;
1249 char *member_name;
1250 bfd_vma hint_member = 0;
1251 bfd_vma iat_member;
1252
1253 if (hint_addr != 0)
1254 hint_member = bfd_get_32 (abfd, data + idx + j);
1255 iat_member = bfd_get_32 (abfd, data + idx2 + j);
1256
1257 if (hint_addr == 0 && iat_member == 0)
1258 break;
1259
1260 if (hint_addr == 0 || hint_member != iat_member)
1261 {
1262 if (differ == 0)
1263 {
1264 fprintf (file,
1265 _("\tThe Import Address Table (difference found)\n"));
1266 fprintf(file, _("\tvma: Hint/Ord Member-Name\n"));
1267 differ = 1;
1268 }
1269 if (iat_member == 0)
1270 {
1271 fprintf(file,
1272 _("\t>>> Ran out of IAT members!\n"));
1273 }
1274 else
1275 {
db8503c4 1276 ordinal = bfd_get_16 (abfd, data + iat_member - adj);
8181c403 1277 member_name = (char *) data + iat_member - adj + 2;
277d1b5e 1278 fprintf(file, "\t%04lx\t %4d %s\n",
a76b448c
AM		 1279 (unsigned long) iat_member,
1280 ordinal,
1281 member_name);
277d1b5e
ILT		 1282 }
1283 }
1284
1285 if (hint_addr != 0 && hint_member == 0)
1286 break;
1287 }
1288 if (differ == 0)
1289 {
1290 fprintf(file,
1291 _("\tThe Import Address Table is identical\n"));
1292 }
1293 }
1294
1295 fprintf(file, "\n");
1296
1297 }
1298
1299 free (data);
1300
1301 return true;
1302}
1303
1304static boolean
1305pe_print_edata (abfd, vfile)
1306 bfd *abfd;
1307 PTR vfile;
1308{
1309 FILE *file = (FILE *) vfile;
a76b448c 1310 bfd_byte *data;
8181c403 1311 asection *section;
277d1b5e 1312
a76b448c 1313 bfd_size_type datasize = 0;
277d1b5e
ILT		 1314 bfd_size_type dataoff;
1315 bfd_size_type i;
1316
8181c403 1317 bfd_signed_vma adj;
277d1b5e
ILT		 1318 struct EDT_type
1319 {
1320 long export_flags; /* reserved - should be zero */
1321 long time_stamp;
1322 short major_ver;
1323 short minor_ver;
1324 bfd_vma name; /* rva - relative to image base */
1325 long base; /* ordinal base */
1326 unsigned long num_functions; /* Number in the export address table */
1327 unsigned long num_names; /* Number in the name pointer table */
1328 bfd_vma eat_addr; /* rva to the export address table */
1329 bfd_vma npt_addr; /* rva to the Export Name Pointer Table */
1330 bfd_vma ot_addr; /* rva to the Ordinal Table */
1331 } edt;
1332
1333 pe_data_type *pe = pe_data (abfd);
1334 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1335
8181c403 1336 bfd_vma addr;
277d1b5e 1337
8181c403 1338 addr = extra->DataDirectory[0].VirtualAddress;
277d1b5e 1339
a76b448c 1340 if (addr == 0 && extra->DataDirectory[0].Size == 0)
8181c403 1341 {
a76b448c
AM		 1342 /* Maybe the extra header isn't there. Look for the section. */
1343 section = bfd_get_section_by_name (abfd, ".edata");
1344 if (section == NULL)
1345 return true;
1346
1347 addr = section->vma;
1348 datasize = bfd_section_size (abfd, section);
1349 if (datasize == 0)
1350 return true;
8181c403 1351 }
a76b448c 1352 else
8181c403 1353 {
a76b448c
AM		 1354 addr += extra->ImageBase;
1355 for (section = abfd->sections; section != NULL; section = section->next)
1356 {
1357 datasize = bfd_section_size (abfd, section);
1358 if (addr >= section->vma && addr < section->vma + datasize)
1359 break;
1360 }
1361
1362 if (section == NULL)
1363 {
1364 fprintf (file,
1365 _("\nThere is an export table, but the section containing it could not be found\n"));
1366 return true;
1367 }
277d1b5e
ILT		 1368 }
1369
8181c403
AM		 1370 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1371 section->name, (unsigned long) addr);
1372
1373 dataoff = addr - section->vma;
a76b448c 1374 datasize -= dataoff;
8181c403 1375
277d1b5e 1376 data = (bfd_byte *) bfd_malloc (datasize);
8181c403 1377 if (data == NULL)
277d1b5e
ILT		 1378 return false;
1379
1380 if (! bfd_get_section_contents (abfd, section, (PTR) data, dataoff,
1381 datasize))
1382 return false;
1383
1384 /* Go get Export Directory Table */
1385 edt.export_flags = bfd_get_32(abfd, data+0);
1386 edt.time_stamp = bfd_get_32(abfd, data+4);
1387 edt.major_ver = bfd_get_16(abfd, data+8);
1388 edt.minor_ver = bfd_get_16(abfd, data+10);
1389 edt.name = bfd_get_32(abfd, data+12);
1390 edt.base = bfd_get_32(abfd, data+16);
1391 edt.num_functions = bfd_get_32(abfd, data+20);
1392 edt.num_names = bfd_get_32(abfd, data+24);
1393 edt.eat_addr = bfd_get_32(abfd, data+28);
1394 edt.npt_addr = bfd_get_32(abfd, data+32);
1395 edt.ot_addr = bfd_get_32(abfd, data+36);
1396
8181c403 1397 adj = section->vma - extra->ImageBase + dataoff;
277d1b5e
ILT		 1398
1399 /* Dump the EDT first first */
1400 fprintf(file,
8181c403
AM		 1401 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1402 section->name);
277d1b5e
ILT		 1403
1404 fprintf(file,
1405 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1406
1407 fprintf(file,
1408 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1409
1410 fprintf(file,
1411 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1412
1413 fprintf (file,
1414 _("Name \t\t\t\t"));
1415 fprintf_vma (file, edt.name);
1416 fprintf (file,
8181c403 1417 " %s\n", data + edt.name - adj);
277d1b5e
ILT		 1418
1419 fprintf(file,
1420 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1421
1422 fprintf(file,
1423 _("Number in:\n"));
1424
1425 fprintf(file,
8181c403 1426 _("\tExport Address Table \t\t%08lx\n"),
277d1b5e
ILT		 1427 edt.num_functions);
1428
1429 fprintf(file,
8181c403 1430 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
277d1b5e
ILT		 1431
1432 fprintf(file,
1433 _("Table Addresses\n"));
1434
1435 fprintf (file,
1436 _("\tExport Address Table \t\t"));
1437 fprintf_vma (file, edt.eat_addr);
1438 fprintf (file, "\n");
1439
1440 fprintf (file,
1441 _("\tName Pointer Table \t\t"));
1442 fprintf_vma (file, edt.npt_addr);
1443 fprintf (file, "\n");
1444
1445 fprintf (file,
1446 _("\tOrdinal Table \t\t\t"));
1447 fprintf_vma (file, edt.ot_addr);
1448 fprintf (file, "\n");
1449
1450
5933bdc9 1451 /* The next table to find is the Export Address Table. It's basically
277d1b5e
ILT		 1452 a list of pointers that either locate a function in this dll, or
1453 forward the call to another dll. Something like:
1454 typedef union
1455 {
1456 long export_rva;
1457 long forwarder_rva;
1458 } export_address_table_entry;
1459 */
1460
1461 fprintf(file,
1462 _("\nExport Address Table -- Ordinal Base %ld\n"),
1463 edt.base);
1464
1465 for (i = 0; i < edt.num_functions; ++i)
1466 {
1467 bfd_vma eat_member = bfd_get_32 (abfd,
8181c403 1468 data + edt.eat_addr + (i * 4) - adj);
277d1b5e
ILT		 1469 if (eat_member == 0)
1470 continue;
1471
db8503c4 1472 if (eat_member - adj <= datasize)
277d1b5e 1473 {
db8503c4 1474 /* This rva is to a name (forwarding function) in our section. */
277d1b5e 1475 /* Should locate a function descriptor */
5933bdc9
ILT		 1476 fprintf (file,
1477 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
a76b448c
AM		 1478 (long) i,
1479 (long) (i + edt.base),
1480 (unsigned long) eat_member,
1481 _("Forwarder RVA"),
1482 data + eat_member - adj);
277d1b5e
ILT		 1483 }
1484 else
1485 {
1486 /* Should locate a function descriptor in the reldata section */
5933bdc9
ILT		 1487 fprintf (file,
1488 "\t[%4ld] +base[%4ld] %04lx %s\n",
a76b448c
AM		 1489 (long) i,
1490 (long) (i + edt.base),
1491 (unsigned long) eat_member,
5933bdc9 1492 _("Export RVA"));
277d1b5e
ILT		 1493 }
1494 }
1495
1496 /* The Export Name Pointer Table is paired with the Export Ordinal Table */
1497 /* Dump them in parallel for clarity */
1498 fprintf(file,
1499 _("\n[Ordinal/Name Pointer] Table\n"));
1500
1501 for (i = 0; i < edt.num_names; ++i)
1502 {
1503 bfd_vma name_ptr = bfd_get_32(abfd,
1504 data +
1505 edt.npt_addr
8181c403 1506 + (i*4) - adj);
277d1b5e 1507
8181c403 1508 char *name = (char *) data + name_ptr - adj;
277d1b5e
ILT		 1509
1510 bfd_vma ord = bfd_get_16(abfd,
1511 data +
1512 edt.ot_addr
8181c403 1513 + (i*2) - adj);
277d1b5e
ILT		 1514 fprintf(file,
1515 "\t[%4ld] %s\n", (long) ord, name);
1516
1517 }
1518
1519 free (data);
1520
1521 return true;
1522}
1523
fac41780
JW		 1524/* This really is architecture dependent. On IA-64, a .pdata entry
1525 consists of three dwords containing relative virtual addresses that
1526 specify the start and end address of the code range the entry
1527 covers and the address of the corresponding unwind info data. */
277d1b5e
ILT		 1528static boolean
1529pe_print_pdata (abfd, vfile)
1530 bfd *abfd;
1531 PTR vfile;
1532{
fac41780
JW		 1533#ifdef COFF_WITH_PEP64
1534# define PDATA_ROW_SIZE (3*8)
1535#else
1536# define PDATA_ROW_SIZE (5*4)
1537#endif
277d1b5e
ILT		 1538 FILE *file = (FILE *) vfile;
1539 bfd_byte *data = 0;
1540 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1541 bfd_size_type datasize = 0;
1542 bfd_size_type i;
1543 bfd_size_type start, stop;
fac41780 1544 int onaline = PDATA_ROW_SIZE;
277d1b5e 1545
5933bdc9
ILT		 1546 if (section == NULL
1547 || coff_section_data (abfd, section) == NULL
1548 || pei_section_data (abfd, section) == NULL)
1549 return true;
277d1b5e 1550
5933bdc9 1551 stop = pei_section_data (abfd, section)->virt_size;
277d1b5e
ILT		 1552 if ((stop % onaline) != 0)
1553 fprintf (file, _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1554 (long)stop, onaline);
1555
5933bdc9
ILT		 1556 fprintf (file,
1557 _("\nThe Function Table (interpreted .pdata section contents)\n"));
fac41780
JW		 1558#ifdef COFF_WITH_PEP64
1559 fprintf(file,
1560 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1561#else
5933bdc9
ILT		 1562 fprintf (file,
1563 _(" vma:\t\tBegin End EH EH PrologEnd Exception\n"));
1564 fprintf (file,
1565 _(" \t\tAddress Address Handler Data Address Mask\n"));
fac41780 1566#endif
277d1b5e
ILT		 1567
1568 if (bfd_section_size (abfd, section) == 0)
1569 return true;
1570
1571 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1572 datasize = bfd_section_size (abfd, section);
1573 if (data == NULL && datasize != 0)
1574 return false;
1575
1576 bfd_get_section_contents (abfd,
1577 section,
1578 (PTR) data, 0,
1579 bfd_section_size (abfd, section));
1580
1581 start = 0;
1582
1583 for (i = start; i < stop; i += onaline)
1584 {
1585 bfd_vma begin_addr;
1586 bfd_vma end_addr;
1587 bfd_vma eh_handler;
1588 bfd_vma eh_data;
1589 bfd_vma prolog_end_addr;
5933bdc9 1590 int em_data;
277d1b5e 1591
fac41780 1592 if (i + PDATA_ROW_SIZE > stop)
277d1b5e 1593 break;
5933bdc9 1594
fac41780
JW		 1595 begin_addr = GET_PDATA_ENTRY(abfd, data+i);
1596 end_addr = GET_PDATA_ENTRY(abfd, data+i+4);
1597 eh_handler = GET_PDATA_ENTRY(abfd, data+i+8);
1598 eh_data = GET_PDATA_ENTRY(abfd, data+i+12);
1599 prolog_end_addr = GET_PDATA_ENTRY(abfd, data+i+16);
277d1b5e
ILT		 1600
1601 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1602 && eh_data == 0 && prolog_end_addr == 0)
1603 {
1604 /* We are probably into the padding of the section now. */
1605 break;
1606 }
1607
5933bdc9 1608 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
fac41780
JW		 1609 eh_handler &= ~ (bfd_vma) 0x3;
1610 prolog_end_addr &= ~ (bfd_vma) 0x3;
1611
1612 fputc (' ', file);
1613 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1614 fprintf_vma (file, begin_addr); fputc (' ', file);
1615 fprintf_vma (file, end_addr); fputc (' ', file);
1616 fprintf_vma (file, eh_handler);
1617#ifndef COFF_WITH_PEP64
1618 fputc (' ', file);
1619 fprintf_vma (file, eh_data); fputc (' ', file);
1620 fprintf_vma (file, prolog_end_addr);
1621 fprintf (file, " %x", em_data);
1622#endif
277d1b5e
ILT		 1623
1624#ifdef POWERPC_LE_PE
1625 if (eh_handler == 0 && eh_data != 0)
1626 {
1627 /* Special bits here, although the meaning may */
1628 /* be a little mysterious. The only one I know */
1629 /* for sure is 0x03. */
1630 /* Code Significance */
1631 /* 0x00 None */
1632 /* 0x01 Register Save Millicode */
1633 /* 0x02 Register Restore Millicode */
1634 /* 0x03 Glue Code Sequence */
1635 switch (eh_data)
1636 {
1637 case 0x01:
1638 fprintf(file, _(" Register save millicode"));
1639 break;
1640 case 0x02:
1641 fprintf(file, _(" Register restore millicode"));
1642 break;
1643 case 0x03:
1644 fprintf(file, _(" Glue code sequence"));
1645 break;
1646 default:
1647 break;
1648 }
1649 }
1650#endif
1651 fprintf(file, "\n");
1652 }
1653
1654 free (data);
1655
1656 return true;
1657}
1658
5933bdc9
ILT		 1659#define IMAGE_REL_BASED_HIGHADJ 4
1660static const char * const tbl[] =
277d1b5e
ILT		 1661{
1662"ABSOLUTE",
1663"HIGH",
1664"LOW",
1665"HIGHLOW",
1666"HIGHADJ",
5933bdc9 1667"MIPS_JMPADDR",
fac41780
JW		 1668"SECTION",
1669"REL32",
1670"RESERVED1",
1671"MIPS_JMPADDR16",
1672"DIR64",
1673"HIGH3ADJ"
5933bdc9 1674"UNKNOWN", /* MUST be last */
277d1b5e
ILT		 1675};
1676
1677static boolean
1678pe_print_reloc (abfd, vfile)
1679 bfd *abfd;
1680 PTR vfile;
1681{
1682 FILE *file = (FILE *) vfile;
1683 bfd_byte *data = 0;
1684 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1685 bfd_size_type datasize = 0;
1686 bfd_size_type i;
1687 bfd_size_type start, stop;
1688
5933bdc9 1689 if (section == NULL)
277d1b5e
ILT		 1690 return true;
1691
1692 if (bfd_section_size (abfd, section) == 0)
1693 return true;
1694
5933bdc9
ILT		 1695 fprintf (file,
1696 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
277d1b5e
ILT		 1697
1698 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1699 datasize = bfd_section_size (abfd, section);
1700 if (data == NULL && datasize != 0)
1701 return false;
1702
1703 bfd_get_section_contents (abfd,
1704 section,
1705 (PTR) data, 0,
1706 bfd_section_size (abfd, section));
1707
1708 start = 0;
1709
1710 stop = bfd_section_size (abfd, section);
1711
1712 for (i = start; i < stop;)
1713 {
1714 int j;
1715 bfd_vma virtual_address;
1716 long number, size;
1717
1718 /* The .reloc section is a sequence of blocks, with a header consisting
1719 of two 32 bit quantities, followed by a number of 16 bit entries */
1720
1721 virtual_address = bfd_get_32(abfd, data+i);
1722 size = bfd_get_32(abfd, data+i+4);
1723 number = (size - 8) / 2;
1724
1725 if (size == 0)
1726 {
1727 break;
1728 }
1729
1730 fprintf (file,
1731 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
a76b448c 1732 (unsigned long) virtual_address, size, size, number);
277d1b5e
ILT		 1733
1734 for (j = 0; j < number; ++j)
1735 {
5933bdc9
ILT		 1736 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1737 unsigned int t = (e & 0xF000) >> 12;
277d1b5e
ILT		 1738 int off = e & 0x0FFF;
1739
5933bdc9
ILT		 1740 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1741 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
277d1b5e 1742
5933bdc9
ILT		 1743 fprintf (file,
1744 _("\treloc %4d offset %4x [%4lx] %s"),
1745 j, off, (long) (off + virtual_address), tbl[t]);
277d1b5e 1746
17505c5c
NC		 1747 /* HIGHADJ takes an argument, - the next record *is* the
1748 low 16 bits of addend. */
5933bdc9
ILT		 1749 if (t == IMAGE_REL_BASED_HIGHADJ)
1750 {
17505c5c 1751 fprintf (file, " (%4x)",
5933bdc9
ILT		 1752 ((unsigned int)
1753 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1754 j++;
1755 }
17505c5c
NC		 1756
1757 fprintf (file, "\n");
277d1b5e
ILT		 1758 }
1759 i += size;
1760 }
1761
1762 free (data);
1763
1764 return true;
1765}
1766
1767/* Print out the program headers. */
1768
1769boolean
1770_bfd_pe_print_private_bfd_data_common (abfd, vfile)
1771 bfd *abfd;
1772 PTR vfile;
1773{
1774 FILE *file = (FILE *) vfile;
1775 int j;
1776 pe_data_type *pe = pe_data (abfd);
1777 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
fac41780 1778 const char *subsystem_name = NULL;
277d1b5e
ILT		 1779
1780 /* The MS dumpbin program reportedly ands with 0xff0f before
1781 printing the characteristics field. Not sure why. No reason to
1782 emulate it here. */
1783 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1784#undef PF
1785#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1786 PF (F_RELFLG, "relocations stripped");
1787 PF (F_EXEC, "executable");
1788 PF (F_LNNO, "line numbers stripped");
1789 PF (F_LSYMS, "symbols stripped");
1790 PF (0x80, "little endian");
1791 PF (F_AR32WR, "32 bit words");
1792 PF (0x200, "debugging information removed");
1793 PF (0x1000, "system file");
1794 PF (F_DLL, "DLL");
1795 PF (0x8000, "big endian");
1796#undef PF
1797
5933bdc9
ILT		 1798 /* ctime implies '\n'. */
1799 fprintf (file, "\nTime/Date\t\t%s", ctime (&pe->coff.timestamp));
277d1b5e
ILT		 1800 fprintf (file,"\nImageBase\t\t");
1801 fprintf_vma (file, i->ImageBase);
1802 fprintf (file,"\nSectionAlignment\t");
1803 fprintf_vma (file, i->SectionAlignment);
1804 fprintf (file,"\nFileAlignment\t\t");
1805 fprintf_vma (file, i->FileAlignment);
1806 fprintf (file,"\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1807 fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1808 fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1809 fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1810 fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1811 fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
8181c403 1812 fprintf (file,"Win32Version\t\t%08lx\n", i->Reserved1);
277d1b5e
ILT		 1813 fprintf (file,"SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1814 fprintf (file,"SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1815 fprintf (file,"CheckSum\t\t%08lx\n", i->CheckSum);
fac41780
JW		 1816 switch (i->Subsystem)
1817 {
1818 case IMAGE_SUBSYSTEM_UNKNOWN:
1819 subsystem_name = "unspecified";
1820 break;
1821 case IMAGE_SUBSYSTEM_NATIVE:
1822 subsystem_name = "NT native";
1823 break;
1824 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1825 subsystem_name = "Windows GUI";
1826 break;
1827 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1828 subsystem_name = "Windows CUI";
1829 break;
1830 case IMAGE_SUBSYSTEM_POSIX_CUI:
1831 subsystem_name = "POSIX CUI";
1832 break;
1833 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1834 subsystem_name = "Wince CUI";
1835 break;
1836 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1837 subsystem_name = "EFI application";
1838 break;
1839 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1840 subsystem_name = "EFI boot service driver";
1841 break;
1842 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1843 subsystem_name = "EFI runtime driver";
1844 break;
1845 }
1846 fprintf (file,"Subsystem\t\t%08x", i->Subsystem);
1847 if (subsystem_name)
1848 fprintf (file, "\t(%s)", subsystem_name);
1849 fprintf (file,"\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
277d1b5e
ILT		 1850 fprintf (file,"SizeOfStackReserve\t");
1851 fprintf_vma (file, i->SizeOfStackReserve);
1852 fprintf (file,"\nSizeOfStackCommit\t");
1853 fprintf_vma (file, i->SizeOfStackCommit);
1854 fprintf (file,"\nSizeOfHeapReserve\t");
1855 fprintf_vma (file, i->SizeOfHeapReserve);
1856 fprintf (file,"\nSizeOfHeapCommit\t");
1857 fprintf_vma (file, i->SizeOfHeapCommit);
1858 fprintf (file,"\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1859 fprintf (file,"NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1860
1861 fprintf (file,"\nThe Data Directory\n");
1862 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1863 {
1864 fprintf (file, "Entry %1x ", j);
1865 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1866 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1867 fprintf (file, "%s\n", dir_names[j]);
1868 }
1869
1870 pe_print_idata (abfd, vfile);
1871 pe_print_edata (abfd, vfile);
1872 pe_print_pdata (abfd, vfile);
1873 pe_print_reloc (abfd, vfile);
1874
1875 return true;
1876}
1877
1878/* Copy any private info we understand from the input bfd
1879 to the output bfd. */
1880
1881boolean
1882_bfd_pe_bfd_copy_private_bfd_data_common (ibfd, obfd)
1883 bfd *ibfd, *obfd;
1884{
1885 /* One day we may try to grok other private data. */
1886 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1887 || obfd->xvec->flavour != bfd_target_coff_flavour)
1888 return true;
1889
1890 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1891 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1892
5933bdc9
ILT		 1893 /* for strip: if we removed .reloc, we'll make a real mess of things
1894 if we don't remove this entry as well. */
1895 if (! pe_data (obfd)->has_reloc_section)
1896 {
1897 pe_data(obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1898 pe_data(obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1899 }
277d1b5e
ILT		 1900 return true;
1901}
1902
1903/* Copy private section data. */
1904boolean
1905_bfd_pe_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1906 bfd *ibfd;
1907 asection *isec;
1908 bfd *obfd;
1909 asection *osec;
1910{
1911 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1912 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1913 return true;
1914
1915 if (coff_section_data (ibfd, isec) != NULL
1916 && pei_section_data (ibfd, isec) != NULL)
1917 {
1918 if (coff_section_data (obfd, osec) == NULL)
1919 {
1920 osec->used_by_bfd =
1921 (PTR) bfd_zalloc (obfd, sizeof (struct coff_section_tdata));
1922 if (osec->used_by_bfd == NULL)
1923 return false;
1924 }
1925 if (pei_section_data (obfd, osec) == NULL)
1926 {
1927 coff_section_data (obfd, osec)->tdata =
1928 (PTR) bfd_zalloc (obfd, sizeof (struct pei_section_tdata));
1929 if (coff_section_data (obfd, osec)->tdata == NULL)
1930 return false;
1931 }
1932 pei_section_data (obfd, osec)->virt_size =
1933 pei_section_data (ibfd, isec)->virt_size;
5933bdc9
ILT		 1934 pei_section_data (obfd, osec)->pe_flags =
1935 pei_section_data (ibfd, isec)->pe_flags;
277d1b5e
ILT		 1936 }
1937
1938 return true;
1939}
7d2b58d6
ILT		 1940
1941void
1942_bfd_pe_get_symbol_info (abfd, symbol, ret)
1943 bfd *abfd;
1944 asymbol *symbol;
1945 symbol_info *ret;
1946{
1947 coff_get_symbol_info (abfd, symbol, ret);
1948
1949 if (pe_data (abfd) != NULL
1950 && ((symbol->flags & BSF_DEBUGGING) == 0
1951 || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
1952 && ! bfd_is_abs_section (symbol->section))
1953 ret->value += pe_data (abfd)->pe_opthdr.ImageBase;
1954}
2fbadf2c
ILT		 1955
1956/* Handle the .idata section and other things that need symbol table
1957 access. */
1958
1959boolean
1960_bfd_pei_final_link_postscript (abfd, pfinfo)
1961 bfd *abfd;
1962 struct coff_final_link_info *pfinfo;
1963{
1964 struct coff_link_hash_entry *h1;
1965 struct bfd_link_info *info = pfinfo->info;
1966
1967 /* There are a few fields that need to be filled in now while we
1968 have symbol table access.
1969
1970 The .idata subsections aren't directly available as sections, but
1971 they are in the symbol table, so get them from there. */
1972
1973 /* The import directory. This is the address of .idata$2, with size
1974 of .idata$2 + .idata$3. */
1975 h1 = coff_link_hash_lookup (coff_hash_table (info),
1976 ".idata$2", false, false, true);
1977 if (h1 != NULL)
1978 {
1979 pe_data(abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
1980 (h1->root.u.def.value
1981 + h1->root.u.def.section->output_section->vma
1982 + h1->root.u.def.section->output_offset);
1983 h1 = coff_link_hash_lookup (coff_hash_table (info),
1984 ".idata$4", false, false, true);
1985 pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
1986 ((h1->root.u.def.value
1987 + h1->root.u.def.section->output_section->vma
1988 + h1->root.u.def.section->output_offset)
1989 - pe_data(abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
1990
1991 /* The import address table. This is the size/address of
1992 .idata$5. */
1993 h1 = coff_link_hash_lookup (coff_hash_table (info),
1994 ".idata$5", false, false, true);
1995 pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
1996 (h1->root.u.def.value
1997 + h1->root.u.def.section->output_section->vma
1998 + h1->root.u.def.section->output_offset);
1999 h1 = coff_link_hash_lookup (coff_hash_table (info),
2000 ".idata$6", false, false, true);
2001 pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
2002 ((h1->root.u.def.value
2003 + h1->root.u.def.section->output_section->vma
2004 + h1->root.u.def.section->output_offset)
2005 - pe_data(abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
2006 }
2007
2008 /* If we couldn't find idata$2, we either have an excessively
2009 trivial program or are in DEEP trouble; we have to assume trivial
2010 program.... */
2011 return true;
2012}
GDB Binutils - Deliverables
This page took 0.136403 seconds and 4 git commands to generate.