projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* internal.h (struct internal_syment): Change n_numaux field from
[deliverable/binutils-gdb.git] / bfd / peicode.h
CommitLineData
4e98461f
SC		 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
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21/*
22Most of this hacked by Steve Chamberlain,
23 sac@cygnus.com
24*/
25
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
172static void
173coff_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
194static unsigned int
195coff_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
220static void
221coff_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
238static unsigned int
239coff_swap_filehdr_out (abfd, in, out)
240 bfd *abfd;
241 PTR in;
242 PTR out;
243{
244 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
245 FILHDR *filehdr_out = (FILHDR *)out;
246
247 if (bfd_get_section_by_name (abfd, ".reloc"))
248 filehdr_in->f_flags &= ~F_RELFLG;
249
250 if (pe_data (abfd)->dll)
251 filehdr_in->f_flags |= F_DLL;
252
253 filehdr_in->pe.e_magic = DOSMAGIC;
254 filehdr_in->pe.e_cblp = 0x90;
255 filehdr_in->pe.e_cp = 0x3;
256 filehdr_in->pe.e_crlc = 0x0;
257 filehdr_in->pe.e_cparhdr = 0x4;
258 filehdr_in->pe.e_minalloc = 0x0;
259 filehdr_in->pe.e_maxalloc = 0xffff;
260 filehdr_in->pe.e_ss = 0x0;
261 filehdr_in->pe.e_sp = 0xb8;
262 filehdr_in->pe.e_csum = 0x0;
263 filehdr_in->pe.e_ip = 0x0;
264 filehdr_in->pe.e_cs = 0x0;
265 filehdr_in->pe.e_lfarlc = 0x40;
266 filehdr_in->pe.e_ovno = 0x0;
267 {
268 int idx;
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 int idx;
276 for (idx=0; idx < 10; idx++)
277 filehdr_in->pe.e_res2[idx] = 0x0;
278 }
279 filehdr_in->pe.e_lfanew = 0x80;
280
281 /* this next collection of data are mostly just characters. It appears
282 to be constant within the headers put on NT exes */
283 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
284 filehdr_in->pe.dos_message[1] = 0xcd09b400;
285 filehdr_in->pe.dos_message[2] = 0x4c01b821;
286 filehdr_in->pe.dos_message[3] = 0x685421cd;
287 filehdr_in->pe.dos_message[4] = 0x70207369;
288 filehdr_in->pe.dos_message[5] = 0x72676f72;
289 filehdr_in->pe.dos_message[6] = 0x63206d61;
290 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
291 filehdr_in->pe.dos_message[8] = 0x65622074;
292 filehdr_in->pe.dos_message[9] = 0x6e757220;
293 filehdr_in->pe.dos_message[10] = 0x206e6920;
294 filehdr_in->pe.dos_message[11] = 0x20534f44;
295 filehdr_in->pe.dos_message[12] = 0x65646f6d;
296 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
297 filehdr_in->pe.dos_message[14] = 0x24;
298 filehdr_in->pe.dos_message[15] = 0x0;
299 filehdr_in->pe.nt_signature = NT_SIGNATURE;
300
301
302
303 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
304 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
305
306 bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
307 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
308 (bfd_byte *) filehdr_out->f_symptr);
309 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
310 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
311 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
312
313
314 /* put in extra dos header stuff. This data remains essentially
315 constant, it just has to be tacked on to the beginning of all exes
316 for NT */
317 bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
318 bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
319 bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
320 bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
321 bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr,
322 (bfd_byte *) filehdr_out->e_cparhdr);
323 bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc,
324 (bfd_byte *) filehdr_out->e_minalloc);
325 bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc,
326 (bfd_byte *) filehdr_out->e_maxalloc);
327 bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
328 bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
329 bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
330 bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
331 bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
332 bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
333 bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
334 {
335 int idx;
336 for (idx=0; idx < 4; idx++)
337 bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx],
338 (bfd_byte *) filehdr_out->e_res[idx]);
339 }
340 bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
341 bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo,
342 (bfd_byte *) filehdr_out->e_oeminfo);
343 {
344 int idx;
345 for (idx=0; idx < 10; idx++)
346 bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx],
347 (bfd_byte *) filehdr_out->e_res2[idx]);
348 }
349 bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
350
351 {
352 int idx;
353 for (idx=0; idx < 16; idx++)
354 bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx],
355 (bfd_byte *) filehdr_out->dos_message[idx]);
356 }
357
358 /* also put in the NT signature */
359 bfd_h_put_32(abfd, filehdr_in->pe.nt_signature,
360 (bfd_byte *) filehdr_out->nt_signature);
361
362
363
364
365 return sizeof(FILHDR);
366}
367
368
369
370static void
371coff_swap_sym_in (abfd, ext1, in1)
372 bfd *abfd;
373 PTR ext1;
374 PTR in1;
375{
376 SYMENT *ext = (SYMENT *)ext1;
377 struct internal_syment *in = (struct internal_syment *)in1;
378
379 if( ext->e.e_name[0] == 0) {
380 in->_n._n_n._n_zeroes = 0;
381 in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
382 }
383 else {
384#if SYMNMLEN != E_SYMNMLEN
385 -> Error, we need to cope with truncating or extending SYMNMLEN!;
386#else
387 memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
388#endif
389 }
390 in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
391 in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
392 if (sizeof(ext->e_type) == 2){
393 in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
394 }
395 else {
396 in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
397 }
398 in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
399 in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
400
401 /* The section symbols for the .idata$ sections have class 68, which MS
402 documentation indicates is a section symbol. The problem is that the
403 value field in the symbol is simply a copy of the .idata section's flags
404 rather than something useful. When these symbols are encountered, change
405 the value to 0 and the section number to 1 so that they will be handled
406 somewhat correctly in the bfd code. */
407 if (in->n_sclass == 0x68) {
408 in->n_value = 0x0;
409 in->n_scnum = 1;
410 /* I have tried setting the class to 3 and using the following to set
411 the section number. This will put the address of the pointer to the
412 string kernel32.dll at addresses 0 and 0x10 off start of idata section
413 which is not correct */
414 /* if (strcmp (in->_n._n_name, ".idata$4") == 0) */
415 /* in->n_scnum = 3; */
416 /* else */
417 /* in->n_scnum = 2; */
418 }
419}
420
421static unsigned int
422coff_swap_sym_out (abfd, inp, extp)
423 bfd *abfd;
424 PTR inp;
425 PTR extp;
426{
427 struct internal_syment *in = (struct internal_syment *)inp;
428 SYMENT *ext =(SYMENT *)extp;
429 if(in->_n._n_name[0] == 0) {
430 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
431 bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
432 }
433 else {
434#if SYMNMLEN != E_SYMNMLEN
435 -> Error, we need to cope with truncating or extending SYMNMLEN!;
436#else
437 memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
438#endif
439 }
440 bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value);
441 bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum);
442 if (sizeof(ext->e_type) == 2)
443 {
444 bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type);
445 }
446 else
447 {
448 bfd_h_put_32(abfd, in->n_type , (bfd_byte *) ext->e_type);
449 }
450 bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass);
451 bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux);
452 return sizeof(SYMENT);
453}
454
455static void
456coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
457 bfd *abfd;
458 PTR ext1;
459 int type;
460 int class;
461 int indx;
462 int numaux;
463 PTR in1;
464{
465 AUXENT *ext = (AUXENT *)ext1;
466 union internal_auxent *in = (union internal_auxent *)in1;
467
468 switch (class) {
469 case C_FILE:
470 if (ext->x_file.x_fname[0] == 0) {
471 in->x_file.x_n.x_zeroes = 0;
472 in->x_file.x_n.x_offset =
473 bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
474 } else {
475#if FILNMLEN != E_FILNMLEN
476 -> Error, we need to cope with truncating or extending FILNMLEN!;
477#else
478 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
479#endif
480 }
481 return;
482
483
484 case C_STAT:
485#ifdef C_LEAFSTAT
486 case C_LEAFSTAT:
487#endif
488 case C_HIDDEN:
489 if (type == T_NULL) {
490 in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
491 in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
492 in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
493 return;
494 }
495 break;
496 }
497
498 in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
499#ifndef NO_TVNDX
500 in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
501#endif
502
503 if (class == C_BLOCK || ISFCN (type) || ISTAG (class))
504 {
505 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
506 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
507 }
508 else
509 {
510#if DIMNUM != E_DIMNUM
511 #error we need to cope with truncating or extending DIMNUM
512#endif
513 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
514 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
515 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
516 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
517 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
518 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
519 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
520 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
521 }
522
523 if (ISFCN(type)) {
524 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
525 }
526 else {
527 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
528 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
529 }
530}
531
532static unsigned int
533coff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
534 bfd *abfd;
535 PTR inp;
536 int type;
537 int class;
538 int indx;
539 int numaux;
540 PTR extp;
541{
542 union internal_auxent *in = (union internal_auxent *)inp;
543 AUXENT *ext = (AUXENT *)extp;
544
545 memset((PTR)ext, 0, AUXESZ);
546 switch (class) {
547 case C_FILE:
548 if (in->x_file.x_fname[0] == 0) {
549 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
550 bfd_h_put_32(abfd,
551 in->x_file.x_n.x_offset,
552 (bfd_byte *) ext->x_file.x_n.x_offset);
553 }
554 else {
555#if FILNMLEN != E_FILNMLEN
556 -> Error, we need to cope with truncating or extending FILNMLEN!;
557#else
558 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
559#endif
560 }
561 return sizeof (AUXENT);
562
563
564 case C_STAT:
565#ifdef C_LEAFSTAT
566 case C_LEAFSTAT:
567#endif
568 case C_HIDDEN:
569 if (type == T_NULL) {
570 PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
571 PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
572 PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
573 return sizeof (AUXENT);
574 }
575 break;
576 }
577
578 bfd_h_put_32(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
579#ifndef NO_TVNDX
580 bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
581#endif
582
583 if (class == C_BLOCK || ISFCN (type) || ISTAG (class))
584 {
585 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
586 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
587 }
588 else
589 {
590#if DIMNUM != E_DIMNUM
591 #error we need to cope with truncating or extending DIMNUM
592#endif
593 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
594 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
595 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
596 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
597 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
598 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
599 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
600 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
601 }
602
603 if (ISFCN (type))
604 bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
605 (bfd_byte *) ext->x_sym.x_misc.x_fsize);
606 else
607 {
608 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
609 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
610 }
611
612 return sizeof(AUXENT);
613}
614
615
616static void
617coff_swap_lineno_in (abfd, ext1, in1)
618 bfd *abfd;
619 PTR ext1;
620 PTR in1;
621{
622 LINENO *ext = (LINENO *)ext1;
623 struct internal_lineno *in = (struct internal_lineno *)in1;
624
625 in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
626 in->l_lnno = GET_LINENO_LNNO(abfd, ext);
627}
628
629static unsigned int
630coff_swap_lineno_out (abfd, inp, outp)
631 bfd *abfd;
632 PTR inp;
633 PTR outp;
634{
635 struct internal_lineno *in = (struct internal_lineno *)inp;
636 struct external_lineno *ext = (struct external_lineno *)outp;
637 bfd_h_put_32(abfd, in->l_addr.l_symndx, (bfd_byte *)
638 ext->l_addr.l_symndx);
639
640 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
641 return sizeof(struct external_lineno);
642}
643
644
645
646static void
647coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
648 bfd *abfd;
649 PTR aouthdr_ext1;
650 PTR aouthdr_int1;
651{
652 struct internal_extra_pe_aouthdr *a;
653 PEAOUTHDR *src = (PEAOUTHDR *)(aouthdr_ext1);
654 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
655 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
656
657 aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
658 aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
659 aouthdr_int->tsize =
660 GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
661 aouthdr_int->dsize =
662 GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
663 aouthdr_int->bsize =
664 GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
665 aouthdr_int->entry =
666 GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
667 aouthdr_int->text_start =
668 GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
669 aouthdr_int->data_start =
670 GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
671
672 a = &aouthdr_int->pe;
673 a->ImageBase = bfd_h_get_32 (abfd, src->ImageBase);
674 a->SectionAlignment = bfd_h_get_32 (abfd, src->SectionAlignment);
675 a->FileAlignment = bfd_h_get_32 (abfd, src->FileAlignment);
676 a->MajorOperatingSystemVersion =
677 bfd_h_get_16 (abfd, src->MajorOperatingSystemVersion);
678 a->MinorOperatingSystemVersion =
679 bfd_h_get_16 (abfd, src->MinorOperatingSystemVersion);
680 a->MajorImageVersion = bfd_h_get_16 (abfd, src->MajorImageVersion);
681 a->MinorImageVersion = bfd_h_get_16 (abfd, src->MinorImageVersion);
682 a->MajorSubsystemVersion = bfd_h_get_16 (abfd, src->MajorSubsystemVersion);
683 a->MinorSubsystemVersion = bfd_h_get_16 (abfd, src->MinorSubsystemVersion);
684 a->Reserved1 = bfd_h_get_32 (abfd, src->Reserved1);
685 a->SizeOfImage = bfd_h_get_32 (abfd, src->SizeOfImage);
686 a->SizeOfHeaders = bfd_h_get_32 (abfd, src->SizeOfHeaders);
687 a->CheckSum = bfd_h_get_32 (abfd, src->CheckSum);
688 a->Subsystem = bfd_h_get_16 (abfd, src->Subsystem);
689 a->DllCharacteristics = bfd_h_get_16 (abfd, src->DllCharacteristics);
690 a->SizeOfStackReserve = bfd_h_get_32 (abfd, src->SizeOfStackReserve);
691 a->SizeOfStackCommit = bfd_h_get_32 (abfd, src->SizeOfStackCommit);
692 a->SizeOfHeapReserve = bfd_h_get_32 (abfd, src->SizeOfHeapReserve);
693 a->SizeOfHeapCommit = bfd_h_get_32 (abfd, src->SizeOfHeapCommit);
694 a->LoaderFlags = bfd_h_get_32 (abfd, src->LoaderFlags);
695 a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, src->NumberOfRvaAndSizes);
696
697 {
698 int idx;
699 for (idx=0; idx < 16; idx++)
700 {
701 a->DataDirectory[idx].VirtualAddress =
702 bfd_h_get_32 (abfd, src->DataDirectory[idx][0]);
703 a->DataDirectory[idx].Size =
704 bfd_h_get_32 (abfd, src->DataDirectory[idx][1]);
705 }
706 }
707}
708
709
710static void add_data_entry (abfd, aout, idx, name, base)
711 bfd *abfd;
712 struct internal_extra_pe_aouthdr *aout;
713 int idx;
714 char *name;
715 bfd_vma base;
716{
717 asection *sec = bfd_get_section_by_name (abfd, name);
718
719 /* add import directory information if it exists */
720 if (sec != NULL)
721 {
722 aout->DataDirectory[idx].VirtualAddress = sec->lma - base;
723 aout->DataDirectory[idx].Size = sec->_raw_size;
724 sec->flags |= SEC_DATA;
725 }
726}
727
728
729static unsigned int
730coff_swap_aouthdr_out (abfd, in, out)
731 bfd *abfd;
732 PTR in;
733 PTR out;
734{
735 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
736 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
737 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
738
739 bfd_vma sa = extra->SectionAlignment;
740 bfd_vma fa = extra->FileAlignment;
741 bfd_vma ib = extra->ImageBase ;
742
743 if (aouthdr_in->tsize)
744 aouthdr_in->text_start -= ib;
745 if (aouthdr_in->dsize)
746 aouthdr_in->data_start -= ib;
747 if (aouthdr_in->entry)
748 aouthdr_in->entry -= ib;
749
750#define FA(x) (((x) + fa -1 ) & (- fa))
751#define SA(x) (((x) + sa -1 ) & (- sa))
752
753 /* We like to have the sizes aligned */
754
755 aouthdr_in->bsize = FA (aouthdr_in->bsize);
756
757
758 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
759
760 /* first null out all data directory entries .. */
761 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
762
763 add_data_entry (abfd, extra, 0, ".edata", ib);
764 add_data_entry (abfd, extra, 1, ".idata", ib);
765 add_data_entry (abfd, extra, 2, ".rsrc" ,ib);
766 add_data_entry (abfd, extra, 5, ".reloc", ib);
767 {
768 asection *sec;
769 bfd_vma dsize= 0;
770 bfd_vma isize = SA(abfd->sections->filepos);
771 bfd_vma tsize= 0;
772 for (sec = abfd->sections; sec; sec = sec->next)
773 {
774 int rounded = FA(sec->_raw_size);
775 if (sec->flags & SEC_DATA)
776 dsize += rounded;
777 if (sec->flags & SEC_CODE)
778 tsize += rounded;
779 isize += SA(rounded);
780 }
781
782 aouthdr_in->dsize = dsize;
783 aouthdr_in->tsize = tsize;
784 extra->SizeOfImage = isize;
785 }
786
787 extra->SizeOfHeaders = abfd->sections->filepos;
788 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
789 bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->standard.vstamp);
790 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
791 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
792 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
793 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
794 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
795 (bfd_byte *) aouthdr_out->standard.text_start);
796 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
797 (bfd_byte *) aouthdr_out->standard.data_start);
798
799
800 bfd_h_put_32 (abfd, extra->ImageBase,
801 (bfd_byte *) aouthdr_out->ImageBase);
802 bfd_h_put_32 (abfd, extra->SectionAlignment,
803 (bfd_byte *) aouthdr_out->SectionAlignment);
804 bfd_h_put_32 (abfd, extra->FileAlignment,
805 (bfd_byte *) aouthdr_out->FileAlignment);
806 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
807 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
808 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
809 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
810 bfd_h_put_16 (abfd, extra->MajorImageVersion,
811 (bfd_byte *) aouthdr_out->MajorImageVersion);
812 bfd_h_put_16 (abfd, extra->MinorImageVersion,
813 (bfd_byte *) aouthdr_out->MinorImageVersion);
814 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
815 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
816 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
817 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
818 bfd_h_put_32 (abfd, extra->Reserved1,
819 (bfd_byte *) aouthdr_out->Reserved1);
820 bfd_h_put_32 (abfd, extra->SizeOfImage,
821 (bfd_byte *) aouthdr_out->SizeOfImage);
822 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
823 (bfd_byte *) aouthdr_out->SizeOfHeaders);
824 bfd_h_put_32 (abfd, extra->CheckSum,
825 (bfd_byte *) aouthdr_out->CheckSum);
826 bfd_h_put_16 (abfd, extra->Subsystem,
827 (bfd_byte *) aouthdr_out->Subsystem);
828 bfd_h_put_16 (abfd, extra->DllCharacteristics,
829 (bfd_byte *) aouthdr_out->DllCharacteristics);
830 bfd_h_put_32 (abfd, extra->SizeOfStackReserve,
831 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
832 bfd_h_put_32 (abfd, extra->SizeOfStackCommit,
833 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
834 bfd_h_put_32 (abfd, extra->SizeOfHeapReserve,
835 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
836 bfd_h_put_32 (abfd, extra->SizeOfHeapCommit,
837 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
838 bfd_h_put_32 (abfd, extra->LoaderFlags,
839 (bfd_byte *) aouthdr_out->LoaderFlags);
840 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
841 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
842 {
843 int idx;
844 for (idx=0; idx < 16; idx++)
845 {
846 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
847 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
848 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
849 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
850 }
851 }
852
853
854 return sizeof(AOUTHDR);
855}
856
857static void
858 coff_swap_scnhdr_in (abfd, ext, in)
859 bfd *abfd;
860 PTR ext;
861 PTR in;
862{
863 SCNHDR *scnhdr_ext = (SCNHDR *) ext;
864 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
865
866 memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
867 scnhdr_int->s_vaddr =
868 GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
869 scnhdr_int->s_paddr =
870 GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
871 scnhdr_int->s_size =
872 GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
873
874 scnhdr_int->s_scnptr =
875 GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
876 scnhdr_int->s_relptr =
877 GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
878 scnhdr_int->s_lnnoptr =
879 GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
880 scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
881
882 scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
883 scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
884
885 if (scnhdr_int->s_vaddr != 0)
886 {
887 scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
888 }
889}
890
891static unsigned int
892 coff_swap_scnhdr_out (abfd, in, out)
893bfd *abfd;
894PTR in;
895PTR out;
896{
897 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
898 SCNHDR *scnhdr_ext = (SCNHDR *)out;
899 unsigned int ret = sizeof (SCNHDR);
900
901 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
902
903
904 PUT_SCNHDR_VADDR (abfd,
905 (scnhdr_int->s_vaddr
906 - pe_data(abfd)->pe_opthdr.ImageBase),
907 (bfd_byte *) scnhdr_ext->s_vaddr);
908
909 /* NT wants the physical address data to be the size (s_size data) of
910 the section */
911 PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_size,
912 (bfd_byte *) scnhdr_ext->s_paddr);
913 /* NT wants the size data to be rounded up to the next NT_FILE_ALIGNMENT
914 value except for the BSS section, its s_size should be 0 */
915 if (strcmp (scnhdr_int->s_name, _BSS) == 0)
916 PUT_SCNHDR_SIZE (abfd, 0, (bfd_byte *) scnhdr_ext->s_size);
917 else
918 {
919 bfd_vma rounded_size;
920 rounded_size = ((scnhdr_int->s_size + NT_FILE_ALIGNMENT - 1) /
921 NT_FILE_ALIGNMENT) *
922 NT_FILE_ALIGNMENT;
923 PUT_SCNHDR_SIZE (abfd, rounded_size, (bfd_byte *) scnhdr_ext->s_size);
924 }
925
926 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
927 (bfd_byte *) scnhdr_ext->s_scnptr);
928 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
929 (bfd_byte *) scnhdr_ext->s_relptr);
930 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
931 (bfd_byte *) scnhdr_ext->s_lnnoptr);
932
933 /* Extra flags must be set when dealing with NT. All sections should also
934 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
935 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
936 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
937 (this is especially important when dealing with the .idata section since
938 the addresses for routines from .dlls must be overwritten). If .reloc
939 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
940 (0x02000000). Also, the resource data should also be read and
941 writable. */
942 {
943 int flags = scnhdr_int->s_flags;
944 if (strcmp (scnhdr_int->s_name, ".data") == 0 ||
945 strcmp (scnhdr_int->s_name, ".CRT") == 0 ||
946 strcmp (scnhdr_int->s_name, ".rsrc") == 0 ||
947 strcmp (scnhdr_int->s_name, ".bss") == 0)
948 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
949 else if (strcmp (scnhdr_int->s_name, ".text") == 0)
950 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
951 else if (strcmp (scnhdr_int->s_name, ".reloc") == 0)
952 flags = SEC_DATA| IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE;
953 else if (strcmp (scnhdr_int->s_name, ".idata") == 0)
954 flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | SEC_DATA;
955 else if (strcmp (scnhdr_int->s_name, ".rdata") == 0
956 || strcmp (scnhdr_int->s_name, ".edata") == 0)
957 flags = IMAGE_SCN_MEM_READ | SEC_DATA;
958
959 bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
960 }
961
962 if (scnhdr_int->s_nlnno <= 0xffff)
963 bfd_h_put_16(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
964 else
965 {
966 (*_bfd_error_handler) ("%s: line number overflow: 0x%lx > 0xffff",
967 bfd_get_filename (abfd),
968 scnhdr_int->s_nlnno);
969 bfd_set_error (bfd_error_file_truncated);
970 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
971 ret = 0;
972 }
973 if (scnhdr_int->s_nreloc <= 0xffff)
974 bfd_h_put_16(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
975 else
976 {
977 (*_bfd_error_handler) ("%s: reloc overflow: 0x%lx > 0xffff",
978 bfd_get_filename (abfd),
979 scnhdr_int->s_nreloc);
980 bfd_set_error (bfd_error_file_truncated);
981 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
982 ret = 0;
983 }
984 return ret;
985}
986/**********************************************************************/
987static boolean
988pe_print_private_bfd_data (abfd, vfile)
989 bfd*abfd;
990 void *vfile;
991{
992 FILE *file = vfile;
993 int j;
994 pe_data_type *pe = pe_data (abfd);
995 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
996 fprintf (file,"ImageBase\t\t%08x\n", i->ImageBase);
997 fprintf (file,"SectionAlignment\t%08x\n", i->SectionAlignment);
998 fprintf (file,"FileAlignment\t\t%08x\n", i->FileAlignment);
999 fprintf (file,"MajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1000 fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1001 fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1002 fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1003 fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1004 fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1005 fprintf (file,"Reserved1\t\t%08x\n", i->Reserved1);
1006 fprintf (file,"SizeOfImage\t\t%08x\n", i->SizeOfImage);
1007 fprintf (file,"SizeOfHeaders\t\t%08x\n", i->SizeOfHeaders);
1008 fprintf (file,"CheckSum\t\t%08x\n", i->CheckSum);
1009 fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem);
1010 fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics);
1011 fprintf (file,"SizeOfStackReserve\t%08x\n", i->SizeOfStackReserve);
1012 fprintf (file,"SizeOfStackCommit\t%08x\n", i->SizeOfStackCommit);
1013 fprintf (file,"SizeOfHeapReserve\t%08x\n", i->SizeOfHeapReserve);
1014 fprintf (file,"SizeOfHeapCommit\t%08x\n", i->SizeOfHeapCommit);
1015 fprintf (file,"LoaderFlags\t\t%08x\n", i->LoaderFlags);
1016 fprintf (file,"NumberOfRvaAndSizes\t%08x\n", i->NumberOfRvaAndSizes);
1017
1018 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1019 {
1020 fprintf(file, "Entry %2d %08x %08x\n",
1021 j,
1022 i->DataDirectory[j].VirtualAddress,
1023 i->DataDirectory[j].Size);
1024 }
1025}
1026
1027static boolean
1028pe_mkobject (abfd)
1029 bfd * abfd;
1030{
1031 pe_data_type *pe;
1032
1033 abfd->tdata.pe_obj_data =
1034 (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
1035 if (abfd->tdata.pe_obj_data == 0)
1036 {
1037 bfd_set_error (bfd_error_no_memory);
1038 return false;
1039 }
1040 pe =pe_data (abfd);
1041 pe->coff.pe = 1;
1042 return true;
1043}
1044
1045/* Create the COFF backend specific information. */
1046static PTR
1047pe_mkobject_hook (abfd, filehdr, aouthdr)
1048 bfd * abfd;
1049 PTR filehdr;
1050 PTR aouthdr;
1051{
1052 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1053 pe_data_type *pe;
1054
1055 if (pe_mkobject (abfd) == false)
1056 return NULL;
1057
1058 pe = pe_data (abfd);
1059
1060 pe->coff.sym_filepos = internal_f->f_symptr;
1061
1062 /* These members communicate important constants about the symbol
1063 table to GDB's symbol-reading code. These `constants'
1064 unfortunately vary among coff implementations... */
1065 pe->coff.local_n_btmask = N_BTMASK;
1066 pe->coff.local_n_btshft = N_BTSHFT;
1067 pe->coff.local_n_tmask = N_TMASK;
1068 pe->coff.local_n_tshift = N_TSHIFT;
1069 pe->coff.local_symesz = SYMESZ;
1070 pe->coff.local_auxesz = AUXESZ;
1071 pe->coff.local_linesz = LINESZ;
1072
1073 obj_raw_syment_count (abfd) =
1074 obj_conv_table_size (abfd) =
1075 internal_f->f_nsyms;
1076
1077 pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe;
1078 return (PTR) pe;
1079}
1080
1081
1082
1083
GDB Binutils - Deliverables
This page took 0.065376 seconds and 4 git commands to generate.