dbghelp: Now fully reading the leafs as variant for constants.
[wine] / tools / winedump / le.c
1 /*
2  * Dumping of LE binaries
3  *
4  * Copyright 2004 Robert Reif
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <fcntl.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winedump.h"
34
35 struct o32_obj
36 {
37     unsigned long       o32_size;
38     unsigned long       o32_base;
39     unsigned long       o32_flags;
40     unsigned long       o32_pagemap;
41     unsigned long       o32_mapsize;
42     char                o32_name[4];
43 };
44
45 struct o32_map
46 {
47     unsigned short      o32_pagedataoffset;
48     unsigned char       o32_pagesize;
49     unsigned char       o32_pageflags;
50 };
51
52 struct b32_bundle
53 {
54     unsigned char       b32_cnt;
55     unsigned char       b32_type;
56 };
57
58 struct vxd_descriptor
59 {
60     unsigned long       next;
61     unsigned short      sdk_version;
62     unsigned short      device_number;
63     unsigned char       version_major;
64     unsigned char       version_minor;
65     unsigned short      flags;
66     char                name[8];
67     unsigned long       init_order;
68     unsigned long       ctrl_ofs;
69     unsigned long       v86_ctrl_ofs;
70     unsigned long       pm_ctrl_ofs;
71     unsigned long       v86_ctrl_csip;
72     unsigned long       pm_ctrl_csip;
73     unsigned long       rm_ref_data;
74     unsigned long       service_table_ofs;
75     unsigned long       service_table_size;
76     unsigned long       win32_service_table_ofs;
77     unsigned long       prev;
78     unsigned long       size;
79     unsigned long       reserved0;
80     unsigned long       reserved1;
81     unsigned long       reserved2;
82 };
83
84 static inline WORD get_word( const BYTE *ptr )
85 {
86     return ptr[0] | (ptr[1] << 8);
87 }
88
89 static void dump_le_header( const IMAGE_VXD_HEADER *le )
90 {
91     printf( "File header:\n" );
92     printf( "    Magic:                                %04x (%c%c)\n",
93             le->e32_magic, LOBYTE(le->e32_magic), HIBYTE(le->e32_magic));
94     printf( "    Byte order:                           %s\n",
95             le->e32_border == 0 ? "little-indian" : "big-endian");
96     printf( "    Word order:                           %s\n",
97             le->e32_worder ==  0 ? "little-indian" : "big-endian");
98     printf( "    Executable format level:              %d\n",
99             le->e32_level);
100     printf( "    CPU type:                             %s\n",
101             le->e32_cpu == 0x01 ? "Intel 80286" :
102             le->e32_cpu == 0x02 ? "Intel 80386" :
103             le->e32_cpu == 0x03 ? "Intel 80486" :
104             le->e32_cpu == 0x04 ? "Intel 80586" :
105             le->e32_cpu == 0x20 ? "Intel i860 (N10)" :
106             le->e32_cpu == 0x21 ? "Intel i860 (N11)" :
107             le->e32_cpu == 0x40 ? "MIPS Mark I" :
108             le->e32_cpu == 0x41 ? "MIPS Mark II" :
109             le->e32_cpu == 0x42 ? "MIPS Mark III" :
110             "Unknown");
111     printf( "    Target operating system:              %s\n",
112             le->e32_os == 0x01 ? "OS/2" :
113             le->e32_os == 0x02 ? "Windows" :
114             le->e32_os == 0x03 ? "DOS 4.x" :
115             le->e32_os == 0x04 ? "Windows 386" :
116             "Unknown");
117     printf( "    Module version:                       %d\n",
118             le->e32_ver);
119     printf( "    Module type flags:                    %08x\n",
120             le->e32_mflags);
121     if (le->e32_mflags & 0x8000)
122     {
123         if (le->e32_mflags & 0x0004)
124             printf( "        Global initialization\n");
125         else
126             printf( "        Per-Process initialization\n");
127         if (le->e32_mflags & 0x0010)
128             printf( "        No internal fixup\n");
129         if (le->e32_mflags & 0x0020)
130             printf( "        No external fixup\n");
131         if ((le->e32_mflags & 0x0700) == 0x0100)
132             printf( "        Incompatible with PM windowing\n");
133         else if ((le->e32_mflags & 0x0700) == 0x0200)
134             printf( "        Compatible with PM windowing\n");
135         else if ((le->e32_mflags & 0x0700) == 0x0300)
136             printf( "        Uses PM windowing API\n");
137         if (le->e32_mflags & 0x2000)
138             printf( "        Module not loadable\n");
139         if (le->e32_mflags & 0x8000)
140             printf( "        Module is DLL\n");
141     }
142     printf( "    Number of memory pages:               %d\n",
143             le->e32_mpages);
144     printf( "    Initial object CS number:             %08x\n",
145             le->e32_startobj);
146     printf( "    Initial EIP:                          %08x\n",
147             le->e32_eip);
148     printf( "    Initial object SS number:             %08x\n",
149             le->e32_stackobj);
150     printf( "    Initial ESP:                          %08x\n",
151             le->e32_esp);
152     printf( "    Memory page size:                     %d\n",
153             le->e32_pagesize);
154     printf( "    Bytes on last page:                   %d\n",
155             le->e32_lastpagesize);
156     printf( "    Fix-up section size:                  %d\n",
157             le->e32_fixupsize);
158     printf( "    Fix-up section checksum:              %08x\n",
159             le->e32_fixupsum);
160     printf( "    Loader section size:                  %d\n",
161             le->e32_ldrsize);
162     printf( "    Loader section checksum:              %08x\n",
163             le->e32_ldrsum);
164     printf( "    Offset of object table:               %08x\n",
165             le->e32_objtab);
166     printf( "    Object table entries:                 %d\n",
167             le->e32_objcnt);
168     printf( "    Object page map offset:               %08x\n",
169             le->e32_objmap);
170     printf( "    Object iterate data map offset:       %08x\n",
171             le->e32_itermap);
172     printf( "    Resource table offset:                %08x\n",
173             le->e32_rsrctab);
174     printf( "    Resource table entries:               %d\n",
175             le->e32_rsrccnt);
176     printf( "    Resident names table offset:          %08x\n",
177             le->e32_restab);
178     printf( "    Entry table offset:                   %08x\n",
179             le->e32_enttab);
180     printf( "    Module directives table offset:       %08x\n",
181             le->e32_dirtab);
182     printf( "    Module directives entries:            %d\n",
183             le->e32_dircnt);
184     printf( "    Fix-up page table offset:             %08x\n",
185             le->e32_fpagetab);
186     printf( "    Fix-up record table offset:           %08x\n",
187             le->e32_frectab);
188     printf( "    Imported modules name table offset:   %08x\n",
189             le->e32_impmod);
190     printf( "    Imported modules count:               %d\n",
191             le->e32_impmodcnt);
192     printf( "    Imported procedure name table offset: %08x\n",
193             le->e32_impproc);
194     printf( "    Per-page checksum table offset:       %08x\n",
195             le->e32_pagesum);
196     printf( "    Data pages offset from top of table:  %08x\n",
197             le->e32_datapage);
198     printf( "    Preload page count:                   %08x\n",
199             le->e32_preload);
200     printf( "    Non-resident names table offset:      %08x\n",
201             le->e32_nrestab);
202     printf( "    Non-resident names table length:      %d\n",
203             le->e32_cbnrestab);
204     printf( "    Non-resident names table checksum:    %08x\n",
205             le->e32_nressum);
206     printf( "    Automatic data object:                %08x\n",
207             le->e32_autodata);
208     printf( "    Debug information offset:             %08x\n",
209             le->e32_debuginfo);
210     printf( "    Debug information length:             %d\n",
211             le->e32_debuglen);
212     printf( "    Preload instance pages number:        %d\n",
213             le->e32_instpreload);
214     printf( "    Demand instance pages number:         %d\n",
215             le->e32_instdemand);
216     printf( "    Extra heap allocation:                %d\n",
217             le->e32_heapsize);
218     printf( "    VxD resource table offset:            %08x\n",
219             le->e32_winresoff);
220     printf( "    Size of VxD resource table:           %d\n",
221             le->e32_winreslen);
222     printf( "    VxD identifier:                       %x\n",
223             le->e32_devid);
224     printf( "    VxD DDK version:                      %x\n",
225             le->e32_ddkver);
226 }
227
228 static void dump_le_objects( const IMAGE_VXD_HEADER *le )
229 {
230     const struct o32_obj *pobj;
231     unsigned int i;
232
233     printf("\nObject table:\n");
234     pobj = (const struct o32_obj *)((const unsigned char *)le + le->e32_objtab);
235     for (i = 0; i < le->e32_objcnt; i++)
236     {
237         unsigned int j;
238         const struct o32_map *pmap=0;
239
240         printf("    Obj. Rel.Base Codesize Flags    Tableidx Tablesize Name\n");
241         printf("    %04X %08lx %08lx %08lx %08lx %08lx  ", i + 1,
242                pobj->o32_base, pobj->o32_size, pobj->o32_flags,
243                pobj->o32_pagemap, pobj->o32_mapsize);
244         for (j = 0; j < 4; j++)
245         {
246            if  (isprint(pobj->o32_name[j]))
247                 printf("%c", pobj->o32_name[j]);
248            else
249                 printf(".");
250         }
251         printf("\n");
252
253         if(pobj->o32_flags & 0x0001)
254             printf("\tReadable\n");
255         if(pobj->o32_flags & 0x0002)
256             printf("\tWritable\n");
257         if(pobj->o32_flags & 0x0004)
258             printf("\tExecutable\n");
259         if(pobj->o32_flags & 0x0008)
260             printf("\tResource\n");
261         if(pobj->o32_flags & 0x0010)
262             printf("\tDiscardable\n");
263         if(pobj->o32_flags & 0x0020)
264             printf("\tShared\n");
265         if(pobj->o32_flags & 0x0040)
266             printf("\tPreloaded\n");
267         if(pobj->o32_flags & 0x0080)
268             printf("\tInvalid\n");
269         if(pobj->o32_flags & 0x2000)
270             printf("\tUse 32\n");
271
272         printf("    Page tables:\n");
273         printf("        Tableidx Offset Flags\n");
274         pmap = (const struct o32_map *)((const unsigned char *)le + le->e32_objmap);
275         pmap = &(pmap[pobj->o32_pagemap - 1]);
276         for (j = 0; j < pobj->o32_mapsize; j++)
277         {
278             printf("        %08lx %06x %02x\n",
279                    pobj->o32_pagemap + j,
280                    (pmap->o32_pagedataoffset << 8) + pmap->o32_pagesize,
281                    (int)pmap->o32_pageflags);
282             pmap++;
283         }
284         pobj++;
285     }
286 }
287
288 static void dump_le_names( const IMAGE_VXD_HEADER *le )
289 {
290     const unsigned char *pstr = (const unsigned char *)le + le->e32_restab;
291
292     printf( "\nResident name table:\n" );
293     while (*pstr)
294     {
295         printf( " %4d: %*.*s\n", get_word(pstr + *pstr + 1), *pstr, *pstr,
296                 pstr + 1 );
297         pstr += *pstr + 1 + sizeof(WORD);
298     }
299     if (le->e32_cbnrestab)
300     {
301         printf( "\nNon-resident name table:\n" );
302         pstr = PRD(le->e32_nrestab, 0);
303         while (*pstr)
304         {
305             printf( " %4d: %*.*s\n", get_word(pstr + *pstr + 1), *pstr, *pstr,
306                     pstr + 1 );
307             pstr += *pstr + 1 + sizeof(WORD);
308         }
309     }
310 }
311
312 static void dump_le_resources( const IMAGE_VXD_HEADER *le )
313 {
314     printf( "\nResources:\n" );
315     printf( "    Not Implemented\n" );
316 }
317
318 static void dump_le_modules( const IMAGE_VXD_HEADER *le )
319 {
320     printf( "\nImported modulename table:\n" );
321     printf( "    Not Implemented\n" );
322 }
323
324 static void dump_le_entries( const IMAGE_VXD_HEADER *le )
325 {
326     printf( "\nEntry table:\n" );
327     printf( "    Not Implemented\n" );
328 }
329
330 static void dump_le_fixups( const IMAGE_VXD_HEADER *le )
331 {
332     printf( "\nFixup table:\n" );
333     printf( "    Not Implemented\n" );
334 }
335
336 static void dump_le_VxD( const IMAGE_VXD_HEADER *le )
337 {
338     printf( "\nVxD descriptor:\n" );
339     printf( "    Not Implemented\n" );
340 }
341
342 void le_dump( void )
343 {
344     const IMAGE_DOS_HEADER *dos;
345     const IMAGE_VXD_HEADER *le;
346
347     dos = PRD(0, sizeof(*dos));
348     if (!dos) return;
349     le = PRD(dos->e_lfanew, sizeof(*le));
350
351     dump_le_header( le );
352     dump_le_objects( le );
353     dump_le_resources( le );
354     dump_le_names( le );
355     dump_le_entries( le );
356     dump_le_modules( le );
357     dump_le_fixups( le );
358     dump_le_VxD( le );
359 }