projects / binutils-gdb.git / blob
? search:


5b52a92d5f71588ed67acdce16a319826502840c
[binutils-gdb.git] / bfd / peicode.h
1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1995 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
27
28 #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data
29 #define coff_mkobject pe_mkobject
30 #define coff_mkobject_hook pe_mkobject_hook
31
32
33 #ifndef GET_FCN_LNNOPTR
34 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
35 #endif
36
37 #ifndef GET_FCN_ENDNDX
38 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
39 #endif
40
41 #ifndef PUT_FCN_LNNOPTR
42 #define PUT_FCN_LNNOPTR(abfd, in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
43 #endif
44 #ifndef PUT_FCN_ENDNDX
45 #define PUT_FCN_ENDNDX(abfd, in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
46 #endif
47 #ifndef GET_LNSZ_LNNO
48 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
49 #endif
50 #ifndef GET_LNSZ_SIZE
51 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
52 #endif
53 #ifndef PUT_LNSZ_LNNO
54 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
55 #endif
56 #ifndef PUT_LNSZ_SIZE
57 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
58 #endif
59 #ifndef GET_SCN_SCNLEN
60 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
61 #endif
62 #ifndef GET_SCN_NRELOC
63 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
64 #endif
65 #ifndef GET_SCN_NLINNO
66 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
67 #endif
68 #ifndef PUT_SCN_SCNLEN
69 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
70 #endif
71 #ifndef PUT_SCN_NRELOC
72 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
73 #endif
74 #ifndef PUT_SCN_NLINNO
75 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
76 #endif
77 #ifndef GET_LINENO_LNNO
78 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
79 #endif
80 #ifndef PUT_LINENO_LNNO
81 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
82 #endif
83
84 /* The f_symptr field in the filehdr is sometimes 64 bits. */
85 #ifndef GET_FILEHDR_SYMPTR
86 #define GET_FILEHDR_SYMPTR bfd_h_get_32
87 #endif
88 #ifndef PUT_FILEHDR_SYMPTR
89 #define PUT_FILEHDR_SYMPTR bfd_h_put_32
90 #endif
91
92 /* Some fields in the aouthdr are sometimes 64 bits. */
93 #ifndef GET_AOUTHDR_TSIZE
94 #define GET_AOUTHDR_TSIZE bfd_h_get_32
95 #endif
96 #ifndef PUT_AOUTHDR_TSIZE
97 #define PUT_AOUTHDR_TSIZE bfd_h_put_32
98 #endif
99 #ifndef GET_AOUTHDR_DSIZE
100 #define GET_AOUTHDR_DSIZE bfd_h_get_32
101 #endif
102 #ifndef PUT_AOUTHDR_DSIZE
103 #define PUT_AOUTHDR_DSIZE bfd_h_put_32
104 #endif
105 #ifndef GET_AOUTHDR_BSIZE
106 #define GET_AOUTHDR_BSIZE bfd_h_get_32
107 #endif
108 #ifndef PUT_AOUTHDR_BSIZE
109 #define PUT_AOUTHDR_BSIZE bfd_h_put_32
110 #endif
111 #ifndef GET_AOUTHDR_ENTRY
112 #define GET_AOUTHDR_ENTRY bfd_h_get_32
113 #endif
114 #ifndef PUT_AOUTHDR_ENTRY
115 #define PUT_AOUTHDR_ENTRY bfd_h_put_32
116 #endif
117 #ifndef GET_AOUTHDR_TEXT_START
118 #define GET_AOUTHDR_TEXT_START bfd_h_get_32
119 #endif
120 #ifndef PUT_AOUTHDR_TEXT_START
121 #define PUT_AOUTHDR_TEXT_START bfd_h_put_32
122 #endif
123 #ifndef GET_AOUTHDR_DATA_START
124 #define GET_AOUTHDR_DATA_START bfd_h_get_32
125 #endif
126 #ifndef PUT_AOUTHDR_DATA_START
127 #define PUT_AOUTHDR_DATA_START bfd_h_put_32
128 #endif
129
130 /* Some fields in the scnhdr are sometimes 64 bits. */
131 #ifndef GET_SCNHDR_PADDR
132 #define GET_SCNHDR_PADDR bfd_h_get_32
133 #endif
134 #ifndef PUT_SCNHDR_PADDR
135 #define PUT_SCNHDR_PADDR bfd_h_put_32
136 #endif
137 #ifndef GET_SCNHDR_VADDR
138 #define GET_SCNHDR_VADDR bfd_h_get_32
139 #endif
140 #ifndef PUT_SCNHDR_VADDR
141 #define PUT_SCNHDR_VADDR bfd_h_put_32
142 #endif
143 #ifndef GET_SCNHDR_SIZE
144 #define GET_SCNHDR_SIZE bfd_h_get_32
145 #endif
146 #ifndef PUT_SCNHDR_SIZE
147 #define PUT_SCNHDR_SIZE bfd_h_put_32
148 #endif
149 #ifndef GET_SCNHDR_SCNPTR
150 #define GET_SCNHDR_SCNPTR bfd_h_get_32
151 #endif
152 #ifndef PUT_SCNHDR_SCNPTR
153 #define PUT_SCNHDR_SCNPTR bfd_h_put_32
154 #endif
155 #ifndef GET_SCNHDR_RELPTR
156 #define GET_SCNHDR_RELPTR bfd_h_get_32
157 #endif
158 #ifndef PUT_SCNHDR_RELPTR
159 #define PUT_SCNHDR_RELPTR bfd_h_put_32
160 #endif
161 #ifndef GET_SCNHDR_LNNOPTR
162 #define GET_SCNHDR_LNNOPTR bfd_h_get_32
163 #endif
164 #ifndef PUT_SCNHDR_LNNOPTR
165 #define PUT_SCNHDR_LNNOPTR bfd_h_put_32
166 #endif
167
168
169
170 /**********************************************************************/
171
172 static void
173 coff_swap_reloc_in (abfd, src, dst)
174 bfd *abfd;
175 PTR src;
176 PTR dst;
177 {
178 RELOC *reloc_src = (RELOC *) src;
179 struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
180
181 reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
182 reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
183
184 reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
185
186 #ifdef SWAP_IN_RELOC_OFFSET
187 reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
188 (bfd_byte *) reloc_src->r_offset);
189 #endif
190
191 }
192
193
194 static unsigned int
195 coff_swap_reloc_out (abfd, src, dst)
196 bfd *abfd;
197 PTR src;
198 PTR dst;
199 {
200 struct internal_reloc *reloc_src = (struct internal_reloc *)src;
201 struct external_reloc *reloc_dst = (struct external_reloc *)dst;
202 bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
203 bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
204
205 bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
206 reloc_dst->r_type);
207
208 #ifdef SWAP_OUT_RELOC_OFFSET
209 SWAP_OUT_RELOC_OFFSET(abfd,
210 reloc_src->r_offset,
211 (bfd_byte *) reloc_dst->r_offset);
212 #endif
213 #ifdef SWAP_OUT_RELOC_EXTRA
214 SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
215 #endif
216 return sizeof(struct external_reloc);
217 }
218
219
220 static void
221 coff_swap_filehdr_in (abfd, src, dst)
222 bfd *abfd;
223 PTR src;
224 PTR dst;
225 {
226 FILHDR *filehdr_src = (FILHDR *) src;
227 struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
228 filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
229 filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
230 filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
231 filehdr_dst->f_symptr =
232 bfd_h_get_32 (abfd, (bfd_byte *) filehdr_src->f_symptr);
233 filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
234 filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr);
235 filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
236 }
237
238 static unsigned int
239 coff_swap_filehdr_out (abfd, in, out)
240 bfd *abfd;
241 PTR in;
242 PTR out;
243 {
244 int idx;
245 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
246 FILHDR *filehdr_out = (FILHDR *)out;
247
248 if (pe_data (abfd)->has_reloc_section)
249 filehdr_in->f_flags &= ~F_RELFLG;
250
251 if (pe_data (abfd)->dll)
252 filehdr_in->f_flags |= F_DLL;
253
254 filehdr_in->pe.e_magic = DOSMAGIC;
255 filehdr_in->pe.e_cblp = 0x90;
256 filehdr_in->pe.e_cp = 0x3;
257 filehdr_in->pe.e_crlc = 0x0;
258 filehdr_in->pe.e_cparhdr = 0x4;
259 filehdr_in->pe.e_minalloc = 0x0;
260 filehdr_in->pe.e_maxalloc = 0xffff;
261 filehdr_in->pe.e_ss = 0x0;
262 filehdr_in->pe.e_sp = 0xb8;
263 filehdr_in->pe.e_csum = 0x0;
264 filehdr_in->pe.e_ip = 0x0;
265 filehdr_in->pe.e_cs = 0x0;
266 filehdr_in->pe.e_lfarlc = 0x40;
267 filehdr_in->pe.e_ovno = 0x0;
268
269 for (idx=0; idx < 4; idx++)
270 filehdr_in->pe.e_res[idx] = 0x0;
271
272 filehdr_in->pe.e_oemid = 0x0;
273 filehdr_in->pe.e_oeminfo = 0x0;
274
275 for (idx=0; idx < 10; idx++)
276 filehdr_in->pe.e_res2[idx] = 0x0;
277
278 filehdr_in->pe.e_lfanew = 0x80;
279
280 /* this next collection of data are mostly just characters. It appears
281 to be constant within the headers put on NT exes */
282 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
283 filehdr_in->pe.dos_message[1] = 0xcd09b400;
284 filehdr_in->pe.dos_message[2] = 0x4c01b821;
285 filehdr_in->pe.dos_message[3] = 0x685421cd;
286 filehdr_in->pe.dos_message[4] = 0x70207369;
287 filehdr_in->pe.dos_message[5] = 0x72676f72;
288 filehdr_in->pe.dos_message[6] = 0x63206d61;
289 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
290 filehdr_in->pe.dos_message[8] = 0x65622074;
291 filehdr_in->pe.dos_message[9] = 0x6e757220;
292 filehdr_in->pe.dos_message[10] = 0x206e6920;
293 filehdr_in->pe.dos_message[11] = 0x20534f44;
294 filehdr_in->pe.dos_message[12] = 0x65646f6d;
295 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
296 filehdr_in->pe.dos_message[14] = 0x24;
297 filehdr_in->pe.dos_message[15] = 0x0;
298 filehdr_in->pe.nt_signature = NT_SIGNATURE;
299
300
301
302 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
303 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
304
305 bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
306 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
307 (bfd_byte *) filehdr_out->f_symptr);
308 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
309 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
310 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
311
312
313 /* put in extra dos header stuff. This data remains essentially
314 constant, it just has to be tacked on to the beginning of all exes
315 for NT */
316 bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
317 bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
318 bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
319 bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
320 bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr,
321 (bfd_byte *) filehdr_out->e_cparhdr);
322 bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc,
323 (bfd_byte *) filehdr_out->e_minalloc);
324 bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc,
325 (bfd_byte *) filehdr_out->e_maxalloc);
326 bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
327 bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
328 bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
329 bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
330 bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
331 bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
332 bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
333 {
334 int idx;
335 for (idx=0; idx < 4; idx++)
336 bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx],
337 (bfd_byte *) filehdr_out->e_res[idx]);
338 }
339 bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
340 bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo,
341 (bfd_byte *) filehdr_out->e_oeminfo);
342 {
343 int idx;
344 for (idx=0; idx < 10; idx++)
345 bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx],
346 (bfd_byte *) filehdr_out->e_res2[idx]);
347 }
348 bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
349
350 {
351 int idx;
352 for (idx=0; idx < 16; idx++)
353 bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx],
354 (bfd_byte *) filehdr_out->dos_message[idx]);
355 }
356
357 /* also put in the NT signature */
358 bfd_h_put_32(abfd, filehdr_in->pe.nt_signature,
359 (bfd_byte *) filehdr_out->nt_signature);
360
361
362
363
364 return sizeof(FILHDR);
365 }
366
367
368
369 static void
370 coff_swap_sym_in (abfd, ext1, in1)
371 bfd *abfd;
372 PTR ext1;
373 PTR in1;
374 {
375 SYMENT *ext = (SYMENT *)ext1;
376 struct internal_syment *in = (struct internal_syment *)in1;
377
378 if( ext->e.e_name[0] == 0) {
379 in->_n._n_n._n_zeroes = 0;
380 in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
381 }
382 else {
383 #if SYMNMLEN != E_SYMNMLEN
384 -> Error, we need to cope with truncating or extending SYMNMLEN!;
385 #else
386 memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
387 #endif
388 }
389 in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
390 in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
391 if (sizeof(ext->e_type) == 2){
392 in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
393 }
394 else {
395 in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
396 }
397 in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
398 in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
399
400 /* The section symbols for the .idata$ sections have class 68, which MS
401 documentation indicates is a section symbol. The problem is that the
402 value field in the symbol is simply a copy of the .idata section's flags
403 rather than something useful. When these symbols are encountered, change
404 the value to 0 and the section number to 1 so that they will be handled
405 somewhat correctly in the bfd code. */
406 if (in->n_sclass == 0x68) {
407 in->n_value = 0x0;
408 in->n_scnum = 1;
409 /* I have tried setting the class to 3 and using the following to set
410 the section number. This will put the address of the pointer to the
411 string kernel32.dll at addresses 0 and 0x10 off start of idata section
412 which is not correct */
413 /* if (strcmp (in->_n._n_name, ".idata$4") == 0) */
414 /* in->n_scnum = 3; */
415 /* else */
416 /* in->n_scnum = 2; */
417 }
418 }
419
420 static unsigned int
421 coff_swap_sym_out (abfd, inp, extp)
422 bfd *abfd;
423 PTR inp;
424 PTR extp;
425 {
426 struct internal_syment *in = (struct internal_syment *)inp;
427 SYMENT *ext =(SYMENT *)extp;
428 if(in->_n._n_name[0] == 0) {
429 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
430 bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
431 }
432 else {
433 #if SYMNMLEN != E_SYMNMLEN
434 -> Error, we need to cope with truncating or extending SYMNMLEN!;
435 #else
436 memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
437 #endif
438 }
439 bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value);
440 bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum);
441 if (sizeof(ext->e_type) == 2)
442 {
443 bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type);
444 }
445 else
446 {
447 bfd_h_put_32(abfd, in->n_type , (bfd_byte *) ext->e_type);
448 }
449 bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass);
450 bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux);
451 return sizeof(SYMENT);
452 }
453
454 static void
455 coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
456 bfd *abfd;
457 PTR ext1;
458 int type;
459 int class;
460 int indx;
461 int numaux;
462 PTR in1;
463 {
464 AUXENT *ext = (AUXENT *)ext1;
465 union internal_auxent *in = (union internal_auxent *)in1;
466
467 switch (class) {
468 case C_FILE:
469 if (ext->x_file.x_fname[0] == 0) {
470 in->x_file.x_n.x_zeroes = 0;
471 in->x_file.x_n.x_offset =
472 bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
473 } else {
474 #if FILNMLEN != E_FILNMLEN
475 -> Error, we need to cope with truncating or extending FILNMLEN!;
476 #else
477 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
478 #endif
479 }
480 return;
481
482
483 case C_STAT:
484 #ifdef C_LEAFSTAT
485 case C_LEAFSTAT:
486 #endif
487 case C_HIDDEN:
488 if (type == T_NULL) {
489 in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
490 in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
491 in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
492 return;
493 }
494 break;
495 }
496
497 in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
498 #ifndef NO_TVNDX
499 in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
500 #endif
501
502 if (class == C_BLOCK || ISFCN (type) || ISTAG (class))
503 {
504 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
505 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
506 }
507 else
508 {
509 #if DIMNUM != E_DIMNUM
510 #error we need to cope with truncating or extending DIMNUM
511 #endif
512 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
513 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
514 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
515 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
516 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
517 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
518 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
519 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
520 }
521
522 if (ISFCN(type)) {
523 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
524 }
525 else {
526 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
527 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
528 }
529 }
530
531 static unsigned int
532 coff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
533 bfd *abfd;
534 PTR inp;
535 int type;
536 int class;
537 int indx;
538 int numaux;
539 PTR extp;
540 {
541 union internal_auxent *in = (union internal_auxent *)inp;
542 AUXENT *ext = (AUXENT *)extp;
543
544 memset((PTR)ext, 0, AUXESZ);
545 switch (class) {
546 case C_FILE:
547 if (in->x_file.x_fname[0] == 0) {
548 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
549 bfd_h_put_32(abfd,
550 in->x_file.x_n.x_offset,
551 (bfd_byte *) ext->x_file.x_n.x_offset);
552 }
553 else {
554 #if FILNMLEN != E_FILNMLEN
555 -> Error, we need to cope with truncating or extending FILNMLEN!;
556 #else
557 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
558 #endif
559 }
560 return sizeof (AUXENT);
561
562
563 case C_STAT:
564 #ifdef C_LEAFSTAT
565 case C_LEAFSTAT:
566 #endif
567 case C_HIDDEN:
568 if (type == T_NULL) {
569 PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
570 PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
571 PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
572 return sizeof (AUXENT);
573 }
574 break;
575 }
576
577 bfd_h_put_32(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
578 #ifndef NO_TVNDX
579 bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
580 #endif
581
582 if (class == C_BLOCK || ISFCN (type) || ISTAG (class))
583 {
584 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
585 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
586 }
587 else
588 {
589 #if DIMNUM != E_DIMNUM
590 #error we need to cope with truncating or extending DIMNUM
591 #endif
592 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
593 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
594 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
595 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
596 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
597 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
598 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
599 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
600 }
601
602 if (ISFCN (type))
603 bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
604 (bfd_byte *) ext->x_sym.x_misc.x_fsize);
605 else
606 {
607 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
608 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
609 }
610
611 return sizeof(AUXENT);
612 }
613
614
615 static void
616 coff_swap_lineno_in (abfd, ext1, in1)
617 bfd *abfd;
618 PTR ext1;
619 PTR in1;
620 {
621 LINENO *ext = (LINENO *)ext1;
622 struct internal_lineno *in = (struct internal_lineno *)in1;
623
624 in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
625 in->l_lnno = GET_LINENO_LNNO(abfd, ext);
626 }
627
628 static unsigned int
629 coff_swap_lineno_out (abfd, inp, outp)
630 bfd *abfd;
631 PTR inp;
632 PTR outp;
633 {
634 struct internal_lineno *in = (struct internal_lineno *)inp;
635 struct external_lineno *ext = (struct external_lineno *)outp;
636 bfd_h_put_32(abfd, in->l_addr.l_symndx, (bfd_byte *)
637 ext->l_addr.l_symndx);
638
639 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
640 return sizeof(struct external_lineno);
641 }
642
643
644
645 static void
646 coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
647 bfd *abfd;
648 PTR aouthdr_ext1;
649 PTR aouthdr_int1;
650 {
651 struct internal_extra_pe_aouthdr *a;
652 PEAOUTHDR *src = (PEAOUTHDR *)(aouthdr_ext1);
653 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
654 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
655
656 aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
657 aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
658 aouthdr_int->tsize =
659 GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
660 aouthdr_int->dsize =
661 GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
662 aouthdr_int->bsize =
663 GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
664 aouthdr_int->entry =
665 GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
666 aouthdr_int->text_start =
667 GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
668 aouthdr_int->data_start =
669 GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
670
671 a = &aouthdr_int->pe;
672 a->ImageBase = bfd_h_get_32 (abfd, src->ImageBase);
673 a->SectionAlignment = bfd_h_get_32 (abfd, src->SectionAlignment);
674 a->FileAlignment = bfd_h_get_32 (abfd, src->FileAlignment);
675 a->MajorOperatingSystemVersion =
676 bfd_h_get_16 (abfd, src->MajorOperatingSystemVersion);
677 a->MinorOperatingSystemVersion =
678 bfd_h_get_16 (abfd, src->MinorOperatingSystemVersion);
679 a->MajorImageVersion = bfd_h_get_16 (abfd, src->MajorImageVersion);
680 a->MinorImageVersion = bfd_h_get_16 (abfd, src->MinorImageVersion);
681 a->MajorSubsystemVersion = bfd_h_get_16 (abfd, src->MajorSubsystemVersion);
682 a->MinorSubsystemVersion = bfd_h_get_16 (abfd, src->MinorSubsystemVersion);
683 a->Reserved1 = bfd_h_get_32 (abfd, src->Reserved1);
684 a->SizeOfImage = bfd_h_get_32 (abfd, src->SizeOfImage);
685 a->SizeOfHeaders = bfd_h_get_32 (abfd, src->SizeOfHeaders);
686 a->CheckSum = bfd_h_get_32 (abfd, src->CheckSum);
687 a->Subsystem = bfd_h_get_16 (abfd, src->Subsystem);
688 a->DllCharacteristics = bfd_h_get_16 (abfd, src->DllCharacteristics);
689 a->SizeOfStackReserve = bfd_h_get_32 (abfd, src->SizeOfStackReserve);
690 a->SizeOfStackCommit = bfd_h_get_32 (abfd, src->SizeOfStackCommit);
691 a->SizeOfHeapReserve = bfd_h_get_32 (abfd, src->SizeOfHeapReserve);
692 a->SizeOfHeapCommit = bfd_h_get_32 (abfd, src->SizeOfHeapCommit);
693 a->LoaderFlags = bfd_h_get_32 (abfd, src->LoaderFlags);
694 a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, src->NumberOfRvaAndSizes);
695
696 {
697 int idx;
698 for (idx=0; idx < 16; idx++)
699 {
700 a->DataDirectory[idx].VirtualAddress =
701 bfd_h_get_32 (abfd, src->DataDirectory[idx][0]);
702 a->DataDirectory[idx].Size =
703 bfd_h_get_32 (abfd, src->DataDirectory[idx][1]);
704 }
705 }
706
707 if (aouthdr_int->entry)
708 aouthdr_int->entry += a->ImageBase;
709 if (aouthdr_int->tsize)
710 aouthdr_int->text_start += a->ImageBase;
711 if (aouthdr_int->dsize)
712 aouthdr_int->data_start += a->ImageBase;
713 }
714
715
716 static void add_data_entry (abfd, aout, idx, name, base)
717 bfd *abfd;
718 struct internal_extra_pe_aouthdr *aout;
719 int idx;
720 char *name;
721 bfd_vma base;
722 {
723 asection *sec = bfd_get_section_by_name (abfd, name);
724
725 /* add import directory information if it exists */
726 if (sec != NULL)
727 {
728 aout->DataDirectory[idx].VirtualAddress = sec->lma - base;
729 aout->DataDirectory[idx].Size = sec->_raw_size;
730 sec->flags |= SEC_DATA;
731 }
732 }
733
734
735 static unsigned int
736 coff_swap_aouthdr_out (abfd, in, out)
737 bfd *abfd;
738 PTR in;
739 PTR out;
740 {
741 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
742 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
743 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
744
745 bfd_vma sa = extra->SectionAlignment;
746 bfd_vma fa = extra->FileAlignment;
747 bfd_vma ib = extra->ImageBase ;
748
749 if (aouthdr_in->tsize)
750 aouthdr_in->text_start -= ib;
751 if (aouthdr_in->dsize)
752 aouthdr_in->data_start -= ib;
753 if (aouthdr_in->entry)
754 aouthdr_in->entry -= ib;
755
756 #define FA(x) (((x) + fa -1 ) & (- fa))
757 #define SA(x) (((x) + sa -1 ) & (- sa))
758
759 /* We like to have the sizes aligned */
760
761 aouthdr_in->bsize = FA (aouthdr_in->bsize);
762
763
764 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
765
766 /* first null out all data directory entries .. */
767 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
768
769 add_data_entry (abfd, extra, 0, ".edata", ib);
770 add_data_entry (abfd, extra, 1, ".idata", ib);
771 add_data_entry (abfd, extra, 2, ".rsrc" ,ib);
772 add_data_entry (abfd, extra, 5, ".reloc", ib);
773 {
774 asection *sec;
775 bfd_vma dsize= 0;
776 bfd_vma isize = SA(abfd->sections->filepos);
777 bfd_vma tsize= 0;
778 for (sec = abfd->sections; sec; sec = sec->next)
779 {
780 int rounded = FA(sec->_raw_size);
781 if (sec->flags & SEC_DATA)
782 dsize += rounded;
783 if (sec->flags & SEC_CODE)
784 tsize += rounded;
785 isize += SA(rounded);
786 }
787
788 aouthdr_in->dsize = dsize;
789 aouthdr_in->tsize = tsize;
790 extra->SizeOfImage = isize;
791 }
792
793 extra->SizeOfHeaders = abfd->sections->filepos;
794 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
795 bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->standard.vstamp);
796 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
797 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
798 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
799 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
800 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
801 (bfd_byte *) aouthdr_out->standard.text_start);
802 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
803 (bfd_byte *) aouthdr_out->standard.data_start);
804
805
806 bfd_h_put_32 (abfd, extra->ImageBase,
807 (bfd_byte *) aouthdr_out->ImageBase);
808 bfd_h_put_32 (abfd, extra->SectionAlignment,
809 (bfd_byte *) aouthdr_out->SectionAlignment);
810 bfd_h_put_32 (abfd, extra->FileAlignment,
811 (bfd_byte *) aouthdr_out->FileAlignment);
812 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
813 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
814 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
815 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
816 bfd_h_put_16 (abfd, extra->MajorImageVersion,
817 (bfd_byte *) aouthdr_out->MajorImageVersion);
818 bfd_h_put_16 (abfd, extra->MinorImageVersion,
819 (bfd_byte *) aouthdr_out->MinorImageVersion);
820 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
821 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
822 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
823 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
824 bfd_h_put_32 (abfd, extra->Reserved1,
825 (bfd_byte *) aouthdr_out->Reserved1);
826 bfd_h_put_32 (abfd, extra->SizeOfImage,
827 (bfd_byte *) aouthdr_out->SizeOfImage);
828 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
829 (bfd_byte *) aouthdr_out->SizeOfHeaders);
830 bfd_h_put_32 (abfd, extra->CheckSum,
831 (bfd_byte *) aouthdr_out->CheckSum);
832 bfd_h_put_16 (abfd, extra->Subsystem,
833 (bfd_byte *) aouthdr_out->Subsystem);
834 bfd_h_put_16 (abfd, extra->DllCharacteristics,
835 (bfd_byte *) aouthdr_out->DllCharacteristics);
836 bfd_h_put_32 (abfd, extra->SizeOfStackReserve,
837 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
838 bfd_h_put_32 (abfd, extra->SizeOfStackCommit,
839 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
840 bfd_h_put_32 (abfd, extra->SizeOfHeapReserve,
841 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
842 bfd_h_put_32 (abfd, extra->SizeOfHeapCommit,
843 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
844 bfd_h_put_32 (abfd, extra->LoaderFlags,
845 (bfd_byte *) aouthdr_out->LoaderFlags);
846 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
847 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
848 {
849 int idx;
850 for (idx=0; idx < 16; idx++)
851 {
852 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
853 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
854 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
855 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
856 }
857 }
858
859
860 return sizeof(AOUTHDR);
861 }
862
863 static void
864 coff_swap_scnhdr_in (abfd, ext, in)
865 bfd *abfd;
866 PTR ext;
867 PTR in;
868 {
869 SCNHDR *scnhdr_ext = (SCNHDR *) ext;
870 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
871
872 memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
873 scnhdr_int->s_vaddr =
874 GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
875 scnhdr_int->s_paddr =
876 GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
877 scnhdr_int->s_size =
878 GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
879 scnhdr_int->s_scnptr =
880 GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
881 scnhdr_int->s_relptr =
882 GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
883 scnhdr_int->s_lnnoptr =
884 GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
885 scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
886
887 scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
888 scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
889
890 if (scnhdr_int->s_vaddr != 0)
891 {
892 scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
893 }
894 }
895
896 static unsigned int
897 coff_swap_scnhdr_out (abfd, in, out)
898 bfd *abfd;
899 PTR in;
900 PTR out;
901 {
902 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
903 SCNHDR *scnhdr_ext = (SCNHDR *)out;
904 unsigned int ret = sizeof (SCNHDR);
905 bfd_vma s;
906
907 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
908
909
910 PUT_SCNHDR_VADDR (abfd,
911 (scnhdr_int->s_vaddr
912 - pe_data(abfd)->pe_opthdr.ImageBase),
913 (bfd_byte *) scnhdr_ext->s_vaddr);
914
915 /* Note that we're really stuffing in the raw size into here. */
916
917
918 PUT_SCNHDR_SIZE (abfd, scnhdr_int->s_size,
919 (bfd_byte *) scnhdr_ext->s_size);
920
921 /* NT wants the size data to be rounded up to the next NT_FILE_ALIGNMENT
922 value except for the BSS section, its s_size should be 0 */
923
924 if (strcmp (scnhdr_int->s_name, _BSS) == 0)
925 s = 0;
926 else
927 s = scnhdr_int->s_paddr;
928
929 PUT_SCNHDR_PADDR (abfd, s, (bfd_byte *) scnhdr_ext->s_paddr);
930
931 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
932 (bfd_byte *) scnhdr_ext->s_scnptr);
933 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
934 (bfd_byte *) scnhdr_ext->s_relptr);
935 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
936 (bfd_byte *) scnhdr_ext->s_lnnoptr);
937
938 /* Extra flags must be set when dealing with NT. All sections should also
939 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
940 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
941 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
942 (this is especially important when dealing with the .idata section since
943 the addresses for routines from .dlls must be overwritten). If .reloc
944 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
945 (0x02000000). Also, the resource data should also be read and
946 writable. */
947 {
948 int flags = scnhdr_int->s_flags;
949 if (strcmp (scnhdr_int->s_name, ".data") == 0 ||
950 strcmp (scnhdr_int->s_name, ".CRT") == 0 ||
951 strcmp (scnhdr_int->s_name, ".rsrc") == 0 ||
952 strcmp (scnhdr_int->s_name, ".bss") == 0)
953 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
954 else if (strcmp (scnhdr_int->s_name, ".text") == 0)
955 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
956 else if (strcmp (scnhdr_int->s_name, ".reloc") == 0)
957 flags = SEC_DATA| IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE;
958 else if (strcmp (scnhdr_int->s_name, ".idata") == 0)
959 flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | SEC_DATA;
960 else if (strcmp (scnhdr_int->s_name, ".rdata") == 0
961 || strcmp (scnhdr_int->s_name, ".edata") == 0)
962 flags = IMAGE_SCN_MEM_READ | SEC_DATA;
963
964 bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
965 }
966
967 if (scnhdr_int->s_nlnno <= 0xffff)
968 bfd_h_put_16(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
969 else
970 {
971 (*_bfd_error_handler) ("%s: line number overflow: 0x%lx > 0xffff",
972 bfd_get_filename (abfd),
973 scnhdr_int->s_nlnno);
974 bfd_set_error (bfd_error_file_truncated);
975 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
976 ret = 0;
977 }
978 if (scnhdr_int->s_nreloc <= 0xffff)
979 bfd_h_put_16(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
980 else
981 {
982 (*_bfd_error_handler) ("%s: reloc overflow: 0x%lx > 0xffff",
983 bfd_get_filename (abfd),
984 scnhdr_int->s_nreloc);
985 bfd_set_error (bfd_error_file_truncated);
986 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
987 ret = 0;
988 }
989 return ret;
990 }
991 /**********************************************************************/
992 static boolean
993 pe_print_private_bfd_data (abfd, vfile)
994 bfd*abfd;
995 void *vfile;
996 {
997 FILE *file = vfile;
998 int j;
999 pe_data_type *pe = pe_data (abfd);
1000 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1001 fprintf (file,"ImageBase\t\t");
1002 fprintf_vma (file, i->ImageBase);
1003 fprintf (file,"SectionAlignment\t");
1004 fprintf_vma (file, i->SectionAlignment);
1005 fprintf (file,"FileAlignment\t\t");
1006 fprintf_vma (file, i->FileAlignment);
1007 fprintf (file,"MajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1008 fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1009 fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1010 fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1011 fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1012 fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1013 fprintf (file,"Reserved1\t\t%08lx\n", i->Reserved1);
1014 fprintf (file,"SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1015 fprintf (file,"SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1016 fprintf (file,"CheckSum\t\t%08lx\n", i->CheckSum);
1017 fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem);
1018 fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics);
1019 fprintf (file,"SizeOfStackReserve\t");
1020 fprintf_vma (file, i->SizeOfStackReserve);
1021 fprintf (file,"SizeOfStackCommit\t");
1022 fprintf_vma (file, i->SizeOfStackCommit);
1023 fprintf (file,"SizeOfHeapReserve\t");
1024 fprintf_vma (file, i->SizeOfHeapReserve);
1025 fprintf (file,"SizeOfHeapCommit\t");
1026 fprintf_vma (file, i->SizeOfHeapCommit);
1027 fprintf (file,"LoaderFlags\t\t%08lx\n", i->LoaderFlags);
1028 fprintf (file,"NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1029
1030 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1031 {
1032 fprintf (file, "Entry %2d ", j);
1033 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1034 fprintf (file, " %08lx\n", i->DataDirectory[j].Size);
1035 }
1036
1037 return true;
1038 }
1039
1040 static boolean
1041 pe_mkobject (abfd)
1042 bfd * abfd;
1043 {
1044 pe_data_type *pe;
1045
1046 abfd->tdata.pe_obj_data =
1047 (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
1048 if (abfd->tdata.pe_obj_data == 0)
1049 {
1050 bfd_set_error (bfd_error_no_memory);
1051 return false;
1052 }
1053 pe =pe_data (abfd);
1054 pe->coff.pe = 1;
1055 return true;
1056 }
1057
1058 /* Create the COFF backend specific information. */
1059 static PTR
1060 pe_mkobject_hook (abfd, filehdr, aouthdr)
1061 bfd * abfd;
1062 PTR filehdr;
1063 PTR aouthdr;
1064 {
1065 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1066 pe_data_type *pe;
1067
1068 if (pe_mkobject (abfd) == false)
1069 return NULL;
1070
1071 pe = pe_data (abfd);
1072
1073 pe->coff.sym_filepos = internal_f->f_symptr;
1074
1075 /* These members communicate important constants about the symbol
1076 table to GDB's symbol-reading code. These `constants'
1077 unfortunately vary among coff implementations... */
1078 pe->coff.local_n_btmask = N_BTMASK;
1079 pe->coff.local_n_btshft = N_BTSHFT;
1080 pe->coff.local_n_tmask = N_TMASK;
1081 pe->coff.local_n_tshift = N_TSHIFT;
1082 pe->coff.local_symesz = SYMESZ;
1083 pe->coff.local_auxesz = AUXESZ;
1084 pe->coff.local_linesz = LINESZ;
1085
1086 obj_raw_syment_count (abfd) =
1087 obj_conv_table_size (abfd) =
1088 internal_f->f_nsyms;
1089
1090 pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe;
1091 return (PTR) pe;
1092 }
1093
1094
1095
1096