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