?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedump: Fix a couple of issues with types table walking.
[wine.git] / tools / winedump / debug.c
blob278b5474c901dd7d9a13420f0bf69cedcef38cec
1 /*
2 * Made after:
3 * CVDump - Parses through a Visual Studio .DBG file in CodeView 4 format
4 * and dumps the info to STDOUT in a human-readable format
5 *
6 * Copyright 2000 John R. Sheets
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdlib.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <time.h>
33 #ifdef HAVE_SYS_TYPES_H
34 # include <sys/types.h>
35 #endif
36 #ifdef HAVE_SYS_STAT_H
37 # include <sys/stat.h>
38 #endif
39 #ifdef HAVE_SYS_MMAN_H
40 #include <sys/mman.h>
41 #endif
42 #include <fcntl.h>
43
44 #include "windef.h"
45 #include "winbase.h"
46 #include "winedump.h"
47 #include "wine/mscvpdb.h"
48
49 /*
50 * .DBG File Layout:
51 *
52 * IMAGE_SEPARATE_DEBUG_HEADER
53 * IMAGE_SECTION_HEADER[]
54 * IMAGE_DEBUG_DIRECTORY[]
55 * OMFSignature
56 * debug data (typical example)
57 * - IMAGE_DEBUG_TYPE_MISC
58 * - IMAGE_DEBUG_TYPE_FPO
59 * - IMAGE_DEBUG_TYPE_CODEVIEW
60 * OMFDirHeader
61 * OMFDirEntry[]
62 */
63
64 /*
65 * Descriptions:
66 *
67 * (hdr) IMAGE_SEPARATE_DEBUG_HEADER - .DBG-specific file header; holds info that
68 * applies to the file as a whole, including # of COFF sections, file offsets, etc.
69 * (hdr) IMAGE_SECTION_HEADER - list of COFF sections copied verbatim from .EXE;
70 * although this directory contains file offsets, these offsets are meaningless
71 * in the context of the .DBG file, because only the section headers are copied
72 * to the .DBG file...not the binary data it points to.
73 * (hdr) IMAGE_DEBUG_DIRECTORY - list of different formats of debug info contained in file
74 * (see IMAGE_DEBUG_TYPE_* descriptions below); tells where each section starts
75 * (hdr) OMFSignature (CV) - Contains "NBxx" signature, plus file offset telling how far
76 * into the IMAGE_DEBUG_TYPE_CODEVIEW section the OMFDirHeader and OMFDirEntry's sit
77 * (data) IMAGE_DEBUG_TYPE_MISC - usually holds name of original .EXE file
78 * (data) IMAGE_DEBUG_TYPE_FPO - Frame Pointer Optimization data; used for dealing with
79 * optimized stack frames (optional)
80 * (data) IMAGE_DEBUG_TYPE_CODEVIEW - *** THE GOOD STUFF ***
81 * This block of data contains all the symbol tables, line number info, etc.,
82 * that the Visual C++ debugger needs.
83 * (hdr) OMFDirHeader (CV) -
84 * (hdr) OMFDirEntry (CV) - list of subsections within CodeView debug data section
85 */
86
87 /*
88 * The .DBG file typically has three arrays of directory entries, which tell
89 * the OS or debugger where in the file to look for the actual data
90 *
91 * IMAGE_SECTION_HEADER - number of entries determined by:
92 * (IMAGE_SEPARATE_DEBUG_HEADER.NumberOfSections)
93 *
94 * IMAGE_DEBUG_DIRECTORY - number of entries determined by:
95 * (IMAGE_SEPARATE_DEBUG_HEADER.DebugDirectorySize / sizeof (IMAGE_DEBUG_DIRECTORY))
96 *
97 * OMFDirEntry - number of entries determined by:
98 * (OMFDirHeader.cDir)
99 */
100
101 extern const IMAGE_NT_HEADERS* PE_nt_headers;
102 static const void* cv_base /* = 0 */;
103
104 static int dump_cv_sst_module(const OMFDirEntry* omfde)
105 {
106 const OMFModule* module;
107 const OMFSegDesc* segDesc;
108 int i;
109
110 module = PRD(Offset(cv_base) + omfde->lfo, sizeof(OMFModule));
111 if (!module) {printf("Can't get the OMF-Module, aborting\n"); return FALSE;}
112
113 printf(" olvNumber: %u\n", module->ovlNumber);
114 printf(" iLib: %u\n", module->iLib);
115 printf(" cSeg: %u\n", module->cSeg);
116 printf(" Style: %c%c\n", module->Style[0], module->Style[1]);
117 printf(" Name: %.*s\n",
118 *(const BYTE*)((const char*)(module + 1) + sizeof(OMFSegDesc) * module->cSeg),
119 (const char*)(module + 1) + sizeof(OMFSegDesc) * module->cSeg + 1);
120
121 segDesc = PRD(Offset(module + 1), sizeof(OMFSegDesc) * module->cSeg);
122 if (!segDesc) {printf("Can't get the OMF-SegDesc, aborting\n"); return FALSE;}
123
124 for (i = 0; i < module->cSeg; i++)
125 {
126 printf (" segment #%2d: offset = [0x%8x], size = [0x%8x]\n",
127 segDesc->Seg, segDesc->Off, segDesc->cbSeg);
128 segDesc++;
129 }
130 return TRUE;
131 }
132
133 static int dump_cv_sst_global_pub(const OMFDirEntry* omfde)
134 {
135 long fileoffset;
136 const OMFSymHash* header;
137 const BYTE* symbols;
138
139 fileoffset = Offset(cv_base) + omfde->lfo;
140 printf (" GlobalPub section starts at file offset 0x%lx\n", fileoffset);
141 printf (" Symbol table starts at 0x%lx\n", fileoffset + sizeof (OMFSymHash));
142
143 printf ("\n ----- Begin Symbol Table -----\n");
144
145 header = PRD(fileoffset, sizeof(OMFSymHash));
146 if (!header) {printf("Can't get OMF-SymHash, aborting\n");return FALSE;}
147
148 symbols = PRD(fileoffset + sizeof(OMFSymHash), header->cbSymbol);
149 if (!symbols) {printf("Can't OMF-SymHash details, aborting\n"); return FALSE;}
150
151 codeview_dump_symbols(symbols, header->cbSymbol);
152
153 return TRUE;
154 }
155
156 static int dump_cv_sst_global_sym(const OMFDirEntry* omfde)
157 {
158 /*** NOT YET IMPLEMENTED ***/
159 return TRUE;
160 }
161
162 static int dump_cv_sst_static_sym(const OMFDirEntry* omfde)
163 {
164 /*** NOT YET IMPLEMENTED ***/
165 return TRUE;
166 }
167
168 static int dump_cv_sst_libraries(const OMFDirEntry* omfde)
169 {
170 /*** NOT YET IMPLEMENTED ***/
171 return TRUE;
172 }
173
174 static int dump_cv_sst_global_types(const OMFDirEntry* omfde)
175 {
176 long fileoffset;
177 const OMFGlobalTypes*types;
178 const BYTE* data;
179 unsigned sz;
180
181 fileoffset = Offset(cv_base) + omfde->lfo;
182 printf (" GlobalTypes section starts at file offset 0x%lx\n", fileoffset);
183
184 printf ("\n ----- Begin Global Types Table -----\n");
185
186 types = PRD(fileoffset, sizeof(OMFGlobalTypes));
187 if (!types) {printf("Can't get OMF-GlobalTypes, aborting\n");return FALSE;}
188
189 sz = omfde->cb - sizeof(OMFGlobalTypes) - sizeof(DWORD) * types->cTypes;
190 data = PRD(fileoffset + sizeof(OMFGlobalTypes) + sizeof(DWORD) * types->cTypes, sz);
191 if (!data) {printf("Can't OMF-SymHash details, aborting\n"); return FALSE;}
192
193 /* doc says:
194 * - for NB07 & NB08 (that we don't support yet), offsets are from types
195 * - for NB09, offsets are from data
196 * For now, we only support the later
197 */
198 codeview_dump_types_from_offsets(data, (const DWORD*)(types + 1), types->cTypes);
199
200 return TRUE;
201 }
202
203 static int dump_cv_sst_seg_map(const OMFDirEntry* omfde)
204 {
205 const OMFSegMap* segMap;
206 const OMFSegMapDesc* segMapDesc;
207 int i;
208
209 segMap = PRD(Offset(cv_base) + omfde->lfo, sizeof(OMFSegMap));
210 if (!segMap) {printf("Can't get SegMap, aborting\n");return FALSE;}
211
212 printf(" cSeg: %u\n", segMap->cSeg);
213 printf(" cSegLog: %u\n", segMap->cSegLog);
214
215 segMapDesc = PRD(Offset(segMap + 1), segMap->cSeg * sizeof(OMFSegDesc));
216 if (!segMapDesc) {printf("Can't get SegDescr array, aborting\n");return FALSE;}
217
218 for (i = 0; i < segMap->cSeg; i++)
219 {
220 printf(" SegDescr #%2d\n", i + 1);
221 printf(" flags: %04X\n", segMapDesc[i].flags);
222 printf(" ovl: %u\n", segMapDesc[i].ovl);
223 printf(" group: %u\n", segMapDesc[i].group);
224 printf(" frame: %u\n", segMapDesc[i].frame);
225 printf(" iSegName: %u\n", segMapDesc[i].iSegName);
226 printf(" iClassName: %u\n", segMapDesc[i].iClassName);
227 printf(" offset: %lu\n", segMapDesc[i].offset);
228 printf(" cbSeg: %lu\n", segMapDesc[i].cbSeg);
229 }
230
231 return TRUE;
232 }
233
234 static int dump_cv_sst_file_index(const OMFDirEntry* omfde)
235 {
236 /*** NOT YET IMPLEMENTED ***/
237 return TRUE;
238 }
239
240 static int dump_cv_sst_src_module(const OMFDirEntry* omfde)
241 {
242 int i, j;
243 const BYTE* rawdata;
244 const unsigned long* seg_info_dw;
245 const unsigned short* seg_info_w;
246 unsigned ofs;
247 const OMFSourceModule* sourceModule;
248 const OMFSourceFile* sourceFile;
249 const OMFSourceLine* sourceLine;
250
251 rawdata = PRD(Offset(cv_base) + omfde->lfo, omfde->cb);
252 if (!rawdata) {printf("Can't get srcModule subsection details, aborting\n");return FALSE;}
253
254 /* FIXME: check ptr validity */
255 sourceModule = (const void*)rawdata;
256 printf (" Module table: Found %d file(s) and %d segment(s)\n",
257 sourceModule->cFile, sourceModule->cSeg);
258 for (i = 0; i < sourceModule->cFile; i++)
259 {
260 printf (" File #%2d begins at an offset of 0x%lx in this section\n",
261 i + 1, sourceModule->baseSrcFile[i]);
262 }
263
264 /* FIXME: check ptr validity */
265 seg_info_dw = (const void*)((const char*)(sourceModule + 1) +
266 sizeof(unsigned long) * (sourceModule->cFile - 1));
267 seg_info_w = (const unsigned short*)(&seg_info_dw[sourceModule->cSeg * 2]);
268 for (i = 0; i < sourceModule->cSeg; i++)
269 {
270 printf (" Segment #%2d start = 0x%lx, end = 0x%lx, seg index = %u\n",
271 i + 1, seg_info_dw[i * 2], seg_info_dw[(i * 2) + 1],
272 seg_info_w[i]);
273 }
274 ofs = sizeof(OMFSourceModule) + sizeof(unsigned long) * (sourceModule->cFile - 1) +
275 sourceModule->cSeg * (2 * sizeof(unsigned long) + sizeof(unsigned short));
276 ofs = (ofs + 3) & ~3;
277
278 /* the OMFSourceFile is quite unpleasant to use:
279 * we have first:
280 * unsigned short number of segments
281 * unsigned short reservered
282 * unsigned long baseSrcLn[# segments]
283 * unsigned long offset[2 * #segments]
284 * odd indices are start offsets
285 * even indices are end offsets
286 * unsigned char string length for file name
287 * char file name (length is previous field)
288 */
289 /* FIXME: check ptr validity */
290 sourceFile = (const void*)(rawdata + ofs);
291 seg_info_dw = (const void*)((const char*)sourceFile + 2 * sizeof(unsigned short) +
292 sourceFile->cSeg * sizeof(unsigned long));
293
294 ofs += 2 * sizeof(unsigned short) + 3 * sourceFile->cSeg * sizeof(unsigned long);
295
296 printf(" File table: %.*s\n",
297 *(const BYTE*)((const char*)sourceModule + ofs), (const char*)sourceModule + ofs + 1);
298
299 for (i = 0; i < sourceFile->cSeg; i++)
300 {
301 printf (" Segment #%2d start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
302 i + 1, seg_info_dw[i * 2], seg_info_dw[(i * 2) + 1], sourceFile->baseSrcLn[i]);
303 }
304 /* add file name length */
305 ofs += *(const BYTE*)((const char*)sourceModule + ofs) + 1;
306 ofs = (ofs + 3) & ~3;
307
308 for (i = 0; i < sourceModule->cSeg; i++)
309 {
310 sourceLine = (const void*)(rawdata + ofs);
311 seg_info_dw = (const void*)((const char*)sourceLine + 2 * sizeof(unsigned short));
312 seg_info_w = (const void*)(&seg_info_dw[sourceLine->cLnOff]);
313
314 printf (" Line table #%2d: Found %d line numbers for segment index %d\n",
315 i, sourceLine->cLnOff, sourceLine->Seg);
316
317 for (j = 0; j < sourceLine->cLnOff; j++)
318 {
319 printf (" Pair #%2d: offset = [0x%8lx], linenumber = %d\n",
320 j + 1, seg_info_dw[j], seg_info_w[j]);
321 }
322 ofs += 2 * sizeof(unsigned short) +
323 sourceLine->cLnOff * (sizeof(unsigned long) + sizeof(unsigned short));
324 ofs = (ofs + 3) & ~3;
325 }
326
327 return TRUE;
328 }
329
330 static int dump_cv_sst_align_sym(const OMFDirEntry* omfde)
331 {
332 const char* rawdata = PRD(Offset(cv_base) + omfde->lfo, omfde->cb);
333
334 if (!rawdata) {printf("Can't get srcAlignSym subsection details, aborting\n");return FALSE;}
335 if (omfde->cb < sizeof(DWORD)) return TRUE;
336 codeview_dump_symbols(rawdata + sizeof(DWORD), omfde->cb - sizeof(DWORD));
337
338 return TRUE;
339 }
340
341 static void dump_codeview_all_modules(const OMFDirHeader *omfdh)
342 {
343 unsigned i;
344 const OMFDirEntry* dirEntry;
345 const char* str;
346
347 if (!omfdh || !omfdh->cDir) return;
348
349 dirEntry = PRD(Offset(omfdh + 1), omfdh->cDir * sizeof(OMFDirEntry));
350 if (!dirEntry) {printf("Can't read DirEntry array, aborting\n"); return;}
351
352 for (i = 0; i < omfdh->cDir; i++)
353 {
354 switch (dirEntry[i].SubSection)
355 {
356 case sstModule: str = "sstModule"; break;
357 case sstAlignSym: str = "sstAlignSym"; break;
358 case sstSrcModule: str = "sstSrcModule"; break;
359 case sstLibraries: str = "sstLibraries"; break;
360 case sstGlobalSym: str = "sstGlobalSym"; break;
361 case sstGlobalPub: str = "sstGlobalPub"; break;
362 case sstGlobalTypes: str = "sstGlobalTypes"; break;
363 case sstSegMap: str = "sstSegMap"; break;
364 case sstFileIndex: str = "sstFileIndex"; break;
365 case sstStaticSym: str = "sstStaticSym"; break;
366 default: str = "<undefined>"; break;
367 }
368 printf("Module #%2d (%p)\n", i + 1, &dirEntry[i]);
369 printf(" SubSection: %04X (%s)\n", dirEntry[i].SubSection, str);
370 printf(" iMod: %d\n", dirEntry[i].iMod);
371 printf(" lfo: %d\n", dirEntry[i].lfo);
372 printf(" cb: %u\n", dirEntry[i].cb);
373
374 switch (dirEntry[i].SubSection)
375 {
376 case sstModule: dump_cv_sst_module(&dirEntry[i]); break;
377 case sstAlignSym: dump_cv_sst_align_sym(&dirEntry[i]); break;
378 case sstSrcModule: dump_cv_sst_src_module(&dirEntry[i]); break;
379 case sstLibraries: dump_cv_sst_libraries(&dirEntry[i]); break;
380 case sstGlobalSym: dump_cv_sst_global_sym(&dirEntry[i]); break;
381 case sstGlobalPub: dump_cv_sst_global_pub(&dirEntry[i]); break;
382 case sstGlobalTypes: dump_cv_sst_global_types(&dirEntry[i]); break;
383 case sstSegMap: dump_cv_sst_seg_map(&dirEntry[i]); break;
384 case sstFileIndex: dump_cv_sst_file_index(&dirEntry[i]); break;
385 case sstStaticSym: dump_cv_sst_static_sym(&dirEntry[i]); break;
386 default: printf("unsupported type %x\n", dirEntry[i].SubSection); break;
387 }
388 printf("\n");
389 }
390
391 return;
392 }
393
394 static void dump_codeview_headers(unsigned long base, unsigned long len)
395 {
396 const OMFDirHeader* dirHeader;
397 const char* signature;
398 const OMFDirEntry* dirEntry;
399 const OMFSignature* sig;
400 unsigned i;
401 int modulecount = 0, alignsymcount = 0, srcmodulecount = 0, librariescount = 0;
402 int globalsymcount = 0, globalpubcount = 0, globaltypescount = 0;
403 int segmapcount = 0, fileindexcount = 0, staticsymcount = 0;
404
405 cv_base = PRD(base, len);
406 if (!cv_base) {printf("Can't get full debug content, aborting\n");return;}
407
408 signature = cv_base;
409
410 printf(" CodeView Data\n");
411 printf(" Signature: %.4s\n", signature);
412
413 if (memcmp(signature, "NB10", 4) == 0)
414 {
415 const CODEVIEW_PDB_DATA* pdb_data;
416 pdb_data = (const void *)cv_base;
417
418 printf(" Filepos: 0x%08lX\n", pdb_data->filepos);
419 printf(" TimeStamp: %08X (%s)\n",
420 pdb_data->timestamp, get_time_str(pdb_data->timestamp));
421 printf(" Dunno: %08X\n", pdb_data->unknown);
422 printf(" Filename: %s\n", pdb_data->name);
423 return;
424 }
425 if (memcmp(signature, "RSDS", 4) == 0)
426 {
427 const OMFSignatureRSDS* rsds_data;
428 char guid_str[40];
429
430 rsds_data = (const void *)cv_base;
431 printf(" Guid: %s\n",
432 guid_to_string(&rsds_data->guid, guid_str, sizeof(guid_str)));
433 printf(" Dunno: %08X\n", rsds_data->unknown);
434 printf(" Filename: %s\n", rsds_data->name);
435 return;
436 }
437
438 if (memcmp(signature, "NB09", 4) != 0 && memcmp(signature, "NB11", 4) != 0)
439 {
440 printf("Unsupported signature (%.4s), aborting\n", signature);
441 return;
442 }
443
444 sig = cv_base;
445
446 printf(" Filepos: 0x%08lX\n", sig->filepos);
447
448 dirHeader = PRD(Offset(cv_base) + sig->filepos, sizeof(OMFDirHeader));
449 if (!dirHeader) {printf("Can't get debug header, aborting\n"); return;}
450
451 printf(" Size of header: 0x%4X\n", dirHeader->cbDirHeader);
452 printf(" Size per entry: 0x%4X\n", dirHeader->cbDirEntry);
453 printf(" # of entries: 0x%8X (%d)\n", dirHeader->cDir, dirHeader->cDir);
454 printf(" Offset to NextDir: 0x%8X\n", dirHeader->lfoNextDir);
455 printf(" Flags: 0x%8X\n", dirHeader->flags);
456
457 if (!dirHeader->cDir) return;
458
459 dirEntry = PRD(Offset(dirHeader + 1), sizeof(OMFDirEntry) * dirHeader->cDir);
460 if (!dirEntry) {printf("Can't get DirEntry array, aborting\n");return;}
461
462 for (i = 0; i < dirHeader->cDir; i++)
463 {
464 switch (dirEntry[i].SubSection)
465 {
466 case sstModule: modulecount++; break;
467 case sstAlignSym: alignsymcount++; break;
468 case sstSrcModule: srcmodulecount++; break;
469 case sstLibraries: librariescount++; break;
470 case sstGlobalSym: globalsymcount++; break;
471 case sstGlobalPub: globalpubcount++; break;
472 case sstGlobalTypes: globaltypescount++; break;
473 case sstSegMap: segmapcount++; break;
474 case sstFileIndex: fileindexcount++; break;
475 case sstStaticSym: staticsymcount++; break;
476 }
477 }
478
479 /* This one has to be > 0
480 */
481 printf ("\nFound: %d sstModule subsections\n", modulecount);
482
483 if (alignsymcount > 0) printf (" %d sstAlignSym subsections\n", alignsymcount);
484 if (srcmodulecount > 0) printf (" %d sstSrcModule subsections\n", srcmodulecount);
485 if (librariescount > 0) printf (" %d sstLibraries subsections\n", librariescount);
486 if (globalsymcount > 0) printf (" %d sstGlobalSym subsections\n", globalsymcount);
487 if (globalpubcount > 0) printf (" %d sstGlobalPub subsections\n", globalpubcount);
488 if (globaltypescount > 0) printf (" %d sstGlobalTypes subsections\n", globaltypescount);
489 if (segmapcount > 0) printf (" %d sstSegMap subsections\n", segmapcount);
490 if (fileindexcount > 0) printf (" %d sstFileIndex subsections\n", fileindexcount);
491 if (staticsymcount > 0) printf (" %d sstStaticSym subsections\n", staticsymcount);
492
493 dump_codeview_all_modules(dirHeader);
494 }
495
496 static const char *get_coff_name( const IMAGE_SYMBOL *coff_sym, const char *coff_strtab )
497 {
498 static char namebuff[9];
499 const char* nampnt;
500
501 if( coff_sym->N.Name.Short )
502 {
503 memcpy(namebuff, coff_sym->N.ShortName, 8);
504 namebuff[8] = '\0';
505 nampnt = &namebuff[0];
506 }
507 else
508 {
509 nampnt = coff_strtab + coff_sym->N.Name.Long;
510 }
511
512 if( nampnt[0] == '_' )
513 nampnt++;
514 return nampnt;
515 }
516
517 void dump_coff(unsigned long coffbase, unsigned long len, const void* pmt)
518 {
519 const IMAGE_COFF_SYMBOLS_HEADER *coff = (const IMAGE_COFF_SYMBOLS_HEADER *)PRD(coffbase, len);
520 const IMAGE_SYMBOL *coff_sym;
521 const IMAGE_SYMBOL *coff_symbols =
522 (const IMAGE_SYMBOL *) ((const char *)coff + coff->LvaToFirstSymbol);
523 const char *coff_strtab = (const char *) (coff_symbols + coff->NumberOfSymbols);
524 const IMAGE_SECTION_HEADER *sectHead = pmt;
525 unsigned int i;
526 const char *nampnt;
527 int naux;
528
529 printf("\nDebug table: COFF format. modbase %p, coffbase %p\n", PRD(0, 0), coff);
530 printf(" ID | seg:offs [ abs ] | symbol/function name\n");
531 for(i=0; i < coff->NumberOfSymbols; i++ )
532 {
533 coff_sym = coff_symbols + i;
534 naux = coff_sym->NumberOfAuxSymbols;
535
536 if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
537 {
538 printf("file %s\n", (const char *) (coff_sym + 1));
539 i += naux;
540 continue;
541 }
542
543 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
544 && (naux == 0)
545 && (coff_sym->SectionNumber == 1) )
546 {
547 DWORD base = sectHead[coff_sym->SectionNumber - 1].VirtualAddress;
548 /*
549 * This is a normal static function when naux == 0.
550 * Just register it. The current file is the correct
551 * one in this instance.
552 */
553 nampnt = get_coff_name( coff_sym, coff_strtab );
554
555 printf("%05d | %02d:%08x [%08x] | %s\n", i, coff_sym->SectionNumber - 1, coff_sym->Value - base, coff_sym->Value, nampnt);
556 i += naux;
557 continue;
558 }
559
560 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
561 && ISFCN(coff_sym->Type)
562 && (coff_sym->SectionNumber > 0) )
563 {
564 DWORD base = sectHead[coff_sym->SectionNumber - 1].VirtualAddress;
565
566 nampnt = get_coff_name( coff_sym, coff_strtab );
567
568 /* FIXME: add code to find out the file this symbol belongs to,
569 * see winedbg */
570 printf("%05d | %02d:%08x [%08x] | %s\n", i, coff_sym->SectionNumber - 1, coff_sym->Value - base, coff_sym->Value, nampnt);
571 i += naux;
572 continue;
573 }
574
575 /*
576 * For now, skip past the aux entries.
577 */
578 i += naux;
579
580 }
581 }
582
583 void dump_codeview(unsigned long base, unsigned long len)
584 {
585 dump_codeview_headers(base, len);
586 }
587
588 void dump_frame_pointer_omission(unsigned long base, unsigned long len)
589 {
590 const FPO_DATA* fpo;
591 const FPO_DATA* last;
592 const char* x;
593 /* FPO is used to describe nonstandard stack frames */
594 printf("Range #loc #pmt Prlg #reg Info\n"
595 "-----------------+----+----+----+----+------------\n");
596
597 fpo = (const FPO_DATA*)PRD(base, len);
598 if (!fpo) {printf("Couldn't get FPO blob\n"); return;}
599 last = (const FPO_DATA*)((const char*)fpo + len);
600
601 while (fpo < last && fpo->ulOffStart)
602 {
603 switch (fpo->cbFrame)
604 {
605 case FRAME_FPO: x = "FRAME_FPO"; break;
606 case FRAME_NONFPO: x = "FRAME_NONFPO"; break;
607 case FRAME_TRAP: x = "FRAME_TRAP"; break;
608 case FRAME_TSS: x = "case FRAME_TSS"; break;
609 default: x = NULL; break;
610 }
611 printf("%08x-%08x %4u %4u %4u %4u %s%s%s\n",
612 fpo->ulOffStart, fpo->ulOffStart + fpo->cbProcSize,
613 fpo->cdwLocals, fpo->cdwParams, fpo->cbProlog, fpo->cbRegs,
614 x, fpo->fHasSEH ? " SEH" : "", fpo->fUseBP ? " UseBP" : "");
615 fpo++;
616 }
617 }
618
619 struct stab_nlist
620 {
621 union
622 {
623 char* n_name;
624 struct stab_nlist* n_next;
625 long n_strx;
626 } n_un;
627 unsigned char n_type;
628 char n_other;
629 short n_desc;
630 unsigned long n_value;
631 };
632
633 static const char * const stabs_defs[] = {
634 NULL,NULL,NULL,NULL, /* 00 */
635 NULL,NULL,NULL,NULL, /* 08 */
636 NULL,NULL,NULL,NULL, /* 10 */
637 NULL,NULL,NULL,NULL, /* 18 */
638 "GSYM","FNAME","FUN","STSYM", /* 20 */
639 "LCSYM","MAIN","ROSYM","PC", /* 28 */
640 NULL,"NSYMS","NOMAP",NULL, /* 30 */
641 "OBJ",NULL,"OPT",NULL, /* 38 */
642 "RSYM","M2C","SLINE","DSLINE", /* 40 */
643 "BSLINE","DEFD","FLINE",NULL, /* 48 */
644 "EHDECL",NULL,"CATCH",NULL, /* 50 */
645 NULL,NULL,NULL,NULL, /* 58 */
646 "SSYM","ENDM","SO",NULL, /* 60 */
647 NULL,NULL,NULL,NULL, /* 68 */
648 NULL,NULL,NULL,NULL, /* 70 */
649 NULL,NULL,NULL,NULL, /* 78 */
650 "LSYM","BINCL","SOL",NULL, /* 80 */
651 NULL,NULL,NULL,NULL, /* 88 */
652 NULL,NULL,NULL,NULL, /* 90 */
653 NULL,NULL,NULL,NULL, /* 98 */
654 "PSYM","EINCL","ENTRY",NULL, /* a0 */
655 NULL,NULL,NULL,NULL, /* a8 */
656 NULL,NULL,NULL,NULL, /* b0 */
657 NULL,NULL,NULL,NULL, /* b8 */
658 "LBRAC","EXCL","SCOPE",NULL, /* c0 */
659 NULL,NULL,NULL,NULL, /* c8 */
660 NULL,NULL,NULL,NULL, /* d0 */
661 NULL,NULL,NULL,NULL, /* d8 */
662 "RBRAC","BCOMM","ECOMM",NULL, /* e0 */
663 "ECOML","WITH",NULL,NULL, /* e8 */
664 "NBTEXT","NBDATA","NBBSS","NBSTS", /* f0 */
665 "NBLCS",NULL,NULL,NULL /* f8 */
666 };
667
668 void dump_stabs(const void* pv_stabs, unsigned szstabs, const char* stabstr, unsigned szstr)
669 {
670 int i;
671 int nstab;
672 const char* ptr;
673 char* stabbuff;
674 unsigned int stabbufflen;
675 const struct stab_nlist* stab_ptr = pv_stabs;
676 const char* strs_end;
677 char n_buffer[16];
678
679 nstab = szstabs / sizeof(struct stab_nlist);
680 strs_end = stabstr + szstr;
681
682 /*
683 * Allocate a buffer into which we can build stab strings for cases
684 * where the stab is continued over multiple lines.
685 */
686 stabbufflen = 65536;
687 stabbuff = malloc(stabbufflen);
688
689 stabbuff[0] = '\0';
690
691 printf("#Sym n_type n_othr n_desc n_value n_strx String\n");
692
693 for (i = 0; i < nstab; i++, stab_ptr++)
694 {
695 ptr = stabstr + stab_ptr->n_un.n_strx;
696 if ((ptr > strs_end) || (ptr + strlen(ptr) > strs_end))
697 {
698 ptr = "[[*** bad string ***]]";
699 }
700 else if (ptr[strlen(ptr) - 1] == '\\')
701 {
702 /*
703 * Indicates continuation. Append this to the buffer, and go onto the
704 * next record. Repeat the process until we find a stab without the
705 * '/' character, as this indicates we have the whole thing.
706 */
707 unsigned len = strlen(ptr);
708 if (strlen(stabbuff) + len > stabbufflen)
709 {
710 stabbufflen += 65536;
711 stabbuff = realloc(stabbuff, stabbufflen);
712 }
713 strncat(stabbuff, ptr, len - 1);
714 continue;
715 }
716 else if (stabbuff[0] != '\0')
717 {
718 strcat(stabbuff, ptr);
719 ptr = stabbuff;
720 }
721 if ((stab_ptr->n_type & 1) || !stabs_defs[stab_ptr->n_type / 2])
722 sprintf(n_buffer, "<0x%02x>", stab_ptr->n_type);
723 else
724 sprintf(n_buffer, "%-6s", stabs_defs[stab_ptr->n_type / 2]);
725 printf("%4d %s %-8x % 6d %-8lx %-6lx %s\n",
726 i, n_buffer, stab_ptr->n_other, stab_ptr->n_desc, stab_ptr->n_value,
727 stab_ptr->n_un.n_strx, ptr);
728 }
729 free(stabbuff);
730 }
Windows API implementation