1 /*
2 * Dumping of NE binaries
3 *
4 * Copyright 2002 Alexandre Julliard
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 "wine/winbase16.h"
34 #include "winedump.h"
35
36 struct ne_segtable_entry
37 {
38 WORD seg_data_offset; /* Sector offset of segment data */
39 WORD seg_data_length; /* Length of segment data */
40 WORD seg_flags; /* Flags associated with this segment */
41 WORD min_alloc; /* Minimum allocation size for this */
42 };
43
44 struct relocation_entry
45 {
46 BYTE address_type; /* Relocation address type */
47 BYTE relocation_type; /* Relocation type */
48 WORD offset; /* Offset in segment to fixup */
49 WORD target1; /* Target specification */
50 WORD target2; /* Target specification */
51 };
52
53 #define NE_RADDR_LOWBYTE 0
54 #define NE_RADDR_SELECTOR 2
55 #define NE_RADDR_POINTER32 3
56 #define NE_RADDR_OFFSET16 5
57 #define NE_RADDR_POINTER48 11
58 #define NE_RADDR_OFFSET32 13
59
60 #define NE_RELTYPE_INTERNAL 0
61 #define NE_RELTYPE_ORDINAL 1
62 #define NE_RELTYPE_NAME 2
63 #define NE_RELTYPE_OSFIXUP 3
64 #define NE_RELFLAG_ADDITIVE 4
65
66 static inline WORD get_word( const BYTE *ptr )
67 {
68 return ptr[0] | (ptr[1] << 8);
69 }
70
71 static void dump_ne_header( const IMAGE_OS2_HEADER *ne )
72 {
73 printf( "File header:\n" );
74 printf( "Linker version: %d.%d\n", ne->ne_ver, ne->ne_rev );
75 printf( "Entry table: %x len %d\n", ne->ne_enttab, ne->ne_cbenttab );
76 printf( "Checksum: %08x\n", ne->ne_crc );
77 printf( "Flags: %04x\n", ne->ne_flags );
78 printf( "Auto data segment: %x\n", ne->ne_autodata );
79 printf( "Heap size: %d bytes\n", ne->ne_heap );
80 printf( "Stack size: %d bytes\n", ne->ne_stack );
81 printf( "Stack pointer: %x:%04x\n", SELECTOROF(ne->ne_sssp), OFFSETOF(ne->ne_sssp) );
82 printf( "Entry point: %x:%04x\n", SELECTOROF(ne->ne_csip), OFFSETOF(ne->ne_csip) );
83 printf( "Number of segments: %d\n", ne->ne_cseg );
84 printf( "Number of modrefs: %d\n", ne->ne_cmod );
85 printf( "Segment table: %x\n", ne->ne_segtab );
86 printf( "Resource table: %x\n", ne->ne_rsrctab );
87 printf( "Resident name table: %x\n", ne->ne_restab );
88 printf( "Module table: %x\n", ne->ne_modtab );
89 printf( "Import table: %x\n", ne->ne_imptab );
90 printf( "Non-resident table: %x\n", ne->ne_nrestab );
91 printf( "Exe type: %x\n", ne->ne_exetyp );
92 printf( "Other flags: %x\n", ne->ne_flagsothers );
93 printf( "Fast load area: %x-%x\n", ne->ne_pretthunks << ne->ne_align,
94 (ne->ne_pretthunks+ne->ne_psegrefbytes) << ne->ne_align );
95 printf( "Expected version: %d.%d\n", HIBYTE(ne->ne_expver), LOBYTE(ne->ne_expver) );
96 }
97
98 static void dump_ne_names( const IMAGE_OS2_HEADER *ne )
99 {
100 const unsigned char *pstr = (const unsigned char *)ne + ne->ne_restab;
101
102 printf( "\nResident name table:\n" );
103 while (*pstr)
104 {
105 printf( " %4d: %*.*s\n", get_word(pstr + *pstr + 1), *pstr, *pstr, pstr + 1 );
106 pstr += *pstr + 1 + sizeof(WORD);
107 }
108 if (ne->ne_cbnrestab)
109 {
110 printf( "\nNon-resident name table:\n" );
111 pstr = PRD(ne->ne_nrestab, 0);
112 while (*pstr)
113 {
114 printf( " %4d: %*.*s\n", get_word(pstr + *pstr + 1), *pstr, *pstr, pstr + 1 );
115 pstr += *pstr + 1 + sizeof(WORD);
116 }
117 }
118 }
119
120 static const char *get_resource_type( WORD id )
121 {
122 static char buffer[5];
123 switch(id)
124 {
125 case NE_RSCTYPE_CURSOR: return "CURSOR";
126 case NE_RSCTYPE_BITMAP: return "BITMAP";
127 case NE_RSCTYPE_ICON: return "ICON";
128 case NE_RSCTYPE_MENU: return "MENU";
129 case NE_RSCTYPE_DIALOG: return "DIALOG";
130 case NE_RSCTYPE_STRING: return "STRING";
131 case NE_RSCTYPE_FONTDIR: return "FONTDIR";
132 case NE_RSCTYPE_FONT: return "FONT";
133 case NE_RSCTYPE_ACCELERATOR: return "ACCELERATOR";
134 case NE_RSCTYPE_RCDATA: return "RCDATA";
135 case NE_RSCTYPE_GROUP_CURSOR: return "CURSOR_GROUP";
136 case NE_RSCTYPE_GROUP_ICON: return "ICON_GROUP";
137 default:
138 sprintf( buffer, "%04x", id );
139 return buffer;
140 }
141 }
142
143 static void dump_ne_resources( const IMAGE_OS2_HEADER *ne )
144 {
145 const NE_NAMEINFO *name;
146 const void *res_ptr = (const char *)ne + ne->ne_rsrctab;
147 WORD size_shift = get_word(res_ptr);
148 const NE_TYPEINFO *info = (const NE_TYPEINFO *)((const WORD *)res_ptr + 1);
149 int count;
150
151 printf( "\nResources:\n" );
152 while (info->type_id != 0 && (const char *)info < (const char *)ne + ne->ne_restab)
153 {
154 name = (const NE_NAMEINFO *)(info + 1);
155 for (count = info->count; count > 0; count--, name++)
156 {
157 if (name->id & 0x8000) printf( " %d", (name->id & ~0x8000) );
158 else printf( " %.*s", *((const unsigned char *)res_ptr + name->id),
159 (const char *)res_ptr + name->id + 1 );
160 if (info->type_id & 0x8000) printf( " %s", get_resource_type(info->type_id) );
161 else printf( " %.*s", *((const unsigned char *)res_ptr + info->type_id),
162 (const char *)res_ptr + info->type_id + 1 );
163 printf(" flags %04x length %04x\n", name->flags, name->length << size_shift);
164 dump_data( PRD(name->offset << size_shift, name->length << size_shift),
165 name->length << size_shift, " " );
166 }
167 info = (const NE_TYPEINFO *)name;
168 }
169 }
170
171 static const char *get_export_name( const IMAGE_OS2_HEADER *ne, int ordinal )
172 {
173 static char name[256];
174 const BYTE *pstr;
175 int pass = 0;
176
177 /* search the resident names */
178
179 while (pass < 2)
180 {
181 if (pass == 0) /* resident names */
182 {
183 pstr = (const BYTE *)ne + ne->ne_restab;
184 if (*pstr) pstr += *pstr + 1 + sizeof(WORD); /* skip first entry (module name) */
185 }
186 else /* non-resident names */
187 {
188 if (!ne->ne_cbnrestab) break;
189 pstr = PRD(ne->ne_nrestab, 0);
190 }
191 while (*pstr)
192 {
193 WORD ord = get_word(pstr + *pstr + 1);
194 if (ord == ordinal)
195 {
196 memcpy( name, pstr + 1, *pstr );
197 name[*pstr] = 0;
198 return name;
199 }
200 pstr += *pstr + 1 + sizeof(WORD);
201 }
202 pass++;
203 }
204 name[0] = 0;
205 return name;
206 }
207
208 static void dump_ne_exports( const IMAGE_OS2_HEADER *ne )
209 {
210 const BYTE *ptr = (const BYTE *)ne + ne->ne_enttab;
211 const BYTE *end = ptr + ne->ne_cbenttab;
212 int i, ordinal = 1;
213
214 if (!ne->ne_cbenttab || !*ptr) return;
215
216 printf( "\nExported entry points:\n" );
217
218 while (ptr < end && *ptr)
219 {
220 BYTE count = *ptr++;
221 BYTE type = *ptr++;
222 switch(type)
223 {
224 case 0: /* next bundle */
225 ordinal += count;
226 break;
227 case 0xff: /* movable */
228 for (i = 0; i < count; i++)
229 {
230 printf( " %4d MOVABLE %d:%04x %s\n",
231 ordinal + i, ptr[3], get_word(ptr + 4),
232 get_export_name( ne, ordinal + i ) );
233 ptr += 6;
234 }
235 ordinal += count;
236 break;
237 case 0xfe: /* constant */
238 for (i = 0; i < count; i++)
239 {
240 printf( " %4d CONST %04x %s\n",
241 ordinal + i, get_word(ptr + 1),
242 get_export_name( ne, ordinal + i ) );
243 ptr += 3;
244 }
245 ordinal += count;
246 break;
247 default: /* fixed */
248 for (i = 0; i < count; i++)
249 {
250 printf( " %4d FIXED %d:%04x %s\n",
251 ordinal + i, type, get_word(ptr + 1),
252 get_export_name( ne, ordinal + i ) );
253 ptr += 3;
254 }
255 ordinal += count;
256 break;
257 }
258 }
259 }
260
261 static const char *get_reloc_name( BYTE addr_type, int additive )
262 {
263 switch(addr_type & 0x7f)
264 {
265 case NE_RADDR_LOWBYTE: return additive ? "byte add" : "byte";
266 case NE_RADDR_OFFSET16: return additive ? "off16 add" : "off16";
267 case NE_RADDR_POINTER32: return additive ? "ptr32 add" : "ptr32";
268 case NE_RADDR_SELECTOR: return additive ? "sel add" : "sel";
269 case NE_RADDR_POINTER48: return additive ? "ptr48 add" : "ptr48";
270 case NE_RADDR_OFFSET32: return additive ? "off32 add" : "off32";
271 }
272 return "???";
273 }
274
275 static const char *get_seg_flags( WORD flags )
276 {
277 static char buffer[256];
278
279 buffer[0] = 0;
280 #define ADD_FLAG(x) if (flags & NE_SEGFLAGS_##x) strcat( buffer, " " #x );
281 ADD_FLAG(DATA);
282 ADD_FLAG(ALLOCATED);
283 ADD_FLAG(LOADED);
284 ADD_FLAG(ITERATED);
285 ADD_FLAG(MOVEABLE);
286 ADD_FLAG(SHAREABLE);
287 ADD_FLAG(PRELOAD);
288 ADD_FLAG(EXECUTEONLY);
289 ADD_FLAG(READONLY);
290 ADD_FLAG(RELOC_DATA);
291 ADD_FLAG(SELFLOAD);
292 ADD_FLAG(DISCARDABLE);
293 ADD_FLAG(32BIT);
294 #undef ADD_FLAG
295 if (buffer[0])
296 {
297 buffer[0] = '(';
298 strcat( buffer, ")" );
299 }
300 return buffer;
301 }
302
303 static void dump_relocations( const IMAGE_OS2_HEADER *ne, WORD count,
304 const struct relocation_entry *rep )
305 {
306 const WORD *modref = (const WORD *)((const BYTE *)ne + ne->ne_modtab);
307 const BYTE *mod_name, *func_name;
308 WORD i;
309
310 for (i = 0; i < count; i++, rep++)
311 {
312 int additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
313 switch (rep->relocation_type & 3)
314 {
315 case NE_RELTYPE_ORDINAL:
316 mod_name = (const BYTE *)ne + ne->ne_imptab + modref[rep->target1 - 1];
317 printf( "%6d: %s = %*.*s.%d\n", i + 1, get_reloc_name( rep->address_type, additive ),
318 *mod_name, *mod_name, mod_name + 1, rep->target2 );
319 break;
320 case NE_RELTYPE_NAME:
321 mod_name = (const BYTE *)ne + ne->ne_imptab + modref[rep->target1 - 1];
322 func_name = (const BYTE *)ne + ne->ne_imptab + rep->target2;
323 printf( "%6d: %s = %*.*s.%*.*s\n", i + 1, get_reloc_name( rep->address_type, additive ),
324 *mod_name, *mod_name, mod_name + 1,
325 *func_name, *func_name, func_name + 1 );
326 break;
327 case NE_RELTYPE_INTERNAL:
328 if ((rep->target1 & 0xff) == 0xff)
329 {
330 /* the module itself */
331 mod_name = (const BYTE *)ne + ne->ne_restab;
332 printf( "%6d: %s = %*.*s.%d\n", i + 1, get_reloc_name( rep->address_type, additive ),
333 *mod_name, *mod_name, mod_name + 1, rep->target2 );
334 }
335 else
336 printf( "%6d: %s = %d:%04x\n", i + 1, get_reloc_name( rep->address_type, additive ),
337 rep->target1, rep->target2 );
338 break;
339 case NE_RELTYPE_OSFIXUP:
340 /* Relocation type 7:
341 *
342 * These appear to be used as fixups for the Windows
343 * floating point emulator. Let's just ignore them and
344 * try to use the hardware floating point. Linux should
345 * successfully emulate the coprocessor if it doesn't
346 * exist.
347 */
348 printf( "%6d: %s = TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
349 i + 1, get_reloc_name( rep->address_type, additive ),
350 rep->relocation_type, rep->offset,
351 rep->target1, rep->target2 );
352 break;
353 }
354 }
355 }
356
357 static void dump_ne_segment( const IMAGE_OS2_HEADER *ne, int segnum )
358 {
359 const struct ne_segtable_entry *table = (const struct ne_segtable_entry *)((const BYTE *)ne + ne->ne_segtab);
360 const struct ne_segtable_entry *seg = table + segnum - 1;
361
362 printf( "\nSegment %d:\n", segnum );
363 printf( " File offset: %08x\n", seg->seg_data_offset << ne->ne_align );
364 printf( " Length: %08x\n", seg->seg_data_length );
365 printf( " Flags: %08x %s\n", seg->seg_flags, get_seg_flags(seg->seg_flags) );
366 printf( " Alloc size: %08x\n", seg->min_alloc );
367 if (seg->seg_flags & NE_SEGFLAGS_RELOC_DATA)
368 {
369 const BYTE *ptr = PRD((seg->seg_data_offset << ne->ne_align) + seg->seg_data_length, 0);
370 WORD count = get_word(ptr);
371 ptr += sizeof(WORD);
372 printf( " Relocations:\n" );
373 dump_relocations( ne, count, (const struct relocation_entry *)ptr );
374 }
375 }
376
377 void ne_dump( void )
378 {
379 unsigned int i;
380 const IMAGE_DOS_HEADER *dos;
381 const IMAGE_OS2_HEADER *ne;
382
383 dos = PRD(0, sizeof(*dos));
384 if (!dos) return;
385 ne = PRD(dos->e_lfanew, sizeof(*ne));
386
387 if (globals.do_dumpheader || !globals.dumpsect)
388 dump_ne_header( ne );
389 if (globals.do_dumpheader)
390 dump_ne_names( ne );
391 if (globals.dumpsect)
392 {
393 BOOL all = strcmp(globals.dumpsect, "ALL") == 0;
394
395 if (all || !strcmp(globals.dumpsect, "resource"))
396 dump_ne_resources( ne );
397 if (all || !strcmp(globals.dumpsect, "export"))
398 dump_ne_exports( ne );
399 }
400 if (globals.do_dumpheader)
401 for (i = 1; i <= ne->ne_cseg; i++) dump_ne_segment( ne, i );
402 }
403
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.