summaryrefslogtreecommitdiff
path: root/src/ToolBox/PdbTypeMatch
diff options
context:
space:
mode:
Diffstat (limited to 'src/ToolBox/PdbTypeMatch')
-rw-r--r--src/ToolBox/PdbTypeMatch/.gitmirror1
-rw-r--r--src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp2023
-rw-r--r--src/ToolBox/PdbTypeMatch/PdbTypeMatch.h69
-rw-r--r--src/ToolBox/PdbTypeMatch/PdbTypeMatch.nativeproj59
-rw-r--r--src/ToolBox/PdbTypeMatch/PrintSymbol.cpp2254
-rw-r--r--src/ToolBox/PdbTypeMatch/PrintSymbol.h66
-rw-r--r--src/ToolBox/PdbTypeMatch/callback.h96
-rw-r--r--src/ToolBox/PdbTypeMatch/include/.gitmirror1
-rw-r--r--src/ToolBox/PdbTypeMatch/include/cvconst.h3181
-rw-r--r--src/ToolBox/PdbTypeMatch/include/dia2.h7854
-rw-r--r--src/ToolBox/PdbTypeMatch/include/diacreate.h40
-rw-r--r--src/ToolBox/PdbTypeMatch/native.rc8
-rw-r--r--src/ToolBox/PdbTypeMatch/regs.cpp1708
-rw-r--r--src/ToolBox/PdbTypeMatch/regs.h23
-rw-r--r--src/ToolBox/PdbTypeMatch/stdafx.cpp9
-rw-r--r--src/ToolBox/PdbTypeMatch/stdafx.h25
16 files changed, 17417 insertions, 0 deletions
diff --git a/src/ToolBox/PdbTypeMatch/.gitmirror b/src/ToolBox/PdbTypeMatch/.gitmirror
new file mode 100644
index 0000000000..f507630f94
--- /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
index 0000000000..052e9e0d1d
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.cpp
@@ -0,0 +1,2023 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#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;
+ case IMAGE_FILE_MACHINE_ARMNT : g_dwMachineType = CV_CFL_ARM7; 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
index 0000000000..2da38cf2b5
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PdbTypeMatch.h
@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#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
index 0000000000..fb2f71b36c
--- /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
index 0000000000..41e3d4cf0e
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PrintSymbol.cpp
@@ -0,0 +1,2254 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// PrintSymbol.cpp : Defines the printing procedures for the symbols
+//
+// This is a part of the Debug Interface Access SDK
+//
+// 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
index 0000000000..5a39460f3f
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/PrintSymbol.h
@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#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
index 0000000000..34ea3d80c0
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/callback.h
@@ -0,0 +1,96 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#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() {
+ ULONG newRefCount = --m_nRefCount;
+ if ( newRefCount == 0 )
+ delete this;
+ return newRefCount;
+ }
+ HRESULT STDMETHODCALLTYPE QueryInterface( REFIID rid, void **ppUnk ) {
+ if ( ppUnk == NULL ) {
+ return E_POINTER;
+ }
+ 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
index 0000000000..f507630f94
--- /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
index 0000000000..6356197c81
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/cvconst.h
@@ -0,0 +1,3181 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// cvconst.h - codeview constant definitions
+
+#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
index 0000000000..3f400b0575
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/dia2.h
@@ -0,0 +1,7854 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/* 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
index 0000000000..8ed82d2ff6
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/include/diacreate.h
@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// diacreate.h - creation helper functions for DIA initialization
+#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
index 0000000000..31e9f49b36
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/native.rc
@@ -0,0 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#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
index 0000000000..aa56cbd3f7
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/regs.cpp
@@ -0,0 +1,1708 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#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
index 0000000000..946d5b8f49
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/regs.h
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+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
index 0000000000..f6da4386ea
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/stdafx.cpp
@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// 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
index 0000000000..7d1423147d
--- /dev/null
+++ b/src/ToolBox/PdbTypeMatch/stdafx.h
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// 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"
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-21 20:30:50 +0000