tools/cvdump/cvdump.c

/*
 * 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
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

#include "cvdump.h"

DWORD g_dwStartOfCodeView = 0;

int g_exe_mode = TRUE;
IMAGE_DOS_HEADER g_doshdr;
IMAGE_SEPARATE_DEBUG_HEADER g_dbghdr;
IMAGE_NT_HEADERS g_nthdr;

IMAGE_SECTION_HEADER *g_secthdrs = NULL;
int g_numsects;
int g_dbg_dircount;

IMAGE_DEBUG_DIRECTORY *g_debugdirs = NULL;
OMFSignature g_cvSig;
OMFDirHeader g_cvHeader;
OMFDirEntry *g_cvEntries = NULL;
int g_module_count = 0;
OMFModuleFull *g_cvModules = NULL;

void PrintFilePos (FILE *file)
{
#ifdef VERBOSE
    printf (" *** Current file position = %lx\n", ftell (file));
#endif
}

/* Calculate the file offset, based on the RVA.
 */
DWORD GetOffsetFromRVA (DWORD rva)
{
    int i;
    DWORD offset;
    DWORD filepos;
    DWORD sectbegin;

    /* Assumes all RVA's in the section headers are sorted in increasing
     * order (which should be the case).
     */
    for (i = g_dbg_dircount - 1; i >= 0; i--)
    {
	sectbegin = g_secthdrs[i].VirtualAddress;
#ifdef VERBOSE
	printf ("iter = %d, rva = 0x%lx, sectbegin = 0x%lx\n", i, rva, sectbegin);
#endif
	if (rva >= sectbegin)
	    break;
    }

    /* Calculate the difference between the section's RVA and file position.
     */
    offset = g_secthdrs[i].VirtualAddress - g_secthdrs[i].PointerToRawData;

    /* Calculate the actual file position.
     */
    filepos = rva - offset;

#ifdef VERBOSE
    printf (">>> Found RVA 0x%lx in section %d, at 0x%lx (section offset = 0x%lx)\n",
	    rva, i, filepos, offset);
#endif

    return filepos;
}

int DumpFileHeaders (FILE *debugfile)
{
    CVHeaderType hdrtype;

    hdrtype = GetHeaderType (debugfile);

    if (hdrtype == CV_DOS)
    {
	if (!ReadDOSFileHeader (debugfile, &g_doshdr))
	    return FALSE;

	printf ("\n============================================================\n");
	printf ("                   DOS FILE HEADER\n");
	printf ("============================================================\n");

	printf ("Magic Signature = [0x%4x]\n", g_doshdr.e_magic);
	printf ("e_cblp          = [0x%4x]\n", g_doshdr.e_cblp);
	printf ("e_cp            = [0x%4x]\n", g_doshdr.e_cp);
	printf ("e_cric          = [0x%4x]\n", g_doshdr.e_crlc);
	printf ("e_cparhdr       = [0x%4x]\n", g_doshdr.e_cparhdr);
	printf ("e_minalloc      = [0x%4x]\n", g_doshdr.e_minalloc);
	printf ("e_maxalloc      = [0x%4x]\n", g_doshdr.e_maxalloc);
	printf ("e_ss            = [0x%4x]\n", g_doshdr.e_ss);
	printf ("e_sp            = [0x%4x]\n", g_doshdr.e_sp);
	printf ("e_csum          = [0x%4x]\n", g_doshdr.e_csum);
	printf ("e_ip            = [0x%4x]\n", g_doshdr.e_ip);
	printf ("e_cs            = [0x%4x]\n", g_doshdr.e_cs);
	printf ("e_lfarlc        = [0x%4x]\n", g_doshdr.e_lfarlc);
	printf ("e_ovno          = [0x%4x]\n", g_doshdr.e_ovno);
	printf ("e_res           = [0x%4x ...]\n", g_doshdr.e_res[0]);  /* worth FIXME? */
	printf ("e_oemid         = [0x%4x]\n", g_doshdr.e_oemid);
	printf ("e_oeminfo       = [0x%4x]\n", g_doshdr.e_oeminfo);
	printf ("e_res2          = [0x%4x ...]\n", g_doshdr.e_res2[0]); /* worth FIXME? */
	printf ("e_lfanew        = [0x%8lx]\n", g_doshdr.e_lfanew);

	/* Roll forward to next type */
	hdrtype = GetHeaderType (debugfile);
    }

    if (hdrtype == CV_NT)
    {
	if (!ReadPEFileHeader (debugfile, &g_nthdr))
	    return FALSE;
	
	printf ("\n============================================================\n");
	printf ("                PE EXECUTABLE FILE HEADER\n");
	printf ("============================================================\n");

	printf ("Signature               = [0x%8lx]\n", g_nthdr.Signature);
	printf ("Machine                 = [0x%4x]\n", g_nthdr.FileHeader.Machine);
	printf ("# of Sections           = [0x%4x]\n", g_nthdr.FileHeader.NumberOfSections);
	printf ("Time/Date Stamp         = [0x%08lx]\n", g_nthdr.FileHeader.TimeDateStamp);
	printf ("Pointer to Symbol Table = [0x%8lx]\n", g_nthdr.FileHeader.PointerToSymbolTable);
	printf ("# of Symbols            = [0x%8lx]\n", g_nthdr.FileHeader.NumberOfSymbols);
	printf ("Size of Opt. Hdr        = [0x%4x]\n", g_nthdr.FileHeader.SizeOfOptionalHeader);
	printf ("Characteristics         = [0x%4x]\n", g_nthdr.FileHeader.Characteristics);

	printf ("\n============================================================\n");
	printf ("                   NT FILE HEADER\n");
	printf ("============================================================\n");

	printf ("Magic          = [0x%4x]\n", g_nthdr.OptionalHeader.Magic);
	printf ("Linker Version = %d.%d\n", g_nthdr.OptionalHeader.MajorLinkerVersion,
		g_nthdr.OptionalHeader.MinorLinkerVersion);
	printf ("Size of Code   = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfCode);
	printf ("Init. Data     = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfInitializedData);
	printf ("Uninit. Data   = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfUninitializedData);
	printf ("Entry Point    = [0x%8lx]\n", g_nthdr.OptionalHeader.AddressOfEntryPoint);
	printf ("Base of Code   = [0x%8lx]\n", g_nthdr.OptionalHeader.BaseOfCode);
	printf ("Base of Data   = [0x%8lx]\n", g_nthdr.OptionalHeader.BaseOfData);

	printf ("\n============================================================\n");
	printf ("                 NT OPTIONAL FILE HEADER\n");
	printf ("============================================================\n");

	printf ("Image Base            = [0x%8lx]\n", g_nthdr.OptionalHeader.ImageBase);
	printf ("Section Alignment     = [0x%8lx]\n", g_nthdr.OptionalHeader.SectionAlignment);
	printf ("File Alignment        = [0x%8lx]\n", g_nthdr.OptionalHeader.FileAlignment);
	printf ("OS Version            = %d.%d\n", g_nthdr.OptionalHeader.MajorOperatingSystemVersion,
		g_nthdr.OptionalHeader.MinorOperatingSystemVersion);
	printf ("Image Version         = %d.%d\n", g_nthdr.OptionalHeader.MajorImageVersion,
		g_nthdr.OptionalHeader.MinorImageVersion);
	printf ("Subsystem Version     = %d.%d\n", g_nthdr.OptionalHeader.MajorSubsystemVersion,
		g_nthdr.OptionalHeader.MinorSubsystemVersion);
	printf ("Size of Image         = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfImage);
	printf ("Size of Headers       = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfHeaders);
	printf ("Checksum              = [0x%8lx]\n", g_nthdr.OptionalHeader.CheckSum);
	printf ("Subsystem             = [0x%4x]\n", g_nthdr.OptionalHeader.Subsystem);
	printf ("DLL Characteristics   = [0x%4x]\n", g_nthdr.OptionalHeader.DllCharacteristics);
	printf ("Size of Stack Reserve = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfStackReserve);
	printf ("Size of Stack Commit  = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfStackCommit);
	printf ("Size of Heap Reserve  = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfHeapReserve);
	printf ("Size of Heap Commit   = [0x%8lx]\n", g_nthdr.OptionalHeader.SizeOfHeapCommit);
	printf ("Loader Flags          = [0x%8lx]\n", g_nthdr.OptionalHeader.LoaderFlags);
	printf ("# of RVA              = [0x%8lx]\n", g_nthdr.OptionalHeader.NumberOfRvaAndSizes);

	printf ("\n============================================================\n");
	printf ("           RVA (RELATIVE VIRTUAL ADDRESS) TABLE\n");
	printf ("============================================================\n");

	printf ("NAME                    RVA         SIZE\n");
	printf ("Export            [0x%8lx] [0x%8lx]\n",
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size);
	printf ("Import            [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size);
	printf ("Resource          [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size);
	printf ("Exception         [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size);
	printf ("Security          [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size);
	printf ("Base Relocations  [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size);
	printf ("Debug             [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size);
	printf ("Description       [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COPYRIGHT].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COPYRIGHT].Size);
	printf ("Special           [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].Size);
	printf ("Thread (TLS)      [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].Size);
	printf ("Load Config       [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].Size);
	printf ("Bound Import      [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size);
	printf ("Import Addr Tbl   [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size);
	printf ("Delay Import      [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].Size);
	printf ("COM Descriptor    [0x%8lx] [0x%8lx]\n", 
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress,
		g_nthdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size);

    }
    else if (hdrtype == CV_DBG)
    {
	if (!ReadDBGFileHeader (debugfile, &g_dbghdr))
	    return FALSE;

	g_exe_mode = FALSE;
#ifdef VERBOSE
	printf ("[ Found DBG header...file is not a PE executable. ]\n");
#endif

	printf ("\n============================================================\n");
	printf ("          STANDALONE DEBUG FILE HEADER (.DBG)\n");
	printf ("============================================================\n");

	printf ("Signature          = [0x%4x]\n", g_dbghdr.Signature);
	printf ("Flags              = [0x%4x]\n", g_dbghdr.Flags);
	printf ("Machine            = [0x%4x]\n", g_dbghdr.Machine);
	printf ("Characteristics    = [0x%4x]\n", g_dbghdr.Characteristics);
	printf ("TimeDateStamp      = [0x%8lx]\n", g_dbghdr.TimeDateStamp);
	printf ("CheckSum           = [0x%8lx]\n", g_dbghdr.CheckSum);
	printf ("ImageBase          = [0x%8lx]\n", g_dbghdr.ImageBase);
	printf ("SizeOfImage        = [0x%8lx]\n", g_dbghdr.SizeOfImage);
	printf ("NumberOfSections   = [0x%8lx]\n", g_dbghdr.NumberOfSections);
	printf ("ExportedNamesSize  = [0x%8lx]\n", g_dbghdr.ExportedNamesSize);
	printf ("DebugDirectorySize = [0x%8lx]\n", g_dbghdr.DebugDirectorySize);

	return TRUE;
    }

    return TRUE;
}

int DumpSectionHeaders (FILE *debugfile)
{
    int i;

    printf ("\n============================================================\n");
    printf ("                 COFF SECTION HEADERS\n");
    printf ("============================================================\n");

    PrintFilePos (debugfile);
    if (!ReadSectionHeaders (debugfile, g_numsects, &g_secthdrs))
	return FALSE;

    /* Print out a quick list of section names
     */
    for (i = 0; i < g_numsects; i++)
	printf ("%8s (0x%08lx bytes long, starts at 0x%08lx)\n", g_secthdrs[i].Name,
		g_secthdrs[i].SizeOfRawData, g_secthdrs[i].PointerToRawData);

    /* Print out bulk of info
     */
    for (i = 0; i < g_numsects; i++)
    {
	printf ("\nContents of IMAGE_SECTION_HEADER %s:\n\n", g_secthdrs[i].Name);

	printf ("Name                 = %s\n", g_secthdrs[i].Name);
	printf ("VirtualSize          = [0x%8lx]\n", g_secthdrs[i].Misc.VirtualSize);
	printf ("VirtualAddress       = [0x%8lx]\n", g_secthdrs[i].VirtualAddress);
	printf ("SizeOfRawData        = [0x%8lx]\n", g_secthdrs[i].SizeOfRawData);
	printf ("PointerToRawData     = [0x%8lx]\n", g_secthdrs[i].PointerToRawData);
	printf ("PointerToRelocations = [0x%8lx]\n", g_secthdrs[i].PointerToRelocations);
	printf ("PointerToLinenumbers = [0x%8lx]\n", g_secthdrs[i].PointerToLinenumbers);
	printf ("NumberOfRelocations  = [0x%4x]\n", g_secthdrs[i].NumberOfRelocations);
	printf ("NumberOfLinenumbers  = [0x%4x]\n", g_secthdrs[i].NumberOfLinenumbers);
	printf ("Characteristics      = [0x%8lx]\n", g_secthdrs[i].Characteristics);
    }

    return TRUE;
}

void PrintDebugDirectoryType (DWORD type)
{
    switch (type)
    {
    case IMAGE_DEBUG_TYPE_UNKNOWN:
	printf ("<Unknown Directory> - %ld\n", type);
	break;
    case IMAGE_DEBUG_TYPE_COFF:
	printf ("COFF Directory:\n");
	break;
    case IMAGE_DEBUG_TYPE_CODEVIEW:
	printf ("CodeView Directory:\n");
	break;
    case IMAGE_DEBUG_TYPE_FPO:
	printf ("FPO Directory:\n");
	break;
    case IMAGE_DEBUG_TYPE_MISC:
	printf ("MISC Directory:\n");
	break;

    default:
	printf ("<Undefined Directory> - %ld\n", type);
    }
}

int DumpDebugDir (FILE *debugfile)
{
    int i;
    int filepos;

    printf ("\n============================================================\n");
    printf ("                CODEVIEW DEBUG DIRECTORY\n");
    printf ("============================================================\n");

    PrintFilePos (debugfile);

    printf ("Found %d CodeView subsection%c...\n", g_dbg_dircount,
	    (g_dbg_dircount == 1) ? '.' : 's');

    if (g_dbg_dircount == 0)
	return FALSE;

    /* Find the location of the debug directory table.
     */
    if (g_exe_mode)
    {
	/* Convert the RVA to a file offset.
	 */
	filepos = GetOffsetFromRVA (g_nthdr.OptionalHeader.DataDirectory[IMAGE_FILE_DEBUG_DIRECTORY].VirtualAddress);

	fseek (debugfile, filepos, SEEK_SET);
	PrintFilePos (debugfile);
    }
#if 0
    else
    {
	int i;

	/* Find the .rdata section.
	 */
	for (i = 0; i < g_numsects; i++)
	    if (strcmp (g_secthdrs[i].Name, ".rdata") == 0)
		break;

	filepos = g_secthdrs[i].PointerToRawData;
    }
#endif

    if (!ReadDebugDir (debugfile, g_dbg_dircount, &g_debugdirs))
	return FALSE;

    /* Print out the contents of the directories.
     */
    for (i = 0; i < g_dbg_dircount; i++)
    {
	/* Remember start of debug data...for later
	 */
	if (g_debugdirs[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW)
	{
	    g_dwStartOfCodeView = g_debugdirs[i].PointerToRawData;
#ifdef VERBOSE
	    printf ("\n[ Found start of CodeView data, at 0x%lx ]\n\n", g_dwStartOfCodeView);
#endif
	}

	printf ("\n");
	PrintDebugDirectoryType (g_debugdirs[i].Type);
	printf ("  Characteristics  = [0x%8lx]\n", g_debugdirs[i].Characteristics);
	printf ("  TimeDateStamp    = [0x%8lx]\n", g_debugdirs[i].TimeDateStamp);
	printf ("  Version          = %d.%d\n", g_debugdirs[i].MajorVersion, g_debugdirs[i].MinorVersion);
	printf ("  SizeOfData       = [0x%8lx]\n", g_debugdirs[i].SizeOfData);
	printf ("  AddressOfRawData = [0x%8lx]\n", g_debugdirs[i].AddressOfRawData);
	printf ("  PointerToRawData = [0x%8lx]\n", g_debugdirs[i].PointerToRawData);
    }

    free (g_debugdirs);
    return TRUE;
}

void PrintSubsectionName (int ssNum)
{
    switch (ssNum)
    {
    case sstModule:
	printf ("sstModule");
	break;
    case sstAlignSym:
	printf ("sstAlignSym");
	break;
    case sstSrcModule:
	printf ("sstSrcModule");
	break;
    case sstLibraries:
	printf ("sstLibraries");
	break;
    case sstGlobalSym:
	printf ("sstGlobalSym");
	break;
    case sstGlobalPub:
	printf ("sstGlobalPub");
	break;
    case sstGlobalTypes:
	printf ("sstGlobalTypes");
	break;
    case sstSegMap:
	printf ("sstSegMap");
	break;
    case sstFileIndex:
	printf ("sstFileIndex");
	break;
    case sstStaticSym:
	printf ("sstStaticSym");
	break;

    default:
	printf ("<undefined> - %x", ssNum);
    }
}

int DumpCodeViewSummary (OMFDirEntry *entries, long entrycount)
{
    int i;
    int modulecount = 0, alignsymcount = 0, srcmodulecount = 0, librariescount = 0;
    int globalsymcount = 0, globalpubcount = 0, globaltypescount = 0;
    int segmapcount = 0, fileindexcount = 0, staticsymcount = 0;

    if (entries == NULL || entrycount == 0)
	return FALSE;

    for (i = 0; i < entrycount; i++)
    {
	switch ((int)g_cvEntries[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;
	}	
    }

    /* 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);
    
    return TRUE;
}

int DumpCodeViewHeaders (FILE *debugfile)
{
    printf ("\n============================================================\n");
    printf ("                    CODEVIEW HEADERS\n");
    printf ("============================================================\n");

    PrintFilePos (debugfile);

    fseek (debugfile, g_dwStartOfCodeView, SEEK_SET);
    printf ("CodeView Directory Table begins at filepos = 0x%lx\n\n", ftell (debugfile));

    if (!ReadCodeViewHeader (debugfile, &g_cvSig, &g_cvHeader))
	return FALSE;

    printf ("Signature   = %.4s\n", g_cvSig.Signature);
    printf ("filepos     = [0x%8lx]\n", g_cvSig.filepos);
    printf ("File Location of debug directories = [0x%8lx]\n\n", g_cvSig.filepos + g_dwStartOfCodeView);

    printf ("Size of header    = [0x%4x]\n", g_cvHeader.cbDirHeader);
    printf ("Size per entry    = [0x%4x]\n", g_cvHeader.cbDirEntry);
    printf ("# of entries      = [0x%8lx] (%ld)\n", g_cvHeader.cDir, g_cvHeader.cDir);
    printf ("Offset to NextDir = [0x%8lx]\n", g_cvHeader.lfoNextDir);
    printf ("Flags             = [0x%8lx]\n", g_cvHeader.flags);

    if (!ReadCodeViewDirectory (debugfile, g_cvHeader.cDir, &g_cvEntries))
	return FALSE;

    DumpCodeViewSummary (g_cvEntries, g_cvHeader.cDir);

    return TRUE;
}

/*
 * Print out the info contained in the sstModule section of a single module
 */
int DumpModuleInfo (int index)
{
    int segnum;

    if (g_cvEntries == NULL || g_cvModules == NULL)
	return FALSE;

    printf ("---------------------- sstModule ----------------------\n");

    /* Print out some juicy module data
     */
    printf ("  '%s' module holds %d segment(s) (style %c%c)\n",
	    g_cvModules[index].Name, g_cvModules[index].cSeg,
	    g_cvModules[index].Style[0], g_cvModules[index].Style[1]);

    /* Print out info from module's OMFDirEntry
     */
    printf ("             file offset = [0x%8lx]\n", g_cvEntries[index].lfo);
    printf ("             size        = [0x%8lx]\n\n", g_cvEntries[index].cb);

    for (segnum = 0; segnum < g_cvModules[index].cSeg; segnum++)
    {
	printf ("  segment #%d: offset = [0x%8lx], size = [0x%8lx]\n",
		g_cvModules[index].SegInfo[segnum].Seg, 
		g_cvModules[index].SegInfo[segnum].Off, 
		g_cvModules[index].SegInfo[segnum].cbSeg);
    }

    return TRUE;
}

int DumpGlobalPubInfo (int index, FILE *debugfile)
{
    long fileoffset;
    unsigned long sectionsize;
    OMFSymHash header;
    BYTE *symbols;
    BYTE *curpos;
    PUBSYM32 *sym;
    char symlen;
    char *symname;
    int recordlen;
    char nametmp[256] = { 0 };  /* Zero out */

    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstGlobalPub)
	return FALSE;

    printf ("-------------------- sstGlobalPub --------------------\n");

    sectionsize = g_cvEntries[index].cb;
    printf ("  offset = [0x%8lx]\n  size   = [0x%8lx]\n", g_cvEntries[index].lfo, sectionsize);

    fileoffset = g_dwStartOfCodeView + g_cvEntries[index].lfo;
    printf ("  GlobalPub section starts at file offset 0x%lx\n", fileoffset);
    printf ("  Symbol table starts at 0x%lx\n", fileoffset + sizeof (OMFSymHash));

#ifdef VERBOSE
    printf (" [iMod = %d] [index = %d]\n", g_cvEntries[index].iMod, index);
#endif

    printf ("\n                       ----- Begin Symbol Table -----\n");
    printf ("  (type)      (symbol name)                 (offset)      (len) (seg) (ind)\n");

    /* Read the section header.
     */
    if (!ReadChunk (debugfile, (void*)&header, sizeof (OMFSymHash), fileoffset))
	return FALSE;
    PrintFilePos (debugfile);

    /* Read the entire sstGlobalPub symbol table.
     */
    symbols = malloc (header.cbSymbol);
    if (!ReadChunk (debugfile, (void*)symbols, header.cbSymbol, -1))
	return FALSE;

    /* We don't know how many symbols are in this block of memory...only what
     * the total size of the block is.  Because the symbol's name is tacked
     * on to the end of the PUBSYM32 struct, each symbol may take up a different
     * # of bytes.  This makes it harder to parse through the symbol table,
     * since we won't know the exact location of the following symbol until we've
     * already parsed the current one.
     */
    curpos = symbols;
    while (curpos < symbols + header.cbSymbol)
    {
	/* Point to the next PUBSYM32 in the table.
	 */
	sym = (PUBSYM32*)curpos;

	/* Ugly hack to find the start of the (length-prefixed) name string.
	 * Must be careful about pointer math (i.e. can't use 'sym').
	 *
	 * FIXME: Should take into account the length...this approach hopes
	 * for a coincidental NULL after the string.
	 */
	symlen = *(curpos + sizeof (PUBSYM32));
	symname = curpos + sizeof (PUBSYM32) + 1;

	/* "  (type) (symbol name)         (offset)   (len) (seg) (typind)" */

	snprintf (nametmp, symlen + 1, "%s", symname);
	printf ("  0x%04x  %-30.30s  [0x%8lx]  [0x%4x]  %d     %ld\n",
		sym->rectyp, nametmp, sym->off, sym->reclen, sym->seg, sym->typind);

	/* The entire record is null-padded to the nearest 4-byte
	 * boundary, so we must do a little extra math to keep things straight.
	 */
	recordlen = sym->reclen;
	if (recordlen % 4)
	    recordlen += 4 - (recordlen % 4);
	
	/*  printf ("Padding length of %d bytes to %d\n", sym->reclen, recordlen); */

	curpos += recordlen;
    }

    printf ("  Freeing symbol memory...\n");
    free (symbols);

    return TRUE;
}

int DumpGlobalSymInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstGlobalSym)
	return FALSE;

    /*** NOT YET IMPLEMENTED ***/
    printf ("---Found section ");
    PrintSubsectionName (g_cvEntries[index].SubSection);
    printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d---\n", index + 1);

    return TRUE;
}

int DumpStaticSymInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstStaticSym)
	return FALSE;

    /*** NOT YET IMPLEMENTED ***/
    printf ("---Found section ");
    PrintSubsectionName (g_cvEntries[index].SubSection);
    printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d---\n", index + 1);

    return TRUE;
}

int DumpLibrariesInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstLibraries)
	return FALSE;

    /*** NOT YET IMPLEMENTED ***/
    printf ("---Found section ");
    PrintSubsectionName (g_cvEntries[index].SubSection);
    printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d---\n", index + 1);

    return TRUE;
}

int DumpGlobalTypesInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstGlobalTypes)
	return FALSE;

    /*** NOT YET IMPLEMENTED ***/
    printf ("---Found section ");
    PrintSubsectionName (g_cvEntries[index].SubSection);
    printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d---\n", index + 1);

    return TRUE;
}

int DumpSegMapInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstSegMap)
	return FALSE;

    printf ("-------------------- sstSegMap --------------------\n");

    printf ("---Found section ");
    PrintSubsectionName (g_cvEntries[index].SubSection);
    printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d---\n", index + 1);

    return TRUE;
}

int DumpFileIndexInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstFileIndex)
	return FALSE;

    /*** NOT YET IMPLEMENTED ***/
    printf ("---Found section ");
    PrintSubsectionName (g_cvEntries[index].SubSection);
    printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d---\n", index + 1);

    return TRUE;
}

int DumpSrcModuleInfo (int index, FILE *debugfile)
{
    int i;
    int fileoffset;
    BYTE *rawdata;
    BYTE *curpos;
    short filecount;
    short segcount;

    int moduledatalen;
    int filedatalen;
    int linedatalen;

    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstSrcModule)
	return FALSE;

    printf ("--------------------- sstSrcModule --------------------\n");
    printf ("             file offset = [0x%8lx]\n", g_dwStartOfCodeView + g_cvEntries[index].lfo);
    printf ("             size        = [0x%8lx]\n", g_cvEntries[index].cb);

    /* Where in the .DBG file should we start reading?
     */
    fileoffset = g_dwStartOfCodeView + g_cvEntries[index].lfo;

    /* Allocate a chunk of memory for the entire sstSrcModule
     */
    rawdata = malloc (g_cvEntries[index].cb);
    if (!rawdata)
    {
	printf ("ERROR - Unable to allocate %ld bytes for DumpSrcModuleInfo()\n",
		g_cvEntries[index].cb);
	return FALSE;
    }

    /* Read in the entire sstSrcModule from the .DBG file.  We'll process it
     * bit by bit, but passing memory pointers into the various functions in
     * cvprint.c.
     */
    if (!ReadChunk (debugfile, (void*)rawdata, g_cvEntries[index].cb, fileoffset))
	return FALSE;

    moduledatalen = PrintSrcModuleInfo (rawdata, &filecount, &segcount);
#ifdef VERBOSE
    printf ("*** PrintSrcModuleInfo() returned %d\n", moduledatalen);
#endif

    curpos = rawdata + moduledatalen;
    filedatalen = PrintSrcModuleFileInfo (curpos);
#ifdef VERBOSE
    printf ("*** PrintSrcModuleFileInfo() returned %d\n", filedatalen);
#endif

    curpos += filedatalen;
    for (i = 0; i < segcount; i++)
    {
	linedatalen = PrintSrcModuleLineInfo (curpos, i);
#ifdef VERBOSE
	printf ("*** PrintSrcModuleLineInfo() returned %d\n", linedatalen);
#endif

	curpos += linedatalen;
    }

    free (rawdata);

    return TRUE;
}

int DumpAlignSymInfo (int index, FILE *debugfile)
{
    if (g_cvEntries == NULL || debugfile == NULL || 
	g_cvEntries[index].SubSection != sstAlignSym)
	return FALSE;

    /*** NOT YET IMPLEMENTED ***/
    printf ("--------------------- sstAlignSym ---------------------\n");
    printf ("  [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
    printf (" of module #%d\n", index + 1);

    return TRUE;
}

/*
 * Print out the info of all related modules (e.g. sstAlignSym, sstSrcModule)
 * for the desired sub-section (i.e. sstModule).
 */
int DumpRelatedSections (int index, FILE *debugfile)
{
    int i;

    if (g_cvEntries == NULL)
	return FALSE;

    /*  printf ("...Scanning %ld entries for matches on module #%d\n", g_cvHeader.cDir, module_num); */

    for (i = 0; i < g_cvHeader.cDir; i++)
    {
	if (g_cvEntries[i].iMod != (index + 1) ||
	    g_cvEntries[i].SubSection == sstModule)
	    continue;

	/* Pass in index of entry in g_cvEntries array to individual sub-section
	 * dumping functions.  Each function will figure out where in the file its
	 * sub-section lies and seek the file position itself, before parsing out
	 * its data.
	 */
	switch (g_cvEntries[i].SubSection)
	{
	case sstAlignSym:
	    DumpAlignSymInfo (i, debugfile);
	    break;
	case sstSrcModule:
	    DumpSrcModuleInfo (i, debugfile);
	    break;

	default:
	    printf ("---Found section ");
	    PrintSubsectionName (g_cvEntries[i].SubSection);
	    printf (" [iMod = %d] [i = %d]", g_cvEntries[i].iMod, i);
	    printf (" of module #%d---\n", index + 1);
	}
    }

    return TRUE;
}

int DumpMiscSections (int index, FILE *debugfile)
{
    /* The module # 65535 is reserved for all free-standing modules, not
     * associated with a sstModule sub-section.  These are the only sections
     * we wish to process here.
     */
    if (g_cvEntries == NULL || g_cvEntries[index].iMod != 65535)
	return FALSE;

    /* Pass in index of entry in g_cvEntries array to individual sub-section
     * dumping functions.  Each function will figure out where in the file its
     * sub-section lies and seek the file position itself, before parsing out
     * its data.
     */
    switch (g_cvEntries[index].SubSection)
    {
    case sstGlobalPub:
	DumpGlobalPubInfo (index, debugfile);
	break;
    case sstGlobalSym:
	DumpGlobalSymInfo (index, debugfile);
	break;
    case sstStaticSym:
	DumpStaticSymInfo (index, debugfile);
	break;
    case sstLibraries:
	DumpLibrariesInfo (index, debugfile);
	break;
    case sstGlobalTypes:
	DumpGlobalTypesInfo (index, debugfile);
	break;
    case sstSegMap:
	DumpSegMapInfo (index, debugfile);
	break;
    case sstFileIndex:
	DumpFileIndexInfo (index, debugfile);
	break;

    default:
	printf ("---Found section ");
	PrintSubsectionName (g_cvEntries[index].SubSection);
	printf (" [iMod = %d] [index = %d]", g_cvEntries[index].iMod, index);
	printf (" of module #%d---\n", index + 1);
    }

    return TRUE;
}

int DumpAllModules (FILE *debugfile)
{
    int i;

    if (g_cvHeader.cDir == 0 || g_cvEntries == NULL)
    {
	printf ("ERROR: Bailing out of Module Data Dump\n");
	printf ("%ld %p\n", g_cvHeader.cDir, g_cvEntries);
	return FALSE;
    }

    printf ("\n============================================================\n");
    printf ("                    MODULE LISTING\n");
    printf ("============================================================\n");

    /* Seek to beginning of debug data
     */
    fseek (debugfile, g_dwStartOfCodeView + g_cvEntries[0].lfo, SEEK_SET);
#ifdef VERBOSE
    printf ("[ Moving to filepos = 0x%lx to read in CodeView module info ]\n",
	    ftell (debugfile));
#endif

    /* Load all OMFModuleFull data from file into memory
     */
    if (!ReadModuleData (debugfile, g_cvHeader.cDir, g_cvEntries,
			 &g_module_count, &g_cvModules))
    {
	PrintFilePos (debugfile);
	return FALSE;
    }

    /* Print out bulk of info (depends on the fact that all sstModule's
     * are packed at the beginning of the array).
     */
    printf ("Found %d modules\n", g_module_count);
    for (i = 0; i < g_module_count; i++)
    {
	printf ("\n====================== Module #%d ======================\n", i + 1);
	DumpModuleInfo (i);
	DumpRelatedSections (i, debugfile);
	printf ("=======================================================\n");
    }

    printf ("\n============================================================\n");
    printf ("                  MISCELLANEOUS MODULES\n");
    printf ("============================================================\n");

    for (i = 0; i < g_cvHeader.cDir; i++)
    {
	DumpMiscSections (i, debugfile);
    }

    return TRUE;
}


/*
 * Free Global data used by OMFModuleFull structs.  Can't just use free() because
 * the 'SegInfo' and 'Name' fields also have allocated memory.
 */
void FreeCVModules ()
{
    int i;
    OMFModuleFull *module;

    for (i = 0; i < g_module_count; i++)
    {
	module = &(g_cvModules[i]);

	free (module->SegInfo);
	free (module->Name);
	free (module);
    }
}

int DumpCVFile (LPSTR filename)
{
    FILE *debugfile;

    if (strlen (filename) == 0)
	return (-1);

    debugfile = fopen (filename, "r");
    if (debugfile == NULL)
    {
	printf ("============================================================\n");
	printf ("   ERROR: Unable to open file [%s]\n", filename);
	printf ("============================================================\n");
	return (-1);
    }

    printf ("============================================================\n");
    printf ("        Performing bindump on file %s\n", filename);
    printf ("============================================================\n\n");

    if (!DumpFileHeaders (debugfile))
    {
	printf ("============================================================\n");
	printf ("   ERROR: Bailed out while printing file headers!\n");
	printf ("============================================================\n");
	return (-1);
    }

    if (g_exe_mode)
	g_numsects = g_nthdr.FileHeader.NumberOfSections;
    else
	g_numsects = g_dbghdr.NumberOfSections;

    if (!DumpSectionHeaders (debugfile))
    {
	printf ("============================================================\n");
	printf ("   ERROR: Bailed out while printing section headers\n");
	printf ("============================================================\n");
	return (-1);
    }

    if (g_exe_mode)
	g_dbg_dircount = g_nthdr.OptionalHeader.DataDirectory[IMAGE_FILE_DEBUG_DIRECTORY].Size /
	    sizeof (IMAGE_DEBUG_DIRECTORY);
    else
	g_dbg_dircount = g_dbghdr.DebugDirectorySize / sizeof (IMAGE_DEBUG_DIRECTORY);

#ifdef VERBOSE
    printf ("\n[ Found %d debug directories in %s file. ]\n", g_dbg_dircount,
	    g_exe_mode ? "PE" : "DBG");
#endif

    if (!DumpDebugDir (debugfile))
    {
	printf ("============================================================\n");
	printf ("   ERROR: Bailed out while printing Debug Directories\n");
	printf ("============================================================\n");
	return (-1);
    }

    /* Only dump CodeView data if we know where it is!
     */
    if (g_dwStartOfCodeView == 0)
    {
	printf ("============================================================\n");
	printf ("   ERROR: Unable to find CodeView info!\n");
	printf ("============================================================\n");
	return (-1);
    }

    if (!DumpCodeViewHeaders (debugfile))
    {
	printf ("============================================================\n");
	printf ("   ERROR: Bailed out while printing CodeView headers\n");
	printf ("============================================================\n");
	return (-1);
    }

    if (!DumpAllModules (debugfile))
    {
	printf ("============================================================\n");
	printf ("   ERROR: Bailed out while printing CodeView debug info\n");
	printf ("============================================================\n");
	return (-1);
    }

    /* Clean up our trash
     */
    printf ("Shutting down...\n");

    free (g_debugdirs);
    free (g_secthdrs);

    /* FIXME: For some reason, this call segfaults...check it out later */
    /*  free (g_cvEntries); */

    /*  printf ("Freeing module data..."); */
    /*  FreeCVModules (); */

    return 0;
}

int main(int argc, char *argv[])
{
    int i;

    if (argc == 1)
    {
        printf ("Usage:\n\tcvdump FILE [FILES...]\n");
        return (-1);
    }

    for (i = 1; i < argc; i++)
       DumpCVFile (argv[i]);
    return 0;
}