projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* dep-in.sed: Remove config.h from generated dependencies.
[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 }
ae115e51
ILT		 707
708 if (aouthdr_int->entry)
709 aouthdr_int->entry += a->ImageBase;
710 if (aouthdr_int->tsize)
711 aouthdr_int->text_start += a->ImageBase;
712 if (aouthdr_int->dsize)
713 aouthdr_int->data_start += a->ImageBase;
4e98461f
SC		 714}
715
716
717static void add_data_entry (abfd, aout, idx, name, base)
718 bfd *abfd;
719 struct internal_extra_pe_aouthdr *aout;
720 int idx;
721 char *name;
722 bfd_vma base;
723{
724 asection *sec = bfd_get_section_by_name (abfd, name);
725
726 /* add import directory information if it exists */
727 if (sec != NULL)
728 {
729 aout->DataDirectory[idx].VirtualAddress = sec->lma - base;
730 aout->DataDirectory[idx].Size = sec->_raw_size;
731 sec->flags |= SEC_DATA;
732 }
733}
734
735
736static unsigned int
737coff_swap_aouthdr_out (abfd, in, out)
738 bfd *abfd;
739 PTR in;
740 PTR out;
741{
742 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
743 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
744 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
745
746 bfd_vma sa = extra->SectionAlignment;
747 bfd_vma fa = extra->FileAlignment;
748 bfd_vma ib = extra->ImageBase ;
749
750 if (aouthdr_in->tsize)
751 aouthdr_in->text_start -= ib;
752 if (aouthdr_in->dsize)
753 aouthdr_in->data_start -= ib;
754 if (aouthdr_in->entry)
755 aouthdr_in->entry -= ib;
756
757#define FA(x) (((x) + fa -1 ) & (- fa))
758#define SA(x) (((x) + sa -1 ) & (- sa))
759
760 /* We like to have the sizes aligned */
761
762 aouthdr_in->bsize = FA (aouthdr_in->bsize);
763
764
765 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
766
767 /* first null out all data directory entries .. */
768 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
769
770 add_data_entry (abfd, extra, 0, ".edata", ib);
771 add_data_entry (abfd, extra, 1, ".idata", ib);
772 add_data_entry (abfd, extra, 2, ".rsrc" ,ib);
773 add_data_entry (abfd, extra, 5, ".reloc", ib);
774 {
775 asection *sec;
776 bfd_vma dsize= 0;
777 bfd_vma isize = SA(abfd->sections->filepos);
778 bfd_vma tsize= 0;
779 for (sec = abfd->sections; sec; sec = sec->next)
780 {
781 int rounded = FA(sec->_raw_size);
782 if (sec->flags & SEC_DATA)
783 dsize += rounded;
784 if (sec->flags & SEC_CODE)
785 tsize += rounded;
786 isize += SA(rounded);
787 }
788
789 aouthdr_in->dsize = dsize;
790 aouthdr_in->tsize = tsize;
791 extra->SizeOfImage = isize;
792 }
793
794 extra->SizeOfHeaders = abfd->sections->filepos;
795 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
796 bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->standard.vstamp);
797 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
798 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
799 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
800 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
801 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
802 (bfd_byte *) aouthdr_out->standard.text_start);
803 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
804 (bfd_byte *) aouthdr_out->standard.data_start);
805
806
807 bfd_h_put_32 (abfd, extra->ImageBase,
808 (bfd_byte *) aouthdr_out->ImageBase);
809 bfd_h_put_32 (abfd, extra->SectionAlignment,
810 (bfd_byte *) aouthdr_out->SectionAlignment);
811 bfd_h_put_32 (abfd, extra->FileAlignment,
812 (bfd_byte *) aouthdr_out->FileAlignment);
813 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
814 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
815 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
816 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
817 bfd_h_put_16 (abfd, extra->MajorImageVersion,
818 (bfd_byte *) aouthdr_out->MajorImageVersion);
819 bfd_h_put_16 (abfd, extra->MinorImageVersion,
820 (bfd_byte *) aouthdr_out->MinorImageVersion);
821 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
822 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
823 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
824 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
825 bfd_h_put_32 (abfd, extra->Reserved1,
826 (bfd_byte *) aouthdr_out->Reserved1);
827 bfd_h_put_32 (abfd, extra->SizeOfImage,
828 (bfd_byte *) aouthdr_out->SizeOfImage);
829 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
830 (bfd_byte *) aouthdr_out->SizeOfHeaders);
831 bfd_h_put_32 (abfd, extra->CheckSum,
832 (bfd_byte *) aouthdr_out->CheckSum);
833 bfd_h_put_16 (abfd, extra->Subsystem,
834 (bfd_byte *) aouthdr_out->Subsystem);
835 bfd_h_put_16 (abfd, extra->DllCharacteristics,
836 (bfd_byte *) aouthdr_out->DllCharacteristics);
837 bfd_h_put_32 (abfd, extra->SizeOfStackReserve,
838 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
839 bfd_h_put_32 (abfd, extra->SizeOfStackCommit,
840 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
841 bfd_h_put_32 (abfd, extra->SizeOfHeapReserve,
842 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
843 bfd_h_put_32 (abfd, extra->SizeOfHeapCommit,
844 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
845 bfd_h_put_32 (abfd, extra->LoaderFlags,
846 (bfd_byte *) aouthdr_out->LoaderFlags);
847 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
848 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
849 {
850 int idx;
851 for (idx=0; idx < 16; idx++)
852 {
853 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
854 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
855 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
856 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
857 }
858 }
859
860
861 return sizeof(AOUTHDR);
862}
863
864static void
865 coff_swap_scnhdr_in (abfd, ext, in)
866 bfd *abfd;
867 PTR ext;
868 PTR in;
869{
870 SCNHDR *scnhdr_ext = (SCNHDR *) ext;
871 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
872
873 memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
874 scnhdr_int->s_vaddr =
875 GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
876 scnhdr_int->s_paddr =
877 GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
878 scnhdr_int->s_size =
879 GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
880
881 scnhdr_int->s_scnptr =
882 GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
883 scnhdr_int->s_relptr =
884 GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
885 scnhdr_int->s_lnnoptr =
886 GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
887 scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
888
889 scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
890 scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
891
892 if (scnhdr_int->s_vaddr != 0)
893 {
894 scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
895 }
896}
897
898static unsigned int
899 coff_swap_scnhdr_out (abfd, in, out)
900bfd *abfd;
901PTR in;
902PTR out;
903{
904 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
905 SCNHDR *scnhdr_ext = (SCNHDR *)out;
906 unsigned int ret = sizeof (SCNHDR);
907
908 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
909
910
911 PUT_SCNHDR_VADDR (abfd,
912 (scnhdr_int->s_vaddr
913 - pe_data(abfd)->pe_opthdr.ImageBase),
914 (bfd_byte *) scnhdr_ext->s_vaddr);
915
916 /* NT wants the physical address data to be the size (s_size data) of
917 the section */
918 PUT_SCNHDR_PADDR (abfd, scnhdr_int->s_size,
919 (bfd_byte *) scnhdr_ext->s_paddr);
920 /* NT wants the size data to be rounded up to the next NT_FILE_ALIGNMENT
921 value except for the BSS section, its s_size should be 0 */
922 if (strcmp (scnhdr_int->s_name, _BSS) == 0)
923 PUT_SCNHDR_SIZE (abfd, 0, (bfd_byte *) scnhdr_ext->s_size);
924 else
925 {
926 bfd_vma rounded_size;
927 rounded_size = ((scnhdr_int->s_size + NT_FILE_ALIGNMENT - 1) /
928 NT_FILE_ALIGNMENT) *
929 NT_FILE_ALIGNMENT;
930 PUT_SCNHDR_SIZE (abfd, rounded_size, (bfd_byte *) scnhdr_ext->s_size);
931 }
932
933 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
934 (bfd_byte *) scnhdr_ext->s_scnptr);
935 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
936 (bfd_byte *) scnhdr_ext->s_relptr);
937 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
938 (bfd_byte *) scnhdr_ext->s_lnnoptr);
939
940 /* Extra flags must be set when dealing with NT. All sections should also
941 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
942 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
943 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
944 (this is especially important when dealing with the .idata section since
945 the addresses for routines from .dlls must be overwritten). If .reloc
946 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
947 (0x02000000). Also, the resource data should also be read and
948 writable. */
949 {
950 int flags = scnhdr_int->s_flags;
951 if (strcmp (scnhdr_int->s_name, ".data") == 0 ||
952 strcmp (scnhdr_int->s_name, ".CRT") == 0 ||
953 strcmp (scnhdr_int->s_name, ".rsrc") == 0 ||
954 strcmp (scnhdr_int->s_name, ".bss") == 0)
955 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
956 else if (strcmp (scnhdr_int->s_name, ".text") == 0)
957 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
958 else if (strcmp (scnhdr_int->s_name, ".reloc") == 0)
959 flags = SEC_DATA| IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE;
960 else if (strcmp (scnhdr_int->s_name, ".idata") == 0)
961 flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | SEC_DATA;
962 else if (strcmp (scnhdr_int->s_name, ".rdata") == 0
963 || strcmp (scnhdr_int->s_name, ".edata") == 0)
964 flags = IMAGE_SCN_MEM_READ | SEC_DATA;
965
966 bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
967 }
968
969 if (scnhdr_int->s_nlnno <= 0xffff)
970 bfd_h_put_16(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
971 else
972 {
973 (*_bfd_error_handler) ("%s: line number overflow: 0x%lx > 0xffff",
974 bfd_get_filename (abfd),
975 scnhdr_int->s_nlnno);
976 bfd_set_error (bfd_error_file_truncated);
977 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
978 ret = 0;
979 }
980 if (scnhdr_int->s_nreloc <= 0xffff)
981 bfd_h_put_16(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
982 else
983 {
984 (*_bfd_error_handler) ("%s: reloc overflow: 0x%lx > 0xffff",
985 bfd_get_filename (abfd),
986 scnhdr_int->s_nreloc);
987 bfd_set_error (bfd_error_file_truncated);
988 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
989 ret = 0;
990 }
991 return ret;
992}
993/**********************************************************************/
994static boolean
995pe_print_private_bfd_data (abfd, vfile)
996 bfd*abfd;
997 void *vfile;
998{
999 FILE *file = vfile;
1000 int j;
1001 pe_data_type *pe = pe_data (abfd);
1002 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
ae115e51
ILT		 1003 fprintf (file,"ImageBase\t\t");
1004 fprintf_vma (file, i->ImageBase);
1005 fprintf (file,"SectionAlignment\t");
1006 fprintf_vma (file, i->SectionAlignment);
1007 fprintf (file,"FileAlignment\t\t");
1008 fprintf_vma (file, i->FileAlignment);
4e98461f
SC		 1009 fprintf (file,"MajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1010 fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1011 fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1012 fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1013 fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1014 fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
ae115e51
ILT		 1015 fprintf (file,"Reserved1\t\t%08lx\n", i->Reserved1);
1016 fprintf (file,"SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1017 fprintf (file,"SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1018 fprintf (file,"CheckSum\t\t%08lx\n", i->CheckSum);
4e98461f
SC		 1019 fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem);
1020 fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics);
ae115e51
ILT		 1021 fprintf (file,"SizeOfStackReserve\t");
1022 fprintf_vma (file, i->SizeOfStackReserve);
1023 fprintf (file,"SizeOfStackCommit\t");
1024 fprintf_vma (file, i->SizeOfStackCommit);
1025 fprintf (file,"SizeOfHeapReserve\t");
1026 fprintf_vma (file, i->SizeOfHeapReserve);
1027 fprintf (file,"SizeOfHeapCommit\t");
1028 fprintf_vma (file, i->SizeOfHeapCommit);
1029 fprintf (file,"LoaderFlags\t\t%08lx\n", i->LoaderFlags);
1030 fprintf (file,"NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
4e98461f
SC		 1031
1032 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1033 {
ae115e51
ILT		 1034 fprintf (file, "Entry %2d ", j);
1035 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1036 fprintf (file, " %08lx\n", i->DataDirectory[j].Size);
4e98461f 1037 }
ae115e51
ILT		 1038
1039 return true;
4e98461f
SC		 1040}
1041
1042static boolean
1043pe_mkobject (abfd)
1044 bfd * abfd;
1045{
1046 pe_data_type *pe;
1047
1048 abfd->tdata.pe_obj_data =
1049 (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
1050 if (abfd->tdata.pe_obj_data == 0)
1051 {
1052 bfd_set_error (bfd_error_no_memory);
1053 return false;
1054 }
1055 pe =pe_data (abfd);
1056 pe->coff.pe = 1;
1057 return true;
1058}
1059
1060/* Create the COFF backend specific information. */
1061static PTR
1062pe_mkobject_hook (abfd, filehdr, aouthdr)
1063 bfd * abfd;
1064 PTR filehdr;
1065 PTR aouthdr;
1066{
1067 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1068 pe_data_type *pe;
1069
1070 if (pe_mkobject (abfd) == false)
1071 return NULL;
1072
1073 pe = pe_data (abfd);
1074
1075 pe->coff.sym_filepos = internal_f->f_symptr;
1076
1077 /* These members communicate important constants about the symbol
1078 table to GDB's symbol-reading code. These `constants'
1079 unfortunately vary among coff implementations... */
1080 pe->coff.local_n_btmask = N_BTMASK;
1081 pe->coff.local_n_btshft = N_BTSHFT;
1082 pe->coff.local_n_tmask = N_TMASK;
1083 pe->coff.local_n_tshift = N_TSHIFT;
1084 pe->coff.local_symesz = SYMESZ;
1085 pe->coff.local_auxesz = AUXESZ;
1086 pe->coff.local_linesz = LINESZ;
1087
1088 obj_raw_syment_count (abfd) =
1089 obj_conv_table_size (abfd) =
1090 internal_f->f_nsyms;
1091
1092 pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe;
1093 return (PTR) pe;
1094}
1095
1096
1097
1098
GDB Binutils - Deliverables
This page took 0.063846 seconds and 4 git commands to generate.