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