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