coreclr BuildTools for github builds - instead of building the tools (which do not...

This contains changes for following:
     1. Binplace & sign following binaries
       a. pdbtypematch.exe (only build in x86 ret .... build errors for other flavors)
       b. dactableGen.exe
       c. dialib.dll
       d. GenClrDebugResource.exe
       e. InjectResource.exe
     2. add sources of PdbTypeMatch tools in github
     3. bump up the version of coreclr buildtools package to 1.0.4
     4. add above tools to coreclr buildtools package
     5. remove bclrewriter from coreclr buildtools package
     6. build dotnet.builtools.coreclr package only for x86 ret builds as pdbtypematch.exe only builds for ret flavor.

[tfs-changeset: 1564332]

diff --git a/src/ToolBox/PdbTypeMatch/.gitmirror b/src/ToolBox/PdbTypeMatch/.gitmirror
new file mode 100644 (file)
index 0000000..f507630
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/.gitmirror
@@ -0,0 +1 @@
+Only contents of this folder, excluding subfolders, will be mirrored by the Git-TFS Mirror. 
\ No newline at end of file

diff --git a/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp
new file mode 100644 (file)
index 0000000..74090f8
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp
@@ -0,0 +1,2022 @@
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+
+#include "stdafx.h"
+#include "PdbTypeMatch.h"
+#include "PrintSymbol.h"
+
+#include "Callback.h"
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <sys/stat.h>
+#include <algorithm>
+#include "Shlwapi.h"
+
+#define DEBUG_VERBOSE 0
+
+#pragma warning (disable : 4100)
+
+const wchar_t *g_szFilename1, *g_szFilename2;
+IDiaDataSource *g_pDiaDataSource1, *g_pDiaDataSource2;
+IDiaSession *g_pDiaSession1, *g_pDiaSession2;
+IDiaSymbol *g_pGlobalSymbol1, *g_pGlobalSymbol2;
+DWORD g_dwMachineType = CV_CFL_80386;
+IDiaSymbolSet g_excludedTypes;
+IDiaSymbolSet g_excludedTypePatterns;
+
+////////////////////////////////////////////////////////////
+//
+int __cdecl wmain(int argc, wchar_t *argv[])
+{
+  FILE *pFile;
+
+  if (argc < 3) {
+    PrintHelpOptions();
+    return -1;
+  }
+
+  if (!_wcsicmp(argv[1], L"-type")) {
+    
+    // -type <symbolname> <pdbfilename>: dump this type in detail
+    
+    if (argc < 4) {
+      PrintHelpOptions();
+      return -1;
+    }
+    
+    if ((argc > 1) && (*argv[2] != L'-')) {
+    
+        if (_wfopen_s(&pFile, argv[3], L"r") || !pFile) {
+        // invalid file name or file does not exist
+    
+        PrintHelpOptions();
+        return -1;
+      }
+      fclose(pFile);
+      // CoCreate() and initialize COM objects
+      if (!InitDiaSource(&g_pDiaDataSource1))
+      {
+          return -1;
+      }
+      if (!LoadDataFromPdb(argv[3], g_pDiaDataSource1, &g_pDiaSession1, &g_pGlobalSymbol1)) {
+        return -1;
+      }
+  
+      DumpType(g_pGlobalSymbol1, argv[2]);
+      
+      // release COM objects and CoUninitialize()
+      Cleanup();
+      
+      return 0;
+    }
+  }
+
+  if (argc < 3) {
+    PrintHelpOptions();
+    return -1;
+  }
+  
+  if (_wfopen_s(&pFile, argv[1], L"r") || !pFile) {
+    // invalid file name or file does not exist
+
+    PrintHelpOptions();
+    return -1;
+  }
+
+  fclose(pFile);
+
+  if (_wfopen_s(&pFile, argv[2], L"r") || !pFile) {
+    // invalid file name or file does not exist
+
+    PrintHelpOptions();
+    return -1;
+  }
+
+  fclose(pFile);
+
+  g_szFilename1 = argv[1];
+
+  // CoCreate() and initialize COM objects
+  if (!InitDiaSource(&g_pDiaDataSource1))
+  {
+      return -1;
+  }
+  if (!LoadDataFromPdb(g_szFilename1, g_pDiaDataSource1, &g_pDiaSession1, &g_pGlobalSymbol1)) {
+    return -1;
+  }
+
+  g_szFilename2 = argv[2];
+
+  InitDiaSource(&g_pDiaDataSource2);
+  if (!LoadDataFromPdb(g_szFilename2, g_pDiaDataSource2, &g_pDiaSession2, &g_pGlobalSymbol2)) {
+    return -1;
+  }
+  
+  // Read exclusion list.
+  struct stat fileStatus;  
+  if (stat(UnicodeToAnsi(argv[3]), &fileStatus) != 0)
+  {
+    wprintf(L"Could not open type_exclusion_list file!\n"); 
+    return -1;
+  }
+ 
+  char linec[2048];  
+  FILE *file = fopen(UnicodeToAnsi(argv[3]), "r");
+  while (fgets (linec, sizeof(linec), file) != NULL)
+  {
+      std::string line(linec);
+      line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
+      if (line.empty() || line.length() <= 1)
+      {
+          continue;
+      }
+      if (line.front() == '#') continue;
+      int len;
+      int slength = (int)line.length() + 1;
+      len = MultiByteToWideChar(CP_ACP, 0, line.c_str(), slength, 0, 0); 
+      wchar_t* buf = new wchar_t[len];
+      MultiByteToWideChar(CP_ACP, 0, line.c_str(), slength, buf, len);
+      std::wstring wLine(buf);
+      delete[] buf;
+      
+      /// Add *str in the patterns list.
+      if (line.front() == '*') 
+      {
+          g_excludedTypePatterns.insert((std::wstring)(wLine.substr(1, wLine.size()-1)));    
+      }
+      else
+      {
+          g_excludedTypes.insert((std::wstring)(wLine));
+      }         
+  } 
+  fclose(file);
+  
+  IDiaSymbolSet types1;
+  IDiaSymbolSet types2;
+  if (!EnumTypesInPdb(&types1, g_pDiaSession1, g_pGlobalSymbol1))
+  {
+      return -1;
+  }
+
+  if (!EnumTypesInPdb(&types2, g_pDiaSession2, g_pGlobalSymbol2))
+  {
+      return -1;
+  }
+
+  IDiaSymbolSet commonTypes;
+
+  // Intersect types
+  for (IDiaSymbolSet::iterator i = types1.begin(); i != types1.end(); i++)
+  {
+      std::wstring typeName = *i;
+
+      /// Skip excluded types
+      if (g_excludedTypes.find(typeName) != g_excludedTypes.end())
+      {
+          continue;
+      }
+      bool skipType = false;
+      /// Skip if includes one pattern string.
+      for (IDiaSymbolSet::iterator j = g_excludedTypePatterns.begin(); j != g_excludedTypePatterns.end(); j++)
+      {
+           std::wstring patternStr = *j;
+           if (wcsstr(typeName.c_str(), patternStr.c_str()) != NULL)
+           {
+              skipType = true;
+              break;
+           }
+      }
+      
+      if (skipType) continue;
+      
+      if (types2.find(typeName) != types2.end())
+      {
+          commonTypes.insert(typeName);
+      }
+  }
+
+  bool matchedSymbols = true;
+  ULONG failuresNb = 0;
+      
+  
+  // Compare layout for common types
+  for (IDiaSymbolSet::iterator i = commonTypes.begin(); i != commonTypes.end(); i++)
+  {
+      std::wstring typeName = *i;
+
+      IDiaEnumSymbols *pEnumSymbols1;
+      BSTR pwstrTypeName = SysAllocString(typeName.c_str());
+      if (FAILED(g_pGlobalSymbol1->findChildren(SymTagUDT, pwstrTypeName, nsNone, &pEnumSymbols1))) {
+        SysFreeString(pwstrTypeName);
+        return false;
+      }
+
+      IDiaEnumSymbols *pEnumSymbols2;
+      if (FAILED(g_pGlobalSymbol2->findChildren(SymTagUDT, pwstrTypeName, nsNone, &pEnumSymbols2))) {
+        SysFreeString(pwstrTypeName);
+        return false;
+      }
+      
+      IDiaSymbol *pSymbol1;
+      IDiaSymbol *pSymbol2;
+      ULONG celt = 0;      
+
+      
+      while (SUCCEEDED(pEnumSymbols1->Next(1, &pSymbol1, &celt)) && (celt == 1)) {
+        if (SUCCEEDED(pEnumSymbols2->Next(1, &pSymbol2, &celt)) && (celt == 1))
+        {   
+           
+            BSTR bstrSymbol1Name;
+            if (pSymbol1->get_name(&bstrSymbol1Name) != S_OK) 
+            {   
+                bstrSymbol1Name = NULL; 
+                pSymbol2->Release();
+                continue;               
+            }              
+            BSTR bstrSymbol2Name;
+            if (pSymbol2->get_name(&bstrSymbol2Name) != S_OK) 
+            {
+                bstrSymbol2Name = NULL;
+                pSymbol2->Release();
+                continue;                           
+            }            
+            if (_wcsicmp(bstrSymbol1Name, bstrSymbol2Name) != 0)
+            {
+                pSymbol2->Release();
+                continue;                
+            }
+            ULONGLONG sym1Size;
+            ULONGLONG sym2Size;
+            if (pSymbol1->get_length(&sym1Size) != S_OK)
+            {
+               wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+               pSymbol2->Release();
+               continue;
+            } 
+            //wprintf(L"sym1Size = %x\n", sym1Size);
+            if (pSymbol2->get_length(&sym2Size) != S_OK)
+            {
+               wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+               pSymbol2->Release();
+               continue;
+            }            
+            //wprintf(L"sym2Size = %x\n", sym2Size);
+            if (sym1Size == 0 || sym2Size == 2)
+            {
+                pSymbol2->Release();
+                continue;
+            }
+            
+            if (!LayoutMatches(pSymbol1, pSymbol2))
+            {
+                wprintf(L"Type \"%s\" is not matching in %s and %s\n", pwstrTypeName, g_szFilename1, g_szFilename2);                
+                pSymbol2->Release();
+
+                matchedSymbols = false;
+                failuresNb++;
+                // Continue to compare and report all inconsistencies.               
+                continue;
+            }
+            else
+            {
+#if    DEBUG_VERBOSE
+                wprintf(L"Matched type: %s\n", pwstrTypeName);
+#endif
+            }
+            
+            pSymbol2->Release();
+        }
+
+        pSymbol1->Release();
+      }
+      
+      SysFreeString(pwstrTypeName);
+      pEnumSymbols1->Release();
+      pEnumSymbols2->Release();
+  }
+  
+  // release COM objects and CoUninitialize()
+  Cleanup();
+  
+  if (matchedSymbols)
+  {
+      wprintf(L"OK: All %d common types of %s and %s match!\n", commonTypes.size(), g_szFilename1, g_szFilename2);
+      return 0;
+  }
+  else
+  {
+      wprintf(L"FAIL: Failed to match %d common types of %s and %s!\n", failuresNb, g_szFilename1, g_szFilename2);
+      wprintf(L"Matched %d common types!\n", commonTypes.size() - failuresNb);
+      return -1;
+  }
+}
+
+LPSTR UnicodeToAnsi(LPCWSTR s)
+{
+    if (s==NULL) return NULL;
+    int cw=lstrlenW(s);
+    if (cw==0) 
+    {
+        CHAR *psz=new CHAR[1];*psz='\0';return psz;
+    }
+    int cc=WideCharToMultiByte(CP_ACP,0,s,cw,NULL,0,NULL,NULL);
+    if (cc==0) return NULL;
+    CHAR *psz=new CHAR[cc+1];
+    cc=WideCharToMultiByte(CP_ACP,0,s,cw,psz,cc,NULL,NULL);
+    if (cc==0) {delete[] psz;return NULL;}
+    psz[cc]='\0';
+    return psz;
+}
+
+
+bool InitDiaSource(IDiaDataSource  **ppSource)
+{
+    HRESULT hr = CoInitialize(NULL);
+
+    // Obtain access to the provider
+
+    hr = CoCreateInstance(__uuidof(DiaSource),
+                        NULL,
+                        CLSCTX_INPROC_SERVER,
+                        __uuidof(IDiaDataSource),
+                        (void **) ppSource);
+
+       if (FAILED(hr)) {
+                  ACTCTX actCtx;
+       memset((void*)&actCtx, 0, sizeof(ACTCTX));
+       actCtx.cbSize = sizeof(ACTCTX);
+       CHAR   dllPath[MAX_PATH*2];
+       GetModuleFileName(NULL, dllPath, _countof(dllPath));
+       PathRemoveFileSpec(dllPath);
+       strcat(dllPath, "\\msdia100.sxs.manifest");
+       actCtx.lpSource = dllPath;
+    
+       HANDLE hCtx = ::CreateActCtx(&actCtx);
+       if (hCtx == INVALID_HANDLE_VALUE)
+          wprintf(L"CreateActCtx returned: INVALID_HANDLE_VALUE\n");                 
+       else
+       {
+          ULONG_PTR cookie;
+          if (::ActivateActCtx(hCtx, &cookie))
+          {
+             hr = CoCreateInstance(__uuidof(DiaSource),
+                        NULL,
+                        CLSCTX_INPROC_SERVER,
+                        __uuidof(IDiaDataSource),
+                        (void **) ppSource);
+             ::DeactivateActCtx(0, cookie);
+                 if (FAILED(hr)) {
+                         wprintf(L"CoCreateInstance failed - HRESULT = %08X\n", hr);
+                         return false;
+              }
+          }
+       }
+         }
+    if (FAILED(hr)) {
+               wprintf(L"CoCreateInstance failed - HRESULT = %08X\n", hr);
+
+               return false;
+    }
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////
+// Create an IDiaData source and open a PDB file
+//
+bool LoadDataFromPdb(
+    const wchar_t    *szFilename,
+    IDiaDataSource  *ppSource,
+    IDiaSession     **ppSession,
+    IDiaSymbol      **ppGlobal)
+{
+  wchar_t wszExt[MAX_PATH];
+  wchar_t *wszSearchPath = L"SRV**\\\\symbols\\symbols"; // Alternate path to search for debug data
+  DWORD dwMachType = 0;
+  HRESULT hr;
+
+  _wsplitpath_s(szFilename, NULL, 0, NULL, 0, NULL, 0, wszExt, MAX_PATH);
+
+  if (!_wcsicmp(wszExt, L".pdb")) {
+    // Open and prepare a program database (.pdb) file as a debug data source
+
+    hr = (ppSource)->loadDataFromPdb(szFilename);
+
+    if (FAILED(hr)) {
+      wprintf(L"loadDataFromPdb failed - HRESULT = %08X\n", hr);
+
+      return false;
+    }
+  }
+
+  else {
+    CCallback callback; // Receives callbacks from the DIA symbol locating procedure,
+                        // thus enabling a user interface to report on the progress of
+                        // the location attempt. The client application may optionally
+                        // provide a reference to its own implementation of this
+                        // virtual base class to the IDiaDataSource::loadDataForExe method.
+    callback.AddRef();
+
+    // Open and prepare the debug data associated with the executable
+
+    hr = (ppSource)->loadDataForExe(szFilename, wszSearchPath, &callback);
+
+    if (FAILED(hr)) {
+      wprintf(L"loadDataForExe failed - HRESULT = %08X\n", hr);
+
+      return false;
+    }
+  }
+
+  // Open a session for querying symbols
+
+  hr = (ppSource)->openSession(ppSession);
+
+  if (FAILED(hr)) {
+    wprintf(L"openSession failed - HRESULT = %08X\n", hr);
+
+    return false;
+  }
+
+  // Retrieve a reference to the global scope
+
+  hr = (*ppSession)->get_globalScope(ppGlobal);
+
+  if (hr != S_OK) {
+    wprintf(L"get_globalScope failed\n");
+
+    return false;
+  }
+
+  // Set Machine type for getting correct register names
+
+  if ((*ppGlobal)->get_machineType(&dwMachType) == S_OK) {
+    switch (dwMachType) {
+      case IMAGE_FILE_MACHINE_I386 : g_dwMachineType = CV_CFL_80386; break;
+      case IMAGE_FILE_MACHINE_IA64 : g_dwMachineType = CV_CFL_IA64; break;
+      case IMAGE_FILE_MACHINE_AMD64 : g_dwMachineType = CV_CFL_AMD64; break;
+    }
+  }
+
+  return true;
+}
+
+bool LayoutMatches(IDiaSymbol* pSymbol1, IDiaSymbol* pSymbol2)
+{
+    DWORD dwTag1, dwTag2;
+    DWORD dwLocType1, dwLocType2;
+    LONG lOffset1, lOffset2;
+
+    if (pSymbol1->get_symTag(&dwTag1) != S_OK) 
+    {
+        wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+        return false;
+   }
+   if (pSymbol2->get_symTag(&dwTag2) != S_OK) 
+   {
+        wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+        return false;
+   }
+
+   if (dwTag1 == SymTagUDT)
+   {
+       if (dwTag2 != SymTagUDT)
+       {
+           
+            wprintf(L"ERROR - symbols don't match\n");
+            wprintf(L"Symbol 1:\n");
+            PrintTypeInDetail(pSymbol1, 0);
+            wprintf(L"Symbol 2:\n");
+            PrintTypeInDetail(pSymbol2, 0);
+            return false;
+       }
+
+       // First check that types size match
+       ULONGLONG sym1Size;
+       ULONGLONG sym2Size;
+       if (pSymbol1->get_length(&sym1Size) != S_OK)
+       {
+           wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+           return false;  
+       } 
+       if (pSymbol2->get_length(&sym2Size) != S_OK)
+       {
+           wprintf(L"ERROR - can't retrieve the symbol's length\n");           
+           return false;  
+       }
+       if (sym1Size == 0 || sym2Size == 0)
+       {
+            return true;
+       } 
+       if (sym1Size != sym2Size)
+       {                
+            wprintf(L"Failed to match type size: (sizeof(sym1)=%x) != (sizeof(sym2)=%x)\n", sym1Size, sym2Size);            
+            return false;
+       }
+       IDiaEnumSymbols *pEnumChildren1, *pEnumChildren2;
+       IDiaSymbol *pChild1, *pChild2;
+       ULONG celt = 0;
+       BSTR bstrName1, bstrName2;
+       if (SUCCEEDED(pSymbol1->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren1))) 
+       {
+            while (SUCCEEDED(pEnumChildren1->Next(1, &pChild1, &celt)) && (celt == 1)) 
+            {
+                if (pChild1->get_symTag(&dwTag1) != S_OK) 
+                {
+                    wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+                    pChild1->Release();
+                    return false;
+                }
+                if (dwTag1 != SymTagData) { pChild1->Release(); continue; }
+                if (pChild1->get_locationType(&dwLocType1) != S_OK) 
+                {
+                    wprintf(L"symbol in optmized code");
+                    pChild1->Release();
+                    return false;
+                }
+                if (dwLocType1 != LocIsThisRel) { pChild1->Release(); continue; }
+                if (pChild1->get_offset(&lOffset1) != S_OK) 
+                {
+                    wprintf(L"ERROR - geting field offset\n");
+                    pChild1->Release();
+                    return false;
+                }
+                if (pChild1->get_name(&bstrName1) != S_OK) 
+                {
+                    bstrName1 = NULL;
+                }
+                /// Search in the second symbol the field at lOffset1
+                bool fieldMatched = false;
+                if  (SUCCEEDED(pSymbol2->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren2)))
+                {
+                    while (SUCCEEDED(pEnumChildren2->Next(1, &pChild2, &celt)) && (celt == 1)) 
+                    {
+                        if (pChild2->get_symTag(&dwTag2) != S_OK) 
+                        {
+                            wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+                            pChild2->Release();
+                            return false;
+                        }
+                        if (dwTag2 != SymTagData) { pChild2->Release(); continue; }
+                        if (pChild2->get_locationType(&dwLocType2) != S_OK) 
+                        {
+                            wprintf(L"symbol in optmized code");
+                            pChild2->Release();
+                            return false;
+                        }
+                        if (dwLocType2 != LocIsThisRel) { pChild2->Release(); continue; }
+                        if (pChild2->get_offset(&lOffset2) != S_OK) 
+                        {
+                            wprintf(L"ERROR - geting field offset\n");
+                            pChild2->Release();
+                            return false;
+                        }
+                        if (pChild2->get_name(&bstrName2) != S_OK) 
+                        {
+                            bstrName2 = NULL;
+                        }
+                        if (lOffset2 == lOffset1)
+                        {
+                            if (_wcsicmp(bstrName1, bstrName2) == 0
+                            || wcsstr(bstrName1, bstrName2) == bstrName1
+                            || wcsstr(bstrName2, bstrName1) == bstrName2)
+                            {
+                                //wprintf(L"Matched field %s at offset %x\n", bstrName1, lOffset2);
+                                fieldMatched = true;
+                                pChild2->Release();
+                                break;
+                            }
+                        }
+                        pChild2->Release();
+                    }
+                    pEnumChildren2->Release();
+                }
+                if (!fieldMatched)
+                {
+                    BSTR bstrSymbol1Name;
+                    if (pSymbol1->get_name(&bstrSymbol1Name) != S_OK) 
+                    {
+                        bstrSymbol1Name = NULL;
+                    }
+                    wprintf(L"Failed to match %s field %s at offset %x\n", bstrSymbol1Name, bstrName1, lOffset1);
+                    pChild1->Release();
+                    return false;
+                }
+                pChild1->Release();
+            }
+
+            pEnumChildren1->Release();
+       }
+   }
+
+   return true;
+}
+
+////////////////////////////////////////////////////////////
+// Release DIA objects and CoUninitialize
+//
+void Cleanup()
+{
+  if (g_pGlobalSymbol1) {
+    g_pGlobalSymbol1->Release();
+    g_pGlobalSymbol1 = NULL;
+  }
+
+  if (g_pGlobalSymbol2) {
+    g_pGlobalSymbol2->Release();
+    g_pGlobalSymbol2 = NULL;
+  }
+
+  if (g_pDiaSession1) {
+    g_pDiaSession1->Release();
+    g_pDiaSession1 = NULL;
+  }
+
+  if (g_pDiaSession2) {
+    g_pDiaSession2->Release();
+    g_pDiaSession2 = NULL;
+  }
+
+  CoUninitialize();
+}
+
+
+////////////////////////////////////////////////////////////
+// Display the usage
+//
+void PrintHelpOptions()
+{
+  static const wchar_t * const helpString = L"usage: PdbTypeMatch.exe <pdb_filename_1> <pdb_filename_2> <type_exclusion_list_file> : compare all common types by size and fields\n"
+                                            L"       PdbTypeMatch.exe -type <symbolname>  <pdb_filename_1>: dump this type in detail\n";
+                                            
+  wprintf(helpString);
+}
+
+bool EnumTypesInPdb(IDiaSymbolSet* types, IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+    IDiaEnumSymbols *pEnumSymbols;
+
+    if (FAILED(pGlobal->findChildren(SymTagUDT, NULL, nsNone, &pEnumSymbols))) 
+    {
+        wprintf(L"ERROR - EnumTypesInPdb() returned no symbols\n");
+
+        return false;
+    }
+
+    IDiaSymbol *pSymbol;
+    ULONG celt = 0;
+
+    while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) 
+    {
+        std::wstring typeName;
+        GetSymbolName(typeName, pSymbol);
+        types->insert(std::wstring(typeName));
+        pSymbol->Release();
+    }
+
+    pEnumSymbols->Release();
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the data stored in a PDB
+//
+void DumpAllPdbInfo(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  DumpAllMods(pGlobal);
+  DumpAllPublics(pGlobal);
+  DumpAllSymbols(pGlobal);
+  DumpAllGlobals(pGlobal);
+  DumpAllTypes(pGlobal);
+  DumpAllFiles(pSession, pGlobal);
+  DumpAllLines(pSession, pGlobal);
+  DumpAllSecContribs(pSession);
+  DumpAllDebugStreams(pSession);
+  DumpAllInjectedSources(pSession);
+  DumpAllFPO(pSession);
+  DumpAllOEMs(pGlobal);
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the modules information
+//
+bool DumpAllMods(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** MODULES\n\n");
+
+  // Retrieve all the compiland symbols
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+  ULONG iMod = 1;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) != S_OK) {
+      wprintf(L"ERROR - Failed to get the compiland's name\n");
+
+      pCompiland->Release();
+      pEnumSymbols->Release();
+
+      return false;
+    }
+
+    wprintf(L"%04X %s\n", iMod++, bstrName);
+
+    // Deallocate the string allocated previously by the call to get_name
+
+    SysFreeString(bstrName);
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the public symbols - SymTagPublicSymbol
+//
+bool DumpAllPublics(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** PUBLICS\n\n");
+
+  // Retrieve all the public symbols
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagPublicSymbol, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintPublicSymbol(pSymbol);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the symbol information stored in the compilands
+//
+bool DumpAllSymbols(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** SYMBOLS\n\n\n");
+
+  // Retrieve the compilands first
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    wprintf(L"\n** Module: ");
+
+    // Retrieve the name of the module
+
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) != S_OK) {
+      wprintf(L"(???)\n\n");
+    }
+
+    else {
+      wprintf(L"%s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    // Find all the symbols defined in this compiland and print their info
+
+    IDiaEnumSymbols *pEnumChildren;
+
+    if (SUCCEEDED(pCompiland->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+      IDiaSymbol *pSymbol;
+      ULONG celtChildren = 0;
+
+      while (SUCCEEDED(pEnumChildren->Next(1, &pSymbol, &celtChildren)) && (celtChildren == 1)) {
+        PrintSymbol(pSymbol, 0);
+        pSymbol->Release();
+      }
+
+      pEnumChildren->Release();
+    }
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the global symbols - SymTagFunction,
+//  SymTagThunk and SymTagData
+//
+bool DumpAllGlobals(IDiaSymbol *pGlobal)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+  IDiaSymbol *pSymbol;
+  enum SymTagEnum dwSymTags[] = { SymTagFunction, SymTagThunk, SymTagData };
+  ULONG celt = 0;
+
+  wprintf(L"\n\n*** GLOBALS\n\n");
+
+  for (size_t i = 0; i < _countof(dwSymTags); i++, pEnumSymbols = NULL) {
+    if (SUCCEEDED(pGlobal->findChildren(dwSymTags[i], NULL, nsNone, &pEnumSymbols))) {
+      while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+        PrintGlobalSymbol(pSymbol);
+
+        pSymbol->Release();
+      }
+
+      pEnumSymbols->Release();
+    }
+
+    else {
+      wprintf(L"ERROR - DumpAllGlobals() returned no symbols\n");
+
+      return false;
+    }
+  }
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the types information
+//  (type symbols can be UDTs, enums or typedefs)
+//
+bool DumpAllTypes(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** TYPES\n");
+
+  return DumpAllUDTs(pGlobal) || DumpAllEnums(pGlobal) || DumpAllTypedefs(pGlobal);
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the user defined types (UDT)
+//
+bool DumpAllUDTs(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n** User Defined Types\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagUDT, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllUDTs() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the enum types from the pdb
+//
+bool DumpAllEnums(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n** ENUMS\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagEnum, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllEnums() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the typedef types from the pdb
+//
+bool DumpAllTypedefs(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n** TYPEDEFS\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagTypedef, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllTypedefs() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump OEM specific types
+//
+bool DumpAllOEMs(IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** OEM Specific types\n\n");
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCustomType, NULL, nsNone, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpAllOEMs() returned no symbols\n");
+
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// For each compiland in the PDB dump all the source files
+//
+bool DumpAllFiles(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** FILES\n\n");
+
+  // In order to find the source files, we have to look at the image's compilands/modules
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) == S_OK) {
+      wprintf(L"\nCompiland = %s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    // Every compiland could contain multiple references to the source files which were used to build it
+    // Retrieve all source files by compiland by passing NULL for the name of the source file
+
+    IDiaEnumSourceFiles *pEnumSourceFiles;
+
+    if (SUCCEEDED(pSession->findFile(pCompiland, NULL, nsNone, &pEnumSourceFiles))) {
+      IDiaSourceFile *pSourceFile;
+
+      while (SUCCEEDED(pEnumSourceFiles->Next(1, &pSourceFile, &celt)) && (celt == 1)) {
+        PrintSourceFile(pSourceFile);
+        putwchar(L'\n');
+
+        pSourceFile->Release();
+      }
+
+      pEnumSourceFiles->Release();
+    }
+
+    putwchar(L'\n');
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the line numbering information contained in the PDB
+//  Only function symbols have corresponding line numbering information
+bool DumpAllLines(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** LINES\n\n");
+
+  // First retrieve the compilands/modules
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    IDiaEnumSymbols *pEnumFunction;
+
+    // For every function symbol defined in the compiland, retrieve and print the line numbering info
+
+    if (SUCCEEDED(pCompiland->findChildren(SymTagFunction, NULL, nsNone, &pEnumFunction))) {
+      IDiaSymbol *pFunction;
+      ULONG celt = 0;
+
+      while (SUCCEEDED(pEnumFunction->Next(1, &pFunction, &celt)) && (celt == 1)) {
+        PrintLines(pSession, pFunction);
+
+        pFunction->Release();
+      }
+
+      pEnumFunction->Release();
+    }
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the line numbering information for a given RVA
+// and a given range
+//
+bool DumpAllLines(IDiaSession *pSession, DWORD dwRVA, DWORD dwRange)
+{
+  // Retrieve and print the lines that corresponds to a specified RVA
+
+  IDiaEnumLineNumbers *pLines;
+
+  if (FAILED(pSession->findLinesByRVA(dwRVA, dwRange, &pLines))) {
+    return false;
+  }
+
+  PrintLines(pLines);
+
+  pLines->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the section contributions from the PDB
+//
+//  Section contributions are stored in a table which will
+//  be retrieved via IDiaSession->getEnumTables through
+//  QueryInterface()using the REFIID of the IDiaEnumSectionContribs
+//
+bool DumpAllSecContribs(IDiaSession *pSession)
+{
+  wprintf(L"\n\n*** SECTION CONTRIBUTION\n\n");
+
+  IDiaEnumSectionContribs *pEnumSecContribs;
+
+  if (FAILED(GetTable(pSession, __uuidof(IDiaEnumSectionContribs), (void **) &pEnumSecContribs))) {
+    return false;
+  }
+
+  wprintf(L"    RVA        Address       Size    Module\n");
+
+  IDiaSectionContrib *pSecContrib;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSecContribs->Next(1, &pSecContrib, &celt)) && (celt == 1)) {
+    PrintSecContribs(pSecContrib);
+
+    pSecContrib->Release();
+  }
+
+  pEnumSecContribs->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all debug data streams contained in the PDB
+//
+bool DumpAllDebugStreams(IDiaSession *pSession)
+{
+  IDiaEnumDebugStreams *pEnumStreams;
+
+  wprintf(L"\n\n*** DEBUG STREAMS\n\n");
+
+  // Retrieve an enumerated sequence of debug data streams
+
+  if (FAILED(pSession->getEnumDebugStreams(&pEnumStreams))) {
+    return false;
+  }
+
+  IDiaEnumDebugStreamData *pStream;
+  ULONG celt = 0;
+
+  for (; SUCCEEDED(pEnumStreams->Next(1, &pStream, &celt)) && (celt == 1); pStream = NULL) {
+    PrintStreamData(pStream);
+
+    pStream->Release();
+  }
+
+  pEnumStreams->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the injected source from the PDB
+//
+//  Injected sources data is stored in a table which will
+//  be retrieved via IDiaSession->getEnumTables through
+//  QueryInterface()using the REFIID of the IDiaEnumSectionContribs
+//
+bool DumpAllInjectedSources(IDiaSession *pSession)
+{
+  wprintf(L"\n\n*** INJECTED SOURCES TABLE\n\n");
+
+  IDiaEnumInjectedSources *pEnumInjSources;
+
+  if (SUCCEEDED(GetTable(pSession, __uuidof(IDiaEnumInjectedSources), (void **) &pEnumInjSources))) {
+    return false;
+  }
+
+  IDiaInjectedSource *pInjSource;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumInjSources->Next(1, &pInjSource, &celt)) && (celt == 1)) {
+    PrintGeneric(pInjSource);
+
+    pInjSource->Release();
+  }
+
+  pEnumInjSources->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump info corresponing to a given injected source filename
+//
+bool DumpInjectedSource(IDiaSession *pSession, const wchar_t *szName)
+{
+  // Retrieve a source that has been placed into the symbol store by attribute providers or
+  //  other components of the compilation process
+
+  IDiaEnumInjectedSources *pEnumInjSources;
+
+  if (FAILED(pSession->findInjectedSource(szName, &pEnumInjSources))) {
+    wprintf(L"ERROR - DumpInjectedSources() could not find %s\n", szName);
+
+    return false;
+  }
+
+  IDiaInjectedSource *pInjSource;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumInjSources->Next(1, &pInjSource, &celt)) && (celt == 1)) {
+    PrintGeneric(pInjSource);
+
+    pInjSource->Release();
+  }
+
+  pEnumInjSources->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the source file information stored in the PDB
+// We have to go through every compiland in order to retrieve
+//   all the information otherwise checksums for instance
+//   will not be available
+// Compilands can have multiple source files with the same
+//   name but different content which produces diffrent
+//   checksums
+//
+bool DumpAllSourceFiles(IDiaSession *pSession, IDiaSymbol *pGlobal)
+{
+  wprintf(L"\n\n*** SOURCE FILES\n\n");
+
+  // To get the complete source file info we must go through the compiland first
+  // by passing NULL instead all the source file names only will be retrieved
+
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) == S_OK) {
+      wprintf(L"\nCompiland = %s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    // Every compiland could contain multiple references to the source files which were used to build it
+    // Retrieve all source files by compiland by passing NULL for the name of the source file
+
+    IDiaEnumSourceFiles *pEnumSourceFiles;
+
+    if (SUCCEEDED(pSession->findFile(pCompiland, NULL, nsNone, &pEnumSourceFiles))) {
+      IDiaSourceFile *pSourceFile;
+
+      while (SUCCEEDED(pEnumSourceFiles->Next(1, &pSourceFile, &celt)) && (celt == 1)) {
+        PrintSourceFile(pSourceFile);
+        putwchar(L'\n');
+
+        pSourceFile->Release();
+      }
+
+      pEnumSourceFiles->Release();
+    }
+
+    putwchar(L'\n');
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the FPO info
+//
+//  FPO data stored in a table which will be retrieved via
+//    IDiaSession->getEnumTables through QueryInterface()
+//    using the REFIID of the IDiaEnumFrameData
+//
+bool DumpAllFPO(IDiaSession *pSession)
+{
+  IDiaEnumFrameData *pEnumFrameData;
+
+  wprintf(L"\n\n*** FPO\n\n");
+
+  if (FAILED(GetTable(pSession, __uuidof(IDiaEnumFrameData), (void **) &pEnumFrameData))) {
+    return false;
+  }
+
+  IDiaFrameData *pFrameData;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumFrameData->Next(1, &pFrameData, &celt)) && (celt == 1)) {
+    PrintFrameData(pFrameData);
+
+    pFrameData->Release();
+  }
+
+  pEnumFrameData->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump FPO info for a function at the specified RVA
+//
+bool DumpFPO(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumFrameData *pEnumFrameData;
+
+  // Retrieve first the table holding all the FPO info
+
+  if ((dwRVA != 0) && SUCCEEDED(GetTable(pSession, __uuidof(IDiaEnumFrameData), (void **) &pEnumFrameData))) {
+    IDiaFrameData *pFrameData;
+
+    // Retrieve the frame data corresponding to the given RVA
+
+    if (SUCCEEDED(pEnumFrameData->frameByRVA(dwRVA, &pFrameData))) {
+      PrintGeneric(pFrameData);
+
+      pFrameData->Release();
+    }
+
+    else {
+      // Some function might not have FPO data available (see ASM funcs like strcpy)
+
+      wprintf(L"ERROR - DumpFPO() frameByRVA invalid RVA: 0x%08X\n", dwRVA);
+
+      pEnumFrameData->Release();
+
+      return false;
+    }
+
+    pEnumFrameData->Release();
+  }
+
+  else {
+    wprintf(L"ERROR - DumpFPO() GetTable\n");
+
+    return false;
+  }
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump FPO info for a specified function symbol using its
+//  name (a regular expression string is used for the search)
+//
+bool DumpFPO(IDiaSession *pSession, IDiaSymbol *pGlobal, const wchar_t *szSymbolName)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+  DWORD dwRVA;
+
+  // Find first all the function symbols that their names matches the search criteria
+
+  if (FAILED(pGlobal->findChildren(SymTagFunction, szSymbolName, nsRegularExpression, &pEnumSymbols))) {
+    wprintf(L"ERROR - DumpFPO() findChildren could not find symol %s\n", szSymbolName);
+
+    return false;
+  }
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    if (pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) {
+      PrintPublicSymbol(pSymbol);
+
+      DumpFPO(pSession, dwRVA);
+    }
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  putwchar(L'\n');
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump a specified compiland and all the symbols defined in it
+//
+bool DumpCompiland(IDiaSymbol *pGlobal, const wchar_t *szCompName)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagCompiland, szCompName, nsCaseInsensitive, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pCompiland;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+    wprintf(L"\n** Module: ");
+
+    // Retrieve the name of the module
+
+    BSTR bstrName;
+
+    if (pCompiland->get_name(&bstrName) != S_OK) {
+      wprintf(L"(???)\n\n");
+    }
+
+    else {
+      wprintf(L"%s\n\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    IDiaEnumSymbols *pEnumChildren;
+
+    if (SUCCEEDED(pCompiland->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+      IDiaSymbol *pSymbol;
+      ULONG celt_ = 0;
+
+      while (SUCCEEDED(pEnumChildren->Next(1, &pSymbol, &celt_)) && (celt_ == 1)) {
+        PrintSymbol(pSymbol, 0);
+
+        pSymbol->Release();
+      }
+
+      pEnumChildren->Release();
+    }
+
+    pCompiland->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the line numbering information for a specified RVA
+//
+bool DumpLines(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumLineNumbers *pLines;
+
+  if (FAILED(pSession->findLinesByRVA(dwRVA, MAX_RVA_LINES_BYTES_RANGE, &pLines))) {
+    return false;
+  }
+
+  PrintLines(pLines);
+
+  pLines->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the all line numbering information for a specified
+//  function symbol name (as a regular expression string)
+//
+bool DumpLines(IDiaSession *pSession, IDiaSymbol *pGlobal, const wchar_t *szFuncName)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagFunction, szFuncName, nsRegularExpression, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pFunction;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pFunction, &celt)) && (celt == 1)) {
+    PrintLines(pSession, pFunction);
+
+    pFunction->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the symbol information corresponding to a specified RVA
+//
+bool DumpSymbolWithRVA(IDiaSession *pSession, DWORD dwRVA, const wchar_t *szChildname)
+{
+  IDiaSymbol *pSymbol;
+  LONG lDisplacement;
+
+  if (FAILED(pSession->findSymbolByRVAEx(dwRVA, SymTagNull, &pSymbol, &lDisplacement))) {
+    return false;
+  }
+
+  wprintf(L"Displacement = 0x%X\n", lDisplacement);
+
+  PrintGeneric(pSymbol);
+
+  bool bReturn = DumpSymbolWithChildren(pSymbol, szChildname);
+
+  while (pSymbol != NULL) {
+    IDiaSymbol *pParent;
+
+    if ((pSymbol->get_lexicalParent(&pParent) == S_OK) && pParent) {
+      wprintf(L"\nParent\n");
+
+      PrintSymbol(pParent, 0);
+
+      pSymbol->Release();
+
+      pSymbol = pParent;
+    }
+
+    else {
+      pSymbol->Release();
+      break;
+    }
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the symbols information where their names matches a
+//  specified regular expression string
+//
+bool DumpSymbolsWithRegEx(IDiaSymbol *pGlobal, const wchar_t *szRegEx, const wchar_t *szChildname)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagNull, szRegEx, nsRegularExpression, &pEnumSymbols))) {
+    return false;
+  }
+
+  bool bReturn = true;
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintGeneric(pSymbol);
+
+    bReturn = DumpSymbolWithChildren(pSymbol, szChildname);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return bReturn;
+}
+
+////////////////////////////////////////////////////////////
+// Dump the information corresponding to a symbol name which
+//  is a children of the specified parent symbol
+//
+bool DumpSymbolWithChildren(IDiaSymbol *pSymbol, const wchar_t *szChildname)
+{
+  if (szChildname != NULL) {
+    IDiaEnumSymbols *pEnumSyms;
+
+    if (FAILED(pSymbol->findChildren(SymTagNull, szChildname, nsRegularExpression, &pEnumSyms))) {
+      return false;
+    }
+
+    IDiaSymbol *pChild;
+    DWORD celt = 1;
+
+    while (SUCCEEDED(pEnumSyms->Next(celt, &pChild, &celt)) && (celt == 1)) {
+      PrintGeneric(pChild);
+      PrintSymbol(pChild, 0);
+
+      pChild->Release();
+    }
+
+    pEnumSyms->Release();
+  }
+
+  else {
+    // If the specified name is NULL then only the parent symbol data is displayed
+
+    DWORD dwSymTag;
+
+    if ((pSymbol->get_symTag(&dwSymTag) == S_OK) && (dwSymTag == SymTagPublicSymbol)) {
+      PrintPublicSymbol(pSymbol);
+    }
+
+    else {
+      PrintSymbol(pSymbol, 0);
+    }
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump all the type symbols information that matches their
+//  names to a specified regular expression string
+//
+bool DumpType(IDiaSymbol *pGlobal, const wchar_t *szRegEx)
+{
+  IDiaEnumSymbols *pEnumSymbols;
+
+  if (FAILED(pGlobal->findChildren(SymTagUDT, szRegEx, nsRegularExpression, &pEnumSymbols))) {
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSymbols->Next(1, &pSymbol, &celt)) && (celt == 1)) {
+    PrintTypeInDetail(pSymbol, 0);
+
+    pSymbol->Release();
+  }
+
+  pEnumSymbols->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump line numbering information for a given file name and
+//  an optional line number
+//
+bool DumpLinesForSourceFile(IDiaSession *pSession, const wchar_t *szFileName, DWORD dwLine)
+{
+  IDiaEnumSourceFiles *pEnumSrcFiles;
+
+  if (FAILED(pSession->findFile(NULL, szFileName, nsFNameExt, &pEnumSrcFiles))) {
+    return false;
+  }
+
+  IDiaSourceFile *pSrcFile;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumSrcFiles->Next(1, &pSrcFile, &celt)) && (celt == 1)) {
+    IDiaEnumSymbols *pEnumCompilands;
+
+    if (pSrcFile->get_compilands(&pEnumCompilands) == S_OK) {
+      IDiaSymbol *pCompiland;
+
+      celt = 0;
+      while (SUCCEEDED(pEnumCompilands->Next(1, &pCompiland, &celt)) && (celt == 1)) {
+        BSTR bstrName;
+
+        if (pCompiland->get_name(&bstrName) == S_OK) {
+          wprintf(L"Compiland = %s\n", bstrName);
+
+          SysFreeString(bstrName);
+        }
+
+        else {
+          wprintf(L"Compiland = (???)\n");
+        }
+
+        IDiaEnumLineNumbers *pLines;
+
+        if (dwLine != 0) {
+          if (SUCCEEDED(pSession->findLinesByLinenum(pCompiland, pSrcFile, dwLine, 0, &pLines))) {
+            PrintLines(pLines);
+
+            pLines->Release();
+          }
+        }
+
+        else {
+          if (SUCCEEDED(pSession->findLines(pCompiland, pSrcFile, &pLines))) {
+            PrintLines(pLines);
+
+            pLines->Release();
+          }
+        }
+
+        pCompiland->Release();
+      }
+
+      pEnumCompilands->Release();
+    }
+
+    pSrcFile->Release();
+  }
+
+  pEnumSrcFiles->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump public symbol information for a given number of
+//  symbols around a given RVA address
+//
+bool DumpPublicSymbolsSorted(IDiaSession *pSession, DWORD dwRVA, DWORD dwRange, bool bReverse)
+{
+  IDiaEnumSymbolsByAddr *pEnumSymsByAddr;
+
+  if (FAILED(pSession->getSymbolsByAddr(&pEnumSymsByAddr))) {
+    return false;
+  }
+
+  IDiaSymbol *pSymbol;
+
+  if (SUCCEEDED(pEnumSymsByAddr->symbolByRVA(dwRVA, &pSymbol))) {
+    if (dwRange == 0) {
+      PrintPublicSymbol(pSymbol);
+    }
+
+    ULONG celt;
+    ULONG i;
+
+    if (bReverse) {
+      pSymbol->Release();
+
+      i = 0;
+
+      for (pSymbol = NULL; (i < dwRange) && SUCCEEDED(pEnumSymsByAddr->Next(1, &pSymbol, &celt)) && (celt == 1); i++) {
+        PrintPublicSymbol(pSymbol);
+
+        pSymbol->Release();
+      }
+    }
+
+    else {
+      PrintPublicSymbol(pSymbol);
+
+      pSymbol->Release();
+
+      i = 1;
+
+      for (pSymbol = NULL; (i < dwRange) && SUCCEEDED(pEnumSymsByAddr->Prev(1, &pSymbol, &celt)) && (celt == 1); i++) {
+        PrintPublicSymbol(pSymbol);
+      }
+    }
+  }
+
+  pEnumSymsByAddr->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump label symbol information at a given RVA
+//
+bool DumpLabel(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaSymbol *pSymbol;
+  LONG lDisplacement;
+
+  if (FAILED(pSession->findSymbolByRVAEx(dwRVA, SymTagLabel, &pSymbol, &lDisplacement)) || (pSymbol == NULL)) {
+    return false;
+  }
+
+  wprintf(L"Displacement = 0x%X\n", lDisplacement);
+
+  PrintGeneric(pSymbol);
+
+  pSymbol->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Dump annotation symbol information at a given RVA
+//
+bool DumpAnnotations(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaSymbol *pSymbol;
+  LONG lDisplacement;
+
+  if (FAILED(pSession->findSymbolByRVAEx(dwRVA, SymTagAnnotation, &pSymbol, &lDisplacement)) || (pSymbol == NULL)) {
+    return false;
+  }
+
+  wprintf(L"Displacement = 0x%X\n", lDisplacement);
+
+  PrintGeneric(pSymbol);
+
+  pSymbol->Release();
+
+  return true;
+}
+
+struct OMAP_DATA
+{
+  DWORD dwRVA;
+  DWORD dwRVATo;
+};
+
+////////////////////////////////////////////////////////////
+//
+bool DumpMapToSrc(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumDebugStreams *pEnumStreams;
+  IDiaEnumDebugStreamData *pStream;
+  ULONG celt;
+
+  if (FAILED(pSession->getEnumDebugStreams(&pEnumStreams))) {
+    return false;
+  }
+
+  celt = 0;
+
+  for (; SUCCEEDED(pEnumStreams->Next(1, &pStream, &celt)) && (celt == 1); pStream = NULL) {
+    BSTR bstrName;
+
+    if (pStream->get_name(&bstrName) != S_OK) {
+      bstrName = NULL;
+    }
+
+    if (bstrName && wcscmp(bstrName, L"OMAPTO") == 0) {
+      OMAP_DATA data, datasav;
+      DWORD cbData, celt;
+      DWORD dwRVATo = 0;
+      unsigned int i;
+
+      datasav.dwRVATo = 0;
+      datasav.dwRVA = 0;
+
+      while (SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1)) {
+        if (dwRVA > data.dwRVA) {
+          datasav = data;
+          continue;
+        }
+
+         else if (dwRVA == data.dwRVA) {
+          dwRVATo = data.dwRVATo;
+        }
+
+        else if (datasav.dwRVATo) {
+          dwRVATo = datasav.dwRVATo + (dwRVA - datasav.dwRVA);
+        }
+        break;
+      }
+
+      wprintf(L"image rva = %08X ==> source rva = %08X\n\nRelated OMAP entries:\n", dwRVA, dwRVATo);
+      wprintf(L"image rva ==> source rva\n");
+      wprintf(L"%08X  ==> %08X\n", datasav.dwRVA, datasav.dwRVATo);
+
+      i = 0;
+
+      do {
+        wprintf(L"%08X  ==> %08X\n", data.dwRVA, data.dwRVATo);
+      }
+      while ((++i) < 5 && SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1));
+    }
+
+    if (bstrName != NULL) {
+      SysFreeString(bstrName);
+    }
+
+    pStream->Release();
+  }
+
+  pEnumStreams->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+//
+bool DumpMapFromSrc(IDiaSession *pSession, DWORD dwRVA)
+{
+  IDiaEnumDebugStreams *pEnumStreams;
+
+  if (FAILED(pSession->getEnumDebugStreams(&pEnumStreams))) {
+    return false;
+  }
+
+  IDiaEnumDebugStreamData *pStream;
+  ULONG celt = 0;
+
+  for (; SUCCEEDED(pEnumStreams->Next(1, &pStream, &celt)) && (celt == 1); pStream = NULL) {
+    BSTR bstrName;
+
+    if (pStream->get_name(&bstrName) != S_OK) {
+      bstrName = NULL;
+    }
+
+    if (bstrName && wcscmp(bstrName, L"OMAPFROM") == 0) {
+      OMAP_DATA data;
+      OMAP_DATA datasav;
+      DWORD cbData;
+      DWORD celt;
+      DWORD dwRVATo = 0;
+      unsigned int i;
+
+      datasav.dwRVATo = 0;
+      datasav.dwRVA = 0;
+
+      while (SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1)) {
+        if (dwRVA > data.dwRVA) {
+          datasav = data;
+          continue;
+        }
+
+        else if (dwRVA == data.dwRVA) {
+          dwRVATo = data.dwRVATo;
+        }
+
+        else if (datasav.dwRVATo) {
+          dwRVATo = datasav.dwRVATo + (dwRVA - datasav.dwRVA);
+        }
+        break;
+      }
+
+      wprintf(L"source rva = %08X ==> image rva = %08X\n\nRelated OMAP entries:\n", dwRVA, dwRVATo);
+      wprintf(L"source rva ==> image rva\n");
+      wprintf(L"%08X  ==> %08X\n", datasav.dwRVA, datasav.dwRVATo);
+
+      i = 0;
+
+      do {
+        wprintf(L"%08X  ==> %08X\n", data.dwRVA, data.dwRVATo);
+      }
+      while ((++i) < 5 && SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE*) &data, &celt)) && (celt == 1));
+    }
+
+    if (bstrName != NULL) {
+      SysFreeString(bstrName);
+    }
+
+    pStream->Release();
+  }
+
+  pEnumStreams->Release();
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+// Retreive the table that matches the given iid
+//
+//  A PDB table could store the section contributions, the frame data,
+//  the injected sources
+//
+HRESULT GetTable(IDiaSession *pSession, REFIID iid, void **ppUnk)
+{
+  IDiaEnumTables *pEnumTables;
+
+  if (FAILED(pSession->getEnumTables(&pEnumTables))) {
+    wprintf(L"ERROR - GetTable() getEnumTables\n");
+
+    return E_FAIL;
+  }
+
+  IDiaTable *pTable;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pEnumTables->Next(1, &pTable, &celt)) && (celt == 1)) {
+    // There's only one table that matches the given IID
+
+    if (SUCCEEDED(pTable->QueryInterface(iid, (void **) ppUnk))) {
+      pTable->Release();
+      pEnumTables->Release();
+
+      return S_OK;
+    }
+
+    pTable->Release();
+  }
+
+  pEnumTables->Release();
+
+  return E_FAIL;
+}

diff --git a/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h
new file mode 100644 (file)
index 0000000..b2accf9
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h
@@ -0,0 +1,65 @@
+#include "dia2.h"
+#include <set>
+
+extern const wchar_t *g_szFilename;
+extern IDiaDataSource *g_pDiaDataSource;
+extern IDiaSession *g_pDiaSession1, *g_pDiaSession2;
+extern IDiaSymbol *g_pGlobalSymbol1, *g_pGlobalSymbol2;
+extern DWORD g_dwMachineType;
+
+typedef std::set<std::wstring> IDiaSymbolSet;
+
+
+void PrintHelpOptions();
+bool ParseArg(int , wchar_t *[]);
+
+bool InitDiaSource(IDiaDataSource  **ppSource);
+void Cleanup();
+bool LoadDataFromPdb(const wchar_t *, IDiaDataSource *, IDiaSession **, IDiaSymbol **);
+
+
+bool EnumTypesInPdb(IDiaSymbolSet* types, IDiaSession *pSession, IDiaSymbol *pGlobal);
+bool LayoutMatches(IDiaSymbol* pSymbol1, IDiaSymbol* pSymbol2);
+
+LPSTR UnicodeToAnsi(LPCWSTR s);
+void DumpAllPdbInfo(IDiaSession *, IDiaSymbol *);
+bool DumpAllMods(IDiaSymbol *);
+bool DumpAllPublics(IDiaSymbol *);
+bool DumpCompiland(IDiaSymbol *, const wchar_t *);
+bool DumpAllSymbols(IDiaSymbol *);
+bool DumpAllGlobals(IDiaSymbol *);
+bool DumpAllTypes(IDiaSymbol *);
+bool DumpAllUDTs(IDiaSymbol *);
+bool DumpAllEnums(IDiaSymbol *);
+bool DumpAllTypedefs(IDiaSymbol *);
+bool DumpAllOEMs(IDiaSymbol *);
+bool DumpAllFiles(IDiaSession *, IDiaSymbol *);
+bool DumpAllLines(IDiaSession *, IDiaSymbol *);
+bool DumpAllLines(IDiaSession *, DWORD, DWORD);
+bool DumpAllSecContribs(IDiaSession *);
+bool DumpAllDebugStreams(IDiaSession *);
+bool DumpAllInjectedSources(IDiaSession *);
+bool DumpInjectedSource(IDiaSession *, const wchar_t *);
+bool DumpAllSourceFiles(IDiaSession *, IDiaSymbol *);
+bool DumpAllFPO(IDiaSession *);
+bool DumpFPO(IDiaSession *, DWORD);
+bool DumpFPO(IDiaSession *, IDiaSymbol *, const wchar_t *);
+bool DumpSymbolWithRVA(IDiaSession *, DWORD, const wchar_t *);
+bool DumpSymbolsWithRegEx(IDiaSymbol *, const wchar_t *, const wchar_t *);
+bool DumpSymbolWithChildren(IDiaSymbol *, const wchar_t *);
+bool DumpLines(IDiaSession *, DWORD);
+bool DumpLines(IDiaSession *, IDiaSymbol *, const wchar_t *);
+bool DumpType(IDiaSymbol *, const wchar_t *);
+bool DumpLinesForSourceFile(IDiaSession *, const wchar_t *, DWORD);
+bool DumpPublicSymbolsSorted(IDiaSession *, DWORD, DWORD, bool);
+bool DumpLabel(IDiaSession *, DWORD);
+bool DumpAnnotations(IDiaSession *, DWORD);
+bool DumpMapToSrc(IDiaSession *, DWORD);
+bool DumpMapFromSrc(IDiaSession *, DWORD);
+
+HRESULT GetTable(IDiaSession *, REFIID, void **);
+
+///////////////////////////////////////////////////////////////////
+// Functions defined in regs.cpp
+const wchar_t *SzNameC7Reg(USHORT, DWORD);
+const wchar_t *SzNameC7Reg(USHORT);

diff --git a/src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj
new file mode 100644 (file)
index 0000000..fb2f71b
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj
@@ -0,0 +1,59 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.props" />
+  <PropertyGroup>    
+    <ClCallingConvention>cdecl</ClCallingConvention>
+    <OutputName>pdbtypematch</OutputName>
+    <OutputPath>$(IntermediateOutputPath)</OutputPath>
+    <TargetType>PROGRAM</TargetType>
+    <LinkSubsystem>console</LinkSubsystem>
+    <EntryPoint>wmain</EntryPoint>
+    <UseStl>true</UseStl>     
+    <PCHHeader>stdafx.h</PCHHeader>
+    <EnableCxxPCHHeaders>true</EnableCxxPCHHeaders>
+    <PCHCompile>stdafx.cpp</PCHCompile>    
+    <PCHOutput>pdbtypematch.pch</PCHOutput>  
+    <LinkAdditionalOptions>$(LinkAdditionalOptions) /DYNAMICBASE /NXCOMPAT /ALLOWISOLATION</LinkAdditionalOptions>        
+    <CharacterSet>MultiByte</CharacterSet>    
+    <PreprocessorDefinitions>WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>      
+    <OutputPath>$(IntermediateOutputPath)</OutputPath>
+    <UserIncludes>
+        .;
+        .\include;
+        $(UserIncludes);      
+    </UserIncludes>
+    <LinkUseCMT>true</LinkUseCMT>
+    <UseMsvcrt>false</UseMsvcrt>
+    <AlwaysUseReleaseLibCMT>true</AlwaysUseReleaseLibCMT>
+        <!--
+            This would build (cl.exe) with /MT switch instead of default /MTd. However it works either way, so we do not need it now.
+            It might be handy if we ever use some debug-only CRT features by accident.
+            <ClRuntimeLibrary>MultiThreaded</ClRuntimeLibrary>
+        -->    
+                                                     
+  </PropertyGroup>
+  <!--Leaf Project Items-->
+  <ItemGroup>
+    <TargetLib Include="$(SdkLibPath)\ole32.lib" />
+    <TargetLib Include="$(SdkLibPath)\oleaut32.lib" />
+    <TargetLib Include="$(SdkLibPath)\Shlwapi.lib" />   
+    <TargetLib Include="$(CrtLibPath)\comsupp.lib" />    
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="DiaLib">
+      <ProjectReference>$(ClrSrcDirectory)toolbox\sos\diasdk\diasdk.nativeproj</ProjectReference>
+      <HintPath>$(ClrIntraLibPath)\DiaLib.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>       
+    <CppCompile Include="PrintSymbol.cpp" />
+    <CppCompile Include="regs.cpp" />
+    <CppCompile Include="PdbTypeMatch.cpp" />         
+  </ItemGroup> 
+
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
+  
+  <!--Import the targets-->
+  <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+</Project>
\ No newline at end of file

diff --git a/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp b/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp
new file mode 100644 (file)
index 0000000..defd454
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp
@@ -0,0 +1,2251 @@
+// PrintSymbol.cpp : Defines the printing procedures for the symbols
+//
+// This is a part of the Debug Interface Access SDK 
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Debug Interface Access SDK and related electronic documentation 
+// provided with the library.
+// See these sources for detailed information regarding the
+// Debug Interface Access SDK API.
+//
+
+#include "stdafx.h"
+
+#include <malloc.h>
+
+#include "dia2.h"
+#include "regs.h"
+#include "PrintSymbol.h"
+#include <comdef.h>
+
+
+// Basic types
+const wchar_t * const rgBaseType[] =
+{
+  L"<NoType>",                         // btNoType = 0,
+  L"void",                             // btVoid = 1,
+  L"char",                             // btChar = 2,
+  L"wchar_t",                          // btWChar = 3,
+  L"signed char",
+  L"unsigned char",
+  L"int",                              // btInt = 6,
+  L"unsigned int",                     // btUInt = 7,
+  L"float",                            // btFloat = 8,
+  L"<BCD>",                            // btBCD = 9,
+  L"bool",                             // btBool = 10,
+  L"short",
+  L"unsigned short",
+  L"long",                             // btLong = 13,
+  L"unsigned long",                    // btULong = 14,
+  L"__int8",
+  L"__int16",
+  L"__int32",
+  L"__int64",
+  L"__int128",
+  L"unsigned __int8",
+  L"unsigned __int16",
+  L"unsigned __int32",
+  L"unsigned __int64",
+  L"unsigned __int128",
+  L"<currency>",                       // btCurrency = 25,
+  L"<date>",                           // btDate = 26,
+  L"VARIANT",                          // btVariant = 27,
+  L"<complex>",                        // btComplex = 28,
+  L"<bit>",                            // btBit = 29,
+  L"BSTR",                             // btBSTR = 30,
+  L"HRESULT"                           // btHresult = 31
+};
+
+// Tags returned by Dia
+const wchar_t * const rgTags[] =
+{
+  L"(SymTagNull)",                     // SymTagNull
+  L"Executable (Global)",              // SymTagExe
+  L"Compiland",                        // SymTagCompiland
+  L"CompilandDetails",                 // SymTagCompilandDetails
+  L"CompilandEnv",                     // SymTagCompilandEnv
+  L"Function",                         // SymTagFunction
+  L"Block",                            // SymTagBlock
+  L"Data",                             // SymTagData
+  L"Annotation",                       // SymTagAnnotation
+  L"Label",                            // SymTagLabel
+  L"PublicSymbol",                     // SymTagPublicSymbol
+  L"UserDefinedType",                  // SymTagUDT
+  L"Enum",                             // SymTagEnum
+  L"FunctionType",                     // SymTagFunctionType
+  L"PointerType",                      // SymTagPointerType
+  L"ArrayType",                        // SymTagArrayType
+  L"BaseType",                         // SymTagBaseType
+  L"Typedef",                          // SymTagTypedef
+  L"BaseClass",                        // SymTagBaseClass
+  L"Friend",                           // SymTagFriend
+  L"FunctionArgType",                  // SymTagFunctionArgType
+  L"FuncDebugStart",                   // SymTagFuncDebugStart
+  L"FuncDebugEnd",                     // SymTagFuncDebugEnd
+  L"UsingNamespace",                   // SymTagUsingNamespace
+  L"VTableShape",                      // SymTagVTableShape
+  L"VTable",                           // SymTagVTable
+  L"Custom",                           // SymTagCustom
+  L"Thunk",                            // SymTagThunk
+  L"CustomType",                       // SymTagCustomType
+  L"ManagedType",                      // SymTagManagedType
+  L"Dimension",                        // SymTagDimension
+  L"CallSite",                         // SymTagCallSite
+};
+
+
+// Processors
+const wchar_t * const rgFloatPackageStrings[] =
+{
+  L"hardware processor (80x87 for Intel processors)",    // CV_CFL_NDP
+  L"emulator",                                           // CV_CFL_EMU
+  L"altmath",                                            // CV_CFL_ALT
+  L"???"
+};
+
+const wchar_t * const rgProcessorStrings[] =
+{
+  L"8080",                             //  CV_CFL_8080
+  L"8086",                             //  CV_CFL_8086
+  L"80286",                            //  CV_CFL_80286
+  L"80386",                            //  CV_CFL_80386
+  L"80486",                            //  CV_CFL_80486
+  L"Pentium",                          //  CV_CFL_PENTIUM
+  L"Pentium Pro/Pentium II",           //  CV_CFL_PENTIUMII/CV_CFL_PENTIUMPRO
+  L"Pentium III",                      //  CV_CFL_PENTIUMIII
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"MIPS (Generic)",                   //  CV_CFL_MIPSR4000
+  L"MIPS16",                           //  CV_CFL_MIPS16
+  L"MIPS32",                           //  CV_CFL_MIPS32
+  L"MIPS64",                           //  CV_CFL_MIPS64
+  L"MIPS I",                           //  CV_CFL_MIPSI
+  L"MIPS II",                          //  CV_CFL_MIPSII
+  L"MIPS III",                         //  CV_CFL_MIPSIII
+  L"MIPS IV",                          //  CV_CFL_MIPSIV
+  L"MIPS V",                           //  CV_CFL_MIPSV
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"M68000",                           //  CV_CFL_M68000
+  L"M68010",                           //  CV_CFL_M68010
+  L"M68020",                           //  CV_CFL_M68020
+  L"M68030",                           //  CV_CFL_M68030
+  L"M68040",                           //  CV_CFL_M68040
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Alpha 21064",                      // CV_CFL_ALPHA, CV_CFL_ALPHA_21064
+  L"Alpha 21164",                      // CV_CFL_ALPHA_21164
+  L"Alpha 21164A",                     // CV_CFL_ALPHA_21164A
+  L"Alpha 21264",                      // CV_CFL_ALPHA_21264
+  L"Alpha 21364",                      // CV_CFL_ALPHA_21364
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"PPC 601",                          // CV_CFL_PPC601
+  L"PPC 603",                          // CV_CFL_PPC603
+  L"PPC 604",                          // CV_CFL_PPC604
+  L"PPC 620",                          // CV_CFL_PPC620
+  L"PPC w/FP",                         // CV_CFL_PPCFP
+  L"PPC (Big Endian)",                 // CV_CFL_PPCBE
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"SH3",                              // CV_CFL_SH3
+  L"SH3E",                             // CV_CFL_SH3E
+  L"SH3DSP",                           // CV_CFL_SH3DSP
+  L"SH4",                              // CV_CFL_SH4
+  L"SHmedia",                          // CV_CFL_SHMEDIA
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"ARM3",                             // CV_CFL_ARM3
+  L"ARM4",                             // CV_CFL_ARM4
+  L"ARM4T",                            // CV_CFL_ARM4T
+  L"ARM5",                             // CV_CFL_ARM5
+  L"ARM5T",                            // CV_CFL_ARM5T
+  L"ARM6",                             // CV_CFL_ARM6
+  L"ARM (XMAC)",                       // CV_CFL_ARM_XMAC
+  L"ARM (WMMX)",                       // CV_CFL_ARM_WMMX
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Omni",                             // CV_CFL_OMNI
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Itanium",                          // CV_CFL_IA64, CV_CFL_IA64_1
+  L"Itanium (McKinley)",               // CV_CFL_IA64_2
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"CEE",                              // CV_CFL_CEE
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"AM33",                             // CV_CFL_AM33
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"M32R",                             // CV_CFL_M32R
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"TriCore",                          // CV_CFL_TRICORE
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"x64",                              // CV_CFL_X64
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"EBC",                              // CV_CFL_EBC
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"???",
+  L"Thumb",                            // CV_CFL_THUMB
+};
+
+const wchar_t * const rgDataKind[] =
+{
+  L"Unknown",
+  L"Local",
+  L"Static Local",
+  L"Param",
+  L"Object Ptr",
+  L"File Static",
+  L"Global",
+  L"Member",
+  L"Static Member",
+  L"Constant",
+};
+
+const wchar_t * const rgUdtKind[] =
+{
+  L"struct",
+  L"class",
+  L"union",
+  L"enum",
+};
+
+const wchar_t * const rgAccess[] =
+{
+  L"",                     // No access specifier
+  L"private",
+  L"protected",
+  L"public"
+};
+
+const wchar_t * const rgCallingConvention[] =
+{
+  L"CV_CALL_NEAR_C      ",
+  L"CV_CALL_FAR_C       ",
+  L"CV_CALL_NEAR_PASCAL ",
+  L"CV_CALL_FAR_PASCAL  ",
+  L"CV_CALL_NEAR_FAST   ",
+  L"CV_CALL_FAR_FAST    ",
+  L"CV_CALL_SKIPPED     ",
+  L"CV_CALL_NEAR_STD    ",
+  L"CV_CALL_FAR_STD     ",
+  L"CV_CALL_NEAR_SYS    ",
+  L"CV_CALL_FAR_SYS     ",
+  L"CV_CALL_THISCALL    ",
+  L"CV_CALL_MIPSCALL    ",
+  L"CV_CALL_GENERIC     ",
+  L"CV_CALL_ALPHACALL   ",
+  L"CV_CALL_PPCCALL     ",
+  L"CV_CALL_SHCALL      ",
+  L"CV_CALL_ARMCALL     ",
+  L"CV_CALL_AM33CALL    ",
+  L"CV_CALL_TRICALL     ",
+  L"CV_CALL_SH5CALL     ",
+  L"CV_CALL_M32RCALL    ",
+  L"CV_CALL_RESERVED    "
+};
+
+const wchar_t * const rgLanguage[] =
+{
+  L"C",                                // CV_CFL_C
+  L"C++",                              // CV_CFL_CXX
+  L"FORTRAN",                          // CV_CFL_FORTRAN
+  L"MASM",                             // CV_CFL_MASM
+  L"Pascal",                           // CV_CFL_PASCAL
+  L"Basic",                            // CV_CFL_BASIC
+  L"COBOL",                            // CV_CFL_COBOL
+  L"LINK",                             // CV_CFL_LINK
+  L"CVTRES",                           // CV_CFL_CVTRES
+  L"CVTPGD",                           // CV_CFL_CVTPGD
+  L"C#",                               // CV_CFL_CSHARP
+  L"Visual Basic",                     // CV_CFL_VB
+  L"ILASM",                            // CV_CFL_ILASM
+  L"Java",                             // CV_CFL_JAVA
+  L"JScript",                          // CV_CFL_JSCRIPT
+  L"MSIL",                             // CV_CFL_MSIL
+};
+
+const wchar_t * const rgLocationTypeString[] =
+{
+  L"NULL",
+  L"static",
+  L"TLS",
+  L"RegRel",
+  L"ThisRel",
+  L"Enregistered",
+  L"BitField",
+  L"Slot",
+  L"IL Relative",
+  L"In MetaData",
+  L"Constant"
+};
+
+
+////////////////////////////////////////////////////////////
+// Print a public symbol info: name, VA, RVA, SEG:OFF
+//
+void PrintPublicSymbol(IDiaSymbol *pSymbol)
+{
+  DWORD dwSymTag;
+  DWORD dwRVA;
+  DWORD dwSeg;
+  DWORD dwOff;
+  BSTR bstrName;
+  
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    return;
+  }
+
+  if (pSymbol->get_relativeVirtualAddress(&dwRVA) != S_OK) {
+    dwRVA = 0xFFFFFFFF;
+  }
+
+  pSymbol->get_addressSection(&dwSeg);
+  pSymbol->get_addressOffset(&dwOff);
+
+  wprintf(L"%s: [%08X][%04X:%08X] ", rgTags[dwSymTag], dwRVA, dwSeg, dwOff);
+  
+  if (dwSymTag == SymTagThunk) {
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      wprintf(L"%s\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    else {
+      if (pSymbol->get_targetRelativeVirtualAddress(&dwRVA) != S_OK) {
+        dwRVA = 0xFFFFFFFF;
+      }
+
+      pSymbol->get_targetSection(&dwSeg);
+      pSymbol->get_targetOffset(&dwOff);
+
+      wprintf(L"target -> [%08X][%04X:%08X]\n", dwRVA, dwSeg, dwOff);
+    }
+  }
+
+  else {
+    // must be a function or a data symbol
+
+    BSTR bstrUndname;
+
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      if (pSymbol->get_undecoratedName(&bstrUndname) == S_OK) {
+        wprintf(L"%s(%s)\n", bstrName, bstrUndname);
+
+        SysFreeString(bstrUndname);
+      }
+
+      else {
+        wprintf(L"%s\n", bstrName);
+      }
+
+      SysFreeString(bstrName);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a global symbol info: name, VA, RVA, SEG:OFF
+//
+void PrintGlobalSymbol(IDiaSymbol *pSymbol)
+{
+  DWORD dwSymTag;
+  DWORD dwRVA;
+  DWORD dwSeg;
+  DWORD dwOff;
+  
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    return;
+  }
+
+  if (pSymbol->get_relativeVirtualAddress(&dwRVA) != S_OK) {
+    dwRVA = 0xFFFFFFFF;
+  }
+
+  pSymbol->get_addressSection(&dwSeg);
+  pSymbol->get_addressOffset(&dwOff);
+
+  wprintf(L"%s: [%08X][%04X:%08X] ", rgTags[dwSymTag], dwRVA, dwSeg, dwOff);
+  
+  if (dwSymTag == SymTagThunk) {
+    BSTR bstrName;
+
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      wprintf(L"%s\n", bstrName);
+
+      SysFreeString(bstrName);
+    }
+
+    else {
+      if (pSymbol->get_targetRelativeVirtualAddress(&dwRVA) != S_OK) {
+        dwRVA = 0xFFFFFFFF;
+      }
+
+      pSymbol->get_targetSection(&dwSeg);
+      pSymbol->get_targetOffset(&dwOff);
+      wprintf(L"target -> [%08X][%04X:%08X]\n", dwRVA, dwSeg, dwOff);
+    }
+  }
+
+  else {
+    BSTR bstrName;
+    BSTR bstrUndname;
+
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      if (pSymbol->get_undecoratedName(&bstrUndname) == S_OK) {
+        wprintf(L"%s(%s)\n", bstrName, bstrUndname);
+
+        SysFreeString(bstrUndname);
+      }
+
+      else {
+        wprintf(L"%s\n", bstrName);
+      }
+
+      SysFreeString(bstrName);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a callsite symbol info: SEG:OFF, RVA, type
+//
+void PrintCallSiteInfo(IDiaSymbol *pSymbol)
+{
+  DWORD dwISect, dwOffset;
+  if (pSymbol->get_addressSection(&dwISect) == S_OK &&
+    pSymbol->get_addressOffset(&dwOffset) == S_OK) {
+    wprintf(L"[0x%04x:0x%08x]  ", dwISect, dwOffset);
+  }
+
+  DWORD rva;
+  if (pSymbol->get_relativeVirtualAddress(&rva) == S_OK) {
+    wprintf(L"0x%08X  ", rva);
+  }
+
+  IDiaSymbol *pFuncType;
+  if (pSymbol->get_type(&pFuncType) == S_OK) {
+    DWORD tag;
+    if (pFuncType->get_symTag(&tag) == S_OK) {
+      switch(tag)
+      {
+        case SymTagFunctionType:
+          PrintFunctionType(pSymbol);
+          break;
+        case SymTagPointerType:
+          PrintFunctionType(pFuncType);
+          break;
+        default:
+          wprintf(L"???\n");
+          break;
+      }
+    }
+    pFuncType->Release();
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a symbol info: name, type etc.
+//
+void PrintSymbol(IDiaSymbol *pSymbol, DWORD dwIndent)
+{
+  IDiaSymbol *pType;
+  DWORD dwSymTag;
+  ULONGLONG ulLen;
+  
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    wprintf(L"ERROR - PrintSymbol get_symTag() failed\n");
+    return;
+  }
+
+  if (dwSymTag == SymTagFunction) {
+    putwchar(L'\n');
+  }
+
+  PrintSymTag(dwSymTag);
+
+  for (DWORD i = 0; i < dwIndent; i++) {
+    putwchar(L' ');
+  }
+
+  switch (dwSymTag) {
+    case SymTagCompilandDetails:
+      PrintCompilandDetails(pSymbol);
+      break;
+
+    case SymTagCompilandEnv:
+      PrintCompilandEnv(pSymbol);
+      break;
+
+    case SymTagData:
+      PrintData(pSymbol, dwIndent + 2);
+      break;
+
+    case SymTagFunction:
+    case SymTagBlock:
+      PrintLocation(pSymbol);
+
+      if (pSymbol->get_length(&ulLen) == S_OK) {
+        wprintf(L", len = %08X, ", ulLen);
+      }
+
+      if (dwSymTag == SymTagFunction) {
+        DWORD dwCall;
+
+        if (pSymbol->get_callingConvention(&dwCall) == S_OK) {
+          wprintf(L", %s", SafeDRef(rgCallingConvention, dwCall));
+        }
+      }
+
+      PrintUndName(pSymbol);
+      putwchar(L'\n');
+
+      if (dwSymTag == SymTagFunction)
+      {
+        BOOL f;
+
+        for (DWORD i = 0; i < dwIndent; i++) {
+          putwchar(L' ');
+        }
+        wprintf(L"                 Function attribute:");
+
+        if ((pSymbol->get_isCxxReturnUdt(&f) == S_OK) && f) {
+          wprintf(L" return user defined type (C++ style)");
+        }
+        if ((pSymbol->get_constructor(&f) == S_OK) && f) {
+          wprintf(L" instance constructor");
+        }
+        if ((pSymbol->get_isConstructorVirtualBase(&f) == S_OK) && f) {
+          wprintf(L" instance constructor of a class with virtual base");
+        }
+        putwchar (L'\n');
+
+        for (DWORD i = 0; i < dwIndent; i++) {
+          putwchar(L' ');
+        }
+        wprintf(L"                 Function info:");
+
+        if ((pSymbol->get_hasAlloca(&f) == S_OK) && f) {
+          wprintf(L" alloca");
+        }
+
+        if ((pSymbol->get_hasSetJump(&f) == S_OK) && f) {
+          wprintf(L" setjmp");
+        }
+
+        if ((pSymbol->get_hasLongJump(&f) == S_OK) && f) {
+          wprintf(L" longjmp");
+        }
+
+        if ((pSymbol->get_hasInlAsm(&f) == S_OK) && f) {
+          wprintf(L" inlasm");
+        }
+
+        if ((pSymbol->get_hasEH(&f) == S_OK) && f) {
+          wprintf(L" eh");
+        }
+
+        if ((pSymbol->get_inlSpec(&f) == S_OK) && f) {
+          wprintf(L" inl_specified");
+        }
+
+        if ((pSymbol->get_hasSEH(&f) == S_OK) && f) {
+          wprintf(L" seh");
+        }
+
+        if ((pSymbol->get_isNaked(&f) == S_OK) && f) {
+          wprintf(L" naked");
+        }
+
+        if ((pSymbol->get_hasSecurityChecks(&f) == S_OK) && f) {
+          wprintf(L" gschecks");
+        }
+
+        if ((pSymbol->get_isSafeBuffers(&f) == S_OK) && f) {
+          wprintf(L" safebuffers");
+        }
+
+        if ((pSymbol->get_hasEHa(&f) == S_OK) && f) {
+          wprintf(L" asyncheh");
+        }
+
+        if ((pSymbol->get_noStackOrdering(&f) == S_OK) && f) {
+          wprintf(L" gsnostackordering");
+        }
+
+        if ((pSymbol->get_wasInlined(&f) == S_OK) && f) {
+          wprintf(L" wasinlined");
+        }
+
+        if ((pSymbol->get_strictGSCheck(&f) == S_OK) && f) {
+          wprintf(L" strict_gs_check");
+        }
+
+        putwchar(L'\n');
+      }
+
+      IDiaEnumSymbols *pEnumChildren;
+
+      if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        IDiaSymbol *pChild;
+        ULONG celt = 0;
+
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          PrintSymbol(pChild, dwIndent + 2);
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+      }
+      return;
+
+    case SymTagAnnotation:
+      PrintLocation(pSymbol);
+      putwchar(L'\n');
+      break;
+
+    case SymTagLabel:
+      PrintLocation(pSymbol);
+      wprintf(L", ");
+      PrintName(pSymbol);
+      break;
+
+    case SymTagEnum:
+    case SymTagTypedef:
+    case SymTagUDT:
+    case SymTagBaseClass:
+      PrintUDT(pSymbol);
+      break;
+
+    case SymTagFuncDebugStart:
+    case SymTagFuncDebugEnd:
+      PrintLocation(pSymbol);
+      break;
+
+    case SymTagFunctionArgType:
+    case SymTagFunctionType:
+    case SymTagPointerType:
+    case SymTagArrayType:
+    case SymTagBaseType:
+      if (pSymbol->get_type(&pType) == S_OK) {
+        PrintType(pType);
+        pType->Release();
+      }
+
+      putwchar(L'\n');
+      break;
+
+    case SymTagThunk:
+      PrintThunk(pSymbol);
+      break;
+
+    case SymTagCallSite:
+      PrintCallSiteInfo(pSymbol);
+      break;
+        
+    default:
+      PrintName(pSymbol);
+
+      IDiaSymbol *pType;
+
+      if (pSymbol->get_type(&pType) == S_OK) {
+        wprintf(L" has type ");
+        PrintType(pType);
+        pType->Release();
+      }
+  }
+
+  if ((dwSymTag == SymTagUDT) || (dwSymTag == SymTagAnnotation)) {
+    IDiaEnumSymbols *pEnumChildren;
+
+    putwchar(L'\n');
+
+    if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+      IDiaSymbol *pChild;
+      ULONG celt = 0;
+
+      while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+        PrintSymbol(pChild, dwIndent + 2);
+        pChild->Release();
+      }
+
+      pEnumChildren->Release();
+    }
+  }
+  putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print the string coresponding to the symbol's tag property
+//
+void PrintSymTag(DWORD dwSymTag)
+{
+  wprintf(L"%-15s: ", SafeDRef(rgTags, dwSymTag));
+}
+
+////////////////////////////////////////////////////////////
+// Print the name of the symbol
+//
+void PrintName(IDiaSymbol *pSymbol)
+{
+  BSTR bstrName;
+  BSTR bstrUndName;
+
+  if (pSymbol->get_name(&bstrName) != S_OK) {
+    wprintf(L"(none)");
+    return;
+  }
+
+  if (pSymbol->get_undecoratedName(&bstrUndName) == S_OK) {
+    if (wcscmp(bstrName, bstrUndName) == 0) {
+      wprintf(L"%s", bstrName);
+    }
+
+    else {
+      wprintf(L"%s(%s)", bstrUndName, bstrName);
+    }
+
+    SysFreeString(bstrUndName);
+  }
+
+  else {
+    wprintf(L"%s", bstrName);
+  }
+
+  SysFreeString(bstrName);
+}
+
+void GetSymbolName(std::wstring& symbolName, IDiaSymbol *pSymbol)
+{
+    BSTR bstrName;
+    BSTR bstrUndName;
+
+    if (pSymbol->get_name(&bstrName) != S_OK) {
+    symbolName.clear();
+    return;
+    }
+
+    if (pSymbol->get_undecoratedName(&bstrUndName) == S_OK) {
+    if (wcscmp(bstrName, bstrUndName) == 0) 
+    {
+        symbolName= _bstr_t(bstrName);
+    }
+    else
+    {
+        symbolName= _bstr_t(bstrUndName);
+    }
+
+        SysFreeString(bstrUndName);
+    }
+
+    else 
+    {
+        symbolName= _bstr_t(bstrName);
+    }
+
+    SysFreeString(bstrName);
+}
+
+////////////////////////////////////////////////////////////
+// Print the undecorated name of the symbol
+//  - only SymTagFunction, SymTagData and SymTagPublicSymbol
+//    can have this property set
+//
+void PrintUndName(IDiaSymbol *pSymbol)
+{
+  BSTR bstrName;
+
+  if (pSymbol->get_undecoratedName(&bstrName) != S_OK) {
+    if (pSymbol->get_name(&bstrName) == S_OK) {
+      // Print the name of the symbol instead
+
+      wprintf(L"%s", (bstrName[0] != L'\0') ? bstrName : L"(none)");
+
+      SysFreeString(bstrName);
+    }
+
+    else {
+      wprintf(L"(none)");
+    }
+
+    return;
+  }
+
+  if (bstrName[0] != L'\0') {
+    wprintf(L"%s", bstrName);
+  }
+
+  SysFreeString(bstrName);
+}
+
+////////////////////////////////////////////////////////////
+// Print a SymTagThunk symbol's info
+//
+void PrintThunk(IDiaSymbol *pSymbol)
+{
+  DWORD dwRVA;
+  DWORD dwISect;
+  DWORD dwOffset;
+
+  if ((pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+      (pSymbol->get_addressSection(&dwISect) == S_OK) &&
+      (pSymbol->get_addressOffset(&dwOffset) == S_OK)) {
+    wprintf(L"[%08X][%04X:%08X]", dwRVA, dwISect, dwOffset);
+  }
+
+  if ((pSymbol->get_targetSection(&dwISect) == S_OK) &&
+      (pSymbol->get_targetOffset(&dwOffset) == S_OK) &&
+      (pSymbol->get_targetRelativeVirtualAddress(&dwRVA) == S_OK)) {
+    wprintf(L", target [%08X][%04X:%08X] ", dwRVA, dwISect, dwOffset);
+  }
+
+  else {
+    wprintf(L", target ");
+
+    PrintName(pSymbol);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print the compiland/module details: language, platform...
+//
+void PrintCompilandDetails(IDiaSymbol *pSymbol)
+{
+  DWORD dwLanguage;
+
+  if (pSymbol->get_language(&dwLanguage) == S_OK) {
+    wprintf(L"\n\tLanguage: %s\n", SafeDRef(rgLanguage, dwLanguage));
+  }
+
+  DWORD dwPlatform;
+
+  if (pSymbol->get_platform(&dwPlatform) == S_OK) {
+    wprintf(L"\tTarget processor: %s\n", SafeDRef(rgProcessorStrings, dwPlatform));
+  }
+
+  BOOL fEC;
+
+  if (pSymbol->get_editAndContinueEnabled(&fEC) == S_OK) {
+    if (fEC) {
+      wprintf(L"\tCompiled for edit and continue: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled for edit and continue: no\n");
+    }
+  }
+
+  BOOL fDbgInfo;
+
+  if (pSymbol->get_hasDebugInfo(&fDbgInfo) == S_OK) {
+    if (fDbgInfo) {
+      wprintf(L"\tCompiled without debugging info: no\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled without debugging info: yes\n");
+    }
+  }
+
+  BOOL fLTCG;
+
+  if (pSymbol->get_isLTCG(&fLTCG) == S_OK) {
+    if (fLTCG) {
+      wprintf(L"\tCompiled with LTCG: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with LTCG: no\n");
+    }
+  }
+
+  BOOL fDataAlign;
+
+  if (pSymbol->get_isDataAligned(&fDataAlign) == S_OK) {
+    if (fDataAlign) {
+      wprintf(L"\tCompiled with /bzalign: no\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with /bzalign: yes\n");
+    }
+  }
+
+  BOOL fManagedPresent;
+
+  if (pSymbol->get_hasManagedCode(&fManagedPresent) == S_OK) {
+    if (fManagedPresent) {
+      wprintf(L"\tManaged code present: yes\n");
+    }
+
+    else {
+      wprintf(L"\tManaged code present: no\n");
+    }
+  }
+
+  BOOL fSecurityChecks;
+
+  if (pSymbol->get_hasSecurityChecks(&fSecurityChecks) == S_OK) {
+    if (fSecurityChecks) {
+      wprintf(L"\tCompiled with /GS: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with /GS: no\n");
+    }
+  }
+
+  BOOL fHotPatch;
+
+  if (pSymbol->get_isHotpatchable(&fHotPatch) == S_OK) {
+    if (fHotPatch) {
+      wprintf(L"\tCompiled with /hotpatch: yes\n");
+    }
+
+    else {
+      wprintf(L"\tCompiled with /hotpatch: no\n");
+    }
+  }
+
+  BOOL fCVTCIL;
+
+  if (pSymbol->get_isCVTCIL(&fCVTCIL) == S_OK) {
+    if (fCVTCIL) {
+      wprintf(L"\tConverted by CVTCIL: yes\n");
+    }
+
+    else {
+      wprintf(L"\tConverted by CVTCIL: no\n");
+    }
+  }
+
+  BOOL fMSILModule;
+
+  if (pSymbol->get_isMSILNetmodule(&fMSILModule) == S_OK) {
+    if (fMSILModule) {
+      wprintf(L"\tMSIL module: yes\n");
+    }
+
+    else {
+      wprintf(L"\tMSIL module: no\n");
+    }
+  }
+
+  DWORD dwVerMajor;
+  DWORD dwVerMinor;
+  DWORD dwVerBuild;
+  DWORD dwVerQFE;
+
+  if ((pSymbol->get_frontEndMajor(&dwVerMajor) == S_OK) &&
+      (pSymbol->get_frontEndMinor(&dwVerMinor) == S_OK) &&
+      (pSymbol->get_frontEndBuild(&dwVerBuild) == S_OK)) {
+    wprintf(L"\tFrontend Version: Major = %u, Minor = %u, Build = %u",
+            dwVerMajor,
+            dwVerMinor,
+            dwVerBuild);
+
+    if (pSymbol->get_frontEndQFE(&dwVerQFE) == S_OK) {
+      wprintf(L", QFE = %u", dwVerQFE);
+    }
+
+    putwchar(L'\n');
+  }
+
+  if ((pSymbol->get_backEndMajor(&dwVerMajor) == S_OK) &&
+      (pSymbol->get_backEndMinor(&dwVerMinor) == S_OK) &&
+      (pSymbol->get_backEndBuild(&dwVerBuild) == S_OK)) {
+    wprintf(L"\tBackend Version: Major = %u, Minor = %u, Build = %u",
+            dwVerMajor,
+            dwVerMinor,
+            dwVerBuild);
+
+    if (pSymbol->get_backEndQFE(&dwVerQFE) == S_OK) {
+      wprintf(L", QFE = %u", dwVerQFE);
+    }
+
+    putwchar(L'\n');
+  }
+
+  BSTR bstrCompilerName;
+
+  if (pSymbol->get_compilerName(&bstrCompilerName) == S_OK) {
+    if (bstrCompilerName != NULL) {
+      wprintf(L"\tVersion string: %s", bstrCompilerName);
+
+      SysFreeString(bstrCompilerName);
+    }
+  }
+
+  putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print the compilan/module env
+//
+void PrintCompilandEnv(IDiaSymbol *pSymbol)
+{
+  PrintName(pSymbol);
+  wprintf(L" =");
+
+  VARIANT vt = { VT_EMPTY };
+
+  if (pSymbol->get_value(&vt) == S_OK) {
+    PrintVariant(vt);
+    VariantClear((VARIANTARG *) &vt);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a string corespondig to a location type
+//
+void PrintLocation(IDiaSymbol *pSymbol)
+{
+  DWORD dwLocType;
+  DWORD dwRVA, dwSect, dwOff, dwReg, dwBitPos, dwSlot;
+  LONG lOffset;
+  ULONGLONG ulLen;
+  VARIANT vt = { VT_EMPTY };
+
+  if (pSymbol->get_locationType(&dwLocType) != S_OK) {
+    // It must be a symbol in optimized code
+
+    wprintf(L"symbol in optmized code");
+    return;
+  }
+
+  switch (dwLocType) {
+    case LocIsStatic:
+      if ((pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+          (pSymbol->get_addressSection(&dwSect) == S_OK) &&
+          (pSymbol->get_addressOffset(&dwOff) == S_OK)) {
+        wprintf(L"%s, [%08X][%04X:%08X]", SafeDRef(rgLocationTypeString, dwLocType), dwRVA, dwSect, dwOff);
+      }
+      break;
+
+    case LocIsTLS:
+    case LocInMetaData:
+    case LocIsIlRel:
+      if ((pSymbol->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+          (pSymbol->get_addressSection(&dwSect) == S_OK) &&
+          (pSymbol->get_addressOffset(&dwOff) == S_OK)) {
+        wprintf(L"%s, [%08X][%04X:%08X]", SafeDRef(rgLocationTypeString, dwLocType), dwRVA, dwSect, dwOff);
+      }
+      break;
+
+    case LocIsRegRel:
+      if ((pSymbol->get_registerId(&dwReg) == S_OK) &&
+          (pSymbol->get_offset(&lOffset) == S_OK)) {
+        wprintf(L"%s Relative, [%08X]", SzNameC7Reg((USHORT) dwReg), lOffset);
+      }
+      break;
+
+    case LocIsThisRel:
+      if (pSymbol->get_offset(&lOffset) == S_OK) {
+        wprintf(L"this+0x%X", lOffset);
+      }
+      break;
+
+    case LocIsBitField:
+      if ((pSymbol->get_offset(&lOffset) == S_OK) &&
+          (pSymbol->get_bitPosition(&dwBitPos) == S_OK) &&
+          (pSymbol->get_length(&ulLen) == S_OK)) {
+        wprintf(L"this(bf)+0x%X:0x%X len(0x%X)", lOffset, dwBitPos, ulLen);
+      }
+      break;
+
+    case LocIsEnregistered:
+      if (pSymbol->get_registerId(&dwReg) == S_OK) {
+        wprintf(L"enregistered %s", SzNameC7Reg((USHORT) dwReg));
+      }
+      break;
+
+    case LocIsSlot:
+      if (pSymbol->get_slot(&dwSlot) == S_OK) {
+        wprintf(L"%s, [%08X]", SafeDRef(rgLocationTypeString, dwLocType), dwSlot);
+      }
+      break;
+
+    case LocIsConstant:
+      wprintf(L"constant");
+
+      if (pSymbol->get_value(&vt) == S_OK) {
+        PrintVariant(vt);
+        VariantClear((VARIANTARG *) &vt);
+      }
+      break;
+
+    case LocIsNull:
+      break;
+
+    default :
+      wprintf(L"Error - invalid location type: 0x%X", dwLocType);
+      break;
+    }
+}
+
+////////////////////////////////////////////////////////////
+// Print the type, value and the name of a const symbol
+//
+void PrintConst(IDiaSymbol *pSymbol)
+{
+  PrintSymbolType(pSymbol);
+
+  VARIANT vt = { VT_EMPTY };
+
+  if (pSymbol->get_value(&vt) == S_OK) {
+    PrintVariant(vt);
+    VariantClear((VARIANTARG *) &vt);
+  }
+
+  PrintName(pSymbol);
+}
+
+////////////////////////////////////////////////////////////
+// Print the name and the type of an user defined type
+//
+void PrintUDT(IDiaSymbol *pSymbol)
+{
+  PrintName(pSymbol);
+  PrintSymbolType(pSymbol);
+}
+
+////////////////////////////////////////////////////////////
+// Print a string representing the type of a symbol
+//
+void PrintSymbolType(IDiaSymbol *pSymbol)
+{
+  IDiaSymbol *pType;
+
+  if (pSymbol->get_type(&pType) == S_OK) {
+    wprintf(L", Type: ");
+    PrintType(pType);
+    pType->Release();
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print the information details for a type symbol
+//
+void PrintType(IDiaSymbol *pSymbol)
+{
+  IDiaSymbol *pBaseType;
+  IDiaEnumSymbols *pEnumSym;
+  IDiaSymbol *pSym;
+  DWORD dwTag;
+  BSTR bstrName;
+  DWORD dwInfo;
+  BOOL bSet;
+  DWORD dwRank;
+  LONG lCount = 0;
+  ULONG celt = 1;
+
+  if (pSymbol->get_symTag(&dwTag) != S_OK) {
+    wprintf(L"ERROR - can't retrieve the symbol's SymTag\n");
+    return;
+  }
+
+  if (pSymbol->get_name(&bstrName) != S_OK) {
+    bstrName = NULL;
+  }
+
+  if (dwTag != SymTagPointerType) {
+    if ((pSymbol->get_constType(&bSet) == S_OK) && bSet) {
+      wprintf(L"const ");
+    }
+
+    if ((pSymbol->get_volatileType(&bSet) == S_OK) && bSet) {
+       wprintf(L"volatile ");
+    }
+
+    if ((pSymbol->get_unalignedType(&bSet) == S_OK) && bSet) {
+      wprintf(L"__unaligned ");
+    }
+  }
+
+  ULONGLONG ulLen;
+
+  pSymbol->get_length(&ulLen);
+
+  switch (dwTag) {
+    case SymTagUDT:
+      PrintUdtKind(pSymbol);
+      PrintName(pSymbol);
+      break;
+
+    case SymTagEnum:
+      wprintf(L"enum ");
+      PrintName(pSymbol);
+      break;
+
+    case SymTagFunctionType:
+      wprintf(L"function ");
+      break;
+
+    case SymTagPointerType:
+      if (pSymbol->get_type(&pBaseType) != S_OK) {
+        wprintf(L"ERROR - SymTagPointerType get_type");
+        if (bstrName != NULL) {
+          SysFreeString(bstrName);
+        }
+        return;
+      }
+
+      PrintType(pBaseType);
+      pBaseType->Release();
+
+      if ((pSymbol->get_reference(&bSet) == S_OK) && bSet) {
+        wprintf(L" &");
+      }
+
+      else {
+        wprintf(L" *");
+      }
+
+      if ((pSymbol->get_constType(&bSet) == S_OK) && bSet) {
+        wprintf(L" const");
+      }
+
+      if ((pSymbol->get_volatileType(&bSet) == S_OK) && bSet) {
+        wprintf(L" volatile");
+      }
+
+      if ((pSymbol->get_unalignedType(&bSet) == S_OK) && bSet) {
+        wprintf(L" __unaligned");
+      }
+      break;
+
+    case SymTagArrayType:
+      if (pSymbol->get_type(&pBaseType) == S_OK) {
+        PrintType(pBaseType);
+
+        if (pSymbol->get_rank(&dwRank) == S_OK) {
+          if (SUCCEEDED(pSymbol->findChildren(SymTagDimension, NULL, nsNone, &pEnumSym)) && (pEnumSym != NULL)) {
+            while (SUCCEEDED(pEnumSym->Next(1, &pSym, &celt)) && (celt == 1)) {
+              IDiaSymbol *pBound;
+
+              wprintf(L"[");
+
+              if (pSym->get_lowerBound(&pBound) == S_OK) {
+                PrintBound(pBound);
+
+                wprintf(L"..");
+
+                pBound->Release();
+              }
+
+              pBound = NULL;
+
+              if (pSym->get_upperBound(&pBound) == S_OK) {
+                PrintBound(pBound);
+
+                pBound->Release();
+              }
+
+              pSym->Release();
+              pSym = NULL;
+
+              wprintf(L"]");
+            }
+
+            pEnumSym->Release();
+          }
+        }
+
+        else if (SUCCEEDED(pSymbol->findChildren(SymTagCustomType, NULL, nsNone, &pEnumSym)) &&
+                 (pEnumSym != NULL) &&
+                 (pEnumSym->get_Count(&lCount) == S_OK) &&
+                 (lCount > 0)) {
+          while (SUCCEEDED(pEnumSym->Next(1, &pSym, &celt)) && (celt == 1)) {
+            wprintf(L"[");
+            PrintType(pSym);
+            wprintf(L"]");
+
+            pSym->Release();
+          }
+
+          pEnumSym->Release();
+        }
+
+        else {
+          DWORD dwCountElems;
+          ULONGLONG ulLenArray;
+          ULONGLONG ulLenElem;
+
+          if (pSymbol->get_count(&dwCountElems) == S_OK) {
+            wprintf(L"[0x%X]", dwCountElems);
+          }
+
+          else if ((pSymbol->get_length(&ulLenArray) == S_OK) &&
+                   (pBaseType->get_length(&ulLenElem) == S_OK)) {
+            if (ulLenElem == 0) {
+              wprintf(L"[0x%lX]", ulLenArray);
+            }
+
+            else {
+              wprintf(L"[0x%lX]", ulLenArray/ulLenElem);
+            }
+          }
+        }
+
+        pBaseType->Release();
+      }
+
+      else {
+        wprintf(L"ERROR - SymTagArrayType get_type\n");
+        if (bstrName != NULL) {
+          SysFreeString(bstrName);
+        }
+        return;
+      }
+      break;
+
+    case SymTagBaseType:
+      if (pSymbol->get_baseType(&dwInfo) != S_OK) {
+        wprintf(L"SymTagBaseType get_baseType\n");
+        if (bstrName != NULL) {
+          SysFreeString(bstrName);
+        }
+        return;
+      }
+
+      switch (dwInfo) {
+        case btUInt :
+          wprintf(L"unsigned ");
+
+        // Fall through
+
+        case btInt :
+          switch (ulLen) {
+            case 1:
+              if (dwInfo == btInt) {
+                wprintf(L"signed ");
+              }
+
+              wprintf(L"char");
+              break;
+
+            case 2:
+              wprintf(L"short");
+              break;
+
+            case 4:
+              wprintf(L"int");
+              break;
+
+            case 8:
+              wprintf(L"__int64");
+              break;
+          }
+
+          dwInfo = 0xFFFFFFFF;
+          break;
+
+        case btFloat :
+          switch (ulLen) {
+            case 4:
+              wprintf(L"float");
+              break;
+
+            case 8:
+              wprintf(L"double");
+              break;
+          }
+
+          dwInfo = 0xFFFFFFFF;
+          break;
+      }
+
+      if (dwInfo == 0xFFFFFFFF) {
+         break;
+      }
+
+      wprintf(L"%s", rgBaseType[dwInfo]);
+      break;
+
+    case SymTagTypedef:
+      PrintName(pSymbol);
+      break;
+
+    case SymTagCustomType:
+      {
+        DWORD idOEM, idOEMSym;
+        DWORD cbData = 0;
+        DWORD count;
+
+        if (pSymbol->get_oemId(&idOEM) == S_OK) {
+          wprintf(L"OEMId = %X, ", idOEM);
+        }
+
+        if (pSymbol->get_oemSymbolId(&idOEMSym) == S_OK) {
+          wprintf(L"SymbolId = %X, ", idOEMSym);
+        }
+
+        if (pSymbol->get_types(0, &count, NULL) == S_OK) {
+          IDiaSymbol** rgpDiaSymbols = (IDiaSymbol**) _alloca(sizeof(IDiaSymbol *) * count);
+
+          if (pSymbol->get_types(count, &count, rgpDiaSymbols) == S_OK) {
+            for (ULONG i = 0; i < count; i++) {
+              PrintType(rgpDiaSymbols[i]);
+              rgpDiaSymbols[i]->Release();
+            }
+          }
+        }
+
+        // print custom data
+
+        if ((pSymbol->get_dataBytes(cbData, &cbData, NULL) == S_OK) && (cbData != 0)) {
+          wprintf(L", Data: ");
+
+          BYTE *pbData = new BYTE[cbData];
+
+          pSymbol->get_dataBytes(cbData, &cbData, pbData);
+
+          for (ULONG i = 0; i < cbData; i++) {
+            wprintf(L"0x%02X ", pbData[i]);
+          }
+
+          delete [] pbData;
+        }
+      }
+      break;
+
+    case SymTagData: // This really is member data, just print its location
+      PrintLocation(pSymbol);
+      break;
+  }
+
+  if (bstrName != NULL) {
+    SysFreeString(bstrName);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print bound information
+//
+void PrintBound(IDiaSymbol *pSymbol)
+{
+  DWORD dwTag = 0;
+  DWORD dwKind;
+
+  if (pSymbol->get_symTag(&dwTag) != S_OK) {
+    wprintf(L"ERROR - PrintBound() get_symTag");
+    return;
+  }
+
+  if (pSymbol->get_locationType(&dwKind) != S_OK) {
+    wprintf(L"ERROR - PrintBound() get_locationType");
+    return;
+  }
+
+  if (dwTag == SymTagData && dwKind == LocIsConstant) {
+    VARIANT v;
+
+    if (pSymbol->get_value(&v) == S_OK) {
+      PrintVariant(v);
+      VariantClear((VARIANTARG *) &v);
+    }
+  }
+
+  else {
+    PrintName(pSymbol);
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintData(IDiaSymbol *pSymbol, DWORD dwIndent)
+{
+  PrintLocation(pSymbol);
+
+  DWORD dwDataKind;
+  if (pSymbol->get_dataKind(&dwDataKind) != S_OK) {
+    wprintf(L"ERROR - PrintData() get_dataKind");
+    return;
+  }
+
+  wprintf(L", %s", SafeDRef(rgDataKind, dwDataKind));
+  PrintSymbolType(pSymbol);
+
+  wprintf(L", ");
+  PrintName(pSymbol);
+}
+
+////////////////////////////////////////////////////////////
+// Print a VARIANT
+//
+void PrintVariant(VARIANT var)
+{
+  switch (var.vt) {
+    case VT_UI1:
+    case VT_I1:
+      wprintf(L" 0x%X", var.bVal);
+      break;
+
+    case VT_I2:
+    case VT_UI2:
+    case VT_BOOL:
+      wprintf(L" 0x%X", var.iVal);
+      break;
+
+    case VT_I4:
+    case VT_UI4:
+    case VT_INT:
+    case VT_UINT:
+    case VT_ERROR:
+      wprintf(L" 0x%X", var.lVal);
+      break;
+
+    case VT_R4:
+      wprintf(L" %g", var.fltVal);
+      break;
+
+    case VT_R8:
+      wprintf(L" %g", var.dblVal);
+      break;
+
+    case VT_BSTR:
+      wprintf(L" \"%s\"", var.bstrVal);
+      break;
+
+    default:
+      wprintf(L" ??");
+    }
+}
+
+////////////////////////////////////////////////////////////
+// Print a string corresponding to a UDT kind
+//
+void PrintUdtKind(IDiaSymbol *pSymbol)
+{
+  DWORD dwKind = 0;
+
+  if (pSymbol->get_udtKind(&dwKind) == S_OK) {
+    wprintf(L"%s ", rgUdtKind[dwKind]);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print type informations is details
+//
+void PrintTypeInDetail(IDiaSymbol *pSymbol, DWORD dwIndent)
+{
+  IDiaEnumSymbols *pEnumChildren;
+  IDiaSymbol *pType;
+  IDiaSymbol *pChild;
+  DWORD dwSymTag;
+  DWORD dwSymTagType;
+  ULONG celt = 0;
+  BOOL bFlag;
+
+  if (dwIndent > MAX_TYPE_IN_DETAIL) {
+    return;
+  }
+
+  if (pSymbol->get_symTag(&dwSymTag) != S_OK) {
+    wprintf(L"ERROR - PrintTypeInDetail() get_symTag\n");
+    return;
+  }
+
+  PrintSymTag(dwSymTag);
+
+  for (DWORD i = 0;i < dwIndent; i++) {
+    putwchar(L' ');
+  }
+
+  switch (dwSymTag) {
+    case SymTagData:
+      PrintData(pSymbol, dwIndent);
+
+      if (pSymbol->get_type(&pType) == S_OK) {
+        if (pType->get_symTag(&dwSymTagType) == S_OK) {
+          if (dwSymTagType == SymTagUDT) {
+            putwchar(L'\n');
+            PrintTypeInDetail(pType, dwIndent + 2);
+          }
+        }
+        pType->Release();
+      }
+      break;
+
+    case SymTagTypedef:
+    case SymTagVTable:
+      PrintSymbolType(pSymbol);
+      break;
+
+    case SymTagEnum:
+    case SymTagUDT:
+      PrintUDT(pSymbol);
+      putwchar(L'\n');
+
+      if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          PrintTypeInDetail(pChild, dwIndent + 2);
+
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+      }
+      return;
+      break;
+
+    case SymTagFunction:
+      PrintFunctionType(pSymbol);
+      return;
+      break;
+
+    case SymTagPointerType:
+      PrintName(pSymbol);
+      wprintf(L" has type ");
+      PrintType(pSymbol);
+      break;
+
+    case SymTagArrayType:
+    case SymTagBaseType:
+    case SymTagFunctionArgType:
+    case SymTagUsingNamespace:
+    case SymTagCustom:
+    case SymTagFriend:
+      PrintName(pSymbol);
+      PrintSymbolType(pSymbol);
+      break;
+
+    case SymTagVTableShape:
+    case SymTagBaseClass:
+      PrintName(pSymbol);
+
+      if ((pSymbol->get_virtualBaseClass(&bFlag) == S_OK) && bFlag) {
+        IDiaSymbol *pVBTableType;
+        LONG ptrOffset;
+        DWORD dispIndex;
+
+        if ((pSymbol->get_virtualBaseDispIndex(&dispIndex) == S_OK) &&
+            (pSymbol->get_virtualBasePointerOffset(&ptrOffset) == S_OK)) {
+          wprintf(L" virtual, offset = 0x%X, pointer offset = %ld, virtual base pointer type = ", dispIndex, ptrOffset);
+
+          if (pSymbol->get_virtualBaseTableType(&pVBTableType) == S_OK) {
+            PrintType(pVBTableType);
+            pVBTableType->Release();
+          }
+
+          else {
+            wprintf(L"(unknown)");
+          }
+        }
+      }
+
+      else {
+        LONG offset;
+
+        if (pSymbol->get_offset(&offset) == S_OK) {
+          wprintf(L", offset = 0x%X", offset);
+        }
+      }
+
+      putwchar(L'\n');
+
+      if (SUCCEEDED(pSymbol->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          PrintTypeInDetail(pChild, dwIndent + 2);
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+      }
+      break;
+
+    case SymTagFunctionType:
+      if (pSymbol->get_type(&pType) == S_OK) {
+        PrintType(pType);
+      }
+      break;
+
+    case SymTagThunk:
+      // Happens for functions which only have S_PROCREF
+      PrintThunk(pSymbol);
+      break;
+
+    default:
+      wprintf(L"ERROR - PrintTypeInDetail() invalid SymTag\n");
+    }
+
+    putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print a function type
+//
+void PrintFunctionType(IDiaSymbol *pSymbol)
+{
+  DWORD dwAccess = 0;
+
+  if (pSymbol->get_access(&dwAccess) == S_OK) {
+    wprintf(L"%s ", SafeDRef(rgAccess, dwAccess));
+  }
+
+  BOOL bIsStatic = FALSE;
+
+  if ((pSymbol->get_isStatic(&bIsStatic) == S_OK) && bIsStatic) {
+    wprintf(L"static ");
+  }
+
+  IDiaSymbol *pFuncType;
+
+  if (pSymbol->get_type(&pFuncType) == S_OK) {
+    IDiaSymbol *pReturnType;
+
+    if (pFuncType->get_type(&pReturnType) == S_OK) {
+      PrintType(pReturnType);
+      putwchar(L' ');
+
+      BSTR bstrName;
+
+      if (pSymbol->get_name(&bstrName) == S_OK) {
+        wprintf(L"%s", bstrName);
+
+        SysFreeString(bstrName);
+      }
+
+      IDiaEnumSymbols *pEnumChildren;
+
+      if (SUCCEEDED(pFuncType->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren))) {
+        IDiaSymbol *pChild;
+        ULONG celt = 0;
+        ULONG nParam = 0;
+
+        wprintf(L"(");
+
+        while (SUCCEEDED(pEnumChildren->Next(1, &pChild, &celt)) && (celt == 1)) {
+          IDiaSymbol *pType;
+
+          if (pChild->get_type(&pType) == S_OK) {
+            if (nParam++) {
+              wprintf(L", ");
+            }
+
+            PrintType(pType);
+            pType->Release();
+          }
+
+          pChild->Release();
+        }
+
+        pEnumChildren->Release();
+
+        wprintf(L")\n");
+      }
+
+      pReturnType->Release();
+    }
+
+    pFuncType->Release();
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintSourceFile(IDiaSourceFile *pSource)
+{
+  BSTR bstrSourceName;
+
+  if (pSource->get_fileName(&bstrSourceName) == S_OK) {
+    wprintf(L"\t%s", bstrSourceName);
+
+    SysFreeString(bstrSourceName);
+  }
+
+  else {
+    wprintf(L"ERROR - PrintSourceFile() get_fileName");
+    return;
+  }
+
+  BYTE checksum[256];
+  DWORD cbChecksum = sizeof(checksum);
+
+  if (pSource->get_checksum(cbChecksum, &cbChecksum, checksum) == S_OK) {
+    wprintf(L" (");
+
+    DWORD checksumType;
+
+    if (pSource->get_checksumType(&checksumType) == S_OK) {
+      switch (checksumType) {
+        case CHKSUM_TYPE_NONE :
+          wprintf(L"None");
+          break;
+
+        case CHKSUM_TYPE_MD5 :
+          wprintf(L"MD5");
+          break;
+
+        case CHKSUM_TYPE_SHA1 :
+          wprintf(L"SHA1");
+          break;
+
+        default :
+          wprintf(L"0x%X", checksumType);
+          break;
+      }
+
+      if (cbChecksum != 0) {
+        wprintf(L": ");
+      }
+    }
+
+    for (DWORD ib = 0; ib < cbChecksum; ib++) {
+      wprintf(L"%02X", checksum[ib]);
+    }
+
+    wprintf(L")");
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintLines(IDiaSession *pSession, IDiaSymbol *pFunction)
+{
+  DWORD dwSymTag;
+
+  if ((pFunction->get_symTag(&dwSymTag) != S_OK) || (dwSymTag != SymTagFunction)) {
+    wprintf(L"ERROR - PrintLines() dwSymTag != SymTagFunction");
+    return;
+  }
+
+  BSTR bstrName;
+
+  if (pFunction->get_name(&bstrName) == S_OK) {
+    wprintf(L"\n** %s\n\n", bstrName);
+
+    SysFreeString(bstrName);
+  }
+
+  ULONGLONG ulLength;
+
+  if (pFunction->get_length(&ulLength) != S_OK) {
+    wprintf(L"ERROR - PrintLines() get_length");
+    return;
+  }
+
+  DWORD dwRVA;
+  IDiaEnumLineNumbers *pLines;
+
+  if (pFunction->get_relativeVirtualAddress(&dwRVA) == S_OK) {
+    if (SUCCEEDED(pSession->findLinesByRVA(dwRVA, static_cast<DWORD>(ulLength), &pLines))) {
+      PrintLines(pLines);
+      pLines->Release();
+    }
+  }
+
+  else {
+    DWORD dwSect;
+    DWORD dwOffset;
+
+    if ((pFunction->get_addressSection(&dwSect) == S_OK) &&
+        (pFunction->get_addressOffset(&dwOffset) == S_OK)) {
+      if (SUCCEEDED(pSession->findLinesByAddr(dwSect, dwOffset, static_cast<DWORD>(ulLength), &pLines))) {
+        PrintLines(pLines);
+        pLines->Release();
+      }
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+//
+void PrintLines(IDiaEnumLineNumbers *pLines)
+{
+  IDiaLineNumber *pLine;
+  DWORD celt;
+  DWORD dwRVA;
+  DWORD dwSeg;
+  DWORD dwOffset;
+  DWORD dwLinenum;
+  DWORD dwSrcId;
+  DWORD dwLength;
+
+  DWORD dwSrcIdLast = (DWORD)(-1);
+
+  while (SUCCEEDED(pLines->Next(1, &pLine, &celt)) && (celt == 1)) {
+    if ((pLine->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+        (pLine->get_addressSection(&dwSeg) == S_OK) &&
+        (pLine->get_addressOffset(&dwOffset) == S_OK) &&
+        (pLine->get_lineNumber(&dwLinenum) == S_OK) &&
+        (pLine->get_sourceFileId(&dwSrcId) == S_OK) &&
+        (pLine->get_length(&dwLength) == S_OK)) {
+      wprintf(L"\tline %u at [%08X][%04X:%08X], len = 0x%X", dwLinenum, dwRVA, dwSeg, dwOffset, dwLength);
+
+      if (dwSrcId != dwSrcIdLast) {
+        IDiaSourceFile *pSource;
+
+        if (pLine->get_sourceFile(&pSource) == S_OK) {
+          PrintSourceFile(pSource);
+
+          dwSrcIdLast = dwSrcId;
+
+          pSource->Release();
+        }
+      }
+
+      pLine->Release();
+
+      putwchar(L'\n');
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print the section contribution data: name, Sec::Off, length
+void PrintSecContribs(IDiaSectionContrib *pSegment)
+{
+  DWORD dwRVA;
+  DWORD dwSect;
+  DWORD dwOffset;
+  DWORD dwLen;
+  IDiaSymbol *pCompiland;
+  BSTR bstrName;
+
+  if ((pSegment->get_relativeVirtualAddress(&dwRVA) == S_OK) &&
+      (pSegment->get_addressSection(&dwSect) == S_OK) &&
+      (pSegment->get_addressOffset(&dwOffset) == S_OK) &&
+      (pSegment->get_length(&dwLen) == S_OK) &&
+      (pSegment->get_compiland(&pCompiland) == S_OK) &&
+      (pCompiland->get_name(&bstrName) == S_OK)) {
+    wprintf(L"  %08X  %04X:%08X  %08X  %s\n", dwRVA, dwSect, dwOffset, dwLen, bstrName);
+
+    pCompiland->Release();
+
+    SysFreeString(bstrName);
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print a debug stream data
+//
+void PrintStreamData(IDiaEnumDebugStreamData *pStream)
+{
+  BSTR bstrName;
+
+  if (pStream->get_name(&bstrName) != S_OK) {
+    wprintf(L"ERROR - PrintStreamData() get_name\n");
+  }
+
+  else {
+    wprintf(L"Stream: %s", bstrName);
+
+    SysFreeString(bstrName);
+  }
+
+  LONG dwElem;
+
+  if (pStream->get_Count(&dwElem) != S_OK) {
+      wprintf(L"ERROR - PrintStreamData() get_Count\n");
+  }
+
+  else {
+    wprintf(L"(%u)\n", dwElem);
+  }
+
+  DWORD cbTotal = 0;
+
+  BYTE data[1024];
+  DWORD cbData;
+  ULONG celt = 0;
+
+  while (SUCCEEDED(pStream->Next(1, sizeof(data), &cbData, (BYTE *) &data, &celt)) && (celt == 1)) {
+    DWORD i;
+
+    for (i = 0; i < cbData; i++) {
+      wprintf(L"%02X ", data[i]);
+
+      if (i && (i % 8 == 7) && (i+1 < cbData)) {
+        wprintf(L"- ");
+      }
+    }
+
+    wprintf(L"| ");
+
+    for (i = 0; i < cbData; i++) {
+      wprintf(L"%c", iswprint(data[i]) ? data[i] : '.');
+    }
+
+    putwchar(L'\n');
+
+    cbTotal += cbData;
+  }
+
+  wprintf(L"Summary :\n\tNo of Elems = %u\n", dwElem);
+  if (dwElem != 0) {
+    wprintf(L"\tSizeof(Elem) = %u\n", cbTotal / dwElem);
+  }
+  putwchar(L'\n');
+}
+
+////////////////////////////////////////////////////////////
+// Print the FPO info for a given symbol;
+//
+void PrintFrameData(IDiaFrameData *pFrameData)
+{
+  DWORD dwSect;
+  DWORD dwOffset;
+  DWORD cbBlock;
+  DWORD cbLocals;                      // Number of bytes reserved for the function locals
+  DWORD cbParams;                      // Number of bytes reserved for the function arguments
+  DWORD cbMaxStack;
+  DWORD cbProlog;
+  DWORD cbSavedRegs;
+  BOOL bSEH;
+  BOOL bEH;
+  BOOL bStart;
+
+  if ((pFrameData->get_addressSection(&dwSect) == S_OK) &&
+      (pFrameData->get_addressOffset(&dwOffset) == S_OK) &&
+      (pFrameData->get_lengthBlock(&cbBlock) == S_OK) &&
+      (pFrameData->get_lengthLocals(&cbLocals) == S_OK) &&
+      (pFrameData->get_lengthParams(&cbParams) == S_OK) &&
+      (pFrameData->get_maxStack(&cbMaxStack) == S_OK) &&
+      (pFrameData->get_lengthProlog(&cbProlog) == S_OK) &&
+      (pFrameData->get_lengthSavedRegisters(&cbSavedRegs) == S_OK) &&
+      (pFrameData->get_systemExceptionHandling(&bSEH) == S_OK) &&
+      (pFrameData->get_cplusplusExceptionHandling(&bEH) == S_OK) &&
+      (pFrameData->get_functionStart(&bStart) == S_OK)) {
+    wprintf(L"%04X:%08X   %8X %8X %8X %8X %8X %8X %c   %c   %c",
+            dwSect, dwOffset, cbBlock, cbLocals, cbParams, cbMaxStack, cbProlog, cbSavedRegs,
+            bSEH ? L'Y' : L'N',
+            bEH ? L'Y' : L'N',
+            bStart ? L'Y' : L'N');
+
+    BSTR bstrProgram;
+
+    if (pFrameData->get_program(&bstrProgram) == S_OK) {
+      wprintf(L" %s", bstrProgram);
+
+      SysFreeString(bstrProgram);
+    }
+
+    putwchar(L'\n');
+  }
+}
+
+////////////////////////////////////////////////////////////
+// Print all the valid properties associated to a symbol
+//
+void PrintPropertyStorage(IDiaPropertyStorage *pPropertyStorage)
+{
+  IEnumSTATPROPSTG *pEnumProps;
+
+  if (SUCCEEDED(pPropertyStorage->Enum(&pEnumProps))) {
+    STATPROPSTG prop;
+    DWORD celt = 1;
+
+    while (SUCCEEDED(pEnumProps->Next(celt, &prop, &celt)) && (celt == 1)) {
+      PROPSPEC pspec = { PRSPEC_PROPID, prop.propid };
+      PROPVARIANT vt = { VT_EMPTY };
+
+      if (SUCCEEDED(pPropertyStorage->ReadMultiple(1, &pspec, &vt))) {
+        switch (vt.vt) {
+          case VT_BOOL:
+            wprintf(L"%32s:\t %s\n", prop.lpwstrName, vt.bVal ? L"true" : L"false");
+            break;
+
+          case VT_I2:
+            wprintf(L"%32s:\t %d\n", prop.lpwstrName, vt.iVal);
+            break;
+
+          case VT_UI2:
+            wprintf(L"%32s:\t %u\n", prop.lpwstrName, vt.uiVal);
+            break;
+
+          case VT_I4:
+            wprintf(L"%32s:\t %d\n", prop.lpwstrName, vt.intVal);
+            break;
+
+          case VT_UI4:
+            wprintf(L"%32s:\t 0x%0X\n", prop.lpwstrName, vt.uintVal);
+            break;
+
+          case VT_UI8:
+            wprintf(L"%32s:\t 0x%X\n", prop.lpwstrName, vt.uhVal.QuadPart);
+            break;
+
+          case VT_BSTR:
+            wprintf(L"%32s:\t %s\n", prop.lpwstrName, vt.bstrVal);
+            break;
+
+          case VT_UNKNOWN:
+            wprintf(L"%32s:\t %p\n", prop.lpwstrName, vt.punkVal);
+            break;
+
+          case VT_SAFEARRAY:
+            break;
+        }
+
+        VariantClear((VARIANTARG *) &vt);
+      }
+
+      SysFreeString( prop.lpwstrName );
+    }
+
+    pEnumProps->Release();
+  }
+}

diff --git a/src/ToolBox/PdbTypeMatch/PrintSymbol.h b/src/ToolBox/PdbTypeMatch/PrintSymbol.h
new file mode 100644 (file)
index 0000000..2aeffc4
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PrintSymbol.h
@@ -0,0 +1,62 @@
+#include <string>
+
+inline int myDebugBreak( int ){
+    DebugBreak();
+    return 0;
+}
+#define MAXELEMS(x)     (sizeof(x)/sizeof(x[0]))
+#define SafeDRef(a, i)  ((i < MAXELEMS(a)) ? a[i] : a[myDebugBreak(i)])
+
+#define MAX_TYPE_IN_DETAIL 5
+#define MAX_RVA_LINES_BYTES_RANGE 0x100
+
+extern const wchar_t * const rgBaseType[];
+extern const wchar_t * const rgTags[];
+extern const wchar_t * const rgFloatPackageStrings[];
+extern const wchar_t * const rgProcessorStrings[];
+extern const wchar_t * const rgDataKind[];
+extern const wchar_t * const rgUdtKind[];
+extern const wchar_t * const rgAccess[];
+extern const wchar_t * const rgCallingConvention[];
+extern const wchar_t * const rgLanguage[];
+extern const wchar_t * const rgLocationTypeString[];
+
+void PrintPublicSymbol( IDiaSymbol* );
+void PrintGlobalSymbol( IDiaSymbol* );
+void PrintSymbol( IDiaSymbol* , DWORD );
+void GetSymbolName(std::wstring& symbolName, IDiaSymbol *pSymbol);
+void PrintSymTag( DWORD );
+void PrintName( IDiaSymbol* );
+void PrintUndName( IDiaSymbol* );
+void PrintThunk( IDiaSymbol* );
+void PrintCompilandDetails( IDiaSymbol* );
+void PrintCompilandEnv( IDiaSymbol* );
+void PrintLocation( IDiaSymbol* );
+void PrintConst( IDiaSymbol* );
+void PrintUDT( IDiaSymbol* );
+void PrintSymbolType( IDiaSymbol* );
+void PrintType( IDiaSymbol* );
+void PrintBound( IDiaSymbol* );
+void PrintData( IDiaSymbol* , DWORD );
+void PrintVariant( VARIANT );
+void PrintUdtKind( IDiaSymbol* );
+void PrintTypeInDetail( IDiaSymbol* , DWORD );
+void PrintFunctionType( IDiaSymbol* );
+void PrintSourceFile( IDiaSourceFile* );
+void PrintLines( IDiaSession* , IDiaSymbol* );
+void PrintLines( IDiaEnumLineNumbers* );
+void PrintSource( IDiaSourceFile* );
+void PrintSecContribs( IDiaSectionContrib* );
+void PrintStreamData( IDiaEnumDebugStreamData* );
+void PrintFrameData( IDiaFrameData* );
+
+void PrintPropertyStorage( IDiaPropertyStorage* );
+
+template<class T> void PrintGeneric( T t ){
+  IDiaPropertyStorage* pPropertyStorage;
+  
+  if(t->QueryInterface( __uuidof(IDiaPropertyStorage), (void **)&pPropertyStorage ) == S_OK){
+    PrintPropertyStorage(pPropertyStorage);
+    pPropertyStorage->Release();
+  }
+}

diff --git a/src/ToolBox/PdbTypeMatch/callback.h b/src/ToolBox/PdbTypeMatch/callback.h
new file mode 100644 (file)
index 0000000..c1d6887
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/callback.h
@@ -0,0 +1,91 @@
+#include "dia2.h"
+
+#pragma warning ( disable : 4100)
+
+class CCallback : public IDiaLoadCallback2{
+    int m_nRefCount;
+public:
+    CCallback() { m_nRefCount = 0; }
+
+    //IUnknown
+    ULONG STDMETHODCALLTYPE AddRef() {
+        m_nRefCount++;
+        return m_nRefCount;
+    }
+    ULONG STDMETHODCALLTYPE Release() {
+        if ( (--m_nRefCount) == 0 )
+            delete this;
+        return m_nRefCount;
+    }
+    HRESULT STDMETHODCALLTYPE QueryInterface( REFIID rid, void **ppUnk ) {
+        if ( ppUnk == NULL ) {
+            return E_INVALIDARG;
+        }
+        if (rid == __uuidof( IDiaLoadCallback2 ) )
+            *ppUnk = (IDiaLoadCallback2 *)this;
+        else if (rid == __uuidof( IDiaLoadCallback ) )
+            *ppUnk = (IDiaLoadCallback *)this;
+        else if (rid == __uuidof( IUnknown ) )
+            *ppUnk = (IUnknown *)this;
+        else
+            *ppUnk = NULL;
+        if ( *ppUnk != NULL ) {
+            AddRef();
+            return S_OK;
+        }
+        return E_NOINTERFACE;
+    }
+
+    HRESULT STDMETHODCALLTYPE NotifyDebugDir(
+                BOOL fExecutable, 
+                DWORD cbData,
+                BYTE data[]) // really a const struct _IMAGE_DEBUG_DIRECTORY *
+    {
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE NotifyOpenDBG(
+                LPCOLESTR dbgPath, 
+                HRESULT resultCode)
+    {
+        // wprintf(L"opening %s...\n", dbgPath);
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE NotifyOpenPDB(
+                LPCOLESTR pdbPath, 
+                HRESULT resultCode)
+    {
+        // wprintf(L"opening %s...\n", pdbPath);
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictRegistryAccess()         
+    {
+        // return hr != S_OK to prevent querying the registry for symbol search paths
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictSymbolServerAccess()
+    {
+      // return hr != S_OK to prevent accessing a symbol server
+      return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictOriginalPathAccess()     
+    {
+        // return hr != S_OK to prevent querying the registry for symbol search paths
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictReferencePathAccess()
+    {
+        // return hr != S_OK to prevent accessing a symbol server
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictDBGAccess()
+    {
+        return S_OK;
+    }
+    HRESULT STDMETHODCALLTYPE RestrictSystemRootAccess()
+    {
+        return S_OK;
+    }
+};
+
+#pragma warning ( default : 4100 )

diff --git a/src/ToolBox/PdbTypeMatch/include/.gitmirror b/src/ToolBox/PdbTypeMatch/include/.gitmirror
new file mode 100644 (file)
index 0000000..f507630
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/.gitmirror
@@ -0,0 +1 @@
+Only contents of this folder, excluding subfolders, will be mirrored by the Git-TFS Mirror. 
\ No newline at end of file

diff --git a/src/ToolBox/PdbTypeMatch/include/cvconst.h b/src/ToolBox/PdbTypeMatch/include/cvconst.h
new file mode 100644 (file)
index 0000000..9212cf1
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/cvconst.h
@@ -0,0 +1,3182 @@
+// cvconst.h - codeview constant definitions
+//-----------------------------------------------------------------
+//
+// Copyright Microsoft Corporation.  All Rights Reserved.
+//
+//---------------------------------------------------------------
+#ifndef _CVCONST_H_
+#define _CVCONST_H_
+
+
+
+//      Enumeration for function call type
+
+
+typedef enum CV_call_e {
+    CV_CALL_NEAR_C      = 0x00, // near right to left push, caller pops stack
+    CV_CALL_FAR_C       = 0x01, // far right to left push, caller pops stack
+    CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack
+    CV_CALL_FAR_PASCAL  = 0x03, // far left to right push, callee pops stack
+    CV_CALL_NEAR_FAST   = 0x04, // near left to right push with regs, callee pops stack
+    CV_CALL_FAR_FAST    = 0x05, // far left to right push with regs, callee pops stack
+    CV_CALL_SKIPPED     = 0x06, // skipped (unused) call index
+    CV_CALL_NEAR_STD    = 0x07, // near standard call
+    CV_CALL_FAR_STD     = 0x08, // far standard call
+    CV_CALL_NEAR_SYS    = 0x09, // near sys call
+    CV_CALL_FAR_SYS     = 0x0a, // far sys call
+    CV_CALL_THISCALL    = 0x0b, // this call (this passed in register)
+    CV_CALL_MIPSCALL    = 0x0c, // Mips call
+    CV_CALL_GENERIC     = 0x0d, // Generic call sequence
+    CV_CALL_ALPHACALL   = 0x0e, // Alpha call
+    CV_CALL_PPCCALL     = 0x0f, // PPC call
+    CV_CALL_SHCALL      = 0x10, // Hitachi SuperH call
+    CV_CALL_ARMCALL     = 0x11, // ARM call
+    CV_CALL_AM33CALL    = 0x12, // AM33 call
+    CV_CALL_TRICALL     = 0x13, // TriCore Call
+    CV_CALL_SH5CALL     = 0x14, // Hitachi SuperH-5 call
+    CV_CALL_M32RCALL    = 0x15, // M32R Call
+    CV_CALL_CLRCALL     = 0x16, // clr call
+    CV_CALL_RESERVED    = 0x17  // first unused call enumeration
+
+    // Do NOT add any more machine specific conventions.  This is to be used for
+    // calling conventions in the source only (e.g. __cdecl, __stdcall).
+} CV_call_e;
+
+
+//      Values for the access protection of class attributes
+
+
+typedef enum CV_access_e {
+    CV_private   = 1,
+    CV_protected = 2,
+    CV_public    = 3
+} CV_access_e;
+
+typedef enum THUNK_ORDINAL {
+    THUNK_ORDINAL_NOTYPE,       // standard thunk
+    THUNK_ORDINAL_ADJUSTOR,     // "this" adjustor thunk
+    THUNK_ORDINAL_VCALL,        // virtual call thunk
+    THUNK_ORDINAL_PCODE,        // pcode thunk
+    THUNK_ORDINAL_LOAD,         // thunk which loads the address to jump to
+                                //  via unknown means...
+
+ // trampoline thunk ordinals   - only for use in Trampoline thunk symbols
+    THUNK_ORDINAL_TRAMP_INCREMENTAL,
+    THUNK_ORDINAL_TRAMP_BRANCHISLAND,
+
+} THUNK_ORDINAL;
+
+
+enum CV_SourceChksum_t {
+    CHKSUM_TYPE_NONE = 0,        // indicates no checksum is available
+    CHKSUM_TYPE_MD5,
+    CHKSUM_TYPE_SHA1
+};
+
+//
+// DIA enums
+//
+
+enum SymTagEnum
+{
+    SymTagNull,
+    SymTagExe,
+    SymTagCompiland,
+    SymTagCompilandDetails,
+    SymTagCompilandEnv,
+    SymTagFunction,
+    SymTagBlock,
+    SymTagData,
+    SymTagAnnotation,
+    SymTagLabel,
+    SymTagPublicSymbol,
+    SymTagUDT,
+    SymTagEnum,
+    SymTagFunctionType,
+    SymTagPointerType,
+    SymTagArrayType,
+    SymTagBaseType,
+    SymTagTypedef,
+    SymTagBaseClass,
+    SymTagFriend,
+    SymTagFunctionArgType,
+    SymTagFuncDebugStart,
+    SymTagFuncDebugEnd,
+    SymTagUsingNamespace,
+    SymTagVTableShape,
+    SymTagVTable,
+    SymTagCustom,
+    SymTagThunk,
+    SymTagCustomType,
+    SymTagManagedType,
+    SymTagDimension,
+    SymTagCallSite,
+    SymTagMax
+};
+
+enum LocationType
+{
+    LocIsNull,
+    LocIsStatic,
+    LocIsTLS,
+    LocIsRegRel,
+    LocIsThisRel,
+    LocIsEnregistered,
+    LocIsBitField,
+    LocIsSlot,
+    LocIsIlRel,
+    LocInMetaData,
+    LocIsConstant,
+    LocTypeMax
+};
+
+enum DataKind
+{
+    DataIsUnknown,
+    DataIsLocal,
+    DataIsStaticLocal,
+    DataIsParam,
+    DataIsObjectPtr,
+    DataIsFileStatic,
+    DataIsGlobal,
+    DataIsMember,
+    DataIsStaticMember,
+    DataIsConstant
+};
+
+enum UdtKind
+{
+    UdtStruct,
+    UdtClass,
+    UdtUnion
+};
+
+enum BasicType
+{
+    btNoType = 0,
+    btVoid = 1,
+    btChar = 2,
+    btWChar = 3,
+    btInt = 6,
+    btUInt = 7,
+    btFloat = 8,
+    btBCD = 9,
+    btBool = 10,
+    btLong = 13,
+    btULong = 14,
+    btCurrency = 25,
+    btDate = 26,
+    btVariant = 27,
+    btComplex = 28,
+    btBit = 29,
+    btBSTR = 30,
+    btHresult = 31
+};
+
+
+//  enum describing the compile flag source language
+
+
+typedef enum CV_CFL_LANG {
+    CV_CFL_C        = 0x00,
+    CV_CFL_CXX      = 0x01,
+    CV_CFL_FORTRAN  = 0x02,
+    CV_CFL_MASM     = 0x03,
+    CV_CFL_PASCAL   = 0x04,
+    CV_CFL_BASIC    = 0x05,
+    CV_CFL_COBOL    = 0x06,
+    CV_CFL_LINK     = 0x07,
+    CV_CFL_CVTRES   = 0x08,
+    CV_CFL_CVTPGD   = 0x09,
+    CV_CFL_CSHARP   = 0x0A,  // C#
+    CV_CFL_VB       = 0x0B,  // Visual Basic
+    CV_CFL_ILASM    = 0x0C,  // IL (as in CLR) ASM
+    CV_CFL_JAVA     = 0x0D,
+    CV_CFL_JSCRIPT  = 0x0E,
+    CV_CFL_MSIL     = 0x0F,  // Unknown MSIL (LTCG of .NETMODULE)
+} CV_CFL_LANG;
+
+
+//  enum describing target processor
+
+
+typedef enum CV_CPU_TYPE_e {
+    CV_CFL_8080         = 0x00,
+    CV_CFL_8086         = 0x01,
+    CV_CFL_80286        = 0x02,
+    CV_CFL_80386        = 0x03,
+    CV_CFL_80486        = 0x04,
+    CV_CFL_PENTIUM      = 0x05,
+    CV_CFL_PENTIUMII    = 0x06,
+    CV_CFL_PENTIUMPRO   = CV_CFL_PENTIUMII,
+    CV_CFL_PENTIUMIII   = 0x07,
+    CV_CFL_MIPS         = 0x10,
+    CV_CFL_MIPSR4000    = CV_CFL_MIPS,  // don't break current code
+    CV_CFL_MIPS16       = 0x11,
+    CV_CFL_MIPS32       = 0x12,
+    CV_CFL_MIPS64       = 0x13,
+    CV_CFL_MIPSI        = 0x14,
+    CV_CFL_MIPSII       = 0x15,
+    CV_CFL_MIPSIII      = 0x16,
+    CV_CFL_MIPSIV       = 0x17,
+    CV_CFL_MIPSV        = 0x18,
+    CV_CFL_M68000       = 0x20,
+    CV_CFL_M68010       = 0x21,
+    CV_CFL_M68020       = 0x22,
+    CV_CFL_M68030       = 0x23,
+    CV_CFL_M68040       = 0x24,
+    CV_CFL_ALPHA        = 0x30,
+    CV_CFL_ALPHA_21064  = 0x30,
+    CV_CFL_ALPHA_21164  = 0x31,
+    CV_CFL_ALPHA_21164A = 0x32,
+    CV_CFL_ALPHA_21264  = 0x33,
+    CV_CFL_ALPHA_21364  = 0x34,
+    CV_CFL_PPC601       = 0x40,
+    CV_CFL_PPC603       = 0x41,
+    CV_CFL_PPC604       = 0x42,
+    CV_CFL_PPC620       = 0x43,
+    CV_CFL_PPCFP        = 0x44,
+    CV_CFL_PPCBE        = 0x45,
+    CV_CFL_SH3          = 0x50,
+    CV_CFL_SH3E         = 0x51,
+    CV_CFL_SH3DSP       = 0x52,
+    CV_CFL_SH4          = 0x53,
+    CV_CFL_SHMEDIA      = 0x54,
+    CV_CFL_ARM3         = 0x60,
+    CV_CFL_ARM4         = 0x61,
+    CV_CFL_ARM4T        = 0x62,
+    CV_CFL_ARM5         = 0x63,
+    CV_CFL_ARM5T        = 0x64,
+    CV_CFL_ARM6         = 0x65,
+    CV_CFL_ARM_XMAC     = 0x66,
+    CV_CFL_ARM_WMMX     = 0x67,
+    CV_CFL_ARM7         = 0x68,
+    CV_CFL_OMNI         = 0x70,
+    CV_CFL_IA64         = 0x80,
+    CV_CFL_IA64_1       = 0x80,
+    CV_CFL_IA64_2       = 0x81,
+    CV_CFL_CEE          = 0x90,
+    CV_CFL_AM33         = 0xA0,
+    CV_CFL_M32R         = 0xB0,
+    CV_CFL_TRICORE      = 0xC0,
+    CV_CFL_X64          = 0xD0,
+    CV_CFL_AMD64        = CV_CFL_X64,
+    CV_CFL_EBC          = 0xE0,
+    CV_CFL_THUMB        = 0xF0,
+} CV_CPU_TYPE_e;
+
+typedef enum CV_HREG_e {
+    // Register subset shared by all processor types,
+    // must not overlap with any of the ranges below, hence the high values
+
+    CV_ALLREG_ERR   =   30000,
+    CV_ALLREG_TEB   =   30001,
+    CV_ALLREG_TIMER =   30002,
+    CV_ALLREG_EFAD1 =   30003,
+    CV_ALLREG_EFAD2 =   30004,
+    CV_ALLREG_EFAD3 =   30005,
+    CV_ALLREG_VFRAME=   30006,
+    CV_ALLREG_HANDLE=   30007,
+    CV_ALLREG_PARAMS=   30008,
+    CV_ALLREG_LOCALS=   30009,
+    CV_ALLREG_TID   =   30010,
+    CV_ALLREG_ENV   =   30011,
+    CV_ALLREG_CMDLN =   30012,
+
+
+    //  Register set for the Intel 80x86 and ix86 processor series
+    //  (plus PCODE registers)
+
+    CV_REG_NONE     =   0,
+    CV_REG_AL       =   1,
+    CV_REG_CL       =   2,
+    CV_REG_DL       =   3,
+    CV_REG_BL       =   4,
+    CV_REG_AH       =   5,
+    CV_REG_CH       =   6,
+    CV_REG_DH       =   7,
+    CV_REG_BH       =   8,
+    CV_REG_AX       =   9,
+    CV_REG_CX       =  10,
+    CV_REG_DX       =  11,
+    CV_REG_BX       =  12,
+    CV_REG_SP       =  13,
+    CV_REG_BP       =  14,
+    CV_REG_SI       =  15,
+    CV_REG_DI       =  16,
+    CV_REG_EAX      =  17,
+    CV_REG_ECX      =  18,
+    CV_REG_EDX      =  19,
+    CV_REG_EBX      =  20,
+    CV_REG_ESP      =  21,
+    CV_REG_EBP      =  22,
+    CV_REG_ESI      =  23,
+    CV_REG_EDI      =  24,
+    CV_REG_ES       =  25,
+    CV_REG_CS       =  26,
+    CV_REG_SS       =  27,
+    CV_REG_DS       =  28,
+    CV_REG_FS       =  29,
+    CV_REG_GS       =  30,
+    CV_REG_IP       =  31,
+    CV_REG_FLAGS    =  32,
+    CV_REG_EIP      =  33,
+    CV_REG_EFLAGS   =  34,
+    CV_REG_TEMP     =  40,          // PCODE Temp
+    CV_REG_TEMPH    =  41,          // PCODE TempH
+    CV_REG_QUOTE    =  42,          // PCODE Quote
+    CV_REG_PCDR3    =  43,          // PCODE reserved
+    CV_REG_PCDR4    =  44,          // PCODE reserved
+    CV_REG_PCDR5    =  45,          // PCODE reserved
+    CV_REG_PCDR6    =  46,          // PCODE reserved
+    CV_REG_PCDR7    =  47,          // PCODE reserved
+    CV_REG_CR0      =  80,          // CR0 -- control registers
+    CV_REG_CR1      =  81,
+    CV_REG_CR2      =  82,
+    CV_REG_CR3      =  83,
+    CV_REG_CR4      =  84,          // Pentium
+    CV_REG_DR0      =  90,          // Debug register
+    CV_REG_DR1      =  91,
+    CV_REG_DR2      =  92,
+    CV_REG_DR3      =  93,
+    CV_REG_DR4      =  94,
+    CV_REG_DR5      =  95,
+    CV_REG_DR6      =  96,
+    CV_REG_DR7      =  97,
+    CV_REG_GDTR     =  110,
+    CV_REG_GDTL     =  111,
+    CV_REG_IDTR     =  112,
+    CV_REG_IDTL     =  113,
+    CV_REG_LDTR     =  114,
+    CV_REG_TR       =  115,
+
+    CV_REG_PSEUDO1  =  116,
+    CV_REG_PSEUDO2  =  117,
+    CV_REG_PSEUDO3  =  118,
+    CV_REG_PSEUDO4  =  119,
+    CV_REG_PSEUDO5  =  120,
+    CV_REG_PSEUDO6  =  121,
+    CV_REG_PSEUDO7  =  122,
+    CV_REG_PSEUDO8  =  123,
+    CV_REG_PSEUDO9  =  124,
+
+    CV_REG_ST0      =  128,
+    CV_REG_ST1      =  129,
+    CV_REG_ST2      =  130,
+    CV_REG_ST3      =  131,
+    CV_REG_ST4      =  132,
+    CV_REG_ST5      =  133,
+    CV_REG_ST6      =  134,
+    CV_REG_ST7      =  135,
+    CV_REG_CTRL     =  136,
+    CV_REG_STAT     =  137,
+    CV_REG_TAG      =  138,
+    CV_REG_FPIP     =  139,
+    CV_REG_FPCS     =  140,
+    CV_REG_FPDO     =  141,
+    CV_REG_FPDS     =  142,
+    CV_REG_ISEM     =  143,
+    CV_REG_FPEIP    =  144,
+    CV_REG_FPEDO    =  145,
+
+    CV_REG_MM0      =  146,
+    CV_REG_MM1      =  147,
+    CV_REG_MM2      =  148,
+    CV_REG_MM3      =  149,
+    CV_REG_MM4      =  150,
+    CV_REG_MM5      =  151,
+    CV_REG_MM6      =  152,
+    CV_REG_MM7      =  153,
+
+    CV_REG_XMM0     =  154, // KATMAI registers
+    CV_REG_XMM1     =  155,
+    CV_REG_XMM2     =  156,
+    CV_REG_XMM3     =  157,
+    CV_REG_XMM4     =  158,
+    CV_REG_XMM5     =  159,
+    CV_REG_XMM6     =  160,
+    CV_REG_XMM7     =  161,
+
+    CV_REG_XMM00    =  162, // KATMAI sub-registers
+    CV_REG_XMM01    =  163,
+    CV_REG_XMM02    =  164,
+    CV_REG_XMM03    =  165,
+    CV_REG_XMM10    =  166,
+    CV_REG_XMM11    =  167,
+    CV_REG_XMM12    =  168,
+    CV_REG_XMM13    =  169,
+    CV_REG_XMM20    =  170,
+    CV_REG_XMM21    =  171,
+    CV_REG_XMM22    =  172,
+    CV_REG_XMM23    =  173,
+    CV_REG_XMM30    =  174,
+    CV_REG_XMM31    =  175,
+    CV_REG_XMM32    =  176,
+    CV_REG_XMM33    =  177,
+    CV_REG_XMM40    =  178,
+    CV_REG_XMM41    =  179,
+    CV_REG_XMM42    =  180,
+    CV_REG_XMM43    =  181,
+    CV_REG_XMM50    =  182,
+    CV_REG_XMM51    =  183,
+    CV_REG_XMM52    =  184,
+    CV_REG_XMM53    =  185,
+    CV_REG_XMM60    =  186,
+    CV_REG_XMM61    =  187,
+    CV_REG_XMM62    =  188,
+    CV_REG_XMM63    =  189,
+    CV_REG_XMM70    =  190,
+    CV_REG_XMM71    =  191,
+    CV_REG_XMM72    =  192,
+    CV_REG_XMM73    =  193,
+
+    CV_REG_XMM0L    =  194,
+    CV_REG_XMM1L    =  195,
+    CV_REG_XMM2L    =  196,
+    CV_REG_XMM3L    =  197,
+    CV_REG_XMM4L    =  198,
+    CV_REG_XMM5L    =  199,
+    CV_REG_XMM6L    =  200,
+    CV_REG_XMM7L    =  201,
+
+    CV_REG_XMM0H    =  202,
+    CV_REG_XMM1H    =  203,
+    CV_REG_XMM2H    =  204,
+    CV_REG_XMM3H    =  205,
+    CV_REG_XMM4H    =  206,
+    CV_REG_XMM5H    =  207,
+    CV_REG_XMM6H    =  208,
+    CV_REG_XMM7H    =  209,
+
+    CV_REG_MXCSR    =  211, // XMM status register
+
+    CV_REG_EDXEAX   =  212, // EDX:EAX pair
+
+    CV_REG_EMM0L    =  220, // XMM sub-registers (WNI integer)
+    CV_REG_EMM1L    =  221,
+    CV_REG_EMM2L    =  222,
+    CV_REG_EMM3L    =  223,
+    CV_REG_EMM4L    =  224,
+    CV_REG_EMM5L    =  225,
+    CV_REG_EMM6L    =  226,
+    CV_REG_EMM7L    =  227,
+
+    CV_REG_EMM0H    =  228,
+    CV_REG_EMM1H    =  229,
+    CV_REG_EMM2H    =  230,
+    CV_REG_EMM3H    =  231,
+    CV_REG_EMM4H    =  232,
+    CV_REG_EMM5H    =  233,
+    CV_REG_EMM6H    =  234,
+    CV_REG_EMM7H    =  235,
+
+    // do not change the order of these regs, first one must be even too
+    CV_REG_MM00     =  236,
+    CV_REG_MM01     =  237,
+    CV_REG_MM10     =  238,
+    CV_REG_MM11     =  239,
+    CV_REG_MM20     =  240,
+    CV_REG_MM21     =  241,
+    CV_REG_MM30     =  242,
+    CV_REG_MM31     =  243,
+    CV_REG_MM40     =  244,
+    CV_REG_MM41     =  245,
+    CV_REG_MM50     =  246,
+    CV_REG_MM51     =  247,
+    CV_REG_MM60     =  248,
+    CV_REG_MM61     =  249,
+    CV_REG_MM70     =  250,
+    CV_REG_MM71     =  251,
+
+    CV_REG_YMM0     =  252, // AVX registers
+    CV_REG_YMM1     =  253,
+    CV_REG_YMM2     =  254,
+    CV_REG_YMM3     =  255,
+    CV_REG_YMM4     =  256,
+    CV_REG_YMM5     =  257,
+    CV_REG_YMM6     =  258,
+    CV_REG_YMM7     =  259,
+
+    CV_REG_YMM0H    =  260,
+    CV_REG_YMM1H    =  261,
+    CV_REG_YMM2H    =  262,
+    CV_REG_YMM3H    =  263,
+    CV_REG_YMM4H    =  264,
+    CV_REG_YMM5H    =  265,
+    CV_REG_YMM6H    =  266,
+    CV_REG_YMM7H    =  267,
+
+    CV_REG_YMM0I0     =    268,    // AVX integer registers
+    CV_REG_YMM0I1     =    269,
+    CV_REG_YMM0I2     =    270,
+    CV_REG_YMM0I3     =    271,
+    CV_REG_YMM1I0     =    272,
+    CV_REG_YMM1I1     =    273,
+    CV_REG_YMM1I2     =    274,
+    CV_REG_YMM1I3     =    275,
+    CV_REG_YMM2I0     =    276,
+    CV_REG_YMM2I1     =    277,
+    CV_REG_YMM2I2     =    278,
+    CV_REG_YMM2I3     =    279,
+    CV_REG_YMM3I0     =    280,
+    CV_REG_YMM3I1     =    281,
+    CV_REG_YMM3I2     =    282,
+    CV_REG_YMM3I3     =    283,
+    CV_REG_YMM4I0     =    284,
+    CV_REG_YMM4I1     =    285,
+    CV_REG_YMM4I2     =    286,
+    CV_REG_YMM4I3     =    287,
+    CV_REG_YMM5I0     =    288,
+    CV_REG_YMM5I1     =    289,
+    CV_REG_YMM5I2     =    290,
+    CV_REG_YMM5I3     =    291,
+    CV_REG_YMM6I0     =    292,
+    CV_REG_YMM6I1     =    293,
+    CV_REG_YMM6I2     =    294,
+    CV_REG_YMM6I3     =    295,
+    CV_REG_YMM7I0     =    296,
+    CV_REG_YMM7I1     =    297,
+    CV_REG_YMM7I2     =    298,
+    CV_REG_YMM7I3     =    299,
+        
+    CV_REG_YMM0F0    =  300,     // AVX floating-point single precise registers
+    CV_REG_YMM0F1    =  301,
+    CV_REG_YMM0F2    =  302,
+    CV_REG_YMM0F3    =  303,
+    CV_REG_YMM0F4    =  304,
+    CV_REG_YMM0F5    =  305,
+    CV_REG_YMM0F6    =  306,
+    CV_REG_YMM0F7    =  307,
+    CV_REG_YMM1F0    =  308,
+    CV_REG_YMM1F1    =  309,
+    CV_REG_YMM1F2    =  310,
+    CV_REG_YMM1F3    =  311,
+    CV_REG_YMM1F4    =  312,
+    CV_REG_YMM1F5    =  313,
+    CV_REG_YMM1F6    =  314,
+    CV_REG_YMM1F7    =  315,
+    CV_REG_YMM2F0    =  316,
+    CV_REG_YMM2F1    =  317,
+    CV_REG_YMM2F2    =  318,
+    CV_REG_YMM2F3    =  319,
+    CV_REG_YMM2F4    =  320,
+    CV_REG_YMM2F5    =  321,
+    CV_REG_YMM2F6    =  322,
+    CV_REG_YMM2F7    =  323,
+    CV_REG_YMM3F0    =  324,
+    CV_REG_YMM3F1    =  325,
+    CV_REG_YMM3F2    =  326,
+    CV_REG_YMM3F3    =  327,
+    CV_REG_YMM3F4    =  328,
+    CV_REG_YMM3F5    =  329,
+    CV_REG_YMM3F6    =  330,
+    CV_REG_YMM3F7    =  331,
+    CV_REG_YMM4F0    =  332,
+    CV_REG_YMM4F1    =  333,
+    CV_REG_YMM4F2    =  334,
+    CV_REG_YMM4F3    =  335,
+    CV_REG_YMM4F4    =  336,
+    CV_REG_YMM4F5    =  337,
+    CV_REG_YMM4F6    =  338,
+    CV_REG_YMM4F7    =  339,
+    CV_REG_YMM5F0    =  340,
+    CV_REG_YMM5F1    =  341,
+    CV_REG_YMM5F2    =  342,
+    CV_REG_YMM5F3    =  343,
+    CV_REG_YMM5F4    =  344,
+    CV_REG_YMM5F5    =  345,
+    CV_REG_YMM5F6    =  346,
+    CV_REG_YMM5F7    =  347,
+    CV_REG_YMM6F0    =  348,
+    CV_REG_YMM6F1    =  349,
+    CV_REG_YMM6F2    =  350,
+    CV_REG_YMM6F3    =  351,
+    CV_REG_YMM6F4    =  352,
+    CV_REG_YMM6F5    =  353,
+    CV_REG_YMM6F6    =  354,
+    CV_REG_YMM6F7    =  355,
+    CV_REG_YMM7F0    =  356,
+    CV_REG_YMM7F1    =  357,
+    CV_REG_YMM7F2    =  358,
+    CV_REG_YMM7F3    =  359,
+    CV_REG_YMM7F4    =  360,
+    CV_REG_YMM7F5    =  361,
+    CV_REG_YMM7F6    =  362,
+    CV_REG_YMM7F7    =  363,
+    
+    CV_REG_YMM0D0     =    364,    // AVX floating-point double precise registers
+    CV_REG_YMM0D1     =    365,
+    CV_REG_YMM0D2     =    366,
+    CV_REG_YMM0D3     =    367,
+    CV_REG_YMM1D0     =    368,
+    CV_REG_YMM1D1     =    369,
+    CV_REG_YMM1D2     =    370,
+    CV_REG_YMM1D3     =    371,
+    CV_REG_YMM2D0     =    372,
+    CV_REG_YMM2D1     =    373,
+    CV_REG_YMM2D2     =    374,
+    CV_REG_YMM2D3     =    375,
+    CV_REG_YMM3D0     =    376,
+    CV_REG_YMM3D1     =    377,
+    CV_REG_YMM3D2     =    378,
+    CV_REG_YMM3D3     =    379,
+    CV_REG_YMM4D0     =    380,
+    CV_REG_YMM4D1     =    381,
+    CV_REG_YMM4D2     =    382,
+    CV_REG_YMM4D3     =    383,
+    CV_REG_YMM5D0     =    384,
+    CV_REG_YMM5D1     =    385,
+    CV_REG_YMM5D2     =    386,
+    CV_REG_YMM5D3     =    387,
+    CV_REG_YMM6D0     =    388,
+    CV_REG_YMM6D1     =    389,
+    CV_REG_YMM6D2     =    390,
+    CV_REG_YMM6D3     =    391,
+    CV_REG_YMM7D0     =    392,
+    CV_REG_YMM7D1     =    393,
+    CV_REG_YMM7D2     =    394,
+    CV_REG_YMM7D3     =    395,
+
+    // registers for the 68K processors
+
+    CV_R68_D0       =    0,
+    CV_R68_D1       =    1,
+    CV_R68_D2       =    2,
+    CV_R68_D3       =    3,
+    CV_R68_D4       =    4,
+    CV_R68_D5       =    5,
+    CV_R68_D6       =    6,
+    CV_R68_D7       =    7,
+    CV_R68_A0       =    8,
+    CV_R68_A1       =    9,
+    CV_R68_A2       =   10,
+    CV_R68_A3       =   11,
+    CV_R68_A4       =   12,
+    CV_R68_A5       =   13,
+    CV_R68_A6       =   14,
+    CV_R68_A7       =   15,
+    CV_R68_CCR      =   16,
+    CV_R68_SR       =   17,
+    CV_R68_USP      =   18,
+    CV_R68_MSP      =   19,
+    CV_R68_SFC      =   20,
+    CV_R68_DFC      =   21,
+    CV_R68_CACR     =   22,
+    CV_R68_VBR      =   23,
+    CV_R68_CAAR     =   24,
+    CV_R68_ISP      =   25,
+    CV_R68_PC       =   26,
+    //reserved  27
+    CV_R68_FPCR     =   28,
+    CV_R68_FPSR     =   29,
+    CV_R68_FPIAR    =   30,
+    //reserved  31
+    CV_R68_FP0      =   32,
+    CV_R68_FP1      =   33,
+    CV_R68_FP2      =   34,
+    CV_R68_FP3      =   35,
+    CV_R68_FP4      =   36,
+    CV_R68_FP5      =   37,
+    CV_R68_FP6      =   38,
+    CV_R68_FP7      =   39,
+    //reserved  40
+    CV_R68_MMUSR030 =   41,
+    CV_R68_MMUSR    =   42,
+    CV_R68_URP      =   43,
+    CV_R68_DTT0     =   44,
+    CV_R68_DTT1     =   45,
+    CV_R68_ITT0     =   46,
+    CV_R68_ITT1     =   47,
+    //reserved  50
+    CV_R68_PSR      =   51,
+    CV_R68_PCSR     =   52,
+    CV_R68_VAL      =   53,
+    CV_R68_CRP      =   54,
+    CV_R68_SRP      =   55,
+    CV_R68_DRP      =   56,
+    CV_R68_TC       =   57,
+    CV_R68_AC       =   58,
+    CV_R68_SCC      =   59,
+    CV_R68_CAL      =   60,
+    CV_R68_TT0      =   61,
+    CV_R68_TT1      =   62,
+    //reserved  63
+    CV_R68_BAD0     =   64,
+    CV_R68_BAD1     =   65,
+    CV_R68_BAD2     =   66,
+    CV_R68_BAD3     =   67,
+    CV_R68_BAD4     =   68,
+    CV_R68_BAD5     =   69,
+    CV_R68_BAD6     =   70,
+    CV_R68_BAD7     =   71,
+    CV_R68_BAC0     =   72,
+    CV_R68_BAC1     =   73,
+    CV_R68_BAC2     =   74,
+    CV_R68_BAC3     =   75,
+    CV_R68_BAC4     =   76,
+    CV_R68_BAC5     =   77,
+    CV_R68_BAC6     =   78,
+    CV_R68_BAC7     =   79,
+
+     // Register set for the MIPS 4000
+
+    CV_M4_NOREG     =   CV_REG_NONE,
+
+    CV_M4_IntZERO   =   10,      /* CPU REGISTER */
+    CV_M4_IntAT     =   11,
+    CV_M4_IntV0     =   12,
+    CV_M4_IntV1     =   13,
+    CV_M4_IntA0     =   14,
+    CV_M4_IntA1     =   15,
+    CV_M4_IntA2     =   16,
+    CV_M4_IntA3     =   17,
+    CV_M4_IntT0     =   18,
+    CV_M4_IntT1     =   19,
+    CV_M4_IntT2     =   20,
+    CV_M4_IntT3     =   21,
+    CV_M4_IntT4     =   22,
+    CV_M4_IntT5     =   23,
+    CV_M4_IntT6     =   24,
+    CV_M4_IntT7     =   25,
+    CV_M4_IntS0     =   26,
+    CV_M4_IntS1     =   27,
+    CV_M4_IntS2     =   28,
+    CV_M4_IntS3     =   29,
+    CV_M4_IntS4     =   30,
+    CV_M4_IntS5     =   31,
+    CV_M4_IntS6     =   32,
+    CV_M4_IntS7     =   33,
+    CV_M4_IntT8     =   34,
+    CV_M4_IntT9     =   35,
+    CV_M4_IntKT0    =   36,
+    CV_M4_IntKT1    =   37,
+    CV_M4_IntGP     =   38,
+    CV_M4_IntSP     =   39,
+    CV_M4_IntS8     =   40,
+    CV_M4_IntRA     =   41,
+    CV_M4_IntLO     =   42,
+    CV_M4_IntHI     =   43,
+
+    CV_M4_Fir       =   50,
+    CV_M4_Psr       =   51,
+
+    CV_M4_FltF0     =   60,      /* Floating point registers */
+    CV_M4_FltF1     =   61,
+    CV_M4_FltF2     =   62,
+    CV_M4_FltF3     =   63,
+    CV_M4_FltF4     =   64,
+    CV_M4_FltF5     =   65,
+    CV_M4_FltF6     =   66,
+    CV_M4_FltF7     =   67,
+    CV_M4_FltF8     =   68,
+    CV_M4_FltF9     =   69,
+    CV_M4_FltF10    =   70,
+    CV_M4_FltF11    =   71,
+    CV_M4_FltF12    =   72,
+    CV_M4_FltF13    =   73,
+    CV_M4_FltF14    =   74,
+    CV_M4_FltF15    =   75,
+    CV_M4_FltF16    =   76,
+    CV_M4_FltF17    =   77,
+    CV_M4_FltF18    =   78,
+    CV_M4_FltF19    =   79,
+    CV_M4_FltF20    =   80,
+    CV_M4_FltF21    =   81,
+    CV_M4_FltF22    =   82,
+    CV_M4_FltF23    =   83,
+    CV_M4_FltF24    =   84,
+    CV_M4_FltF25    =   85,
+    CV_M4_FltF26    =   86,
+    CV_M4_FltF27    =   87,
+    CV_M4_FltF28    =   88,
+    CV_M4_FltF29    =   89,
+    CV_M4_FltF30    =   90,
+    CV_M4_FltF31    =   91,
+    CV_M4_FltFsr    =   92,
+
+
+    // Register set for the ALPHA AXP
+
+    CV_ALPHA_NOREG  = CV_REG_NONE,
+
+    CV_ALPHA_FltF0  =   10,   // Floating point registers
+    CV_ALPHA_FltF1  =   11,
+    CV_ALPHA_FltF2  =   12,
+    CV_ALPHA_FltF3  =   13,
+    CV_ALPHA_FltF4  =   14,
+    CV_ALPHA_FltF5  =   15,
+    CV_ALPHA_FltF6  =   16,
+    CV_ALPHA_FltF7  =   17,
+    CV_ALPHA_FltF8  =   18,
+    CV_ALPHA_FltF9  =   19,
+    CV_ALPHA_FltF10 =   20,
+    CV_ALPHA_FltF11 =   21,
+    CV_ALPHA_FltF12 =   22,
+    CV_ALPHA_FltF13 =   23,
+    CV_ALPHA_FltF14 =   24,
+    CV_ALPHA_FltF15 =   25,
+    CV_ALPHA_FltF16 =   26,
+    CV_ALPHA_FltF17 =   27,
+    CV_ALPHA_FltF18 =   28,
+    CV_ALPHA_FltF19 =   29,
+    CV_ALPHA_FltF20 =   30,
+    CV_ALPHA_FltF21 =   31,
+    CV_ALPHA_FltF22 =   32,
+    CV_ALPHA_FltF23 =   33,
+    CV_ALPHA_FltF24 =   34,
+    CV_ALPHA_FltF25 =   35,
+    CV_ALPHA_FltF26 =   36,
+    CV_ALPHA_FltF27 =   37,
+    CV_ALPHA_FltF28 =   38,
+    CV_ALPHA_FltF29 =   39,
+    CV_ALPHA_FltF30 =   40,
+    CV_ALPHA_FltF31 =   41,
+
+    CV_ALPHA_IntV0  =   42,   // Integer registers
+    CV_ALPHA_IntT0  =   43,
+    CV_ALPHA_IntT1  =   44,
+    CV_ALPHA_IntT2  =   45,
+    CV_ALPHA_IntT3  =   46,
+    CV_ALPHA_IntT4  =   47,
+    CV_ALPHA_IntT5  =   48,
+    CV_ALPHA_IntT6  =   49,
+    CV_ALPHA_IntT7  =   50,
+    CV_ALPHA_IntS0  =   51,
+    CV_ALPHA_IntS1  =   52,
+    CV_ALPHA_IntS2  =   53,
+    CV_ALPHA_IntS3  =   54,
+    CV_ALPHA_IntS4  =   55,
+    CV_ALPHA_IntS5  =   56,
+    CV_ALPHA_IntFP  =   57,
+    CV_ALPHA_IntA0  =   58,
+    CV_ALPHA_IntA1  =   59,
+    CV_ALPHA_IntA2  =   60,
+    CV_ALPHA_IntA3  =   61,
+    CV_ALPHA_IntA4  =   62,
+    CV_ALPHA_IntA5  =   63,
+    CV_ALPHA_IntT8  =   64,
+    CV_ALPHA_IntT9  =   65,
+    CV_ALPHA_IntT10 =   66,
+    CV_ALPHA_IntT11 =   67,
+    CV_ALPHA_IntRA  =   68,
+    CV_ALPHA_IntT12 =   69,
+    CV_ALPHA_IntAT  =   70,
+    CV_ALPHA_IntGP  =   71,
+    CV_ALPHA_IntSP  =   72,
+    CV_ALPHA_IntZERO =  73,
+
+
+    CV_ALPHA_Fpcr   =   74,   // Control registers
+    CV_ALPHA_Fir    =   75,
+    CV_ALPHA_Psr    =   76,
+    CV_ALPHA_FltFsr =   77,
+    CV_ALPHA_SoftFpcr =   78,
+
+    // Register Set for Motorola/IBM PowerPC
+
+    /*
+    ** PowerPC General Registers ( User Level )
+    */
+    CV_PPC_GPR0     =  1,
+    CV_PPC_GPR1     =  2,
+    CV_PPC_GPR2     =  3,
+    CV_PPC_GPR3     =  4,
+    CV_PPC_GPR4     =  5,
+    CV_PPC_GPR5     =  6,
+    CV_PPC_GPR6     =  7,
+    CV_PPC_GPR7     =  8,
+    CV_PPC_GPR8     =  9,
+    CV_PPC_GPR9     = 10,
+    CV_PPC_GPR10    = 11,
+    CV_PPC_GPR11    = 12,
+    CV_PPC_GPR12    = 13,
+    CV_PPC_GPR13    = 14,
+    CV_PPC_GPR14    = 15,
+    CV_PPC_GPR15    = 16,
+    CV_PPC_GPR16    = 17,
+    CV_PPC_GPR17    = 18,
+    CV_PPC_GPR18    = 19,
+    CV_PPC_GPR19    = 20,
+    CV_PPC_GPR20    = 21,
+    CV_PPC_GPR21    = 22,
+    CV_PPC_GPR22    = 23,
+    CV_PPC_GPR23    = 24,
+    CV_PPC_GPR24    = 25,
+    CV_PPC_GPR25    = 26,
+    CV_PPC_GPR26    = 27,
+    CV_PPC_GPR27    = 28,
+    CV_PPC_GPR28    = 29,
+    CV_PPC_GPR29    = 30,
+    CV_PPC_GPR30    = 31,
+    CV_PPC_GPR31    = 32,
+
+    /*
+    ** PowerPC Condition Register ( User Level )
+    */
+    CV_PPC_CR       = 33,
+    CV_PPC_CR0      = 34,
+    CV_PPC_CR1      = 35,
+    CV_PPC_CR2      = 36,
+    CV_PPC_CR3      = 37,
+    CV_PPC_CR4      = 38,
+    CV_PPC_CR5      = 39,
+    CV_PPC_CR6      = 40,
+    CV_PPC_CR7      = 41,
+
+    /*
+    ** PowerPC Floating Point Registers ( User Level )
+    */
+    CV_PPC_FPR0     = 42,
+    CV_PPC_FPR1     = 43,
+    CV_PPC_FPR2     = 44,
+    CV_PPC_FPR3     = 45,
+    CV_PPC_FPR4     = 46,
+    CV_PPC_FPR5     = 47,
+    CV_PPC_FPR6     = 48,
+    CV_PPC_FPR7     = 49,
+    CV_PPC_FPR8     = 50,
+    CV_PPC_FPR9     = 51,
+    CV_PPC_FPR10    = 52,
+    CV_PPC_FPR11    = 53,
+    CV_PPC_FPR12    = 54,
+    CV_PPC_FPR13    = 55,
+    CV_PPC_FPR14    = 56,
+    CV_PPC_FPR15    = 57,
+    CV_PPC_FPR16    = 58,
+    CV_PPC_FPR17    = 59,
+    CV_PPC_FPR18    = 60,
+    CV_PPC_FPR19    = 61,
+    CV_PPC_FPR20    = 62,
+    CV_PPC_FPR21    = 63,
+    CV_PPC_FPR22    = 64,
+    CV_PPC_FPR23    = 65,
+    CV_PPC_FPR24    = 66,
+    CV_PPC_FPR25    = 67,
+    CV_PPC_FPR26    = 68,
+    CV_PPC_FPR27    = 69,
+    CV_PPC_FPR28    = 70,
+    CV_PPC_FPR29    = 71,
+    CV_PPC_FPR30    = 72,
+    CV_PPC_FPR31    = 73,
+
+    /*
+    ** PowerPC Floating Point Status and Control Register ( User Level )
+    */
+    CV_PPC_FPSCR    = 74,
+
+    /*
+    ** PowerPC Machine State Register ( Supervisor Level )
+    */
+    CV_PPC_MSR      = 75,
+
+    /*
+    ** PowerPC Segment Registers ( Supervisor Level )
+    */
+    CV_PPC_SR0      = 76,
+    CV_PPC_SR1      = 77,
+    CV_PPC_SR2      = 78,
+    CV_PPC_SR3      = 79,
+    CV_PPC_SR4      = 80,
+    CV_PPC_SR5      = 81,
+    CV_PPC_SR6      = 82,
+    CV_PPC_SR7      = 83,
+    CV_PPC_SR8      = 84,
+    CV_PPC_SR9      = 85,
+    CV_PPC_SR10     = 86,
+    CV_PPC_SR11     = 87,
+    CV_PPC_SR12     = 88,
+    CV_PPC_SR13     = 89,
+    CV_PPC_SR14     = 90,
+    CV_PPC_SR15     = 91,
+
+    /*
+    ** For all of the special purpose registers add 100 to the SPR# that the
+    ** Motorola/IBM documentation gives with the exception of any imaginary
+    ** registers.
+    */
+
+    /*
+    ** PowerPC Special Purpose Registers ( User Level )
+    */
+    CV_PPC_PC       = 99,     // PC (imaginary register)
+
+    CV_PPC_MQ       = 100,    // MPC601
+    CV_PPC_XER      = 101,
+    CV_PPC_RTCU     = 104,    // MPC601
+    CV_PPC_RTCL     = 105,    // MPC601
+    CV_PPC_LR       = 108,
+    CV_PPC_CTR      = 109,
+
+    CV_PPC_COMPARE  = 110,    // part of XER (internal to the debugger only)
+    CV_PPC_COUNT    = 111,    // part of XER (internal to the debugger only)
+
+    /*
+    ** PowerPC Special Purpose Registers ( Supervisor Level )
+    */
+    CV_PPC_DSISR    = 118,
+    CV_PPC_DAR      = 119,
+    CV_PPC_DEC      = 122,
+    CV_PPC_SDR1     = 125,
+    CV_PPC_SRR0     = 126,
+    CV_PPC_SRR1     = 127,
+    CV_PPC_SPRG0    = 372,
+    CV_PPC_SPRG1    = 373,
+    CV_PPC_SPRG2    = 374,
+    CV_PPC_SPRG3    = 375,
+    CV_PPC_ASR      = 280,    // 64-bit implementations only
+    CV_PPC_EAR      = 382,
+    CV_PPC_PVR      = 287,
+    CV_PPC_BAT0U    = 628,
+    CV_PPC_BAT0L    = 629,
+    CV_PPC_BAT1U    = 630,
+    CV_PPC_BAT1L    = 631,
+    CV_PPC_BAT2U    = 632,
+    CV_PPC_BAT2L    = 633,
+    CV_PPC_BAT3U    = 634,
+    CV_PPC_BAT3L    = 635,
+    CV_PPC_DBAT0U   = 636,
+    CV_PPC_DBAT0L   = 637,
+    CV_PPC_DBAT1U   = 638,
+    CV_PPC_DBAT1L   = 639,
+    CV_PPC_DBAT2U   = 640,
+    CV_PPC_DBAT2L   = 641,
+    CV_PPC_DBAT3U   = 642,
+    CV_PPC_DBAT3L   = 643,
+
+    /*
+    ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level )
+    */
+
+    /*
+    ** Doesn't appear that IBM/Motorola has finished defining these.
+    */
+
+    CV_PPC_PMR0     = 1044,   // MPC620,
+    CV_PPC_PMR1     = 1045,   // MPC620,
+    CV_PPC_PMR2     = 1046,   // MPC620,
+    CV_PPC_PMR3     = 1047,   // MPC620,
+    CV_PPC_PMR4     = 1048,   // MPC620,
+    CV_PPC_PMR5     = 1049,   // MPC620,
+    CV_PPC_PMR6     = 1050,   // MPC620,
+    CV_PPC_PMR7     = 1051,   // MPC620,
+    CV_PPC_PMR8     = 1052,   // MPC620,
+    CV_PPC_PMR9     = 1053,   // MPC620,
+    CV_PPC_PMR10    = 1054,   // MPC620,
+    CV_PPC_PMR11    = 1055,   // MPC620,
+    CV_PPC_PMR12    = 1056,   // MPC620,
+    CV_PPC_PMR13    = 1057,   // MPC620,
+    CV_PPC_PMR14    = 1058,   // MPC620,
+    CV_PPC_PMR15    = 1059,   // MPC620,
+
+    CV_PPC_DMISS    = 1076,   // MPC603
+    CV_PPC_DCMP     = 1077,   // MPC603
+    CV_PPC_HASH1    = 1078,   // MPC603
+    CV_PPC_HASH2    = 1079,   // MPC603
+    CV_PPC_IMISS    = 1080,   // MPC603
+    CV_PPC_ICMP     = 1081,   // MPC603
+    CV_PPC_RPA      = 1082,   // MPC603
+
+    CV_PPC_HID0     = 1108,   // MPC601, MPC603, MPC620
+    CV_PPC_HID1     = 1109,   // MPC601
+    CV_PPC_HID2     = 1110,   // MPC601, MPC603, MPC620 ( IABR )
+    CV_PPC_HID3     = 1111,   // Not Defined
+    CV_PPC_HID4     = 1112,   // Not Defined
+    CV_PPC_HID5     = 1113,   // MPC601, MPC604, MPC620 ( DABR )
+    CV_PPC_HID6     = 1114,   // Not Defined
+    CV_PPC_HID7     = 1115,   // Not Defined
+    CV_PPC_HID8     = 1116,   // MPC620 ( BUSCSR )
+    CV_PPC_HID9     = 1117,   // MPC620 ( L2CSR )
+    CV_PPC_HID10    = 1118,   // Not Defined
+    CV_PPC_HID11    = 1119,   // Not Defined
+    CV_PPC_HID12    = 1120,   // Not Defined
+    CV_PPC_HID13    = 1121,   // MPC604 ( HCR )
+    CV_PPC_HID14    = 1122,   // Not Defined
+    CV_PPC_HID15    = 1123,   // MPC601, MPC604, MPC620 ( PIR )
+
+    //
+    // JAVA VM registers
+    //
+
+    CV_JAVA_PC      = 1,
+
+    //
+    // Register set for the Hitachi SH3
+    //
+
+    CV_SH3_NOREG    =   CV_REG_NONE,
+
+    CV_SH3_IntR0    =   10,   // CPU REGISTER
+    CV_SH3_IntR1    =   11,
+    CV_SH3_IntR2    =   12,
+    CV_SH3_IntR3    =   13,
+    CV_SH3_IntR4    =   14,
+    CV_SH3_IntR5    =   15,
+    CV_SH3_IntR6    =   16,
+    CV_SH3_IntR7    =   17,
+    CV_SH3_IntR8    =   18,
+    CV_SH3_IntR9    =   19,
+    CV_SH3_IntR10   =   20,
+    CV_SH3_IntR11   =   21,
+    CV_SH3_IntR12   =   22,
+    CV_SH3_IntR13   =   23,
+    CV_SH3_IntFp    =   24,
+    CV_SH3_IntSp    =   25,
+    CV_SH3_Gbr      =   38,
+    CV_SH3_Pr       =   39,
+    CV_SH3_Mach     =   40,
+    CV_SH3_Macl     =   41,
+
+    CV_SH3_Pc       =   50,
+    CV_SH3_Sr       =   51,
+
+    CV_SH3_BarA     =   60,
+    CV_SH3_BasrA    =   61,
+    CV_SH3_BamrA    =   62,
+    CV_SH3_BbrA     =   63,
+    CV_SH3_BarB     =   64,
+    CV_SH3_BasrB    =   65,
+    CV_SH3_BamrB    =   66,
+    CV_SH3_BbrB     =   67,
+    CV_SH3_BdrB     =   68,
+    CV_SH3_BdmrB    =   69,
+    CV_SH3_Brcr     =   70,
+
+    //
+    // Additional registers for Hitachi SH processors
+    //
+
+    CV_SH_Fpscr    =   75,    // floating point status/control register
+    CV_SH_Fpul     =   76,    // floating point communication register
+
+    CV_SH_FpR0     =   80,    // Floating point registers
+    CV_SH_FpR1     =   81,
+    CV_SH_FpR2     =   82,
+    CV_SH_FpR3     =   83,
+    CV_SH_FpR4     =   84,
+    CV_SH_FpR5     =   85,
+    CV_SH_FpR6     =   86,
+    CV_SH_FpR7     =   87,
+    CV_SH_FpR8     =   88,
+    CV_SH_FpR9     =   89,
+    CV_SH_FpR10    =   90,
+    CV_SH_FpR11    =   91,
+    CV_SH_FpR12    =   92,
+    CV_SH_FpR13    =   93,
+    CV_SH_FpR14    =   94,
+    CV_SH_FpR15    =   95,
+
+    CV_SH_XFpR0    =   96,
+    CV_SH_XFpR1    =   97,
+    CV_SH_XFpR2    =   98,
+    CV_SH_XFpR3    =   99,
+    CV_SH_XFpR4    =  100,
+    CV_SH_XFpR5    =  101,
+    CV_SH_XFpR6    =  102,
+    CV_SH_XFpR7    =  103,
+    CV_SH_XFpR8    =  104,
+    CV_SH_XFpR9    =  105,
+    CV_SH_XFpR10   =  106,
+    CV_SH_XFpR11   =  107,
+    CV_SH_XFpR12   =  108,
+    CV_SH_XFpR13   =  109,
+    CV_SH_XFpR14   =  110,
+    CV_SH_XFpR15   =  111,
+
+    //
+    // Register set for the ARM processor.
+    //
+
+    CV_ARM_NOREG    =   CV_REG_NONE,
+
+    CV_ARM_R0       =   10,
+    CV_ARM_R1       =   11,
+    CV_ARM_R2       =   12,
+    CV_ARM_R3       =   13,
+    CV_ARM_R4       =   14,
+    CV_ARM_R5       =   15,
+    CV_ARM_R6       =   16,
+    CV_ARM_R7       =   17,
+    CV_ARM_R8       =   18,
+    CV_ARM_R9       =   19,
+    CV_ARM_R10      =   20,
+    CV_ARM_R11      =   21, // Frame pointer, if allocated
+    CV_ARM_R12      =   22,
+    CV_ARM_SP       =   23, // Stack pointer
+    CV_ARM_LR       =   24, // Link Register
+    CV_ARM_PC       =   25, // Program counter
+    CV_ARM_CPSR     =   26, // Current program status register
+
+    //
+    // Register set for Intel IA64
+    //
+
+    CV_IA64_NOREG   =   CV_REG_NONE,
+
+    // Branch Registers
+
+    CV_IA64_Br0     =   512,
+    CV_IA64_Br1     =   513,
+    CV_IA64_Br2     =   514,
+    CV_IA64_Br3     =   515,
+    CV_IA64_Br4     =   516,
+    CV_IA64_Br5     =   517,
+    CV_IA64_Br6     =   518,
+    CV_IA64_Br7     =   519,
+
+    // Predicate Registers
+
+    CV_IA64_P0    =   704,
+    CV_IA64_P1    =   705,
+    CV_IA64_P2    =   706,
+    CV_IA64_P3    =   707,
+    CV_IA64_P4    =   708,
+    CV_IA64_P5    =   709,
+    CV_IA64_P6    =   710,
+    CV_IA64_P7    =   711,
+    CV_IA64_P8    =   712,
+    CV_IA64_P9    =   713,
+    CV_IA64_P10   =   714,
+    CV_IA64_P11   =   715,
+    CV_IA64_P12   =   716,
+    CV_IA64_P13   =   717,
+    CV_IA64_P14   =   718,
+    CV_IA64_P15   =   719,
+    CV_IA64_P16   =   720,
+    CV_IA64_P17   =   721,
+    CV_IA64_P18   =   722,
+    CV_IA64_P19   =   723,
+    CV_IA64_P20   =   724,
+    CV_IA64_P21   =   725,
+    CV_IA64_P22   =   726,
+    CV_IA64_P23   =   727,
+    CV_IA64_P24   =   728,
+    CV_IA64_P25   =   729,
+    CV_IA64_P26   =   730,
+    CV_IA64_P27   =   731,
+    CV_IA64_P28   =   732,
+    CV_IA64_P29   =   733,
+    CV_IA64_P30   =   734,
+    CV_IA64_P31   =   735,
+    CV_IA64_P32   =   736,
+    CV_IA64_P33   =   737,
+    CV_IA64_P34   =   738,
+    CV_IA64_P35   =   739,
+    CV_IA64_P36   =   740,
+    CV_IA64_P37   =   741,
+    CV_IA64_P38   =   742,
+    CV_IA64_P39   =   743,
+    CV_IA64_P40   =   744,
+    CV_IA64_P41   =   745,
+    CV_IA64_P42   =   746,
+    CV_IA64_P43   =   747,
+    CV_IA64_P44   =   748,
+    CV_IA64_P45   =   749,
+    CV_IA64_P46   =   750,
+    CV_IA64_P47   =   751,
+    CV_IA64_P48   =   752,
+    CV_IA64_P49   =   753,
+    CV_IA64_P50   =   754,
+    CV_IA64_P51   =   755,
+    CV_IA64_P52   =   756,
+    CV_IA64_P53   =   757,
+    CV_IA64_P54   =   758,
+    CV_IA64_P55   =   759,
+    CV_IA64_P56   =   760,
+    CV_IA64_P57   =   761,
+    CV_IA64_P58   =   762,
+    CV_IA64_P59   =   763,
+    CV_IA64_P60   =   764,
+    CV_IA64_P61   =   765,
+    CV_IA64_P62   =   766,
+    CV_IA64_P63   =   767,
+
+    CV_IA64_Preds   =   768,
+
+    // Banked General Registers
+
+    CV_IA64_IntH0   =   832,
+    CV_IA64_IntH1   =   833,
+    CV_IA64_IntH2   =   834,
+    CV_IA64_IntH3   =   835,
+    CV_IA64_IntH4   =   836,
+    CV_IA64_IntH5   =   837,
+    CV_IA64_IntH6   =   838,
+    CV_IA64_IntH7   =   839,
+    CV_IA64_IntH8   =   840,
+    CV_IA64_IntH9   =   841,
+    CV_IA64_IntH10  =   842,
+    CV_IA64_IntH11  =   843,
+    CV_IA64_IntH12  =   844,
+    CV_IA64_IntH13  =   845,
+    CV_IA64_IntH14  =   846,
+    CV_IA64_IntH15  =   847,
+
+    // Special Registers
+
+    CV_IA64_Ip      =   1016,
+    CV_IA64_Umask   =   1017,
+    CV_IA64_Cfm     =   1018,
+    CV_IA64_Psr     =   1019,
+
+    // Banked General Registers
+
+    CV_IA64_Nats    =   1020,
+    CV_IA64_Nats2   =   1021,
+    CV_IA64_Nats3   =   1022,
+
+    // General-Purpose Registers
+
+    // Integer registers
+    CV_IA64_IntR0   =   1024,
+    CV_IA64_IntR1   =   1025,
+    CV_IA64_IntR2   =   1026,
+    CV_IA64_IntR3   =   1027,
+    CV_IA64_IntR4   =   1028,
+    CV_IA64_IntR5   =   1029,
+    CV_IA64_IntR6   =   1030,
+    CV_IA64_IntR7   =   1031,
+    CV_IA64_IntR8   =   1032,
+    CV_IA64_IntR9   =   1033,
+    CV_IA64_IntR10  =   1034,
+    CV_IA64_IntR11  =   1035,
+    CV_IA64_IntR12  =   1036,
+    CV_IA64_IntR13  =   1037,
+    CV_IA64_IntR14  =   1038,
+    CV_IA64_IntR15  =   1039,
+    CV_IA64_IntR16  =   1040,
+    CV_IA64_IntR17  =   1041,
+    CV_IA64_IntR18  =   1042,
+    CV_IA64_IntR19  =   1043,
+    CV_IA64_IntR20  =   1044,
+    CV_IA64_IntR21  =   1045,
+    CV_IA64_IntR22  =   1046,
+    CV_IA64_IntR23  =   1047,
+    CV_IA64_IntR24  =   1048,
+    CV_IA64_IntR25  =   1049,
+    CV_IA64_IntR26  =   1050,
+    CV_IA64_IntR27  =   1051,
+    CV_IA64_IntR28  =   1052,
+    CV_IA64_IntR29  =   1053,
+    CV_IA64_IntR30  =   1054,
+    CV_IA64_IntR31  =   1055,
+
+    // Register Stack
+    CV_IA64_IntR32  =   1056,
+    CV_IA64_IntR33  =   1057,
+    CV_IA64_IntR34  =   1058,
+    CV_IA64_IntR35  =   1059,
+    CV_IA64_IntR36  =   1060,
+    CV_IA64_IntR37  =   1061,
+    CV_IA64_IntR38  =   1062,
+    CV_IA64_IntR39  =   1063,
+    CV_IA64_IntR40  =   1064,
+    CV_IA64_IntR41  =   1065,
+    CV_IA64_IntR42  =   1066,
+    CV_IA64_IntR43  =   1067,
+    CV_IA64_IntR44  =   1068,
+    CV_IA64_IntR45  =   1069,
+    CV_IA64_IntR46  =   1070,
+    CV_IA64_IntR47  =   1071,
+    CV_IA64_IntR48  =   1072,
+    CV_IA64_IntR49  =   1073,
+    CV_IA64_IntR50  =   1074,
+    CV_IA64_IntR51  =   1075,
+    CV_IA64_IntR52  =   1076,
+    CV_IA64_IntR53  =   1077,
+    CV_IA64_IntR54  =   1078,
+    CV_IA64_IntR55  =   1079,
+    CV_IA64_IntR56  =   1080,
+    CV_IA64_IntR57  =   1081,
+    CV_IA64_IntR58  =   1082,
+    CV_IA64_IntR59  =   1083,
+    CV_IA64_IntR60  =   1084,
+    CV_IA64_IntR61  =   1085,
+    CV_IA64_IntR62  =   1086,
+    CV_IA64_IntR63  =   1087,
+    CV_IA64_IntR64  =   1088,
+    CV_IA64_IntR65  =   1089,
+    CV_IA64_IntR66  =   1090,
+    CV_IA64_IntR67  =   1091,
+    CV_IA64_IntR68  =   1092,
+    CV_IA64_IntR69  =   1093,
+    CV_IA64_IntR70  =   1094,
+    CV_IA64_IntR71  =   1095,
+    CV_IA64_IntR72  =   1096,
+    CV_IA64_IntR73  =   1097,
+    CV_IA64_IntR74  =   1098,
+    CV_IA64_IntR75  =   1099,
+    CV_IA64_IntR76  =   1100,
+    CV_IA64_IntR77  =   1101,
+    CV_IA64_IntR78  =   1102,
+    CV_IA64_IntR79  =   1103,
+    CV_IA64_IntR80  =   1104,
+    CV_IA64_IntR81  =   1105,
+    CV_IA64_IntR82  =   1106,
+    CV_IA64_IntR83  =   1107,
+    CV_IA64_IntR84  =   1108,
+    CV_IA64_IntR85  =   1109,
+    CV_IA64_IntR86  =   1110,
+    CV_IA64_IntR87  =   1111,
+    CV_IA64_IntR88  =   1112,
+    CV_IA64_IntR89  =   1113,
+    CV_IA64_IntR90  =   1114,
+    CV_IA64_IntR91  =   1115,
+    CV_IA64_IntR92  =   1116,
+    CV_IA64_IntR93  =   1117,
+    CV_IA64_IntR94  =   1118,
+    CV_IA64_IntR95  =   1119,
+    CV_IA64_IntR96  =   1120,
+    CV_IA64_IntR97  =   1121,
+    CV_IA64_IntR98  =   1122,
+    CV_IA64_IntR99  =   1123,
+    CV_IA64_IntR100 =   1124,
+    CV_IA64_IntR101 =   1125,
+    CV_IA64_IntR102 =   1126,
+    CV_IA64_IntR103 =   1127,
+    CV_IA64_IntR104 =   1128,
+    CV_IA64_IntR105 =   1129,
+    CV_IA64_IntR106 =   1130,
+    CV_IA64_IntR107 =   1131,
+    CV_IA64_IntR108 =   1132,
+    CV_IA64_IntR109 =   1133,
+    CV_IA64_IntR110 =   1134,
+    CV_IA64_IntR111 =   1135,
+    CV_IA64_IntR112 =   1136,
+    CV_IA64_IntR113 =   1137,
+    CV_IA64_IntR114 =   1138,
+    CV_IA64_IntR115 =   1139,
+    CV_IA64_IntR116 =   1140,
+    CV_IA64_IntR117 =   1141,
+    CV_IA64_IntR118 =   1142,
+    CV_IA64_IntR119 =   1143,
+    CV_IA64_IntR120 =   1144,
+    CV_IA64_IntR121 =   1145,
+    CV_IA64_IntR122 =   1146,
+    CV_IA64_IntR123 =   1147,
+    CV_IA64_IntR124 =   1148,
+    CV_IA64_IntR125 =   1149,
+    CV_IA64_IntR126 =   1150,
+    CV_IA64_IntR127 =   1151,
+
+    // Floating-Point Registers
+
+    // Low Floating Point Registers
+    CV_IA64_FltF0   =   2048,
+    CV_IA64_FltF1   =   2049,
+    CV_IA64_FltF2   =   2050,
+    CV_IA64_FltF3   =   2051,
+    CV_IA64_FltF4   =   2052,
+    CV_IA64_FltF5   =   2053,
+    CV_IA64_FltF6   =   2054,
+    CV_IA64_FltF7   =   2055,
+    CV_IA64_FltF8   =   2056,
+    CV_IA64_FltF9   =   2057,
+    CV_IA64_FltF10  =   2058,
+    CV_IA64_FltF11  =   2059,
+    CV_IA64_FltF12  =   2060,
+    CV_IA64_FltF13  =   2061,
+    CV_IA64_FltF14  =   2062,
+    CV_IA64_FltF15  =   2063,
+    CV_IA64_FltF16  =   2064,
+    CV_IA64_FltF17  =   2065,
+    CV_IA64_FltF18  =   2066,
+    CV_IA64_FltF19  =   2067,
+    CV_IA64_FltF20  =   2068,
+    CV_IA64_FltF21  =   2069,
+    CV_IA64_FltF22  =   2070,
+    CV_IA64_FltF23  =   2071,
+    CV_IA64_FltF24  =   2072,
+    CV_IA64_FltF25  =   2073,
+    CV_IA64_FltF26  =   2074,
+    CV_IA64_FltF27  =   2075,
+    CV_IA64_FltF28  =   2076,
+    CV_IA64_FltF29  =   2077,
+    CV_IA64_FltF30  =   2078,
+    CV_IA64_FltF31  =   2079,
+
+    // High Floating Point Registers
+    CV_IA64_FltF32  =   2080,
+    CV_IA64_FltF33  =   2081,
+    CV_IA64_FltF34  =   2082,
+    CV_IA64_FltF35  =   2083,
+    CV_IA64_FltF36  =   2084,
+    CV_IA64_FltF37  =   2085,
+    CV_IA64_FltF38  =   2086,
+    CV_IA64_FltF39  =   2087,
+    CV_IA64_FltF40  =   2088,
+    CV_IA64_FltF41  =   2089,
+    CV_IA64_FltF42  =   2090,
+    CV_IA64_FltF43  =   2091,
+    CV_IA64_FltF44  =   2092,
+    CV_IA64_FltF45  =   2093,
+    CV_IA64_FltF46  =   2094,
+    CV_IA64_FltF47  =   2095,
+    CV_IA64_FltF48  =   2096,
+    CV_IA64_FltF49  =   2097,
+    CV_IA64_FltF50  =   2098,
+    CV_IA64_FltF51  =   2099,
+    CV_IA64_FltF52  =   2100,
+    CV_IA64_FltF53  =   2101,
+    CV_IA64_FltF54  =   2102,
+    CV_IA64_FltF55  =   2103,
+    CV_IA64_FltF56  =   2104,
+    CV_IA64_FltF57  =   2105,
+    CV_IA64_FltF58  =   2106,
+    CV_IA64_FltF59  =   2107,
+    CV_IA64_FltF60  =   2108,
+    CV_IA64_FltF61  =   2109,
+    CV_IA64_FltF62  =   2110,
+    CV_IA64_FltF63  =   2111,
+    CV_IA64_FltF64  =   2112,
+    CV_IA64_FltF65  =   2113,
+    CV_IA64_FltF66  =   2114,
+    CV_IA64_FltF67  =   2115,
+    CV_IA64_FltF68  =   2116,
+    CV_IA64_FltF69  =   2117,
+    CV_IA64_FltF70  =   2118,
+    CV_IA64_FltF71  =   2119,
+    CV_IA64_FltF72  =   2120,
+    CV_IA64_FltF73  =   2121,
+    CV_IA64_FltF74  =   2122,
+    CV_IA64_FltF75  =   2123,
+    CV_IA64_FltF76  =   2124,
+    CV_IA64_FltF77  =   2125,
+    CV_IA64_FltF78  =   2126,
+    CV_IA64_FltF79  =   2127,
+    CV_IA64_FltF80  =   2128,
+    CV_IA64_FltF81  =   2129,
+    CV_IA64_FltF82  =   2130,
+    CV_IA64_FltF83  =   2131,
+    CV_IA64_FltF84  =   2132,
+    CV_IA64_FltF85  =   2133,
+    CV_IA64_FltF86  =   2134,
+    CV_IA64_FltF87  =   2135,
+    CV_IA64_FltF88  =   2136,
+    CV_IA64_FltF89  =   2137,
+    CV_IA64_FltF90  =   2138,
+    CV_IA64_FltF91  =   2139,
+    CV_IA64_FltF92  =   2140,
+    CV_IA64_FltF93  =   2141,
+    CV_IA64_FltF94  =   2142,
+    CV_IA64_FltF95  =   2143,
+    CV_IA64_FltF96  =   2144,
+    CV_IA64_FltF97  =   2145,
+    CV_IA64_FltF98  =   2146,
+    CV_IA64_FltF99  =   2147,
+    CV_IA64_FltF100 =   2148,
+    CV_IA64_FltF101 =   2149,
+    CV_IA64_FltF102 =   2150,
+    CV_IA64_FltF103 =   2151,
+    CV_IA64_FltF104 =   2152,
+    CV_IA64_FltF105 =   2153,
+    CV_IA64_FltF106 =   2154,
+    CV_IA64_FltF107 =   2155,
+    CV_IA64_FltF108 =   2156,
+    CV_IA64_FltF109 =   2157,
+    CV_IA64_FltF110 =   2158,
+    CV_IA64_FltF111 =   2159,
+    CV_IA64_FltF112 =   2160,
+    CV_IA64_FltF113 =   2161,
+    CV_IA64_FltF114 =   2162,
+    CV_IA64_FltF115 =   2163,
+    CV_IA64_FltF116 =   2164,
+    CV_IA64_FltF117 =   2165,
+    CV_IA64_FltF118 =   2166,
+    CV_IA64_FltF119 =   2167,
+    CV_IA64_FltF120 =   2168,
+    CV_IA64_FltF121 =   2169,
+    CV_IA64_FltF122 =   2170,
+    CV_IA64_FltF123 =   2171,
+    CV_IA64_FltF124 =   2172,
+    CV_IA64_FltF125 =   2173,
+    CV_IA64_FltF126 =   2174,
+    CV_IA64_FltF127 =   2175,
+
+    // Application Registers
+
+    CV_IA64_ApKR0   =   3072,
+    CV_IA64_ApKR1   =   3073,
+    CV_IA64_ApKR2   =   3074,
+    CV_IA64_ApKR3   =   3075,
+    CV_IA64_ApKR4   =   3076,
+    CV_IA64_ApKR5   =   3077,
+    CV_IA64_ApKR6   =   3078,
+    CV_IA64_ApKR7   =   3079,
+    CV_IA64_AR8     =   3080,
+    CV_IA64_AR9     =   3081,
+    CV_IA64_AR10    =   3082,
+    CV_IA64_AR11    =   3083,
+    CV_IA64_AR12    =   3084,
+    CV_IA64_AR13    =   3085,
+    CV_IA64_AR14    =   3086,
+    CV_IA64_AR15    =   3087,
+    CV_IA64_RsRSC   =   3088,
+    CV_IA64_RsBSP   =   3089,
+    CV_IA64_RsBSPSTORE  =   3090,
+    CV_IA64_RsRNAT  =   3091,
+    CV_IA64_AR20    =   3092,
+    CV_IA64_StFCR   =   3093,
+    CV_IA64_AR22    =   3094,
+    CV_IA64_AR23    =   3095,
+    CV_IA64_EFLAG   =   3096,
+    CV_IA64_CSD     =   3097,
+    CV_IA64_SSD     =   3098,
+    CV_IA64_CFLG    =   3099,
+    CV_IA64_StFSR   =   3100,
+    CV_IA64_StFIR   =   3101,
+    CV_IA64_StFDR   =   3102,
+    CV_IA64_AR31    =   3103,
+    CV_IA64_ApCCV   =   3104,
+    CV_IA64_AR33    =   3105,
+    CV_IA64_AR34    =   3106,
+    CV_IA64_AR35    =   3107,
+    CV_IA64_ApUNAT  =   3108,
+    CV_IA64_AR37    =   3109,
+    CV_IA64_AR38    =   3110,
+    CV_IA64_AR39    =   3111,
+    CV_IA64_StFPSR  =   3112,
+    CV_IA64_AR41    =   3113,
+    CV_IA64_AR42    =   3114,
+    CV_IA64_AR43    =   3115,
+    CV_IA64_ApITC   =   3116,
+    CV_IA64_AR45    =   3117,
+    CV_IA64_AR46    =   3118,
+    CV_IA64_AR47    =   3119,
+    CV_IA64_AR48    =   3120,
+    CV_IA64_AR49    =   3121,
+    CV_IA64_AR50    =   3122,
+    CV_IA64_AR51    =   3123,
+    CV_IA64_AR52    =   3124,
+    CV_IA64_AR53    =   3125,
+    CV_IA64_AR54    =   3126,
+    CV_IA64_AR55    =   3127,
+    CV_IA64_AR56    =   3128,
+    CV_IA64_AR57    =   3129,
+    CV_IA64_AR58    =   3130,
+    CV_IA64_AR59    =   3131,
+    CV_IA64_AR60    =   3132,
+    CV_IA64_AR61    =   3133,
+    CV_IA64_AR62    =   3134,
+    CV_IA64_AR63    =   3135,
+    CV_IA64_RsPFS   =   3136,
+    CV_IA64_ApLC    =   3137,
+    CV_IA64_ApEC    =   3138,
+    CV_IA64_AR67    =   3139,
+    CV_IA64_AR68    =   3140,
+    CV_IA64_AR69    =   3141,
+    CV_IA64_AR70    =   3142,
+    CV_IA64_AR71    =   3143,
+    CV_IA64_AR72    =   3144,
+    CV_IA64_AR73    =   3145,
+    CV_IA64_AR74    =   3146,
+    CV_IA64_AR75    =   3147,
+    CV_IA64_AR76    =   3148,
+    CV_IA64_AR77    =   3149,
+    CV_IA64_AR78    =   3150,
+    CV_IA64_AR79    =   3151,
+    CV_IA64_AR80    =   3152,
+    CV_IA64_AR81    =   3153,
+    CV_IA64_AR82    =   3154,
+    CV_IA64_AR83    =   3155,
+    CV_IA64_AR84    =   3156,
+    CV_IA64_AR85    =   3157,
+    CV_IA64_AR86    =   3158,
+    CV_IA64_AR87    =   3159,
+    CV_IA64_AR88    =   3160,
+    CV_IA64_AR89    =   3161,
+    CV_IA64_AR90    =   3162,
+    CV_IA64_AR91    =   3163,
+    CV_IA64_AR92    =   3164,
+    CV_IA64_AR93    =   3165,
+    CV_IA64_AR94    =   3166,
+    CV_IA64_AR95    =   3167,
+    CV_IA64_AR96    =   3168,
+    CV_IA64_AR97    =   3169,
+    CV_IA64_AR98    =   3170,
+    CV_IA64_AR99    =   3171,
+    CV_IA64_AR100   =   3172,
+    CV_IA64_AR101   =   3173,
+    CV_IA64_AR102   =   3174,
+    CV_IA64_AR103   =   3175,
+    CV_IA64_AR104   =   3176,
+    CV_IA64_AR105   =   3177,
+    CV_IA64_AR106   =   3178,
+    CV_IA64_AR107   =   3179,
+    CV_IA64_AR108   =   3180,
+    CV_IA64_AR109   =   3181,
+    CV_IA64_AR110   =   3182,
+    CV_IA64_AR111   =   3183,
+    CV_IA64_AR112   =   3184,
+    CV_IA64_AR113   =   3185,
+    CV_IA64_AR114   =   3186,
+    CV_IA64_AR115   =   3187,
+    CV_IA64_AR116   =   3188,
+    CV_IA64_AR117   =   3189,
+    CV_IA64_AR118   =   3190,
+    CV_IA64_AR119   =   3191,
+    CV_IA64_AR120   =   3192,
+    CV_IA64_AR121   =   3193,
+    CV_IA64_AR122   =   3194,
+    CV_IA64_AR123   =   3195,
+    CV_IA64_AR124   =   3196,
+    CV_IA64_AR125   =   3197,
+    CV_IA64_AR126   =   3198,
+    CV_IA64_AR127   =   3199,
+
+    // CPUID Registers
+
+    CV_IA64_CPUID0  =   3328,
+    CV_IA64_CPUID1  =   3329,
+    CV_IA64_CPUID2  =   3330,
+    CV_IA64_CPUID3  =   3331,
+    CV_IA64_CPUID4  =   3332,
+
+    // Control Registers
+
+    CV_IA64_ApDCR   =   4096,
+    CV_IA64_ApITM   =   4097,
+    CV_IA64_ApIVA   =   4098,
+    CV_IA64_CR3     =   4099,
+    CV_IA64_CR4     =   4100,
+    CV_IA64_CR5     =   4101,
+    CV_IA64_CR6     =   4102,
+    CV_IA64_CR7     =   4103,
+    CV_IA64_ApPTA   =   4104,
+    CV_IA64_ApGPTA  =   4105,
+    CV_IA64_CR10    =   4106,
+    CV_IA64_CR11    =   4107,
+    CV_IA64_CR12    =   4108,
+    CV_IA64_CR13    =   4109,
+    CV_IA64_CR14    =   4110,
+    CV_IA64_CR15    =   4111,
+    CV_IA64_StIPSR  =   4112,
+    CV_IA64_StISR   =   4113,
+    CV_IA64_CR18    =   4114,
+    CV_IA64_StIIP   =   4115,
+    CV_IA64_StIFA   =   4116,
+    CV_IA64_StITIR  =   4117,
+    CV_IA64_StIIPA  =   4118,
+    CV_IA64_StIFS   =   4119,
+    CV_IA64_StIIM   =   4120,
+    CV_IA64_StIHA   =   4121,
+    CV_IA64_CR26    =   4122,
+    CV_IA64_CR27    =   4123,
+    CV_IA64_CR28    =   4124,
+    CV_IA64_CR29    =   4125,
+    CV_IA64_CR30    =   4126,
+    CV_IA64_CR31    =   4127,
+    CV_IA64_CR32    =   4128,
+    CV_IA64_CR33    =   4129,
+    CV_IA64_CR34    =   4130,
+    CV_IA64_CR35    =   4131,
+    CV_IA64_CR36    =   4132,
+    CV_IA64_CR37    =   4133,
+    CV_IA64_CR38    =   4134,
+    CV_IA64_CR39    =   4135,
+    CV_IA64_CR40    =   4136,
+    CV_IA64_CR41    =   4137,
+    CV_IA64_CR42    =   4138,
+    CV_IA64_CR43    =   4139,
+    CV_IA64_CR44    =   4140,
+    CV_IA64_CR45    =   4141,
+    CV_IA64_CR46    =   4142,
+    CV_IA64_CR47    =   4143,
+    CV_IA64_CR48    =   4144,
+    CV_IA64_CR49    =   4145,
+    CV_IA64_CR50    =   4146,
+    CV_IA64_CR51    =   4147,
+    CV_IA64_CR52    =   4148,
+    CV_IA64_CR53    =   4149,
+    CV_IA64_CR54    =   4150,
+    CV_IA64_CR55    =   4151,
+    CV_IA64_CR56    =   4152,
+    CV_IA64_CR57    =   4153,
+    CV_IA64_CR58    =   4154,
+    CV_IA64_CR59    =   4155,
+    CV_IA64_CR60    =   4156,
+    CV_IA64_CR61    =   4157,
+    CV_IA64_CR62    =   4158,
+    CV_IA64_CR63    =   4159,
+    CV_IA64_SaLID   =   4160,
+    CV_IA64_SaIVR   =   4161,
+    CV_IA64_SaTPR   =   4162,
+    CV_IA64_SaEOI   =   4163,
+    CV_IA64_SaIRR0  =   4164,
+    CV_IA64_SaIRR1  =   4165,
+    CV_IA64_SaIRR2  =   4166,
+    CV_IA64_SaIRR3  =   4167,
+    CV_IA64_SaITV   =   4168,
+    CV_IA64_SaPMV   =   4169,
+    CV_IA64_SaCMCV  =   4170,
+    CV_IA64_CR75    =   4171,
+    CV_IA64_CR76    =   4172,
+    CV_IA64_CR77    =   4173,
+    CV_IA64_CR78    =   4174,
+    CV_IA64_CR79    =   4175,
+    CV_IA64_SaLRR0  =   4176,
+    CV_IA64_SaLRR1  =   4177,
+    CV_IA64_CR82    =   4178,
+    CV_IA64_CR83    =   4179,
+    CV_IA64_CR84    =   4180,
+    CV_IA64_CR85    =   4181,
+    CV_IA64_CR86    =   4182,
+    CV_IA64_CR87    =   4183,
+    CV_IA64_CR88    =   4184,
+    CV_IA64_CR89    =   4185,
+    CV_IA64_CR90    =   4186,
+    CV_IA64_CR91    =   4187,
+    CV_IA64_CR92    =   4188,
+    CV_IA64_CR93    =   4189,
+    CV_IA64_CR94    =   4190,
+    CV_IA64_CR95    =   4191,
+    CV_IA64_CR96    =   4192,
+    CV_IA64_CR97    =   4193,
+    CV_IA64_CR98    =   4194,
+    CV_IA64_CR99    =   4195,
+    CV_IA64_CR100   =   4196,
+    CV_IA64_CR101   =   4197,
+    CV_IA64_CR102   =   4198,
+    CV_IA64_CR103   =   4199,
+    CV_IA64_CR104   =   4200,
+    CV_IA64_CR105   =   4201,
+    CV_IA64_CR106   =   4202,
+    CV_IA64_CR107   =   4203,
+    CV_IA64_CR108   =   4204,
+    CV_IA64_CR109   =   4205,
+    CV_IA64_CR110   =   4206,
+    CV_IA64_CR111   =   4207,
+    CV_IA64_CR112   =   4208,
+    CV_IA64_CR113   =   4209,
+    CV_IA64_CR114   =   4210,
+    CV_IA64_CR115   =   4211,
+    CV_IA64_CR116   =   4212,
+    CV_IA64_CR117   =   4213,
+    CV_IA64_CR118   =   4214,
+    CV_IA64_CR119   =   4215,
+    CV_IA64_CR120   =   4216,
+    CV_IA64_CR121   =   4217,
+    CV_IA64_CR122   =   4218,
+    CV_IA64_CR123   =   4219,
+    CV_IA64_CR124   =   4220,
+    CV_IA64_CR125   =   4221,
+    CV_IA64_CR126   =   4222,
+    CV_IA64_CR127   =   4223,
+
+    // Protection Key Registers
+
+    CV_IA64_Pkr0    =   5120,
+    CV_IA64_Pkr1    =   5121,
+    CV_IA64_Pkr2    =   5122,
+    CV_IA64_Pkr3    =   5123,
+    CV_IA64_Pkr4    =   5124,
+    CV_IA64_Pkr5    =   5125,
+    CV_IA64_Pkr6    =   5126,
+    CV_IA64_Pkr7    =   5127,
+    CV_IA64_Pkr8    =   5128,
+    CV_IA64_Pkr9    =   5129,
+    CV_IA64_Pkr10   =   5130,
+    CV_IA64_Pkr11   =   5131,
+    CV_IA64_Pkr12   =   5132,
+    CV_IA64_Pkr13   =   5133,
+    CV_IA64_Pkr14   =   5134,
+    CV_IA64_Pkr15   =   5135,
+
+    // Region Registers
+
+    CV_IA64_Rr0     =   6144,
+    CV_IA64_Rr1     =   6145,
+    CV_IA64_Rr2     =   6146,
+    CV_IA64_Rr3     =   6147,
+    CV_IA64_Rr4     =   6148,
+    CV_IA64_Rr5     =   6149,
+    CV_IA64_Rr6     =   6150,
+    CV_IA64_Rr7     =   6151,
+
+    // Performance Monitor Data Registers
+
+    CV_IA64_PFD0    =   7168,
+    CV_IA64_PFD1    =   7169,
+    CV_IA64_PFD2    =   7170,
+    CV_IA64_PFD3    =   7171,
+    CV_IA64_PFD4    =   7172,
+    CV_IA64_PFD5    =   7173,
+    CV_IA64_PFD6    =   7174,
+    CV_IA64_PFD7    =   7175,
+    CV_IA64_PFD8    =   7176,
+    CV_IA64_PFD9    =   7177,
+    CV_IA64_PFD10   =   7178,
+    CV_IA64_PFD11   =   7179,
+    CV_IA64_PFD12   =   7180,
+    CV_IA64_PFD13   =   7181,
+    CV_IA64_PFD14   =   7182,
+    CV_IA64_PFD15   =   7183,
+    CV_IA64_PFD16   =   7184,
+    CV_IA64_PFD17   =   7185,
+
+    // Performance Monitor Config Registers
+
+    CV_IA64_PFC0    =   7424,
+    CV_IA64_PFC1    =   7425,
+    CV_IA64_PFC2    =   7426,
+    CV_IA64_PFC3    =   7427,
+    CV_IA64_PFC4    =   7428,
+    CV_IA64_PFC5    =   7429,
+    CV_IA64_PFC6    =   7430,
+    CV_IA64_PFC7    =   7431,
+    CV_IA64_PFC8    =   7432,
+    CV_IA64_PFC9    =   7433,
+    CV_IA64_PFC10   =   7434,
+    CV_IA64_PFC11   =   7435,
+    CV_IA64_PFC12   =   7436,
+    CV_IA64_PFC13   =   7437,
+    CV_IA64_PFC14   =   7438,
+    CV_IA64_PFC15   =   7439,
+
+    // Instruction Translation Registers
+
+    CV_IA64_TrI0    =   8192,
+    CV_IA64_TrI1    =   8193,
+    CV_IA64_TrI2    =   8194,
+    CV_IA64_TrI3    =   8195,
+    CV_IA64_TrI4    =   8196,
+    CV_IA64_TrI5    =   8197,
+    CV_IA64_TrI6    =   8198,
+    CV_IA64_TrI7    =   8199,
+
+    // Data Translation Registers
+
+    CV_IA64_TrD0    =   8320,
+    CV_IA64_TrD1    =   8321,
+    CV_IA64_TrD2    =   8322,
+    CV_IA64_TrD3    =   8323,
+    CV_IA64_TrD4    =   8324,
+    CV_IA64_TrD5    =   8325,
+    CV_IA64_TrD6    =   8326,
+    CV_IA64_TrD7    =   8327,
+
+    // Instruction Breakpoint Registers
+
+    CV_IA64_DbI0    =   8448,
+    CV_IA64_DbI1    =   8449,
+    CV_IA64_DbI2    =   8450,
+    CV_IA64_DbI3    =   8451,
+    CV_IA64_DbI4    =   8452,
+    CV_IA64_DbI5    =   8453,
+    CV_IA64_DbI6    =   8454,
+    CV_IA64_DbI7    =   8455,
+
+    // Data Breakpoint Registers
+
+    CV_IA64_DbD0    =   8576,
+    CV_IA64_DbD1    =   8577,
+    CV_IA64_DbD2    =   8578,
+    CV_IA64_DbD3    =   8579,
+    CV_IA64_DbD4    =   8580,
+    CV_IA64_DbD5    =   8581,
+    CV_IA64_DbD6    =   8582,
+    CV_IA64_DbD7    =   8583,
+
+    //
+    // Register set for the TriCore processor.
+    //
+
+    CV_TRI_NOREG    =   CV_REG_NONE,
+
+    // General Purpose Data Registers
+
+    CV_TRI_D0   =   10,
+    CV_TRI_D1   =   11,
+    CV_TRI_D2   =   12,
+    CV_TRI_D3   =   13,
+    CV_TRI_D4   =   14,
+    CV_TRI_D5   =   15,
+    CV_TRI_D6   =   16,
+    CV_TRI_D7   =   17,
+    CV_TRI_D8   =   18,
+    CV_TRI_D9   =   19,
+    CV_TRI_D10  =   20,
+    CV_TRI_D11  =   21,
+    CV_TRI_D12  =   22,
+    CV_TRI_D13  =   23,
+    CV_TRI_D14  =   24,
+    CV_TRI_D15  =   25,
+
+    // General Purpose Address Registers
+
+    CV_TRI_A0   =   26,
+    CV_TRI_A1   =   27,
+    CV_TRI_A2   =   28,
+    CV_TRI_A3   =   29,
+    CV_TRI_A4   =   30,
+    CV_TRI_A5   =   31,
+    CV_TRI_A6   =   32,
+    CV_TRI_A7   =   33,
+    CV_TRI_A8   =   34,
+    CV_TRI_A9   =   35,
+    CV_TRI_A10  =   36,
+    CV_TRI_A11  =   37,
+    CV_TRI_A12  =   38,
+    CV_TRI_A13  =   39,
+    CV_TRI_A14  =   40,
+    CV_TRI_A15  =   41,
+
+    // Extended (64-bit) data registers
+
+    CV_TRI_E0   =   42,
+    CV_TRI_E2   =   43,
+    CV_TRI_E4   =   44,
+    CV_TRI_E6   =   45,
+    CV_TRI_E8   =   46,
+    CV_TRI_E10  =   47,
+    CV_TRI_E12  =   48,
+    CV_TRI_E14  =   49,
+
+    // Extended (64-bit) address registers
+
+    CV_TRI_EA0  =   50,
+    CV_TRI_EA2  =   51,
+    CV_TRI_EA4  =   52,
+    CV_TRI_EA6  =   53,
+    CV_TRI_EA8  =   54,
+    CV_TRI_EA10 =   55,
+    CV_TRI_EA12 =   56,
+    CV_TRI_EA14 =   57,
+
+    CV_TRI_PSW  =   58,
+    CV_TRI_PCXI =   59,
+    CV_TRI_PC   =   60,
+    CV_TRI_FCX  =   61,
+    CV_TRI_LCX  =   62,
+    CV_TRI_ISP  =   63,
+    CV_TRI_ICR  =   64,
+    CV_TRI_BIV  =   65,
+    CV_TRI_BTV  =   66,
+    CV_TRI_SYSCON   =   67,
+    CV_TRI_DPRx_0   =   68,
+    CV_TRI_DPRx_1   =   69,
+    CV_TRI_DPRx_2   =   70,
+    CV_TRI_DPRx_3   =   71,
+    CV_TRI_CPRx_0   =   68,
+    CV_TRI_CPRx_1   =   69,
+    CV_TRI_CPRx_2   =   70,
+    CV_TRI_CPRx_3   =   71,
+    CV_TRI_DPMx_0   =   68,
+    CV_TRI_DPMx_1   =   69,
+    CV_TRI_DPMx_2   =   70,
+    CV_TRI_DPMx_3   =   71,
+    CV_TRI_CPMx_0   =   68,
+    CV_TRI_CPMx_1   =   69,
+    CV_TRI_CPMx_2   =   70,
+    CV_TRI_CPMx_3   =   71,
+    CV_TRI_DBGSSR   =   72,
+    CV_TRI_EXEVT    =   73,
+    CV_TRI_SWEVT    =   74,
+    CV_TRI_CREVT    =   75,
+    CV_TRI_TRnEVT   =   76,
+    CV_TRI_MMUCON   =   77,
+    CV_TRI_ASI      =   78,
+    CV_TRI_TVA      =   79,
+    CV_TRI_TPA      =   80,
+    CV_TRI_TPX      =   81,
+    CV_TRI_TFA      =   82,
+
+    //
+    // Register set for the AM33 and related processors.
+    //
+
+    CV_AM33_NOREG   =   CV_REG_NONE,
+
+    // "Extended" (general purpose integer) registers
+    CV_AM33_E0      =   10,
+    CV_AM33_E1      =   11,
+    CV_AM33_E2      =   12,
+    CV_AM33_E3      =   13,
+    CV_AM33_E4      =   14,
+    CV_AM33_E5      =   15,
+    CV_AM33_E6      =   16,
+    CV_AM33_E7      =   17,
+
+    // Address registers
+    CV_AM33_A0      =   20,
+    CV_AM33_A1      =   21,
+    CV_AM33_A2      =   22,
+    CV_AM33_A3      =   23,
+
+    // Integer data registers
+    CV_AM33_D0      =   30,
+    CV_AM33_D1      =   31,
+    CV_AM33_D2      =   32,
+    CV_AM33_D3      =   33,
+
+    // (Single-precision) floating-point registers
+    CV_AM33_FS0     =   40,
+    CV_AM33_FS1     =   41,
+    CV_AM33_FS2     =   42,
+    CV_AM33_FS3     =   43,
+    CV_AM33_FS4     =   44,
+    CV_AM33_FS5     =   45,
+    CV_AM33_FS6     =   46,
+    CV_AM33_FS7     =   47,
+    CV_AM33_FS8     =   48,
+    CV_AM33_FS9     =   49,
+    CV_AM33_FS10    =   50,
+    CV_AM33_FS11    =   51,
+    CV_AM33_FS12    =   52,
+    CV_AM33_FS13    =   53,
+    CV_AM33_FS14    =   54,
+    CV_AM33_FS15    =   55,
+    CV_AM33_FS16    =   56,
+    CV_AM33_FS17    =   57,
+    CV_AM33_FS18    =   58,
+    CV_AM33_FS19    =   59,
+    CV_AM33_FS20    =   60,
+    CV_AM33_FS21    =   61,
+    CV_AM33_FS22    =   62,
+    CV_AM33_FS23    =   63,
+    CV_AM33_FS24    =   64,
+    CV_AM33_FS25    =   65,
+    CV_AM33_FS26    =   66,
+    CV_AM33_FS27    =   67,
+    CV_AM33_FS28    =   68,
+    CV_AM33_FS29    =   69,
+    CV_AM33_FS30    =   70,
+    CV_AM33_FS31    =   71,
+
+    // Special purpose registers
+
+    // Stack pointer
+    CV_AM33_SP      =   80,
+
+    // Program counter
+    CV_AM33_PC      =   81,
+
+    // Multiply-divide/accumulate registers
+    CV_AM33_MDR     =   82,
+    CV_AM33_MDRQ    =   83,
+    CV_AM33_MCRH    =   84,
+    CV_AM33_MCRL    =   85,
+    CV_AM33_MCVF    =   86,
+
+    // CPU status words
+    CV_AM33_EPSW    =   87,
+    CV_AM33_FPCR    =   88,
+
+    // Loop buffer registers
+    CV_AM33_LIR     =   89,
+    CV_AM33_LAR     =   90,
+
+    //
+    // Register set for the Mitsubishi M32R
+    //
+
+    CV_M32R_NOREG    =   CV_REG_NONE,
+
+    CV_M32R_R0    =   10,
+    CV_M32R_R1    =   11,
+    CV_M32R_R2    =   12,
+    CV_M32R_R3    =   13,
+    CV_M32R_R4    =   14,
+    CV_M32R_R5    =   15,
+    CV_M32R_R6    =   16,
+    CV_M32R_R7    =   17,
+    CV_M32R_R8    =   18,
+    CV_M32R_R9    =   19,
+    CV_M32R_R10   =   20,
+    CV_M32R_R11   =   21,
+    CV_M32R_R12   =   22,   // Gloabal Pointer, if used
+    CV_M32R_R13   =   23,   // Frame Pointer, if allocated
+    CV_M32R_R14   =   24,   // Link Register
+    CV_M32R_R15   =   25,   // Stack Pointer
+    CV_M32R_PSW   =   26,   // Preocessor Status Register
+    CV_M32R_CBR   =   27,   // Condition Bit Register
+    CV_M32R_SPI   =   28,   // Interrupt Stack Pointer
+    CV_M32R_SPU   =   29,   // User Stack Pointer
+    CV_M32R_SPO   =   30,   // OS Stack Pointer
+    CV_M32R_BPC   =   31,   // Backup Program Counter
+    CV_M32R_ACHI  =   32,   // Accumulator High
+    CV_M32R_ACLO  =   33,   // Accumulator Low
+    CV_M32R_PC    =   34,   // Program Counter
+
+    //
+    // Register set for the SuperH SHMedia processor including compact
+    // mode
+    //
+
+    // Integer - 64 bit general registers
+    CV_SHMEDIA_NOREG   =   CV_REG_NONE,
+    CV_SHMEDIA_R0      =   10,
+    CV_SHMEDIA_R1      =   11,
+    CV_SHMEDIA_R2      =   12,
+    CV_SHMEDIA_R3      =   13,
+    CV_SHMEDIA_R4      =   14,
+    CV_SHMEDIA_R5      =   15,
+    CV_SHMEDIA_R6      =   16,
+    CV_SHMEDIA_R7      =   17,
+    CV_SHMEDIA_R8      =   18,
+    CV_SHMEDIA_R9      =   19,
+    CV_SHMEDIA_R10     =   20,
+    CV_SHMEDIA_R11     =   21,
+    CV_SHMEDIA_R12     =   22,
+    CV_SHMEDIA_R13     =   23,
+    CV_SHMEDIA_R14     =   24,
+    CV_SHMEDIA_R15     =   25,
+    CV_SHMEDIA_R16     =   26,
+    CV_SHMEDIA_R17     =   27,
+    CV_SHMEDIA_R18     =   28,
+    CV_SHMEDIA_R19     =   29,
+    CV_SHMEDIA_R20     =   30,
+    CV_SHMEDIA_R21     =   31,
+    CV_SHMEDIA_R22     =   32,
+    CV_SHMEDIA_R23     =   33,
+    CV_SHMEDIA_R24     =   34,
+    CV_SHMEDIA_R25     =   35,
+    CV_SHMEDIA_R26     =   36,
+    CV_SHMEDIA_R27     =   37,
+    CV_SHMEDIA_R28     =   38,
+    CV_SHMEDIA_R29     =   39,
+    CV_SHMEDIA_R30     =   40,
+    CV_SHMEDIA_R31     =   41,
+    CV_SHMEDIA_R32     =   42,
+    CV_SHMEDIA_R33     =   43,
+    CV_SHMEDIA_R34     =   44,
+    CV_SHMEDIA_R35     =   45,
+    CV_SHMEDIA_R36     =   46,
+    CV_SHMEDIA_R37     =   47,
+    CV_SHMEDIA_R38     =   48,
+    CV_SHMEDIA_R39     =   49,
+    CV_SHMEDIA_R40     =   50,
+    CV_SHMEDIA_R41     =   51,
+    CV_SHMEDIA_R42     =   52,
+    CV_SHMEDIA_R43     =   53,
+    CV_SHMEDIA_R44     =   54,
+    CV_SHMEDIA_R45     =   55,
+    CV_SHMEDIA_R46     =   56,
+    CV_SHMEDIA_R47     =   57,
+    CV_SHMEDIA_R48     =   58,
+    CV_SHMEDIA_R49     =   59,
+    CV_SHMEDIA_R50     =   60,
+    CV_SHMEDIA_R51     =   61,
+    CV_SHMEDIA_R52     =   62,
+    CV_SHMEDIA_R53     =   63,
+    CV_SHMEDIA_R54     =   64,
+    CV_SHMEDIA_R55     =   65,
+    CV_SHMEDIA_R56     =   66,
+    CV_SHMEDIA_R57     =   67,
+    CV_SHMEDIA_R58     =   68,
+    CV_SHMEDIA_R59     =   69,
+    CV_SHMEDIA_R60     =   70,
+    CV_SHMEDIA_R61     =   71,
+    CV_SHMEDIA_R62     =   72,
+    CV_SHMEDIA_R63     =   73,
+    
+    // Target Registers - 32 bit
+    CV_SHMEDIA_TR0     =   74,
+    CV_SHMEDIA_TR1     =   75,
+    CV_SHMEDIA_TR2     =   76,
+    CV_SHMEDIA_TR3     =   77,
+    CV_SHMEDIA_TR4     =   78,
+    CV_SHMEDIA_TR5     =   79,
+    CV_SHMEDIA_TR6     =   80,
+    CV_SHMEDIA_TR7     =   81,
+    CV_SHMEDIA_TR8     =   82, // future-proof
+    CV_SHMEDIA_TR9     =   83, // future-proof
+    CV_SHMEDIA_TR10    =   84, // future-proof
+    CV_SHMEDIA_TR11    =   85, // future-proof
+    CV_SHMEDIA_TR12    =   86, // future-proof
+    CV_SHMEDIA_TR13    =   87, // future-proof
+    CV_SHMEDIA_TR14    =   88, // future-proof
+    CV_SHMEDIA_TR15    =   89, // future-proof
+
+    // Single - 32 bit fp registers
+    CV_SHMEDIA_FR0     =   128,
+    CV_SHMEDIA_FR1     =   129,
+    CV_SHMEDIA_FR2     =   130,
+    CV_SHMEDIA_FR3     =   131,
+    CV_SHMEDIA_FR4     =   132,
+    CV_SHMEDIA_FR5     =   133,
+    CV_SHMEDIA_FR6     =   134,
+    CV_SHMEDIA_FR7     =   135,
+    CV_SHMEDIA_FR8     =   136,
+    CV_SHMEDIA_FR9     =   137,
+    CV_SHMEDIA_FR10    =   138,
+    CV_SHMEDIA_FR11    =   139,
+    CV_SHMEDIA_FR12    =   140,
+    CV_SHMEDIA_FR13    =   141,
+    CV_SHMEDIA_FR14    =   142,
+    CV_SHMEDIA_FR15    =   143,
+    CV_SHMEDIA_FR16    =   144,
+    CV_SHMEDIA_FR17    =   145,
+    CV_SHMEDIA_FR18    =   146,
+    CV_SHMEDIA_FR19    =   147,
+    CV_SHMEDIA_FR20    =   148,
+    CV_SHMEDIA_FR21    =   149,
+    CV_SHMEDIA_FR22    =   150,
+    CV_SHMEDIA_FR23    =   151,
+    CV_SHMEDIA_FR24    =   152,
+    CV_SHMEDIA_FR25    =   153,
+    CV_SHMEDIA_FR26    =   154,
+    CV_SHMEDIA_FR27    =   155,
+    CV_SHMEDIA_FR28    =   156,
+    CV_SHMEDIA_FR29    =   157,
+    CV_SHMEDIA_FR30    =   158,
+    CV_SHMEDIA_FR31    =   159,
+    CV_SHMEDIA_FR32    =   160,
+    CV_SHMEDIA_FR33    =   161,
+    CV_SHMEDIA_FR34    =   162,
+    CV_SHMEDIA_FR35    =   163,
+    CV_SHMEDIA_FR36    =   164,
+    CV_SHMEDIA_FR37    =   165,
+    CV_SHMEDIA_FR38    =   166,
+    CV_SHMEDIA_FR39    =   167,
+    CV_SHMEDIA_FR40    =   168,
+    CV_SHMEDIA_FR41    =   169,
+    CV_SHMEDIA_FR42    =   170,
+    CV_SHMEDIA_FR43    =   171,
+    CV_SHMEDIA_FR44    =   172,
+    CV_SHMEDIA_FR45    =   173,
+    CV_SHMEDIA_FR46    =   174,
+    CV_SHMEDIA_FR47    =   175,
+    CV_SHMEDIA_FR48    =   176,
+    CV_SHMEDIA_FR49    =   177,
+    CV_SHMEDIA_FR50    =   178,
+    CV_SHMEDIA_FR51    =   179,
+    CV_SHMEDIA_FR52    =   180,
+    CV_SHMEDIA_FR53    =   181,
+    CV_SHMEDIA_FR54    =   182,
+    CV_SHMEDIA_FR55    =   183,
+    CV_SHMEDIA_FR56    =   184,
+    CV_SHMEDIA_FR57    =   185,
+    CV_SHMEDIA_FR58    =   186,
+    CV_SHMEDIA_FR59    =   187,
+    CV_SHMEDIA_FR60    =   188,
+    CV_SHMEDIA_FR61    =   189,
+    CV_SHMEDIA_FR62    =   190,
+    CV_SHMEDIA_FR63    =   191,
+
+    // Double - 64 bit synonyms for 32bit fp register pairs
+    //          subtract 128 to find first base single register
+    CV_SHMEDIA_DR0     =   256,
+    CV_SHMEDIA_DR2     =   258,
+    CV_SHMEDIA_DR4     =   260,
+    CV_SHMEDIA_DR6     =   262,
+    CV_SHMEDIA_DR8     =   264,
+    CV_SHMEDIA_DR10    =   266,
+    CV_SHMEDIA_DR12    =   268,
+    CV_SHMEDIA_DR14    =   270,
+    CV_SHMEDIA_DR16    =   272,
+    CV_SHMEDIA_DR18    =   274,
+    CV_SHMEDIA_DR20    =   276,
+    CV_SHMEDIA_DR22    =   278,
+    CV_SHMEDIA_DR24    =   280,
+    CV_SHMEDIA_DR26    =   282,
+    CV_SHMEDIA_DR28    =   284,
+    CV_SHMEDIA_DR30    =   286,
+    CV_SHMEDIA_DR32    =   288,
+    CV_SHMEDIA_DR34    =   290,
+    CV_SHMEDIA_DR36    =   292,
+    CV_SHMEDIA_DR38    =   294,
+    CV_SHMEDIA_DR40    =   296,
+    CV_SHMEDIA_DR42    =   298,
+    CV_SHMEDIA_DR44    =   300,
+    CV_SHMEDIA_DR46    =   302,
+    CV_SHMEDIA_DR48    =   304,
+    CV_SHMEDIA_DR50    =   306,
+    CV_SHMEDIA_DR52    =   308,
+    CV_SHMEDIA_DR54    =   310,
+    CV_SHMEDIA_DR56    =   312,
+    CV_SHMEDIA_DR58    =   314,
+    CV_SHMEDIA_DR60    =   316,
+    CV_SHMEDIA_DR62    =   318,
+
+    // Vector - 128 bit synonyms for 32bit fp register quads
+    //          subtract 384 to find first base single register
+    CV_SHMEDIA_FV0     =   512,
+    CV_SHMEDIA_FV4     =   516,
+    CV_SHMEDIA_FV8     =   520,
+    CV_SHMEDIA_FV12    =   524,
+    CV_SHMEDIA_FV16    =   528,
+    CV_SHMEDIA_FV20    =   532,
+    CV_SHMEDIA_FV24    =   536,
+    CV_SHMEDIA_FV28    =   540,
+    CV_SHMEDIA_FV32    =   544,
+    CV_SHMEDIA_FV36    =   548,
+    CV_SHMEDIA_FV40    =   552,
+    CV_SHMEDIA_FV44    =   556,
+    CV_SHMEDIA_FV48    =   560,
+    CV_SHMEDIA_FV52    =   564,
+    CV_SHMEDIA_FV56    =   568,
+    CV_SHMEDIA_FV60    =   572,
+
+    // Matrix - 512 bit synonyms for 16 adjacent 32bit fp registers
+    //          subtract 896 to find first base single register
+    CV_SHMEDIA_MTRX0   =   1024,
+    CV_SHMEDIA_MTRX16  =   1040,
+    CV_SHMEDIA_MTRX32  =   1056,
+    CV_SHMEDIA_MTRX48  =   1072,
+
+    // Control - Implementation defined 64bit control registers
+    CV_SHMEDIA_CR0     =   2000,
+    CV_SHMEDIA_CR1     =   2001,
+    CV_SHMEDIA_CR2     =   2002,
+    CV_SHMEDIA_CR3     =   2003,
+    CV_SHMEDIA_CR4     =   2004,
+    CV_SHMEDIA_CR5     =   2005,
+    CV_SHMEDIA_CR6     =   2006,
+    CV_SHMEDIA_CR7     =   2007,
+    CV_SHMEDIA_CR8     =   2008,
+    CV_SHMEDIA_CR9     =   2009,
+    CV_SHMEDIA_CR10    =   2010,
+    CV_SHMEDIA_CR11    =   2011,
+    CV_SHMEDIA_CR12    =   2012,
+    CV_SHMEDIA_CR13    =   2013,
+    CV_SHMEDIA_CR14    =   2014,
+    CV_SHMEDIA_CR15    =   2015,
+    CV_SHMEDIA_CR16    =   2016,
+    CV_SHMEDIA_CR17    =   2017,
+    CV_SHMEDIA_CR18    =   2018,
+    CV_SHMEDIA_CR19    =   2019,
+    CV_SHMEDIA_CR20    =   2020,
+    CV_SHMEDIA_CR21    =   2021,
+    CV_SHMEDIA_CR22    =   2022,
+    CV_SHMEDIA_CR23    =   2023,
+    CV_SHMEDIA_CR24    =   2024,
+    CV_SHMEDIA_CR25    =   2025,
+    CV_SHMEDIA_CR26    =   2026,
+    CV_SHMEDIA_CR27    =   2027,
+    CV_SHMEDIA_CR28    =   2028,
+    CV_SHMEDIA_CR29    =   2029,
+    CV_SHMEDIA_CR30    =   2030,
+    CV_SHMEDIA_CR31    =   2031,
+    CV_SHMEDIA_CR32    =   2032,
+    CV_SHMEDIA_CR33    =   2033,
+    CV_SHMEDIA_CR34    =   2034,
+    CV_SHMEDIA_CR35    =   2035,
+    CV_SHMEDIA_CR36    =   2036,
+    CV_SHMEDIA_CR37    =   2037,
+    CV_SHMEDIA_CR38    =   2038,
+    CV_SHMEDIA_CR39    =   2039,
+    CV_SHMEDIA_CR40    =   2040,
+    CV_SHMEDIA_CR41    =   2041,
+    CV_SHMEDIA_CR42    =   2042,
+    CV_SHMEDIA_CR43    =   2043,
+    CV_SHMEDIA_CR44    =   2044,
+    CV_SHMEDIA_CR45    =   2045,
+    CV_SHMEDIA_CR46    =   2046,
+    CV_SHMEDIA_CR47    =   2047,
+    CV_SHMEDIA_CR48    =   2048,
+    CV_SHMEDIA_CR49    =   2049,
+    CV_SHMEDIA_CR50    =   2050,
+    CV_SHMEDIA_CR51    =   2051,
+    CV_SHMEDIA_CR52    =   2052,
+    CV_SHMEDIA_CR53    =   2053,
+    CV_SHMEDIA_CR54    =   2054,
+    CV_SHMEDIA_CR55    =   2055,
+    CV_SHMEDIA_CR56    =   2056,
+    CV_SHMEDIA_CR57    =   2057,
+    CV_SHMEDIA_CR58    =   2058,
+    CV_SHMEDIA_CR59    =   2059,
+    CV_SHMEDIA_CR60    =   2060,
+    CV_SHMEDIA_CR61    =   2061,
+    CV_SHMEDIA_CR62    =   2062,
+    CV_SHMEDIA_CR63    =   2063,
+
+    CV_SHMEDIA_FPSCR   =   2064,
+
+    // Compact mode synonyms
+    CV_SHMEDIA_GBR     =   CV_SHMEDIA_R16,
+    CV_SHMEDIA_MACL    =   90, // synonym for lower 32bits of media R17
+    CV_SHMEDIA_MACH    =   91, // synonym for upper 32bits of media R17
+    CV_SHMEDIA_PR      =   CV_SHMEDIA_R18,
+    CV_SHMEDIA_T       =   92, // synonym for lowest bit of media R19
+    CV_SHMEDIA_FPUL    =   CV_SHMEDIA_FR32,
+    CV_SHMEDIA_PC      =   93,
+    CV_SHMEDIA_SR      =   CV_SHMEDIA_CR0,
+
+    //
+    // AMD64 registers
+    //
+
+    CV_AMD64_AL       =   1,
+    CV_AMD64_CL       =   2,
+    CV_AMD64_DL       =   3,
+    CV_AMD64_BL       =   4,
+    CV_AMD64_AH       =   5,
+    CV_AMD64_CH       =   6,
+    CV_AMD64_DH       =   7,
+    CV_AMD64_BH       =   8,
+    CV_AMD64_AX       =   9,
+    CV_AMD64_CX       =  10,
+    CV_AMD64_DX       =  11,
+    CV_AMD64_BX       =  12,
+    CV_AMD64_SP       =  13,
+    CV_AMD64_BP       =  14,
+    CV_AMD64_SI       =  15,
+    CV_AMD64_DI       =  16,
+    CV_AMD64_EAX      =  17,
+    CV_AMD64_ECX      =  18,
+    CV_AMD64_EDX      =  19,
+    CV_AMD64_EBX      =  20,
+    CV_AMD64_ESP      =  21,
+    CV_AMD64_EBP      =  22,
+    CV_AMD64_ESI      =  23,
+    CV_AMD64_EDI      =  24,
+    CV_AMD64_ES       =  25,
+    CV_AMD64_CS       =  26,
+    CV_AMD64_SS       =  27,
+    CV_AMD64_DS       =  28,
+    CV_AMD64_FS       =  29,
+    CV_AMD64_GS       =  30,
+    CV_AMD64_FLAGS    =  32,
+    CV_AMD64_RIP      =  33,
+    CV_AMD64_EFLAGS   =  34,
+
+    // Control registers
+    CV_AMD64_CR0      =  80,
+    CV_AMD64_CR1      =  81,
+    CV_AMD64_CR2      =  82,
+    CV_AMD64_CR3      =  83,
+    CV_AMD64_CR4      =  84,
+    CV_AMD64_CR8      =  88,
+
+    // Debug registers
+    CV_AMD64_DR0      =  90,
+    CV_AMD64_DR1      =  91,
+    CV_AMD64_DR2      =  92,
+    CV_AMD64_DR3      =  93,
+    CV_AMD64_DR4      =  94,
+    CV_AMD64_DR5      =  95,
+    CV_AMD64_DR6      =  96,
+    CV_AMD64_DR7      =  97,
+    CV_AMD64_DR8      =  98,
+    CV_AMD64_DR9      =  99,
+    CV_AMD64_DR10     =  100,
+    CV_AMD64_DR11     =  101,
+    CV_AMD64_DR12     =  102,
+    CV_AMD64_DR13     =  103,
+    CV_AMD64_DR14     =  104,
+    CV_AMD64_DR15     =  105,
+
+    CV_AMD64_GDTR     =  110,
+    CV_AMD64_GDTL     =  111,
+    CV_AMD64_IDTR     =  112,
+    CV_AMD64_IDTL     =  113,
+    CV_AMD64_LDTR     =  114,
+    CV_AMD64_TR       =  115,
+
+    CV_AMD64_ST0      =  128,
+    CV_AMD64_ST1      =  129,
+    CV_AMD64_ST2      =  130,
+    CV_AMD64_ST3      =  131,
+    CV_AMD64_ST4      =  132,
+    CV_AMD64_ST5      =  133,
+    CV_AMD64_ST6      =  134,
+    CV_AMD64_ST7      =  135,
+    CV_AMD64_CTRL     =  136,
+    CV_AMD64_STAT     =  137,
+    CV_AMD64_TAG      =  138,
+    CV_AMD64_FPIP     =  139,
+    CV_AMD64_FPCS     =  140,
+    CV_AMD64_FPDO     =  141,
+    CV_AMD64_FPDS     =  142,
+    CV_AMD64_ISEM     =  143,
+    CV_AMD64_FPEIP    =  144,
+    CV_AMD64_FPEDO    =  145,
+
+    CV_AMD64_MM0      =  146,
+    CV_AMD64_MM1      =  147,
+    CV_AMD64_MM2      =  148,
+    CV_AMD64_MM3      =  149,
+    CV_AMD64_MM4      =  150,
+    CV_AMD64_MM5      =  151,
+    CV_AMD64_MM6      =  152,
+    CV_AMD64_MM7      =  153,
+
+    CV_AMD64_XMM0     =  154,   // KATMAI registers
+    CV_AMD64_XMM1     =  155,
+    CV_AMD64_XMM2     =  156,
+    CV_AMD64_XMM3     =  157,
+    CV_AMD64_XMM4     =  158,
+    CV_AMD64_XMM5     =  159,
+    CV_AMD64_XMM6     =  160,
+    CV_AMD64_XMM7     =  161,
+
+    CV_AMD64_XMM0_0   =  162,   // KATMAI sub-registers
+    CV_AMD64_XMM0_1   =  163,
+    CV_AMD64_XMM0_2   =  164,
+    CV_AMD64_XMM0_3   =  165,
+    CV_AMD64_XMM1_0   =  166,
+    CV_AMD64_XMM1_1   =  167,
+    CV_AMD64_XMM1_2   =  168,
+    CV_AMD64_XMM1_3   =  169,
+    CV_AMD64_XMM2_0   =  170,
+    CV_AMD64_XMM2_1   =  171,
+    CV_AMD64_XMM2_2   =  172,
+    CV_AMD64_XMM2_3   =  173,
+    CV_AMD64_XMM3_0   =  174,
+    CV_AMD64_XMM3_1   =  175,
+    CV_AMD64_XMM3_2   =  176,
+    CV_AMD64_XMM3_3   =  177,
+    CV_AMD64_XMM4_0   =  178,
+    CV_AMD64_XMM4_1   =  179,
+    CV_AMD64_XMM4_2   =  180,
+    CV_AMD64_XMM4_3   =  181,
+    CV_AMD64_XMM5_0   =  182,
+    CV_AMD64_XMM5_1   =  183,
+    CV_AMD64_XMM5_2   =  184,
+    CV_AMD64_XMM5_3   =  185,
+    CV_AMD64_XMM6_0   =  186,
+    CV_AMD64_XMM6_1   =  187,
+    CV_AMD64_XMM6_2   =  188,
+    CV_AMD64_XMM6_3   =  189,
+    CV_AMD64_XMM7_0   =  190,
+    CV_AMD64_XMM7_1   =  191,
+    CV_AMD64_XMM7_2   =  192,
+    CV_AMD64_XMM7_3   =  193,
+
+    CV_AMD64_XMM0L    =  194,
+    CV_AMD64_XMM1L    =  195,
+    CV_AMD64_XMM2L    =  196,
+    CV_AMD64_XMM3L    =  197,
+    CV_AMD64_XMM4L    =  198,
+    CV_AMD64_XMM5L    =  199,
+    CV_AMD64_XMM6L    =  200,
+    CV_AMD64_XMM7L    =  201,
+
+    CV_AMD64_XMM0H    =  202,
+    CV_AMD64_XMM1H    =  203,
+    CV_AMD64_XMM2H    =  204,
+    CV_AMD64_XMM3H    =  205,
+    CV_AMD64_XMM4H    =  206,
+    CV_AMD64_XMM5H    =  207,
+    CV_AMD64_XMM6H    =  208,
+    CV_AMD64_XMM7H    =  209,
+
+    CV_AMD64_MXCSR    =  211,   // XMM status register
+
+    CV_AMD64_EMM0L    =  220,   // XMM sub-registers (WNI integer)
+    CV_AMD64_EMM1L    =  221,
+    CV_AMD64_EMM2L    =  222,
+    CV_AMD64_EMM3L    =  223,
+    CV_AMD64_EMM4L    =  224,
+    CV_AMD64_EMM5L    =  225,
+    CV_AMD64_EMM6L    =  226,
+    CV_AMD64_EMM7L    =  227,
+
+    CV_AMD64_EMM0H    =  228,
+    CV_AMD64_EMM1H    =  229,
+    CV_AMD64_EMM2H    =  230,
+    CV_AMD64_EMM3H    =  231,
+    CV_AMD64_EMM4H    =  232,
+    CV_AMD64_EMM5H    =  233,
+    CV_AMD64_EMM6H    =  234,
+    CV_AMD64_EMM7H    =  235,
+
+    // do not change the order of these regs, first one must be even too
+    CV_AMD64_MM00     =  236,
+    CV_AMD64_MM01     =  237,
+    CV_AMD64_MM10     =  238,
+    CV_AMD64_MM11     =  239,
+    CV_AMD64_MM20     =  240,
+    CV_AMD64_MM21     =  241,
+    CV_AMD64_MM30     =  242,
+    CV_AMD64_MM31     =  243,
+    CV_AMD64_MM40     =  244,
+    CV_AMD64_MM41     =  245,
+    CV_AMD64_MM50     =  246,
+    CV_AMD64_MM51     =  247,
+    CV_AMD64_MM60     =  248,
+    CV_AMD64_MM61     =  249,
+    CV_AMD64_MM70     =  250,
+    CV_AMD64_MM71     =  251,
+
+    // Extended KATMAI registers
+    CV_AMD64_XMM8     =  252,   // KATMAI registers
+    CV_AMD64_XMM9     =  253,
+    CV_AMD64_XMM10    =  254,
+    CV_AMD64_XMM11    =  255,
+    CV_AMD64_XMM12    =  256,
+    CV_AMD64_XMM13    =  257,
+    CV_AMD64_XMM14    =  258,
+    CV_AMD64_XMM15    =  259,
+
+    CV_AMD64_XMM8_0   =  260,   // KATMAI sub-registers
+    CV_AMD64_XMM8_1   =  261,
+    CV_AMD64_XMM8_2   =  262,
+    CV_AMD64_XMM8_3   =  263,
+    CV_AMD64_XMM9_0   =  264,
+    CV_AMD64_XMM9_1   =  265,
+    CV_AMD64_XMM9_2   =  266,
+    CV_AMD64_XMM9_3   =  267,
+    CV_AMD64_XMM10_0  =  268,
+    CV_AMD64_XMM10_1  =  269,
+    CV_AMD64_XMM10_2  =  270,
+    CV_AMD64_XMM10_3  =  271,
+    CV_AMD64_XMM11_0  =  272,
+    CV_AMD64_XMM11_1  =  273,
+    CV_AMD64_XMM11_2  =  274,
+    CV_AMD64_XMM11_3  =  275,
+    CV_AMD64_XMM12_0  =  276,
+    CV_AMD64_XMM12_1  =  277,
+    CV_AMD64_XMM12_2  =  278,
+    CV_AMD64_XMM12_3  =  279,
+    CV_AMD64_XMM13_0  =  280,
+    CV_AMD64_XMM13_1  =  281,
+    CV_AMD64_XMM13_2  =  282,
+    CV_AMD64_XMM13_3  =  283,
+    CV_AMD64_XMM14_0  =  284,
+    CV_AMD64_XMM14_1  =  285,
+    CV_AMD64_XMM14_2  =  286,
+    CV_AMD64_XMM14_3  =  287,
+    CV_AMD64_XMM15_0  =  288,
+    CV_AMD64_XMM15_1  =  289,
+    CV_AMD64_XMM15_2  =  290,
+    CV_AMD64_XMM15_3  =  291,
+
+    CV_AMD64_XMM8L    =  292,
+    CV_AMD64_XMM9L    =  293,
+    CV_AMD64_XMM10L   =  294,
+    CV_AMD64_XMM11L   =  295,
+    CV_AMD64_XMM12L   =  296,
+    CV_AMD64_XMM13L   =  297,
+    CV_AMD64_XMM14L   =  298,
+    CV_AMD64_XMM15L   =  299,
+
+    CV_AMD64_XMM8H    =  300,
+    CV_AMD64_XMM9H    =  301,
+    CV_AMD64_XMM10H   =  302,
+    CV_AMD64_XMM11H   =  303,
+    CV_AMD64_XMM12H   =  304,
+    CV_AMD64_XMM13H   =  305,
+    CV_AMD64_XMM14H   =  306,
+    CV_AMD64_XMM15H   =  307,
+
+    CV_AMD64_EMM8L    =  308,   // XMM sub-registers (WNI integer)
+    CV_AMD64_EMM9L    =  309,
+    CV_AMD64_EMM10L   =  310,
+    CV_AMD64_EMM11L   =  311,
+    CV_AMD64_EMM12L   =  312,
+    CV_AMD64_EMM13L   =  313,
+    CV_AMD64_EMM14L   =  314,
+    CV_AMD64_EMM15L   =  315,
+
+    CV_AMD64_EMM8H    =  316,
+    CV_AMD64_EMM9H    =  317,
+    CV_AMD64_EMM10H   =  318,
+    CV_AMD64_EMM11H   =  319,
+    CV_AMD64_EMM12H   =  320,
+    CV_AMD64_EMM13H   =  321,
+    CV_AMD64_EMM14H   =  322,
+    CV_AMD64_EMM15H   =  323,
+
+    // Low byte forms of some standard registers
+    CV_AMD64_SIL      =  324,
+    CV_AMD64_DIL      =  325,
+    CV_AMD64_BPL      =  326,
+    CV_AMD64_SPL      =  327,
+
+    // 64-bit regular registers
+    CV_AMD64_RAX      =  328,
+    CV_AMD64_RBX      =  329,
+    CV_AMD64_RCX      =  330,
+    CV_AMD64_RDX      =  331,
+    CV_AMD64_RSI      =  332,
+    CV_AMD64_RDI      =  333,
+    CV_AMD64_RBP      =  334,
+    CV_AMD64_RSP      =  335,
+
+    // 64-bit integer registers with 8-, 16-, and 32-bit forms (B, W, and D)
+    CV_AMD64_R8       =  336,
+    CV_AMD64_R9       =  337,
+    CV_AMD64_R10      =  338,
+    CV_AMD64_R11      =  339,
+    CV_AMD64_R12      =  340,
+    CV_AMD64_R13      =  341,
+    CV_AMD64_R14      =  342,
+    CV_AMD64_R15      =  343,
+
+    CV_AMD64_R8B      =  344,
+    CV_AMD64_R9B      =  345,
+    CV_AMD64_R10B     =  346,
+    CV_AMD64_R11B     =  347,
+    CV_AMD64_R12B     =  348,
+    CV_AMD64_R13B     =  349,
+    CV_AMD64_R14B     =  350,
+    CV_AMD64_R15B     =  351,
+
+    CV_AMD64_R8W      =  352,
+    CV_AMD64_R9W      =  353,
+    CV_AMD64_R10W     =  354,
+    CV_AMD64_R11W     =  355,
+    CV_AMD64_R12W     =  356,
+    CV_AMD64_R13W     =  357,
+    CV_AMD64_R14W     =  358,
+    CV_AMD64_R15W     =  359,
+
+    CV_AMD64_R8D      =  360,
+    CV_AMD64_R9D      =  361,
+    CV_AMD64_R10D     =  362,
+    CV_AMD64_R11D     =  363,
+    CV_AMD64_R12D     =  364,
+    CV_AMD64_R13D     =  365,
+    CV_AMD64_R14D     =  366,
+    CV_AMD64_R15D     =  367,
+
+    // AVX registers 256 bits
+    CV_AMD64_YMM0     =  368,
+    CV_AMD64_YMM1     =  369,
+    CV_AMD64_YMM2     =  370,
+    CV_AMD64_YMM3     =  371,
+    CV_AMD64_YMM4     =  372,
+    CV_AMD64_YMM5     =  373,
+    CV_AMD64_YMM6     =  374,
+    CV_AMD64_YMM7     =  375,
+    CV_AMD64_YMM8     =  376, 
+    CV_AMD64_YMM9     =  377,
+    CV_AMD64_YMM10    =  378,
+    CV_AMD64_YMM11    =  379,
+    CV_AMD64_YMM12    =  380,
+    CV_AMD64_YMM13    =  381,
+    CV_AMD64_YMM14    =  382,
+    CV_AMD64_YMM15    =  383,
+
+    // AVX registers upper 128 bits
+    CV_AMD64_YMM0H    =  384,
+    CV_AMD64_YMM1H    =  385,
+    CV_AMD64_YMM2H    =  386,
+    CV_AMD64_YMM3H    =  387,
+    CV_AMD64_YMM4H    =  388,
+    CV_AMD64_YMM5H    =  389,
+    CV_AMD64_YMM6H    =  390,
+    CV_AMD64_YMM7H    =  391,
+    CV_AMD64_YMM8H    =  392, 
+    CV_AMD64_YMM9H    =  393,
+    CV_AMD64_YMM10H   =  394,
+    CV_AMD64_YMM11H   =  395,
+    CV_AMD64_YMM12H   =  396,
+    CV_AMD64_YMM13H   =  397,
+    CV_AMD64_YMM14H   =  398,
+    CV_AMD64_YMM15H   =  399,
+
+    //Lower/upper 8 bytes of XMM registers.  Unlike CV_AMD64_XMM<regnum><H/L>, these
+    //values reprsesent the bit patterns of the registers as 64-bit integers, not
+    //the representation of these registers as a double.
+    CV_AMD64_XMM0IL    = 400,
+    CV_AMD64_XMM1IL    = 401,
+    CV_AMD64_XMM2IL    = 402,
+    CV_AMD64_XMM3IL    = 403,
+    CV_AMD64_XMM4IL    = 404,
+    CV_AMD64_XMM5IL    = 405,
+    CV_AMD64_XMM6IL    = 406,
+    CV_AMD64_XMM7IL    = 407,
+    CV_AMD64_XMM8IL    = 408,
+    CV_AMD64_XMM9IL    = 409,
+    CV_AMD64_XMM10IL    = 410,
+    CV_AMD64_XMM11IL    = 411,
+    CV_AMD64_XMM12IL    = 412,
+    CV_AMD64_XMM13IL    = 413,
+    CV_AMD64_XMM14IL    = 414,
+    CV_AMD64_XMM15IL    = 415,
+
+    CV_AMD64_XMM0IH    = 416,
+    CV_AMD64_XMM1IH    = 417,
+    CV_AMD64_XMM2IH    = 418,
+    CV_AMD64_XMM3IH    = 419,
+    CV_AMD64_XMM4IH    = 420,
+    CV_AMD64_XMM5IH    = 421,
+    CV_AMD64_XMM6IH    = 422,
+    CV_AMD64_XMM7IH    = 423,
+    CV_AMD64_XMM8IH    = 424,
+    CV_AMD64_XMM9IH    = 425,
+    CV_AMD64_XMM10IH    = 426,
+    CV_AMD64_XMM11IH    = 427,
+    CV_AMD64_XMM12IH    = 428,
+    CV_AMD64_XMM13IH    = 429,
+    CV_AMD64_XMM14IH    = 430,
+    CV_AMD64_XMM15IH    = 431,
+
+    CV_AMD64_YMM0I0    =  432,        // AVX integer registers
+    CV_AMD64_YMM0I1    =  433,
+    CV_AMD64_YMM0I2    =  434,
+    CV_AMD64_YMM0I3    =  435,
+    CV_AMD64_YMM1I0    =  436,
+    CV_AMD64_YMM1I1    =  437,
+    CV_AMD64_YMM1I2    =  438,
+    CV_AMD64_YMM1I3    =  439,
+    CV_AMD64_YMM2I0    =  440,
+    CV_AMD64_YMM2I1    =  441,
+    CV_AMD64_YMM2I2    =  442,
+    CV_AMD64_YMM2I3    =  443,
+    CV_AMD64_YMM3I0    =  444,
+    CV_AMD64_YMM3I1    =  445,
+    CV_AMD64_YMM3I2    =  446,
+    CV_AMD64_YMM3I3    =  447,
+    CV_AMD64_YMM4I0    =  448,
+    CV_AMD64_YMM4I1    =  449,
+    CV_AMD64_YMM4I2    =  450,
+    CV_AMD64_YMM4I3    =  451,
+    CV_AMD64_YMM5I0    =  452,
+    CV_AMD64_YMM5I1    =  453,
+    CV_AMD64_YMM5I2    =  454,
+    CV_AMD64_YMM5I3    =  455,
+    CV_AMD64_YMM6I0    =  456,
+    CV_AMD64_YMM6I1    =  457,
+    CV_AMD64_YMM6I2    =  458,
+    CV_AMD64_YMM6I3    =  459,
+    CV_AMD64_YMM7I0    =  460,
+    CV_AMD64_YMM7I1    =  461,
+    CV_AMD64_YMM7I2    =  462,
+    CV_AMD64_YMM7I3    =  463,
+    CV_AMD64_YMM8I0    =  464,
+    CV_AMD64_YMM8I1    =  465,
+    CV_AMD64_YMM8I2    =  466,
+    CV_AMD64_YMM8I3    =  467,
+    CV_AMD64_YMM9I0    =  468,
+    CV_AMD64_YMM9I1    =  469,
+    CV_AMD64_YMM9I2    =  470,
+    CV_AMD64_YMM9I3    =  471,
+    CV_AMD64_YMM10I0    =  472,
+    CV_AMD64_YMM10I1    =  473,
+    CV_AMD64_YMM10I2    =  474,
+    CV_AMD64_YMM10I3    =  475,
+    CV_AMD64_YMM11I0    =  476,
+    CV_AMD64_YMM11I1    =  477,
+    CV_AMD64_YMM11I2    =  478,
+    CV_AMD64_YMM11I3    =  479,
+    CV_AMD64_YMM12I0    =  480,
+    CV_AMD64_YMM12I1    =  481,
+    CV_AMD64_YMM12I2    =  482,
+    CV_AMD64_YMM12I3    =  483,
+    CV_AMD64_YMM13I0    =  484,
+    CV_AMD64_YMM13I1    =  485,
+    CV_AMD64_YMM13I2    =  486,
+    CV_AMD64_YMM13I3    =  487,
+    CV_AMD64_YMM14I0    =  488,
+    CV_AMD64_YMM14I1    =  489,
+    CV_AMD64_YMM14I2    =  490,
+    CV_AMD64_YMM14I3    =  491,
+    CV_AMD64_YMM15I0    =  492,
+    CV_AMD64_YMM15I1    =  493,
+    CV_AMD64_YMM15I2    =  494,
+    CV_AMD64_YMM15I3    =  495,
+
+    CV_AMD64_YMM0F0    =  496,        // AVX floating-point single precise registers
+    CV_AMD64_YMM0F1    =  497,
+    CV_AMD64_YMM0F2    =  498,
+    CV_AMD64_YMM0F3    =  499,
+    CV_AMD64_YMM0F4    =  500,
+    CV_AMD64_YMM0F5    =  501,
+    CV_AMD64_YMM0F6    =  502,
+    CV_AMD64_YMM0F7    =  503,
+    CV_AMD64_YMM1F0    =  504,
+    CV_AMD64_YMM1F1    =  505,
+    CV_AMD64_YMM1F2    =  506,
+    CV_AMD64_YMM1F3    =  507,
+    CV_AMD64_YMM1F4    =  508,
+    CV_AMD64_YMM1F5    =  509,
+    CV_AMD64_YMM1F6    =  510,
+    CV_AMD64_YMM1F7    =  511,
+    CV_AMD64_YMM2F0    =  512,
+    CV_AMD64_YMM2F1    =  513,
+    CV_AMD64_YMM2F2    =  514,
+    CV_AMD64_YMM2F3    =  515,
+    CV_AMD64_YMM2F4    =  516,
+    CV_AMD64_YMM2F5    =  517,
+    CV_AMD64_YMM2F6    =  518,
+    CV_AMD64_YMM2F7    =  519,
+    CV_AMD64_YMM3F0    =  520,
+    CV_AMD64_YMM3F1    =  521,
+    CV_AMD64_YMM3F2    =  522,
+    CV_AMD64_YMM3F3    =  523,
+    CV_AMD64_YMM3F4    =  524,
+    CV_AMD64_YMM3F5    =  525,
+    CV_AMD64_YMM3F6    =  526,
+    CV_AMD64_YMM3F7    =  527,
+    CV_AMD64_YMM4F0    =  528,
+    CV_AMD64_YMM4F1    =  529,
+    CV_AMD64_YMM4F2    =  530,
+    CV_AMD64_YMM4F3    =  531,
+    CV_AMD64_YMM4F4    =  532,
+    CV_AMD64_YMM4F5    =  533,
+    CV_AMD64_YMM4F6    =  534,
+    CV_AMD64_YMM4F7    =  535,
+    CV_AMD64_YMM5F0    =  536,
+    CV_AMD64_YMM5F1    =  537,
+    CV_AMD64_YMM5F2    =  538,
+    CV_AMD64_YMM5F3    =  539,
+    CV_AMD64_YMM5F4    =  540,
+    CV_AMD64_YMM5F5    =  541,
+    CV_AMD64_YMM5F6    =  542,
+    CV_AMD64_YMM5F7    =  543,
+    CV_AMD64_YMM6F0    =  544,
+    CV_AMD64_YMM6F1    =  545,
+    CV_AMD64_YMM6F2    =  546,
+    CV_AMD64_YMM6F3    =  547,
+    CV_AMD64_YMM6F4    =  548,
+    CV_AMD64_YMM6F5    =  549,
+    CV_AMD64_YMM6F6    =  550,
+    CV_AMD64_YMM6F7    =  551,
+    CV_AMD64_YMM7F0    =  552,
+    CV_AMD64_YMM7F1    =  553,
+    CV_AMD64_YMM7F2    =  554,
+    CV_AMD64_YMM7F3    =  555,
+    CV_AMD64_YMM7F4    =  556,
+    CV_AMD64_YMM7F5    =  557,
+    CV_AMD64_YMM7F6    =  558,
+    CV_AMD64_YMM7F7    =  559,
+    CV_AMD64_YMM8F0    =  560,
+    CV_AMD64_YMM8F1    =  561,
+    CV_AMD64_YMM8F2    =  562,
+    CV_AMD64_YMM8F3    =  563,
+    CV_AMD64_YMM8F4    =  564,
+    CV_AMD64_YMM8F5    =  565,
+    CV_AMD64_YMM8F6    =  566,
+    CV_AMD64_YMM8F7    =  567,
+    CV_AMD64_YMM9F0    =  568,
+    CV_AMD64_YMM9F1    =  569,
+    CV_AMD64_YMM9F2    =  570,
+    CV_AMD64_YMM9F3    =  571,
+    CV_AMD64_YMM9F4    =  572,
+    CV_AMD64_YMM9F5    =  573,
+    CV_AMD64_YMM9F6    =  574,
+    CV_AMD64_YMM9F7    =  575,
+    CV_AMD64_YMM10F0    =  576,
+    CV_AMD64_YMM10F1    =  577,
+    CV_AMD64_YMM10F2    =  578,
+    CV_AMD64_YMM10F3    =  579,
+    CV_AMD64_YMM10F4    =  580,
+    CV_AMD64_YMM10F5    =  581,
+    CV_AMD64_YMM10F6    =  582,
+    CV_AMD64_YMM10F7    =  583,
+    CV_AMD64_YMM11F0    =  584,
+    CV_AMD64_YMM11F1    =  585,
+    CV_AMD64_YMM11F2    =  586,
+    CV_AMD64_YMM11F3    =  587,
+    CV_AMD64_YMM11F4    =  588,
+    CV_AMD64_YMM11F5    =  589,
+    CV_AMD64_YMM11F6    =  590,
+    CV_AMD64_YMM11F7    =  591,
+    CV_AMD64_YMM12F0    =  592,
+    CV_AMD64_YMM12F1    =  593,
+    CV_AMD64_YMM12F2    =  594,
+    CV_AMD64_YMM12F3    =  595,
+    CV_AMD64_YMM12F4    =  596,
+    CV_AMD64_YMM12F5    =  597,
+    CV_AMD64_YMM12F6    =  598,
+    CV_AMD64_YMM12F7    =  599,
+    CV_AMD64_YMM13F0    =  600,
+    CV_AMD64_YMM13F1    =  601,
+    CV_AMD64_YMM13F2    =  602,
+    CV_AMD64_YMM13F3    =  603,
+    CV_AMD64_YMM13F4    =  604,
+    CV_AMD64_YMM13F5    =  605,
+    CV_AMD64_YMM13F6    =  606,
+    CV_AMD64_YMM13F7    =  607,
+    CV_AMD64_YMM14F0    =  608,
+    CV_AMD64_YMM14F1    =  609,
+    CV_AMD64_YMM14F2    =  610,
+    CV_AMD64_YMM14F3    =  611,
+    CV_AMD64_YMM14F4    =  612,
+    CV_AMD64_YMM14F5    =  613,
+    CV_AMD64_YMM14F6    =  614,
+    CV_AMD64_YMM14F7    =  615,
+    CV_AMD64_YMM15F0    =  616,
+    CV_AMD64_YMM15F1    =  617,
+    CV_AMD64_YMM15F2    =  618,
+    CV_AMD64_YMM15F3    =  619,
+    CV_AMD64_YMM15F4    =  620,
+    CV_AMD64_YMM15F5    =  621,
+    CV_AMD64_YMM15F6    =  622,
+    CV_AMD64_YMM15F7    =  623,
+    
+    CV_AMD64_YMM0D0    =  624,        // AVX floating-point double precise registers
+    CV_AMD64_YMM0D1    =  625,
+    CV_AMD64_YMM0D2    =  626,
+    CV_AMD64_YMM0D3    =  627,
+    CV_AMD64_YMM1D0    =  628,
+    CV_AMD64_YMM1D1    =  629,
+    CV_AMD64_YMM1D2    =  630,
+    CV_AMD64_YMM1D3    =  631,
+    CV_AMD64_YMM2D0    =  632,
+    CV_AMD64_YMM2D1    =  633,
+    CV_AMD64_YMM2D2    =  634,
+    CV_AMD64_YMM2D3    =  635,
+    CV_AMD64_YMM3D0    =  636,
+    CV_AMD64_YMM3D1    =  637,
+    CV_AMD64_YMM3D2    =  638,
+    CV_AMD64_YMM3D3    =  639,
+    CV_AMD64_YMM4D0    =  640,
+    CV_AMD64_YMM4D1    =  641,
+    CV_AMD64_YMM4D2    =  642,
+    CV_AMD64_YMM4D3    =  643,
+    CV_AMD64_YMM5D0    =  644,
+    CV_AMD64_YMM5D1    =  645,
+    CV_AMD64_YMM5D2    =  646,
+    CV_AMD64_YMM5D3    =  647,
+    CV_AMD64_YMM6D0    =  648,
+    CV_AMD64_YMM6D1    =  649,
+    CV_AMD64_YMM6D2    =  650,
+    CV_AMD64_YMM6D3    =  651,
+    CV_AMD64_YMM7D0    =  652,
+    CV_AMD64_YMM7D1    =  653,
+    CV_AMD64_YMM7D2    =  654,
+    CV_AMD64_YMM7D3    =  655,
+    CV_AMD64_YMM8D0    =  656,
+    CV_AMD64_YMM8D1    =  657,
+    CV_AMD64_YMM8D2    =  658,
+    CV_AMD64_YMM8D3    =  659,
+    CV_AMD64_YMM9D0    =  660,
+    CV_AMD64_YMM9D1    =  661,
+    CV_AMD64_YMM9D2    =  662,
+    CV_AMD64_YMM9D3    =  663,
+    CV_AMD64_YMM10D0    =  664,
+    CV_AMD64_YMM10D1    =  665,
+    CV_AMD64_YMM10D2    =  666,
+    CV_AMD64_YMM10D3    =  667,
+    CV_AMD64_YMM11D0    =  668,
+    CV_AMD64_YMM11D1    =  669,
+    CV_AMD64_YMM11D2    =  670,
+    CV_AMD64_YMM11D3    =  671,
+    CV_AMD64_YMM12D0    =  672,
+    CV_AMD64_YMM12D1    =  673,
+    CV_AMD64_YMM12D2    =  674,
+    CV_AMD64_YMM12D3    =  675,
+    CV_AMD64_YMM13D0    =  676,
+    CV_AMD64_YMM13D1    =  677,
+    CV_AMD64_YMM13D2    =  678,
+    CV_AMD64_YMM13D3    =  679,
+    CV_AMD64_YMM14D0    =  680,
+    CV_AMD64_YMM14D1    =  681,
+    CV_AMD64_YMM14D2    =  682,
+    CV_AMD64_YMM14D3    =  683,
+    CV_AMD64_YMM15D0    =  684,
+    CV_AMD64_YMM15D1    =  685,
+    CV_AMD64_YMM15D2    =  686,
+    CV_AMD64_YMM15D3    =  687
+
+
+    // Note:  Next set of platform registers need to go into a new enum...
+    // this one is above 44K now.
+
+} CV_HREG_e;
+
+enum StackFrameTypeEnum
+{
+    FrameTypeFPO,                   // Frame pointer omitted, FPO info available
+    FrameTypeTrap,                  // Kernel Trap frame
+    FrameTypeTSS,                   // Kernel Trap frame
+    FrameTypeStandard,              // Standard EBP stackframe
+    FrameTypeFrameData,             // Frame pointer omitted, FrameData info available
+
+    FrameTypeUnknown = -1,          // Frame which does not have any debug info
+};
+
+enum MemoryTypeEnum
+{
+    MemTypeCode,                    // Read only code memory
+    MemTypeData,                    // Read only data/stack memory
+    MemTypeStack,                   // Read only stack memory
+
+    MemTypeAny = -1,
+};
+
+#endif

diff --git a/src/ToolBox/PdbTypeMatch/include/dia2.h b/src/ToolBox/PdbTypeMatch/include/dia2.h
new file mode 100644 (file)
index 0000000..e463b79
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/dia2.h
@@ -0,0 +1,7852 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 7.00.0499 */
+/* Compiler settings for dia2.idl:
+    Oicf, W1, Zp8, env=Win32 (32b run)
+    protocol : dce , ms_ext, c_ext, robust
+    error checks: allocation ref bounds_check enum stub_data 
+    VC __declspec() decoration level: 
+         __declspec(uuid()), __declspec(selectany), __declspec(novtable)
+         DECLSPEC_UUID(), MIDL_INTERFACE()
+*/
+//@@MIDL_FILE_HEADING(  )
+
+#pragma warning( disable: 4049 )  /* more than 64k source lines */
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __dia2_h__
+#define __dia2_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __IDiaLoadCallback_FWD_DEFINED__
+#define __IDiaLoadCallback_FWD_DEFINED__
+typedef interface IDiaLoadCallback IDiaLoadCallback;
+#endif         /* __IDiaLoadCallback_FWD_DEFINED__ */
+
+
+#ifndef __IDiaLoadCallback2_FWD_DEFINED__
+#define __IDiaLoadCallback2_FWD_DEFINED__
+typedef interface IDiaLoadCallback2 IDiaLoadCallback2;
+#endif         /* __IDiaLoadCallback2_FWD_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtOffsetCallback_FWD_DEFINED__
+#define __IDiaReadExeAtOffsetCallback_FWD_DEFINED__
+typedef interface IDiaReadExeAtOffsetCallback IDiaReadExeAtOffsetCallback;
+#endif         /* __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtRVACallback_FWD_DEFINED__
+#define __IDiaReadExeAtRVACallback_FWD_DEFINED__
+typedef interface IDiaReadExeAtRVACallback IDiaReadExeAtRVACallback;
+#endif         /* __IDiaReadExeAtRVACallback_FWD_DEFINED__ */
+
+
+#ifndef __IDiaDataSource_FWD_DEFINED__
+#define __IDiaDataSource_FWD_DEFINED__
+typedef interface IDiaDataSource IDiaDataSource;
+#endif         /* __IDiaDataSource_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbols_FWD_DEFINED__
+#define __IDiaEnumSymbols_FWD_DEFINED__
+typedef interface IDiaEnumSymbols IDiaEnumSymbols;
+#endif         /* __IDiaEnumSymbols_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbolsByAddr_FWD_DEFINED__
+#define __IDiaEnumSymbolsByAddr_FWD_DEFINED__
+typedef interface IDiaEnumSymbolsByAddr IDiaEnumSymbolsByAddr;
+#endif         /* __IDiaEnumSymbolsByAddr_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSourceFiles_FWD_DEFINED__
+#define __IDiaEnumSourceFiles_FWD_DEFINED__
+typedef interface IDiaEnumSourceFiles IDiaEnumSourceFiles;
+#endif         /* __IDiaEnumSourceFiles_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumLineNumbers_FWD_DEFINED__
+#define __IDiaEnumLineNumbers_FWD_DEFINED__
+typedef interface IDiaEnumLineNumbers IDiaEnumLineNumbers;
+#endif         /* __IDiaEnumLineNumbers_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumInjectedSources_FWD_DEFINED__
+#define __IDiaEnumInjectedSources_FWD_DEFINED__
+typedef interface IDiaEnumInjectedSources IDiaEnumInjectedSources;
+#endif         /* __IDiaEnumInjectedSources_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSegments_FWD_DEFINED__
+#define __IDiaEnumSegments_FWD_DEFINED__
+typedef interface IDiaEnumSegments IDiaEnumSegments;
+#endif         /* __IDiaEnumSegments_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumSectionContribs_FWD_DEFINED__
+#define __IDiaEnumSectionContribs_FWD_DEFINED__
+typedef interface IDiaEnumSectionContribs IDiaEnumSectionContribs;
+#endif         /* __IDiaEnumSectionContribs_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumFrameData_FWD_DEFINED__
+#define __IDiaEnumFrameData_FWD_DEFINED__
+typedef interface IDiaEnumFrameData IDiaEnumFrameData;
+#endif         /* __IDiaEnumFrameData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreamData_FWD_DEFINED__
+#define __IDiaEnumDebugStreamData_FWD_DEFINED__
+typedef interface IDiaEnumDebugStreamData IDiaEnumDebugStreamData;
+#endif         /* __IDiaEnumDebugStreamData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreams_FWD_DEFINED__
+#define __IDiaEnumDebugStreams_FWD_DEFINED__
+typedef interface IDiaEnumDebugStreams IDiaEnumDebugStreams;
+#endif         /* __IDiaEnumDebugStreams_FWD_DEFINED__ */
+
+
+#ifndef __IDiaAddressMap_FWD_DEFINED__
+#define __IDiaAddressMap_FWD_DEFINED__
+typedef interface IDiaAddressMap IDiaAddressMap;
+#endif         /* __IDiaAddressMap_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSession_FWD_DEFINED__
+#define __IDiaSession_FWD_DEFINED__
+typedef interface IDiaSession IDiaSession;
+#endif         /* __IDiaSession_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSymbol_FWD_DEFINED__
+#define __IDiaSymbol_FWD_DEFINED__
+typedef interface IDiaSymbol IDiaSymbol;
+#endif         /* __IDiaSymbol_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSourceFile_FWD_DEFINED__
+#define __IDiaSourceFile_FWD_DEFINED__
+typedef interface IDiaSourceFile IDiaSourceFile;
+#endif         /* __IDiaSourceFile_FWD_DEFINED__ */
+
+
+#ifndef __IDiaLineNumber_FWD_DEFINED__
+#define __IDiaLineNumber_FWD_DEFINED__
+typedef interface IDiaLineNumber IDiaLineNumber;
+#endif         /* __IDiaLineNumber_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSectionContrib_FWD_DEFINED__
+#define __IDiaSectionContrib_FWD_DEFINED__
+typedef interface IDiaSectionContrib IDiaSectionContrib;
+#endif         /* __IDiaSectionContrib_FWD_DEFINED__ */
+
+
+#ifndef __IDiaSegment_FWD_DEFINED__
+#define __IDiaSegment_FWD_DEFINED__
+typedef interface IDiaSegment IDiaSegment;
+#endif         /* __IDiaSegment_FWD_DEFINED__ */
+
+
+#ifndef __IDiaInjectedSource_FWD_DEFINED__
+#define __IDiaInjectedSource_FWD_DEFINED__
+typedef interface IDiaInjectedSource IDiaInjectedSource;
+#endif         /* __IDiaInjectedSource_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkFrame_FWD_DEFINED__
+#define __IDiaStackWalkFrame_FWD_DEFINED__
+typedef interface IDiaStackWalkFrame IDiaStackWalkFrame;
+#endif         /* __IDiaStackWalkFrame_FWD_DEFINED__ */
+
+
+#ifndef __IDiaFrameData_FWD_DEFINED__
+#define __IDiaFrameData_FWD_DEFINED__
+typedef interface IDiaFrameData IDiaFrameData;
+#endif         /* __IDiaFrameData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaImageData_FWD_DEFINED__
+#define __IDiaImageData_FWD_DEFINED__
+typedef interface IDiaImageData IDiaImageData;
+#endif         /* __IDiaImageData_FWD_DEFINED__ */
+
+
+#ifndef __IDiaTable_FWD_DEFINED__
+#define __IDiaTable_FWD_DEFINED__
+typedef interface IDiaTable IDiaTable;
+#endif         /* __IDiaTable_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumTables_FWD_DEFINED__
+#define __IDiaEnumTables_FWD_DEFINED__
+typedef interface IDiaEnumTables IDiaEnumTables;
+#endif         /* __IDiaEnumTables_FWD_DEFINED__ */
+
+
+#ifndef __DiaSource_FWD_DEFINED__
+#define __DiaSource_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DiaSource DiaSource;
+#else
+typedef struct DiaSource DiaSource;
+#endif /* __cplusplus */
+
+#endif         /* __DiaSource_FWD_DEFINED__ */
+
+
+#ifndef __DiaSourceAlt_FWD_DEFINED__
+#define __DiaSourceAlt_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DiaSourceAlt DiaSourceAlt;
+#else
+typedef struct DiaSourceAlt DiaSourceAlt;
+#endif /* __cplusplus */
+
+#endif         /* __DiaSourceAlt_FWD_DEFINED__ */
+
+
+#ifndef __DiaStackWalker_FWD_DEFINED__
+#define __DiaStackWalker_FWD_DEFINED__
+
+#ifdef __cplusplus
+typedef class DiaStackWalker DiaStackWalker;
+#else
+typedef struct DiaStackWalker DiaStackWalker;
+#endif /* __cplusplus */
+
+#endif         /* __DiaStackWalker_FWD_DEFINED__ */
+
+
+#ifndef __IDiaPropertyStorage_FWD_DEFINED__
+#define __IDiaPropertyStorage_FWD_DEFINED__
+typedef interface IDiaPropertyStorage IDiaPropertyStorage;
+#endif         /* __IDiaPropertyStorage_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackFrame_FWD_DEFINED__
+#define __IDiaStackFrame_FWD_DEFINED__
+typedef interface IDiaStackFrame IDiaStackFrame;
+#endif         /* __IDiaStackFrame_FWD_DEFINED__ */
+
+
+#ifndef __IDiaEnumStackFrames_FWD_DEFINED__
+#define __IDiaEnumStackFrames_FWD_DEFINED__
+typedef interface IDiaEnumStackFrames IDiaEnumStackFrames;
+#endif         /* __IDiaEnumStackFrames_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkHelper_FWD_DEFINED__
+#define __IDiaStackWalkHelper_FWD_DEFINED__
+typedef interface IDiaStackWalkHelper IDiaStackWalkHelper;
+#endif         /* __IDiaStackWalkHelper_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker_FWD_DEFINED__
+#define __IDiaStackWalker_FWD_DEFINED__
+typedef interface IDiaStackWalker IDiaStackWalker;
+#endif         /* __IDiaStackWalker_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkHelper2_FWD_DEFINED__
+#define __IDiaStackWalkHelper2_FWD_DEFINED__
+typedef interface IDiaStackWalkHelper2 IDiaStackWalkHelper2;
+#endif         /* __IDiaStackWalkHelper2_FWD_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker2_FWD_DEFINED__
+#define __IDiaStackWalker2_FWD_DEFINED__
+typedef interface IDiaStackWalker2 IDiaStackWalker2;
+#endif         /* __IDiaStackWalker2_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "objidl.h"
+#include "oaidl.h"
+#include "propidl.h"
+#include "cvconst.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_dia2_0000_0000 */
+/* [local] */ 
+
+
+enum NameSearchOptions
+    {  nsNone  = 0,
+       nsfCaseSensitive        = 0x1,
+       nsfCaseInsensitive      = 0x2,
+       nsfFNameExt     = 0x4,
+       nsfRegularExpression    = 0x8,
+       nsfUndecoratedName      = 0x10,
+       nsCaseSensitive = nsfCaseSensitive,
+       nsCaseInsensitive       = nsfCaseInsensitive,
+       nsFNameExt      = ( nsfCaseInsensitive | nsfFNameExt ) ,
+       nsRegularExpression     = ( nsfRegularExpression | nsfCaseSensitive ) ,
+       nsCaseInRegularExpression       = ( nsfRegularExpression | nsfCaseInsensitive ) 
+    } ;
+
+enum __MIDL___MIDL_itf_dia2_0000_0000_0001
+    {  E_PDB_OK        = ( HRESULT  )(( ( ( ( unsigned long  )1 << 31 )  | ( ( unsigned long  )( LONG  )0x6d << 16 )  )  | ( unsigned long  )1 ) ),
+       E_PDB_USAGE     = ( E_PDB_OK + 1 ) ,
+       E_PDB_OUT_OF_MEMORY     = ( E_PDB_USAGE + 1 ) ,
+       E_PDB_FILE_SYSTEM       = ( E_PDB_OUT_OF_MEMORY + 1 ) ,
+       E_PDB_NOT_FOUND = ( E_PDB_FILE_SYSTEM + 1 ) ,
+       E_PDB_INVALID_SIG       = ( E_PDB_NOT_FOUND + 1 ) ,
+       E_PDB_INVALID_AGE       = ( E_PDB_INVALID_SIG + 1 ) ,
+       E_PDB_PRECOMP_REQUIRED  = ( E_PDB_INVALID_AGE + 1 ) ,
+       E_PDB_OUT_OF_TI = ( E_PDB_PRECOMP_REQUIRED + 1 ) ,
+       E_PDB_NOT_IMPLEMENTED   = ( E_PDB_OUT_OF_TI + 1 ) ,
+       E_PDB_V1_PDB    = ( E_PDB_NOT_IMPLEMENTED + 1 ) ,
+       E_PDB_FORMAT    = ( E_PDB_V1_PDB + 1 ) ,
+       E_PDB_LIMIT     = ( E_PDB_FORMAT + 1 ) ,
+       E_PDB_CORRUPT   = ( E_PDB_LIMIT + 1 ) ,
+       E_PDB_TI16      = ( E_PDB_CORRUPT + 1 ) ,
+       E_PDB_ACCESS_DENIED     = ( E_PDB_TI16 + 1 ) ,
+       E_PDB_ILLEGAL_TYPE_EDIT = ( E_PDB_ACCESS_DENIED + 1 ) ,
+       E_PDB_INVALID_EXECUTABLE        = ( E_PDB_ILLEGAL_TYPE_EDIT + 1 ) ,
+       E_PDB_DBG_NOT_FOUND     = ( E_PDB_INVALID_EXECUTABLE + 1 ) ,
+       E_PDB_NO_DEBUG_INFO     = ( E_PDB_DBG_NOT_FOUND + 1 ) ,
+       E_PDB_INVALID_EXE_TIMESTAMP     = ( E_PDB_NO_DEBUG_INFO + 1 ) ,
+       E_PDB_RESERVED  = ( E_PDB_INVALID_EXE_TIMESTAMP + 1 ) ,
+       E_PDB_DEBUG_INFO_NOT_IN_PDB     = ( E_PDB_RESERVED + 1 ) ,
+       E_PDB_SYMSRV_BAD_CACHE_PATH     = ( E_PDB_DEBUG_INFO_NOT_IN_PDB + 1 ) ,
+       E_PDB_SYMSRV_CACHE_FULL = ( E_PDB_SYMSRV_BAD_CACHE_PATH + 1 ) ,
+       E_PDB_MAX       = ( E_PDB_SYMSRV_CACHE_FULL + 1 ) 
+    } ;
+typedef void ( __cdecl *PfnPDBDebugDirV )( 
+    BOOL __MIDL____MIDL_itf_dia2_0000_00000000,
+    void *__MIDL____MIDL_itf_dia2_0000_00000001);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0000_v0_0_s_ifspec;
+
+#ifndef __IDiaLoadCallback_INTERFACE_DEFINED__
+#define __IDiaLoadCallback_INTERFACE_DEFINED__
+
+/* interface IDiaLoadCallback */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaLoadCallback;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C32ADB82-73F4-421b-95D5-A4706EDF5DBE")
+    IDiaLoadCallback : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE NotifyDebugDir( 
+            /* [in] */ BOOL fExecutable,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE NotifyOpenDBG( 
+            /* [in] */ LPCOLESTR dbgPath,
+            /* [in] */ HRESULT resultCode) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE NotifyOpenPDB( 
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ HRESULT resultCode) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictRegistryAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictSymbolServerAccess( void) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaLoadCallbackVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaLoadCallback * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaLoadCallback * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaLoadCallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyDebugDir )( 
+            IDiaLoadCallback * This,
+            /* [in] */ BOOL fExecutable,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenDBG )( 
+            IDiaLoadCallback * This,
+            /* [in] */ LPCOLESTR dbgPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenPDB )( 
+            IDiaLoadCallback * This,
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictRegistryAccess )( 
+            IDiaLoadCallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictSymbolServerAccess )( 
+            IDiaLoadCallback * This);
+        
+        END_INTERFACE
+    } IDiaLoadCallbackVtbl;
+
+    interface IDiaLoadCallback
+    {
+        CONST_VTBL struct IDiaLoadCallbackVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaLoadCallback_QueryInterface(This,riid,ppvObject)   \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaLoadCallback_AddRef(This)  \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaLoadCallback_Release(This) \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaLoadCallback_NotifyDebugDir(This,fExecutable,cbData,pbData)        \
+    ( (This)->lpVtbl -> NotifyDebugDir(This,fExecutable,cbData,pbData) ) 
+
+#define IDiaLoadCallback_NotifyOpenDBG(This,dbgPath,resultCode)        \
+    ( (This)->lpVtbl -> NotifyOpenDBG(This,dbgPath,resultCode) ) 
+
+#define IDiaLoadCallback_NotifyOpenPDB(This,pdbPath,resultCode)        \
+    ( (This)->lpVtbl -> NotifyOpenPDB(This,pdbPath,resultCode) ) 
+
+#define IDiaLoadCallback_RestrictRegistryAccess(This)  \
+    ( (This)->lpVtbl -> RestrictRegistryAccess(This) ) 
+
+#define IDiaLoadCallback_RestrictSymbolServerAccess(This)      \
+    ( (This)->lpVtbl -> RestrictSymbolServerAccess(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaLoadCallback_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaLoadCallback2_INTERFACE_DEFINED__
+#define __IDiaLoadCallback2_INTERFACE_DEFINED__
+
+/* interface IDiaLoadCallback2 */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaLoadCallback2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4688a074-5a4d-4486-aea8-7b90711d9f7c")
+    IDiaLoadCallback2 : public IDiaLoadCallback
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RestrictOriginalPathAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictReferencePathAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictDBGAccess( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RestrictSystemRootAccess( void) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaLoadCallback2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaLoadCallback2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyDebugDir )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ BOOL fExecutable,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenDBG )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ LPCOLESTR dbgPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *NotifyOpenPDB )( 
+            IDiaLoadCallback2 * This,
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ HRESULT resultCode);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictRegistryAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictSymbolServerAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictOriginalPathAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictReferencePathAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictDBGAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RestrictSystemRootAccess )( 
+            IDiaLoadCallback2 * This);
+        
+        END_INTERFACE
+    } IDiaLoadCallback2Vtbl;
+
+    interface IDiaLoadCallback2
+    {
+        CONST_VTBL struct IDiaLoadCallback2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaLoadCallback2_QueryInterface(This,riid,ppvObject)  \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaLoadCallback2_AddRef(This) \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaLoadCallback2_Release(This)        \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaLoadCallback2_NotifyDebugDir(This,fExecutable,cbData,pbData)       \
+    ( (This)->lpVtbl -> NotifyDebugDir(This,fExecutable,cbData,pbData) ) 
+
+#define IDiaLoadCallback2_NotifyOpenDBG(This,dbgPath,resultCode)       \
+    ( (This)->lpVtbl -> NotifyOpenDBG(This,dbgPath,resultCode) ) 
+
+#define IDiaLoadCallback2_NotifyOpenPDB(This,pdbPath,resultCode)       \
+    ( (This)->lpVtbl -> NotifyOpenPDB(This,pdbPath,resultCode) ) 
+
+#define IDiaLoadCallback2_RestrictRegistryAccess(This) \
+    ( (This)->lpVtbl -> RestrictRegistryAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictSymbolServerAccess(This)     \
+    ( (This)->lpVtbl -> RestrictSymbolServerAccess(This) ) 
+
+
+#define IDiaLoadCallback2_RestrictOriginalPathAccess(This)     \
+    ( (This)->lpVtbl -> RestrictOriginalPathAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictReferencePathAccess(This)    \
+    ( (This)->lpVtbl -> RestrictReferencePathAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictDBGAccess(This)      \
+    ( (This)->lpVtbl -> RestrictDBGAccess(This) ) 
+
+#define IDiaLoadCallback2_RestrictSystemRootAccess(This)       \
+    ( (This)->lpVtbl -> RestrictSystemRootAccess(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaLoadCallback2_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__
+#define __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__
+
+/* interface IDiaReadExeAtOffsetCallback */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaReadExeAtOffsetCallback;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("587A461C-B80B-4f54-9194-5032589A6319")
+    IDiaReadExeAtOffsetCallback : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReadExecutableAt( 
+            /* [in] */ DWORDLONG fileOffset,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaReadExeAtOffsetCallbackVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaReadExeAtOffsetCallback * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaReadExeAtOffsetCallback * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaReadExeAtOffsetCallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadExecutableAt )( 
+            IDiaReadExeAtOffsetCallback * This,
+            /* [in] */ DWORDLONG fileOffset,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaReadExeAtOffsetCallbackVtbl;
+
+    interface IDiaReadExeAtOffsetCallback
+    {
+        CONST_VTBL struct IDiaReadExeAtOffsetCallbackVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaReadExeAtOffsetCallback_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaReadExeAtOffsetCallback_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaReadExeAtOffsetCallback_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaReadExeAtOffsetCallback_ReadExecutableAt(This,fileOffset,cbData,pcbData,pbData)    \
+    ( (This)->lpVtbl -> ReadExecutableAt(This,fileOffset,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__
+#define __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__
+
+/* interface IDiaReadExeAtRVACallback */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaReadExeAtRVACallback;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8E3F80CA-7517-432a-BA07-285134AAEA8E")
+    IDiaReadExeAtRVACallback : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReadExecutableAtRVA( 
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaReadExeAtRVACallbackVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaReadExeAtRVACallback * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaReadExeAtRVACallback * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaReadExeAtRVACallback * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadExecutableAtRVA )( 
+            IDiaReadExeAtRVACallback * This,
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaReadExeAtRVACallbackVtbl;
+
+    interface IDiaReadExeAtRVACallback
+    {
+        CONST_VTBL struct IDiaReadExeAtRVACallbackVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaReadExeAtRVACallback_QueryInterface(This,riid,ppvObject)   \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaReadExeAtRVACallback_AddRef(This)  \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaReadExeAtRVACallback_Release(This) \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaReadExeAtRVACallback_ReadExecutableAtRVA(This,relativeVirtualAddress,cbData,pcbData,pbData)        \
+    ( (This)->lpVtbl -> ReadExecutableAtRVA(This,relativeVirtualAddress,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaDataSource_INTERFACE_DEFINED__
+#define __IDiaDataSource_INTERFACE_DEFINED__
+
+/* interface IDiaDataSource */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaDataSource;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("79F1BB5F-B66E-48e5-B6A9-1545C323CA3D")
+    IDiaDataSource : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lastError( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadDataFromPdb( 
+            /* [in] */ LPCOLESTR pdbPath) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadAndValidateDataFromPdb( 
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ GUID *pcsig70,
+            /* [in] */ DWORD sig,
+            /* [in] */ DWORD age) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadDataForExe( 
+            /* [in] */ LPCOLESTR executable,
+            /* [in] */ LPCOLESTR searchPath,
+            /* [in] */ IUnknown *pCallback) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE loadDataFromIStream( 
+            /* [in] */ IStream *pIStream) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE openSession( 
+            /* [out] */ IDiaSession **ppSession) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaDataSourceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaDataSource * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaDataSource * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaDataSource * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lastError )( 
+            IDiaDataSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadDataFromPdb )( 
+            IDiaDataSource * This,
+            /* [in] */ LPCOLESTR pdbPath);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadAndValidateDataFromPdb )( 
+            IDiaDataSource * This,
+            /* [in] */ LPCOLESTR pdbPath,
+            /* [in] */ GUID *pcsig70,
+            /* [in] */ DWORD sig,
+            /* [in] */ DWORD age);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadDataForExe )( 
+            IDiaDataSource * This,
+            /* [in] */ LPCOLESTR executable,
+            /* [in] */ LPCOLESTR searchPath,
+            /* [in] */ IUnknown *pCallback);
+        
+        HRESULT ( STDMETHODCALLTYPE *loadDataFromIStream )( 
+            IDiaDataSource * This,
+            /* [in] */ IStream *pIStream);
+        
+        HRESULT ( STDMETHODCALLTYPE *openSession )( 
+            IDiaDataSource * This,
+            /* [out] */ IDiaSession **ppSession);
+        
+        END_INTERFACE
+    } IDiaDataSourceVtbl;
+
+    interface IDiaDataSource
+    {
+        CONST_VTBL struct IDiaDataSourceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaDataSource_QueryInterface(This,riid,ppvObject)     \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaDataSource_AddRef(This)    \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaDataSource_Release(This)   \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaDataSource_get_lastError(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_lastError(This,pRetVal) ) 
+
+#define IDiaDataSource_loadDataFromPdb(This,pdbPath)   \
+    ( (This)->lpVtbl -> loadDataFromPdb(This,pdbPath) ) 
+
+#define IDiaDataSource_loadAndValidateDataFromPdb(This,pdbPath,pcsig70,sig,age)        \
+    ( (This)->lpVtbl -> loadAndValidateDataFromPdb(This,pdbPath,pcsig70,sig,age) ) 
+
+#define IDiaDataSource_loadDataForExe(This,executable,searchPath,pCallback)    \
+    ( (This)->lpVtbl -> loadDataForExe(This,executable,searchPath,pCallback) ) 
+
+#define IDiaDataSource_loadDataFromIStream(This,pIStream)      \
+    ( (This)->lpVtbl -> loadDataFromIStream(This,pIStream) ) 
+
+#define IDiaDataSource_openSession(This,ppSession)     \
+    ( (This)->lpVtbl -> openSession(This,ppSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaDataSource_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbols_INTERFACE_DEFINED__
+#define __IDiaEnumSymbols_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSymbols */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSymbols;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("CAB72C48-443B-48f5-9B0B-42F0820AB29A")
+    IDiaEnumSymbols : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSymbol **symbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSymbols **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumSymbolsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSymbols * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSymbols * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSymbols * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSymbols * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSymbol **symbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSymbols * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSymbols * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSymbols * This,
+            /* [out] */ IDiaEnumSymbols **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSymbolsVtbl;
+
+    interface IDiaEnumSymbols
+    {
+        CONST_VTBL struct IDiaEnumSymbolsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSymbols_QueryInterface(This,riid,ppvObject)    \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSymbols_AddRef(This)   \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSymbols_Release(This)  \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSymbols_get__NewEnum(This,pRetVal)     \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSymbols_get_Count(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSymbols_Item(This,index,symbol)        \
+    ( (This)->lpVtbl -> Item(This,index,symbol) ) 
+
+#define IDiaEnumSymbols_Next(This,celt,rgelt,pceltFetched)     \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSymbols_Skip(This,celt)        \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSymbols_Reset(This)    \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSymbols_Clone(This,ppenum)     \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumSymbols_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__
+#define __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSymbolsByAddr */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSymbolsByAddr;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("624B7D9C-24EA-4421-9D06-3B577471C1FA")
+    IDiaEnumSymbolsByAddr : public IUnknown
+    {
+    public:
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByAddr( 
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [retval][out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByRVA( 
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByVA( 
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Prev( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSymbolsByAddr **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumSymbolsByAddrVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSymbolsByAddr * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSymbolsByAddr * This);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByAddr )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [retval][out] */ IDiaSymbol **ppSymbol);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByRVA )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByVA )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Prev )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSymbol **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSymbolsByAddr * This,
+            /* [out] */ IDiaEnumSymbolsByAddr **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSymbolsByAddrVtbl;
+
+    interface IDiaEnumSymbolsByAddr
+    {
+        CONST_VTBL struct IDiaEnumSymbolsByAddrVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSymbolsByAddr_QueryInterface(This,riid,ppvObject)      \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSymbolsByAddr_AddRef(This)     \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSymbolsByAddr_Release(This)    \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSymbolsByAddr_symbolByAddr(This,isect,offset,ppSymbol) \
+    ( (This)->lpVtbl -> symbolByAddr(This,isect,offset,ppSymbol) ) 
+
+#define IDiaEnumSymbolsByAddr_symbolByRVA(This,relativeVirtualAddress,ppSymbol)        \
+    ( (This)->lpVtbl -> symbolByRVA(This,relativeVirtualAddress,ppSymbol) ) 
+
+#define IDiaEnumSymbolsByAddr_symbolByVA(This,virtualAddress,ppSymbol) \
+    ( (This)->lpVtbl -> symbolByVA(This,virtualAddress,ppSymbol) ) 
+
+#define IDiaEnumSymbolsByAddr_Next(This,celt,rgelt,pceltFetched)       \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSymbolsByAddr_Prev(This,celt,rgelt,pceltFetched)       \
+    ( (This)->lpVtbl -> Prev(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSymbolsByAddr_Clone(This,ppenum)       \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSourceFiles_INTERFACE_DEFINED__
+#define __IDiaEnumSourceFiles_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSourceFiles */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSourceFiles;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("10F3DBD9-664F-4469-B808-9471C7A50538")
+    IDiaEnumSourceFiles : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSourceFile **sourceFile) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSourceFile **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSourceFiles **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumSourceFilesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSourceFiles * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSourceFiles * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSourceFiles * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSourceFiles * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSourceFile **sourceFile);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSourceFile **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSourceFiles * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSourceFiles * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSourceFiles * This,
+            /* [out] */ IDiaEnumSourceFiles **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSourceFilesVtbl;
+
+    interface IDiaEnumSourceFiles
+    {
+        CONST_VTBL struct IDiaEnumSourceFilesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSourceFiles_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSourceFiles_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSourceFiles_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSourceFiles_get__NewEnum(This,pRetVal) \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSourceFiles_get_Count(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSourceFiles_Item(This,index,sourceFile)        \
+    ( (This)->lpVtbl -> Item(This,index,sourceFile) ) 
+
+#define IDiaEnumSourceFiles_Next(This,celt,rgelt,pceltFetched) \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSourceFiles_Skip(This,celt)    \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSourceFiles_Reset(This)        \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSourceFiles_Clone(This,ppenum) \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumSourceFiles_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumLineNumbers_INTERFACE_DEFINED__
+#define __IDiaEnumLineNumbers_INTERFACE_DEFINED__
+
+/* interface IDiaEnumLineNumbers */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumLineNumbers;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("FE30E878-54AC-44f1-81BA-39DE940F6052")
+    IDiaEnumLineNumbers : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaLineNumber **lineNumber) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaLineNumber **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumLineNumbers **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumLineNumbersVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumLineNumbers * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumLineNumbers * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumLineNumbers * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumLineNumbers * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaLineNumber **lineNumber);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaLineNumber **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumLineNumbers * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumLineNumbers * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumLineNumbers * This,
+            /* [out] */ IDiaEnumLineNumbers **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumLineNumbersVtbl;
+
+    interface IDiaEnumLineNumbers
+    {
+        CONST_VTBL struct IDiaEnumLineNumbersVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumLineNumbers_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumLineNumbers_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumLineNumbers_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumLineNumbers_get__NewEnum(This,pRetVal) \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumLineNumbers_get_Count(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumLineNumbers_Item(This,index,lineNumber)        \
+    ( (This)->lpVtbl -> Item(This,index,lineNumber) ) 
+
+#define IDiaEnumLineNumbers_Next(This,celt,rgelt,pceltFetched) \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumLineNumbers_Skip(This,celt)    \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumLineNumbers_Reset(This)        \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumLineNumbers_Clone(This,ppenum) \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumLineNumbers_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumInjectedSources_INTERFACE_DEFINED__
+#define __IDiaEnumInjectedSources_INTERFACE_DEFINED__
+
+/* interface IDiaEnumInjectedSources */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumInjectedSources;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("D5612573-6925-4468-8883-98CDEC8C384A")
+    IDiaEnumInjectedSources : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaInjectedSource **injectedSource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaInjectedSource **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumInjectedSources **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumInjectedSourcesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumInjectedSources * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumInjectedSources * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumInjectedSources * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumInjectedSources * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaInjectedSource **injectedSource);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaInjectedSource **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumInjectedSources * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumInjectedSources * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumInjectedSources * This,
+            /* [out] */ IDiaEnumInjectedSources **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumInjectedSourcesVtbl;
+
+    interface IDiaEnumInjectedSources
+    {
+        CONST_VTBL struct IDiaEnumInjectedSourcesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumInjectedSources_QueryInterface(This,riid,ppvObject)    \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumInjectedSources_AddRef(This)   \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumInjectedSources_Release(This)  \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumInjectedSources_get__NewEnum(This,pRetVal)     \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumInjectedSources_get_Count(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumInjectedSources_Item(This,index,injectedSource)        \
+    ( (This)->lpVtbl -> Item(This,index,injectedSource) ) 
+
+#define IDiaEnumInjectedSources_Next(This,celt,rgelt,pceltFetched)     \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumInjectedSources_Skip(This,celt)        \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumInjectedSources_Reset(This)    \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumInjectedSources_Clone(This,ppenum)     \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumInjectedSources_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSegments_INTERFACE_DEFINED__
+#define __IDiaEnumSegments_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSegments */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSegments;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("E8368CA9-01D1-419d-AC0C-E31235DBDA9F")
+    IDiaEnumSegments : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSegment **segment) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSegment **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSegments **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumSegmentsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSegments * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSegments * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSegments * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSegments * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSegments * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSegments * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSegment **segment);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSegments * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSegment **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSegments * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSegments * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSegments * This,
+            /* [out] */ IDiaEnumSegments **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSegmentsVtbl;
+
+    interface IDiaEnumSegments
+    {
+        CONST_VTBL struct IDiaEnumSegmentsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSegments_QueryInterface(This,riid,ppvObject)   \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSegments_AddRef(This)  \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSegments_Release(This) \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSegments_get__NewEnum(This,pRetVal)    \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSegments_get_Count(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSegments_Item(This,index,segment)      \
+    ( (This)->lpVtbl -> Item(This,index,segment) ) 
+
+#define IDiaEnumSegments_Next(This,celt,rgelt,pceltFetched)    \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSegments_Skip(This,celt)       \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSegments_Reset(This)   \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSegments_Clone(This,ppenum)    \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumSegments_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumSectionContribs_INTERFACE_DEFINED__
+#define __IDiaEnumSectionContribs_INTERFACE_DEFINED__
+
+/* interface IDiaEnumSectionContribs */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumSectionContribs;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1994DEB2-2C82-4b1d-A57F-AFF424D54A68")
+    IDiaEnumSectionContribs : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSectionContrib **section) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSectionContrib **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumSectionContribs **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumSectionContribsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumSectionContribs * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumSectionContribs * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumSectionContribs * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumSectionContribs * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaSectionContrib **section);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaSectionContrib **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumSectionContribs * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumSectionContribs * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumSectionContribs * This,
+            /* [out] */ IDiaEnumSectionContribs **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumSectionContribsVtbl;
+
+    interface IDiaEnumSectionContribs
+    {
+        CONST_VTBL struct IDiaEnumSectionContribsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumSectionContribs_QueryInterface(This,riid,ppvObject)    \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumSectionContribs_AddRef(This)   \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumSectionContribs_Release(This)  \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumSectionContribs_get__NewEnum(This,pRetVal)     \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumSectionContribs_get_Count(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumSectionContribs_Item(This,index,section)       \
+    ( (This)->lpVtbl -> Item(This,index,section) ) 
+
+#define IDiaEnumSectionContribs_Next(This,celt,rgelt,pceltFetched)     \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumSectionContribs_Skip(This,celt)        \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumSectionContribs_Reset(This)    \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumSectionContribs_Clone(This,ppenum)     \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumSectionContribs_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumFrameData_INTERFACE_DEFINED__
+#define __IDiaEnumFrameData_INTERFACE_DEFINED__
+
+/* interface IDiaEnumFrameData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumFrameData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9FC77A4B-3C1C-44ed-A798-6C1DEEA53E1F")
+    IDiaEnumFrameData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaFrameData **frame) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaFrameData **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumFrameData **ppenum) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE frameByRVA( 
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame) = 0;
+        
+        virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE frameByVA( 
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumFrameDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumFrameData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumFrameData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumFrameData * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumFrameData * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IDiaFrameData **frame);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaFrameData **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumFrameData * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumFrameData * This,
+            /* [out] */ IDiaEnumFrameData **ppenum);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *frameByRVA )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ DWORD relativeVirtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame);
+        
+        /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *frameByVA )( 
+            IDiaEnumFrameData * This,
+            /* [in] */ ULONGLONG virtualAddress,
+            /* [retval][out] */ IDiaFrameData **frame);
+        
+        END_INTERFACE
+    } IDiaEnumFrameDataVtbl;
+
+    interface IDiaEnumFrameData
+    {
+        CONST_VTBL struct IDiaEnumFrameDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumFrameData_QueryInterface(This,riid,ppvObject)  \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumFrameData_AddRef(This) \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumFrameData_Release(This)        \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumFrameData_get__NewEnum(This,pRetVal)   \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumFrameData_get_Count(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumFrameData_Item(This,index,frame)       \
+    ( (This)->lpVtbl -> Item(This,index,frame) ) 
+
+#define IDiaEnumFrameData_Next(This,celt,rgelt,pceltFetched)   \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumFrameData_Skip(This,celt)      \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumFrameData_Reset(This)  \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumFrameData_Clone(This,ppenum)   \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#define IDiaEnumFrameData_frameByRVA(This,relativeVirtualAddress,frame)        \
+    ( (This)->lpVtbl -> frameByRVA(This,relativeVirtualAddress,frame) ) 
+
+#define IDiaEnumFrameData_frameByVA(This,virtualAddress,frame) \
+    ( (This)->lpVtbl -> frameByVA(This,virtualAddress,frame) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumFrameData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreamData_INTERFACE_DEFINED__
+#define __IDiaEnumDebugStreamData_INTERFACE_DEFINED__
+
+/* interface IDiaEnumDebugStreamData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumDebugStreamData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("486943E8-D187-4a6b-A3C4-291259FFF60D")
+    IDiaEnumDebugStreamData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumDebugStreamData **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumDebugStreamDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumDebugStreamData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumDebugStreamData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumDebugStreamData * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumDebugStreamData * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
+            IDiaEnumDebugStreamData * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ DWORD index,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ ULONG celt,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumDebugStreamData * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumDebugStreamData * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumDebugStreamData * This,
+            /* [out] */ IDiaEnumDebugStreamData **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumDebugStreamDataVtbl;
+
+    interface IDiaEnumDebugStreamData
+    {
+        CONST_VTBL struct IDiaEnumDebugStreamDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumDebugStreamData_QueryInterface(This,riid,ppvObject)    \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumDebugStreamData_AddRef(This)   \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumDebugStreamData_Release(This)  \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumDebugStreamData_get__NewEnum(This,pRetVal)     \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreamData_get_Count(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreamData_get_name(This,pRetVal) \
+    ( (This)->lpVtbl -> get_name(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreamData_Item(This,index,cbData,pcbData,pbData) \
+    ( (This)->lpVtbl -> Item(This,index,cbData,pcbData,pbData) ) 
+
+#define IDiaEnumDebugStreamData_Next(This,celt,cbData,pcbData,pbData,pceltFetched)     \
+    ( (This)->lpVtbl -> Next(This,celt,cbData,pcbData,pbData,pceltFetched) ) 
+
+#define IDiaEnumDebugStreamData_Skip(This,celt)        \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumDebugStreamData_Reset(This)    \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumDebugStreamData_Clone(This,ppenum)     \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumDebugStreamData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumDebugStreams_INTERFACE_DEFINED__
+#define __IDiaEnumDebugStreams_INTERFACE_DEFINED__
+
+/* interface IDiaEnumDebugStreams */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumDebugStreams;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("08CBB41E-47A6-4f87-92F1-1C9C87CED044")
+    IDiaEnumDebugStreams : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaEnumDebugStreamData **stream) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaEnumDebugStreamData **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumDebugStreams **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumDebugStreamsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumDebugStreams * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumDebugStreams * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumDebugStreams * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumDebugStreams * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaEnumDebugStreamData **stream);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaEnumDebugStreamData **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumDebugStreams * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumDebugStreams * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumDebugStreams * This,
+            /* [out] */ IDiaEnumDebugStreams **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumDebugStreamsVtbl;
+
+    interface IDiaEnumDebugStreams
+    {
+        CONST_VTBL struct IDiaEnumDebugStreamsVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumDebugStreams_QueryInterface(This,riid,ppvObject)       \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumDebugStreams_AddRef(This)      \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumDebugStreams_Release(This)     \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumDebugStreams_get__NewEnum(This,pRetVal)        \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreams_get_Count(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumDebugStreams_Item(This,index,stream)   \
+    ( (This)->lpVtbl -> Item(This,index,stream) ) 
+
+#define IDiaEnumDebugStreams_Next(This,celt,rgelt,pceltFetched)        \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumDebugStreams_Skip(This,celt)   \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumDebugStreams_Reset(This)       \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumDebugStreams_Clone(This,ppenum)        \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumDebugStreams_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dia2_0000_0015 */
+/* [local] */ 
+
+struct DiaAddressMapEntry
+    {
+    DWORD rva;
+    DWORD rvaTo;
+    } ;
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0015_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0015_v0_0_s_ifspec;
+
+#ifndef __IDiaAddressMap_INTERFACE_DEFINED__
+#define __IDiaAddressMap_INTERFACE_DEFINED__
+
+/* interface IDiaAddressMap */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaAddressMap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("B62A2E7A-067A-4ea3-B598-04C09717502C")
+    IDiaAddressMap : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressMapEnabled( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_addressMapEnabled( 
+            /* [in] */ BOOL NewVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddressEnabled( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_relativeVirtualAddressEnabled( 
+            /* [in] */ BOOL NewVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_imageAlign( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_imageAlign( 
+            /* [in] */ DWORD NewVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE set_imageHeaders( 
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData,
+            /* [in] */ BOOL originalHeaders) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE set_addressMap( 
+            /* [in] */ DWORD cData,
+            /* [size_is][in] */ struct DiaAddressMapEntry *pData,
+            /* [in] */ BOOL imageToSymbols) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaAddressMapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaAddressMap * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaAddressMap * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaAddressMap * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressMapEnabled )( 
+            IDiaAddressMap * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_addressMapEnabled )( 
+            IDiaAddressMap * This,
+            /* [in] */ BOOL NewVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddressEnabled )( 
+            IDiaAddressMap * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_relativeVirtualAddressEnabled )( 
+            IDiaAddressMap * This,
+            /* [in] */ BOOL NewVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageAlign )( 
+            IDiaAddressMap * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_imageAlign )( 
+            IDiaAddressMap * This,
+            /* [in] */ DWORD NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *set_imageHeaders )( 
+            IDiaAddressMap * This,
+            /* [in] */ DWORD cbData,
+            /* [size_is][in] */ BYTE *pbData,
+            /* [in] */ BOOL originalHeaders);
+        
+        HRESULT ( STDMETHODCALLTYPE *set_addressMap )( 
+            IDiaAddressMap * This,
+            /* [in] */ DWORD cData,
+            /* [size_is][in] */ struct DiaAddressMapEntry *pData,
+            /* [in] */ BOOL imageToSymbols);
+        
+        END_INTERFACE
+    } IDiaAddressMapVtbl;
+
+    interface IDiaAddressMap
+    {
+        CONST_VTBL struct IDiaAddressMapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaAddressMap_QueryInterface(This,riid,ppvObject)     \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaAddressMap_AddRef(This)    \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaAddressMap_Release(This)   \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaAddressMap_get_addressMapEnabled(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_addressMapEnabled(This,pRetVal) ) 
+
+#define IDiaAddressMap_put_addressMapEnabled(This,NewVal)      \
+    ( (This)->lpVtbl -> put_addressMapEnabled(This,NewVal) ) 
+
+#define IDiaAddressMap_get_relativeVirtualAddressEnabled(This,pRetVal) \
+    ( (This)->lpVtbl -> get_relativeVirtualAddressEnabled(This,pRetVal) ) 
+
+#define IDiaAddressMap_put_relativeVirtualAddressEnabled(This,NewVal)  \
+    ( (This)->lpVtbl -> put_relativeVirtualAddressEnabled(This,NewVal) ) 
+
+#define IDiaAddressMap_get_imageAlign(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_imageAlign(This,pRetVal) ) 
+
+#define IDiaAddressMap_put_imageAlign(This,NewVal)     \
+    ( (This)->lpVtbl -> put_imageAlign(This,NewVal) ) 
+
+#define IDiaAddressMap_set_imageHeaders(This,cbData,pbData,originalHeaders)    \
+    ( (This)->lpVtbl -> set_imageHeaders(This,cbData,pbData,originalHeaders) ) 
+
+#define IDiaAddressMap_set_addressMap(This,cData,pData,imageToSymbols) \
+    ( (This)->lpVtbl -> set_addressMap(This,cData,pData,imageToSymbols) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaAddressMap_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSession_INTERFACE_DEFINED__
+#define __IDiaSession_INTERFACE_DEFINED__
+
+/* interface IDiaSession */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("67138B34-79CD-4b42-B74A-A18ADBB799DF")
+    IDiaSession : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_loadAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_loadAddress( 
+            /* [in] */ ULONGLONG NewVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_globalScope( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getEnumTables( 
+            /* [out] */ IDiaEnumTables **ppEnumTables) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getSymbolsByAddr( 
+            /* [out] */ IDiaEnumSymbolsByAddr **ppEnumbyAddr) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildren( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenEx( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByAddr( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByVA( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByRVA( 
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByAddr( 
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByRVA( 
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByVA( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByToken( 
+            /* [in] */ ULONG token,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE symsAreEquiv( 
+            /* [in] */ IDiaSymbol *symbolA,
+            /* [in] */ IDiaSymbol *symbolB) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE symbolById( 
+            /* [in] */ DWORD id,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByRVAEx( 
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findSymbolByVAEx( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findFile( 
+            /* [in] */ IDiaSymbol *pCompiland,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSourceFiles **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findFileById( 
+            /* [in] */ DWORD uniqueId,
+            /* [out] */ IDiaSourceFile **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLines( 
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByAddr( 
+            /* [in] */ DWORD seg,
+            /* [in] */ DWORD offset,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByRVA( 
+            /* [in] */ DWORD rva,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByVA( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findLinesByLinenum( 
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [in] */ DWORD linenum,
+            /* [in] */ DWORD column,
+            /* [out] */ IDiaEnumLineNumbers **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findInjectedSource( 
+            /* [in] */ LPCOLESTR srcFile,
+            /* [out] */ IDiaEnumInjectedSources **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getEnumDebugStreams( 
+            /* [out] */ IDiaEnumDebugStreams **ppEnumDebugStreams) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSession * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSession * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSession * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_loadAddress )( 
+            IDiaSession * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_loadAddress )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG NewVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_globalScope )( 
+            IDiaSession * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumTables )( 
+            IDiaSession * This,
+            /* [out] */ IDiaEnumTables **ppEnumTables);
+        
+        HRESULT ( STDMETHODCALLTYPE *getSymbolsByAddr )( 
+            IDiaSession * This,
+            /* [out] */ IDiaEnumSymbolsByAddr **ppEnumbyAddr);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildren )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *parent,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByAddr )( 
+            IDiaSession * This,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByRVA )( 
+            IDiaSession * This,
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByVA )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByToken )( 
+            IDiaSession * This,
+            /* [in] */ ULONG token,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *symsAreEquiv )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *symbolA,
+            /* [in] */ IDiaSymbol *symbolB);
+        
+        HRESULT ( STDMETHODCALLTYPE *symbolById )( 
+            IDiaSession * This,
+            /* [in] */ DWORD id,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByRVAEx )( 
+            IDiaSession * This,
+            /* [in] */ DWORD rva,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement);
+        
+        HRESULT ( STDMETHODCALLTYPE *findSymbolByVAEx )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [out] */ IDiaSymbol **ppSymbol,
+            /* [out] */ long *displacement);
+        
+        HRESULT ( STDMETHODCALLTYPE *findFile )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *pCompiland,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSourceFiles **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findFileById )( 
+            IDiaSession * This,
+            /* [in] */ DWORD uniqueId,
+            /* [out] */ IDiaSourceFile **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLines )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByAddr )( 
+            IDiaSession * This,
+            /* [in] */ DWORD seg,
+            /* [in] */ DWORD offset,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByRVA )( 
+            IDiaSession * This,
+            /* [in] */ DWORD rva,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByVA )( 
+            IDiaSession * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD length,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findLinesByLinenum )( 
+            IDiaSession * This,
+            /* [in] */ IDiaSymbol *compiland,
+            /* [in] */ IDiaSourceFile *file,
+            /* [in] */ DWORD linenum,
+            /* [in] */ DWORD column,
+            /* [out] */ IDiaEnumLineNumbers **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findInjectedSource )( 
+            IDiaSession * This,
+            /* [in] */ LPCOLESTR srcFile,
+            /* [out] */ IDiaEnumInjectedSources **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumDebugStreams )( 
+            IDiaSession * This,
+            /* [out] */ IDiaEnumDebugStreams **ppEnumDebugStreams);
+        
+        END_INTERFACE
+    } IDiaSessionVtbl;
+
+    interface IDiaSession
+    {
+        CONST_VTBL struct IDiaSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSession_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSession_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSession_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSession_get_loadAddress(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_loadAddress(This,pRetVal) ) 
+
+#define IDiaSession_put_loadAddress(This,NewVal)       \
+    ( (This)->lpVtbl -> put_loadAddress(This,NewVal) ) 
+
+#define IDiaSession_get_globalScope(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_globalScope(This,pRetVal) ) 
+
+#define IDiaSession_getEnumTables(This,ppEnumTables)   \
+    ( (This)->lpVtbl -> getEnumTables(This,ppEnumTables) ) 
+
+#define IDiaSession_getSymbolsByAddr(This,ppEnumbyAddr)        \
+    ( (This)->lpVtbl -> getSymbolsByAddr(This,ppEnumbyAddr) ) 
+
+#define IDiaSession_findChildren(This,parent,symtag,name,compareFlags,ppResult)        \
+    ( (This)->lpVtbl -> findChildren(This,parent,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSession_findChildrenEx(This,parent,symtag,name,compareFlags,ppResult)      \
+    ( (This)->lpVtbl -> findChildrenEx(This,parent,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSession_findChildrenExByAddr(This,parent,symtag,name,compareFlags,isect,offset,ppResult)   \
+    ( (This)->lpVtbl -> findChildrenExByAddr(This,parent,symtag,name,compareFlags,isect,offset,ppResult) ) 
+
+#define IDiaSession_findChildrenExByVA(This,parent,symtag,name,compareFlags,va,ppResult)       \
+    ( (This)->lpVtbl -> findChildrenExByVA(This,parent,symtag,name,compareFlags,va,ppResult) ) 
+
+#define IDiaSession_findChildrenExByRVA(This,parent,symtag,name,compareFlags,rva,ppResult)     \
+    ( (This)->lpVtbl -> findChildrenExByRVA(This,parent,symtag,name,compareFlags,rva,ppResult) ) 
+
+#define IDiaSession_findSymbolByAddr(This,isect,offset,symtag,ppSymbol)        \
+    ( (This)->lpVtbl -> findSymbolByAddr(This,isect,offset,symtag,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByRVA(This,rva,symtag,ppSymbol)  \
+    ( (This)->lpVtbl -> findSymbolByRVA(This,rva,symtag,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByVA(This,va,symtag,ppSymbol)    \
+    ( (This)->lpVtbl -> findSymbolByVA(This,va,symtag,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByToken(This,token,symtag,ppSymbol)      \
+    ( (This)->lpVtbl -> findSymbolByToken(This,token,symtag,ppSymbol) ) 
+
+#define IDiaSession_symsAreEquiv(This,symbolA,symbolB) \
+    ( (This)->lpVtbl -> symsAreEquiv(This,symbolA,symbolB) ) 
+
+#define IDiaSession_symbolById(This,id,ppSymbol)       \
+    ( (This)->lpVtbl -> symbolById(This,id,ppSymbol) ) 
+
+#define IDiaSession_findSymbolByRVAEx(This,rva,symtag,ppSymbol,displacement)   \
+    ( (This)->lpVtbl -> findSymbolByRVAEx(This,rva,symtag,ppSymbol,displacement) ) 
+
+#define IDiaSession_findSymbolByVAEx(This,va,symtag,ppSymbol,displacement)     \
+    ( (This)->lpVtbl -> findSymbolByVAEx(This,va,symtag,ppSymbol,displacement) ) 
+
+#define IDiaSession_findFile(This,pCompiland,name,compareFlags,ppResult)       \
+    ( (This)->lpVtbl -> findFile(This,pCompiland,name,compareFlags,ppResult) ) 
+
+#define IDiaSession_findFileById(This,uniqueId,ppResult)       \
+    ( (This)->lpVtbl -> findFileById(This,uniqueId,ppResult) ) 
+
+#define IDiaSession_findLines(This,compiland,file,ppResult)    \
+    ( (This)->lpVtbl -> findLines(This,compiland,file,ppResult) ) 
+
+#define IDiaSession_findLinesByAddr(This,seg,offset,length,ppResult)   \
+    ( (This)->lpVtbl -> findLinesByAddr(This,seg,offset,length,ppResult) ) 
+
+#define IDiaSession_findLinesByRVA(This,rva,length,ppResult)   \
+    ( (This)->lpVtbl -> findLinesByRVA(This,rva,length,ppResult) ) 
+
+#define IDiaSession_findLinesByVA(This,va,length,ppResult)     \
+    ( (This)->lpVtbl -> findLinesByVA(This,va,length,ppResult) ) 
+
+#define IDiaSession_findLinesByLinenum(This,compiland,file,linenum,column,ppResult)    \
+    ( (This)->lpVtbl -> findLinesByLinenum(This,compiland,file,linenum,column,ppResult) ) 
+
+#define IDiaSession_findInjectedSource(This,srcFile,ppResult)  \
+    ( (This)->lpVtbl -> findInjectedSource(This,srcFile,ppResult) ) 
+
+#define IDiaSession_getEnumDebugStreams(This,ppEnumDebugStreams)       \
+    ( (This)->lpVtbl -> getEnumDebugStreams(This,ppEnumDebugStreams) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaSession_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSymbol_INTERFACE_DEFINED__
+#define __IDiaSymbol_INTERFACE_DEFINED__
+
+/* interface IDiaSymbol */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSymbol;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("cb787b2f-bd6c-4635-ba52-933126bd2dcd")
+    IDiaSymbol : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symIndexId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symTag( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lexicalParent( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_classParent( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataKind( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_locationType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offset( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_slot( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_volatileType( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constType( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unalignedType( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_access( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_libraryName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_platform( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_language( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_editAndContinueEnabled( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndMajor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndMinor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndBuild( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndMajor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndMinor( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndBuild( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFileName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unused( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_thunkOrdinal( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_thisAdjust( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtual( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_intro( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_pure( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_callingConvention( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_value( 
+            /* [retval][out] */ VARIANT *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_token( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_timeStamp( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_guid( 
+            /* [retval][out] */ GUID *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symbolsFileName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_reference( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_count( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bitPosition( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_arrayIndexType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_packed( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constructor( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_overloadedOperator( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_nested( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasNestedTypes( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAssignmentOperator( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasCastOperator( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_scoped( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseClass( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_indirectVirtualBaseClass( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBasePointerOffset( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualTableShape( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lexicalParentId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_classParentId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_typeId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_arrayIndexTypeId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualTableShapeId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_function( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_managed( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_msil( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseDispIndex( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_undecoratedName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_age( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_signature( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilerGenerated( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressTaken( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_rank( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lowerBound( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_upperBound( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lowerBoundId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_upperBoundId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_dataBytes( 
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildren( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenEx( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByAddr( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByVA( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE findChildrenExByRVA( 
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetRelativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetVirtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_machineType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_oemId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_oemSymbolId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_types( 
+            /* [in] */ DWORD cTypes,
+            /* [out] */ DWORD *pcTypes,
+            /* [size_is][size_is][out] */ IDiaSymbol **pTypes) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_typeIds( 
+            /* [in] */ DWORD cTypeIds,
+            /* [out] */ DWORD *pcTypeIds,
+            /* [size_is][out] */ DWORD *pdwTypeIds) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectPointerType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_udtKind( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_undecoratedNameEx( 
+            /* [in] */ DWORD undecorateOptions,
+            /* [out] */ BSTR *name) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noReturn( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_customCallingConvention( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noInline( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_optimizedCodeDebugInfo( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notReached( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_interruptReturn( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_farReturn( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStatic( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasDebugInfo( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isLTCG( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isDataAligned( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSecurityChecks( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilerName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAlloca( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSetJump( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasLongJump( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasInlAsm( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasEH( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSEH( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasEHa( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isNaked( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAggregated( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSplitted( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_container( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlSpec( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noStackOrdering( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseTableType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasManagedCode( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isHotpatchable( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCVTCIL( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMSILNetmodule( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCTypes( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStripped( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndQFE( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndQFE( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_wasInlined( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_strictGSCheck( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCxxReturnUdt( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isConstructorVirtualBase( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RValueReference( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unmodifiedType( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_framePointerPresent( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSafeBuffers( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_intrinsic( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sealed( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hfaFloat( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hfaDouble( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartAddressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartAddressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartRelativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_countLiveRanges( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeLength( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offsetInUdt( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_paramBasePointerRegisterId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_localBasePointerRegisterId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaSymbolVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSymbol * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSymbol * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSymbol * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ VARIANT *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ GUID *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildren )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD isect,
+            /* [in] */ DWORD offset,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( 
+            IDiaSymbol * This,
+            /* [in] */ enum SymTagEnum symtag,
+            /* [in] */ LPCOLESTR name,
+            /* [in] */ DWORD compareFlags,
+            /* [in] */ DWORD rva,
+            /* [out] */ IDiaEnumSymbols **ppResult);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_types )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD cTypes,
+            /* [out] */ DWORD *pcTypes,
+            /* [size_is][size_is][out] */ IDiaSymbol **pTypes);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_typeIds )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD cTypeIds,
+            /* [out] */ DWORD *pcTypeIds,
+            /* [size_is][out] */ DWORD *pdwTypeIds);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( 
+            IDiaSymbol * This,
+            /* [in] */ DWORD undecorateOptions,
+            /* [out] */ BSTR *name);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( 
+            IDiaSymbol * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        END_INTERFACE
+    } IDiaSymbolVtbl;
+
+    interface IDiaSymbol
+    {
+        CONST_VTBL struct IDiaSymbolVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSymbol_QueryInterface(This,riid,ppvObject) \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSymbol_AddRef(This)        \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSymbol_Release(This)       \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSymbol_get_symIndexId(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_symTag(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) 
+
+#define IDiaSymbol_get_name(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_name(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lexicalParent(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) 
+
+#define IDiaSymbol_get_classParent(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) 
+
+#define IDiaSymbol_get_type(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_type(This,pRetVal) ) 
+
+#define IDiaSymbol_get_dataKind(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) 
+
+#define IDiaSymbol_get_locationType(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_addressSection(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaSymbol_get_addressOffset(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_relativeVirtualAddress(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualAddress(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_registerId(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_offset(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_offset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_length(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaSymbol_get_slot(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_slot(This,pRetVal) ) 
+
+#define IDiaSymbol_get_volatileType(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_constType(This,pRetVal) \
+    ( (This)->lpVtbl -> get_constType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_unalignedType(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_access(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_access(This,pRetVal) ) 
+
+#define IDiaSymbol_get_libraryName(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_platform(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_platform(This,pRetVal) ) 
+
+#define IDiaSymbol_get_language(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_language(This,pRetVal) ) 
+
+#define IDiaSymbol_get_editAndContinueEnabled(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndMajor(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndMinor(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndBuild(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndMajor(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndMinor(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndBuild(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) 
+
+#define IDiaSymbol_get_sourceFileName(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_unused(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_unused(This,pRetVal) ) 
+
+#define IDiaSymbol_get_thunkOrdinal(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) 
+
+#define IDiaSymbol_get_thisAdjust(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseOffset(This,pRetVal) \
+    ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtual(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) 
+
+#define IDiaSymbol_get_intro(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_intro(This,pRetVal) ) 
+
+#define IDiaSymbol_get_pure(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_pure(This,pRetVal) ) 
+
+#define IDiaSymbol_get_callingConvention(This,pRetVal) \
+    ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) 
+
+#define IDiaSymbol_get_value(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_value(This,pRetVal) ) 
+
+#define IDiaSymbol_get_baseType(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_token(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_token(This,pRetVal) ) 
+
+#define IDiaSymbol_get_timeStamp(This,pRetVal) \
+    ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) 
+
+#define IDiaSymbol_get_guid(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_guid(This,pRetVal) ) 
+
+#define IDiaSymbol_get_symbolsFileName(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_reference(This,pRetVal) \
+    ( (This)->lpVtbl -> get_reference(This,pRetVal) ) 
+
+#define IDiaSymbol_get_count(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_count(This,pRetVal) ) 
+
+#define IDiaSymbol_get_bitPosition(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) 
+
+#define IDiaSymbol_get_arrayIndexType(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_packed(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_packed(This,pRetVal) ) 
+
+#define IDiaSymbol_get_constructor(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) 
+
+#define IDiaSymbol_get_overloadedOperator(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) 
+
+#define IDiaSymbol_get_nested(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_nested(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasNestedTypes(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasAssignmentOperator(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasCastOperator(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) 
+
+#define IDiaSymbol_get_scoped(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseClass(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) 
+
+#define IDiaSymbol_get_indirectVirtualBaseClass(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBasePointerOffset(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualTableShape(This,pRetVal) \
+    ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lexicalParentId(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_classParentId(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_typeId(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_arrayIndexTypeId(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualTableShapeId(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_code(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_code(This,pRetVal) ) 
+
+#define IDiaSymbol_get_function(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_function(This,pRetVal) ) 
+
+#define IDiaSymbol_get_managed(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_managed(This,pRetVal) ) 
+
+#define IDiaSymbol_get_msil(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_msil(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseDispIndex(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) 
+
+#define IDiaSymbol_get_undecoratedName(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_age(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_age(This,pRetVal) ) 
+
+#define IDiaSymbol_get_signature(This,pRetVal) \
+    ( (This)->lpVtbl -> get_signature(This,pRetVal) ) 
+
+#define IDiaSymbol_get_compilerGenerated(This,pRetVal) \
+    ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) 
+
+#define IDiaSymbol_get_addressTaken(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) 
+
+#define IDiaSymbol_get_rank(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_rank(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lowerBound(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) 
+
+#define IDiaSymbol_get_upperBound(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) 
+
+#define IDiaSymbol_get_lowerBoundId(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_upperBoundId(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_dataBytes(This,cbData,pcbData,pbData)   \
+    ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) 
+
+#define IDiaSymbol_findChildren(This,symtag,name,compareFlags,ppResult)        \
+    ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSymbol_findChildrenEx(This,symtag,name,compareFlags,ppResult)      \
+    ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) 
+
+#define IDiaSymbol_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult)   \
+    ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) 
+
+#define IDiaSymbol_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult)       \
+    ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) 
+
+#define IDiaSymbol_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult)     \
+    ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) 
+
+#define IDiaSymbol_get_targetSection(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) 
+
+#define IDiaSymbol_get_targetOffset(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_targetRelativeVirtualAddress(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_targetVirtualAddress(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_machineType(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_oemId(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_oemSymbolId(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_types(This,cTypes,pcTypes,pTypes)       \
+    ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) 
+
+#define IDiaSymbol_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds)     \
+    ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) 
+
+#define IDiaSymbol_get_objectPointerType(This,pRetVal) \
+    ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_udtKind(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) 
+
+#define IDiaSymbol_get_undecoratedNameEx(This,undecorateOptions,name)  \
+    ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) 
+
+#define IDiaSymbol_get_noReturn(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) 
+
+#define IDiaSymbol_get_customCallingConvention(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) 
+
+#define IDiaSymbol_get_noInline(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) 
+
+#define IDiaSymbol_get_optimizedCodeDebugInfo(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) 
+
+#define IDiaSymbol_get_notReached(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) 
+
+#define IDiaSymbol_get_interruptReturn(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) 
+
+#define IDiaSymbol_get_farReturn(This,pRetVal) \
+    ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isStatic(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasDebugInfo(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isLTCG(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isDataAligned(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasSecurityChecks(This,pRetVal) \
+    ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) 
+
+#define IDiaSymbol_get_compilerName(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasAlloca(This,pRetVal) \
+    ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasSetJump(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasLongJump(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasInlAsm(This,pRetVal) \
+    ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasEH(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasSEH(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasEHa(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isNaked(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isAggregated(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isSplitted(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) 
+
+#define IDiaSymbol_get_container(This,pRetVal) \
+    ( (This)->lpVtbl -> get_container(This,pRetVal) ) 
+
+#define IDiaSymbol_get_inlSpec(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) 
+
+#define IDiaSymbol_get_noStackOrdering(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) 
+
+#define IDiaSymbol_get_virtualBaseTableType(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hasManagedCode(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isHotpatchable(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isCVTCIL(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isMSILNetmodule(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isCTypes(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isStripped(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) 
+
+#define IDiaSymbol_get_frontEndQFE(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) 
+
+#define IDiaSymbol_get_backEndQFE(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) 
+
+#define IDiaSymbol_get_wasInlined(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) 
+
+#define IDiaSymbol_get_strictGSCheck(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isCxxReturnUdt(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isConstructorVirtualBase(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) 
+
+#define IDiaSymbol_get_RValueReference(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) 
+
+#define IDiaSymbol_get_unmodifiedType(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) 
+
+#define IDiaSymbol_get_framePointerPresent(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) 
+
+#define IDiaSymbol_get_isSafeBuffers(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) 
+
+#define IDiaSymbol_get_intrinsic(This,pRetVal) \
+    ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) 
+
+#define IDiaSymbol_get_sealed(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hfaFloat(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) 
+
+#define IDiaSymbol_get_hfaDouble(This,pRetVal) \
+    ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeStartAddressSection(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeStartAddressOffset(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeStartRelativeVirtualAddress(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSymbol_get_countLiveRanges(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) 
+
+#define IDiaSymbol_get_liveRangeLength(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) 
+
+#define IDiaSymbol_get_offsetInUdt(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) 
+
+#define IDiaSymbol_get_paramBasePointerRegisterId(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) 
+
+#define IDiaSymbol_get_localBasePointerRegisterId(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_virtualBaseTableType_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ IDiaSymbol **pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_virtualBaseTableType_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasManagedCode_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_hasManagedCode_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isHotpatchable_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isHotpatchable_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCVTCIL_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isCVTCIL_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMSILNetmodule_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isMSILNetmodule_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCTypes_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isCTypes_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isStripped_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isStripped_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_frontEndQFE_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_frontEndQFE_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_backEndQFE_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_backEndQFE_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_wasInlined_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_wasInlined_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_strictGSCheck_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_strictGSCheck_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCxxReturnUdt_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isCxxReturnUdt_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isConstructorVirtualBase_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isConstructorVirtualBase_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_RValueReference_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_RValueReference_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_unmodifiedType_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ IDiaSymbol **pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_unmodifiedType_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_framePointerPresent_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_framePointerPresent_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSafeBuffers_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_isSafeBuffers_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_intrinsic_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_intrinsic_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_sealed_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_sealed_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hfaFloat_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_hfaFloat_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hfaDouble_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ BOOL *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_hfaDouble_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartAddressSection_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeStartAddressSection_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartAddressOffset_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeStartAddressOffset_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartRelativeVirtualAddress_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeStartRelativeVirtualAddress_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_countLiveRanges_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_countLiveRanges_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeLength_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ ULONGLONG *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_liveRangeLength_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_offsetInUdt_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_offsetInUdt_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_paramBasePointerRegisterId_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_paramBasePointerRegisterId_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_localBasePointerRegisterId_Proxy( 
+    IDiaSymbol * This,
+    /* [retval][out] */ DWORD *pRetVal);
+
+
+void __RPC_STUB IDiaSymbol_get_localBasePointerRegisterId_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+
+#endif         /* __IDiaSymbol_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSourceFile_INTERFACE_DEFINED__
+#define __IDiaSourceFile_INTERFACE_DEFINED__
+
+/* interface IDiaSourceFile */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSourceFile;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("A2EF5353-F5A8-4eb3-90D2-CB526ACB3CDD")
+    IDiaSourceFile : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uniqueId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_fileName( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_checksumType( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilands( 
+            /* [retval][out] */ IDiaEnumSymbols **pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_checksum( 
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaSourceFileVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSourceFile * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSourceFile * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSourceFile * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueId )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_fileName )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_checksumType )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilands )( 
+            IDiaSourceFile * This,
+            /* [retval][out] */ IDiaEnumSymbols **pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_checksum )( 
+            IDiaSourceFile * This,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaSourceFileVtbl;
+
+    interface IDiaSourceFile
+    {
+        CONST_VTBL struct IDiaSourceFileVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSourceFile_QueryInterface(This,riid,ppvObject)     \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSourceFile_AddRef(This)    \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSourceFile_Release(This)   \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSourceFile_get_uniqueId(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_uniqueId(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_fileName(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_fileName(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_checksumType(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_checksumType(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_compilands(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_compilands(This,pRetVal) ) 
+
+#define IDiaSourceFile_get_checksum(This,cbData,pcbData,pbData)        \
+    ( (This)->lpVtbl -> get_checksum(This,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaSourceFile_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaLineNumber_INTERFACE_DEFINED__
+#define __IDiaLineNumber_INTERFACE_DEFINED__
+
+/* interface IDiaLineNumber */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaLineNumber;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("B388EB14-BE4D-421d-A8A1-6CF7AB057086")
+    IDiaLineNumber : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compiland( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFile( 
+            /* [retval][out] */ IDiaSourceFile **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lineNumber( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lineNumberEnd( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_columnNumber( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_columnNumberEnd( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFileId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_statement( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilandId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaLineNumberVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaLineNumber * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaLineNumber * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaLineNumber * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compiland )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFile )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ IDiaSourceFile **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lineNumber )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lineNumberEnd )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnNumber )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnNumberEnd )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileId )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_statement )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilandId )( 
+            IDiaLineNumber * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        END_INTERFACE
+    } IDiaLineNumberVtbl;
+
+    interface IDiaLineNumber
+    {
+        CONST_VTBL struct IDiaLineNumberVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaLineNumber_QueryInterface(This,riid,ppvObject)     \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaLineNumber_AddRef(This)    \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaLineNumber_Release(This)   \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaLineNumber_get_compiland(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_compiland(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_sourceFile(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_sourceFile(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_lineNumber(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_lineNumber(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_lineNumberEnd(This,pRetVal) \
+    ( (This)->lpVtbl -> get_lineNumberEnd(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_columnNumber(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_columnNumber(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_columnNumberEnd(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_columnNumberEnd(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_addressSection(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_addressOffset(This,pRetVal) \
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_relativeVirtualAddress(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_virtualAddress(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_length(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_sourceFileId(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_sourceFileId(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_statement(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_statement(This,pRetVal) ) 
+
+#define IDiaLineNumber_get_compilandId(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_compilandId(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaLineNumber_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSectionContrib_INTERFACE_DEFINED__
+#define __IDiaSectionContrib_INTERFACE_DEFINED__
+
+/* interface IDiaSectionContrib */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSectionContrib;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0CF4B60E-35B1-4c6c-BDD8-854B9C8E3857")
+    IDiaSectionContrib : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compiland( 
+            /* [retval][out] */ IDiaSymbol **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notPaged( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_initializedData( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uninitializedData( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_remove( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_comdat( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_discardable( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notCached( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_share( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_execute( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_read( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_write( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataCrc( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relocationsCrc( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilandId( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code16bit( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaSectionContribVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSectionContrib * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSectionContrib * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSectionContrib * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compiland )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ IDiaSymbol **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notPaged )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_initializedData )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uninitializedData )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_remove )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_comdat )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_discardable )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notCached )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_share )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_execute )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_read )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_write )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataCrc )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relocationsCrc )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilandId )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code16bit )( 
+            IDiaSectionContrib * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        END_INTERFACE
+    } IDiaSectionContribVtbl;
+
+    interface IDiaSectionContrib
+    {
+        CONST_VTBL struct IDiaSectionContribVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSectionContrib_QueryInterface(This,riid,ppvObject) \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSectionContrib_AddRef(This)        \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSectionContrib_Release(This)       \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSectionContrib_get_compiland(This,pRetVal) \
+    ( (This)->lpVtbl -> get_compiland(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_addressSection(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_addressOffset(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_relativeVirtualAddress(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_virtualAddress(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_length(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_notPaged(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_notPaged(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_code(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_code(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_initializedData(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_initializedData(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_uninitializedData(This,pRetVal) \
+    ( (This)->lpVtbl -> get_uninitializedData(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_remove(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_remove(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_comdat(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_comdat(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_discardable(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_discardable(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_notCached(This,pRetVal) \
+    ( (This)->lpVtbl -> get_notCached(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_share(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_share(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_execute(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_execute(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_read(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_read(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_write(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_write(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_dataCrc(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_dataCrc(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_relocationsCrc(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_relocationsCrc(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_compilandId(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_compilandId(This,pRetVal) ) 
+
+#define IDiaSectionContrib_get_code16bit(This,pRetVal) \
+    ( (This)->lpVtbl -> get_code16bit(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaSectionContrib_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaSegment_INTERFACE_DEFINED__
+#define __IDiaSegment_INTERFACE_DEFINED__
+
+/* interface IDiaSegment */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaSegment;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0775B784-C75B-4449-848B-B7BD3159545B")
+    IDiaSegment : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frame( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_read( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_write( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_execute( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaSegmentVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaSegment * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaSegment * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaSegment * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frame )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_read )( 
+            IDiaSegment * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_write )( 
+            IDiaSegment * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_execute )( 
+            IDiaSegment * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaSegment * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaSegment * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        END_INTERFACE
+    } IDiaSegmentVtbl;
+
+    interface IDiaSegment
+    {
+        CONST_VTBL struct IDiaSegmentVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaSegment_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaSegment_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaSegment_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaSegment_get_frame(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_frame(This,pRetVal) ) 
+
+#define IDiaSegment_get_offset(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_offset(This,pRetVal) ) 
+
+#define IDiaSegment_get_length(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaSegment_get_read(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_read(This,pRetVal) ) 
+
+#define IDiaSegment_get_write(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_write(This,pRetVal) ) 
+
+#define IDiaSegment_get_execute(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_execute(This,pRetVal) ) 
+
+#define IDiaSegment_get_addressSection(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaSegment_get_relativeVirtualAddress(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaSegment_get_virtualAddress(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaSegment_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaInjectedSource_INTERFACE_DEFINED__
+#define __IDiaInjectedSource_INTERFACE_DEFINED__
+
+/* interface IDiaInjectedSource */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaInjectedSource;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("AE605CDC-8105-4a23-B710-3259F1E26112")
+    IDiaInjectedSource : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_crc( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_filename( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectFilename( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualFilename( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceCompression( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE get_source( 
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaInjectedSourceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaInjectedSource * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaInjectedSource * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaInjectedSource * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_crc )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_filename )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFilename )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualFilename )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceCompression )( 
+            IDiaInjectedSource * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *get_source )( 
+            IDiaInjectedSource * This,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        END_INTERFACE
+    } IDiaInjectedSourceVtbl;
+
+    interface IDiaInjectedSource
+    {
+        CONST_VTBL struct IDiaInjectedSourceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaInjectedSource_QueryInterface(This,riid,ppvObject) \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaInjectedSource_AddRef(This)        \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaInjectedSource_Release(This)       \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaInjectedSource_get_crc(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_crc(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_length(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_length(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_filename(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_filename(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_objectFilename(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_objectFilename(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_virtualFilename(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_virtualFilename(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_sourceCompression(This,pRetVal) \
+    ( (This)->lpVtbl -> get_sourceCompression(This,pRetVal) ) 
+
+#define IDiaInjectedSource_get_source(This,cbData,pcbData,pbData)      \
+    ( (This)->lpVtbl -> get_source(This,cbData,pcbData,pbData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaInjectedSource_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dia2_0000_0023 */
+/* [local] */ 
+
+
+enum __MIDL___MIDL_itf_dia2_0000_0023_0001
+    {  E_DIA_INPROLOG  = ( HRESULT  )(( ( ( ( unsigned long  )1 << 31 )  | ( ( unsigned long  )( LONG  )0x6d << 16 )  )  | ( unsigned long  )100 ) ),
+       E_DIA_SYNTAX    = ( E_DIA_INPROLOG + 1 ) ,
+       E_DIA_FRAME_ACCESS      = ( E_DIA_SYNTAX + 1 ) ,
+       E_DIA_VALUE     = ( E_DIA_FRAME_ACCESS + 1 ) 
+    } ;
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0023_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0023_v0_0_s_ifspec;
+
+#ifndef __IDiaStackWalkFrame_INTERFACE_DEFINED__
+#define __IDiaStackWalkFrame_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalkFrame */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalkFrame;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("97F0F1A6-E04E-4ea4-B4F9-B0D0E8D90F5D")
+    IDiaStackWalkFrame : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_registerValue( 
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE readMemory( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddress( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddressStart( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaStackWalkFrameVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalkFrame * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalkFrame * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *readMemory )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( 
+            IDiaStackWalkFrame * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        END_INTERFACE
+    } IDiaStackWalkFrameVtbl;
+
+    interface IDiaStackWalkFrame
+    {
+        CONST_VTBL struct IDiaStackWalkFrameVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalkFrame_QueryInterface(This,riid,ppvObject) \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalkFrame_AddRef(This)        \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalkFrame_Release(This)       \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalkFrame_get_registerValue(This,index,pRetVal)       \
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#define IDiaStackWalkFrame_put_registerValue(This,index,NewVal)        \
+    ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) 
+
+#define IDiaStackWalkFrame_readMemory(This,va,cbData,pcbData,pbData)   \
+    ( (This)->lpVtbl -> readMemory(This,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkFrame_searchForReturnAddress(This,frame,returnAddress)    \
+    ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) 
+
+#define IDiaStackWalkFrame_searchForReturnAddressStart(This,frame,startAddress,returnAddress)  \
+    ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaStackWalkFrame_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaFrameData_INTERFACE_DEFINED__
+#define __IDiaFrameData_INTERFACE_DEFINED__
+
+/* interface IDiaFrameData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaFrameData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("A39184B7-6A36-42de-8EEC-7DF9F3F59F33")
+    IDiaFrameData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthBlock( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthLocals( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthParams( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_maxStack( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthProlog( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthSavedRegisters( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_program( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_systemExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_cplusplusExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionStart( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_allocatesBasePointer( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionParent( 
+            /* [retval][out] */ IDiaFrameData **pRetVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE execute( 
+            IDiaStackWalkFrame *frame) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaFrameDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaFrameData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaFrameData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaFrameData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthBlock )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthLocals )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthParams )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_maxStack )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthProlog )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthSavedRegisters )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_program )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_systemExceptionHandling )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_cplusplusExceptionHandling )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionStart )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_allocatesBasePointer )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionParent )( 
+            IDiaFrameData * This,
+            /* [retval][out] */ IDiaFrameData **pRetVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *execute )( 
+            IDiaFrameData * This,
+            IDiaStackWalkFrame *frame);
+        
+        END_INTERFACE
+    } IDiaFrameDataVtbl;
+
+    interface IDiaFrameData
+    {
+        CONST_VTBL struct IDiaFrameDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaFrameData_QueryInterface(This,riid,ppvObject)      \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaFrameData_AddRef(This)     \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaFrameData_Release(This)    \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaFrameData_get_addressSection(This,pRetVal) \
+    ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) 
+
+#define IDiaFrameData_get_addressOffset(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) 
+
+#define IDiaFrameData_get_relativeVirtualAddress(This,pRetVal) \
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaFrameData_get_virtualAddress(This,pRetVal) \
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthBlock(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_lengthBlock(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthLocals(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_lengthLocals(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthParams(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_lengthParams(This,pRetVal) ) 
+
+#define IDiaFrameData_get_maxStack(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_maxStack(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthProlog(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_lengthProlog(This,pRetVal) ) 
+
+#define IDiaFrameData_get_lengthSavedRegisters(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_lengthSavedRegisters(This,pRetVal) ) 
+
+#define IDiaFrameData_get_program(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_program(This,pRetVal) ) 
+
+#define IDiaFrameData_get_systemExceptionHandling(This,pRetVal)        \
+    ( (This)->lpVtbl -> get_systemExceptionHandling(This,pRetVal) ) 
+
+#define IDiaFrameData_get_cplusplusExceptionHandling(This,pRetVal)     \
+    ( (This)->lpVtbl -> get_cplusplusExceptionHandling(This,pRetVal) ) 
+
+#define IDiaFrameData_get_functionStart(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_functionStart(This,pRetVal) ) 
+
+#define IDiaFrameData_get_allocatesBasePointer(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_allocatesBasePointer(This,pRetVal) ) 
+
+#define IDiaFrameData_get_type(This,pRetVal)   \
+    ( (This)->lpVtbl -> get_type(This,pRetVal) ) 
+
+#define IDiaFrameData_get_functionParent(This,pRetVal) \
+    ( (This)->lpVtbl -> get_functionParent(This,pRetVal) ) 
+
+#define IDiaFrameData_execute(This,frame)      \
+    ( (This)->lpVtbl -> execute(This,frame) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaFrameData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaImageData_INTERFACE_DEFINED__
+#define __IDiaImageData_INTERFACE_DEFINED__
+
+/* interface IDiaImageData */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaImageData;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C8E40ED2-A1D9-4221-8692-3CE661184B44")
+    IDiaImageData : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_imageBase( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaImageDataVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaImageData * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaImageData * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaImageData * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( 
+            IDiaImageData * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( 
+            IDiaImageData * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageBase )( 
+            IDiaImageData * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        END_INTERFACE
+    } IDiaImageDataVtbl;
+
+    interface IDiaImageData
+    {
+        CONST_VTBL struct IDiaImageDataVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaImageData_QueryInterface(This,riid,ppvObject)      \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaImageData_AddRef(This)     \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaImageData_Release(This)    \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaImageData_get_relativeVirtualAddress(This,pRetVal) \
+    ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) 
+
+#define IDiaImageData_get_virtualAddress(This,pRetVal) \
+    ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) 
+
+#define IDiaImageData_get_imageBase(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_imageBase(This,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaImageData_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaTable_INTERFACE_DEFINED__
+#define __IDiaTable_INTERFACE_DEFINED__
+
+/* interface IDiaTable */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaTable;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4A59FB77-ABAC-469b-A30B-9ECC85BFEF14")
+    IDiaTable : public IEnumUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( 
+            /* [retval][out] */ BSTR *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IUnknown **element) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaTableVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaTable * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaTable * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaTable * This);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaTable * This,
+            /* [in] */ 
+            __in  ULONG celt,
+            /* [out] */ 
+            __out_ecount_part(celt,*pceltFetched)  IUnknown **rgelt,
+            /* [out] */ 
+            __out_opt  ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaTable * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaTable * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaTable * This,
+            /* [out] */ IEnumUnknown **ppenum);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaTable * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( 
+            IDiaTable * This,
+            /* [retval][out] */ BSTR *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaTable * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaTable * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ IUnknown **element);
+        
+        END_INTERFACE
+    } IDiaTableVtbl;
+
+    interface IDiaTable
+    {
+        CONST_VTBL struct IDiaTableVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaTable_QueryInterface(This,riid,ppvObject)  \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaTable_AddRef(This) \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaTable_Release(This)        \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaTable_Next(This,celt,rgelt,pceltFetched)   \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaTable_Skip(This,celt)      \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaTable_Reset(This)  \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaTable_Clone(This,ppenum)   \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+
+#define IDiaTable_get__NewEnum(This,pRetVal)   \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaTable_get_name(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_name(This,pRetVal) ) 
+
+#define IDiaTable_get_Count(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaTable_Item(This,index,element)     \
+    ( (This)->lpVtbl -> Item(This,index,element) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaTable_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumTables_INTERFACE_DEFINED__
+#define __IDiaEnumTables_INTERFACE_DEFINED__
+
+/* interface IDiaEnumTables */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumTables;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C65C2B0A-1150-4d7a-AFCC-E05BF3DEE81E")
+    IDiaEnumTables : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( 
+            /* [retval][out] */ IUnknown **pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( 
+            /* [retval][out] */ LONG *pRetVal) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( 
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaTable **table) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            ULONG celt,
+            IDiaTable **rgelt,
+            ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Skip( 
+            /* [in] */ ULONG celt) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Clone( 
+            /* [out] */ IDiaEnumTables **ppenum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumTablesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumTables * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumTables * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumTables * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( 
+            IDiaEnumTables * This,
+            /* [retval][out] */ IUnknown **pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( 
+            IDiaEnumTables * This,
+            /* [retval][out] */ LONG *pRetVal);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
+            IDiaEnumTables * This,
+            /* [in] */ VARIANT index,
+            /* [retval][out] */ IDiaTable **table);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumTables * This,
+            ULONG celt,
+            IDiaTable **rgelt,
+            ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            IDiaEnumTables * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumTables * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            IDiaEnumTables * This,
+            /* [out] */ IDiaEnumTables **ppenum);
+        
+        END_INTERFACE
+    } IDiaEnumTablesVtbl;
+
+    interface IDiaEnumTables
+    {
+        CONST_VTBL struct IDiaEnumTablesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumTables_QueryInterface(This,riid,ppvObject)     \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumTables_AddRef(This)    \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumTables_Release(This)   \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumTables_get__NewEnum(This,pRetVal)      \
+    ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) 
+
+#define IDiaEnumTables_get_Count(This,pRetVal) \
+    ( (This)->lpVtbl -> get_Count(This,pRetVal) ) 
+
+#define IDiaEnumTables_Item(This,index,table)  \
+    ( (This)->lpVtbl -> Item(This,index,table) ) 
+
+#define IDiaEnumTables_Next(This,celt,rgelt,pceltFetched)      \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumTables_Skip(This,celt) \
+    ( (This)->lpVtbl -> Skip(This,celt) ) 
+
+#define IDiaEnumTables_Reset(This)     \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#define IDiaEnumTables_Clone(This,ppenum)      \
+    ( (This)->lpVtbl -> Clone(This,ppenum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumTables_INTERFACE_DEFINED__ */
+
+
+
+#ifndef __Dia2Lib_LIBRARY_DEFINED__
+#define __Dia2Lib_LIBRARY_DEFINED__
+
+/* library Dia2Lib */
+/* [helpstring][version][uuid] */ 
+
+
+EXTERN_C const IID LIBID_Dia2Lib;
+
+EXTERN_C const CLSID CLSID_DiaSource;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("B86AE24D-BF2F-4ac9-B5A2-34B14E4CE11D")
+DiaSource;
+#endif
+
+EXTERN_C const CLSID CLSID_DiaSourceAlt;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("E3E90253-8E14-49a5-AA30-2E7B798AB839")
+DiaSourceAlt;
+#endif
+
+EXTERN_C const CLSID CLSID_DiaStackWalker;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("EBA05B6F-BD22-490e-A7B0-32D821C9046C")
+DiaStackWalker;
+#endif
+#endif /* __Dia2Lib_LIBRARY_DEFINED__ */
+
+/* interface __MIDL_itf_dia2_0000_0028 */
+/* [local] */ 
+
+#define        DiaTable_Symbols        ( L"Symbols" )
+
+#define        DiaTable_Sections       ( L"Sections" )
+
+#define        DiaTable_SrcFiles       ( L"SourceFiles" )
+
+#define        DiaTable_LineNums       ( L"LineNumbers" )
+
+#define        DiaTable_SegMap ( L"SegmentMap" )
+
+#define        DiaTable_Dbg    ( L"Dbg" )
+
+#define        DiaTable_InjSrc ( L"InjectedSource" )
+
+#define        DiaTable_FrameData      ( L"FrameData" )
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0028_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0028_v0_0_s_ifspec;
+
+#ifndef __IDiaPropertyStorage_INTERFACE_DEFINED__
+#define __IDiaPropertyStorage_INTERFACE_DEFINED__
+
+/* interface IDiaPropertyStorage */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaPropertyStorage;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("9d416f9c-e184-45b2-a4f0-ce517f719e9b")
+    IDiaPropertyStorage : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ReadMultiple( 
+            /* [in] */ ULONG cpspec,
+            /* [size_is][in] */ const PROPSPEC *rgpspec,
+            /* [size_is][out] */ PROPVARIANT *rgvar) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadPropertyNames( 
+            /* [in] */ ULONG cpropid,
+            /* [size_is][in] */ const PROPID *rgpropid,
+            /* [size_is][out][in] */ BSTR *rglpwstrName) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Enum( 
+            /* [out] */ IEnumSTATPROPSTG **ppenum) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadDWORD( 
+            /* [in] */ PROPID id,
+            /* [out] */ DWORD *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadLONG( 
+            /* [in] */ PROPID id,
+            /* [out] */ LONG *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadBOOL( 
+            /* [in] */ PROPID id,
+            /* [out] */ BOOL *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadULONGLONG( 
+            /* [in] */ PROPID id,
+            /* [out] */ ULONGLONG *pValue) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReadBSTR( 
+            /* [in] */ PROPID id,
+            /* [out] */ BSTR *pValue) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaPropertyStorageVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaPropertyStorage * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaPropertyStorage * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadMultiple )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ ULONG cpspec,
+            /* [size_is][in] */ const PROPSPEC *rgpspec,
+            /* [size_is][out] */ PROPVARIANT *rgvar);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadPropertyNames )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ ULONG cpropid,
+            /* [size_is][in] */ const PROPID *rgpropid,
+            /* [size_is][out][in] */ BSTR *rglpwstrName);
+        
+        HRESULT ( STDMETHODCALLTYPE *Enum )( 
+            IDiaPropertyStorage * This,
+            /* [out] */ IEnumSTATPROPSTG **ppenum);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadDWORD )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ DWORD *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadLONG )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ LONG *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadBOOL )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ BOOL *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadULONGLONG )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ ULONGLONG *pValue);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReadBSTR )( 
+            IDiaPropertyStorage * This,
+            /* [in] */ PROPID id,
+            /* [out] */ BSTR *pValue);
+        
+        END_INTERFACE
+    } IDiaPropertyStorageVtbl;
+
+    interface IDiaPropertyStorage
+    {
+        CONST_VTBL struct IDiaPropertyStorageVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaPropertyStorage_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaPropertyStorage_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaPropertyStorage_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaPropertyStorage_ReadMultiple(This,cpspec,rgpspec,rgvar)    \
+    ( (This)->lpVtbl -> ReadMultiple(This,cpspec,rgpspec,rgvar) ) 
+
+#define IDiaPropertyStorage_ReadPropertyNames(This,cpropid,rgpropid,rglpwstrName)      \
+    ( (This)->lpVtbl -> ReadPropertyNames(This,cpropid,rgpropid,rglpwstrName) ) 
+
+#define IDiaPropertyStorage_Enum(This,ppenum)  \
+    ( (This)->lpVtbl -> Enum(This,ppenum) ) 
+
+#define IDiaPropertyStorage_ReadDWORD(This,id,pValue)  \
+    ( (This)->lpVtbl -> ReadDWORD(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadLONG(This,id,pValue)   \
+    ( (This)->lpVtbl -> ReadLONG(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadBOOL(This,id,pValue)   \
+    ( (This)->lpVtbl -> ReadBOOL(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadULONGLONG(This,id,pValue)      \
+    ( (This)->lpVtbl -> ReadULONGLONG(This,id,pValue) ) 
+
+#define IDiaPropertyStorage_ReadBSTR(This,id,pValue)   \
+    ( (This)->lpVtbl -> ReadBSTR(This,id,pValue) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaPropertyStorage_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackFrame_INTERFACE_DEFINED__
+#define __IDiaStackFrame_INTERFACE_DEFINED__
+
+/* interface IDiaStackFrame */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackFrame;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5edbc96d-cdd6-4792-afbe-cc89007d9610")
+    IDiaStackFrame : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_base( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_size( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_returnAddress( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_localsBase( 
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthLocals( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthParams( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthProlog( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthSavedRegisters( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_systemExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_cplusplusExceptionHandling( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionStart( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_allocatesBasePointer( 
+            /* [retval][out] */ BOOL *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_maxStack( 
+            /* [retval][out] */ DWORD *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaStackFrameVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackFrame * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackFrame * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackFrame * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_base )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_size )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_returnAddress )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localsBase )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthLocals )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthParams )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthProlog )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthSavedRegisters )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_systemExceptionHandling )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_cplusplusExceptionHandling )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionStart )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_allocatesBasePointer )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ BOOL *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_maxStack )( 
+            IDiaStackFrame * This,
+            /* [retval][out] */ DWORD *pRetVal);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackFrame * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        END_INTERFACE
+    } IDiaStackFrameVtbl;
+
+    interface IDiaStackFrame
+    {
+        CONST_VTBL struct IDiaStackFrameVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackFrame_QueryInterface(This,riid,ppvObject)     \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackFrame_AddRef(This)    \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackFrame_Release(This)   \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackFrame_get_type(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_type(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_base(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_base(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_size(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_size(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_returnAddress(This,pRetVal) \
+    ( (This)->lpVtbl -> get_returnAddress(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_localsBase(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_localsBase(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthLocals(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_lengthLocals(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthParams(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_lengthParams(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthProlog(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_lengthProlog(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_lengthSavedRegisters(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_lengthSavedRegisters(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_systemExceptionHandling(This,pRetVal)       \
+    ( (This)->lpVtbl -> get_systemExceptionHandling(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_cplusplusExceptionHandling(This,pRetVal)    \
+    ( (This)->lpVtbl -> get_cplusplusExceptionHandling(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_functionStart(This,pRetVal) \
+    ( (This)->lpVtbl -> get_functionStart(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_allocatesBasePointer(This,pRetVal)  \
+    ( (This)->lpVtbl -> get_allocatesBasePointer(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_maxStack(This,pRetVal)      \
+    ( (This)->lpVtbl -> get_maxStack(This,pRetVal) ) 
+
+#define IDiaStackFrame_get_registerValue(This,index,pRetVal)   \
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaStackFrame_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaEnumStackFrames_INTERFACE_DEFINED__
+#define __IDiaEnumStackFrames_INTERFACE_DEFINED__
+
+/* interface IDiaEnumStackFrames */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaEnumStackFrames;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("ec9d461d-ce74-4711-a020-7d8f9a1dd255")
+    IDiaEnumStackFrames : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Next( 
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaStackFrame **rgelt,
+            /* [out] */ ULONG *pceltFetched) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaEnumStackFramesVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaEnumStackFrames * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaEnumStackFrames * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaEnumStackFrames * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IDiaEnumStackFrames * This,
+            /* [in] */ ULONG celt,
+            /* [out] */ IDiaStackFrame **rgelt,
+            /* [out] */ ULONG *pceltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            IDiaEnumStackFrames * This);
+        
+        END_INTERFACE
+    } IDiaEnumStackFramesVtbl;
+
+    interface IDiaEnumStackFrames
+    {
+        CONST_VTBL struct IDiaEnumStackFramesVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaEnumStackFrames_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaEnumStackFrames_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaEnumStackFrames_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaEnumStackFrames_Next(This,celt,rgelt,pceltFetched) \
+    ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) 
+
+#define IDiaEnumStackFrames_Reset(This)        \
+    ( (This)->lpVtbl -> Reset(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaEnumStackFrames_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dia2_0000_0031 */
+/* [local] */ 
+
+typedef /* [public] */ struct __MIDL___MIDL_itf_dia2_0000_0031_0001
+    {
+    DWORD ulOffStart;
+    DWORD cbProcSize;
+    DWORD cdwLocals;
+    WORD cdwParams;
+    WORD cdwFlags;
+    }  FPODATA;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_v0_0_s_ifspec;
+
+#ifndef __IDiaStackWalkHelper_INTERFACE_DEFINED__
+#define __IDiaStackWalkHelper_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalkHelper */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalkHelper;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("feb0155d-35a8-42d4-8328-bf458f429a3a")
+    IDiaStackWalkHelper : public IUnknown
+    {
+    public:
+        virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( 
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal) = 0;
+        
+        virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_registerValue( 
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE readMemory( 
+            /* [in] */ enum MemoryTypeEnum type,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddress( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE searchForReturnAddressStart( 
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE frameForVA( 
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaFrameData **ppFrame) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE symbolForVA( 
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaSymbol **ppSymbol) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE pdataForVA( 
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE imageForVA( 
+            /* [in] */ ULONGLONG vaContext,
+            /* [out] */ ULONGLONG *pvaImageStart) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaStackWalkHelperVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalkHelper * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalkHelper * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *readMemory )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ enum MemoryTypeEnum type,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *frameForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaFrameData **ppFrame);
+        
+        HRESULT ( STDMETHODCALLTYPE *symbolForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *pdataForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *imageForVA )( 
+            IDiaStackWalkHelper * This,
+            /* [in] */ ULONGLONG vaContext,
+            /* [out] */ ULONGLONG *pvaImageStart);
+        
+        END_INTERFACE
+    } IDiaStackWalkHelperVtbl;
+
+    interface IDiaStackWalkHelper
+    {
+        CONST_VTBL struct IDiaStackWalkHelperVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalkHelper_QueryInterface(This,riid,ppvObject)        \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalkHelper_AddRef(This)       \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalkHelper_Release(This)      \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalkHelper_get_registerValue(This,index,pRetVal)      \
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#define IDiaStackWalkHelper_put_registerValue(This,index,NewVal)       \
+    ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) 
+
+#define IDiaStackWalkHelper_readMemory(This,type,va,cbData,pcbData,pbData)     \
+    ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper_searchForReturnAddress(This,frame,returnAddress)   \
+    ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) 
+
+#define IDiaStackWalkHelper_searchForReturnAddressStart(This,frame,startAddress,returnAddress) \
+    ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) 
+
+#define IDiaStackWalkHelper_frameForVA(This,va,ppFrame)        \
+    ( (This)->lpVtbl -> frameForVA(This,va,ppFrame) ) 
+
+#define IDiaStackWalkHelper_symbolForVA(This,va,ppSymbol)      \
+    ( (This)->lpVtbl -> symbolForVA(This,va,ppSymbol) ) 
+
+#define IDiaStackWalkHelper_pdataForVA(This,va,cbData,pcbData,pbData)  \
+    ( (This)->lpVtbl -> pdataForVA(This,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper_imageForVA(This,vaContext,pvaImageStart)   \
+    ( (This)->lpVtbl -> imageForVA(This,vaContext,pvaImageStart) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaStackWalkHelper_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker_INTERFACE_DEFINED__
+#define __IDiaStackWalker_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalker */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalker;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5485216b-a54c-469f-9670-52b24d5229bb")
+    IDiaStackWalker : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE getEnumFrames( 
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE getEnumFrames2( 
+            /* [in] */ enum CV_CPU_TYPE_e cpuid,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum) = 0;
+        
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaStackWalkerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalker * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalker * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalker * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames )( 
+            IDiaStackWalker * This,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames2 )( 
+            IDiaStackWalker * This,
+            /* [in] */ enum CV_CPU_TYPE_e cpuid,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        END_INTERFACE
+    } IDiaStackWalkerVtbl;
+
+    interface IDiaStackWalker
+    {
+        CONST_VTBL struct IDiaStackWalkerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalker_QueryInterface(This,riid,ppvObject)    \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalker_AddRef(This)   \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalker_Release(This)  \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalker_getEnumFrames(This,pHelper,ppEnum)     \
+    ( (This)->lpVtbl -> getEnumFrames(This,pHelper,ppEnum) ) 
+
+#define IDiaStackWalker_getEnumFrames2(This,cpuid,pHelper,ppEnum)      \
+    ( (This)->lpVtbl -> getEnumFrames2(This,cpuid,pHelper,ppEnum) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaStackWalker_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackWalkHelper2_INTERFACE_DEFINED__
+#define __IDiaStackWalkHelper2_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalkHelper2 */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalkHelper2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8222c490-507b-4bef-b3bd-41dca7b5934c")
+    IDiaStackWalkHelper2 : public IDiaStackWalkHelper
+    {
+    public:
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaStackWalkHelper2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalkHelper2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalkHelper2 * This);
+        
+        /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ DWORD index,
+            /* [retval][out] */ ULONGLONG *pRetVal);
+        
+        /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ DWORD index,
+            /* [in] */ ULONGLONG NewVal);
+        
+        HRESULT ( STDMETHODCALLTYPE *readMemory )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ enum MemoryTypeEnum type,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ IDiaFrameData *frame,
+            /* [in] */ ULONGLONG startAddress,
+            /* [out] */ ULONGLONG *returnAddress);
+        
+        HRESULT ( STDMETHODCALLTYPE *frameForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaFrameData **ppFrame);
+        
+        HRESULT ( STDMETHODCALLTYPE *symbolForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG va,
+            /* [out] */ IDiaSymbol **ppSymbol);
+        
+        HRESULT ( STDMETHODCALLTYPE *pdataForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG va,
+            /* [in] */ DWORD cbData,
+            /* [out] */ DWORD *pcbData,
+            /* [size_is][out] */ BYTE *pbData);
+        
+        HRESULT ( STDMETHODCALLTYPE *imageForVA )( 
+            IDiaStackWalkHelper2 * This,
+            /* [in] */ ULONGLONG vaContext,
+            /* [out] */ ULONGLONG *pvaImageStart);
+        
+        END_INTERFACE
+    } IDiaStackWalkHelper2Vtbl;
+
+    interface IDiaStackWalkHelper2
+    {
+        CONST_VTBL struct IDiaStackWalkHelper2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalkHelper2_QueryInterface(This,riid,ppvObject)       \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalkHelper2_AddRef(This)      \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalkHelper2_Release(This)     \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalkHelper2_get_registerValue(This,index,pRetVal)     \
+    ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) 
+
+#define IDiaStackWalkHelper2_put_registerValue(This,index,NewVal)      \
+    ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) 
+
+#define IDiaStackWalkHelper2_readMemory(This,type,va,cbData,pcbData,pbData)    \
+    ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper2_searchForReturnAddress(This,frame,returnAddress)  \
+    ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) 
+
+#define IDiaStackWalkHelper2_searchForReturnAddressStart(This,frame,startAddress,returnAddress)        \
+    ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) 
+
+#define IDiaStackWalkHelper2_frameForVA(This,va,ppFrame)       \
+    ( (This)->lpVtbl -> frameForVA(This,va,ppFrame) ) 
+
+#define IDiaStackWalkHelper2_symbolForVA(This,va,ppSymbol)     \
+    ( (This)->lpVtbl -> symbolForVA(This,va,ppSymbol) ) 
+
+#define IDiaStackWalkHelper2_pdataForVA(This,va,cbData,pcbData,pbData) \
+    ( (This)->lpVtbl -> pdataForVA(This,va,cbData,pcbData,pbData) ) 
+
+#define IDiaStackWalkHelper2_imageForVA(This,vaContext,pvaImageStart)  \
+    ( (This)->lpVtbl -> imageForVA(This,vaContext,pvaImageStart) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaStackWalkHelper2_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDiaStackWalker2_INTERFACE_DEFINED__
+#define __IDiaStackWalker2_INTERFACE_DEFINED__
+
+/* interface IDiaStackWalker2 */
+/* [unique][helpstring][local][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDiaStackWalker2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7c185885-a015-4cac-9411-0f4fb39b1f3a")
+    IDiaStackWalker2 : public IDiaStackWalker
+    {
+    public:
+    };
+    
+#else  /* C style interface */
+
+    typedef struct IDiaStackWalker2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDiaStackWalker2 * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDiaStackWalker2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDiaStackWalker2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames )( 
+            IDiaStackWalker2 * This,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        HRESULT ( STDMETHODCALLTYPE *getEnumFrames2 )( 
+            IDiaStackWalker2 * This,
+            /* [in] */ enum CV_CPU_TYPE_e cpuid,
+            /* [in] */ IDiaStackWalkHelper *pHelper,
+            /* [out] */ IDiaEnumStackFrames **ppEnum);
+        
+        END_INTERFACE
+    } IDiaStackWalker2Vtbl;
+
+    interface IDiaStackWalker2
+    {
+        CONST_VTBL struct IDiaStackWalker2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDiaStackWalker2_QueryInterface(This,riid,ppvObject)   \
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDiaStackWalker2_AddRef(This)  \
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDiaStackWalker2_Release(This) \
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDiaStackWalker2_getEnumFrames(This,pHelper,ppEnum)    \
+    ( (This)->lpVtbl -> getEnumFrames(This,pHelper,ppEnum) ) 
+
+#define IDiaStackWalker2_getEnumFrames2(This,cpuid,pHelper,ppEnum)     \
+    ( (This)->lpVtbl -> getEnumFrames2(This,cpuid,pHelper,ppEnum) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif         /* C style interface */
+
+
+
+
+#endif         /* __IDiaStackWalker2_INTERFACE_DEFINED__ */
+
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

diff --git a/src/ToolBox/PdbTypeMatch/include/diacreate.h b/src/ToolBox/PdbTypeMatch/include/diacreate.h
new file mode 100644 (file)
index 0000000..fac6668
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/diacreate.h
@@ -0,0 +1,42 @@
+// diacreate.h - creation helper functions for DIA initialization
+//-----------------------------------------------------------------
+// 
+// Copyright Microsoft Corporation.  All Rights Reserved.
+//
+//---------------------------------------------------------------
+#ifndef _DIACREATE_H_
+#define _DIACREATE_H_
+
+//
+// Create a dia data source object from the dia dll (by dll name - does not access the registry).
+//
+
+HRESULT STDMETHODCALLTYPE NoRegCoCreate(  const __wchar_t *dllName,
+                        REFCLSID   rclsid,
+                        REFIID     riid,
+                        void     **ppv);
+
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#ifdef __cplusplus
+
+HRESULT STDMETHODCALLTYPE NoRegCoCreate(  const wchar_t *dllName,
+                        REFCLSID   rclsid,
+                        REFIID     riid,
+                        void     **ppv) 
+{
+    return NoRegCoCreate( (const __wchar_t *)dllName, rclsid, riid, ppv );
+}
+
+#endif
+#endif
+
+
+
+//
+// Create a dia data source object from the dia dll (looks up the class id in the registry).
+//
+HRESULT STDMETHODCALLTYPE NoOleCoCreate(  REFCLSID   rclsid,
+                        REFIID     riid,
+                        void     **ppv);
+
+#endif

diff --git a/src/ToolBox/PdbTypeMatch/native.rc b/src/ToolBox/PdbTypeMatch/native.rc
new file mode 100644 (file)
index 0000000..c4474f2
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>

diff --git a/src/ToolBox/PdbTypeMatch/regs.cpp b/src/ToolBox/PdbTypeMatch/regs.cpp
new file mode 100644 (file)
index 0000000..4358f81
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/regs.cpp
@@ -0,0 +1,1704 @@
+#include "stdafx.h"
+#include "cvconst.h"
+#include "regs.h"
+
+const wchar_t * const rgRegX86[] = {
+    L"None",         // 0   CV_REG_NONE
+    L"al",           // 1   CV_REG_AL
+    L"cl",           // 2   CV_REG_CL
+    L"dl",           // 3   CV_REG_DL
+    L"bl",           // 4   CV_REG_BL
+    L"ah",           // 5   CV_REG_AH
+    L"ch",           // 6   CV_REG_CH
+    L"dh",           // 7   CV_REG_DH
+    L"bh",           // 8   CV_REG_BH
+    L"ax",           // 9   CV_REG_AX
+    L"cx",           // 10  CV_REG_CX
+    L"dx",           // 11  CV_REG_DX
+    L"bx",           // 12  CV_REG_BX
+    L"sp",           // 13  CV_REG_SP
+    L"bp",           // 14  CV_REG_BP
+    L"si",           // 15  CV_REG_SI
+    L"di",           // 16  CV_REG_DI
+    L"eax",          // 17  CV_REG_EAX
+    L"ecx",          // 18  CV_REG_ECX
+    L"edx",          // 19  CV_REG_EDX
+    L"ebx",          // 20  CV_REG_EBX
+    L"esp",          // 21  CV_REG_ESP
+    L"ebp",          // 22  CV_REG_EBP
+    L"esi",          // 23  CV_REG_ESI
+    L"edi",          // 24  CV_REG_EDI
+    L"es",           // 25  CV_REG_ES
+    L"cs",           // 26  CV_REG_CS
+    L"ss",           // 27  CV_REG_SS
+    L"ds",           // 28  CV_REG_DS
+    L"fs",           // 29  CV_REG_FS
+    L"gs",           // 30  CV_REG_GS
+    L"IP",           // 31  CV_REG_IP
+    L"FLAGS",        // 32  CV_REG_FLAGS
+    L"EIP",          // 33  CV_REG_EIP
+    L"EFLAGS",       // 34  CV_REG_EFLAG
+    L"???",          // 35
+    L"???",          // 36
+    L"???",          // 37
+    L"???",          // 38
+    L"???",          // 39
+    L"TEMP",         // 40  CV_REG_TEMP
+    L"TEMPH"         // 41  CV_REG_TEMPH
+    L"QUOTE",        // 42  CV_REG_QUOTE
+    L"PCDR3",        // 43  CV_REG_PCDR3
+    L"PCDR4",        // 44  CV_REG_PCDR4
+    L"PCDR5",        // 45  CV_REG_PCDR5
+    L"PCDR6",        // 46  CV_REG_PCDR6
+    L"PCDR7",        // 47  CV_REG_PCDR7
+    L"???",          // 48
+    L"???",          // 49
+    L"???",          // 50
+    L"???",          // 51
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"???",          // 60
+    L"???",          // 61
+    L"???",          // 62
+    L"???",          // 63
+    L"???",          // 64
+    L"???",          // 65
+    L"???",          // 66
+    L"???",          // 67
+    L"???",          // 68
+    L"???",          // 69
+    L"???",          // 70
+    L"???",          // 71
+    L"???",          // 72
+    L"???",          // 73
+    L"???",          // 74
+    L"???",          // 75
+    L"???",          // 76
+    L"???",          // 77
+    L"???",          // 78
+    L"???",          // 79
+    L"cr0",          // 80  CV_REG_CR0
+    L"cr1",          // 81  CV_REG_CR1
+    L"cr2",          // 82  CV_REG_CR2
+    L"cr3",          // 83  CV_REG_CR3
+    L"cr4",          // 84  CV_REG_CR4
+    L"???",          // 85
+    L"???",          // 86
+    L"???",          // 87
+    L"???",          // 88
+    L"???",          // 89
+    L"dr0",          // 90  CV_REG_DR0
+    L"dr1",          // 91  CV_REG_DR1
+    L"dr2",          // 92  CV_REG_DR2
+    L"dr3",          // 93  CV_REG_DR3
+    L"dr4",          // 94  CV_REG_DR4
+    L"dr5",          // 95  CV_REG_DR5
+    L"dr6",          // 96  CV_REG_DR6
+    L"dr7",          // 97  CV_REG_DR7
+    L"???",          // 98
+    L"???",          // 99
+    L"???",          // 10
+    L"???",          // 101
+    L"???",          // 102
+    L"???",          // 103
+    L"???",          // 104
+    L"???",          // 105
+    L"???",          // 106
+    L"???",          // 107
+    L"???",          // 108
+    L"???",          // 109
+    L"GDTR",         // 110 CV_REG_GDTR
+    L"GDTL",         // 111 CV_REG_GDTL
+    L"IDTR",         // 112 CV_REG_IDTR
+    L"IDTL",         // 113 CV_REG_IDTL
+    L"LDTR",         // 114 CV_REG_LDTR
+    L"TR",           // 115 CV_REG_TR
+    L"???",          // 116
+    L"???",          // 117
+    L"???",          // 118
+    L"???",          // 119
+    L"???",          // 120
+    L"???",          // 121
+    L"???",          // 122
+    L"???",          // 123
+    L"???",          // 124
+    L"???",          // 125
+    L"???",          // 126
+    L"???",          // 127
+    L"st(0)",        // 128 CV_REG_ST0
+    L"st(1)",        // 129 CV_REG_ST1
+    L"st(2)",        // 130 CV_REG_ST2
+    L"st(3)",        // 131 CV_REG_ST3
+    L"st(4)",        // 132 CV_REG_ST4
+    L"st(5)",        // 133 CV_REG_ST5
+    L"st(6)",        // 134 CV_REG_ST6
+    L"st(7)",        // 135 CV_REG_ST7
+    L"CTRL",         // 136 CV_REG_CTRL
+    L"STAT",         // 137 CV_REG_STAT
+    L"TAG",          // 138 CV_REG_TAG
+    L"FPIP",         // 139 CV_REG_FPIP
+    L"FPCS",         // 140 CV_REG_FPCS
+    L"FPDO",         // 141 CV_REG_FPDO
+    L"FPDS",         // 142 CV_REG_FPDS
+    L"ISEM",         // 143 CV_REG_ISEM
+    L"FPEIP",        // 144 CV_REG_FPEIP
+    L"FPED0"         // 145 CV_REG_FPEDO
+};
+
+const wchar_t * const rgRegAMD64[] = {
+    L"None",         // 0   CV_REG_NONE
+    L"al",           // 1   CV_AMD64_AL
+    L"cl",           // 2   CV_AMD64_CL
+    L"dl",           // 3   CV_AMD64_DL
+    L"bl",           // 4   CV_AMD64_BL
+    L"ah",           // 5   CV_AMD64_AH
+    L"ch",           // 6   CV_AMD64_CH
+    L"dh",           // 7   CV_AMD64_DH
+    L"bh",           // 8   CV_AMD64_BH
+    L"ax",           // 9   CV_AMD64_AX
+    L"cx",           // 10  CV_AMD64_CX
+    L"dx",           // 11  CV_AMD64_DX
+    L"bx",           // 12  CV_AMD64_BX
+    L"sp",           // 13  CV_AMD64_SP
+    L"bp",           // 14  CV_AMD64_BP
+    L"si",           // 15  CV_AMD64_SI
+    L"di",           // 16  CV_AMD64_DI
+    L"eax",          // 17  CV_AMD64_EAX
+    L"ecx",          // 18  CV_AMD64_ECX
+    L"edx",          // 19  CV_AMD64_EDX
+    L"ebx",          // 20  CV_AMD64_EBX
+    L"esp",          // 21  CV_AMD64_ESP
+    L"ebp",          // 22  CV_AMD64_EBP
+    L"esi",          // 23  CV_AMD64_ESI
+    L"edi",          // 24  CV_AMD64_EDI
+    L"es",           // 25  CV_AMD64_ES
+    L"cs",           // 26  CV_AMD64_CS
+    L"ss",           // 27  CV_AMD64_SS
+    L"ds",           // 28  CV_AMD64_DS
+    L"fs",           // 29  CV_AMD64_FS
+    L"gs",           // 30  CV_AMD64_GS
+    L"???",          // 31  Not filled up
+    L"flags",        // 32  CV_AMD64_FLAGS
+    L"rip",          // 33  CV_AMD64_RIP
+    L"eflags",       // 34  CV_AMD64_EFLAGS
+    L"???",          // 35
+    L"???",          // 36
+    L"???",          // 37
+    L"???",          // 38
+    L"???",          // 39
+    L"???",          // 40
+    L"???",          // 41
+    L"???",          // 42
+    L"???",          // 43
+    L"???",          // 44
+    L"???",          // 45
+    L"???",          // 46
+    L"???",          // 47
+    L"???",          // 48
+    L"???",          // 49
+    L"???",          // 50
+    L"???",          // 51
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"???",          // 60
+    L"???",          // 61
+    L"???",          // 62
+    L"???",          // 63
+    L"???",          // 64
+    L"???",          // 65
+    L"???",          // 66
+    L"???",          // 67
+    L"???",          // 68
+    L"???",          // 69
+    L"???",          // 70
+    L"???",          // 71
+    L"???",          // 72
+    L"???",          // 73
+    L"???",          // 74
+    L"???",          // 75
+    L"???",          // 76
+    L"???",          // 77
+    L"???",          // 78
+    L"???",          // 79
+    L"cr0",          // 80  CV_AMD64_CR0
+    L"cr1",          // 81  CV_AMD64_CR1
+    L"cr2",          // 82  CV_AMD64_CR2
+    L"cr3",          // 83  CV_AMD64_CR3
+    L"cr4",          // 84  CV_AMD64_CR4
+    L"???",          // 85
+    L"???",          // 86
+    L"???",          // 87
+    L"cr8",          // 88  CV_AMD64_CR8
+    L"???",          // 89
+    L"dr0",          // 90  CV_AMD64_DR0
+    L"dr1",          // 91  CV_AMD64_DR1
+    L"dr2",          // 92  CV_AMD64_DR2
+    L"dr3",          // 93  CV_AMD64_DR3
+    L"dr4",          // 94  CV_AMD64_DR4
+    L"dr5",          // 95  CV_AMD64_DR5
+    L"dr6",          // 96  CV_AMD64_DR6
+    L"dr7",          // 97  CV_AMD64_DR7
+    L"dr8",          // 98  CV_AMD64_DR8
+    L"dr9",          // 99  CV_AMD64_DR9
+    L"dr10",         // 100 CV_AMD64_DR10
+    L"dr11",         // 101 CV_AMD64_DR11
+    L"dr12",         // 102 CV_AMD64_DR12
+    L"dr13",         // 103 CV_AMD64_DR13
+    L"dr14",         // 104 CV_AMD64_DR14
+    L"dr15",         // 105 CV_AMD64_DR15
+    L"???",          // 106
+    L"???",          // 107
+    L"???",          // 108
+    L"???",          // 109
+    L"gdtr",         // 110 CV_AMD64_GDTR
+    L"gdt",         // 111 CV_AMD64_GDTL
+    L"idtr",         // 112 CV_AMD64_IDTR
+    L"idt",         // 113 CV_AMD64_IDTL
+    L"ldtr",         // 114 CV_AMD64_LDTR
+    L"tr",           // 115 CV_AMD64_TR
+    L"???",          // 116
+    L"???",          // 117
+    L"???",          // 118
+    L"???",          // 119
+    L"???",          // 120
+    L"???",          // 121
+    L"???",          // 122
+    L"???",          // 123
+    L"???",          // 124
+    L"???",          // 125
+    L"???",          // 126
+    L"???",          // 127
+    L"st(0)",        // 128 CV_AMD64_ST0
+    L"st(1)",        // 129 CV_AMD64_ST1
+    L"st(2)",        // 130 CV_AMD64_ST2
+    L"st(3)",        // 131 CV_AMD64_ST3
+    L"st(4)",        // 132 CV_AMD64_ST4
+    L"st(5)",        // 133 CV_AMD64_ST5
+    L"st(6)",        // 134 CV_AMD64_ST6
+    L"st(7)",        // 135 CV_AMD64_ST7
+    L"ctr",         // 136 CV_AMD64_CTRL
+    L"stat",         // 137 CV_AMD64_STAT
+    L"tag",          // 138 CV_AMD64_TAG
+    L"fpip",         // 139 CV_AMD64_FPIP
+    L"fpcs",         // 140 CV_AMD64_FPCS
+    L"fpdo",         // 141 CV_AMD64_FPDO
+    L"fpds",         // 142 CV_AMD64_FPDS
+    L"isem",         // 143 CV_AMD64_ISEM
+    L"fpeip",        // 144 CV_AMD64_FPEIP
+    L"fped0",        // 145 CV_AMD64_FPEDO
+    L"mm0",          // 146 CV_AMD64_MM0
+    L"mm1",          // 147 CV_AMD64_MM1
+    L"mm2",          // 148 CV_AMD64_MM2
+    L"mm3",          // 149 CV_AMD64_MM3
+    L"mm4",          // 150 CV_AMD64_MM4
+    L"mm5",          // 151 CV_AMD64_MM5
+    L"mm6",          // 152 CV_AMD64_MM6
+    L"mm7",          // 153 CV_AMD64_MM7
+    L"xmm0",         // 154 CV_AMD64_XMM0
+    L"xmm1",         // 155 CV_AMD64_XMM1
+    L"xmm2",         // 156 CV_AMD64_XMM2
+    L"xmm3",         // 157 CV_AMD64_XMM3
+    L"xmm4",         // 158 CV_AMD64_XMM4
+    L"xmm5",         // 159 CV_AMD64_XMM5
+    L"xmm6",         // 160 CV_AMD64_XMM6
+    L"xmm7",         // 161 CV_AMD64_XMM7
+    L"xmm0_0",       // 162 CV_AMD64_XMM0_0
+    L"xmm0_1",       // 163 CV_AMD64_XMM0_1
+    L"xmm0_2",       // 164 CV_AMD64_XMM0_2
+    L"xmm0_3",       // 165 CV_AMD64_XMM0_3
+    L"xmm1_0",       // 166 CV_AMD64_XMM1_0
+    L"xmm1_1",       // 167 CV_AMD64_XMM1_1
+    L"xmm1_2",       // 168 CV_AMD64_XMM1_2
+    L"xmm1_3",       // 169 CV_AMD64_XMM1_3
+    L"xmm2_0",       // 170 CV_AMD64_XMM2_0
+    L"xmm2_1",       // 171 CV_AMD64_XMM2_1
+    L"xmm2_2",       // 172 CV_AMD64_XMM2_2
+    L"xmm2_3",       // 173 CV_AMD64_XMM2_3
+    L"xmm3_0",       // 174 CV_AMD64_XMM3_0
+    L"xmm3_1",       // 175 CV_AMD64_XMM3_1
+    L"xmm3_2",       // 176 CV_AMD64_XMM3_2
+    L"xmm3_3",       // 177 CV_AMD64_XMM3_3
+    L"xmm4_0",       // 178 CV_AMD64_XMM4_0
+    L"xmm4_1",       // 179 CV_AMD64_XMM4_1
+    L"xmm4_2",       // 180 CV_AMD64_XMM4_2
+    L"xmm4_3",       // 181 CV_AMD64_XMM4_3
+    L"xmm5_0",       // 182 CV_AMD64_XMM5_0
+    L"xmm5_1",       // 183 CV_AMD64_XMM5_1
+    L"xmm5_2",       // 184 CV_AMD64_XMM5_2
+    L"xmm5_3",       // 185 CV_AMD64_XMM5_3
+    L"xmm6_0",       // 186 CV_AMD64_XMM6_0
+    L"xmm6_1",       // 187 CV_AMD64_XMM6_1
+    L"xmm6_2",       // 188 CV_AMD64_XMM6_2
+    L"xmm6_3",       // 189 CV_AMD64_XMM6_3
+    L"xmm7_0",       // 190 CV_AMD64_XMM7_0
+    L"xmm7_1",       // 191 CV_AMD64_XMM7_1
+    L"xmm7_2",       // 192 CV_AMD64_XMM7_2
+    L"xmm7_3",       // 193 CV_AMD64_XMM7_3
+    L"xmm0",        // 194 CV_AMD64_XMM0L
+    L"xmm1",        // 195 CV_AMD64_XMM1L
+    L"xmm2",        // 196 CV_AMD64_XMM2L
+    L"xmm3",        // 197 CV_AMD64_XMM3L
+    L"xmm4",        // 198 CV_AMD64_XMM4L
+    L"xmm5",        // 199 CV_AMD64_XMM5L
+    L"xmm6",        // 200 CV_AMD64_XMM6L
+    L"xmm7",        // 201 CV_AMD64_XMM7L
+    L"xmm0h",        // 202 CV_AMD64_XMM0H
+    L"xmm1h",        // 203 CV_AMD64_XMM1H
+    L"xmm2h",        // 204 CV_AMD64_XMM2H
+    L"xmm3h",        // 205 CV_AMD64_XMM3H
+    L"xmm4h",        // 206 CV_AMD64_XMM4H
+    L"xmm5h",        // 207 CV_AMD64_XMM5H
+    L"xmm6h",        // 208 CV_AMD64_XMM6H
+    L"xmm7h",        // 209 CV_AMD64_XMM7H
+    L"???",          // 210
+    L"mxcsr",        // 211 CV_AMD64_MXCSR
+    L"???",          // 212
+    L"???",          // 213
+    L"???",          // 214
+    L"???",          // 215
+    L"???",          // 216
+    L"???",          // 217
+    L"???",          // 218
+    L"???",          // 219
+    L"emm0",        // 220 CV_AMD64_EMM0L
+    L"emm1",        // 221 CV_AMD64_EMM1L
+    L"emm2",        // 222 CV_AMD64_EMM2L
+    L"emm3",        // 223 CV_AMD64_EMM3L
+    L"emm4",        // 224 CV_AMD64_EMM4L
+    L"emm5",        // 225 CV_AMD64_EMM5L
+    L"emm6",        // 226 CV_AMD64_EMM6L
+    L"emm7",        // 227 CV_AMD64_EMM7L
+    L"emm0h",        // 228 CV_AMD64_EMM0H
+    L"emm1h",        // 229 CV_AMD64_EMM1H
+    L"emm2h",        // 230 CV_AMD64_EMM2H
+    L"emm3h",        // 231 CV_AMD64_EMM3H
+    L"emm4h",        // 232 CV_AMD64_EMM4H
+    L"emm5h",        // 233 CV_AMD64_EMM5H
+    L"emm6h",        // 234 CV_AMD64_EMM6H
+    L"emm7h",        // 235 CV_AMD64_EMM7H
+    L"mm00",         // 236 CV_AMD64_MM00
+    L"mm01",         // 237 CV_AMD64_MM01
+    L"mm10",         // 238 CV_AMD64_MM10
+    L"mm11",         // 239 CV_AMD64_MM11
+    L"mm20",         // 240 CV_AMD64_MM20
+    L"mm21",         // 241 CV_AMD64_MM21
+    L"mm30",         // 242 CV_AMD64_MM30
+    L"mm31",         // 243 CV_AMD64_MM31
+    L"mm40",         // 244 CV_AMD64_MM40
+    L"mm41",         // 245 CV_AMD64_MM41
+    L"mm50",         // 246 CV_AMD64_MM50
+    L"mm51",         // 247 CV_AMD64_MM51
+    L"mm60",         // 248 CV_AMD64_MM60
+    L"mm61",         // 249 CV_AMD64_MM61
+    L"mm70",         // 250 CV_AMD64_MM70
+    L"mm71",         // 251 CV_AMD64_MM71
+    L"xmm8",         // 252 CV_AMD64_XMM8
+    L"xmm9",         // 253 CV_AMD64_XMM9
+    L"xmm10",        // 254 CV_AMD64_XMM10
+    L"xmm11",        // 255 CV_AMD64_XMM11
+    L"xmm12",        // 256 CV_AMD64_XMM12
+    L"xmm13",        // 257 CV_AMD64_XMM13
+    L"xmm14",        // 258 CV_AMD64_XMM14
+    L"xmm15",        // 259 CV_AMD64_XMM15
+    L"xmm8_0",       // 260 CV_AMD64_XMM8_0
+    L"xmm8_1",       // 261 CV_AMD64_XMM8_1
+    L"xmm8_2",       // 262 CV_AMD64_XMM8_2
+    L"xmm8_3",       // 263 CV_AMD64_XMM8_3
+    L"xmm9_0",       // 264 CV_AMD64_XMM9_0
+    L"xmm9_1",       // 265 CV_AMD64_XMM9_1
+    L"xmm9_2",       // 266 CV_AMD64_XMM9_2
+    L"xmm9_3",       // 267 CV_AMD64_XMM9_3
+    L"xmm10_0",      // 268 CV_AMD64_XMM10_0
+    L"xmm10_1",      // 269 CV_AMD64_XMM10_1
+    L"xmm10_2",      // 270 CV_AMD64_XMM10_2
+    L"xmm10_3",      // 271 CV_AMD64_XMM10_3
+    L"xmm11_0",      // 272 CV_AMD64_XMM11_0
+    L"xmm11_1",      // 273 CV_AMD64_XMM11_1
+    L"xmm11_2",      // 274 CV_AMD64_XMM11_2
+    L"xmm11_3",      // 275 CV_AMD64_XMM11_3
+    L"xmm12_0",      // 276 CV_AMD64_XMM12_0
+    L"xmm12_1",      // 277 CV_AMD64_XMM12_1
+    L"xmm12_2",      // 278 CV_AMD64_XMM12_2
+    L"xmm12_3",      // 279 CV_AMD64_XMM12_3
+    L"xmm13_0",      // 280 CV_AMD64_XMM13_0
+    L"xmm13_1",      // 281 CV_AMD64_XMM13_1
+    L"xmm13_2",      // 282 CV_AMD64_XMM13_2
+    L"xmm13_3",      // 283 CV_AMD64_XMM13_3
+    L"xmm14_0",      // 284 CV_AMD64_XMM14_0
+    L"xmm14_1",      // 285 CV_AMD64_XMM14_1
+    L"xmm14_2",      // 286 CV_AMD64_XMM14_2
+    L"xmm14_3",      // 287 CV_AMD64_XMM14_3
+    L"xmm15_0",      // 288 CV_AMD64_XMM15_0
+    L"xmm15_1",      // 289 CV_AMD64_XMM15_1
+    L"xmm15_2",      // 290 CV_AMD64_XMM15_2
+    L"xmm15_3",      // 291 CV_AMD64_XMM15_3
+    L"xmm8",        // 292 CV_AMD64_XMM8L
+    L"xmm9",        // 293 CV_AMD64_XMM9L
+    L"xmm10",       // 294 CV_AMD64_XMM10L
+    L"xmm11",       // 295 CV_AMD64_XMM11L
+    L"xmm12",       // 296 CV_AMD64_XMM12L
+    L"xmm13",       // 297 CV_AMD64_XMM13L
+    L"xmm14",       // 298 CV_AMD64_XMM14L
+    L"xmm15",       // 299 CV_AMD64_XMM15L
+    L"xmm8h",        // 300 CV_AMD64_XMM8H
+    L"xmm9h",        // 301 CV_AMD64_XMM9H
+    L"xmm10h",       // 302 CV_AMD64_XMM10H
+    L"xmm11h",       // 303 CV_AMD64_XMM11H
+    L"xmm12h",       // 304 CV_AMD64_XMM12H
+    L"xmm13h",       // 305 CV_AMD64_XMM13H
+    L"xmm14h",       // 306 CV_AMD64_XMM14H
+    L"xmm15h",       // 307 CV_AMD64_XMM15H
+    L"emm8",        // 308 CV_AMD64_EMM8L
+    L"emm9",        // 309 CV_AMD64_EMM9L
+    L"emm10",       // 310 CV_AMD64_EMM10L
+    L"emm11",       // 311 CV_AMD64_EMM11L
+    L"emm12",       // 312 CV_AMD64_EMM12L
+    L"emm13",       // 313 CV_AMD64_EMM13L
+    L"emm14",       // 314 CV_AMD64_EMM14L
+    L"emm15",       // 315 CV_AMD64_EMM15L
+    L"emm8h",        // 316 CV_AMD64_EMM8H
+    L"emm9h",        // 317 CV_AMD64_EMM9H
+    L"emm10h",       // 318 CV_AMD64_EMM10H
+    L"emm11h",       // 319 CV_AMD64_EMM11H
+    L"emm12h",       // 320 CV_AMD64_EMM12H
+    L"emm13h",       // 321 CV_AMD64_EMM13H
+    L"emm14h",       // 322 CV_AMD64_EMM14H
+    L"emm15h",       // 323 CV_AMD64_EMM15H
+    L"si",          // 324 CV_AMD64_SIL
+    L"di",          // 325 CV_AMD64_DIL
+    L"bp",          // 326 CV_AMD64_BPL
+    L"sp",          // 327 CV_AMD64_SPL
+    L"rax",          // 328 CV_AMD64_RAX
+    L"rbx",          // 329 CV_AMD64_RBX
+    L"rcx",          // 330 CV_AMD64_RCX
+    L"rdx",          // 331 CV_AMD64_RDX
+    L"rsi",          // 332 CV_AMD64_RSI
+    L"rdi",          // 333 CV_AMD64_RDI
+    L"rbp",          // 334 CV_AMD64_RBP
+    L"rsp",          // 335 CV_AMD64_RSP
+    L"r8",           // 336 CV_AMD64_R8
+    L"r9",           // 337 CV_AMD64_R9
+    L"r10",          // 338 CV_AMD64_R10
+    L"r11",          // 339 CV_AMD64_R11
+    L"r12",          // 340 CV_AMD64_R12
+    L"r13",          // 341 CV_AMD64_R13
+    L"r14",          // 342 CV_AMD64_R14
+    L"r15",          // 343 CV_AMD64_R15
+    L"r8b",          // 344 CV_AMD64_R8B
+    L"r9b",          // 345 CV_AMD64_R9B
+    L"r10b",         // 346 CV_AMD64_R10B
+    L"r11b",         // 347 CV_AMD64_R11B
+    L"r12b",         // 348 CV_AMD64_R12B
+    L"r13b",         // 349 CV_AMD64_R13B
+    L"r14b",         // 350 CV_AMD64_R14B
+    L"r15b",         // 351 CV_AMD64_R15B
+    L"r8w",          // 352 CV_AMD64_R8W
+    L"r9w",          // 353 CV_AMD64_R9W
+    L"r10w",         // 354 CV_AMD64_R10W
+    L"r11w",         // 355 CV_AMD64_R11W
+    L"r12w",         // 356 CV_AMD64_R12W
+    L"r13w",         // 357 CV_AMD64_R13W
+    L"r14w",         // 358 CV_AMD64_R14W
+    L"r15w",         // 359 CV_AMD64_R15W
+    L"r8d",          // 360 CV_AMD64_R8D
+    L"r9d",          // 361 CV_AMD64_R9D
+    L"r10d",         // 362 CV_AMD64_R10D
+    L"r11d",         // 363 CV_AMD64_R11D
+    L"r12d",         // 364 CV_AMD64_R12D
+    L"r13d",         // 365 CV_AMD64_R13D
+    L"r14d",         // 366 CV_AMD64_R14D
+    L"r15d"          // 367 CV_AMD64_R15D
+};
+
+const wchar_t * const rgRegMips[] = {
+    L"None",         // 0   CV_M4_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"zero",         // 10  CV_M4_IntZERO
+    L"at",           // 11  CV_M4_IntAT
+    L"v0",           // 12  CV_M4_IntV0
+    L"v1",           // 13  CV_M4_IntV1
+    L"a0",           // 14  CV_M4_IntA0
+    L"a1",           // 15  CV_M4_IntA1
+    L"a2",           // 16  CV_M4_IntA2
+    L"a3",           // 17  CV_M4_IntA3
+    L"t0",           // 18  CV_M4_IntT0
+    L"t1",           // 19  CV_M4_IntT1
+    L"t2",           // 20  CV_M4_IntT2
+    L"t3",           // 21  CV_M4_IntT3
+    L"t4",           // 22  CV_M4_IntT4
+    L"t5",           // 23  CV_M4_IntT5
+    L"t6",           // 24  CV_M4_IntT6
+    L"t7",           // 25  CV_M4_IntT7
+    L"s0",           // 26  CV_M4_IntS0
+    L"s1",           // 27  CV_M4_IntS1
+    L"s2",           // 28  CV_M4_IntS2
+    L"s3",           // 29  CV_M4_IntS3
+    L"s4",           // 30  CV_M4_IntS4
+    L"s5",           // 31  CV_M4_IntS5
+    L"s6",           // 32  CV_M4_IntS6
+    L"s7",           // 33  CV_M4_IntS7
+    L"t8",           // 34  CV_M4_IntT8
+    L"t9",           // 35  CV_M4_IntT9
+    L"k0",           // 36  CV_M4_IntKT0
+    L"k1",           // 37  CV_M4_IntKT1
+    L"gp",           // 38  CV_M4_IntGP
+    L"sp",           // 39  CV_M4_IntSP
+    L"s8",           // 40  CV_M4_IntS8
+    L"ra",           // 41  CV_M4_IntRA
+    L"lo",           // 42  CV_M4_IntLO
+    L"hi",           // 43  CV_M4_IntHI
+    L"???",          // 44
+    L"???",          // 45
+    L"???",          // 46
+    L"???",          // 47
+    L"???",          // 48
+    L"???",          // 49
+    L"Fir",          // 50  CV_M4_Fir
+    L"Psr",          // 51  CV_M4_Psr
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"$f0",          // 60  CV_M4_FltF0
+    L"$f1",          // 61  CV_M4_FltF1
+    L"$f2",          // 62  CV_M4_FltF2
+    L"$f3",          // 63  CV_M4_FltF3
+    L"$f4",          // 64  CV_M4_FltF4
+    L"$f5",          // 65  CV_M4_FltF5
+    L"$f6",          // 66  CV_M4_FltF6
+    L"$f7",          // 67  CV_M4_FltF7
+    L"$f8",          // 68  CV_M4_FltF8
+    L"$f9",          // 69  CV_M4_FltF9
+    L"$f10",         // 70  CV_M4_FltF10
+    L"$f11",         // 71  CV_M4_FltF11
+    L"$f12",         // 72  CV_M4_FltF12
+    L"$f13",         // 73  CV_M4_FltF13
+    L"$f14",         // 74  CV_M4_FltF14
+    L"$f15",         // 75  CV_M4_FltF15
+    L"$f16",         // 76  CV_M4_FltF16
+    L"$f17",         // 77  CV_M4_FltF17
+    L"$f18",         // 78  CV_M4_FltF18
+    L"$f19",         // 79  CV_M4_FltF19
+    L"$f20",         // 80  CV_M4_FltF20
+    L"$f21",         // 81  CV_M4_FltF21
+    L"$f22",         // 82  CV_M4_FltF22
+    L"$f23",         // 83  CV_M4_FltF23
+    L"$f24",         // 84  CV_M4_FltF24
+    L"$f25",         // 85  CV_M4_FltF25
+    L"$f26",         // 86  CV_M4_FltF26
+    L"$f27",         // 87  CV_M4_FltF27
+    L"$f28",         // 88  CV_M4_FltF28
+    L"$f29",         // 89  CV_M4_FltF29
+    L"$f30",         // 90  CV_M4_FltF30
+    L"$f31",         // 91  CV_M4_FltF31
+    L"Fsr"           // 92  CV_M4_FltFsr
+};
+
+const wchar_t * const rgReg68k[] = {
+    L"D0",           // 0   CV_R68_D0
+    L"D1",           // 1   CV_R68_D1
+    L"D2",           // 2   CV_R68_D2
+    L"D3",           // 3   CV_R68_D3
+    L"D4",           // 4   CV_R68_D4
+    L"D5",           // 5   CV_R68_D5
+    L"D6",           // 6   CV_R68_D6
+    L"D7",           // 7   CV_R68_D7
+    L"A0",           // 8   CV_R68_A0
+    L"A1",           // 9   CV_R68_A1
+    L"A2",           // 10  CV_R68_A2
+    L"A3",           // 11  CV_R68_A3
+    L"A4",           // 12  CV_R68_A4
+    L"A5",           // 13  CV_R68_A5
+    L"A6",           // 14  CV_R68_A6
+    L"A7",           // 15  CV_R68_A7
+    L"CCR",          // 16  CV_R68_CCR
+    L"SR",           // 17  CV_R68_SR
+    L"USP",          // 18  CV_R68_USP
+    L"MSP",          // 19  CV_R68_MSP
+    L"SFC",          // 20  CV_R68_SFC
+    L"DFC",          // 21  CV_R68_DFC
+    L"CACR",         // 22  CV_R68_CACR
+    L"VBR",          // 23  CV_R68_VBR
+    L"CAAR",         // 24  CV_R68_CAAR
+    L"ISP",          // 25  CV_R68_ISP
+    L"PC",           // 26  CV_R68_PC
+    L"???",          // 27
+    L"FPCR",         // 28  CV_R68_FPCR
+    L"FPSR",         // 29  CV_R68_FPSR
+    L"FPIAR",        // 30  CV_R68_FPIAR
+    L"???",          // 31
+    L"FP0",          // 32  CV_R68_FP0
+    L"FP1",          // 33  CV_R68_FP1
+    L"FP2",          // 34  CV_R68_FP2
+    L"FP3",          // 35  CV_R68_FP3
+    L"FP4",          // 36  CV_R68_FP4
+    L"FP5",          // 37  CV_R68_FP5
+    L"FP6",          // 38  CV_R68_FP6
+    L"FP7",          // 39  CV_R68_FP7
+    L"???",          // 40
+    L"???",          // 41  CV_R68_MMUSR030
+    L"???",          // 42  CV_R68_MMUSR
+    L"???",          // 43  CV_R68_URP
+    L"???",          // 44  CV_R68_DTT0
+    L"???",          // 45  CV_R68_DTT1
+    L"???",          // 46  CV_R68_ITT0
+    L"???",          // 47  CV_R68_ITT1
+    L"???",          // 48
+    L"???",          // 49
+    L"???",          // 50
+    L"PSR",          // 51  CV_R68_PSR
+    L"PCSR",         // 52  CV_R68_PCSR
+    L"VAL",          // 53  CV_R68_VAL
+    L"CRP",          // 54  CV_R68_CRP
+    L"SRP",          // 55  CV_R68_SRP
+    L"DRP",          // 56  CV_R68_DRP
+    L"TC",           // 57  CV_R68_TC
+    L"AC",           // 58  CV_R68_AC
+    L"SCC",          // 59  CV_R68_SCC
+    L"CAL",          // 60  CV_R68_CAL
+    L"TT0",          // 61  CV_R68_TT0
+    L"TT1",          // 62  CV_R68_TT1
+    L"???",          // 63
+    L"BAD0",         // 64  CV_R68_BAD0
+    L"BAD1",         // 65  CV_R68_BAD1
+    L"BAD2",         // 66  CV_R68_BAD2
+    L"BAD3",         // 67  CV_R68_BAD3
+    L"BAD4",         // 68  CV_R68_BAD4
+    L"BAD5",         // 69  CV_R68_BAD5
+    L"BAD6",         // 70  CV_R68_BAD6
+    L"BAD7",         // 71  CV_R68_BAD7
+    L"BAC0",         // 72  CV_R68_BAC0
+    L"BAC1",         // 73  CV_R68_BAC1
+    L"BAC2",         // 74  CV_R68_BAC2
+    L"BAC3",         // 75  CV_R68_BAC3
+    L"BAC4",         // 76  CV_R68_BAC4
+    L"BAC5",         // 77  CV_R68_BAC5
+    L"BAC6",         // 78  CV_R68_BAC6
+    L"BAC7"          // 79  CV_R68_BAC7
+};
+
+const wchar_t * const rgRegAlpha[] = {
+    L"None",         // 0   CV_ALPHA_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"$f0",          // 10  CV_ALPHA_FltF0
+    L"$f1",          // 11  CV_ALPHA_FltF1
+    L"$f2",          // 12  CV_ALPHA_FltF2
+    L"$f3",          // 13  CV_ALPHA_FltF3
+    L"$f4",          // 14  CV_ALPHA_FltF4
+    L"$f5",          // 15  CV_ALPHA_FltF5
+    L"$f6",          // 16  CV_ALPHA_FltF6
+    L"$f7",          // 17  CV_ALPHA_FltF7
+    L"$f8",          // 18  CV_ALPHA_FltF8
+    L"$f9",          // 19  CV_ALPHA_FltF9
+    L"$f10",         // 20  CV_ALPHA_FltF10
+    L"$f11",         // 21  CV_ALPHA_FltF11
+    L"$f12",         // 22  CV_ALPHA_FltF12
+    L"$f13",         // 23  CV_ALPHA_FltF13
+    L"$f14",         // 24  CV_ALPHA_FltF14
+    L"$f15",         // 25  CV_ALPHA_FltF15
+    L"$f16",         // 26  CV_ALPHA_FltF16
+    L"$f17",         // 27  CV_ALPHA_FltF17
+    L"$f18",         // 28  CV_ALPHA_FltF18
+    L"$f19",         // 29  CV_ALPHA_FltF19
+    L"$f20",         // 30  CV_ALPHA_FltF20
+    L"$f21",         // 31  CV_ALPHA_FltF21
+    L"$f22",         // 32  CV_ALPHA_FltF22
+    L"$f23",         // 33  CV_ALPHA_FltF23
+    L"$f24",         // 34  CV_ALPHA_FltF24
+    L"$f25",         // 35  CV_ALPHA_FltF25
+    L"$f26",         // 36  CV_ALPHA_FltF26
+    L"$f27",         // 37  CV_ALPHA_FltF27
+    L"$f28",         // 38  CV_ALPHA_FltF28
+    L"$f29",         // 39  CV_ALPHA_FltF29
+    L"$f30",         // 40  CV_ALPHA_FltF30
+    L"$f31",         // 41  CV_ALPHA_FltF31
+    L"v0",           // 42  CV_ALPHA_IntV0
+    L"t0",           // 43  CV_ALPHA_IntT0
+    L"t1",           // 44  CV_ALPHA_IntT1
+    L"t2",           // 45  CV_ALPHA_IntT2
+    L"t3",           // 46  CV_ALPHA_IntT3
+    L"t4",           // 47  CV_ALPHA_IntT4
+    L"t5",           // 48  CV_ALPHA_IntT5
+    L"t6",           // 49  CV_ALPHA_IntT6
+    L"t7",           // 50  CV_ALPHA_IntT7
+    L"s0",           // 51  CV_ALPHA_IntS0
+    L"s1",           // 52  CV_ALPHA_IntS1
+    L"s2",           // 53  CV_ALPHA_IntS2
+    L"s3",           // 54  CV_ALPHA_IntS3
+    L"s4",           // 55  CV_ALPHA_IntS4
+    L"s5",           // 56  CV_ALPHA_IntS5
+    L"fp",           // 57  CV_ALPHA_IntFP
+    L"a0",           // 58  CV_ALPHA_IntA0
+    L"a1",           // 59  CV_ALPHA_IntA1
+    L"a2",           // 60  CV_ALPHA_IntA2
+    L"a3",           // 61  CV_ALPHA_IntA3
+    L"a4",           // 62  CV_ALPHA_IntA4
+    L"a5",           // 63  CV_ALPHA_IntA5
+    L"t8",           // 64  CV_ALPHA_IntT8
+    L"t9",           // 65  CV_ALPHA_IntT9
+    L"t10",          // 66  CV_ALPHA_IntT10
+    L"t11",          // 67  CV_ALPHA_IntT11
+    L"ra",           // 68  CV_ALPHA_IntRA
+    L"t12",          // 69  CV_ALPHA_IntT12
+    L"at",           // 70  CV_ALPHA_IntAT
+    L"gp",           // 71  CV_ALPHA_IntGP
+    L"sp",           // 72  CV_ALPHA_IntSP
+    L"zero",         // 73  CV_ALPHA_IntZERO
+    L"Fpcr",         // 74  CV_ALPHA_Fpcr
+    L"Fir",          // 75  CV_ALPHA_Fir
+    L"Psr",          // 76  CV_ALPHA_Psr
+    L"FltFsr"        // 77  CV_ALPHA_FltFsr
+};
+
+const wchar_t * const rgRegPpc[] = {
+    L"None",         // 0
+    L"r0",           // 1   CV_PPC_GPR0
+    L"r1",           // 2   CV_PPC_GPR1
+    L"r2",           // 3   CV_PPC_GPR2
+    L"r3",           // 4   CV_PPC_GPR3
+    L"r4",           // 5   CV_PPC_GPR4
+    L"r5",           // 6   CV_PPC_GPR5
+    L"r6",           // 7   CV_PPC_GPR6
+    L"r7",           // 8   CV_PPC_GPR7
+    L"r8",           // 9   CV_PPC_GPR8
+    L"r9",           // 10  CV_PPC_GPR9
+    L"r10",          // 11  CV_PPC_GPR10
+    L"r11",          // 12  CV_PPC_GPR11
+    L"r12",          // 13  CV_PPC_GPR12
+    L"r13",          // 14  CV_PPC_GPR13
+    L"r14",          // 15  CV_PPC_GPR14
+    L"r15",          // 16  CV_PPC_GPR15
+    L"r16",          // 17  CV_PPC_GPR16
+    L"r17",          // 18  CV_PPC_GPR17
+    L"r18",          // 19  CV_PPC_GPR18
+    L"r19",          // 20  CV_PPC_GPR19
+    L"r20",          // 21  CV_PPC_GPR20
+    L"r21",          // 22  CV_PPC_GPR21
+    L"r22",          // 23  CV_PPC_GPR22
+    L"r23",          // 24  CV_PPC_GPR23
+    L"r24",          // 25  CV_PPC_GPR24
+    L"r25",          // 26  CV_PPC_GPR25
+    L"r26",          // 27  CV_PPC_GPR26
+    L"r27",          // 28  CV_PPC_GPR27
+    L"r28",          // 29  CV_PPC_GPR28
+    L"r29",          // 30  CV_PPC_GPR29
+    L"r30",          // 31  CV_PPC_GPR30
+    L"r31",          // 32  CV_PPC_GPR31
+    L"cr",           // 33  CV_PPC_CR
+    L"cr0",          // 34  CV_PPC_CR0
+    L"cr1",          // 35  CV_PPC_CR1
+    L"cr2",          // 36  CV_PPC_CR2
+    L"cr3",          // 37  CV_PPC_CR3
+    L"cr4",          // 38  CV_PPC_CR4
+    L"cr5",          // 39  CV_PPC_CR5
+    L"cr6",          // 40  CV_PPC_CR6
+    L"cr7",          // 41  CV_PPC_CR7
+    L"f0",           // 42  CV_PPC_FPR0
+    L"f1",           // 43  CV_PPC_FPR1
+    L"f2",           // 44  CV_PPC_FPR2
+    L"f3",           // 45  CV_PPC_FPR3
+    L"f4",           // 46  CV_PPC_FPR4
+    L"f5",           // 47  CV_PPC_FPR5
+    L"f6",           // 48  CV_PPC_FPR6
+    L"f7",           // 49  CV_PPC_FPR7
+    L"f8",           // 50  CV_PPC_FPR8
+    L"f9",           // 51  CV_PPC_FPR9
+    L"f10",          // 52  CV_PPC_FPR10
+    L"f11",          // 53  CV_PPC_FPR11
+    L"f12",          // 54  CV_PPC_FPR12
+    L"f13",          // 55  CV_PPC_FPR13
+    L"f14",          // 56  CV_PPC_FPR14
+    L"f15",          // 57  CV_PPC_FPR15
+    L"f16",          // 58  CV_PPC_FPR16
+    L"f17",          // 59  CV_PPC_FPR17
+    L"f18",          // 60  CV_PPC_FPR18
+    L"f19",          // 61  CV_PPC_FPR19
+    L"f20",          // 62  CV_PPC_FPR20
+    L"f21",          // 63  CV_PPC_FPR21
+    L"f22",          // 64  CV_PPC_FPR22
+    L"f23",          // 65  CV_PPC_FPR23
+    L"f24",          // 66  CV_PPC_FPR24
+    L"f25",          // 67  CV_PPC_FPR25
+    L"f26",          // 68  CV_PPC_FPR26
+    L"f27",          // 69  CV_PPC_FPR27
+    L"f28",          // 70  CV_PPC_FPR28
+    L"f29",          // 71  CV_PPC_FPR29
+    L"f30",          // 72  CV_PPC_FPR30
+    L"f31",          // 73  CV_PPC_FPR31
+    L"Fpscr",        // 74  CV_PPC_FPSCR
+    L"Msr"           // 75  CV_PPC_MSR
+};
+
+const wchar_t * const rgRegSh[] = {
+    L"None",         // 0   CV_SH3_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"r0",           // 10  CV_SH3_IntR0
+    L"r1",           // 11  CV_SH3_IntR1
+    L"r2",           // 12  CV_SH3_IntR2
+    L"r3",           // 13  CV_SH3_IntR3
+    L"r4",           // 14  CV_SH3_IntR4
+    L"r5",           // 15  CV_SH3_IntR5
+    L"r6",           // 16  CV_SH3_IntR6
+    L"r7",           // 17  CV_SH3_IntR7
+    L"r8",           // 18  CV_SH3_IntR8
+    L"r9",           // 19  CV_SH3_IntR9
+    L"r10",          // 20  CV_SH3_IntR10
+    L"r11",          // 21  CV_SH3_IntR11
+    L"r12",          // 22  CV_SH3_IntR12
+    L"r13",          // 23  CV_SH3_IntR13
+    L"fp",           // 24  CV_SH3_IntFp
+    L"sp",           // 25  CV_SH3_IntSp
+    L"???",          // 26
+    L"???",          // 27
+    L"???",          // 28
+    L"???",          // 29
+    L"???",          // 30
+    L"???",          // 31
+    L"???",          // 32
+    L"???",          // 33
+    L"???",          // 34
+    L"???",          // 35
+    L"???",          // 36
+    L"???",          // 37
+    L"gbr",          // 38  CV_SH3_Gbr
+    L"pr",           // 39  CV_SH3_Pr
+    L"mach",         // 40  CV_SH3_Mach
+    L"macl",         // 41  CV_SH3_Macl
+    L"???",          // 42
+    L"???",          // 43
+    L"???",          // 44
+    L"???",          // 45
+    L"???",          // 46
+    L"???",          // 47
+    L"???",          // 48
+    L"???",          // 49
+    L"pc",           // 50
+    L"sr",           // 51
+    L"???",          // 52
+    L"???",          // 53
+    L"???",          // 54
+    L"???",          // 55
+    L"???",          // 56
+    L"???",          // 57
+    L"???",          // 58
+    L"???",          // 59
+    L"bara",         // 60  CV_SH3_BarA
+    L"basra",        // 61  CV_SH3_BasrA
+    L"bamra",        // 62  CV_SH3_BamrA
+    L"bbra",         // 63  CV_SH3_BbrA
+    L"barb",         // 64  CV_SH3_BarB
+    L"basrb",        // 65  CV_SH3_BasrB
+    L"bamrb",        // 66  CV_SH3_BamrB
+    L"bbrb",         // 67  CV_SH3_BbrB
+    L"bdrb",         // 68  CV_SH3_BdrB
+    L"bdmrb",        // 69  CV_SH3_BdmrB
+    L"brcr"          // 70  CV_SH3_Brcr
+};
+
+const wchar_t * const rgRegArm[] = {
+    L"None",         // 0   CV_ARM_NOREG
+    L"???",          // 1
+    L"???",          // 2
+    L"???",          // 3
+    L"???",          // 4
+    L"???",          // 5
+    L"???",          // 6
+    L"???",          // 7
+    L"???",          // 8
+    L"???",          // 9
+    L"r0",           // 10  CV_ARM_R0
+    L"r1",           // 11  CV_ARM_R1
+    L"r2",           // 12  CV_ARM_R2
+    L"r3",           // 13  CV_ARM_R3
+    L"r4",           // 14  CV_ARM_R4
+    L"r5",           // 15  CV_ARM_R5
+    L"r6",           // 16  CV_ARM_R6
+    L"r7",           // 17  CV_ARM_R7
+    L"r8",           // 18  CV_ARM_R8
+    L"r9",           // 19  CV_ARM_R9
+    L"r10",          // 20  CV_ARM_R10
+    L"r11",          // 21  CV_ARM_R11
+    L"r12",          // 22  CV_ARM_R12
+    L"sp",           // 23  CV_ARM_SP
+    L"lr",           // 24  CV_ARM_LR
+    L"pc",           // 25  CV_ARM_PC
+    L"cpsr"          // 26  CV_ARM_CPSR
+};
+
+const MapIa64Reg mpIa64regSz[] = {
+    { CV_IA64_Br0, L"Br0" },
+    { CV_IA64_Br1, L"Br1" },
+    { CV_IA64_Br2, L"Br2" },
+    { CV_IA64_Br3, L"Br3" },
+    { CV_IA64_Br4, L"Br4" },
+    { CV_IA64_Br5, L"Br5" },
+    { CV_IA64_Br6, L"Br6" },
+    { CV_IA64_Br7, L"Br7" },
+    { CV_IA64_Preds, L"Preds" },
+    { CV_IA64_IntH0, L"IntH0" },
+    { CV_IA64_IntH1, L"IntH1" },
+    { CV_IA64_IntH2, L"IntH2" },
+    { CV_IA64_IntH3, L"IntH3" },
+    { CV_IA64_IntH4, L"IntH4" },
+    { CV_IA64_IntH5, L"IntH5" },
+    { CV_IA64_IntH6, L"IntH6" },
+    { CV_IA64_IntH7, L"IntH7" },
+    { CV_IA64_IntH8, L"IntH8" },
+    { CV_IA64_IntH9, L"IntH9" },
+    { CV_IA64_IntH10, L"IntH10" },
+    { CV_IA64_IntH11, L"IntH11" },
+    { CV_IA64_IntH12, L"IntH12" },
+    { CV_IA64_IntH13, L"IntH13" },
+    { CV_IA64_IntH14, L"IntH14" },
+    { CV_IA64_IntH15, L"IntH15" },
+    { CV_IA64_Ip, L"Ip" },
+    { CV_IA64_Umask, L"Umask" },
+    { CV_IA64_Cfm, L"Cfm" },
+    { CV_IA64_Psr, L"Psr" },
+    { CV_IA64_Nats, L"Nats" },
+    { CV_IA64_Nats2, L"Nats2" },
+    { CV_IA64_Nats3, L"Nats3" },
+    { CV_IA64_IntR0, L"IntR0" },
+    { CV_IA64_IntR1, L"IntR1" },
+    { CV_IA64_IntR2, L"IntR2" },
+    { CV_IA64_IntR3, L"IntR3" },
+    { CV_IA64_IntR4, L"IntR4" },
+    { CV_IA64_IntR5, L"IntR5" },
+    { CV_IA64_IntR6, L"IntR6" },
+    { CV_IA64_IntR7, L"IntR7" },
+    { CV_IA64_IntR8, L"IntR8" },
+    { CV_IA64_IntR9, L"IntR9" },
+    { CV_IA64_IntR10, L"IntR10" },
+    { CV_IA64_IntR11, L"IntR11" },
+    { CV_IA64_IntR12, L"IntR12" },
+    { CV_IA64_IntR13, L"IntR13" },
+    { CV_IA64_IntR14, L"IntR14" },
+    { CV_IA64_IntR15, L"IntR15" },
+    { CV_IA64_IntR16, L"IntR16" },
+    { CV_IA64_IntR17, L"IntR17" },
+    { CV_IA64_IntR18, L"IntR18" },
+    { CV_IA64_IntR19, L"IntR19" },
+    { CV_IA64_IntR20, L"IntR20" },
+    { CV_IA64_IntR21, L"IntR21" },
+    { CV_IA64_IntR22, L"IntR22" },
+    { CV_IA64_IntR23, L"IntR23" },
+    { CV_IA64_IntR24, L"IntR24" },
+    { CV_IA64_IntR25, L"IntR25" },
+    { CV_IA64_IntR26, L"IntR26" },
+    { CV_IA64_IntR27, L"IntR27" },
+    { CV_IA64_IntR28, L"IntR28" },
+    { CV_IA64_IntR29, L"IntR29" },
+    { CV_IA64_IntR30, L"IntR30" },
+    { CV_IA64_IntR31, L"IntR31" },
+    { CV_IA64_IntR32, L"IntR32" },
+    { CV_IA64_IntR33, L"IntR33" },
+    { CV_IA64_IntR34, L"IntR34" },
+    { CV_IA64_IntR35, L"IntR35" },
+    { CV_IA64_IntR36, L"IntR36" },
+    { CV_IA64_IntR37, L"IntR37" },
+    { CV_IA64_IntR38, L"IntR38" },
+    { CV_IA64_IntR39, L"IntR39" },
+    { CV_IA64_IntR40, L"IntR40" },
+    { CV_IA64_IntR41, L"IntR41" },
+    { CV_IA64_IntR42, L"IntR42" },
+    { CV_IA64_IntR43, L"IntR43" },
+    { CV_IA64_IntR44, L"IntR44" },
+    { CV_IA64_IntR45, L"IntR45" },
+    { CV_IA64_IntR46, L"IntR46" },
+    { CV_IA64_IntR47, L"IntR47" },
+    { CV_IA64_IntR48, L"IntR48" },
+    { CV_IA64_IntR49, L"IntR49" },
+    { CV_IA64_IntR50, L"IntR50" },
+    { CV_IA64_IntR51, L"IntR51" },
+    { CV_IA64_IntR52, L"IntR52" },
+    { CV_IA64_IntR53, L"IntR53" },
+    { CV_IA64_IntR54, L"IntR54" },
+    { CV_IA64_IntR55, L"IntR55" },
+    { CV_IA64_IntR56, L"IntR56" },
+    { CV_IA64_IntR57, L"IntR57" },
+    { CV_IA64_IntR58, L"IntR58" },
+    { CV_IA64_IntR59, L"IntR59" },
+    { CV_IA64_IntR60, L"IntR60" },
+    { CV_IA64_IntR61, L"IntR61" },
+    { CV_IA64_IntR62, L"IntR62" },
+    { CV_IA64_IntR63, L"IntR63" },
+    { CV_IA64_IntR64, L"IntR64" },
+    { CV_IA64_IntR65, L"IntR65" },
+    { CV_IA64_IntR66, L"IntR66" },
+    { CV_IA64_IntR67, L"IntR67" },
+    { CV_IA64_IntR68, L"IntR68" },
+    { CV_IA64_IntR69, L"IntR69" },
+    { CV_IA64_IntR70, L"IntR70" },
+    { CV_IA64_IntR71, L"IntR71" },
+    { CV_IA64_IntR72, L"IntR72" },
+    { CV_IA64_IntR73, L"IntR73" },
+    { CV_IA64_IntR74, L"IntR74" },
+    { CV_IA64_IntR75, L"IntR75" },
+    { CV_IA64_IntR76, L"IntR76" },
+    { CV_IA64_IntR77, L"IntR77" },
+    { CV_IA64_IntR78, L"IntR78" },
+    { CV_IA64_IntR79, L"IntR79" },
+    { CV_IA64_IntR80, L"IntR80" },
+    { CV_IA64_IntR81, L"IntR81" },
+    { CV_IA64_IntR82, L"IntR82" },
+    { CV_IA64_IntR83, L"IntR83" },
+    { CV_IA64_IntR84, L"IntR84" },
+    { CV_IA64_IntR85, L"IntR85" },
+    { CV_IA64_IntR86, L"IntR86" },
+    { CV_IA64_IntR87, L"IntR87" },
+    { CV_IA64_IntR88, L"IntR88" },
+    { CV_IA64_IntR89, L"IntR89" },
+    { CV_IA64_IntR90, L"IntR90" },
+    { CV_IA64_IntR91, L"IntR91" },
+    { CV_IA64_IntR92, L"IntR92" },
+    { CV_IA64_IntR93, L"IntR93" },
+    { CV_IA64_IntR94, L"IntR94" },
+    { CV_IA64_IntR95, L"IntR95" },
+    { CV_IA64_IntR96, L"IntR96" },
+    { CV_IA64_IntR97, L"IntR97" },
+    { CV_IA64_IntR98, L"IntR98" },
+    { CV_IA64_IntR99, L"IntR99" },
+    { CV_IA64_IntR100, L"IntR100" },
+    { CV_IA64_IntR101, L"IntR101" },
+    { CV_IA64_IntR102, L"IntR102" },
+    { CV_IA64_IntR103, L"IntR103" },
+    { CV_IA64_IntR104, L"IntR104" },
+    { CV_IA64_IntR105, L"IntR105" },
+    { CV_IA64_IntR106, L"IntR106" },
+    { CV_IA64_IntR107, L"IntR107" },
+    { CV_IA64_IntR108, L"IntR108" },
+    { CV_IA64_IntR109, L"IntR109" },
+    { CV_IA64_IntR110, L"IntR110" },
+    { CV_IA64_IntR111, L"IntR111" },
+    { CV_IA64_IntR112, L"IntR112" },
+    { CV_IA64_IntR113, L"IntR113" },
+    { CV_IA64_IntR114, L"IntR114" },
+    { CV_IA64_IntR115, L"IntR115" },
+    { CV_IA64_IntR116, L"IntR116" },
+    { CV_IA64_IntR117, L"IntR117" },
+    { CV_IA64_IntR118, L"IntR118" },
+    { CV_IA64_IntR119, L"IntR119" },
+    { CV_IA64_IntR120, L"IntR120" },
+    { CV_IA64_IntR121, L"IntR121" },
+    { CV_IA64_IntR122, L"IntR122" },
+    { CV_IA64_IntR123, L"IntR123" },
+    { CV_IA64_IntR124, L"IntR124" },
+    { CV_IA64_IntR125, L"IntR125" },
+    { CV_IA64_IntR126, L"IntR126" },
+    { CV_IA64_IntR127, L"IntR127" },
+    { CV_IA64_FltF0, L"FltF0" },
+    { CV_IA64_FltF1, L"FltF1" },
+    { CV_IA64_FltF2, L"FltF2" },
+    { CV_IA64_FltF3, L"FltF3" },
+    { CV_IA64_FltF4, L"FltF4" },
+    { CV_IA64_FltF5, L"FltF5" },
+    { CV_IA64_FltF6, L"FltF6" },
+    { CV_IA64_FltF7, L"FltF7" },
+    { CV_IA64_FltF8, L"FltF8" },
+    { CV_IA64_FltF9, L"FltF9" },
+    { CV_IA64_FltF10, L"FltF10" },
+    { CV_IA64_FltF11, L"FltF11" },
+    { CV_IA64_FltF12, L"FltF12" },
+    { CV_IA64_FltF13, L"FltF13" },
+    { CV_IA64_FltF14, L"FltF14" },
+    { CV_IA64_FltF15, L"FltF15" },
+    { CV_IA64_FltF16, L"FltF16" },
+    { CV_IA64_FltF17, L"FltF17" },
+    { CV_IA64_FltF18, L"FltF18" },
+    { CV_IA64_FltF19, L"FltF19" },
+    { CV_IA64_FltF20, L"FltF20" },
+    { CV_IA64_FltF21, L"FltF21" },
+    { CV_IA64_FltF22, L"FltF22" },
+    { CV_IA64_FltF23, L"FltF23" },
+    { CV_IA64_FltF24, L"FltF24" },
+    { CV_IA64_FltF25, L"FltF25" },
+    { CV_IA64_FltF26, L"FltF26" },
+    { CV_IA64_FltF27, L"FltF27" },
+    { CV_IA64_FltF28, L"FltF28" },
+    { CV_IA64_FltF29, L"FltF29" },
+    { CV_IA64_FltF30, L"FltF30" },
+    { CV_IA64_FltF31, L"FltF31" },
+    { CV_IA64_FltF32, L"FltF32" },
+    { CV_IA64_FltF33, L"FltF33" },
+    { CV_IA64_FltF34, L"FltF34" },
+    { CV_IA64_FltF35, L"FltF35" },
+    { CV_IA64_FltF36, L"FltF36" },
+    { CV_IA64_FltF37, L"FltF37" },
+    { CV_IA64_FltF38, L"FltF38" },
+    { CV_IA64_FltF39, L"FltF39" },
+    { CV_IA64_FltF40, L"FltF40" },
+    { CV_IA64_FltF41, L"FltF41" },
+    { CV_IA64_FltF42, L"FltF42" },
+    { CV_IA64_FltF43, L"FltF43" },
+    { CV_IA64_FltF44, L"FltF44" },
+    { CV_IA64_FltF45, L"FltF45" },
+    { CV_IA64_FltF46, L"FltF46" },
+    { CV_IA64_FltF47, L"FltF47" },
+    { CV_IA64_FltF48, L"FltF48" },
+    { CV_IA64_FltF49, L"FltF49" },
+    { CV_IA64_FltF50, L"FltF50" },
+    { CV_IA64_FltF51, L"FltF51" },
+    { CV_IA64_FltF52, L"FltF52" },
+    { CV_IA64_FltF53, L"FltF53" },
+    { CV_IA64_FltF54, L"FltF54" },
+    { CV_IA64_FltF55, L"FltF55" },
+    { CV_IA64_FltF56, L"FltF56" },
+    { CV_IA64_FltF57, L"FltF57" },
+    { CV_IA64_FltF58, L"FltF58" },
+    { CV_IA64_FltF59, L"FltF59" },
+    { CV_IA64_FltF60, L"FltF60" },
+    { CV_IA64_FltF61, L"FltF61" },
+    { CV_IA64_FltF62, L"FltF62" },
+    { CV_IA64_FltF63, L"FltF63" },
+    { CV_IA64_FltF64, L"FltF64" },
+    { CV_IA64_FltF65, L"FltF65" },
+    { CV_IA64_FltF66, L"FltF66" },
+    { CV_IA64_FltF67, L"FltF67" },
+    { CV_IA64_FltF68, L"FltF68" },
+    { CV_IA64_FltF69, L"FltF69" },
+    { CV_IA64_FltF70, L"FltF70" },
+    { CV_IA64_FltF71, L"FltF71" },
+    { CV_IA64_FltF72, L"FltF72" },
+    { CV_IA64_FltF73, L"FltF73" },
+    { CV_IA64_FltF74, L"FltF74" },
+    { CV_IA64_FltF75, L"FltF75" },
+    { CV_IA64_FltF76, L"FltF76" },
+    { CV_IA64_FltF77, L"FltF77" },
+    { CV_IA64_FltF78, L"FltF78" },
+    { CV_IA64_FltF79, L"FltF79" },
+    { CV_IA64_FltF80, L"FltF80" },
+    { CV_IA64_FltF81, L"FltF81" },
+    { CV_IA64_FltF82, L"FltF82" },
+    { CV_IA64_FltF83, L"FltF83" },
+    { CV_IA64_FltF84, L"FltF84" },
+    { CV_IA64_FltF85, L"FltF85" },
+    { CV_IA64_FltF86, L"FltF86" },
+    { CV_IA64_FltF87, L"FltF87" },
+    { CV_IA64_FltF88, L"FltF88" },
+    { CV_IA64_FltF89, L"FltF89" },
+    { CV_IA64_FltF90, L"FltF90" },
+    { CV_IA64_FltF91, L"FltF91" },
+    { CV_IA64_FltF92, L"FltF92" },
+    { CV_IA64_FltF93, L"FltF93" },
+    { CV_IA64_FltF94, L"FltF94" },
+    { CV_IA64_FltF95, L"FltF95" },
+    { CV_IA64_FltF96, L"FltF96" },
+    { CV_IA64_FltF97, L"FltF97" },
+    { CV_IA64_FltF98, L"FltF98" },
+    { CV_IA64_FltF99, L"FltF99" },
+    { CV_IA64_FltF100, L"FltF100" },
+    { CV_IA64_FltF101, L"FltF101" },
+    { CV_IA64_FltF102, L"FltF102" },
+    { CV_IA64_FltF103, L"FltF103" },
+    { CV_IA64_FltF104, L"FltF104" },
+    { CV_IA64_FltF105, L"FltF105" },
+    { CV_IA64_FltF106, L"FltF106" },
+    { CV_IA64_FltF107, L"FltF107" },
+    { CV_IA64_FltF108, L"FltF108" },
+    { CV_IA64_FltF109, L"FltF109" },
+    { CV_IA64_FltF110, L"FltF110" },
+    { CV_IA64_FltF111, L"FltF111" },
+    { CV_IA64_FltF112, L"FltF112" },
+    { CV_IA64_FltF113, L"FltF113" },
+    { CV_IA64_FltF114, L"FltF114" },
+    { CV_IA64_FltF115, L"FltF115" },
+    { CV_IA64_FltF116, L"FltF116" },
+    { CV_IA64_FltF117, L"FltF117" },
+    { CV_IA64_FltF118, L"FltF118" },
+    { CV_IA64_FltF119, L"FltF119" },
+    { CV_IA64_FltF120, L"FltF120" },
+    { CV_IA64_FltF121, L"FltF121" },
+    { CV_IA64_FltF122, L"FltF122" },
+    { CV_IA64_FltF123, L"FltF123" },
+    { CV_IA64_FltF124, L"FltF124" },
+    { CV_IA64_FltF125, L"FltF125" },
+    { CV_IA64_FltF126, L"FltF126" },
+    { CV_IA64_FltF127, L"FltF127" },
+    { CV_IA64_ApKR0, L"ApKR0" },
+    { CV_IA64_ApKR1, L"ApKR1" },
+    { CV_IA64_ApKR2, L"ApKR2" },
+    { CV_IA64_ApKR3, L"ApKR3" },
+    { CV_IA64_ApKR4, L"ApKR4" },
+    { CV_IA64_ApKR5, L"ApKR5" },
+    { CV_IA64_ApKR6, L"ApKR6" },
+    { CV_IA64_ApKR7, L"ApKR7" },
+    { CV_IA64_AR8, L"AR8" },
+    { CV_IA64_AR9, L"AR9" },
+    { CV_IA64_AR10, L"AR10" },
+    { CV_IA64_AR11, L"AR11" },
+    { CV_IA64_AR12, L"AR12" },
+    { CV_IA64_AR13, L"AR13" },
+    { CV_IA64_AR14, L"AR14" },
+    { CV_IA64_AR15, L"AR15" },
+    { CV_IA64_RsRSC, L"RsRSC" },
+    { CV_IA64_RsBSP, L"RsBSP" },
+    { CV_IA64_RsBSPSTORE, L"RsBSPSTORE" },
+    { CV_IA64_RsRNAT, L"RsRNAT" },
+    { CV_IA64_AR20, L"AR20" },
+    { CV_IA64_StFCR, L"StFCR" },
+    { CV_IA64_AR22, L"AR22" },
+    { CV_IA64_AR23, L"AR23" },
+    { CV_IA64_EFLAG, L"EFLAG" },
+    { CV_IA64_CSD, L"CSD" },
+    { CV_IA64_SSD, L"SSD" },
+    { CV_IA64_CFLG, L"CFLG" },
+    { CV_IA64_StFSR, L"StFSR" },
+    { CV_IA64_StFIR, L"StFIR" },
+    { CV_IA64_StFDR, L"StFDR" },
+    { CV_IA64_AR31, L"AR31" },
+    { CV_IA64_ApCCV, L"ApCCV" },
+    { CV_IA64_AR33, L"AR33" },
+    { CV_IA64_AR34, L"AR34" },
+    { CV_IA64_AR35, L"AR35" },
+    { CV_IA64_ApUNAT, L"ApUNAT" },
+    { CV_IA64_AR37, L"AR37" },
+    { CV_IA64_AR38, L"AR38" },
+    { CV_IA64_AR39, L"AR39" },
+    { CV_IA64_StFPSR, L"StFPSR" },
+    { CV_IA64_AR41, L"AR41" },
+    { CV_IA64_AR42, L"AR42" },
+    { CV_IA64_AR43, L"AR43" },
+    { CV_IA64_ApITC, L"ApITC" },
+    { CV_IA64_AR45, L"AR45" },
+    { CV_IA64_AR46, L"AR46" },
+    { CV_IA64_AR47, L"AR47" },
+    { CV_IA64_AR48, L"AR48" },
+    { CV_IA64_AR49, L"AR49" },
+    { CV_IA64_AR50, L"AR50" },
+    { CV_IA64_AR51, L"AR51" },
+    { CV_IA64_AR52, L"AR52" },
+    { CV_IA64_AR53, L"AR53" },
+    { CV_IA64_AR54, L"AR54" },
+    { CV_IA64_AR55, L"AR55" },
+    { CV_IA64_AR56, L"AR56" },
+    { CV_IA64_AR57, L"AR57" },
+    { CV_IA64_AR58, L"AR58" },
+    { CV_IA64_AR59, L"AR59" },
+    { CV_IA64_AR60, L"AR60" },
+    { CV_IA64_AR61, L"AR61" },
+    { CV_IA64_AR62, L"AR62" },
+    { CV_IA64_AR63, L"AR63" },
+    { CV_IA64_RsPFS, L"RsPFS" },
+    { CV_IA64_ApLC, L"ApLC" },
+    { CV_IA64_ApEC, L"ApEC" },
+    { CV_IA64_AR67, L"AR67" },
+    { CV_IA64_AR68, L"AR68" },
+    { CV_IA64_AR69, L"AR69" },
+    { CV_IA64_AR70, L"AR70" },
+    { CV_IA64_AR71, L"AR71" },
+    { CV_IA64_AR72, L"AR72" },
+    { CV_IA64_AR73, L"AR73" },
+    { CV_IA64_AR74, L"AR74" },
+    { CV_IA64_AR75, L"AR75" },
+    { CV_IA64_AR76, L"AR76" },
+    { CV_IA64_AR77, L"AR77" },
+    { CV_IA64_AR78, L"AR78" },
+    { CV_IA64_AR79, L"AR79" },
+    { CV_IA64_AR80, L"AR80" },
+    { CV_IA64_AR81, L"AR81" },
+    { CV_IA64_AR82, L"AR82" },
+    { CV_IA64_AR83, L"AR83" },
+    { CV_IA64_AR84, L"AR84" },
+    { CV_IA64_AR85, L"AR85" },
+    { CV_IA64_AR86, L"AR86" },
+    { CV_IA64_AR87, L"AR87" },
+    { CV_IA64_AR88, L"AR88" },
+    { CV_IA64_AR89, L"AR89" },
+    { CV_IA64_AR90, L"AR90" },
+    { CV_IA64_AR91, L"AR91" },
+    { CV_IA64_AR92, L"AR92" },
+    { CV_IA64_AR93, L"AR93" },
+    { CV_IA64_AR94, L"AR94" },
+    { CV_IA64_AR95, L"AR95" },
+    { CV_IA64_AR96, L"AR96" },
+    { CV_IA64_AR97, L"AR97" },
+    { CV_IA64_AR98, L"AR98" },
+    { CV_IA64_AR99, L"AR99" },
+    { CV_IA64_AR100, L"AR100" },
+    { CV_IA64_AR101, L"AR101" },
+    { CV_IA64_AR102, L"AR102" },
+    { CV_IA64_AR103, L"AR103" },
+    { CV_IA64_AR104, L"AR104" },
+    { CV_IA64_AR105, L"AR105" },
+    { CV_IA64_AR106, L"AR106" },
+    { CV_IA64_AR107, L"AR107" },
+    { CV_IA64_AR108, L"AR108" },
+    { CV_IA64_AR109, L"AR109" },
+    { CV_IA64_AR110, L"AR110" },
+    { CV_IA64_AR111, L"AR111" },
+    { CV_IA64_AR112, L"AR112" },
+    { CV_IA64_AR113, L"AR113" },
+    { CV_IA64_AR114, L"AR114" },
+    { CV_IA64_AR115, L"AR115" },
+    { CV_IA64_AR116, L"AR116" },
+    { CV_IA64_AR117, L"AR117" },
+    { CV_IA64_AR118, L"AR118" },
+    { CV_IA64_AR119, L"AR119" },
+    { CV_IA64_AR120, L"AR120" },
+    { CV_IA64_AR121, L"AR121" },
+    { CV_IA64_AR122, L"AR122" },
+    { CV_IA64_AR123, L"AR123" },
+    { CV_IA64_AR124, L"AR124" },
+    { CV_IA64_AR125, L"AR125" },
+    { CV_IA64_AR126, L"AR126" },
+    { CV_IA64_AR127, L"AR127" },
+    { CV_IA64_ApDCR, L"ApDCR" },
+    { CV_IA64_ApITM, L"ApITM" },
+    { CV_IA64_ApIVA, L"ApIVA" },
+    { CV_IA64_CR3, L"CR3" },
+    { CV_IA64_CR4, L"CR4" },
+    { CV_IA64_CR5, L"CR5" },
+    { CV_IA64_CR6, L"CR6" },
+    { CV_IA64_CR7, L"CR7" },
+    { CV_IA64_ApPTA, L"ApPTA" },
+    { CV_IA64_ApGPTA, L"ApGPTA" },
+    { CV_IA64_CR10, L"CR10" },
+    { CV_IA64_CR11, L"CR11" },
+    { CV_IA64_CR12, L"CR12" },
+    { CV_IA64_CR13, L"CR13" },
+    { CV_IA64_CR14, L"CR14" },
+    { CV_IA64_CR15, L"CR15" },
+    { CV_IA64_StIPSR, L"StIPSR" },
+    { CV_IA64_StISR, L"StISR" },
+    { CV_IA64_CR18, L"CR18" },
+    { CV_IA64_StIIP, L"StIIP" },
+    { CV_IA64_StIFA, L"StIFA" },
+    { CV_IA64_StITIR, L"StITIR" },
+    { CV_IA64_StIIPA, L"StIIPA" },
+    { CV_IA64_StIFS, L"StIFS" },
+    { CV_IA64_StIIM, L"StIIM" },
+    { CV_IA64_StIHA, L"StIHA" },
+    { CV_IA64_CR26, L"CR26" },
+    { CV_IA64_CR27, L"CR27" },
+    { CV_IA64_CR28, L"CR28" },
+    { CV_IA64_CR29, L"CR29" },
+    { CV_IA64_CR30, L"CR30" },
+    { CV_IA64_CR31, L"CR31" },
+    { CV_IA64_CR32, L"CR32" },
+    { CV_IA64_CR33, L"CR33" },
+    { CV_IA64_CR34, L"CR34" },
+    { CV_IA64_CR35, L"CR35" },
+    { CV_IA64_CR36, L"CR36" },
+    { CV_IA64_CR37, L"CR37" },
+    { CV_IA64_CR38, L"CR38" },
+    { CV_IA64_CR39, L"CR39" },
+    { CV_IA64_CR40, L"CR40" },
+    { CV_IA64_CR41, L"CR41" },
+    { CV_IA64_CR42, L"CR42" },
+    { CV_IA64_CR43, L"CR43" },
+    { CV_IA64_CR44, L"CR44" },
+    { CV_IA64_CR45, L"CR45" },
+    { CV_IA64_CR46, L"CR46" },
+    { CV_IA64_CR47, L"CR47" },
+    { CV_IA64_CR48, L"CR48" },
+    { CV_IA64_CR49, L"CR49" },
+    { CV_IA64_CR50, L"CR50" },
+    { CV_IA64_CR51, L"CR51" },
+    { CV_IA64_CR52, L"CR52" },
+    { CV_IA64_CR53, L"CR53" },
+    { CV_IA64_CR54, L"CR54" },
+    { CV_IA64_CR55, L"CR55" },
+    { CV_IA64_CR56, L"CR56" },
+    { CV_IA64_CR57, L"CR57" },
+    { CV_IA64_CR58, L"CR58" },
+    { CV_IA64_CR59, L"CR59" },
+    { CV_IA64_CR60, L"CR60" },
+    { CV_IA64_CR61, L"CR61" },
+    { CV_IA64_CR62, L"CR62" },
+    { CV_IA64_CR63, L"CR63" },
+    { CV_IA64_SaLID, L"SaLID" },
+    { CV_IA64_SaIVR, L"SaIVR" },
+    { CV_IA64_SaTPR, L"SaTPR" },
+    { CV_IA64_SaEOI, L"SaEOI" },
+    { CV_IA64_SaIRR0, L"SaIRR0" },
+    { CV_IA64_SaIRR1, L"SaIRR1" },
+    { CV_IA64_SaIRR2, L"SaIRR2" },
+    { CV_IA64_SaIRR3, L"SaIRR3" },
+    { CV_IA64_SaITV, L"SaITV" },
+    { CV_IA64_SaPMV, L"SaPMV" },
+    { CV_IA64_SaCMCV, L"SaCMCV" },
+    { CV_IA64_CR75, L"CR75" },
+    { CV_IA64_CR76, L"CR76" },
+    { CV_IA64_CR77, L"CR77" },
+    { CV_IA64_CR78, L"CR78" },
+    { CV_IA64_CR79, L"CR79" },
+    { CV_IA64_SaLRR0, L"SaLRR0" },
+    { CV_IA64_SaLRR1, L"SaLRR1" },
+    { CV_IA64_CR82, L"CR82" },
+    { CV_IA64_CR83, L"CR83" },
+    { CV_IA64_CR84, L"CR84" },
+    { CV_IA64_CR85, L"CR85" },
+    { CV_IA64_CR86, L"CR86" },
+    { CV_IA64_CR87, L"CR87" },
+    { CV_IA64_CR88, L"CR88" },
+    { CV_IA64_CR89, L"CR89" },
+    { CV_IA64_CR90, L"CR90" },
+    { CV_IA64_CR91, L"CR91" },
+    { CV_IA64_CR92, L"CR92" },
+    { CV_IA64_CR93, L"CR93" },
+    { CV_IA64_CR94, L"CR94" },
+    { CV_IA64_CR95, L"CR95" },
+    { CV_IA64_SaIRR0, L"SaIRR0" },
+    { CV_IA64_CR97, L"CR97" },
+    { CV_IA64_SaIRR1, L"SaIRR1" },
+    { CV_IA64_CR99, L"CR99" },
+    { CV_IA64_SaIRR2, L"SaIRR2" },
+    { CV_IA64_CR101, L"CR101" },
+    { CV_IA64_SaIRR3, L"SaIRR3" },
+    { CV_IA64_CR103, L"CR103" },
+    { CV_IA64_CR104, L"CR104" },
+    { CV_IA64_CR105, L"CR105" },
+    { CV_IA64_CR106, L"CR106" },
+    { CV_IA64_CR107, L"CR107" },
+    { CV_IA64_CR108, L"CR108" },
+    { CV_IA64_CR109, L"CR109" },
+    { CV_IA64_CR110, L"CR110" },
+    { CV_IA64_CR111, L"CR111" },
+    { CV_IA64_CR112, L"CR112" },
+    { CV_IA64_CR113, L"CR113" },
+    { CV_IA64_SaITV, L"SaITV" },
+    { CV_IA64_CR115, L"CR115" },
+    { CV_IA64_SaPMV, L"SaPMV" },
+    { CV_IA64_SaLRR0, L"SaLRR0" },
+    { CV_IA64_SaLRR1, L"SaLRR1" },
+    { CV_IA64_SaCMCV, L"SaCMCV" },
+    { CV_IA64_CR120, L"CR120" },
+    { CV_IA64_CR121, L"CR121" },
+    { CV_IA64_CR122, L"CR122" },
+    { CV_IA64_CR123, L"CR123" },
+    { CV_IA64_CR124, L"CR124" },
+    { CV_IA64_CR125, L"CR125" },
+    { CV_IA64_CR126, L"CR126" },
+    { CV_IA64_CR127, L"CR127" },
+    { CV_IA64_Pkr0, L"Pkr0" },
+    { CV_IA64_Pkr1, L"Pkr1" },
+    { CV_IA64_Pkr2, L"Pkr2" },
+    { CV_IA64_Pkr3, L"Pkr3" },
+    { CV_IA64_Pkr4, L"Pkr4" },
+    { CV_IA64_Pkr5, L"Pkr5" },
+    { CV_IA64_Pkr6, L"Pkr6" },
+    { CV_IA64_Pkr7, L"Pkr7" },
+    { CV_IA64_Pkr8, L"Pkr8" },
+    { CV_IA64_Pkr9, L"Pkr9" },
+    { CV_IA64_Pkr10, L"Pkr10" },
+    { CV_IA64_Pkr11, L"Pkr11" },
+    { CV_IA64_Pkr12, L"Pkr12" },
+    { CV_IA64_Pkr13, L"Pkr13" },
+    { CV_IA64_Pkr14, L"Pkr14" },
+    { CV_IA64_Pkr15, L"Pkr15" },
+    { CV_IA64_Rr0, L"Rr0" },
+    { CV_IA64_Rr1, L"Rr1" },
+    { CV_IA64_Rr2, L"Rr2" },
+    { CV_IA64_Rr3, L"Rr3" },
+    { CV_IA64_Rr4, L"Rr4" },
+    { CV_IA64_Rr5, L"Rr5" },
+    { CV_IA64_Rr6, L"Rr6" },
+    { CV_IA64_Rr7, L"Rr7" },
+    { CV_IA64_PFD0, L"PFD0" },
+    { CV_IA64_PFD1, L"PFD1" },
+    { CV_IA64_PFD2, L"PFD2" },
+    { CV_IA64_PFD3, L"PFD3" },
+    { CV_IA64_PFD4, L"PFD4" },
+    { CV_IA64_PFD5, L"PFD5" },
+    { CV_IA64_PFD6, L"PFD6" },
+    { CV_IA64_PFD7, L"PFD7" },
+    { CV_IA64_PFC0, L"PFC0" },
+    { CV_IA64_PFC1, L"PFC1" },
+    { CV_IA64_PFC2, L"PFC2" },
+    { CV_IA64_PFC3, L"PFC3" },
+    { CV_IA64_PFC4, L"PFC4" },
+    { CV_IA64_PFC5, L"PFC5" },
+    { CV_IA64_PFC6, L"PFC6" },
+    { CV_IA64_PFC7, L"PFC7" },
+    { CV_IA64_TrI0, L"TrI0" },
+    { CV_IA64_TrI1, L"TrI1" },
+    { CV_IA64_TrI2, L"TrI2" },
+    { CV_IA64_TrI3, L"TrI3" },
+    { CV_IA64_TrI4, L"TrI4" },
+    { CV_IA64_TrI5, L"TrI5" },
+    { CV_IA64_TrI6, L"TrI6" },
+    { CV_IA64_TrI7, L"TrI7" },
+    { CV_IA64_TrD0, L"TrD0" },
+    { CV_IA64_TrD1, L"TrD1" },
+    { CV_IA64_TrD2, L"TrD2" },
+    { CV_IA64_TrD3, L"TrD3" },
+    { CV_IA64_TrD4, L"TrD4" },
+    { CV_IA64_TrD5, L"TrD5" },
+    { CV_IA64_TrD6, L"TrD6" },
+    { CV_IA64_TrD7, L"TrD7" },
+    { CV_IA64_DbI0, L"DbI0" },
+    { CV_IA64_DbI1, L"DbI1" },
+    { CV_IA64_DbI2, L"DbI2" },
+    { CV_IA64_DbI3, L"DbI3" },
+    { CV_IA64_DbI4, L"DbI4" },
+    { CV_IA64_DbI5, L"DbI5" },
+    { CV_IA64_DbI6, L"DbI6" },
+    { CV_IA64_DbI7, L"DbI7" },
+    { CV_IA64_DbD0, L"DbD0" },
+    { CV_IA64_DbD1, L"DbD1" },
+    { CV_IA64_DbD2, L"DbD2" },
+    { CV_IA64_DbD3, L"DbD3" },
+    { CV_IA64_DbD4, L"DbD4" },
+    { CV_IA64_DbD5, L"DbD5" },
+    { CV_IA64_DbD6, L"DbD6" },
+    { CV_IA64_DbD7, L"DbD7" }
+};
+
+////////////////////////////////////////////////////////////
+// Map an IA64 registry ID with the corresponding string name
+//
+int __cdecl cmpIa64regSz(const void *pv1, const void *pv2) {
+  const MapIa64Reg *p1 = (MapIa64Reg *) pv1;
+  const MapIa64Reg *p2 = (MapIa64Reg *) pv2;
+  
+  if(p1->iCvReg < p2->iCvReg){
+    return -1;
+  }
+  if(p1->iCvReg > p2->iCvReg){
+    return 1;
+  }
+  return 0;
+}
+
+////////////////////////////////////////////////////////////
+// Map a registry id code with the corresponding string name
+//
+const wchar_t* SzNameC7Reg(USHORT reg, DWORD MachineType){
+  static wchar_t wszRegNum[64];
+  
+       switch(reg){
+               case CV_ALLREG_LOCALS : return L"BaseOfLocals";
+               case CV_ALLREG_PARAMS : return L"BaseOfParams";
+               case CV_ALLREG_VFRAME : return L"VFrame";
+       }
+  swprintf_s(wszRegNum, L"???(0x%x)", reg);
+  switch(MachineType) {
+    case CV_CFL_8080:
+    case CV_CFL_8086:
+    case CV_CFL_80286:
+    case CV_CFL_80386:
+    case CV_CFL_80486:
+    case CV_CFL_PENTIUM:
+      if(reg < (sizeof(rgRegX86)/sizeof(*rgRegX86))){
+        return(rgRegX86[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_ALPHA:
+      if(reg < (sizeof(rgRegAlpha)/sizeof(*rgRegAlpha))){
+        return(rgRegAlpha[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_MIPSR4000:
+    case CV_CFL_MIPS16:
+      if(reg < (sizeof(rgRegMips)/sizeof(*rgRegMips))) {
+        return(rgRegMips[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_M68000:
+    case CV_CFL_M68010:
+    case CV_CFL_M68020:
+    case CV_CFL_M68030:
+    case CV_CFL_M68040:
+      if(reg < (sizeof(rgReg68k)/sizeof(*rgReg68k))){
+        return(rgReg68k[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_PPC601:
+    case CV_CFL_PPC603:
+    case CV_CFL_PPC604:
+    case CV_CFL_PPC620:
+      if(reg < (sizeof(rgRegPpc)/sizeof(*rgRegPpc))){
+        return(rgRegPpc[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_SH3:
+      if(reg < (sizeof(rgRegSh)/sizeof(*rgRegSh))){
+        return(rgRegSh[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_ARM3:
+    case CV_CFL_ARM4:
+    case CV_CFL_ARM4T:
+      if(reg < (sizeof(rgRegArm)/sizeof(*rgRegArm))){
+        return(rgRegArm[reg]);
+      }
+      return wszRegNum;
+      break;
+    case CV_CFL_IA64: {
+      MapIa64Reg *p;
+      MapIa64Reg  m = {(CV_HREG_e) reg};
+      p = (MapIa64Reg *) bsearch(&m,
+                                 mpIa64regSz,
+                                 sizeof(mpIa64regSz)/sizeof(*mpIa64regSz),
+                                 sizeof(MapIa64Reg),
+                                 cmpIa64regSz);
+      if (p) {
+        return p->wszRegName;
+      }else{
+        return wszRegNum;
+      }
+      break;
+    }
+    case CV_CFL_AMD64 :
+      if (reg < sizeof(rgRegAMD64)/sizeof(*rgRegAMD64)) {
+        return rgRegAMD64[reg];
+      }else{
+        return wszRegNum;
+      }
+      break;
+    default:
+      return wszRegNum;
+      break;
+  }
+}
+
+const wchar_t* SzNameC7Reg(USHORT reg){
+    return SzNameC7Reg(reg, g_dwMachineType);
+}
+

diff --git a/src/ToolBox/PdbTypeMatch/regs.h b/src/ToolBox/PdbTypeMatch/regs.h
new file mode 100644 (file)
index 0000000..85d67c6
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/regs.h
@@ -0,0 +1,19 @@
+extern const wchar_t * const rgRegX86[];
+extern const wchar_t * const rgRegAMD64[];
+extern const wchar_t * const rgRegMips[];
+extern const wchar_t * const rgReg68k[];
+extern const wchar_t * const rgRegAlpha[];
+extern const wchar_t * const rgRegPpc[];
+extern const wchar_t * const rgRegSh[];
+extern const wchar_t * const rgRegArm[];
+
+typedef struct MapIa64Reg{
+    CV_HREG_e  iCvReg;
+    const wchar_t* wszRegName;
+}MapIa64Reg;
+extern const MapIa64Reg mpIa64regSz[];
+int __cdecl cmpIa64regSz( const void* , const void* );
+
+extern DWORD g_dwMachineType;
+const wchar_t* SzNameC7Reg( USHORT , DWORD );
+const wchar_t* SzNameC7Reg( USHORT );

diff --git a/src/ToolBox/PdbTypeMatch/stdafx.cpp b/src/ToolBox/PdbTypeMatch/stdafx.cpp
new file mode 100644 (file)
index 0000000..56e6187
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/stdafx.cpp
@@ -0,0 +1,6 @@
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file

diff --git a/src/ToolBox/PdbTypeMatch/stdafx.h b/src/ToolBox/PdbTypeMatch/stdafx.h
new file mode 100644 (file)
index 0000000..7b7ebb2
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/stdafx.h
@@ -0,0 +1,22 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN            // Exclude rarely-used stuff from Windows headers
+#endif
+
+#include <stdio.h>
+#include <tchar.h>
+#include <string.h>
+#include <comdef.h>
+
+#define _WIN32_FUSION 0x0100 // this causes activation context 
+
+// TODO: reference additional headers your program requires here
+#include "dia2.h"
+

diff --git a/src/ToolBox/SOS/diasdk/diasdk.nativeproj b/src/ToolBox/SOS/diasdk/diasdk.nativeproj
index 4e460a2..230e2d9 100644 (file)
--- a/src/ToolBox/SOS/diasdk/diasdk.nativeproj
+++ b/src/ToolBox/SOS/diasdk/diasdk.nativeproj
@@ -15,19 +15,29 @@
         $(VCToolsIncPath)</UserIncludes>
     <MidlTlbDir>$(IntermediateOutputDirectory)</MidlTlbDir>
     <TlbImportFlags>/namespace:Dia /unsafe</TlbImportFlags>
-    <BinplaceSymbols>false</BinplaceSymbols>
   </PropertyGroup>
-  
+
   <ItemGroup>
     <Idl Include="$(VCToolsIncPath)\dia2.idl" />
-
     <PublishPartLinked  Include="$(IntermediateOutputDirectory)\dialib.dll">
       <Visibility>Intra</Visibility>
       <FileType>Binary</FileType>      
     </PublishPartLinked>
+  </ItemGroup>
 
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
   </ItemGroup>
+
   <!--Leaf Project Items-->
   <!--Import the targets-->
   <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+
+  <PropertyGroup>
+    <BuildLinkedDependsOn>
+      $(BuildLinkedDependsOn)
+      PlaceSymbols
+    </BuildLinkedDependsOn>
+  </PropertyGroup>
+
 </Project>

diff --git a/src/ToolBox/SOS/diasdk/native.rc b/src/ToolBox/SOS/diasdk/native.rc
new file mode 100644 (file)
index 0000000..c4474f2
--- /dev/null
+++ b/src/ToolBox/SOS/diasdk/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>

diff --git a/src/ToolBox/SOS/dirs.proj b/src/ToolBox/SOS/dirs.proj
index e1ec0c6..028d4c2 100644 (file)
--- a/src/ToolBox/SOS/dirs.proj
+++ b/src/ToolBox/SOS/dirs.proj
@@ -14,8 +14,12 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(BuildExePhase)' == '1' and '$(BuildArchitecture)' == 'i386' and '$(FeatureCoreClr)' != 'true'">
-    <ProjectFile Include="diasdk\diasdk.nativeproj" />
-    <ProjectFile Include="dactablegen\dactablegen.csproj" />
+    <ProjectFile Include="diasdk\diasdk.nativeproj" >
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
+    <ProjectFile Include="dactablegen\dactablegen.csproj" >
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
   </ItemGroup>
   
   <Import Project="$(_NTDRIVE)$(_NTROOT)\tools\Microsoft.DevDiv.Traversal.targets" />

diff --git a/src/ToolBox/dirs.proj b/src/ToolBox/dirs.proj
index b4c4137..bd47b72 100644 (file)
--- a/src/ToolBox/dirs.proj
+++ b/src/ToolBox/dirs.proj
@@ -77,6 +77,9 @@
     <ProjectFile Include="winmdexp\dirs.proj" />
     <ProjectFile Include="winverify\dirs.proj" />
     <ProjectFile Include="wpf\wpf.proj" Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'amd64'" />
+    <ProjectFile Include="PdbTypeMatch\PdbTypeMatch.nativeproj" Condition="'$(BuildArchitecture)' == 'i386' and '$(_BuildType)' == 'ret'" >
+        <ProductGroups>PK</ProductGroups>
+    </ProjectFile>
   </ItemGroup>
   
   <!--The following projects will build during PHASE 1 of the CoreCLR build-->

diff --git a/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj b/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj
index d5ce215..9bd544d 100644 (file)
--- a/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj
+++ b/src/tools/GenClrDebugResource/GenClrDebugResource.nativeproj
@@ -10,7 +10,6 @@
     <OutputName>GenClrDebugResource</OutputName>
     <TargetType>PROGRAM</TargetType>
     <LinkSubsystem>console</LinkSubsystem>
-    <BinplaceSymbols>false</BinplaceSymbols>
     <LinkGenerateManifest>true</LinkGenerateManifest>
     <LinkAdditionalOptions>$(LinkAdditionalOptions) /MANIFEST</LinkAdditionalOptions>
     <UseMsvcrt>false</UseMsvcrt>
@@ -19,6 +18,9 @@
   <ItemGroup>
     <CppCompile Include="GenClrDebugResource.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
   <!--Import the targets-->
   <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
 </Project>
\ No newline at end of file

diff --git a/src/tools/GenClrDebugResource/native.rc b/src/tools/GenClrDebugResource/native.rc
new file mode 100644 (file)
index 0000000..c4474f2
--- /dev/null
+++ b/src/tools/GenClrDebugResource/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>

diff --git a/src/tools/InjectResource/InjectResource.nativeproj b/src/tools/InjectResource/InjectResource.nativeproj
index fc77425..057d01f 100644 (file)
--- a/src/tools/InjectResource/InjectResource.nativeproj
+++ b/src/tools/InjectResource/InjectResource.nativeproj
@@ -10,7 +10,7 @@
     <OutputName>InjectResource</OutputName>
     <TargetType>PROGRAM</TargetType>
     <LinkSubsystem>console</LinkSubsystem>
-    <BinplaceSymbols>false</BinplaceSymbols>
+    <BinplaceSymbols>true</BinplaceSymbols>
     <LinkGenerateManifest>true</LinkGenerateManifest>
     <LinkAdditionalOptions>$(LinkAdditionalOptions) /MANIFEST</LinkAdditionalOptions>
     <UseMsvcrt>false</UseMsvcrt>
@@ -19,6 +19,9 @@
   <ItemGroup>
     <CppCompile Include="InjectResource.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
   <!--Import the targets-->
   <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
 </Project>
\ No newline at end of file

diff --git a/src/tools/InjectResource/native.rc b/src/tools/InjectResource/native.rc
new file mode 100644 (file)
index 0000000..c4474f2
--- /dev/null
+++ b/src/tools/InjectResource/native.rc
@@ -0,0 +1,4 @@
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft\0"
+
+#include <fxver.h>
+#include <fxver.rc>

diff --git a/src/tools/dirs.proj b/src/tools/dirs.proj
index 2a17d6d..21f2833 100644 (file)
--- a/src/tools/dirs.proj
+++ b/src/tools/dirs.proj
@@ -48,7 +48,12 @@
     <ProjectFile Include="McjProfofileUtil\McjProfileUtil.csproj" Condition="'$(BuildArchitecture)' != 'arm' and '$(BuildArchitecture)' != 'arm64'" />
     <ProjectFile Include="winphoneintegrate\winphoneintegrate.csproj" />
     <ProjectFile Include="crossgen\crossgen.nativeproj" />
-    <ProjectFile Include="GenClrDebugResource\GenClrDebugResource.nativeproj" />
+    <ProjectFile Include="GenClrDebugResource\GenClrDebugResource.nativeproj" >
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
+    <ProjectFile Include="InjectResource\InjectResource.nativeproj" Condition="'$(BuildArchitecture)' == 'i386'">
+        <ProductGroups>FX;PK</ProductGroups>
+    </ProjectFile>
   </ItemGroup>
   
   <!-- CoreClr -->