debug.c 25.3 KB
Newer Older
1 2 3 4 5 6
/*
 * Made after:
 *	CVDump - Parses through a Visual Studio .DBG file in CodeView 4 format
 * 	and dumps the info to STDOUT in a human-readable format
 *
 * 	Copyright 2000 John R. Sheets
7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 24
#include "config.h"

25
#include <stdlib.h>
26
#include <stdarg.h>
27 28 29
#include <stdio.h>
#include <time.h>

30
#include "../tools.h"
31
#include "windef.h"
32
#include "winbase.h"
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
#include "winedump.h"

/*
 * .DBG File Layout:
 *
 * IMAGE_SEPARATE_DEBUG_HEADER
 * IMAGE_SECTION_HEADER[]
 * IMAGE_DEBUG_DIRECTORY[]
 * OMFSignature
 * debug data (typical example)
 *   - IMAGE_DEBUG_TYPE_MISC
 *   - IMAGE_DEBUG_TYPE_FPO
 *   - IMAGE_DEBUG_TYPE_CODEVIEW
 * OMFDirHeader
 * OMFDirEntry[]
 */

/*
 * Descriptions:
 *
53
 * (hdr)  IMAGE_SEPARATE_DEBUG_HEADER - .DBG-specific file header; holds info that
54 55 56 57
 *        applies to the file as a whole, including # of COFF sections, file offsets, etc.
 * (hdr)  IMAGE_SECTION_HEADER - list of COFF sections copied verbatim from .EXE;
 *        although this directory contains file offsets, these offsets are meaningless
 *        in the context of the .DBG file, because only the section headers are copied
58
 *        to the .DBG file... not the binary data it points to.
59 60 61 62 63 64 65 66 67 68
 * (hdr)  IMAGE_DEBUG_DIRECTORY - list of different formats of debug info contained in file
 *        (see IMAGE_DEBUG_TYPE_* descriptions below); tells where each section starts
 * (hdr)  OMFSignature (CV) - Contains "NBxx" signature, plus file offset telling how far
 *        into the IMAGE_DEBUG_TYPE_CODEVIEW section the OMFDirHeader and OMFDirEntry's sit
 * (data) IMAGE_DEBUG_TYPE_MISC - usually holds name of original .EXE file
 * (data) IMAGE_DEBUG_TYPE_FPO - Frame Pointer Optimization data; used for dealing with
 *        optimized stack frames (optional)
 * (data) IMAGE_DEBUG_TYPE_CODEVIEW - *** THE GOOD STUFF ***
 *        This block of data contains all the symbol tables, line number info, etc.,
 *        that the Visual C++ debugger needs.
69
 * (hdr)  OMFDirHeader (CV) -
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
 * (hdr)  OMFDirEntry (CV) - list of subsections within CodeView debug data section
 */

/*
 * The .DBG file typically has three arrays of directory entries, which tell
 * the OS or debugger where in the file to look for the actual data
 *
 * IMAGE_SECTION_HEADER - number of entries determined by:
 *    (IMAGE_SEPARATE_DEBUG_HEADER.NumberOfSections)
 *
 * IMAGE_DEBUG_DIRECTORY - number of entries determined by:
 *    (IMAGE_SEPARATE_DEBUG_HEADER.DebugDirectorySize / sizeof (IMAGE_DEBUG_DIRECTORY))
 *
 * OMFDirEntry - number of entries determined by:
 *    (OMFDirHeader.cDir)
 */

87 88
extern const IMAGE_NT_HEADERS*  PE_nt_headers;
static const void*	        cv_base /* = 0 */;
89

90
static BOOL dump_cv_sst_module(const OMFDirEntry* omfde)
91
{
92 93
    const OMFModule*	module;
    const OMFSegDesc*	segDesc;
94 95 96 97 98 99 100 101 102
    int		i;

    module = PRD(Offset(cv_base) + omfde->lfo, sizeof(OMFModule));
    if (!module) {printf("Can't get the OMF-Module, aborting\n"); return FALSE;}

    printf("    olvNumber:          %u\n", module->ovlNumber);
    printf("    iLib:               %u\n", module->iLib);
    printf("    cSeg:               %u\n", module->cSeg);
    printf("    Style:              %c%c\n", module->Style[0], module->Style[1]);
103
    printf("    Name:               %.*s\n",
104 105
	   *(const BYTE*)((const char*)(module + 1) + sizeof(OMFSegDesc) * module->cSeg),
	   (const char*)(module + 1) + sizeof(OMFSegDesc) * module->cSeg + 1);
106 107 108 109 110 111

    segDesc = PRD(Offset(module + 1), sizeof(OMFSegDesc) * module->cSeg);
    if (!segDesc) {printf("Can't get the OMF-SegDesc, aborting\n"); return FALSE;}

    for (i = 0; i < module->cSeg; i++)
    {
112
	printf ("      segment #%2d: offset = [0x%8x], size = [0x%8x]\n",
113 114 115 116 117 118
		segDesc->Seg, segDesc->Off, segDesc->cbSeg);
	segDesc++;
    }
    return TRUE;
}

119
static BOOL dump_cv_sst_global_pub(const OMFDirEntry* omfde)
120
{
121 122 123
    long	        fileoffset;
    const OMFSymHash*   header;
    const BYTE*	        symbols;
124 125 126 127 128 129 130 131 132 133 134 135 136

    fileoffset = Offset(cv_base) + omfde->lfo;
    printf ("    GlobalPub section starts at file offset 0x%lx\n", fileoffset);
    printf ("    Symbol table starts at 0x%lx\n", fileoffset + sizeof (OMFSymHash));

    printf ("\n                           ----- Begin Symbol Table -----\n");

    header = PRD(fileoffset, sizeof(OMFSymHash));
    if (!header) {printf("Can't get OMF-SymHash, aborting\n");return FALSE;}

    symbols = PRD(fileoffset + sizeof(OMFSymHash), header->cbSymbol);
    if (!symbols) {printf("Can't OMF-SymHash details, aborting\n"); return FALSE;}

137
    codeview_dump_symbols(symbols, 0, header->cbSymbol);
138 139 140 141

    return TRUE;
}

142
static BOOL dump_cv_sst_global_sym(const OMFDirEntry* omfde)
143 144 145 146 147
{
    /*** NOT YET IMPLEMENTED ***/
    return TRUE;
}

148
static BOOL dump_cv_sst_static_sym(const OMFDirEntry* omfde)
149 150 151 152 153
{
    /*** NOT YET IMPLEMENTED ***/
    return TRUE;
}

154
static BOOL dump_cv_sst_libraries(const OMFDirEntry* omfde)
155 156 157 158 159
{
    /*** NOT YET IMPLEMENTED ***/
    return TRUE;
}

160
static BOOL dump_cv_sst_global_types(const OMFDirEntry* omfde)
161
{
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
    long	        fileoffset;
    const OMFGlobalTypes*types;
    const BYTE*         data;
    unsigned            sz;

    fileoffset = Offset(cv_base) + omfde->lfo;
    printf ("    GlobalTypes section starts at file offset 0x%lx\n", fileoffset);

    printf ("\n                           ----- Begin Global Types Table -----\n");

    types = PRD(fileoffset, sizeof(OMFGlobalTypes));
    if (!types) {printf("Can't get OMF-GlobalTypes, aborting\n");return FALSE;}

    sz = omfde->cb - sizeof(OMFGlobalTypes) - sizeof(DWORD) * types->cTypes;
    data = PRD(fileoffset + sizeof(OMFGlobalTypes) + sizeof(DWORD) * types->cTypes, sz);
    if (!data) {printf("Can't OMF-SymHash details, aborting\n"); return FALSE;}

179 180 181
    /* doc says:
     * - for NB07 & NB08 (that we don't support yet), offsets are from types
     * - for NB09, offsets are from data
Austin English's avatar
Austin English committed
182
     * For now, we only support the latter
183 184
     */
    codeview_dump_types_from_offsets(data, (const DWORD*)(types + 1), types->cTypes);
185

186 187 188
    return TRUE;
}

189
static BOOL dump_cv_sst_seg_map(const OMFDirEntry* omfde)
190
{
191 192
    const OMFSegMap*		segMap;
    const OMFSegMapDesc*	segMapDesc;
193 194 195 196 197 198 199 200 201 202
    int		i;

    segMap = PRD(Offset(cv_base) + omfde->lfo, sizeof(OMFSegMap));
    if (!segMap) {printf("Can't get SegMap, aborting\n");return FALSE;}

    printf("    cSeg:          %u\n", segMap->cSeg);
    printf("    cSegLog:       %u\n", segMap->cSegLog);

    segMapDesc = PRD(Offset(segMap + 1), segMap->cSeg * sizeof(OMFSegDesc));
    if (!segMapDesc) {printf("Can't get SegDescr array, aborting\n");return FALSE;}
203

204 205 206 207 208 209 210 211 212
    for (i = 0; i < segMap->cSeg; i++)
    {
	printf("    SegDescr #%2d\n", i + 1);
	printf("      flags:         %04X\n", segMapDesc[i].flags);
	printf("      ovl:           %u\n", segMapDesc[i].ovl);
	printf("      group:         %u\n", segMapDesc[i].group);
	printf("      frame:         %u\n", segMapDesc[i].frame);
	printf("      iSegName:      %u\n", segMapDesc[i].iSegName);
	printf("      iClassName:    %u\n", segMapDesc[i].iClassName);
213 214
	printf("      offset:        %u\n", segMapDesc[i].offset);
	printf("      cbSeg:         %u\n", segMapDesc[i].cbSeg);
215 216 217 218 219
    }

    return TRUE;
}

220
static BOOL dump_cv_sst_file_index(const OMFDirEntry* omfde)
221 222 223 224 225
{
    /*** NOT YET IMPLEMENTED ***/
    return TRUE;
}

226
static BOOL dump_cv_sst_src_module(const OMFDirEntry* omfde)
227
{
228 229
    int 		        i, j;
    const BYTE*		        rawdata;
230
    const unsigned int *seg_info_dw;
231 232 233 234 235
    const unsigned short*	seg_info_w;
    unsigned		        ofs;
    const OMFSourceModule*	sourceModule;
    const OMFSourceFile*	sourceFile;
    const OMFSourceLine*	sourceLine;
236 237 238 239 240

    rawdata = PRD(Offset(cv_base) + omfde->lfo, omfde->cb);
    if (!rawdata) {printf("Can't get srcModule subsection details, aborting\n");return FALSE;}

    /* FIXME: check ptr validity */
241
    sourceModule = (const void*)rawdata;
242
    printf ("    Module table: Found %d file(s) and %d segment(s)\n",
243 244 245
	    sourceModule->cFile, sourceModule->cSeg);
    for (i = 0; i < sourceModule->cFile; i++)
    {
246
	printf ("      File #%2d begins at an offset of 0x%x in this section\n",
247 248 249 250
		i + 1, sourceModule->baseSrcFile[i]);
    }

    /* FIXME: check ptr validity */
251
    seg_info_dw = (const void*)((const char*)(sourceModule + 1) +
252
			  sizeof(unsigned int) * (sourceModule->cFile - 1));
253
    seg_info_w = (const unsigned short*)(&seg_info_dw[sourceModule->cSeg * 2]);
254 255
    for (i = 0; i <  sourceModule->cSeg; i++)
    {
256
	printf ("      Segment #%2d start = 0x%x, end = 0x%x, seg index = %u\n",
257
		i + 1, seg_info_dw[i * 2], seg_info_dw[(i * 2) + 1],
258 259
		seg_info_w[i]);
    }
260 261
    ofs = sizeof(OMFSourceModule) + sizeof(unsigned int) * (sourceModule->cFile - 1) +
	sourceModule->cSeg * (2 * sizeof(unsigned int) + sizeof(unsigned short));
262 263 264 265 266
    ofs = (ofs + 3) & ~3;

    /* the OMFSourceFile is quite unpleasant to use:
     * we have first:
     * 	unsigned short	number of segments
Austin English's avatar
Austin English committed
267
     *	unsigned short	reserved
268 269
     *	unsigned int	baseSrcLn[# segments]
     *  unsigned int	offset[2 * #segments]
270 271 272 273 274 275
     *				odd indices are start offsets
     *				even indices are end offsets
     * 	unsigned char	string length for file name
     *	char		file name (length is previous field)
     */
    /* FIXME: check ptr validity */
276 277
    sourceFile = (const void*)(rawdata + ofs);
    seg_info_dw = (const void*)((const char*)sourceFile + 2 * sizeof(unsigned short) +
278
			  sourceFile->cSeg * sizeof(unsigned int));
279

280
    ofs += 2 * sizeof(unsigned short) + 3 * sourceFile->cSeg * sizeof(unsigned int);
281

282
    printf("    File table: %.*s\n",
283
	   *(const BYTE*)((const char*)sourceModule + ofs), (const char*)sourceModule + ofs + 1);
284 285 286

    for (i = 0; i < sourceFile->cSeg; i++)
    {
287
	printf ("      Segment #%2d start = 0x%x, end = 0x%x, offset = 0x%x\n",
288 289 290
		i + 1, seg_info_dw[i * 2], seg_info_dw[(i * 2) + 1], sourceFile->baseSrcLn[i]);
    }
    /* add file name length */
291
    ofs += *(const BYTE*)((const char*)sourceModule + ofs) + 1;
292 293
    ofs = (ofs + 3) & ~3;

294
    for (i = 0; i < sourceModule->cSeg; i++)
295
    {
296 297 298
        sourceLine = (const void*)(rawdata + ofs);
        seg_info_dw = (const void*)((const char*)sourceLine + 2 * sizeof(unsigned short));
        seg_info_w = (const void*)(&seg_info_dw[sourceLine->cLnOff]);
299

300 301
	printf ("    Line table #%2d: Found %d line numbers for segment index %d\n",
		i, sourceLine->cLnOff, sourceLine->Seg);
302

303 304
	for (j = 0; j < sourceLine->cLnOff; j++)
	{
305
	    printf ("      Pair #%2d: offset = [0x%8x], linenumber = %d\n",
306 307
		    j + 1, seg_info_dw[j], seg_info_w[j]);
	}
308
	ofs += 2 * sizeof(unsigned short) +
309
	    sourceLine->cLnOff * (sizeof(unsigned int) + sizeof(unsigned short));
310 311 312 313 314 315
	ofs = (ofs + 3) & ~3;
    }

    return TRUE;
}

316
static BOOL dump_cv_sst_align_sym(const OMFDirEntry* omfde)
317
{
318 319 320 321
    const char* rawdata = PRD(Offset(cv_base) + omfde->lfo, omfde->cb);

    if (!rawdata) {printf("Can't get srcAlignSym subsection details, aborting\n");return FALSE;}
    if (omfde->cb < sizeof(DWORD)) return TRUE;
322
    codeview_dump_symbols(rawdata, sizeof(DWORD), omfde->cb);
323 324 325 326

    return TRUE;
}

327
static void dump_codeview_all_modules(const OMFDirHeader *omfdh)
328
{
Eric Pouech's avatar
Eric Pouech committed
329
    unsigned 		i;
330
    const OMFDirEntry*  dirEntry;
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
    const char*		str;

    if (!omfdh || !omfdh->cDir) return;

    dirEntry = PRD(Offset(omfdh + 1), omfdh->cDir * sizeof(OMFDirEntry));
    if (!dirEntry) {printf("Can't read DirEntry array, aborting\n"); return;}

    for (i = 0; i < omfdh->cDir; i++)
    {
	switch (dirEntry[i].SubSection)
	{
	case sstModule:		str = "sstModule";	break;
	case sstAlignSym:	str = "sstAlignSym";	break;
	case sstSrcModule:	str = "sstSrcModule";	break;
	case sstLibraries:	str = "sstLibraries";	break;
	case sstGlobalSym:	str = "sstGlobalSym";	break;
	case sstGlobalPub:	str = "sstGlobalPub";	break;
	case sstGlobalTypes:	str = "sstGlobalTypes";	break;
	case sstSegMap:		str = "sstSegMap";	break;
	case sstFileIndex:	str = "sstFileIndex";	break;
	case sstStaticSym:	str = "sstStaticSym";	break;
	default:		str = "<undefined>";	break;
	}
	printf("Module #%2d (%p)\n", i + 1, &dirEntry[i]);
	printf("  SubSection:            %04X (%s)\n", dirEntry[i].SubSection, str);
	printf("  iMod:                  %d\n", dirEntry[i].iMod);
357 358
	printf("  lfo:                   %d\n", dirEntry[i].lfo);
	printf("  cb:                    %u\n", dirEntry[i].cb);
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381

	switch (dirEntry[i].SubSection)
	{
	case sstModule:		dump_cv_sst_module(&dirEntry[i]);	break;
	case sstAlignSym:	dump_cv_sst_align_sym(&dirEntry[i]);	break;
	case sstSrcModule:	dump_cv_sst_src_module(&dirEntry[i]);	break;
	case sstLibraries:	dump_cv_sst_libraries(&dirEntry[i]);	break;
	case sstGlobalSym:	dump_cv_sst_global_sym(&dirEntry[i]);	break;
	case sstGlobalPub:	dump_cv_sst_global_pub(&dirEntry[i]);	break;
	case sstGlobalTypes:	dump_cv_sst_global_types(&dirEntry[i]);	break;
	case sstSegMap:		dump_cv_sst_seg_map(&dirEntry[i]);	break;
	case sstFileIndex:	dump_cv_sst_file_index(&dirEntry[i]);	break;
	case sstStaticSym:	dump_cv_sst_static_sym(&dirEntry[i]);	break;
	default:		printf("unsupported type %x\n", dirEntry[i].SubSection); break;
	}
	printf("\n");
    }

    return;
}

static void dump_codeview_headers(unsigned long base, unsigned long len)
{
382
    const OMFDirHeader* dirHeader;
383
    const char*         signature;
384
    const OMFDirEntry*  dirEntry;
385
    const OMFSignature* sig;
Eric Pouech's avatar
Eric Pouech committed
386
    unsigned		i;
387 388 389
    int modulecount = 0, alignsymcount = 0, srcmodulecount = 0, librariescount = 0;
    int globalsymcount = 0, globalpubcount = 0, globaltypescount = 0;
    int segmapcount = 0, fileindexcount = 0, staticsymcount = 0;
390

391 392 393 394 395 396
    cv_base = PRD(base, len);
    if (!cv_base) {printf("Can't get full debug content, aborting\n");return;}

    signature = cv_base;

    printf("    CodeView Data\n");
397
    printf("      Signature:         %.4s\n", signature);
398

399
    if (memcmp(signature, "NB10", 4) == 0)
400
    {
401
	const CODEVIEW_PDB_DATA* pdb_data;
402
	pdb_data = cv_base;
403

404
        printf("      Filepos:           0x%08X\n", pdb_data->filepos);
405
	printf("      TimeStamp:         %08X (%s)\n",
406
	       pdb_data->timestamp, get_time_str(pdb_data->timestamp));
407
	printf("      Age:               %08X\n", pdb_data->age);
408
	printf("      Filename:          %s\n", pdb_data->name);
409 410
	return;
    }
411
    if (memcmp(signature, "RSDS", 4) == 0)
412
    {
413
	const OMFSignatureRSDS* rsds_data;
414

415
	rsds_data = cv_base;
416
	printf("      Guid:              %s\n", get_guid_str(&rsds_data->guid));
417
	printf("      Age:               %08X\n", rsds_data->age);
418
	printf("      Filename:          %s\n", rsds_data->name);
419
	return;
420
    }
421

422
    if (memcmp(signature, "NB09", 4) != 0 && memcmp(signature, "NB11", 4) != 0)
423
    {
424
	printf("Unsupported signature (%.4s), aborting\n", signature);
425 426 427
	return;
    }

428 429
    sig = cv_base;

430
    printf("      Filepos:           0x%08X\n", sig->filepos);
431 432

    dirHeader = PRD(Offset(cv_base) + sig->filepos, sizeof(OMFDirHeader));
433 434 435 436
    if (!dirHeader) {printf("Can't get debug header, aborting\n"); return;}

    printf("      Size of header:    0x%4X\n", dirHeader->cbDirHeader);
    printf("      Size per entry:    0x%4X\n", dirHeader->cbDirEntry);
437 438 439
    printf("      # of entries:      0x%8X (%d)\n", dirHeader->cDir, dirHeader->cDir);
    printf("      Offset to NextDir: 0x%8X\n", dirHeader->lfoNextDir);
    printf("      Flags:             0x%8X\n", dirHeader->flags);
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

    if (!dirHeader->cDir) return;

    dirEntry = PRD(Offset(dirHeader + 1), sizeof(OMFDirEntry) * dirHeader->cDir);
    if (!dirEntry) {printf("Can't get DirEntry array, aborting\n");return;}

    for (i = 0; i < dirHeader->cDir; i++)
    {
	switch (dirEntry[i].SubSection)
	{
	case sstModule:		modulecount++;		break;
	case sstAlignSym:	alignsymcount++;	break;
	case sstSrcModule:	srcmodulecount++;	break;
	case sstLibraries:	librariescount++;	break;
	case sstGlobalSym:	globalsymcount++;	break;
	case sstGlobalPub:	globalpubcount++;	break;
	case sstGlobalTypes:	globaltypescount++;	break;
	case sstSegMap:		segmapcount++;		break;
	case sstFileIndex:	fileindexcount++;	break;
	case sstStaticSym:	staticsymcount++;	break;
460
	}
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
    }

    /* This one has to be > 0
     */
    printf ("\nFound: %d sstModule subsections\n", modulecount);

    if (alignsymcount > 0)    printf ("       %d sstAlignSym subsections\n", alignsymcount);
    if (srcmodulecount > 0)   printf ("       %d sstSrcModule subsections\n", srcmodulecount);
    if (librariescount > 0)   printf ("       %d sstLibraries subsections\n", librariescount);
    if (globalsymcount > 0)   printf ("       %d sstGlobalSym subsections\n", globalsymcount);
    if (globalpubcount > 0)   printf ("       %d sstGlobalPub subsections\n", globalpubcount);
    if (globaltypescount > 0) printf ("       %d sstGlobalTypes subsections\n", globaltypescount);
    if (segmapcount > 0)      printf ("       %d sstSegMap subsections\n", segmapcount);
    if (fileindexcount > 0)   printf ("       %d sstFileIndex subsections\n", fileindexcount);
    if (staticsymcount > 0)   printf ("       %d sstStaticSym subsections\n", staticsymcount);

    dump_codeview_all_modules(dirHeader);
}

480
static const char *get_coff_name( const IMAGE_SYMBOL *coff_sym, const char *coff_strtab )
481 482 483 484 485 486 487 488
{
   static       char    namebuff[9];
   const char*          nampnt;

   if( coff_sym->N.Name.Short )
      {
         memcpy(namebuff, coff_sym->N.ShortName, 8);
         namebuff[8] = '\0';
489
         nampnt = namebuff;
490 491 492 493 494 495 496 497 498 499 500
      }
   else
      {
         nampnt = coff_strtab + coff_sym->N.Name.Long;
      }

   if( nampnt[0] == '_' )
      nampnt++;
   return nampnt;
}

501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
static const char* storage_class(BYTE sc)
{
    static char tmp[7];
    switch (sc)
    {
    case IMAGE_SYM_CLASS_STATIC:        return "static";
    case IMAGE_SYM_CLASS_EXTERNAL:      return "extrnl";
    case IMAGE_SYM_CLASS_LABEL:         return "label ";
    }
    sprintf(tmp, "#%d", sc);
    return tmp;
}

void    dump_coff_symbol_table(const IMAGE_SYMBOL *coff_symbols, unsigned num_sym,
                               const IMAGE_SECTION_HEADER *sectHead)
516
{
517
    const IMAGE_SYMBOL              *coff_sym;
518
    const char                      *coff_strtab = (const char *) (coff_symbols + num_sym);
519 520 521
    unsigned int                    i;
    const char                      *nampnt;
    int                             naux;
522

523 524 525
    printf("\nDebug table: COFF format.\n");
    printf("  ID  | seg:offs    [  abs   ] |  Kind  | symbol/function name\n");
    for (i=0; i < num_sym; i++)
526
    {
527 528
        coff_sym = coff_symbols + i;
        naux = coff_sym->NumberOfAuxSymbols;
529

530
        switch (coff_sym->StorageClass)
531
        {
532 533 534 535 536 537 538 539
        case IMAGE_SYM_CLASS_FILE:
            printf("file %s\n", (const char *) (coff_sym + 1));
            break;
        case IMAGE_SYM_CLASS_STATIC:
        case IMAGE_SYM_CLASS_EXTERNAL:
        case IMAGE_SYM_CLASS_LABEL:
            if (coff_sym->SectionNumber > 0)
            {
540
                UINT base = sectHead[coff_sym->SectionNumber - 1].VirtualAddress;
541 542 543
                nampnt = get_coff_name( coff_sym, coff_strtab );

                printf("%05d | %02d:%08x [%08x] | %s | %s\n",
544 545
                       i, coff_sym->SectionNumber - 1, (UINT)coff_sym->Value,
                       base + (UINT)coff_sym->Value,
546 547 548 549 550
                       storage_class(coff_sym->StorageClass), nampnt);
            }
            break;
        default:
            printf("%05d | %s\n", i, storage_class(coff_sym->StorageClass));
551
        }
552 553 554 555 556 557
        /*
         * For now, skip past the aux entries.
         */
        i += naux;
    }
}
558

559
void	dump_coff(unsigned long coffbase, unsigned long len, const IMAGE_SECTION_HEADER* sectHead)
560 561 562 563
{
    const IMAGE_COFF_SYMBOLS_HEADER *coff = PRD(coffbase, len);
    const IMAGE_SYMBOL              *coff_symbols =
                                        (const IMAGE_SYMBOL *) ((const char *)coff + coff->LvaToFirstSymbol);
564

565
    dump_coff_symbol_table(coff_symbols, coff->NumberOfSymbols, sectHead);
566 567
}

568 569 570 571
void	dump_codeview(unsigned long base, unsigned long len)
{
    dump_codeview_headers(base, len);
}
572 573 574

void	dump_frame_pointer_omission(unsigned long base, unsigned long len)
{
575 576 577 578 579 580 581
    const FPO_DATA*     fpo;
    const FPO_DATA*     last;
    const char*         x;
    /* FPO is used to describe nonstandard stack frames */
    printf("Range             #loc #pmt Prlg #reg Info\n"
           "-----------------+----+----+----+----+------------\n");

582
    fpo = PRD(base, len);
583 584 585 586 587 588 589 590 591 592 593 594 595 596
    if (!fpo) {printf("Couldn't get FPO blob\n"); return;}
    last = (const FPO_DATA*)((const char*)fpo + len);

    while (fpo < last && fpo->ulOffStart)
    {
        switch (fpo->cbFrame)
        {
        case FRAME_FPO: x = "FRAME_FPO"; break;
        case FRAME_NONFPO: x = "FRAME_NONFPO"; break;
        case FRAME_TRAP: x = "FRAME_TRAP"; break;
        case FRAME_TSS: x = "case FRAME_TSS"; break;
        default: x = NULL; break;
        }
        printf("%08x-%08x %4u %4u %4u %4u %s%s%s\n",
597 598
               (UINT)fpo->ulOffStart, (UINT)(fpo->ulOffStart + fpo->cbProcSize),
               (UINT)fpo->cdwLocals, fpo->cdwParams, fpo->cbProlog, fpo->cbRegs,
599 600 601
               x, fpo->fHasSEH ? " SEH" : "", fpo->fUseBP ? " UseBP" : "");
        fpo++;
    }
602
}
603 604 605 606 607 608 609

struct stab_nlist
{
    union
    {
        char*                   n_name;
        struct stab_nlist*      n_next;
610
        int                     n_strx;
611 612 613 614
    } n_un;
    unsigned char       n_type;
    char                n_other;
    short               n_desc;
615
    unsigned int        n_value;
616 617
};

618
static const char * const stabs_defs[] = {
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
    NULL,NULL,NULL,NULL,                /* 00 */
    NULL,NULL,NULL,NULL,                /* 08 */
    NULL,NULL,NULL,NULL,                /* 10 */
    NULL,NULL,NULL,NULL,                /* 18 */
    "GSYM","FNAME","FUN","STSYM",       /* 20 */
    "LCSYM","MAIN","ROSYM","PC",        /* 28 */
    NULL,"NSYMS","NOMAP",NULL,          /* 30 */
    "OBJ",NULL,"OPT",NULL,              /* 38 */
    "RSYM","M2C","SLINE","DSLINE",      /* 40 */
    "BSLINE","DEFD","FLINE",NULL,       /* 48 */
    "EHDECL",NULL,"CATCH",NULL,         /* 50 */
    NULL,NULL,NULL,NULL,                /* 58 */
    "SSYM","ENDM","SO",NULL,            /* 60 */
    NULL,NULL,NULL,NULL,                /* 68 */
    NULL,NULL,NULL,NULL,                /* 70 */
    NULL,NULL,NULL,NULL,                /* 78 */
    "LSYM","BINCL","SOL",NULL,          /* 80 */
    NULL,NULL,NULL,NULL,                /* 88 */
    NULL,NULL,NULL,NULL,                /* 90 */
    NULL,NULL,NULL,NULL,                /* 98 */
    "PSYM","EINCL","ENTRY",NULL,        /* a0 */
    NULL,NULL,NULL,NULL,                /* a8 */
    NULL,NULL,NULL,NULL,                /* b0 */
    NULL,NULL,NULL,NULL,                /* b8 */
    "LBRAC","EXCL","SCOPE",NULL,        /* c0 */
    NULL,NULL,NULL,NULL,                /* c8 */
    NULL,NULL,NULL,NULL,                /* d0 */
    NULL,NULL,NULL,NULL,                /* d8 */
    "RBRAC","BCOMM","ECOMM",NULL,       /* e0 */
    "ECOML","WITH",NULL,NULL,           /* e8 */
    "NBTEXT","NBDATA","NBBSS","NBSTS",  /* f0 */
    "NBLCS",NULL,NULL,NULL              /* f8 */
};

void    dump_stabs(const void* pv_stabs, unsigned szstabs, const char* stabstr, unsigned szstr)
{
    int                         i;
    int                         nstab;
    const char*                 ptr;
    char*                       stabbuff;
    unsigned int                stabbufflen;
    const struct stab_nlist*    stab_ptr = pv_stabs;
    const char*                 strs_end;
    char                        n_buffer[16];

    nstab = szstabs / sizeof(struct stab_nlist);
    strs_end = stabstr + szstr;

    /*
     * Allocate a buffer into which we can build stab strings for cases
     * where the stab is continued over multiple lines.
     */
    stabbufflen = 65536;
672
    stabbuff = xmalloc(stabbufflen);
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695

    stabbuff[0] = '\0';

    printf("#Sym n_type n_othr   n_desc n_value  n_strx String\n");

    for (i = 0; i < nstab; i++, stab_ptr++)
    {
        ptr = stabstr + stab_ptr->n_un.n_strx;
        if ((ptr > strs_end) || (ptr + strlen(ptr) > strs_end))
        {
            ptr = "[[*** bad string ***]]";
        }
        else if (ptr[strlen(ptr) - 1] == '\\')
        {
            /*
             * Indicates continuation.  Append this to the buffer, and go onto the
             * next record.  Repeat the process until we find a stab without the
             * '/' character, as this indicates we have the whole thing.
             */
            unsigned    len = strlen(ptr);
            if (strlen(stabbuff) + len > stabbufflen)
            {
                stabbufflen += 65536;
696
                stabbuff = xrealloc(stabbuff, stabbufflen);
697
            }
698
            strcat(stabbuff, ptr);
699 700 701 702 703 704 705 706 707 708 709
            continue;
        }
        else if (stabbuff[0] != '\0')
        {
            strcat(stabbuff, ptr);
            ptr = stabbuff;
        }
        if ((stab_ptr->n_type & 1) || !stabs_defs[stab_ptr->n_type / 2])
            sprintf(n_buffer, "<0x%02x>", stab_ptr->n_type);
        else
            sprintf(n_buffer, "%-6s", stabs_defs[stab_ptr->n_type / 2]);
710
        printf("%4d %s %-8x % 6d %-8x %-6x %s\n",
711 712 713 714 715
               i, n_buffer, stab_ptr->n_other, stab_ptr->n_desc, stab_ptr->n_value,
               stab_ptr->n_un.n_strx, ptr);
    }
    free(stabbuff);
}