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