language
stringlengths
0
24
filename
stringlengths
9
214
code
stringlengths
99
9.93M
C++
x64dbg-development/src/dbg/_scriptapi_register.cpp
#include "_scriptapi_register.h" #include "value.h" #include "debugger.h" #include "TraceRecord.h" static const char* regTable[] = { "DR0", "DR1", "DR2", "DR3", "DR6", "DR7", "EAX", "AX", "AH", "AL", "EBX", "BX", "BH", "BL", "ECX", "CX", "CH", "CL", "EDX", "DX", "DH", "DL", "EDI", "DI", "ESI", "SI", "EBP", "BP", "ESP", "SP", "EIP", #ifdef _WIN64 "RAX", "RBX", "RCX", "RDX", "RSI", "SIL", "RDI", "DIL", "RBP", "BPL", "RSP", "SPL", "RIP", "R8", "R8D", "R8W", "R8B", "R9", "R9D", "R9W", "R9B", "R10", "R10D", "R10W", "R10B", "R11", "R11D", "R11W", "R11B", "R12", "R12D", "R12W", "R12B", "R13", "R13D", "R13W", "R13B", "R14", "R14D", "R14W", "R14B", "R15", "R15D", "R15W", "R15", #endif //_WIN64 ArchValue("EIP", "RIP"), ArchValue("ESP", "RSP"), ArchValue("EAX", "RAX"), ArchValue("EBX", "RBX"), ArchValue("ECX", "RCX"), ArchValue("EDX", "RDX"), ArchValue("EDI", "RDI"), ArchValue("ESI", "RSI"), ArchValue("EBP", "RBP"), ArchValue("EFLAGS", "RFLAGS") }; SCRIPT_EXPORT duint Script::Register::Get(Script::Register::RegisterEnum reg) { return getregister(nullptr, regTable[reg]); } SCRIPT_EXPORT bool Script::Register::Set(Script::Register::RegisterEnum reg, duint value) { auto result = setregister(regTable[reg], value); if(reg == ArchValue(EIP, RIP) || reg == CIP) { auto cip = GetContextDataEx(hActiveThread, UE_CIP); dbgtraceexecute(cip); DebugUpdateGuiAsync(cip, false); //update disassembly + register view } else if(reg == ArchValue(ESP, RSP) || reg == SP || reg == CSP) //update stack { duint csp = GetContextDataEx(hActiveThread, UE_CSP); DebugUpdateStack(csp, csp); } return result; } SCRIPT_EXPORT int Script::Register::Size() { return (int)sizeof(duint); } SCRIPT_EXPORT duint Script::Register::GetDR0() { return Get(DR0); } SCRIPT_EXPORT bool Script::Register::SetDR0(duint value) { return Set(DR0, value); } SCRIPT_EXPORT duint Script::Register::GetDR1() { return Get(DR1); } SCRIPT_EXPORT bool Script::Register::SetDR1(duint value) { return Set(DR1, value); } SCRIPT_EXPORT duint Script::Register::GetDR2() { return Get(DR2); } SCRIPT_EXPORT bool Script::Register::SetDR2(duint value) { return Set(DR2, value); } SCRIPT_EXPORT duint Script::Register::GetDR3() { return Get(DR3); } SCRIPT_EXPORT bool Script::Register::SetDR3(duint value) { return Set(DR3, value); } SCRIPT_EXPORT duint Script::Register::GetDR6() { return Get(DR6); } SCRIPT_EXPORT bool Script::Register::SetDR6(duint value) { return Set(DR6, value); } SCRIPT_EXPORT duint Script::Register::GetDR7() { return Get(DR7); } SCRIPT_EXPORT bool Script::Register::SetDR7(duint value) { return Set(DR7, value); } SCRIPT_EXPORT unsigned int Script::Register::GetEAX() { return (unsigned int)Get(EAX); } SCRIPT_EXPORT bool Script::Register::SetEAX(unsigned int value) { return Set(EAX, value); } SCRIPT_EXPORT unsigned short Script::Register::GetAX() { return (unsigned short)Get(AX); } SCRIPT_EXPORT bool Script::Register::SetAX(unsigned short value) { return Set(AX, value); } SCRIPT_EXPORT unsigned char Script::Register::GetAH() { return (unsigned char)Get(AH); } SCRIPT_EXPORT bool Script::Register::SetAH(unsigned char value) { return Set(AH, value); } SCRIPT_EXPORT unsigned char Script::Register::GetAL() { return (unsigned char)Get(AL); } SCRIPT_EXPORT bool Script::Register::SetAL(unsigned char value) { return Set(AL, value); } SCRIPT_EXPORT unsigned int Script::Register::GetEBX() { return (unsigned int)Get(EBX); } SCRIPT_EXPORT bool Script::Register::SetEBX(unsigned int value) { return Set(EBX, value); } SCRIPT_EXPORT unsigned short Script::Register::GetBX() { return (unsigned short)Get(BX); } SCRIPT_EXPORT bool Script::Register::SetBX(unsigned short value) { return Set(BX, value); } SCRIPT_EXPORT unsigned char Script::Register::GetBH() { return (unsigned char)Get(BH); } SCRIPT_EXPORT bool Script::Register::SetBH(unsigned char value) { return Set(BH, value); } SCRIPT_EXPORT unsigned char Script::Register::GetBL() { return (unsigned char)Get(BL); } SCRIPT_EXPORT bool Script::Register::SetBL(unsigned char value) { return Set(BL, value); } SCRIPT_EXPORT unsigned int Script::Register::GetECX() { return (unsigned int)Get(ECX); } SCRIPT_EXPORT bool Script::Register::SetECX(unsigned int value) { return Set(ECX, value); } SCRIPT_EXPORT unsigned short Script::Register::GetCX() { return (unsigned short)Get(CX); } SCRIPT_EXPORT bool Script::Register::SetCX(unsigned short value) { return Set(CX, value); } SCRIPT_EXPORT unsigned char Script::Register::GetCH() { return (unsigned char)Get(CH); } SCRIPT_EXPORT bool Script::Register::SetCH(unsigned char value) { return Set(CH, value); } SCRIPT_EXPORT unsigned char Script::Register::GetCL() { return (unsigned char)Get(CL); } SCRIPT_EXPORT bool Script::Register::SetCL(unsigned char value) { return Set(CL, value); } SCRIPT_EXPORT unsigned int Script::Register::GetEDX() { return (unsigned int)Get(EDX); } SCRIPT_EXPORT bool Script::Register::SetEDX(unsigned int value) { return Set(EDX, value); } SCRIPT_EXPORT unsigned short Script::Register::GetDX() { return (unsigned short)Get(DX); } SCRIPT_EXPORT bool Script::Register::SetDX(unsigned short value) { return Set(DX, value); } SCRIPT_EXPORT unsigned char Script::Register::GetDH() { return (unsigned char)Get(DH); } SCRIPT_EXPORT bool Script::Register::SetDH(unsigned char value) { return Set(DH, value); } SCRIPT_EXPORT unsigned char Script::Register::GetDL() { return (unsigned char)Get(DL); } SCRIPT_EXPORT bool Script::Register::SetDL(unsigned char value) { return Set(DL, value); } SCRIPT_EXPORT unsigned int Script::Register::GetEDI() { return (unsigned int)Get(EDI); } SCRIPT_EXPORT bool Script::Register::SetEDI(unsigned int value) { return Set(EDI, value); } SCRIPT_EXPORT unsigned short Script::Register::GetDI() { return (unsigned short)Get(DI); } SCRIPT_EXPORT bool Script::Register::SetDI(unsigned short value) { return Set(DI, value); } SCRIPT_EXPORT unsigned int Script::Register::GetESI() { return (unsigned int)Get(ESI); } SCRIPT_EXPORT bool Script::Register::SetESI(unsigned int value) { return Set(ESI, value); } SCRIPT_EXPORT unsigned short Script::Register::GetSI() { return (unsigned short)Get(SI); } SCRIPT_EXPORT bool Script::Register::SetSI(unsigned short value) { return Set(SI, value); } SCRIPT_EXPORT unsigned int Script::Register::GetEBP() { return (unsigned int)Get(EBP); } SCRIPT_EXPORT bool Script::Register::SetEBP(unsigned int value) { return Set(EBP, value); } SCRIPT_EXPORT unsigned short Script::Register::GetBP() { return (unsigned short)Get(BP); } SCRIPT_EXPORT bool Script::Register::SetBP(unsigned short value) { return Set(BP, value); } SCRIPT_EXPORT unsigned int Script::Register::GetESP() { return (unsigned int)Get(ESP); } SCRIPT_EXPORT bool Script::Register::SetESP(unsigned int value) { return Set(ESP, value); } SCRIPT_EXPORT unsigned short Script::Register::GetSP() { return (unsigned short)Get(SP); } SCRIPT_EXPORT bool Script::Register::SetSP(unsigned short value) { return Set(SP, value); } SCRIPT_EXPORT unsigned int Script::Register::GetEIP() { return (unsigned int)Get(EIP); } SCRIPT_EXPORT bool Script::Register::SetEIP(unsigned int value) { return Set(EIP, value); } #ifdef _WIN64 SCRIPT_EXPORT unsigned long long Script::Register::GetRAX() { return (unsigned long long)Get(RAX); } SCRIPT_EXPORT bool Script::Register::SetRAX(unsigned long long value) { return Set(RAX, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRBX() { return (unsigned long long)Get(RBX); } SCRIPT_EXPORT bool Script::Register::SetRBX(unsigned long long value) { return Set(RBX, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRCX() { return (unsigned long long)Get(RCX); } SCRIPT_EXPORT bool Script::Register::SetRCX(unsigned long long value) { return Set(RCX, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRDX() { return (unsigned long long)Get(RDX); } SCRIPT_EXPORT bool Script::Register::SetRDX(unsigned long long value) { return Set(RDX, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRSI() { return (unsigned long long)Get(RSI); } SCRIPT_EXPORT bool Script::Register::SetRSI(unsigned long long value) { return Set(RSI, value); } SCRIPT_EXPORT unsigned char Script::Register::GetSIL() { return (unsigned char)Get(SIL); } SCRIPT_EXPORT bool Script::Register::SetSIL(unsigned char value) { return Set(SIL, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRDI() { return (unsigned long long)Get(RDI); } SCRIPT_EXPORT bool Script::Register::SetRDI(unsigned long long value) { return Set(RDI, value); } SCRIPT_EXPORT unsigned char Script::Register::GetDIL() { return (unsigned char)Get(DIL); } SCRIPT_EXPORT bool Script::Register::SetDIL(unsigned char value) { return Set(DIL, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRBP() { return (unsigned long long)Get(RBP); } SCRIPT_EXPORT bool Script::Register::SetRBP(unsigned long long value) { return Set(RBP, value); } SCRIPT_EXPORT unsigned char Script::Register::GetBPL() { return (unsigned char)Get(BPL); } SCRIPT_EXPORT bool Script::Register::SetBPL(unsigned char value) { return Set(BPL, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRSP() { return (unsigned long long)Get(RSP); } SCRIPT_EXPORT bool Script::Register::SetRSP(unsigned long long value) { return Set(RSP, value); } SCRIPT_EXPORT unsigned char Script::Register::GetSPL() { return (unsigned char)Get(SPL); } SCRIPT_EXPORT bool Script::Register::SetSPL(unsigned char value) { return Set(SPL, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetRIP() { return (unsigned long long)Get(RIP); } SCRIPT_EXPORT bool Script::Register::SetRIP(unsigned long long value) { return Set(RIP, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR8() { return (unsigned long long)Get(R8); } SCRIPT_EXPORT bool Script::Register::SetR8(unsigned long long value) { return Set(R8, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR8D() { return (unsigned int)Get(R8D); } SCRIPT_EXPORT bool Script::Register::SetR8D(unsigned int value) { return Set(R8D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR8W() { return (unsigned short)Get(R8W); } SCRIPT_EXPORT bool Script::Register::SetR8W(unsigned short value) { return Set(R8W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR8B() { return (unsigned char)Get(R8B); } SCRIPT_EXPORT bool Script::Register::SetR8B(unsigned char value) { return Set(R8B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR9() { return (unsigned long long)Get(R9); } SCRIPT_EXPORT bool Script::Register::SetR9(unsigned long long value) { return Set(R9, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR9D() { return (unsigned int)Get(R9D); } SCRIPT_EXPORT bool Script::Register::SetR9D(unsigned int value) { return Set(R9D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR9W() { return (unsigned short)Get(R9W); } SCRIPT_EXPORT bool Script::Register::SetR9W(unsigned short value) { return Set(R9W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR9B() { return (unsigned char)Get(R9B); } SCRIPT_EXPORT bool Script::Register::SetR9B(unsigned char value) { return Set(R9B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR10() { return (unsigned long long)Get(R10); } SCRIPT_EXPORT bool Script::Register::SetR10(unsigned long long value) { return Set(R10, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR10D() { return (unsigned int)Get(R10D); } SCRIPT_EXPORT bool Script::Register::SetR10D(unsigned int value) { return Set(R10D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR10W() { return (unsigned short)Get(R10W); } SCRIPT_EXPORT bool Script::Register::SetR10W(unsigned short value) { return Set(R10W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR10B() { return (unsigned char)Get(R10B); } SCRIPT_EXPORT bool Script::Register::SetR10B(unsigned char value) { return Set(R10B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR11() { return (unsigned long long)Get(R11); } SCRIPT_EXPORT bool Script::Register::SetR11(unsigned long long value) { return Set(R11, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR11D() { return (unsigned int)Get(R11D); } SCRIPT_EXPORT bool Script::Register::SetR11D(unsigned int value) { return Set(R11D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR11W() { return (unsigned short)Get(R11W); } SCRIPT_EXPORT bool Script::Register::SetR11W(unsigned short value) { return Set(R11W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR11B() { return (unsigned char)Get(R11B); } SCRIPT_EXPORT bool Script::Register::SetR11B(unsigned char value) { return Set(R11B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR12() { return (unsigned long long)Get(R12); } SCRIPT_EXPORT bool Script::Register::SetR12(unsigned long long value) { return Set(R12, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR12D() { return (unsigned int)Get(R12D); } SCRIPT_EXPORT bool Script::Register::SetR12D(unsigned int value) { return Set(R12D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR12W() { return (unsigned short)Get(R12W); } SCRIPT_EXPORT bool Script::Register::SetR12W(unsigned short value) { return Set(R12W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR12B() { return (unsigned char)Get(R12B); } SCRIPT_EXPORT bool Script::Register::SetR12B(unsigned char value) { return Set(R12B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR13() { return (unsigned long long)Get(R13); } SCRIPT_EXPORT bool Script::Register::SetR13(unsigned long long value) { return Set(R13, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR13D() { return (unsigned int)Get(R13D); } SCRIPT_EXPORT bool Script::Register::SetR13D(unsigned int value) { return Set(R13D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR13W() { return (unsigned short)Get(R13W); } SCRIPT_EXPORT bool Script::Register::SetR13W(unsigned short value) { return Set(R13W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR13B() { return (unsigned char)Get(R13B); } SCRIPT_EXPORT bool Script::Register::SetR13B(unsigned char value) { return Set(R13B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR14() { return (unsigned long long)Get(R14); } SCRIPT_EXPORT bool Script::Register::SetR14(unsigned long long value) { return Set(R14, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR14D() { return (unsigned int)Get(R14D); } SCRIPT_EXPORT bool Script::Register::SetR14D(unsigned int value) { return Set(R14D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR14W() { return (unsigned short)Get(R14W); } SCRIPT_EXPORT bool Script::Register::SetR14W(unsigned short value) { return Set(R14W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR14B() { return (unsigned char)Get(R14B); } SCRIPT_EXPORT bool Script::Register::SetR14B(unsigned char value) { return Set(R14B, value); } SCRIPT_EXPORT unsigned long long Script::Register::GetR15() { return (unsigned long long)Get(R15); } SCRIPT_EXPORT bool Script::Register::SetR15(unsigned long long value) { return Set(R15, value); } SCRIPT_EXPORT unsigned int Script::Register::GetR15D() { return (unsigned int)Get(R15D); } SCRIPT_EXPORT bool Script::Register::SetR15D(unsigned int value) { return Set(R15D, value); } SCRIPT_EXPORT unsigned short Script::Register::GetR15W() { return (unsigned short)Get(R15W); } SCRIPT_EXPORT bool Script::Register::SetR15W(unsigned short value) { return Set(R15W, value); } SCRIPT_EXPORT unsigned char Script::Register::GetR15B() { return (unsigned char)Get(R15B); } SCRIPT_EXPORT bool Script::Register::SetR15B(unsigned char value) { return Set(R15B, value); } #endif //_WIN64 SCRIPT_EXPORT duint Script::Register::GetCAX() { return Get(CAX); } SCRIPT_EXPORT bool Script::Register::SetCAX(duint value) { return Set(CAX, value); } SCRIPT_EXPORT duint Script::Register::GetCBX() { return Get(CBX); } SCRIPT_EXPORT bool Script::Register::SetCBX(duint value) { return Set(CBX, value); } SCRIPT_EXPORT duint Script::Register::GetCCX() { return Get(CCX); } SCRIPT_EXPORT bool Script::Register::SetCCX(duint value) { return Set(CCX, value); } SCRIPT_EXPORT duint Script::Register::GetCDX() { return Get(CDX); } SCRIPT_EXPORT bool Script::Register::SetCDX(duint value) { return Set(CDX, value); } SCRIPT_EXPORT duint Script::Register::GetCDI() { return Get(CDI); } SCRIPT_EXPORT bool Script::Register::SetCDI(duint value) { return Set(CDI, value); } SCRIPT_EXPORT duint Script::Register::GetCSI() { return Get(CSI); } SCRIPT_EXPORT bool Script::Register::SetCSI(duint value) { return Set(CSI, value); } SCRIPT_EXPORT duint Script::Register::GetCBP() { return Get(CBP); } SCRIPT_EXPORT bool Script::Register::SetCBP(duint value) { return Set(CBP, value); } SCRIPT_EXPORT duint Script::Register::GetCSP() { return Get(CSP); } SCRIPT_EXPORT bool Script::Register::SetCSP(duint value) { return Set(CSP, value); } SCRIPT_EXPORT duint Script::Register::GetCIP() { return Get(CIP); } SCRIPT_EXPORT bool Script::Register::SetCIP(duint value) { return Set(CIP, value); } SCRIPT_EXPORT duint Script::Register::GetCFLAGS() { return Get(CFLAGS); } SCRIPT_EXPORT bool Script::Register::SetCFLAGS(duint value) { return Set(CFLAGS, value); }
C/C++
x64dbg-development/src/dbg/_scriptapi_register.h
#ifndef _SCRIPTAPI_REGISTER_H #define _SCRIPTAPI_REGISTER_H #include "_scriptapi.h" namespace Script { namespace Register { enum RegisterEnum { DR0, DR1, DR2, DR3, DR6, DR7, EAX, AX, AH, AL, EBX, BX, BH, BL, ECX, CX, CH, CL, EDX, DX, DH, DL, EDI, DI, ESI, SI, EBP, BP, ESP, SP, EIP, #ifdef _WIN64 RAX, RBX, RCX, RDX, RSI, SIL, RDI, DIL, RBP, BPL, RSP, SPL, RIP, R8, R8D, R8W, R8B, R9, R9D, R9W, R9B, R10, R10D, R10W, R10B, R11, R11D, R11W, R11B, R12, R12D, R12W, R12B, R13, R13D, R13W, R13B, R14, R14D, R14W, R14B, R15, R15D, R15W, R15B, #endif //_WIN64 CIP, CSP, CAX, CBX, CCX, CDX, CDI, CSI, CBP, CFLAGS }; //RegisterEnum SCRIPT_EXPORT duint Get(RegisterEnum reg); SCRIPT_EXPORT bool Set(RegisterEnum reg, duint value); SCRIPT_EXPORT int Size(); //gets architecture register size in bytes SCRIPT_EXPORT duint GetDR0(); SCRIPT_EXPORT bool SetDR0(duint value); SCRIPT_EXPORT duint GetDR1(); SCRIPT_EXPORT bool SetDR1(duint value); SCRIPT_EXPORT duint GetDR2(); SCRIPT_EXPORT bool SetDR2(duint value); SCRIPT_EXPORT duint GetDR3(); SCRIPT_EXPORT bool SetDR3(duint value); SCRIPT_EXPORT duint GetDR6(); SCRIPT_EXPORT bool SetDR6(duint value); SCRIPT_EXPORT duint GetDR7(); SCRIPT_EXPORT bool SetDR7(duint value); SCRIPT_EXPORT unsigned int GetEAX(); SCRIPT_EXPORT bool SetEAX(unsigned int value); SCRIPT_EXPORT unsigned short GetAX(); SCRIPT_EXPORT bool SetAX(unsigned short value); SCRIPT_EXPORT unsigned char GetAH(); SCRIPT_EXPORT bool SetAH(unsigned char value); SCRIPT_EXPORT unsigned char GetAL(); SCRIPT_EXPORT bool SetAL(unsigned char value); SCRIPT_EXPORT unsigned int GetEBX(); SCRIPT_EXPORT bool SetEBX(unsigned int value); SCRIPT_EXPORT unsigned short GetBX(); SCRIPT_EXPORT bool SetBX(unsigned short value); SCRIPT_EXPORT unsigned char GetBH(); SCRIPT_EXPORT bool SetBH(unsigned char value); SCRIPT_EXPORT unsigned char GetBL(); SCRIPT_EXPORT bool SetBL(unsigned char value); SCRIPT_EXPORT unsigned int GetECX(); SCRIPT_EXPORT bool SetECX(unsigned int value); SCRIPT_EXPORT unsigned short GetCX(); SCRIPT_EXPORT bool SetCX(unsigned short value); SCRIPT_EXPORT unsigned char GetCH(); SCRIPT_EXPORT bool SetCH(unsigned char value); SCRIPT_EXPORT unsigned char GetCL(); SCRIPT_EXPORT bool SetCL(unsigned char value); SCRIPT_EXPORT unsigned int GetEDX(); SCRIPT_EXPORT bool SetEDX(unsigned int value); SCRIPT_EXPORT unsigned short GetDX(); SCRIPT_EXPORT bool SetDX(unsigned short value); SCRIPT_EXPORT unsigned char GetDH(); SCRIPT_EXPORT bool SetDH(unsigned char value); SCRIPT_EXPORT unsigned char GetDL(); SCRIPT_EXPORT bool SetDL(unsigned char value); SCRIPT_EXPORT unsigned int GetEDI(); SCRIPT_EXPORT bool SetEDI(unsigned int value); SCRIPT_EXPORT unsigned short GetDI(); SCRIPT_EXPORT bool SetDI(unsigned short value); SCRIPT_EXPORT unsigned int GetESI(); SCRIPT_EXPORT bool SetESI(unsigned int value); SCRIPT_EXPORT unsigned short GetSI(); SCRIPT_EXPORT bool SetSI(unsigned short value); SCRIPT_EXPORT unsigned int GetEBP(); SCRIPT_EXPORT bool SetEBP(unsigned int value); SCRIPT_EXPORT unsigned short GetBP(); SCRIPT_EXPORT bool SetBP(unsigned short value); SCRIPT_EXPORT unsigned int GetESP(); SCRIPT_EXPORT bool SetESP(unsigned int value); SCRIPT_EXPORT unsigned short GetSP(); SCRIPT_EXPORT bool SetSP(unsigned short value); SCRIPT_EXPORT unsigned int GetEIP(); SCRIPT_EXPORT bool SetEIP(unsigned int value); #ifdef _WIN64 SCRIPT_EXPORT unsigned long long GetRAX(); SCRIPT_EXPORT bool SetRAX(unsigned long long value); SCRIPT_EXPORT unsigned long long GetRBX(); SCRIPT_EXPORT bool SetRBX(unsigned long long value); SCRIPT_EXPORT unsigned long long GetRCX(); SCRIPT_EXPORT bool SetRCX(unsigned long long value); SCRIPT_EXPORT unsigned long long GetRDX(); SCRIPT_EXPORT bool SetRDX(unsigned long long value); SCRIPT_EXPORT unsigned long long GetRSI(); SCRIPT_EXPORT bool SetRSI(unsigned long long value); SCRIPT_EXPORT unsigned char GetSIL(); SCRIPT_EXPORT bool SetSIL(unsigned char value); SCRIPT_EXPORT unsigned long long GetRDI(); SCRIPT_EXPORT bool SetRDI(unsigned long long value); SCRIPT_EXPORT unsigned char GetDIL(); SCRIPT_EXPORT bool SetDIL(unsigned char value); SCRIPT_EXPORT unsigned long long GetRBP(); SCRIPT_EXPORT bool SetRBP(unsigned long long value); SCRIPT_EXPORT unsigned char GetBPL(); SCRIPT_EXPORT bool SetBPL(unsigned char value); SCRIPT_EXPORT unsigned long long GetRSP(); SCRIPT_EXPORT bool SetRSP(unsigned long long value); SCRIPT_EXPORT unsigned char GetSPL(); SCRIPT_EXPORT bool SetSPL(unsigned char value); SCRIPT_EXPORT unsigned long long GetRIP(); SCRIPT_EXPORT bool SetRIP(unsigned long long value); SCRIPT_EXPORT unsigned long long GetR8(); SCRIPT_EXPORT bool SetR8(unsigned long long value); SCRIPT_EXPORT unsigned int GetR8D(); SCRIPT_EXPORT bool SetR8D(unsigned int value); SCRIPT_EXPORT unsigned short GetR8W(); SCRIPT_EXPORT bool SetR8W(unsigned short value); SCRIPT_EXPORT unsigned char GetR8B(); SCRIPT_EXPORT bool SetR8B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR9(); SCRIPT_EXPORT bool SetR9(unsigned long long value); SCRIPT_EXPORT unsigned int GetR9D(); SCRIPT_EXPORT bool SetR9D(unsigned int value); SCRIPT_EXPORT unsigned short GetR9W(); SCRIPT_EXPORT bool SetR9W(unsigned short value); SCRIPT_EXPORT unsigned char GetR9B(); SCRIPT_EXPORT bool SetR9B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR10(); SCRIPT_EXPORT bool SetR10(unsigned long long value); SCRIPT_EXPORT unsigned int GetR10D(); SCRIPT_EXPORT bool SetR10D(unsigned int value); SCRIPT_EXPORT unsigned short GetR10W(); SCRIPT_EXPORT bool SetR10W(unsigned short value); SCRIPT_EXPORT unsigned char GetR10B(); SCRIPT_EXPORT bool SetR10B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR11(); SCRIPT_EXPORT bool SetR11(unsigned long long value); SCRIPT_EXPORT unsigned int GetR11D(); SCRIPT_EXPORT bool SetR11D(unsigned int value); SCRIPT_EXPORT unsigned short GetR11W(); SCRIPT_EXPORT bool SetR11W(unsigned short value); SCRIPT_EXPORT unsigned char GetR11B(); SCRIPT_EXPORT bool SetR11B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR12(); SCRIPT_EXPORT bool SetR12(unsigned long long value); SCRIPT_EXPORT unsigned int GetR12D(); SCRIPT_EXPORT bool SetR12D(unsigned int value); SCRIPT_EXPORT unsigned short GetR12W(); SCRIPT_EXPORT bool SetR12W(unsigned short value); SCRIPT_EXPORT unsigned char GetR12B(); SCRIPT_EXPORT bool SetR12B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR13(); SCRIPT_EXPORT bool SetR13(unsigned long long value); SCRIPT_EXPORT unsigned int GetR13D(); SCRIPT_EXPORT bool SetR13D(unsigned int value); SCRIPT_EXPORT unsigned short GetR13W(); SCRIPT_EXPORT bool SetR13W(unsigned short value); SCRIPT_EXPORT unsigned char GetR13B(); SCRIPT_EXPORT bool SetR13B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR14(); SCRIPT_EXPORT bool SetR14(unsigned long long value); SCRIPT_EXPORT unsigned int GetR14D(); SCRIPT_EXPORT bool SetR14D(unsigned int value); SCRIPT_EXPORT unsigned short GetR14W(); SCRIPT_EXPORT bool SetR14W(unsigned short value); SCRIPT_EXPORT unsigned char GetR14B(); SCRIPT_EXPORT bool SetR14B(unsigned char value); SCRIPT_EXPORT unsigned long long GetR15(); SCRIPT_EXPORT bool SetR15(unsigned long long value); SCRIPT_EXPORT unsigned int GetR15D(); SCRIPT_EXPORT bool SetR15D(unsigned int value); SCRIPT_EXPORT unsigned short GetR15W(); SCRIPT_EXPORT bool SetR15W(unsigned short value); SCRIPT_EXPORT unsigned char GetR15B(); SCRIPT_EXPORT bool SetR15B(unsigned char value); #endif //_WIN64 SCRIPT_EXPORT duint GetCAX(); SCRIPT_EXPORT bool SetCAX(duint value); SCRIPT_EXPORT duint GetCBX(); SCRIPT_EXPORT bool SetCBX(duint value); SCRIPT_EXPORT duint GetCCX(); SCRIPT_EXPORT bool SetCCX(duint value); SCRIPT_EXPORT duint GetCDX(); SCRIPT_EXPORT bool SetCDX(duint value); SCRIPT_EXPORT duint GetCDI(); SCRIPT_EXPORT bool SetCDI(duint value); SCRIPT_EXPORT duint GetCSI(); SCRIPT_EXPORT bool SetCSI(duint value); SCRIPT_EXPORT duint GetCBP(); SCRIPT_EXPORT bool SetCBP(duint value); SCRIPT_EXPORT duint GetCSP(); SCRIPT_EXPORT bool SetCSP(duint value); SCRIPT_EXPORT duint GetCIP(); SCRIPT_EXPORT bool SetCIP(duint value); SCRIPT_EXPORT duint GetCFLAGS(); SCRIPT_EXPORT bool SetCFLAGS(duint value); }; //Register }; //Script #endif //_SCRIPTAPI_REGISTER_H
C++
x64dbg-development/src/dbg/_scriptapi_stack.cpp
#include "_scriptapi_stack.h" #include "_scriptapi_memory.h" #include "_scriptapi_register.h" SCRIPT_EXPORT duint Script::Stack::Pop() { duint csp = Register::GetCSP(); duint top = Memory::ReadPtr(csp); Register::SetCSP(csp + sizeof(duint)); return top; } SCRIPT_EXPORT duint Script::Stack::Push(duint value) { duint csp = Register::GetCSP(); Register::SetCSP(csp - sizeof(duint)); Memory::WritePtr(csp - sizeof(duint), value); return Memory::ReadPtr(csp); } SCRIPT_EXPORT duint Script::Stack::Peek(int offset) { return Memory::ReadPtr(Register::GetCSP() + offset * sizeof(duint)); }
C/C++
x64dbg-development/src/dbg/_scriptapi_stack.h
#ifndef _SCRIPTAPI_STACK_H #define _SCRIPTAPI_STACK_H #include "_scriptapi.h" namespace Script { namespace Stack { SCRIPT_EXPORT duint Pop(); SCRIPT_EXPORT duint Push(duint value); //returns the previous top, equal to Peek(1) SCRIPT_EXPORT duint Peek(int offset = 0); //offset is in multiples of Register::Size(), for easy x32/x64 portability }; //Stack }; //Script #endif //_SCRIPTAPI_STACK_H
C++
x64dbg-development/src/dbg/_scriptapi_symbol.cpp
#include "_scriptapi_symbol.h" #include "_scriptapi_label.h" #include "symbolinfo.h" using namespace Script::Symbol; struct cbSymbolEnumCtx { const SYMBOLMODULEINFO* module; std::vector<SymbolInfo>* symbols; }; static bool cbSymbolEnum(const SYMBOLPTR* ptr, void* user) { auto ctx = (cbSymbolEnumCtx*)user; SYMBOLINFO info; DbgGetSymbolInfo(ptr, &info); const bool hasUndecoratedName = (0 != info.undecoratedSymbol) && (0 != info.undecoratedSymbol[0]); const char* symbolName = hasUndecoratedName ? info.undecoratedSymbol : info.decoratedSymbol; SymbolInfo symbol = {}; strncpy_s(symbol.mod, sizeof(symbol.mod), ctx->module->name, sizeof(symbol.mod) - 1); symbol.rva = info.addr - ctx->module->base; strncpy_s(symbol.name, sizeof(symbol.name), symbolName, sizeof(symbol.name) - 1); symbol.manual = false; switch(info.type) { case sym_import: symbol.type = Import; break; case sym_export: symbol.type = Export; break; case sym_symbol: symbol.type = Function; break; default: __debugbreak(); } if(info.freeDecorated) BridgeFree(info.decoratedSymbol); if(info.freeUndecorated) BridgeFree(info.undecoratedSymbol); ctx->symbols->push_back(symbol); return true; } SCRIPT_EXPORT bool Script::Symbol::GetList(ListOf(SymbolInfo) list) { BridgeList<Label::LabelInfo> labels; if(!Label::GetList(&labels)) return false; std::vector<SymbolInfo> symbols; symbols.reserve(labels.Count()); for(auto i = 0; i < labels.Count(); i++) { const auto & label = labels[i]; SymbolInfo symbol; strcpy_s(symbol.mod, label.mod); symbol.rva = label.rva; strcpy_s(symbol.name, label.text); symbol.manual = label.manual; symbol.type = Function; symbols.push_back(symbol); } std::vector<SYMBOLMODULEINFO> modules; SymGetModuleList(&modules); cbSymbolEnumCtx ctx; ctx.symbols = &symbols; for(const auto & mod : modules) { ctx.module = &mod; DbgSymbolEnumFromCache(mod.base, cbSymbolEnum, &ctx); } //TODO: enumerate actual symbols + virtual symbols (sub_XXXXXX) + imports + exports in addition to user-defined labels. return BridgeList<SymbolInfo>::CopyData(list, symbols); }
C/C++
x64dbg-development/src/dbg/_scriptapi_symbol.h
#ifndef _SCRIPTAPI_SYMBOL_H #define _SCRIPTAPI_SYMBOL_H #include "_scriptapi.h" namespace Script { namespace Symbol { enum SymbolType { Function, //user-defined function Import, //IAT entry Export //export }; struct SymbolInfo { char mod[MAX_MODULE_SIZE]; duint rva; char name[MAX_LABEL_SIZE]; bool manual; SymbolType type; }; SCRIPT_EXPORT bool GetList(ListOf(SymbolInfo) list); //caller has the responsibility to free the list }; //Symbol }; //Script #endif //_SCRIPTAPI_SYMBOL_H
C++
x64dbg-development/src/dbg/analysis/advancedanalysis.cpp
#include "advancedanalysis.h" #include <queue> #include "console.h" #include "filehelper.h" #include "function.h" #include "xrefs.h" #include "encodemap.h" AdvancedAnalysis::AdvancedAnalysis(duint base, duint size, bool dump) : Analysis(base, size), mDump(dump) { mEncMap = new byte[size]; memset(mEncMap, 0, size); } AdvancedAnalysis::~AdvancedAnalysis() { delete[] mEncMap; } void AdvancedAnalysis::Analyse() { linearXrefPass(); findEntryPoints(); analyzeCandidateFunctions(true); findFuzzyEntryPoints(); analyzeCandidateFunctions(true); findInvalidXrefs(); writeDataXrefs(); } void AdvancedAnalysis::SetMarkers() { if(mDump) for(const auto & function : mFunctions) FileHelper::WriteAllText(StringUtils::sprintf("cfgraph_%p.dot", function.entryPoint), function.ToDot()); duint encMapSize; byte* buffer = (byte*)EncodeMapGetBuffer(mBase, &encMapSize, true); memcpy(buffer, mEncMap, encMapSize); EncodeMapReleaseBuffer(buffer); XrefDelRange(mBase, mBase + mSize - 1); for(const auto & vec : mXrefs) { for(const auto & xref : vec.second) { if(xref.valid) XrefAdd(xref.addr, xref.from); } } FunctionClear(); for(const auto & function : mFunctions) { duint start = ~0; duint end = 0; duint icount = 0; for(const auto & node : function.nodes) { icount += node.second.icount; start = min(node.second.start, start); end = max(node.second.end, end); } if(!FunctionAdd(start, end, false, icount)) { FunctionDelete(start); FunctionDelete(end); FunctionAdd(start, end, false, icount); } } GuiUpdateAllViews(); } void AdvancedAnalysis::analyzeFunction(duint entryPoint, bool writedata) { //BFS through the disassembly starting at entryPoint CFGraph graph(entryPoint); UintSet visited; std::queue<duint> queue; mEntryPoints.insert(entryPoint); queue.push(graph.entryPoint); while(!queue.empty()) { auto start = queue.front(); queue.pop(); if(visited.count(start) || !inRange(start)) //already visited or out of range continue; visited.insert(start); CFNode node(graph.entryPoint, start, start); while(true) { node.icount++; if(!mCp.Disassemble(node.end, translateAddr(node.end))) { if(writedata) mEncMap[node.end - mBase] = (byte)enc_byte; // If the next byte would be out of the memory range finish this node if(!inRange(node.end + 1)) { graph.AddNode(node); break; } node.end++; continue; } // If the memory range doesn't fit the entire instruction // mark it as bytes and finish this node if(!inRange(node.end + mCp.Size() - 1)) { duint remainingSize = mBase + mSize - node.end; memset(&mEncMap[node.end - mBase], (byte)enc_byte, remainingSize); graph.AddNode(node); break; } if(writedata) { mEncMap[node.end - mBase] = (byte)enc_code; for(int i = 1; i < mCp.Size(); i++) mEncMap[node.end - mBase + i] = (byte)enc_middle; } if(mCp.IsJump() || mCp.IsLoop()) //jump { //set the branch destinations node.brtrue = mCp.BranchDestination(); if(mCp.GetId() != ZYDIS_MNEMONIC_JMP) //unconditional jumps dont have a brfalse node.brfalse = node.end + mCp.Size(); //add node to the function graph graph.AddNode(node); //enqueue branch destinations if(node.brtrue) queue.push(node.brtrue); if(node.brfalse) queue.push(node.brfalse); break; } if(mCp.IsCall()) //call { //TODO: handle no return duint target = mCp.BranchDestination(); if(inRange(target) && mEntryPoints.find(target) == mEntryPoints.end()) mCandidateEPs.insert(target); } if(mCp.IsRet()) //return { node.terminal = true; graph.AddNode(node); break; } // If this instruction finishes the memory range, end the loop for this entry point if(!inRange(node.end + mCp.Size())) { graph.AddNode(node); break; } node.end += mCp.Size(); } } mFunctions.push_back(graph); } void AdvancedAnalysis::linearXrefPass() { dputs("Starting xref analysis..."); auto ticks = GetTickCount(); for(auto addr = mBase; addr < mBase + mSize;) { if(!mCp.Disassemble(addr, translateAddr(addr))) { addr++; continue; } addr += mCp.Size(); XREF xref; xref.valid = true; xref.addr = 0; xref.from = mCp.Address(); for(auto i = 0; i < mCp.OpCount(); i++) { duint dest = mCp.ResolveOpValue(i, [](ZydisRegister)->size_t { return 0; }); if(inRange(dest)) { xref.addr = dest; break; } } if(xref.addr) { if(mCp.IsCall()) xref.type = XREF_CALL; else if(mCp.IsJump()) xref.type = XREF_JMP; else xref.type = XREF_DATA; auto found = mXrefs.find(xref.addr); if(found == mXrefs.end()) { std::vector<XREF> vec; vec.push_back(xref); mXrefs[xref.addr] = vec; } else { found->second.push_back(xref); } } } dprintf("%d xrefs found in %ums!\n", int(mXrefs.size()), GetTickCount() - ticks); } void AdvancedAnalysis::findInvalidXrefs() { for(auto & vec : mXrefs) { duint jmps = 0, calls = 0; duint addr = vec.first; byte desttype = mEncMap[vec.first - mBase]; for(auto & xref : vec.second) { byte type = mEncMap[xref.from - mBase]; if(desttype == enc_code && type != enc_unknown && type != enc_code) xref.valid = false; else if(desttype == enc_middle) xref.valid = false; } } } bool isFloatInstruction(ZydisMnemonic opcode) { switch(opcode) { case ZYDIS_MNEMONIC_FLD: case ZYDIS_MNEMONIC_FST: case ZYDIS_MNEMONIC_FSTP: case ZYDIS_MNEMONIC_FADD: case ZYDIS_MNEMONIC_FSUB: case ZYDIS_MNEMONIC_FSUBR: case ZYDIS_MNEMONIC_FMUL: case ZYDIS_MNEMONIC_FDIV: case ZYDIS_MNEMONIC_FDIVR: case ZYDIS_MNEMONIC_FCOM: case ZYDIS_MNEMONIC_FCOMP: return true; default: return false; } } void AdvancedAnalysis::writeDataXrefs() { for(auto & vec : mXrefs) { for(auto & xref : vec.second) { if(xref.type == XREF_DATA && xref.valid) { if(!mCp.Disassemble(xref.from, translateAddr(xref.from))) { xref.valid = false; continue; } auto opcode = mCp.GetId(); bool isfloat = isFloatInstruction(opcode); for(auto i = 0; i < mCp.OpCount(); i++) { auto & op = mCp[i]; ENCODETYPE type = enc_unknown; //Todo: Analyze op type and set correct type if(op.type == ZYDIS_OPERAND_TYPE_MEMORY) { duint size = op.size / 8; duint offset = xref.addr - mBase; switch(op.size) { case 8: type = enc_byte; break; case 16: type = enc_word; break; case 32: type = isfloat ? enc_real4 : enc_dword; break; case 48: type = enc_fword; break; case 64: type = isfloat ? enc_real8 : enc_qword; break; case 80: type = isfloat ? enc_real10 : enc_tbyte; break; case 128: type = enc_oword; break; case 256: type = enc_ymmword; break; //case 512: type = enc_zmmword; break; default: __debugbreak(); } if(size == 1) { mEncMap[offset] = (byte)type; } else { // Check if the entire referenced data fits into the memory range if((offset + size) <= mSize) { mEncMap[offset] = (byte)type; memset(mEncMap + offset + 1, (byte)enc_middle, size - 1); } else { // If it doesn't fit, mark the remaining places as bytes duint remainingSize = mSize - offset; memset(mEncMap + offset, (byte)enc_byte, size); } } } } } } } } void AdvancedAnalysis::findFuzzyEntryPoints() { for(const auto & entryPoint : mFuzzyEPs) { mCandidateEPs.insert(entryPoint); } } void AdvancedAnalysis::findEntryPoints() { duint modbase = ModBaseFromAddr(mBase); if(modbase) { apienumexports(modbase, [&](duint Base, const char* Module, const char* Name, duint Address) { // If within limits... if(inRange(Address)) { mCandidateEPs.insert(Address); } }); } for(const auto & vec : mXrefs) { duint jmps = 0, calls = 0; duint addr = vec.first; for(const auto & xref : vec.second) { if(xref.type == XREF_CALL) calls++; else if(xref.type == XREF_JMP) jmps++; } if(calls >= 1 && jmps + calls > 1) mCandidateEPs.insert(addr); else if(calls >= 1) mFuzzyEPs.insert(addr); } } void AdvancedAnalysis::analyzeCandidateFunctions(bool writedata) { std::unordered_set<duint> pendingEPs; while(true) { pendingEPs.clear(); if(mCandidateEPs.size() == 0) return; for(const auto & entryPoint : mCandidateEPs) { pendingEPs.insert(entryPoint); } mCandidateEPs.clear(); for(const auto & entryPoint : pendingEPs) { if(mEntryPoints.find(entryPoint) == mEntryPoints.end()) { analyzeFunction(entryPoint, true); } } } }
C/C++
x64dbg-development/src/dbg/analysis/advancedanalysis.h
#pragma once #include "analysis.h" class AdvancedAnalysis : public Analysis { public: explicit AdvancedAnalysis(duint base, duint size, bool dump = false); ~AdvancedAnalysis(); void Analyse() override; void SetMarkers() override; using UintSet = std::unordered_set<duint>; template<class T> using UintMap = std::unordered_map<duint, T>; struct CFNode { duint parentGraph; //function of which this node is a part duint start; //start of the block duint end; //end of the block (inclusive) duint brtrue; //destination if condition is true duint brfalse; //destination if condition is false duint icount; //number of instructions in node bool terminal; //node is a RET explicit CFNode(duint parentGraph, duint start, duint end) : parentGraph(parentGraph), start(start), end(end), brtrue(0), brfalse(0), icount(0), terminal(false) { } explicit CFNode() : CFNode(0, 0, 0) { } String ToString() const { return StringUtils::sprintf("start: %p\nend: %p\nfunction: %p", start, end, parentGraph); } }; struct CFGraph { duint entryPoint; //graph entry point UintMap<CFNode> nodes; //CFNode.start -> CFNode UintMap<UintSet> parents; //CFNode.start -> parents explicit CFGraph(duint entryPoint) : entryPoint(entryPoint) { } void AddNode(const CFNode & node) { nodes[node.start] = node; AddParent(node.start, node.brtrue); AddParent(node.start, node.brfalse); } void AddParent(duint child, duint parent) { if(!child || !parent) return; auto found = parents.find(child); if(found == parents.end()) { UintSet p; p.insert(parent); parents[child] = p; } else found->second.insert(parent); } const char* GetNodeColor(const CFNode & node) const { if(node.terminal) return "firebrick"; if(node.start == entryPoint) return "forestgreen"; return "lightblue"; } String ToDot() const { String result = "digraph CFGraph {\n"; for(const auto & node : nodes) result += StringUtils::sprintf(" n%p[label=\"%s\" style=filled fillcolor=%s shape=box]\n", node.second.start, node.second.ToString().c_str(), GetNodeColor(node.second)); result += "\n"; for(const auto & node : nodes) { if(node.second.brtrue) result += StringUtils::sprintf(" n%p-> n%p [color=green]\n", node.second.start, node.second.brtrue); if(node.second.brfalse) result += StringUtils::sprintf(" n%p-> n%p [color=red]\n", node.second.start, node.second.brfalse); } result += "\n"; for(const auto & parent : parents) { for(const auto & node : parent.second) result += StringUtils::sprintf(" n%p-> n%p [style=dotted color=grey]\n", node, parent.first); } result += "}"; return result; } }; protected: struct XREF { duint addr; duint from; XREFTYPE type; bool valid; }; std::unordered_set<duint> mEntryPoints; std::unordered_set<duint> mCandidateEPs; std::unordered_set<duint> mFuzzyEPs; std::vector<CFGraph> mFunctions; std::unordered_map<duint, std::vector<XREF>> mXrefs; byte* mEncMap; private: bool mDump; void linearXrefPass(); void findInvalidXrefs(); void writeDataXrefs(); void findFuzzyEntryPoints(); void findEntryPoints(); void analyzeCandidateFunctions(bool writedata); void analyzeFunction(duint entryPoint, bool writedata); };
C++
x64dbg-development/src/dbg/analysis/analysis.cpp
#include "analysis.h" #include "memory.h" #include "debugger.h" Analysis::Analysis(duint base, duint size) { mBase = base; mSize = size; mData = new unsigned char[mSize + MAX_DISASM_BUFFER]; memset(mData, 0xCC, mSize + MAX_DISASM_BUFFER); MemReadDumb(base, mData, size); } Analysis::~Analysis() { delete[] mData; }
C/C++
x64dbg-development/src/dbg/analysis/analysis.h
#ifndef _ANALYSIS_H #define _ANALYSIS_H #include "_global.h" #include <zydis_wrapper.h> class Analysis { public: explicit Analysis(duint base, duint size); Analysis(const Analysis & that) = delete; virtual ~Analysis(); virtual void Analyse() = 0; virtual void SetMarkers() = 0; protected: duint mBase; duint mSize; unsigned char* mData; Zydis mCp; bool inRange(duint addr) const { return addr >= mBase && addr < mBase + mSize; } const unsigned char* translateAddr(duint addr) const { return inRange(addr) ? mData + (addr - mBase) : nullptr; } }; #endif //_ANALYSIS_H
C++
x64dbg-development/src/dbg/analysis/AnalysisPass.cpp
#include <assert.h> #include <thread> #include "AnalysisPass.h" #include "memory.h" AnalysisPass::AnalysisPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks) : m_MainBlocks(MainBlocks) { assert(VirtualEnd > VirtualStart); // Internal class data m_VirtualStart = VirtualStart; m_VirtualEnd = VirtualEnd; m_InternalMaxThreads = 0; // Read remote instruction data to local memory m_DataSize = VirtualEnd - VirtualStart; m_Data = (unsigned char*)VirtualAlloc(nullptr, m_DataSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); if(!MemRead(VirtualStart, m_Data, m_DataSize)) { VirtualFree(m_Data, 0, MEM_RELEASE); assert(false); } } AnalysisPass::~AnalysisPass() { if(m_Data) VirtualFree(m_Data, 0, MEM_RELEASE); } BasicBlock* AnalysisPass::FindBBlockInRange(duint Address) { // NOTE: __MUST__ BE A SORTED VECTOR // // Use a binary search duint indexLo = 0; duint indexHi = m_MainBlocks.size(); // Get a pointer to pure data const auto blocks = m_MainBlocks.data(); while(indexHi > indexLo) { duint indexMid = (indexLo + indexHi) / 2; auto entry = &blocks[indexMid]; if(Address < entry->VirtualStart) { // Continue search in lower half indexHi = indexMid; } else if(Address >= entry->VirtualEnd) { // Continue search in upper half indexLo = indexMid + 1; } else { // Address is within limits, return entry return entry; } } // Not found return nullptr; } duint AnalysisPass::FindBBlockIndex(BasicBlock* Block) { // Fast pointer arithmetic to find index return ((duint)Block - (duint)m_MainBlocks.data()) / sizeof(BasicBlock); } duint AnalysisPass::IdealThreadCount() { if(m_InternalMaxThreads == 0) { // Determine the maximum hardware thread count at once duint maximumThreads = max(std::thread::hardware_concurrency(), 1); // Don't consume 100% of the CPU, adjust accordingly if(maximumThreads > 1) maximumThreads -= 1; SetIdealThreadCount(maximumThreads); } return m_InternalMaxThreads; } void AnalysisPass::SetIdealThreadCount(duint Count) { m_InternalMaxThreads = (BYTE)min(Count, 255); }
C/C++
x64dbg-development/src/dbg/analysis/AnalysisPass.h
#pragma once #include "_global.h" #include "BasicBlock.h" class AnalysisPass { public: AnalysisPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks); virtual ~AnalysisPass(); virtual const char* GetName() = 0; virtual bool Analyse() = 0; protected: duint m_VirtualStart; duint m_VirtualEnd; duint m_DataSize; unsigned char* m_Data; BBlockArray & m_MainBlocks; unsigned char* TranslateAddress(duint Address) { ASSERT_TRUE(ValidateAddress(Address)); return &m_Data[Address - m_VirtualStart]; } bool ValidateAddress(duint Address) { return (Address >= m_VirtualStart && Address < m_VirtualEnd); } BasicBlock* FindBBlockInRange(duint Address); duint FindBBlockIndex(BasicBlock* Block); duint IdealThreadCount(); void SetIdealThreadCount(duint Count); private: BYTE m_InternalMaxThreads; };
C++
x64dbg-development/src/dbg/analysis/analysis_nukem.cpp
#include "analysis_nukem.h" #include "BasicBlock.h" #include "LinearPass.h" #include "FunctionPass.h" #include "console.h" void Analyse_nukem(duint base, duint size) { dputs("Starting analysis (Nukem)..."); DWORD ticks = GetTickCount(); duint end = base + size; BBlockArray blocks; LinearPass pass1(base, end, blocks); pass1.Analyse(); FunctionPass pass2(base, end, blocks); pass2.Analyse(); dprintf("Analysis finished in %ums!\n", GetTickCount() - ticks); }
C/C++
x64dbg-development/src/dbg/analysis/BasicBlock.h
#pragma once #include "_global.h" enum BasicBlockFlags : duint { BASIC_BLOCK_FLAG_NONE = 0, // No flag BASIC_BLOCK_FLAG_FUNCTION = (1 << 1), // Scanned; also part of a known function BASIC_BLOCK_FLAG_CUTOFF = (1 << 3), // Ends prematurely because of another JMP to location BASIC_BLOCK_FLAG_DELETE = (1 << 4), // Delete element at the next possible time BASIC_BLOCK_FLAG_CALL = (1 << 5), // The block ends with a call BASIC_BLOCK_FLAG_RET = (1 << 6), // The block ends with a retn BASIC_BLOCK_FLAG_ABSJMP = (1 << 7), // Branch is absolute BASIC_BLOCK_FLAG_INDIRECT = (1 << 8), // This block ends with an indirect branch; memory or register BASIC_BLOCK_FLAG_INDIRPTR = (1 << 9), // This block ends with an indirect branch; pointer known BASIC_BLOCK_FLAG_CALL_TARGET = (1 << 10), // Block is pointed to by a call instruction //BASIC_BLOCK_FLAG_JMP_TARGET = (1 << 11), BASIC_BLOCK_FLAG_PREPAD = (1 << 12), // Block ends because there was padding afterwards BASIC_BLOCK_FLAG_PAD = (1 << 13), // Block is only a series of padding instructions }; struct BasicBlock { duint VirtualStart; // Inclusive duint VirtualEnd; // Inclusive duint Flags; duint Target; duint InstrCount; // Number of instructions in block __forceinline bool GetFlag(duint Flag) { return (Flags & Flag) == Flag; } __forceinline void SetFlag(duint Flag) { Flags |= Flag; } __forceinline duint Size() { return VirtualEnd - VirtualStart; } bool operator< (const BasicBlock & b) const { return VirtualStart < b.VirtualStart; } bool operator== (const BasicBlock & b) const { return VirtualStart == b.VirtualStart; } }; struct FunctionDef { duint VirtualStart; // Inclusive duint VirtualEnd; // Inclusive duint BBlockStart; // Index of first basic block duint BBlockEnd; // Index of last basic block duint InstrCount; // Number of instructions in function bool operator< (const FunctionDef & b) const { if(VirtualStart == b.VirtualStart) return VirtualEnd > b.VirtualEnd; return VirtualStart < b.VirtualStart; } bool operator== (const FunctionDef & b) const { return VirtualStart == b.VirtualStart; } }; typedef std::vector<BasicBlock> BBlockArray; typedef std::vector<FunctionDef> FuncDefArray;
C++
x64dbg-development/src/dbg/analysis/CodeFollowPass.cpp
#include "AnalysisPass.h" #include "CodeFollowPass.h" CodeFollowPass::CodeFollowPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks) : AnalysisPass(VirtualStart, VirtualEnd, MainBlocks) { } CodeFollowPass::~CodeFollowPass() { } const char* CodeFollowPass::GetName() { return "Code Follower"; } bool CodeFollowPass::Analyse() { // First gather all possible function references with certain tables // // This includes: // Main entry // Module exports // Module import references (?) // Control flow guard // RUNTIME_FUNCTION // TLS callbacks // FLS callbacks return false; } duint CodeFollowPass::GetReferenceOperand(const ZydisDecodedInstruction & Context) { for(int i = 0; i < Context.operandCount; i++) { auto operand = Context.operands[i]; // Looking for immediate references if(operand.type == ZYDIS_OPERAND_TYPE_IMMEDIATE) { duint dest = (duint)operand.imm.value.u; if(ValidateAddress(dest)) return dest; } } return 0; } duint CodeFollowPass::GetMemoryOperand(Zydis & Disasm, const ZydisDecodedInstruction & Context, bool* Indirect) { if(Context.operandCount <= 0) return 0; // Only the first operand matters auto operand = Context.operands[0]; // Jumps and calls only if(Disasm.IsCall() || Disasm.IsJump()) { // Looking for memory references if(operand.type == ZYDIS_OPERAND_TYPE_MEMORY) { // Notify if the operand was indirect if(Indirect) { if(operand.mem.base != ZYDIS_REGISTER_NONE || operand.mem.index != ZYDIS_REGISTER_NONE || operand.mem.scale != 0) { *Indirect = true; return 0; } } // TODO: Read pointer // TODO: Find virtual tables (new pass?) // TODO: Translate RIP-Relative return 0; duint dest = (duint)operand.mem.disp.value; if(ValidateAddress(dest)) return dest; } } return 0; }
C/C++
x64dbg-development/src/dbg/analysis/CodeFollowPass.h
#pragma once #include "AnalysisPass.h" #include "BasicBlock.h" #include <zydis_wrapper.h> class CodeFollowPass : public AnalysisPass { public: CodeFollowPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks); virtual ~CodeFollowPass(); virtual const char* GetName() override; virtual bool Analyse() override; private: duint GetReferenceOperand(const ZydisDecodedInstruction & Context); duint GetMemoryOperand(Zydis & Disasm, const ZydisDecodedInstruction & Context, bool* Indirect); };
C++
x64dbg-development/src/dbg/analysis/controlflowanalysis.cpp
#include "controlflowanalysis.h" #include "console.h" #include "module.h" #include "TitanEngine/TitanEngine.h" #include "memory.h" #include "function.h" ControlFlowAnalysis::ControlFlowAnalysis(duint base, duint size, bool exceptionDirectory) : Analysis(base, size), mFunctionInfoSize(0), mFunctionInfoData(nullptr) { #ifdef _WIN64 // This will only be valid if the address range is within a loaded module mModuleBase = ModBaseFromAddr(base); if(exceptionDirectory && mModuleBase != 0) { char modulePath[MAX_PATH]; memset(modulePath, 0, sizeof(modulePath)); ModPathFromAddr(mModuleBase, modulePath, ARRAYSIZE(modulePath)); HANDLE fileHandle; DWORD fileSize; HANDLE fileMapHandle; ULONG_PTR fileMapVa; if(StaticFileLoadW( StringUtils::Utf8ToUtf16(modulePath).c_str(), UE_ACCESS_READ, false, &fileHandle, &fileSize, &fileMapHandle, &fileMapVa)) { // Find a pointer to IMAGE_DIRECTORY_ENTRY_EXCEPTION for later use auto virtualOffset = GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALOFFSET); mFunctionInfoSize = duint(GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALSIZE)); // Unload the file StaticFileUnloadW(nullptr, false, fileHandle, fileSize, fileMapHandle, fileMapVa); // Get a copy of the function table if(virtualOffset) { // Read the table into a buffer mFunctionInfoData = emalloc(mFunctionInfoSize); if(mFunctionInfoData) MemRead(virtualOffset + mModuleBase, mFunctionInfoData, mFunctionInfoSize); } } } #endif //_WIN64 } ControlFlowAnalysis::~ControlFlowAnalysis() { if(mFunctionInfoData) efree(mFunctionInfoData); } void ControlFlowAnalysis::Analyse() { dputs("Starting analysis..."); auto ticks = GetTickCount(); BasicBlockStarts(); dprintf("Basic block starts in %ums!\n", GetTickCount() - ticks); ticks = GetTickCount(); BasicBlocks(); dprintf("Basic blocks in %ums!\n", GetTickCount() - ticks); ticks = GetTickCount(); Functions(); dprintf("Functions in %ums!\n", GetTickCount() - ticks); ticks = GetTickCount(); FunctionRanges(); dprintf("Function ranges in %ums!\n", GetTickCount() - ticks); dprintf("Analysis finished!\n"); } void ControlFlowAnalysis::SetMarkers() { FunctionDelRange(mBase, mBase + mSize - 1, false); auto size = mFunctionRanges.size(); for(auto i = size - 1; i != -1; i--) { const auto & range = mFunctionRanges[i]; FunctionAdd(range.first, range.second, false); } /*dprintf("digraph ControlFlow {\n"); int i = 0; std::map<duint, int> nodeMap; for(const auto & it : mBlocks) { const auto & block = it.second; nodeMap.insert({ block.start, i }); dprintf(" node%u [label=\"s=%p, e=%p, f=%p\"];\n", i, block.start, block.end, block.function); i++; } for(auto it : mBlocks) { const auto & block = it.second; int startNode = nodeMap[block.start]; if(block.left) { if(nodeMap.count(block.left)) dprintf(" node%u -> node%u;\n", startNode, nodeMap[block.left]); } else { dprintf(" node%u [shape=point];\n", i); dprintf(" node%u -> node%u;\n", startNode, i); i++; } if(block.right) { if(nodeMap.count(block.right)) dprintf(" node%u -> node%u;\n", startNode, nodeMap[block.right]); } else { dprintf(" node%u [shape=point];\n", i); dprintf(" node%u -> node%u;\n", startNode, i); i++; } } dprintf("}\n");*/ } void ControlFlowAnalysis::BasicBlockStarts() { mBlockStarts.insert(mBase); auto bSkipFilling = false; for(duint i = 0; i < mSize;) { auto addr = mBase + i; if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER)) { if(bSkipFilling) //handle filling skip mode { if(!mCp.IsFilling()) //do nothing until the filling stopped { bSkipFilling = false; mBlockStarts.insert(addr); } } else if(mCp.IsRet()) //RET breaks control flow { bSkipFilling = true; //skip INT3/NOP/whatever filling bytes (those are not part of the control flow) } else if(mCp.IsJump() || mCp.IsLoop()) //branches { auto dest1 = getReferenceOperand(); duint dest2 = 0; if(mCp.GetId() != ZYDIS_MNEMONIC_JMP) //conditional jump dest2 = addr + mCp.Size(); if(!dest1 && !dest2) //TODO: better code for this (make sure absolutely no filling is inserted) bSkipFilling = true; if(dest1) mBlockStarts.insert(dest1); if(dest2) mBlockStarts.insert(dest2); } else if(mCp.IsCall()) { auto dest1 = getReferenceOperand(); if(dest1) { mBlockStarts.insert(dest1); mFunctionStarts.insert(dest1); } } else { auto dest1 = getReferenceOperand(); if(dest1) mBlockStarts.insert(dest1); } i += mCp.Size(); } else i++; } } void ControlFlowAnalysis::BasicBlocks() { for(auto i = mBlockStarts.begin(); i != mBlockStarts.end(); ++i) { auto start = *i; if(!inRange(start)) continue; auto nextStart = mBase + mSize; auto next = std::next(i); if(next != mBlockStarts.end()) nextStart = *next; for(duint addr = start, prevaddr; addr < mBase + mSize;) { prevaddr = addr; if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER)) { if(mCp.IsRet()) { insertBlock(BasicBlock(start, addr, 0, 0)); //leaf block break; } else if(mCp.IsJump() || mCp.IsLoop()) { auto dest1 = getReferenceOperand(); auto dest2 = mCp.GetId() != ZYDIS_MNEMONIC_JMP ? addr + mCp.Size() : 0; insertBlock(BasicBlock(start, addr, dest1, dest2)); insertParent(dest1, start); insertParent(dest2, start); break; } addr += mCp.Size(); } else addr++; if(addr == nextStart) //special case handling overlapping blocks { insertBlock(BasicBlock(start, prevaddr, 0, nextStart)); insertParent(nextStart, start); break; } } } mBlockStarts.clear(); #ifdef _WIN64 auto count = 0; enumerateFunctionRuntimeEntries64([&](PRUNTIME_FUNCTION Function) { auto funcAddr = mModuleBase + Function->BeginAddress; auto funcEnd = mModuleBase + Function->EndAddress; // If within limits... if(inRange(funcAddr) && inRange(funcEnd)) mFunctionStarts.insert(funcAddr); count++; return true; }); dprintf("%d functions from the exception directory...\n", count); #endif // _WIN64 dprintf("%d basic blocks, %d function starts detected...\n", int(mBlocks.size()), int(mFunctionStarts.size())); } void ControlFlowAnalysis::Functions() { typedef std::pair<BasicBlock*, const UintSet*> DelayedBlock; std::vector<DelayedBlock> delayedBlocks; for(auto & it : mBlocks) { auto block = &it.second; auto parents = findParents(block->start); if(!block->function) { if(!parents || mFunctionStarts.count(block->start)) //no parents = function start { auto functionStart = block->start; block->function = functionStart; UintSet functionBlocks; functionBlocks.insert(functionStart); mFunctions[functionStart] = functionBlocks; } else //in function { auto function = findFunctionStart(block, parents); if(!function) //this happens with loops / unreferenced blocks sometimes delayedBlocks.push_back(DelayedBlock(block, parents)); else block->function = function; } } else DebugBreak(); //this should not happen } auto delayedCount = int(delayedBlocks.size()); dprintf("%d/%d delayed blocks...\n", delayedCount, int(mBlocks.size())); auto resolved = 0; for(auto & delayedBlock : delayedBlocks) { auto block = delayedBlock.first; auto parents = delayedBlock.second; auto function = findFunctionStart(block, parents); if(!function) { continue; /*dprintf("unresolved block %s\n", blockToString(block).c_str()); if(parents) { dprintf("parents:\n"); for(auto parent : *parents) dprintf(" %s\n", blockToString(findBlock(parent)).c_str()); } else dprintf("parents: null"); dprintf("left: %s\n", blockToString(findBlock(block->left)).c_str()); dprintf("right: %s\n", blockToString(findBlock(block->right)).c_str()); return;*/ } block->function = function; resolved++; } dprintf("%d/%d delayed blocks resolved (%d/%d still left, probably unreferenced functions)\n", resolved, delayedCount, delayedCount - resolved, int(mBlocks.size())); auto unreferencedCount = 0; for(const auto & block : mBlocks) { auto found = mFunctions.find(block.second.function); if(found == mFunctions.end()) //unreferenced block { unreferencedCount++; continue; } found->second.insert(block.second.start); } dprintf("%d/%u unreferenced blocks\n", unreferencedCount, DWORD(mBlocks.size())); dprintf("%u functions found!\n", DWORD(mFunctions.size())); } void ControlFlowAnalysis::FunctionRanges() { //iterate over the functions and then find the deepest block = function end for(const auto & function : mFunctions) { auto start = function.first; auto end = start; for(auto blockstart : function.second) { auto block = findBlock(blockstart); if(!block) __debugbreak(); //this shouldn't happen if(block->end > end) end = block->end; } mFunctionRanges.push_back({ start, end }); } } void ControlFlowAnalysis::insertBlock(const BasicBlock & block) { if(mBlocks.find(block.start) != mBlocks.end()) DebugBreak(); mBlocks[block.start] = block; } const ControlFlowAnalysis::BasicBlock* ControlFlowAnalysis::findBlock(duint start) const { if(!start) return nullptr; auto found = mBlocks.find(start); return found != mBlocks.end() ? &found->second : nullptr; } void ControlFlowAnalysis::insertParent(duint child, duint parent) { if(!child || !parent) return; auto found = mParentMap.find(child); if(found == mParentMap.end()) { UintSet parents; parents.insert(parent); mParentMap[child] = parents; } else found->second.insert(parent); } const ControlFlowAnalysis::UintSet* ControlFlowAnalysis::findParents(duint child) const { if(!child) return nullptr; auto found = mParentMap.find(child); return found != mParentMap.end() ? &found->second : nullptr; } duint ControlFlowAnalysis::findFunctionStart(const BasicBlock* block, const UintSet* parents) const { if(!block) return 0; if(block->function) return block->function; auto left = findBlock(block->left); if(left && left->function) return left->function; auto right = findBlock(block->right); if(right && right->function) return right->function; for(auto start : *parents) { auto parent = findBlock(start); if(parent->function) return parent->function; } return 0; } String ControlFlowAnalysis::blockToString(const BasicBlock* block) { if(!block) return String("null"); return block->toString(); } duint ControlFlowAnalysis::getReferenceOperand() const { for(auto i = 0; i < mCp.OpCount(); i++) { const auto & op = mCp[i]; if(op.type == ZYDIS_OPERAND_TYPE_IMMEDIATE) { auto dest = duint(op.imm.value.u); if(inRange(dest)) return dest; } else if(op.type == ZYDIS_OPERAND_TYPE_MEMORY) { auto dest = duint(op.mem.disp.value); if(op.mem.base == ZYDIS_REGISTER_RIP) //rip-relative dest += mCp.Address() + mCp.Size(); if(inRange(dest)) return dest; } } return 0; } #ifdef _WIN64 void ControlFlowAnalysis::enumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const { if(!mFunctionInfoData) return; // Get the table pointer and size auto functionTable = PRUNTIME_FUNCTION(mFunctionInfoData); auto totalCount = mFunctionInfoSize / sizeof(RUNTIME_FUNCTION); // Enumerate each entry for(duint i = 0; i < totalCount; i++) { if(!Callback(&functionTable[i])) break; } } #endif // _WIN64
C/C++
x64dbg-development/src/dbg/analysis/controlflowanalysis.h
#ifndef _CONTROLFLOWANALYSIS_H #define _CONTROLFLOWANALYSIS_H #include "_global.h" #include "analysis.h" #include "addrinfo.h" #include <functional> class ControlFlowAnalysis : public Analysis { public: explicit ControlFlowAnalysis(duint base, duint size, bool exceptionDirectory); ~ControlFlowAnalysis(); void Analyse() override; void SetMarkers() override; private: struct BasicBlock { duint start; duint end; duint left; duint right; duint function; BasicBlock() : BasicBlock(0, 0, 0, 0) { } BasicBlock(duint start, duint end, duint left, duint right) : start(start), end(end), left(min(left, right)), right(min(left, right)), function(0) { } String toString() const { return StringUtils::sprintf("start:%p,end:%p,left:%p,right:%p,func:%p", start, end, left, right, function); } }; typedef std::unordered_set<duint> UintSet; duint mModuleBase; duint mFunctionInfoSize; void* mFunctionInfoData; UintSet mBlockStarts; UintSet mFunctionStarts; std::unordered_map<duint, BasicBlock> mBlocks; //start of block -> block std::unordered_map<duint, UintSet> mParentMap; //start child -> parents std::unordered_map<duint, UintSet> mFunctions; //function start -> function block starts std::vector<Range> mFunctionRanges; //function start -> function range TODO: smarter stuff with overlapping ranges void BasicBlockStarts(); void BasicBlocks(); void Functions(); void FunctionRanges(); void insertBlock(const BasicBlock & block); const BasicBlock* findBlock(duint start) const; void insertParent(duint child, duint parent); const UintSet* findParents(duint child) const; duint findFunctionStart(const BasicBlock* block, const UintSet* parents) const; static String blockToString(const BasicBlock* block); duint getReferenceOperand() const; #ifdef _WIN64 void enumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const; #endif // _WIN64 }; #endif //_CONTROLFLOWANALYSIS_H
C++
x64dbg-development/src/dbg/analysis/exceptiondirectoryanalysis.cpp
#include "exceptiondirectoryanalysis.h" #include "module.h" #include "TitanEngine/TitanEngine.h" #include "memory.h" #include "console.h" #include "function.h" ExceptionDirectoryAnalysis::ExceptionDirectoryAnalysis(duint base, duint size) : Analysis(base, size), mFunctionInfoSize(0), mFunctionInfoData(nullptr) { #ifdef _WIN64 // This will only be valid if the address range is within a loaded module mModuleBase = ModBaseFromAddr(base); if(mModuleBase != 0) { char modulePath[MAX_PATH]; memset(modulePath, 0, sizeof(modulePath)); ModPathFromAddr(mModuleBase, modulePath, ARRAYSIZE(modulePath)); HANDLE fileHandle; DWORD fileSize; HANDLE fileMapHandle; ULONG_PTR fileMapVa; if(StaticFileLoadW( StringUtils::Utf8ToUtf16(modulePath).c_str(), UE_ACCESS_READ, false, &fileHandle, &fileSize, &fileMapHandle, &fileMapVa)) { // Find a pointer to IMAGE_DIRECTORY_ENTRY_EXCEPTION for later use auto virtualOffset = GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALOFFSET); mFunctionInfoSize = duint(GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALSIZE)); // Unload the file StaticFileUnloadW(nullptr, false, fileHandle, fileSize, fileMapHandle, fileMapVa); // Get a copy of the function table if(virtualOffset) { // Read the table into a buffer mFunctionInfoData = emalloc(mFunctionInfoSize); if(mFunctionInfoData) MemRead(virtualOffset + mModuleBase, mFunctionInfoData, mFunctionInfoSize); } } } #endif //_WIN64 } ExceptionDirectoryAnalysis::~ExceptionDirectoryAnalysis() { if(mFunctionInfoData) efree(mFunctionInfoData); } void ExceptionDirectoryAnalysis::Analyse() { #ifdef _WIN64 EnumerateFunctionRuntimeEntries64([&](PRUNTIME_FUNCTION Function) { auto funcAddr = mModuleBase + Function->BeginAddress; auto funcEnd = mModuleBase + Function->EndAddress - 1; // If within limits... if(inRange(funcAddr) && inRange(funcEnd) && funcAddr <= funcEnd) mFunctions.push_back({ funcAddr, funcEnd }); return true; }); dprintf(QT_TRANSLATE_NOOP("DBG", "%u functions discovered!\n"), DWORD(mFunctions.size())); #else //x32 dputs(QT_TRANSLATE_NOOP("DBG", "This kind of analysis doesn't work on x32 executables...\n")); #endif // _WIN64 } void ExceptionDirectoryAnalysis::SetMarkers() { FunctionDelRange(mBase, mBase + mSize - 1, false); for(const auto & function : mFunctions) FunctionAdd(function.first, function.second, false); } #ifdef _WIN64 void ExceptionDirectoryAnalysis::EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const { if(!mFunctionInfoData) return; // Get the table pointer and size auto functionTable = PRUNTIME_FUNCTION(mFunctionInfoData); auto totalCount = mFunctionInfoSize / sizeof(RUNTIME_FUNCTION); // Enumerate each entry for(duint i = 0; i < totalCount; i++) { if(!Callback(&functionTable[i])) break; } } #endif // _WIN64
C/C++
x64dbg-development/src/dbg/analysis/exceptiondirectoryanalysis.h
#ifndef _EXCEPTIONDIRECTORYANALYSIS_H #define _EXCEPTIONDIRECTORYANALYSIS_H #include "analysis.h" #include <functional> class ExceptionDirectoryAnalysis : public Analysis { public: explicit ExceptionDirectoryAnalysis(duint base, duint size); ~ExceptionDirectoryAnalysis(); void Analyse() override; void SetMarkers() override; private: duint mModuleBase; duint mFunctionInfoSize; void* mFunctionInfoData; std::vector<std::pair<duint, duint>> mFunctions; #ifdef _WIN64 void EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const; #endif // _WIN64 }; #endif //_EXCEPTIONDIRECTORYANALYSIS_H
C++
x64dbg-development/src/dbg/analysis/FunctionPass.cpp
#include "FunctionPass.h" #include <ppl.h> #include "memory.h" #include "console.h" #include "debugger.h" #include "module.h" #include "function.h" FunctionPass::FunctionPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks) : AnalysisPass(VirtualStart, VirtualEnd, MainBlocks) { // Zero values m_FunctionInfo = nullptr; m_FunctionInfoSize = 0; // This will only be valid if the address range is within a loaded module m_ModuleStart = ModBaseFromAddr(VirtualStart); if(m_ModuleStart != 0) { char modulePath[MAX_PATH]; memset(modulePath, 0, sizeof(modulePath)); ModPathFromAddr(m_ModuleStart, modulePath, ARRAYSIZE(modulePath)); HANDLE fileHandle; DWORD fileSize; HANDLE fileMapHandle; ULONG_PTR fileMapVa; if(StaticFileLoadW( StringUtils::Utf8ToUtf16(modulePath).c_str(), UE_ACCESS_READ, false, &fileHandle, &fileSize, &fileMapHandle, &fileMapVa)) { // Find a pointer to IMAGE_DIRECTORY_ENTRY_EXCEPTION for later use ULONG_PTR virtualOffset = GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALOFFSET); m_FunctionInfoSize = (ULONG)GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALSIZE); // Unload the file StaticFileUnloadW(nullptr, false, fileHandle, fileSize, fileMapHandle, fileMapVa); // Get a copy of the function table if(virtualOffset) { // Read the table into a buffer m_FunctionInfo = BridgeAlloc(m_FunctionInfoSize); if(m_FunctionInfo) MemRead(virtualOffset + m_ModuleStart, m_FunctionInfo, m_FunctionInfoSize); } } } } FunctionPass::~FunctionPass() { if(m_FunctionInfo) BridgeFree(m_FunctionInfo); } const char* FunctionPass::GetName() { return "Function Analysis"; } bool FunctionPass::Analyse() { // THREAD_WORK = ceil(TOTAL / # THREADS) duint workAmount = (m_MainBlocks.size() + (IdealThreadCount() - 1)) / IdealThreadCount(); // Initialize thread vector auto threadFunctions = new std::vector<FunctionDef>[IdealThreadCount()]; concurrency::parallel_for(duint(0), IdealThreadCount(), [&](duint i) { // Memory allocation optimization // TODO: Option to conserve memory threadFunctions[i].reserve(30000); // Execute duint threadWorkStart = (workAmount * i); duint threadWorkStop = min((threadWorkStart + workAmount), m_MainBlocks.size()); AnalysisWorker(threadWorkStart, threadWorkStop, &threadFunctions[i]); }); // Merge thread vectors into single local std::vector<FunctionDef> funcs; for(duint i = 0; i < IdealThreadCount(); i++) std::move(threadFunctions[i].begin(), threadFunctions[i].end(), std::back_inserter(funcs)); // Sort and remove duplicates std::sort(funcs.begin(), funcs.end()); funcs.erase(std::unique(funcs.begin(), funcs.end()), funcs.end()); dprintf(QT_TRANSLATE_NOOP("DBG", "%u functions\n"), DWORD(funcs.size())); FunctionDelRange(m_VirtualStart, m_VirtualEnd - 1, false); for(auto & func : funcs) { FunctionAdd(func.VirtualStart, func.VirtualEnd, false, func.InstrCount); } GuiUpdateAllViews(); delete[] threadFunctions; return true; } void FunctionPass::AnalysisWorker(duint Start, duint End, std::vector<FunctionDef>* Blocks) { // // Step 1: Use any defined functions in the PE function table // FindFunctionWorkerPrepass(Start, End, Blocks); // // Step 2: for each block that contains a CALL flag, // add it to a local function start array // // NOTE: *Some* indirect calls are included auto blockItr = std::next(m_MainBlocks.begin(), Start); for(duint i = Start; i < End; i++, ++blockItr) { if(blockItr->GetFlag(BASIC_BLOCK_FLAG_CALL)) { duint destination = blockItr->Target; // Was it a pointer? if(blockItr->GetFlag(BASIC_BLOCK_FLAG_INDIRPTR)) { // Read it from memory if(!MemRead(destination, &destination, sizeof(duint))) continue; // Validity check if(!MemIsValidReadPtr(destination)) continue; dprintf(QT_TRANSLATE_NOOP("DBG", "Indirect pointer: 0x%p 0x%p\n"), blockItr->Target, destination); } // Destination must be within analysis limits if(!ValidateAddress(destination)) continue; Blocks->push_back({ destination, 0, 0, 0, 0 }); } } // // Step 3: Sort and remove duplicates // std::sort(Blocks->begin(), Blocks->end()); Blocks->erase(std::unique(Blocks->begin(), Blocks->end()), Blocks->end()); // // Step 4: Find function ends // FindFunctionWorker(Blocks); // // Step 5: Find all orphaned blocks and repeat analysis process // // Starting from the first global block, scan until an "untouched" block is found blockItr = std::next(m_MainBlocks.begin(), Start); // Cached final block BasicBlock* finalBlock = &m_MainBlocks.back(); duint virtEnd = 0; for(duint i = Start; i < End; i++, ++blockItr) { if(blockItr->VirtualStart < virtEnd) continue; // Skip padding if(blockItr->GetFlag(BASIC_BLOCK_FLAG_PAD)) continue; // Is the block untouched? if(blockItr->GetFlag(BASIC_BLOCK_FLAG_FUNCTION)) continue; // Try to define a function FunctionDef def { blockItr->VirtualStart, 0, 0, 0, 0 }; if(ResolveFunctionEnd(&def, finalBlock)) { Blocks->push_back(def); virtEnd = def.VirtualEnd; } } } void FunctionPass::FindFunctionWorkerPrepass(duint Start, duint End, std::vector<FunctionDef>* Blocks) { return; const duint minFunc = std::next(m_MainBlocks.begin(), Start)->VirtualStart; const duint maxFunc = std::next(m_MainBlocks.begin(), End - 1)->VirtualEnd; #ifdef _WIN64 // RUNTIME_FUNCTION exception information EnumerateFunctionRuntimeEntries64([&](PRUNTIME_FUNCTION Function) { const duint funcAddr = m_ModuleStart + Function->BeginAddress; const duint funcEnd = m_ModuleStart + Function->EndAddress; // If within limits... if(funcAddr >= minFunc && funcAddr < maxFunc) { // Add the descriptor (virtual start/end) Blocks->push_back({ funcAddr, funcEnd, 0, 0, 0 }); } return true; }); #endif // _WIN64 // Module exports (return value ignored) apienumexports(m_ModuleStart, [&](duint Base, const char* Module, const char* Name, duint Address) { // If within limits... if(Address >= minFunc && Address < maxFunc) { // Add the descriptor (virtual start) Blocks->push_back({ Address, 0, 0, 0, 0 }); } }); } void FunctionPass::FindFunctionWorker(std::vector<FunctionDef>* Blocks) { // Cached final block BasicBlock* finalBlock = &m_MainBlocks.back(); // Enumerate all function entries for this thread for(auto & block : *Blocks) { // Sometimes the ending address is already supplied, so check first if(block.VirtualEnd != 0) { if(ResolveKnownFunctionEnd(&block)) continue; } // Now the function end must be determined by heuristics (find manually) ResolveFunctionEnd(&block, finalBlock); } } bool FunctionPass::ResolveKnownFunctionEnd(FunctionDef* Function) { // Helper to link final blocks to function auto startBlock = FindBBlockInRange(Function->VirtualStart); auto endBlock = FindBBlockInRange(Function->VirtualEnd); if(!startBlock || !endBlock) return false; // Find block start/end indices Function->BBlockStart = FindBBlockIndex(startBlock); Function->BBlockEnd = FindBBlockIndex(endBlock); // Set the flag for blocks that have been scanned for(BasicBlock* block = startBlock; (duint)block <= (duint)endBlock; block++) { // Block now in use block->SetFlag(BASIC_BLOCK_FLAG_FUNCTION); // Counter Function->InstrCount += block->InstrCount; } return true; } bool FunctionPass::ResolveFunctionEnd(FunctionDef* Function, BasicBlock* LastBlock) { ASSERT_TRUE(Function->VirtualStart != 0); // Find the first basic block of the function BasicBlock* block = FindBBlockInRange(Function->VirtualStart); if(!block) { ASSERT_ALWAYS("Block should exist at this point"); return false; } // The maximum address is determined by any jump that extends past // a RET or other terminating basic block. A function may have multiple // return statements. duint maximumAddr = 0; // Loop forever until the end is found for(; (duint)block <= (duint)LastBlock; block++) { if(block->GetFlag(BASIC_BLOCK_FLAG_CALL_TARGET) && block->VirtualStart != Function->VirtualStart) { block--; break; } // Block is now in use block->SetFlag(BASIC_BLOCK_FLAG_FUNCTION); // Increment instruction count Function->InstrCount += block->InstrCount; // Calculate max from just linear instructions maximumAddr = max(maximumAddr, block->VirtualEnd); // Find maximum jump target if(!block->GetFlag(BASIC_BLOCK_FLAG_CALL) && !block->GetFlag(BASIC_BLOCK_FLAG_INDIRECT)) { if(block->Target != 0 && block->Target >= maximumAddr) { // Here's a problem: Compilers add tail-call elimination with a jump. // Solve this by creating a maximum jump limit. auto targetBlock = FindBBlockInRange(block->Target); // If (target block found) and (target block is not called) if(targetBlock && !targetBlock->GetFlag(BASIC_BLOCK_FLAG_CALL_TARGET)) { duint blockEnd = targetBlock->VirtualEnd; // // Edge case when a compiler emits: // // pop ebp // jmp some_func // int3 // int3 // some_func: // push ebp // // Where INT3 will align "some_func" to 4, 8, 12, or 16. // INT3 padding is also optional (if the jump fits perfectly). // if(true/*block->GetFlag(BASIC_BLOCK_FLAG_ABSJMP)*/) { { // Check if padding is aligned to 4 auto nextBlock = block + 1; if((duint)nextBlock <= (duint)LastBlock) { if(nextBlock->GetFlag(BASIC_BLOCK_FLAG_PAD)) { // If this block is aligned to 4 bytes at the end if((nextBlock->VirtualEnd + 1) % 4 == 0) blockEnd = block->VirtualEnd; } } } } // Now calculate the maximum end address, taking into account the jump destination maximumAddr = max(maximumAddr, blockEnd); } } } // Coherence check ASSERT_TRUE(maximumAddr >= block->VirtualStart); // Does this node contain the maximum address? if(maximumAddr >= block->VirtualStart && maximumAddr <= block->VirtualEnd) { // It does! There's 4 possibilities next: // // 1. Return // 2. Tail-call elimination // 3. Optimized loop // 4. Function continues to next block // // 1. if(block->GetFlag(BASIC_BLOCK_FLAG_RET)) break; if(block->Target != 0) { // NOTE: Both must be an absolute jump if(block->GetFlag(BASIC_BLOCK_FLAG_ABSJMP)) { // 2. if(block->VirtualEnd == maximumAddr) break; // 3. if(block->Target >= Function->VirtualStart && block->Target < block->VirtualEnd) break; } } // 4. Continue } } // Loop is done. Set the information in the function structure. Function->VirtualEnd = block->VirtualEnd; Function->BBlockEnd = FindBBlockIndex(block); return true; } #ifdef _WIN64 void FunctionPass::EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) { if(!m_FunctionInfo) return; // Get the table pointer and size auto functionTable = (PRUNTIME_FUNCTION)m_FunctionInfo; size_t totalCount = (m_FunctionInfoSize / sizeof(RUNTIME_FUNCTION)); // Enumerate each entry for(size_t i = 0; i < totalCount; i++) { if(!Callback(&functionTable[i])) break; } } #endif // _WIN64
C/C++
x64dbg-development/src/dbg/analysis/FunctionPass.h
#pragma once #include <functional> #include "AnalysisPass.h" #include "BasicBlock.h" class FunctionPass : public AnalysisPass { public: FunctionPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks); virtual ~FunctionPass(); virtual const char* GetName() override; virtual bool Analyse() override; private: duint m_ModuleStart; PVOID m_FunctionInfo; ULONG m_FunctionInfoSize; void AnalysisWorker(duint Start, duint End, std::vector<FunctionDef>* Blocks); void FindFunctionWorkerPrepass(duint Start, duint End, std::vector<FunctionDef>* Blocks); void FindFunctionWorker(std::vector<FunctionDef>* Blocks); bool ResolveKnownFunctionEnd(FunctionDef* Function); bool ResolveFunctionEnd(FunctionDef* Function, BasicBlock* LastBlock); #ifdef _WIN64 void EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback); #endif // _WIN64 };
C++
x64dbg-development/src/dbg/analysis/linearanalysis.cpp
#include "linearanalysis.h" #include "console.h" #include "memory.h" #include "function.h" #include <algorithm> LinearAnalysis::LinearAnalysis(duint base, duint size) : Analysis(base, size) { } void LinearAnalysis::Analyse() { dputs("Starting analysis..."); auto ticks = GetTickCount(); populateReferences(); dprintf("%u called functions populated\n", DWORD(mFunctions.size())); analyseFunctions(); dprintf("Analysis finished in %ums!\n", GetTickCount() - ticks); } void LinearAnalysis::SetMarkers() { FunctionDelRange(mBase, mBase + mSize - 1, false); for(auto & function : mFunctions) { if(!function.end) continue; FunctionAdd(function.start, function.end, false); } } void LinearAnalysis::sortCleanup() { //sort & remove duplicates std::sort(mFunctions.begin(), mFunctions.end()); auto last = std::unique(mFunctions.begin(), mFunctions.end()); mFunctions.erase(last, mFunctions.end()); } void LinearAnalysis::populateReferences() { //linear immediate reference scan (call <addr>, push <addr>, mov [somewhere], <addr>) for(duint i = 0; i < mSize;) { auto addr = mBase + i; if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER)) { auto ref = getReferenceOperand(); if(ref) mFunctions.push_back({ ref, 0 }); i += mCp.Size(); } else i++; } sortCleanup(); } void LinearAnalysis::analyseFunctions() { for(size_t i = 0; i < mFunctions.size(); i++) { auto & function = mFunctions[i]; if(function.end) //skip already-analysed functions continue; auto maxaddr = mBase + mSize; if(i < mFunctions.size() - 1) maxaddr = mFunctions[i + 1].start; auto end = findFunctionEnd(function.start, maxaddr); if(end) { if(mCp.Disassemble(end, translateAddr(end), MAX_DISASM_BUFFER)) function.end = end + mCp.Size() - 1; else function.end = end; } } } duint LinearAnalysis::findFunctionEnd(duint start, duint maxaddr) { //disassemble first instruction for some heuristics if(mCp.Disassemble(start, translateAddr(start), MAX_DISASM_BUFFER)) { //JMP [123456] ; import if(mCp.IsJump() && mCp.OpCount() && mCp[0].type == ZYDIS_OPERAND_TYPE_MEMORY) return 0; } //linear search with some trickery duint end = 0; duint jumpback = 0; for(duint addr = start, fardest = 0; addr < maxaddr;) { if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER)) { if(addr + mCp.Size() > maxaddr) //we went past the maximum allowed address break; if((mCp.IsJump() || mCp.IsLoop()) && mCp.OpCount() && mCp[0].type == ZYDIS_OPERAND_TYPE_IMMEDIATE) //jump { auto dest = duint(mCp[0].imm.value.u); if(dest >= maxaddr) //jump across function boundaries { //currently unused } else if(dest > addr && dest > fardest) //save the farthest JXX destination forward { fardest = dest; } else if(end && dest < end && (mCp.GetId() == ZYDIS_MNEMONIC_JMP || mCp.GetId() == ZYDIS_MNEMONIC_LOOP)) //save the last JMP backwards { jumpback = addr; } } else if(mCp.IsRet()) //possible function end? { end = addr; if(fardest < addr) //we stop if the farthest JXX destination forward is before this RET break; } addr += mCp.Size(); } else addr++; } return end < jumpback ? jumpback : end; } duint LinearAnalysis::getReferenceOperand() const { for(auto i = 0; i < mCp.OpCount(); i++) { const auto & op = mCp[i]; if(mCp.IsJump() || mCp.IsLoop()) //skip jumps/loops continue; if(op.type == ZYDIS_OPERAND_TYPE_IMMEDIATE) //we are looking for immediate references { auto dest = duint(op.imm.value.u); if(inRange(dest)) return dest; } } return 0; }
C/C++
x64dbg-development/src/dbg/analysis/linearanalysis.h
#ifndef _LINEARANALYSIS_H #define _LINEARANALYSIS_H #include "_global.h" #include "analysis.h" class LinearAnalysis : public Analysis { public: explicit LinearAnalysis(duint base, duint size); void Analyse() override; void SetMarkers() override; private: struct FunctionInfo { duint start; duint end; bool operator<(const FunctionInfo & b) const { return start < b.start; } bool operator==(const FunctionInfo & b) const { return start == b.start; } }; std::vector<FunctionInfo> mFunctions; void sortCleanup(); void populateReferences(); void analyseFunctions(); duint findFunctionEnd(duint start, duint maxaddr); duint getReferenceOperand() const; }; #endif //_LINEARANALYSIS_H
C++
x64dbg-development/src/dbg/analysis/LinearPass.cpp
#include <thread> #include <ppl.h> #include "AnalysisPass.h" #include "LinearPass.h" #include <zydis_wrapper.h> LinearPass::LinearPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks) : AnalysisPass(VirtualStart, VirtualEnd, MainBlocks) { // This is a fix for when the total data analysis size is less // than what parallelization can support. The minimum size requirement // is ((# THREADS) * (512)) bytes. If the requirement isn't met, // scale to use a single thread. if((512 * IdealThreadCount()) >= m_DataSize) SetIdealThreadCount(1); } LinearPass::~LinearPass() { } const char* LinearPass::GetName() { return "Linear Scandown"; } bool LinearPass::Analyse() { // Divide the work up between each thread // THREAD_WORK = (TOTAL / # THREADS) duint workAmount = m_DataSize / IdealThreadCount(); // Initialize thread vector auto threadBlocks = new std::vector<BasicBlock>[IdealThreadCount()]; concurrency::parallel_for(duint(0), IdealThreadCount(), [&](duint i) { duint threadWorkStart = m_VirtualStart + (workAmount * i); duint threadWorkStop = min((threadWorkStart + workAmount), m_VirtualEnd); // Allow a 256-byte variance of scanning because of // integer rounding errors and instruction overlap if(threadWorkStart > m_VirtualStart) { threadWorkStart = max((threadWorkStart - 256), m_VirtualStart); threadWorkStop = min((threadWorkStop + 256), m_VirtualEnd); } // Memory allocation optimization // TODO: Option to conserve memory threadBlocks[i].reserve(100000); // Execute AnalysisWorker(threadWorkStart, threadWorkStop, &threadBlocks[i]); }); // Clear old data and combine vectors m_MainBlocks.clear(); for(duint i = 0; i < IdealThreadCount(); i++) { std::move(threadBlocks[i].begin(), threadBlocks[i].end(), std::back_inserter(m_MainBlocks)); // Free old elements to conserve memory further BBlockArray().swap(threadBlocks[i]); } // Free memory ASAP delete[] threadBlocks; // Sort and remove duplicates std::sort(m_MainBlocks.begin(), m_MainBlocks.end()); m_MainBlocks.erase(std::unique(m_MainBlocks.begin(), m_MainBlocks.end()), m_MainBlocks.end()); // Run overlap analysis sub-pass AnalyseOverlaps(); return true; } void LinearPass::AnalyseOverlaps() { // Goal of this function: // // Remove all overlapping basic blocks because of threads // not ending or starting at absolutely defined points. // (Example: one thread starts in the middle of an instruction) // // This also checks for basic block targets jumping into // the middle of other basic blocks. // // THREAD_WORK = ceil(TOTAL / # THREADS) duint workTotal = m_MainBlocks.size(); duint workAmount = (workTotal + (IdealThreadCount() - 1)) / IdealThreadCount(); // Initialize thread vectors auto threadInserts = new std::vector<BasicBlock>[IdealThreadCount()]; concurrency::parallel_for(duint(0), IdealThreadCount(), [&](duint i) { duint threadWorkStart = (workAmount * i); duint threadWorkStop = min((threadWorkStart + workAmount), workTotal); // Again, allow an overlap of +/- 1 entry if(threadWorkStart > 0) { threadWorkStart = max((threadWorkStart - 1), 0); threadWorkStop = min((threadWorkStop + 1), workTotal); } // Execute AnalysisOverlapWorker(threadWorkStart, threadWorkStop, &threadInserts[i]); }); // THREAD VECTOR std::vector<BasicBlock> overlapInserts; { for(duint i = 0; i < IdealThreadCount(); i++) std::move(threadInserts[i].begin(), threadInserts[i].end(), std::back_inserter(overlapInserts)); // Sort and remove duplicates std::sort(overlapInserts.begin(), overlapInserts.end()); overlapInserts.erase(std::unique(overlapInserts.begin(), overlapInserts.end()), overlapInserts.end()); delete[] threadInserts; } // GLOBAL VECTOR { // Erase blocks marked for deletion m_MainBlocks.erase(std::remove_if(m_MainBlocks.begin(), m_MainBlocks.end(), [](BasicBlock & Elem) { return Elem.GetFlag(BASIC_BLOCK_FLAG_DELETE); })); // Insert std::move(overlapInserts.begin(), overlapInserts.end(), std::back_inserter(m_MainBlocks)); // Final sort std::sort(m_MainBlocks.begin(), m_MainBlocks.end()); } } void LinearPass::AnalysisWorker(duint Start, duint End, BBlockArray* Blocks) { Zydis disasm; duint blockBegin = Start; // BBlock starting virtual address duint blockEnd = 0; // BBlock ending virtual address bool blockPrevPad = false; // Indicator if the last instruction was padding BasicBlock* lastBlock = nullptr; // Avoid an expensive call to std::vector::back() int insnCount = 0; // Temporary number of instructions counted for a block for(duint i = Start; i < End;) { if(!disasm.Disassemble(i, TranslateAddress(i), int(End - i))) { // Skip instructions that can't be determined i++; continue; } // Increment counters i += disasm.Size(); blockEnd = i; insnCount++; // The basic block ends here if it is a branch bool call = disasm.IsCall(); // CALL bool jmp = disasm.IsJump(); // JUMP bool ret = disasm.IsRet(); // RETURN bool padding = disasm.IsFilling(); // INSTRUCTION PADDING if(padding) { // PADDING is treated differently. They are all created as their // own separate block for more analysis later. duint realBlockEnd = blockEnd - disasm.Size(); if((realBlockEnd - blockBegin) > 0) { // The next line terminates the BBlock before the INT instruction. // Early termination, faked as an indirect JMP. Rare case. lastBlock = CreateBlockWorker(Blocks, blockBegin, realBlockEnd, false, false, false, false); lastBlock->SetFlag(BASIC_BLOCK_FLAG_PREPAD); blockBegin = realBlockEnd; lastBlock->InstrCount = insnCount; insnCount = 0; } } if(call || jmp || ret || padding) { // Was this a padding instruction? if(padding && blockPrevPad) { // Append it to the previous block lastBlock->VirtualEnd = blockEnd; } else { // Otherwise use the default route: create a new entry auto block = lastBlock = CreateBlockWorker(Blocks, blockBegin, blockEnd, call, jmp, ret, padding); // Counters lastBlock->InstrCount = insnCount; insnCount = 0; if(!padding) { // Check if absolute jump, regardless of operand if(disasm.GetId() == ZYDIS_MNEMONIC_JMP) block->SetFlag(BASIC_BLOCK_FLAG_ABSJMP); // Figure out the operand type(s) if(disasm.OpCount() > 0) { const auto & operand = disasm[0]; if(operand.type == ZYDIS_OPERAND_TYPE_IMMEDIATE) { // Branch target immediate block->Target = (duint)operand.imm.value.u; } else { // Indirects (no operand, register, or memory) block->SetFlag(BASIC_BLOCK_FLAG_INDIRECT); if(operand.type == ZYDIS_OPERAND_TYPE_MEMORY && operand.mem.base == ZYDIS_REGISTER_RIP && operand.mem.index == ZYDIS_REGISTER_NONE && operand.mem.scale == 1) { /* block->SetFlag(BASIC_BLOCK_FLAG_INDIRPTR); block->Target = (duint)operand.mem.disp; */ } } } } } // Reset the loop variables blockBegin = i; blockPrevPad = padding; } } } void LinearPass::AnalysisOverlapWorker(duint Start, duint End, BBlockArray* Insertions) { // Comparison function to see if two blocks overlap auto BlockOverlapsRemove = [](BasicBlock * A, BasicBlock * B) -> BasicBlock* { // Do the blocks overlap? if(max(A->VirtualStart, B->VirtualStart) <= min((A->VirtualEnd - 1), (B->VirtualEnd - 1))) { // Return the block that should be removed if(A->Size() > B->Size()) return B; return A; } return nullptr; }; // Get a pointer to pure data const auto blocks = m_MainBlocks.data(); for(duint i = Start; i < End; i++) { const auto curr = &blocks[i]; const auto next = &blocks[i + 1]; // Current versus next (overlap -> delete) BasicBlock* removal = BlockOverlapsRemove(curr, next); if(removal) removal->SetFlag(BASIC_BLOCK_FLAG_DELETE); // Find blocks that need to be split in two because // of CALL/JMP targets // // Find targets in the virtual range if(ValidateAddress(curr->Target)) { removal = FindBBlockInRange(curr->Target); if(removal) { if(curr->GetFlag(BASIC_BLOCK_FLAG_CALL)) removal->SetFlag(BASIC_BLOCK_FLAG_CALL_TARGET); // If the target does not equal the block start... if(curr->Target != removal->VirtualStart) { // Mark for deletion removal->SetFlag(BASIC_BLOCK_FLAG_DELETE); // Block part 1 BasicBlock block1; block1.VirtualStart = removal->VirtualStart; block1.VirtualEnd = curr->Target; block1.Target = 0; block1.Flags = BASIC_BLOCK_FLAG_CUTOFF; // Attributes of the top half block1.InstrCount = removal->InstrCount; // Block part 2 BasicBlock block2; block2.VirtualStart = curr->Target; block2.VirtualEnd = removal->VirtualEnd; block2.Target = removal->Target; block2.Flags = removal->Flags; // Attributes of the bottom half (taken from original block) block2.InstrCount = removal->InstrCount; Insertions->push_back(block1); Insertions->push_back(block2); } } } } } BasicBlock* LinearPass::CreateBlockWorker(std::vector<BasicBlock>* Blocks, duint Start, duint End, bool Call, bool Jmp, bool Ret, bool Pad) { BasicBlock block { Start, End - 1, 0, 0, 0 }; // Check for calls if(Call) block.SetFlag(BASIC_BLOCK_FLAG_CALL); // Check for returns if(Ret) block.SetFlag(BASIC_BLOCK_FLAG_RET); // Check for interrupts if(Pad) block.SetFlag(BASIC_BLOCK_FLAG_PAD); Blocks->push_back(block); // std::vector::back() incurs a very large performance overhead (30% slower) when // used in debug mode. This code eliminates it from showing up in the profiler. #ifdef _DEBUG return &Blocks->data()[Blocks->size() - 1]; #else return &Blocks->back(); #endif // _DEBUG }
C/C++
x64dbg-development/src/dbg/analysis/LinearPass.h
#pragma once #include "AnalysisPass.h" #include "BasicBlock.h" class LinearPass : public AnalysisPass { public: LinearPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks); virtual ~LinearPass(); virtual const char* GetName() override; virtual bool Analyse() override; void AnalyseOverlaps(); private: void AnalysisWorker(duint Start, duint End, BBlockArray* Blocks); void AnalysisOverlapWorker(duint Start, duint End, BBlockArray* Insertions); BasicBlock* CreateBlockWorker(BBlockArray* Blocks, duint Start, duint End, bool Call, bool Jmp, bool Ret, bool Pad); };
C++
x64dbg-development/src/dbg/analysis/recursiveanalysis.cpp
#include "recursiveanalysis.h" #include <queue> #include "console.h" #include "filehelper.h" #include "function.h" #include "label.h" #include "xrefs.h" #include "plugin_loader.h" #include "loop.h" #include <set> #include <map> RecursiveAnalysis::RecursiveAnalysis(duint base, duint size, duint entryPoint, bool usePlugins, bool dump) : Analysis(base, size), mEntryPoint(entryPoint), mUsePlugins(usePlugins), mDump(dump) { } void RecursiveAnalysis::Analyse() { //TODO: implement queue to analyze multiple functions analyzeFunction(mEntryPoint); analyzeLoops(mEntryPoint); } void RecursiveAnalysis::SetMarkers() { if(mDump) for(const auto & function : mFunctions) FileHelper::WriteAllText(StringUtils::sprintf("cfgraph_%p.dot", function.second.entryPoint), GraphToDot(function.second)); //set function ranges for(const auto & functionItr : mFunctions) { // Split functions with multiple chunks (either due to tail calls or PGO) // Example: kernelbase:KernelBaseBaseDllInitialize // This algorithm orders basic blocks and then iterates, growing the chunk downwards // Function ranges are collected in another ordered map for loop insertion const auto & function = functionItr.second; std::map<Range, const BridgeCFNode*, RangeCompare> blockRanges, functionRanges; for(const auto & nodeItr : function.nodes) { const auto & node = nodeItr.second; if(!blockRanges.emplace(Range(node.start, node.end), &node).second) dprintf_untranslated("Overlapping basic block %p-%p, please report a bug!\n", node.start, node.end); } auto addFunction = [&function, &functionRanges](duint start, duint end, duint icount) { FunctionDelRange(start, end, false /* Do not override user-defined functions */); LoopDeleteRange(start, end); // clear loop range in function //XrefDelRange(start, end); // clear xrefs in function FunctionAdd(start, end, false, icount, function.entryPoint); functionRanges.emplace(Range(start, end), nullptr); }; duint rangeStart = 0, rangeEnd = 0, rangeInstructionCount = 0; for(auto rangeItr = blockRanges.begin(); rangeItr != blockRanges.end(); ++rangeItr) { auto disasmLen = [this](duint addr) { if(!mCp.Disassemble(addr, translateAddr(addr))) return 1; return mCp.Size(); }; const auto & node = *rangeItr->second; if(!rangeStart) { rangeStart = node.start; rangeEnd = node.end; rangeInstructionCount = node.icount; } else { #define ALIGN_UP(Address, Align) (((ULONG_PTR)(Address) + (Align) - 1) & ~((Align) - 1)) auto nextInstr = rangeEnd + disasmLen(rangeEnd); // The next instruction(s) might be padding to align IP, also allow this case to count as consecutive if(nextInstr == node.start || ((node.start & 0xF) == 0 && ALIGN_UP(nextInstr, 16) == node.start)) { // Merge the consecutive range rangeEnd = node.end; rangeInstructionCount += node.icount; } else { if(mDump) dprintf_untranslated("Flush partial range %p-%p\n", rangeStart, rangeEnd); addFunction(rangeStart, rangeEnd, rangeInstructionCount); rangeStart = node.start; rangeEnd = node.end; rangeInstructionCount = node.icount; } } } if(mDump) dprintf_untranslated("Flush range %p-%p\n", rangeStart, rangeEnd); addFunction(rangeStart, rangeEnd, rangeInstructionCount); // Collect loop ranges const auto & loopInfo = mLoopInfo[function.entryPoint]; std::vector<Range> loopRanges; for(const auto & backedge : loopInfo.backedges) { //dprintf("Backedge %p-%p\n", backedge.first, backedge.second); auto startBlock = backedge.second; // destination is the start of the potential loop range auto endBlock = backedge.first; // source is the start of the last block in the potential loop range auto startFunctionItr = functionRanges.find(Range(startBlock, startBlock)); auto endFunctionItr = functionRanges.find(Range(endBlock, endBlock)); if(startFunctionItr != functionRanges.end() && startFunctionItr == endFunctionItr) { // Loop ranges can only be in the same function chunk range, otherwise they won't insert/display properly const auto & endBlockNode = function.nodes.at(endBlock); loopRanges.emplace_back(startBlock, endBlockNode.end); } } // Order loop ranges by start address so the outermost loop is inserted first std::sort(loopRanges.begin(), loopRanges.end()); for(const auto & loopRange : loopRanges) { if(mDump) dprintf_untranslated("Loop %p-%p\n", loopRange.first, loopRange.second); duint loopInstructionCount = 0; for(auto blockItr = blockRanges.find(Range(loopRange.first, loopRange.first)); blockItr != blockRanges.end(); ++blockItr) { if(mDump) dprintf_untranslated("icount block %p-%p\n", blockItr->second->start, blockItr->second->end); loopInstructionCount += blockItr->second->icount; if(blockItr->second->end >= loopRange.second) break; } // TODO: RtlpEnterCriticalSectionContended has some weirdly nested loops that overlap each other // this might cause LoopAdd to fail LoopAdd(loopRange.first, loopRange.second, false, loopInstructionCount); } } //set xrefs for(const auto & xref : mXrefs) XrefAdd(xref.addr, xref.from); GuiUpdateAllViews(); } void RecursiveAnalysis::analyzeFunction(duint entryPoint) { //first pass: BFS through the disassembly starting at entryPoint CFGraph graph(entryPoint); UintSet visited; std::queue<duint> queue; queue.push(graph.entryPoint); while(!queue.empty()) { auto start = queue.front(); queue.pop(); if(visited.count(start)) //already visited continue; visited.insert(start); CFNode node(graph.entryPoint, start, start); if(!inRange(start)) //out of range { graph.AddNode(node); continue; } while(true) { if(!inRange(node.end)) { node.end = mCp.Address(); node.terminal = true; graph.AddNode(node); break; } node.icount++; if(!mCp.Disassemble(node.end, translateAddr(node.end))) { node.end++; continue; } //do xref analysis on the instruction XREF xref; xref.addr = 0; xref.from = mCp.Address(); for(auto i = 0; i < mCp.OpCount(); i++) { duint dest = mCp.ResolveOpValue(i, [](ZydisRegister)->size_t { return 0; }); if(inRange(dest)) { xref.addr = dest; break; } } if(xref.addr) mXrefs.push_back(xref); if(!mCp.IsNop() && (mCp.IsJump() || mCp.IsLoop())) //non-nop jump { //set the branch destinations node.brtrue = mCp.BranchDestination(); if(mCp.GetId() != ZYDIS_MNEMONIC_JMP) //unconditional jumps dont have a brfalse node.brfalse = node.end + mCp.Size(); //consider register/memory branches as terminal nodes if(mCp.OpCount() && mCp[0].type != ZYDIS_OPERAND_TYPE_IMMEDIATE) { //jmp ptr [index * sizeof(duint) + switchTable] if(mCp[0].type == ZYDIS_OPERAND_TYPE_MEMORY && mCp[0].mem.base == ZYDIS_REGISTER_NONE && mCp[0].mem.index != ZYDIS_REGISTER_NONE && mCp[0].mem.scale == sizeof(duint) && MemIsValidReadPtr(duint(mCp[0].mem.disp.value))) { Memory<duint*> switchTable(512 * sizeof(duint)); duint actualSize, index; MemRead(duint(mCp[0].mem.disp.value), switchTable(), 512 * sizeof(duint), &actualSize); actualSize /= sizeof(duint); for(index = 0; index < actualSize; index++) if(MemIsCodePage(switchTable()[index], false) == false) break; actualSize = index; if(actualSize >= 2 && actualSize < 512) { node.brtrue = 0; node.brfalse = 0; for(index = 0; index < actualSize; index++) { node.exits.push_back(switchTable()[index]); queue.emplace(switchTable()[index]); xref.addr = switchTable()[index]; mXrefs.push_back(xref); } } else node.terminal = true; } else node.terminal = true; } //add node to the function graph graph.AddNode(node); //enqueue branch destinations if(node.brtrue) queue.push(node.brtrue); if(node.brfalse) queue.push(node.brfalse); break; } if(mCp.IsCall()) { //TODO: add this to a queue to be analyzed later } if(mCp.IsRet()) { node.terminal = true; graph.AddNode(node); break; } node.end += mCp.Size(); } } //second pass: split overlapping blocks introduced by backedges for(auto & nodeIt : graph.nodes) { auto & node = nodeIt.second; duint addr = node.start; duint icount = 0; while(addr < node.end) { icount++; auto size = mCp.Disassemble(addr, translateAddr(addr)) ? mCp.Size() : 1; if(graph.nodes.count(addr + size)) { node.end = addr; node.split = true; node.brtrue = addr + size; node.brfalse = 0; node.terminal = false; node.icount = icount; break; } addr += size; } } //third pass: correct the parents + add brtrue and brfalse to the exits + get data graph.parents.clear(); for(auto & nodeIt : graph.nodes) { auto & node = nodeIt.second; graph.AddParent(node.start, node.brtrue); graph.AddParent(node.start, node.brfalse); if(node.brtrue) node.exits.push_back(node.brtrue); if(node.brfalse) node.exits.push_back(node.brfalse); if(node.brtrue && !node.brfalse) node.brtrue = 0; if(!node.icount) continue; node.instrs.reserve(node.icount); auto addr = node.start; while(addr <= node.end) //disassemble all instructions { auto size = mCp.Disassemble(addr, translateAddr(addr)) ? mCp.Size() : 1; if(mCp.IsCall() && mCp.OpCount()) //call reg / call [reg+X] { auto & op = mCp[0]; switch(op.type) { case ZYDIS_OPERAND_TYPE_REGISTER: node.indirectcall = true; break; case ZYDIS_OPERAND_TYPE_MEMORY: node.indirectcall |= op.mem.base != ZYDIS_REGISTER_RIP && (op.mem.base != ZYDIS_REGISTER_NONE || op.mem.index != ZYDIS_REGISTER_NONE); break; default: break; } } BridgeCFInstruction instr; instr.addr = addr; for(int i = 0; i < size; i++) instr.data[i] = inRange(addr + i) ? *translateAddr(addr + i) : 0; node.instrs.push_back(instr); addr += size; } } //fourth pass: allow plugins to manipulate the graph if(mUsePlugins && !plugincbempty(CB_ANALYZE)) { PLUG_CB_ANALYZE info; info.graph = graph.ToGraphList(); plugincbcall(CB_ANALYZE, &info); graph = BridgeCFGraph(&info.graph, true); } mFunctions.emplace(entryPoint, graph); } void RecursiveAnalysis::analyzeLoops(duint entryPoint) { auto graph = GetFunctionGraph(entryPoint); if(!graph) return; auto & loopInfo = mLoopInfo[entryPoint] = LoopInfo(); loopInfo.functionEntry = entryPoint; // Detect loops to the same basic block for(const auto & node : graph->nodes) for(duint exit : node.second.exits) if(exit == node.first) loopInfo.trivialLoops.insert(node.first); // Thanks to DefCon42 for help with the algorithm! std::vector<duint> stack; stack.push_back(entryPoint); std::set<duint> visited; std::map<duint, std::vector<duint>> state; while(!stack.empty()) { auto start = stack.back(); stack.pop_back(); if(visited.count(start)) //already visited continue; visited.insert(start); state[start].push_back(start); for(duint exit : graph->nodes.at(start).exits) { if(!visited.count(exit)) { state[exit] = state[start]; stack.push_back(exit); } else if(std::count(state[start].begin(), state[start].end(), exit)) { loopInfo.backedges.emplace(start, exit); } } } } void RecursiveAnalysis::dominatorAnalysis(duint entryPoint) { auto graph = GetFunctionGraph(entryPoint); if(!graph) return; // WIP algo // http://jgaa.info/accepted/2006/GeorgiadisTarjanWerneck2006.10.1.pdf // https://www.cs.princeton.edu/courses/archive/fall03/cs528/handouts/a%20fast%20algorithm%20for%20finding.pdf std::map<duint, duint> parent, anchestor, vertex; std::map<duint, duint> label, semi; std::map<duint, std::set<duint>> pred, bucket; std::map<duint, duint> dom; std::map<duint, duint> indexToAddress, addressToIndex; std::map<duint, std::set<duint>> succ; { size_t curIndex = 1; for(const auto & node : graph->nodes) { indexToAddress[curIndex] = node.first; addressToIndex[node.first] = curIndex; curIndex++; } for(const auto & node : graph->nodes) { auto & s = succ[addressToIndex[node.first]]; for(duint exit : node.second.exits) { s.insert(addressToIndex[exit]); } } } duint r = addressToIndex[entryPoint]; duint n = 0; std::function<void(duint)> dfs = [&](duint v) { semi.at(v) = (n = n + 1); vertex.at(n) = label.at(v) = v; anchestor.at(v) = 0; for(duint w : succ.at(v)) { if(semi.at(w) == 0) { parent.at(w) = v; dfs(w); } pred.at(w).insert(v); } }; std::function<void(duint)> compress = [&](duint v) { if(anchestor.at(anchestor.at(v)) != 0) { compress(anchestor.at(v)); if(semi.at(label.at(anchestor.at(v))) < semi.at(label.at(v))) label.at(v) = label.at(anchestor.at(v)); anchestor.at(v) = anchestor.at(anchestor.at(v)); } }; auto eval = [&](duint v) { if(anchestor.at(v) == 0) { return v; } else { compress(v); return label.at(v); } }; auto link = [&](duint v, duint w) { anchestor.at(w) = v; }; auto print = [](const char* name, const std::map<duint, duint> & m) { dprintf("%s:\n", name); for(const auto & e : m) dprintf(" %s[%p] = %p\n", name, e.first, e.second); }; print("indexToAddress", indexToAddress); print("addressToIndex", addressToIndex); // step1 for(duint i = 0; i < succ.size(); i++) { auto v = i + 1; pred[v] = bucket[v]; semi[v] = vertex[v] = anchestor[v] = label[v] = parent[v] = dom[v] = 0; dprintf("%d\n", v); } n = 0; dfs(r); print("semi", semi); print("vertex", vertex); print("label", label); print("anchestor", anchestor); for(duint i = n; i != 1; i--) { auto w = vertex.at(i); // step2 for(duint v : pred.at(w)) { auto u = eval(v); if(semi.at(u) < semi.at(w)) { semi[w] = semi.at(u); } bucket.at(vertex.at(semi.at(w))).insert(w); link(parent.at(w), w); } // step3 duint parentw = parent.at(w); auto & bp = bucket.at(parent.at(w)); for(auto itr = bp.begin(); itr != bp.end(); itr = bp.erase(itr)) { auto v = *itr; auto u = eval(v); if(semi.at(u) < semi.at(v)) { dom.at(v) = u; } else { dom.at(v) = parent.at(w); } } } // step4 for(duint i = 2; i != n; i++) { auto w = vertex.at(i); if(dom.at(w) != vertex.at(semi.at(w))) { dom[w] = dom[dom[w]]; } } dom.at(r) = 0; print("semi", semi); //succ(v) for(const auto & d : dom) { dprintf("dom[%d] = %d\n", d.first, d.second); } for(const auto & x : indexToAddress) { char label[256]; sprintf_s(label, "block%p", x.first); LabelSet(x.second, label, false, true); } }
C/C++
x64dbg-development/src/dbg/analysis/recursiveanalysis.h
#pragma once #include "analysis.h" class RecursiveAnalysis : public Analysis { public: explicit RecursiveAnalysis(duint base, duint size, duint entryPoint, bool usePlugins, bool dump = false); void Analyse() override; void SetMarkers() override; using UintSet = std::unordered_set<duint>; template<class T> using UintMap = std::unordered_map<duint, T>; using CFNode = BridgeCFNode; using CFGraph = BridgeCFGraph; static String NodeToString(const CFNode & n) { #ifdef _WIN64 return StringUtils::sprintf("start: %p, %lld\nend: %p\nfunction: %p", n.start, n.icount, n.end, n.parentGraph); //TODO: %llu or %u #else //x86 return StringUtils::sprintf("start: %p, %d\nend: %p\nfunction: %p", n.start, n.icount, n.end, n.parentGraph); //TODO: %llu or %u #endif //_WIN64 } static const char* GetNodeColor(const CFGraph & graph, const CFNode & node) { if(node.terminal) return "firebrick"; if(node.start == graph.entryPoint) return "forestgreen"; return "lightblue"; } static String GraphToDot(const CFGraph & graph) { String result = "digraph CFGraph {\n"; for(const auto & node : graph.nodes) result += StringUtils::sprintf(" n%p[label=\"%s\" style=filled fillcolor=%s shape=box]\n", node.second.start, NodeToString(node.second).c_str(), GetNodeColor(graph, node.second)); result += "\n"; for(const auto & node : graph.nodes) { if(node.second.brtrue) result += StringUtils::sprintf(" n%p-> n%p [color=%s]\n", node.second.start, node.second.brtrue, node.second.split ? "black" : "green"); if(node.second.brfalse) result += StringUtils::sprintf(" n%p-> n%p [color=red]\n", node.second.start, node.second.brfalse); } result += "\n"; for(const auto & parent : graph.parents) { for(const auto & node : parent.second) result += StringUtils::sprintf(" n%p-> n%p [style=dotted color=grey]\n", node, parent.first); } result += "}"; return std::move(result); } const CFGraph* GetFunctionGraph(duint entry) const { auto itr = mFunctions.find(entry); return itr == mFunctions.end() ? nullptr : &itr->second; } protected: duint mEntryPoint; std::unordered_map<duint, CFGraph> mFunctions; private: bool mUsePlugins; bool mDump; struct XREF { duint addr; duint from; }; std::vector<XREF> mXrefs; struct LoopInfo { duint functionEntry = 0; std::unordered_set<duint> trivialLoops; // loops to the same basic block std::unordered_map<duint, duint> backedges; // backedges in the CFG }; std::unordered_map<duint, LoopInfo> mLoopInfo; void analyzeFunction(duint entryPoint); void analyzeLoops(duint entryPoint); void dominatorAnalysis(duint entryPoint); };
C++
x64dbg-development/src/dbg/analysis/xrefsanalysis.cpp
#include "xrefsanalysis.h" #include "xrefs.h" #include "console.h" #include <module.h> XrefsAnalysis::XrefsAnalysis(duint base, duint size) : Analysis(base, size) { modbase = ModBaseFromAddr(base); modsize = ModSizeFromAddr(modbase); } void XrefsAnalysis::Analyse() { dputs("Starting xref analysis..."); auto ticks = GetTickCount(); for(auto addr = mBase; addr < mBase + mSize;) { if(!mCp.Disassemble(addr, translateAddr(addr))) { addr++; continue; } addr += mCp.Size(); XREF xref; xref.addr = 0; xref.from = mCp.Address(); for(auto i = 0; i < mCp.OpCount(); i++) { duint dest = mCp.ResolveOpValue(i, [](ZydisRegister)->size_t { return 0; }); if(inModRange(dest)) { xref.addr = dest; break; } } if(xref.addr) mXrefs.push_back(xref); } dprintf("%u xrefs found in %ums!\n", DWORD(mXrefs.size()), GetTickCount() - ticks); } void XrefsAnalysis::SetMarkers() { XrefDelRange(mBase, mBase + mSize - 1); for(const auto & xref : mXrefs) XrefAdd(xref.addr, xref.from); }
C/C++
x64dbg-development/src/dbg/analysis/xrefsanalysis.h
#pragma once #include "analysis.h" class XrefsAnalysis : public Analysis { public: XrefsAnalysis(duint base, duint size); void Analyse() override; void SetMarkers() override; private: struct XREF { duint addr; duint from; }; std::vector<XREF> mXrefs; duint modbase = 0; duint modsize = 0; bool inModRange(duint addr) const { return modbase ? (addr >= modbase && addr < modbase + modsize) : inRange(addr); } };
C/C++
x64dbg-development/src/dbg/commands/cmd-all.h
#pragma once #include "cmd-general-purpose.h" #include "cmd-debug-control.h" #include "cmd-breakpoint-control.h" #include "cmd-conditional-breakpoint-control.h" #include "cmd-tracing.h" #include "cmd-thread-control.h" #include "cmd-memory-operations.h" #include "cmd-operating-system-control.h" #include "cmd-watch-control.h" #include "cmd-variables.h" #include "cmd-searching.h" #include "cmd-user-database.h" #include "cmd-analysis.h" #include "cmd-types.h" #include "cmd-plugins.h" #include "cmd-script.h" #include "cmd-gui.h" #include "cmd-misc.h" #include "cmd-undocumented.h"
C++
x64dbg-development/src/dbg/commands/cmd-analysis.cpp
#include "cmd-analysis.h" #include "ntdll/ntdll.h" #include "linearanalysis.h" #include "memory.h" #include "exceptiondirectoryanalysis.h" #include "controlflowanalysis.h" #include "analysis_nukem.h" #include "xrefsanalysis.h" #include "recursiveanalysis.h" #include "value.h" #include "advancedanalysis.h" #include "debugger.h" #include "variable.h" #include "exhandlerinfo.h" #include "symbolinfo.h" #include "exception.h" #include "TraceRecord.h" #include "dbghelp_safe.h" bool cbInstrAnalyse(int argc, char* argv[]) { SELECTIONDATA sel; GuiSelectionGet(GUI_DISASSEMBLY, &sel); duint size = 0; duint base = MemFindBaseAddr(sel.start, &size); LinearAnalysis anal(base, size); anal.Analyse(); anal.SetMarkers(); GuiUpdateAllViews(); return true; } bool cbInstrExanalyse(int argc, char* argv[]) { SELECTIONDATA sel; GuiSelectionGet(GUI_DISASSEMBLY, &sel); duint size = 0; duint base = MemFindBaseAddr(sel.start, &size); ExceptionDirectoryAnalysis anal(base, size); anal.Analyse(); anal.SetMarkers(); GuiUpdateAllViews(); return true; } bool cbInstrCfanalyse(int argc, char* argv[]) { bool exceptionDirectory = false; if(argc > 1) exceptionDirectory = true; SELECTIONDATA sel; GuiSelectionGet(GUI_DISASSEMBLY, &sel); duint size = 0; duint base = MemFindBaseAddr(sel.start, &size); ControlFlowAnalysis anal(base, size, exceptionDirectory); anal.Analyse(); anal.SetMarkers(); GuiUpdateAllViews(); return true; } bool cbInstrAnalyseNukem(int argc, char* argv[]) { SELECTIONDATA sel; GuiSelectionGet(GUI_DISASSEMBLY, &sel); duint size = 0; duint base = MemFindBaseAddr(sel.start, &size); Analyse_nukem(base, size); GuiUpdateAllViews(); return true; } bool cbInstrAnalxrefs(int argc, char* argv[]) { SELECTIONDATA sel; GuiSelectionGet(GUI_DISASSEMBLY, &sel); duint size = 0; auto base = MemFindBaseAddr(sel.start, &size); XrefsAnalysis anal(base, size); anal.Analyse(); anal.SetMarkers(); GuiUpdateAllViews(); return true; } bool cbInstrAnalrecur(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint entry; if(!valfromstring(argv[1], &entry, false)) return false; #ifdef _WIN64 // find the closest function { SHARED_ACQUIRE(LockModules); auto info = ModInfoFromAddr(entry); if(info) { DWORD rva = DWORD(entry - info->base); auto runtimeFunction = info->findRuntimeFunction(rva); if(runtimeFunction) { if(runtimeFunction->BeginAddress < rva) { entry = info->base + runtimeFunction->BeginAddress; } } } } #endif // _WIN64 duint size; auto base = MemFindBaseAddr(entry, &size); if(!base) return false; RecursiveAnalysis analysis(base, size, entry, true); analysis.Analyse(); analysis.SetMarkers(); return true; } bool cbInstrAnalyseadv(int argc, char* argv[]) { SELECTIONDATA sel; GuiSelectionGet(GUI_DISASSEMBLY, &sel); duint size = 0; auto base = MemFindBaseAddr(sel.start, &size); AdvancedAnalysis anal(base, size); anal.Analyse(); anal.SetMarkers(); GuiUpdateAllViews(); return true; } bool cbInstrVirtualmod(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint base; if(!valfromstring(argv[2], &base)) { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid parameter [base]!")); return false; } if(!MemIsValidReadPtr(base)) { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid memory address!")); return false; } duint size; if(argc < 4) base = MemFindBaseAddr(base, &size); else if(!valfromstring(argv[3], &size)) { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid parameter [size]")); return false; } auto name = String("virtual:\\") + (argv[1]); if(!ModLoad(base, size, name.c_str())) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to load module (ModLoad)...")); return false; } char modname[MAX_MODULE_SIZE] = ""; if(ModNameFromAddr(base, modname, true)) BpEnumAll(cbSetModuleBreakpoints, modname); dprintf(QT_TRANSLATE_NOOP("DBG", "Virtual module \"%s\" loaded on %p[%p]!\n"), argv[1], base, size); GuiUpdateAllViews(); return true; } bool cbDebugDownloadSymbol(int argc, char* argv[]) { dputs(QT_TRANSLATE_NOOP("DBG", "This may take very long, depending on your network connection and data in the debug directory...")); Memory<char*> szDefaultStore(MAX_SETTING_SIZE + 1); const char* szSymbolStore = szDefaultStore(); if(!BridgeSettingGet("Symbols", "DefaultStore", szDefaultStore())) //get default symbol store from settings { strcpy_s(szDefaultStore(), MAX_SETTING_SIZE, "https://msdl.microsoft.com/download/symbols"); BridgeSettingSet("Symbols", "DefaultStore", szDefaultStore()); } if(argc < 2) //no arguments { SymDownloadAllSymbols(szSymbolStore); //download symbols for all modules GuiSymbolRefreshCurrent(); dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information")); return true; } //get some module information duint modbase = ModBaseFromName(argv[1]); if(!modbase) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]); return false; } if(argc > 2) szSymbolStore = argv[2]; if(!SymDownloadSymbol(modbase, szSymbolStore)) { dputs(QT_TRANSLATE_NOOP("DBG", "Symbol download failed... See symbol log for more information")); return false; } GuiSymbolRefreshCurrent(); dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information")); return true; } bool cbDebugLoadSymbol(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; //get some module information duint modbase = ModBaseFromName(argv[1]); if(!modbase) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]); return false; } auto pdbFile = argv[2]; if(!FileExists(pdbFile)) { dputs(QT_TRANSLATE_NOOP("DBG", "File does not exist!")); return false; } bool forceLoad = argc > 3 && DbgEval(argv[3]); EXCLUSIVE_ACQUIRE(LockModules); auto info = ModInfoFromAddr(modbase); if(!info) { // TODO: this really isn't supposed to happen, but could if the module is suddenly unloaded dputs("module not found..."); return false; } // trigger a symbol load if(!info->loadSymbols(pdbFile, forceLoad)) { dputs(QT_TRANSLATE_NOOP("DBG", "Symbol load failed... See symbol log for more information")); return false; } GuiSymbolRefreshCurrent(); dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information")); return true; } bool cbDebugUnloadSymbol(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; //get some module information duint modbase = ModBaseFromName(argv[1]); if(!modbase) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]); return false; } EXCLUSIVE_ACQUIRE(LockModules); auto info = ModInfoFromAddr(modbase); if(!info) { // TODO: this really isn't supposed to happen, but could if the module is suddenly unloaded dputs("module not found..."); return false; } info->unloadSymbols(); GuiRepaintTableView(); dputs(QT_TRANSLATE_NOOP("DBG", "Done!")); return true; } bool cbInstrImageinfo(int argc, char* argv[]) { duint address; if(argc < 2) address = GetContextDataEx(hActiveThread, UE_CIP); else if(!valfromstring(argv[1], &address)) { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid argument")); return false; } duint c, dllc, mod; { SHARED_ACQUIRE(LockModules); auto modinfo = ModInfoFromAddr(address); if(!modinfo) { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid argument")); return false; } c = GetPE32DataFromMappedFile(modinfo->fileMapVA, 0, UE_CHARACTERISTICS); dllc = GetPE32DataFromMappedFile(modinfo->fileMapVA, 0, UE_DLLCHARACTERISTICS); mod = modinfo->base; } auto pFlag = [](ULONG_PTR value, ULONG_PTR flag, const char* name) { if((value & flag) == flag) { dprintf(" "); dputs(name); } }; char modname[MAX_MODULE_SIZE] = ""; ModNameFromAddr(mod, modname, true); dputs_untranslated("---------------"); dprintf(QT_TRANSLATE_NOOP("DBG", "Image information for %s\n"), modname); dprintf(QT_TRANSLATE_NOOP("DBG", "Characteristics (0x%X):\n"), DWORD(c)); if(!c) dputs(QT_TRANSLATE_NOOP("DBG", " None\n")); pFlag(c, IMAGE_FILE_RELOCS_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_RELOCS_STRIPPED: Relocation info stripped from file.")); pFlag(c, IMAGE_FILE_EXECUTABLE_IMAGE, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_EXECUTABLE_IMAGE: File is executable (i.e. no unresolved externel references).")); pFlag(c, IMAGE_FILE_LINE_NUMS_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_LINE_NUMS_STRIPPED: Line numbers stripped from file.")); pFlag(c, IMAGE_FILE_LOCAL_SYMS_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_LOCAL_SYMS_STRIPPED: Local symbols stripped from file.")); pFlag(c, IMAGE_FILE_AGGRESIVE_WS_TRIM, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_AGGRESIVE_WS_TRIM: Agressively trim working set")); pFlag(c, IMAGE_FILE_LARGE_ADDRESS_AWARE, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_LARGE_ADDRESS_AWARE: App can handle >2gb addresses")); pFlag(c, IMAGE_FILE_BYTES_REVERSED_LO, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_BYTES_REVERSED_LO: Bytes of machine word are reversed.")); pFlag(c, IMAGE_FILE_32BIT_MACHINE, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_32BIT_MACHINE: 32 bit word machine.")); pFlag(c, IMAGE_FILE_DEBUG_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_DEBUG_STRIPPED: Debugging info stripped from file in .DBG file")); pFlag(c, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP: If Image is on removable media, copy and run from the swap file.")); pFlag(c, IMAGE_FILE_NET_RUN_FROM_SWAP, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_NET_RUN_FROM_SWAP: If Image is on Net, copy and run from the swap file.")); pFlag(c, IMAGE_FILE_SYSTEM, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_SYSTEM: System File.")); pFlag(c, IMAGE_FILE_DLL, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_DLL: File is a DLL.")); pFlag(c, IMAGE_FILE_UP_SYSTEM_ONLY, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_UP_SYSTEM_ONLY: File should only be run on a UP machine")); pFlag(c, IMAGE_FILE_BYTES_REVERSED_HI, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_BYTES_REVERSED_HI: Bytes of machine word are reversed.")); dprintf(QT_TRANSLATE_NOOP("DBG", "DLL Characteristics (0x%X):\n"), DWORD(dllc)); if(!dllc) dputs(QT_TRANSLATE_NOOP("DBG", " None\n")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE: DLL can move.")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY: Code Integrity Image")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NX_COMPAT, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NX_COMPAT: Image is NX compatible")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NO_ISOLATION, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NO_ISOLATION: Image understands isolation and doesn't want it")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NO_SEH, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NO_SEH: Image does not use SEH. No SE handler may reside in this image")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NO_BIND, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NO_BIND: Do not bind this image.")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_WDM_DRIVER, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_WDM_DRIVER: Driver uses WDM model.")); pFlag(dllc, IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE: Remote Desktop Services aware.")); dputs_untranslated("---------------"); return true; } bool cbInstrGetRelocSize(int argc, char* argv[]) { //Original tool "GetRelocSize" by Killboy/SND if(argc < 2) { _plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!")); return false; } duint RelocDirAddr; if(!valfromstring(argv[1], &RelocDirAddr, false)) return false; duint RelocSize = 0; varset("$result", RelocSize, false); IMAGE_RELOCATION RelocDir; do { if(!MemRead(RelocDirAddr, &RelocDir, sizeof(IMAGE_RELOCATION))) { _plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Invalid relocation table!")); return false; } if(!RelocDir.SymbolTableIndex) break; RelocSize += RelocDir.SymbolTableIndex; RelocDirAddr += RelocDir.SymbolTableIndex; } while(RelocDir.VirtualAddress); if(!RelocSize) { _plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Invalid relocation table!")); return false; } varset("$result", RelocSize, false); _plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Relocation table size: %X\n"), RelocSize); return true; } static void printExhandlers(const char* name, const std::vector<duint> & entries) { if(!entries.size()) return; dprintf("%s:\n", name); for(auto entry : entries) { dputs_untranslated(SymGetSymbolicName(entry).c_str()); } } bool cbInstrExhandlers(int argc, char* argv[]) { std::vector<duint> entries; #ifndef _WIN64 if(ExHandlerGetInfo(EX_HANDLER_SEH, entries)) { std::vector<duint> handlers; for(auto entry : entries) { duint handler; if(MemRead(entry + sizeof(duint), &handler, sizeof(handler))) handlers.push_back(handler); } printExhandlers("StructuredExceptionHandler (SEH)", handlers); } else dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get SEH (disabled?)")); #endif //_WIN64 if(ExHandlerGetInfo(EX_HANDLER_VEH, entries)) printExhandlers("VectoredExceptionHandler (VEH)", entries); else dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get VEH (loaded symbols for ntdll.dll?)")); if(IsVistaOrLater()) { if(ExHandlerGetInfo(EX_HANDLER_VCH, entries)) printExhandlers("VectoredContinueHandler (VCH)", entries); else dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get VCH (loaded symbols for ntdll.dll?)")); } if(ExHandlerGetInfo(EX_HANDLER_UNHANDLED, entries)) printExhandlers("UnhandledExceptionFilter", entries); else if(IsVistaOrLater()) dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get UnhandledExceptionFilter (loaded symbols for kernelbase.dll?)")); else dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get UnhandledExceptionFilter (loaded symbols for kernel32.dll?)")); return true; } bool cbInstrExinfo(int argc, char* argv[]) { const unsigned int MASK_FACILITY_VISUALCPP = 0x006D0000; auto info = getLastExceptionInfo(); const auto & record = info.ExceptionRecord; dputs_untranslated("EXCEPTION_DEBUG_INFO:"); dprintf_untranslated(" dwFirstChance: %X\n", info.dwFirstChance); auto exceptionName = ExceptionCodeToName(record.ExceptionCode); if(!exceptionName.size()) //if no exception was found, try the error codes (RPC_S_*) exceptionName = ErrorCodeToName(record.ExceptionCode); if(exceptionName.size()) dprintf_untranslated(" ExceptionCode: %08X (%s)\n", record.ExceptionCode, exceptionName.c_str()); else if((record.ExceptionCode & MASK_FACILITY_VISUALCPP) == MASK_FACILITY_VISUALCPP) //delayhlp.cpp { auto possibleError = record.ExceptionCode & 0xFFFF; exceptionName = ErrorCodeToName(possibleError); if(!exceptionName.empty()) exceptionName = StringUtils::sprintf(" (Visual C++ %s)", exceptionName.c_str()); dprintf_untranslated(" ExceptionCode: %08X%s\n", record.ExceptionCode, exceptionName.c_str()); } else dprintf_untranslated(" ExceptionCode: %08X\n", record.ExceptionCode); dprintf_untranslated(" ExceptionFlags: %08X\n", record.ExceptionFlags); dprintf_untranslated(" ExceptionAddress: %s\n", SymGetSymbolicName(duint(record.ExceptionAddress)).c_str()); dprintf_untranslated(" NumberParameters: %u\n", record.NumberParameters); if(record.NumberParameters) for(DWORD i = 0; i < record.NumberParameters; i++) { dprintf_untranslated("ExceptionInformation[%02u]: %s", i, SymGetSymbolicName(duint(record.ExceptionInformation[i])).c_str()); //https://msdn.microsoft.com/en-us/library/windows/desktop/aa363082(v=vs.85).aspx if(record.ExceptionCode == EXCEPTION_ACCESS_VIOLATION || record.ExceptionCode == EXCEPTION_IN_PAGE_ERROR || record.ExceptionCode == EXCEPTION_GUARD_PAGE) { if(i == 0) { if(record.ExceptionInformation[i] == 0) dprintf_untranslated(" Read"); else if(record.ExceptionInformation[i] == 1) dprintf_untranslated(" Write"); else if(record.ExceptionInformation[i] == 8) dprintf_untranslated(" DEP Violation"); } else if(i == 1) dprintf_untranslated(" Inaccessible Address"); else if(record.ExceptionCode == EXCEPTION_IN_PAGE_ERROR && i == 2) dprintf_untranslated(" %s", ExceptionCodeToName((unsigned int)record.ExceptionInformation[i]).c_str()); } dprintf_untranslated("\n"); } return true; } bool cbInstrTraceexecute(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr; if(!valfromstring(argv[1], &addr, false)) return false; dbgtraceexecute(addr); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-analysis.h
#pragma once #include "command.h" bool cbInstrAnalyse(int argc, char* argv[]); bool cbInstrExanalyse(int argc, char* argv[]); bool cbInstrCfanalyse(int argc, char* argv[]); bool cbInstrAnalyseNukem(int argc, char* argv[]); bool cbInstrAnalxrefs(int argc, char* argv[]); bool cbInstrAnalrecur(int argc, char* argv[]); bool cbInstrAnalyseadv(int argc, char* argv[]); bool cbInstrVirtualmod(int argc, char* argv[]); bool cbDebugDownloadSymbol(int argc, char* argv[]); bool cbDebugLoadSymbol(int argc, char* argv[]); bool cbDebugUnloadSymbol(int argc, char* argv[]); bool cbInstrImageinfo(int argc, char* argv[]); bool cbInstrGetRelocSize(int argc, char* argv[]); bool cbInstrExhandlers(int argc, char* argv[]); bool cbInstrExinfo(int argc, char* argv[]); bool cbInstrTraceexecute(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-breakpoint-control.cpp
#include "cmd-breakpoint-control.h" #include "console.h" #include "memory.h" #include "debugger.h" #include "exception.h" #include "value.h" // breakpoint enumeration callbacks static bool cbDeleteAllBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPNORMAL) return true; if(!BpDelete(*bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (BpDelete): %p\n"), bp->addr); return false; } if(bp->enabled && bp->active && !DeleteBPX(bp->addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (DeleteBPX): %p\n"), bp->addr); return false; } return true; } static bool cbEnableAllBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPNORMAL || bp->enabled) return true; if(!SetBPX(bp->addr, bp->titantype, cbUserBreakpoint)) { if(!MemIsValidReadPtr(bp->addr)) return true; dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (SetBPX)\n"), bp->addr); return false; } if(!BpEnable(bp->addr, BPNORMAL, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (BpEnable)\n"), bp->addr); return false; } return true; } static bool cbDisableAllBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPNORMAL || !bp->enabled) return true; if(!BpEnable(bp->addr, BPNORMAL, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (BpEnable)\n"), bp->addr); return false; } if(!DeleteBPX(bp->addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (DeleteBPX)\n"), bp->addr); return false; } return true; } // Software breakpoints bool cbDebugSetBPX(int argc, char* argv[]) //bp addr [,name [,type]] { if(IsArgumentsLessThan(argc, 2)) return false; char argaddr[deflen] = ""; strcpy_s(argaddr, argv[1]); char argname[deflen] = ""; if(argc > 2) strcpy_s(argname, argv[2]); char argtype[deflen] = ""; bool has_arg2 = argc > 3; if(has_arg2) strcpy_s(argtype, argv[3]); if(!has_arg2 && (scmp(argname, "ss") || scmp(argname, "long") || scmp(argname, "ud2"))) { strcpy_s(argtype, argname); *argname = 0; } _strlwr_s(argtype); duint addr = 0; if(!valfromstring(argaddr, &addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid addr: \"%s\"\n"), argaddr); return false; } int type = 0; bool singleshoot = false; if(strstr(argtype, "ss")) { type |= UE_SINGLESHOOT; singleshoot = true; } else type |= UE_BREAKPOINT; if(strstr(argtype, "long")) type |= UE_BREAKPOINT_TYPE_LONG_INT3; else if(strstr(argtype, "ud2")) type |= UE_BREAKPOINT_TYPE_UD2; else if(strstr(argtype, "short")) type |= UE_BREAKPOINT_TYPE_INT3; short oldbytes; const char* bpname = 0; if(*argname) bpname = argname; BREAKPOINT bp; if(BpGet(addr, BPNORMAL, bpname, &bp)) { if(!bp.enabled) return DbgCmdExecDirect(StringUtils::sprintf("bpe %p", bp.addr).c_str()); dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint already set!")); return true; } if(IsBPXEnabled(addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (IsBPXEnabled)\n"), addr); return false; } if(!MemRead(addr, &oldbytes, sizeof(short))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (memread)\n"), addr); return false; } if(!BpNew(addr, true, singleshoot, oldbytes, BPNORMAL, type, bpname)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (bpnew)\n"), addr); return false; } if(!SetBPX(addr, type, cbUserBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (SetBPX)\n"), addr); if(!BpDelete(addr, BPNORMAL)) dprintf(QT_TRANSLATE_NOOP("DBG", "Error handling invalid breakpoint at %p! (bpdel)\n"), addr); return false; } GuiUpdateAllViews(); if(bpname) dprintf(QT_TRANSLATE_NOOP("DBG", "Breakpoint at %p (%s) set!\n"), addr, bpname); else dprintf(QT_TRANSLATE_NOOP("DBG", "Breakpoint at %p set!\n"), addr); return true; } bool cbDebugDeleteBPX(int argc, char* argv[]) { if(argc < 2) //delete all breakpoints { if(!BpGetCount(BPNORMAL)) { dputs(QT_TRANSLATE_NOOP("DBG", "No breakpoints to delete!")); return true; } if(!BpEnumAll(cbDeleteAllBreakpoints)) //at least one deletion failed { GuiUpdateAllViews(); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "All breakpoints deleted!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; if(BpGet(0, BPNORMAL, argv[1], &found)) //found a breakpoint with name { if(!BpDelete(found.addr, BPNORMAL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (bpdel): %p\n"), found.addr); return false; } if(found.enabled && !DeleteBPX(found.addr)) { GuiUpdateAllViews(); if(!MemIsValidReadPtr(found.addr)) return true; dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (DeleteBPX): %p\n"), found.addr); return false; } GuiUpdateAllViews(); return true; } duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPNORMAL, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpDelete(found.addr, BPNORMAL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (bpdel): %p\n"), found.addr); return false; } if(found.enabled && !DeleteBPX(found.addr)) { GuiUpdateAllViews(); if(!MemIsValidReadPtr(found.addr)) return true; dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (DeleteBPX): %p\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint deleted!")); GuiUpdateAllViews(); return true; } bool cbDebugEnableBPX(int argc, char* argv[]) { if(argc < 2) //enable all breakpoints { if(!BpGetCount(BPNORMAL)) { dputs(QT_TRANSLATE_NOOP("DBG", "No breakpoints to enable!")); return true; } if(!BpEnumAll(cbEnableAllBreakpoints)) //at least one enable failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All breakpoints enabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; if(BpGet(0, BPNORMAL, argv[1], &found)) //found a breakpoint with name { if(!SetBPX(found.addr, found.titantype, cbUserBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (SetBPX)\n"), found.addr); return false; } if(!BpEnable(found.addr, BPNORMAL, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (BpEnable)\n"), found.addr); return false; } GuiUpdateAllViews(); return true; } duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPNORMAL, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint already enabled!")); GuiUpdateAllViews(); return true; } if(!SetBPX(found.addr, found.titantype, cbUserBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (SetBPX)\n"), found.addr); return false; } if(!BpEnable(found.addr, BPNORMAL, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (BpEnable)\n"), found.addr); return false; } GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint enabled!")); return true; } bool cbDebugDisableBPX(int argc, char* argv[]) { if(argc < 2) //delete all breakpoints { if(!BpGetCount(BPNORMAL)) { dputs(QT_TRANSLATE_NOOP("DBG", "No breakpoints to disable!")); return true; } if(!BpEnumAll(cbDisableAllBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All breakpoints disabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; if(BpGet(0, BPNORMAL, argv[1], &found)) //found a breakpoint with name { if(!BpEnable(found.addr, BPNORMAL, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (BpEnable)\n"), found.addr); return false; } if(!DeleteBPX(found.addr)) { GuiUpdateAllViews(); if(!MemIsValidReadPtr(found.addr)) return true; dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (DeleteBPX)\n"), found.addr); return false; } GuiUpdateAllViews(); return true; } duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPNORMAL, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint already disabled!")); return true; } if(!BpEnable(found.addr, BPNORMAL, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (BpEnable)\n"), found.addr); return false; } if(!DeleteBPX(found.addr)) { GuiUpdateAllViews(); if(!MemIsValidReadPtr(found.addr)) return true; dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (DeleteBPX)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint disabled!")); GuiUpdateAllViews(); return true; } // Hardware breakpoints static bool cbDeleteAllHardwareBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPHARDWARE) return true; if(!BpDelete(*bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed (BpDelete): %p\n"), bp->addr); return false; } if(bp->enabled && bp->active && TITANDRXVALID(bp->titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(bp->titantype))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed (DeleteHardwareBreakPoint): %p\n"), bp->addr); return false; } return true; } static bool cbEnableAllHardwareBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPHARDWARE || bp->enabled) return true; DWORD drx = 0; if(!GetUnusedHardwareBreakPointRegister(&drx)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Did not enable hardware breakpoint %p (all slots full)\n"), bp->addr); return true; } int titantype = bp->titantype; TITANSETDRX(titantype, drx); BpSetTitanType(bp->addr, BPHARDWARE, titantype); if(!BpEnable(bp->addr, BPHARDWARE, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (BpEnable)\n"), bp->addr); return false; } if(!SetHardwareBreakPoint(bp->addr, drx, TITANGETTYPE(bp->titantype), TITANGETSIZE(bp->titantype), cbHardwareBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (SetHardwareBreakPoint)\n"), bp->addr); return false; } return true; } static bool cbDisableAllHardwareBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPHARDWARE) return true; if(!BpEnable(bp->addr, BPHARDWARE, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (BpEnable)\n"), bp->addr); return false; } if(bp->enabled && TITANDRXVALID(bp->titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(bp->titantype))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (DeleteHardwareBreakPoint)\n"), bp->addr); return false; } auto titantype = bp->titantype; TITANSETDRX(titantype, UE_DR7); BpSetTitanType(bp->addr, BPHARDWARE, titantype); return true; } bool cbDebugSetHardwareBreakpoint(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr; if(!valfromstring(argv[1], &addr)) return false; DWORD type = UE_HARDWARE_EXECUTE; if(argc > 2) { switch(*argv[2]) { case 'r': type = UE_HARDWARE_READWRITE; break; case 'w': type = UE_HARDWARE_WRITE; break; case 'x': break; default: dputs(QT_TRANSLATE_NOOP("DBG", "Invalid type, assuming 'x'")); break; } } DWORD titsize = UE_HARDWARE_SIZE_1; if(argc > 3) { duint size; if(!valfromstring(argv[3], &size)) return false; switch(size) { case 1: titsize = UE_HARDWARE_SIZE_1; break; case 2: titsize = UE_HARDWARE_SIZE_2; break; case 4: titsize = UE_HARDWARE_SIZE_4; break; #ifdef _WIN64 case 8: titsize = UE_HARDWARE_SIZE_8; break; #endif // _WIN64 default: titsize = UE_HARDWARE_SIZE_1; dputs(QT_TRANSLATE_NOOP("DBG", "Invalid size, using 1")); break; } if((addr % size) != 0) { dprintf(QT_TRANSLATE_NOOP("DBG", "Address not aligned to %d\n"), int(size)); return false; } } DWORD drx = 0; if(!GetUnusedHardwareBreakPointRegister(&drx)) { dputs(QT_TRANSLATE_NOOP("DBG", "You can only set 4 hardware breakpoints")); return false; } int titantype = 0; TITANSETDRX(titantype, drx); TITANSETTYPE(titantype, type); TITANSETSIZE(titantype, titsize); //TODO: hwbp in multiple threads TEST BREAKPOINT bp; if(BpGet(addr, BPHARDWARE, 0, &bp)) { if(!bp.enabled) return DbgCmdExecDirect(StringUtils::sprintf("bphwe %p", bp.addr).c_str()); dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint already set!")); return true; } if(!BpNew(addr, true, false, 0, BPHARDWARE, titantype, 0)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting hardware breakpoint (bpnew)!")); return false; } if(!SetHardwareBreakPoint(addr, drx, type, titsize, cbHardwareBreakpoint)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting hardware breakpoint (TitanEngine)!")); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint at %p set!\n"), addr); GuiUpdateAllViews(); return true; } bool cbDebugDeleteHardwareBreakpoint(int argc, char* argv[]) { if(argc < 2) //delete all breakpoints { if(!BpGetCount(BPHARDWARE)) { dputs(QT_TRANSLATE_NOOP("DBG", "No hardware breakpoints to delete!")); return true; } if(!BpEnumAll(cbDeleteAllHardwareBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All hardware breakpoints deleted!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; if(BpGet(0, BPHARDWARE, argv[1], &found)) //found a breakpoint with name { if(!BpDelete(found.addr, BPHARDWARE)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (BpDelete)\n"), found.addr); return false; } if(TITANDRXVALID(found.titantype) && !DeleteHardwareBreakPoint(found.titantype)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (DeleteHardwareBreakPoint)\n"), found.addr); return false; } GuiUpdateAllViews(); return true; } duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPHARDWARE, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such hardware breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpDelete(found.addr, BPHARDWARE)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (BpDelete)\n"), found.addr); return false; } if(TITANDRXVALID(found.titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (DeleteHardwareBreakPoint)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint deleted!")); GuiUpdateAllViews(); return true; } bool cbDebugEnableHardwareBreakpoint(int argc, char* argv[]) { DWORD drx = 0; if(!GetUnusedHardwareBreakPointRegister(&drx)) { dputs(QT_TRANSLATE_NOOP("DBG", "You can only set 4 hardware breakpoints")); return false; } if(argc < 2) //enable all hardware breakpoints { if(!BpGetCount(BPHARDWARE)) { dputs(QT_TRANSLATE_NOOP("DBG", "No hardware breakpoints to enable!")); return true; } if(!BpEnumAll(cbEnableAllHardwareBreakpoints)) //at least one enable failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All hardware breakpoints enabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPHARDWARE, 0, &found)) //invalid hardware breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such hardware breakpoint \"%s\"\n"), argv[1]); return false; } if(found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint already enabled!")); GuiUpdateAllViews(); return true; } TITANSETDRX(found.titantype, drx); BpSetTitanType(found.addr, BPHARDWARE, found.titantype); if(!SetHardwareBreakPoint(found.addr, drx, TITANGETTYPE(found.titantype), TITANGETSIZE(found.titantype), cbHardwareBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (SetHardwareBreakpoint)\n"), found.addr); return false; } if(!BpEnable(found.addr, BPHARDWARE, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (BpEnable)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint enabled!")); GuiUpdateAllViews(); return true; } bool cbDebugDisableHardwareBreakpoint(int argc, char* argv[]) { if(argc < 2) //delete all hardware breakpoints { if(!BpGetCount(BPHARDWARE)) { dputs(QT_TRANSLATE_NOOP("DBG", "No hardware breakpoints to disable!")); return true; } if(!BpEnumAll(cbDisableAllHardwareBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All hardware breakpoints disabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPHARDWARE, 0, &found)) //invalid hardware breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such hardware breakpoint \"%s\"\n"), argv[1]); return false; } if(!found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint already disabled!")); return true; } if(!BpEnable(found.addr, BPHARDWARE, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (BpEnable)\n"), found.addr); return false; } if(TITANDRXVALID(found.titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (DeleteHardwareBreakpoint)\n"), found.addr); return false; } TITANSETDRX(found.titantype, UE_DR7); BpSetTitanType(found.addr, BPHARDWARE, found.titantype); dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint disabled!")); GuiUpdateAllViews(); return true; } // Memory breakpoints static bool cbDeleteAllMemoryBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPMEMORY) return true; duint size; MemFindBaseAddr(bp->addr, &size); if(!BpDelete(*bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed (BpDelete): %p\n"), bp->addr); return false; } if(bp->enabled && bp->active && !RemoveMemoryBPX(bp->addr, size)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed (RemoveMemoryBPX): %p\n"), bp->addr); return false; } return true; } static bool cbEnableAllMemoryBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPMEMORY || bp->enabled) return true; duint size = 0; MemFindBaseAddr(bp->addr, &size); if(!BpEnable(bp->addr, BPMEMORY, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (BpEnable)\n"), bp->addr); return false; } if(!SetMemoryBPXEx(bp->addr, size, bp->titantype, !bp->singleshoot, cbMemoryBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (SetMemoryBPXEx)\n"), bp->addr); return false; } return true; } static bool cbDisableAllMemoryBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPMEMORY || !bp->enabled) return true; if(!BpEnable(bp->addr, BPMEMORY, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (BpEnable)\n"), bp->addr); return false; } if(!RemoveMemoryBPX(bp->addr, 0)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (RemoveMemoryBPX)\n"), bp->addr); return false; } return true; } bool cbDebugSetMemoryBpx(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr; if(!valfromstring(argv[1], &addr)) return false; bool restore = false; char arg3[deflen] = ""; if(argc > 3) strcpy_s(arg3, argv[3]); if(argc > 2) { if(*argv[2] == '1') restore = true; else if(*argv[2] == '0') restore = false; else strcpy_s(arg3, argv[2]); } DWORD type = UE_MEMORY; if(*arg3) { switch(*arg3) { case 'a': //read+write+execute type = UE_MEMORY; break; case 'r': //read type = UE_MEMORY_READ; break; case 'w': //write type = UE_MEMORY_WRITE; break; case 'x': //execute type = UE_MEMORY_EXECUTE; break; default: dputs(QT_TRANSLATE_NOOP("DBG", "Invalid type (argument ignored)")); break; } } duint size = 0; duint base = MemFindBaseAddr(addr, &size, true); bool singleshoot = false; if(!restore) singleshoot = true; BREAKPOINT bp; if(BpGet(base, BPMEMORY, 0, &bp)) { if(!bp.enabled) return BpEnable(base, BPMEMORY, true); dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint already set!")); return true; } if(!BpNew(base, true, singleshoot, 0, BPMEMORY, type, 0, size)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting memory breakpoint! (BpNew)")); return false; } if(!SetMemoryBPXEx(base, size, type, restore, cbMemoryBreakpoint)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting memory breakpoint! (SetMemoryBPXEx)")); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint at %p set!\n"), addr); GuiUpdateAllViews(); return true; } bool cbDebugDeleteMemoryBreakpoint(int argc, char* argv[]) { if(argc < 2) //delete all breakpoints { if(!BpGetCount(BPMEMORY)) { dputs(QT_TRANSLATE_NOOP("DBG", "No memory breakpoints to delete!")); return true; } if(!BpEnumAll(cbDeleteAllMemoryBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All memory breakpoints deleted!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; if(BpGet(0, BPMEMORY, argv[1], &found)) //found a breakpoint with name { duint size; MemFindBaseAddr(found.addr, &size); if(!BpDelete(found.addr, BPMEMORY)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (BpDelete)\n"), found.addr); return false; } if(!RemoveMemoryBPX(found.addr, size)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (RemoveMemoryBPX)\n"), found.addr); return false; } GuiUpdateAllViews(); return true; } duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPMEMORY, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such memory breakpoint \"%s\"\n"), argv[1]); return false; } duint size; MemFindBaseAddr(found.addr, &size); if(!BpDelete(found.addr, BPMEMORY)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (BpDelete)\n"), found.addr); return false; } if(!RemoveMemoryBPX(found.addr, size)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (RemoveMemoryBPX)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint deleted!")); GuiUpdateAllViews(); return true; } bool cbDebugEnableMemoryBreakpoint(int argc, char* argv[]) { if(argc < 2) //enable all memory breakpoints { if(!BpGetCount(BPMEMORY)) { dputs(QT_TRANSLATE_NOOP("DBG", "No memory breakpoints to enable!")); return true; } if(!BpEnumAll(cbEnableAllMemoryBreakpoints)) //at least one enable failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All memory breakpoints enabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPMEMORY, 0, &found)) //invalid memory breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such memory breakpoint \"%s\"\n"), argv[1]); return false; } if(found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint already enabled!")); GuiUpdateAllViews(); return true; } duint size = 0; MemFindBaseAddr(found.addr, &size); if(!SetMemoryBPXEx(found.addr, size, found.titantype, !found.singleshoot, cbMemoryBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (SetMemoryBPXEx)\n"), found.addr); return false; } if(!BpEnable(found.addr, BPMEMORY, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (BpEnable)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint enabled!")); GuiUpdateAllViews(); return true; } bool cbDebugDisableMemoryBreakpoint(int argc, char* argv[]) { if(argc < 2) //disable all memory breakpoints { if(!BpGetCount(BPMEMORY)) { dputs(QT_TRANSLATE_NOOP("DBG", "No memory breakpoints to disable!")); return true; } if(!BpEnumAll(cbDisableAllMemoryBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All memory breakpoints disabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; duint addr = 0; if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPMEMORY, 0, &found)) //invalid memory breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such memory breakpoint \"%s\"\n"), argv[1]); return false; } if(!found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint already disabled!")); return true; } duint size = 0; MemFindBaseAddr(found.addr, &size); if(!RemoveMemoryBPX(found.addr, size)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (RemoveMemoryBPX)\n"), found.addr); return false; } if(!BpEnable(found.addr, BPMEMORY, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (BpEnable)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint disabled!")); GuiUpdateAllViews(); return true; } // DLL breakpoints static bool cbDeleteAllDllBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPDLL || !bp->enabled) return true; if(!BpDelete(*bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete DLL breakpoint %s (BpDelete)\n"), bp->mod); return false; } if(!dbgdeletedllbreakpoint(bp->mod, bp->titantype)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete DLL breakpoint %s (LibrarianRemoveBreakPoint)\n"), bp->mod); return false; } return true; } static bool cbEnableAllDllBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPDLL || bp->enabled) return true; if(!BpEnable(bp->addr, BPDLL, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (BpEnable)\n"), bp->mod); return false; } if(!dbgsetdllbreakpoint(bp->mod, bp->titantype, bp->singleshoot)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (LibrarianSetBreakPoint)\n"), bp->mod); return false; } return true; } static bool cbDisableAllDllBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPDLL || !bp->enabled) return true; if(!BpEnable(bp->addr, BPDLL, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (BpEnable)\n"), bp->mod); return false; } if(!dbgdeletedllbreakpoint(bp->mod, bp->titantype)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (LibrarianRemoveBreakPoint)\n"), bp->mod); return false; } return true; } bool cbDebugBpDll(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; _strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings DWORD type = UE_ON_LIB_ALL; if(argc > 2) { switch(*argv[2]) { case 'a': type = UE_ON_LIB_ALL; break; case 'l': type = UE_ON_LIB_LOAD; break; case 'u': type = UE_ON_LIB_UNLOAD; break; } } bool singleshoot = false; if(argc > 3) singleshoot = true; if(!BpNewDll(argv[1], true, singleshoot, type, "")) { dputs(QT_TRANSLATE_NOOP("DBG", "Error creating Dll breakpoint! (BpNewDll)")); return false; } if(!dbgsetdllbreakpoint(argv[1], type, singleshoot)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error creating Dll breakpoint! (LibrarianSetBreakPoint)")); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "Dll breakpoint set on \"%s\"!\n"), argv[1]); DebugUpdateBreakpointsViewAsync(); return true; } bool cbDebugBcDll(int argc, char* argv[]) { if(argc < 2) { // delete all Dll breakpoints if(!BpGetCount(BPDLL)) { dputs(QT_TRANSLATE_NOOP("DBG", "No DLL breakpoints to delete!")); return true; } if(!BpEnumAll(cbDeleteAllDllBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All DLL breakpoints deleted!")); DebugUpdateBreakpointsViewAsync(); return true; } _strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings BREAKPOINT bp; if(!BpGetAny(BPDLL, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to find DLL breakpoint '%s'...\n"), argv[1]); return false; } if(!BpDelete(bp.addr, BPDLL)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to remove DLL breakpoint (BpDelete)...")); return false; } DebugUpdateBreakpointsViewAsync(); if(!dbgdeletedllbreakpoint(bp.mod, bp.titantype)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to remove DLL breakpoint (dbgdeletedllbreakpoint)...")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint removed!")); return true; } bool cbDebugBpDllEnable(int argc, char* argv[]) { if(argc < 2) //enable all DLL breakpoints { if(!BpGetCount(BPDLL)) { dputs(QT_TRANSLATE_NOOP("DBG", "No DLL breakpoints to enable!")); return true; } if(!BpEnumAll(cbEnableAllDllBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All DLL breakpoints enabled!")); GuiUpdateAllViews(); return true; } _strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings BREAKPOINT found; duint addr = 0; if(!BpGetAny(BPDLL, argv[1], &found)) //invalid DLL breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such DLL breakpoint \"%s\"\n"), argv[1]); return false; } if(found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint already enabled!")); return true; } if(!BpEnable(found.addr, BPDLL, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (BpEnable)\n"), found.mod); return false; } if(!dbgsetdllbreakpoint(found.mod, found.titantype, found.singleshoot)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (LibrarianSetBreakPoint)\n"), found.mod); } dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint enable!")); GuiUpdateAllViews(); return true; } bool cbDebugBpDllDisable(int argc, char* argv[]) { if(argc < 2) //disable all DLL breakpoints { if(!BpGetCount(BPDLL)) { dputs(QT_TRANSLATE_NOOP("DBG", "No DLL breakpoints to disable!")); return true; } if(!BpEnumAll(cbDisableAllDllBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All DLL breakpoints disabled!")); GuiUpdateAllViews(); return true; } _strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings BREAKPOINT found; duint addr = 0; if(!BpGetAny(BPDLL, argv[1], &found)) //invalid DLL breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such DLL breakpoint \"%s\"\n"), argv[1]); return false; } if(!found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint already disabled!")); return true; } if(!BpEnable(found.addr, BPDLL, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (BpEnable)\n"), found.mod); return false; } if(!dbgdeletedllbreakpoint(found.mod, found.titantype)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (LibrarianRemoveBreakPoint)\n"), found.mod); } dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint disabled!")); GuiUpdateAllViews(); return true; } // Exception breakpoints static bool cbDeleteAllExceptionBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPEXCEPTION) return true; if(!BpDelete(*bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete exception breakpoint %p (BpEnable)\n"), bp->addr); return false; } return true; } static bool cbEnableAllExceptionBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPEXCEPTION || bp->enabled) return true; if(!BpEnable(bp->addr, BPEXCEPTION, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable exception breakpoint %p (BpEnable)\n"), bp->addr); return false; } return true; } static bool cbDisableAllExceptionBreakpoints(const BREAKPOINT* bp) { if(bp->type != BPEXCEPTION || !bp->enabled) return true; if(!BpEnable(bp->addr, BPEXCEPTION, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable exception breakpoint %p (BpEnable)\n"), bp->addr); return false; } return true; } bool cbDebugSetExceptionBPX(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint ExceptionCode; if(!valfromstring(argv[1], &ExceptionCode)) { ExceptionCode = 0; if(!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&ExceptionCode))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid exception code: %s.\n"), argv[1]); return false; } } const String & ExceptionName = ExceptionCodeToName((unsigned int)ExceptionCode); if(BpGet(ExceptionCode, BPEXCEPTION, nullptr, nullptr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint %X (%s) already exists!\n"), DWORD(ExceptionCode), ExceptionName.c_str()); return false; } auto extype = ex_firstchance; if(argc > 2) { duint chance; if(scmp(argv[2], "first")) extype = ex_firstchance; else if(scmp(argv[2], "second")) extype = ex_secondchance; else if(scmp(argv[2], "all")) extype = ex_all; else if(valfromstring(argv[2], &chance)) { switch(chance) { case 1: extype = ex_firstchance; break; case 2: extype = ex_secondchance; break; case 3: extype = ex_all; break; default: _plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Invalid exception type!")); return false; } } else { _plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Invalid exception type!")); return false; } } if(!BpNew(ExceptionCode, true, false, 0, BPEXCEPTION, extype, "")) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to set exception breakpoint! (BpNew)")); return false; } DebugUpdateBreakpointsViewAsync(); return true; } bool cbDebugDeleteExceptionBPX(int argc, char* argv[]) { if(argc < 2) { // delete all exception breakpoints if(!BpGetCount(BPEXCEPTION)) { dputs(QT_TRANSLATE_NOOP("DBG", "No exception breakpoints to delete!")); return true; } if(!BpEnumAll(cbDeleteAllExceptionBreakpoints)) //at least one enable failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All exception breakpoints deleted!")); DebugUpdateBreakpointsViewAsync(); return true; } BREAKPOINT found; if(BpGet(0, BPEXCEPTION, argv[1], &found)) //found a breakpoint with name { if(!BpDelete(found.addr, BPEXCEPTION)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete exception breakpoint failed (bpdel): %p\n"), found.addr); return false; } DebugUpdateBreakpointsViewAsync(); return true; } duint addr = 0; if((!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&addr)) && !valfromstring(argv[1], &addr)) || !BpGet(addr, BPEXCEPTION, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such exception breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpDelete(found.addr, BPEXCEPTION)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Delete exception breakpoint failed (bpdel): %p\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint deleted!")); DebugUpdateBreakpointsViewAsync(); return true; } bool cbDebugEnableExceptionBPX(int argc, char* argv[]) { if(argc < 2) //enable all breakpoints { if(!BpGetCount(BPEXCEPTION)) { dputs(QT_TRANSLATE_NOOP("DBG", "No exception breakpoints to enable!")); return true; } if(!BpEnumAll(cbEnableAllExceptionBreakpoints)) //at least one enable failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All exception breakpoints enabled!")); DebugUpdateBreakpointsViewAsync(); return true; } BREAKPOINT found; if(BpGet(0, BPEXCEPTION, argv[1], &found)) //found a breakpoint with name { if(!BpEnable(found.addr, BPEXCEPTION, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable exception breakpoint %p (BpEnable)\n"), found.addr); return false; } DebugUpdateBreakpointsViewAsync(); return true; } duint addr = 0; if((!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&addr)) && !valfromstring(argv[1], &addr)) || !BpGet(addr, BPEXCEPTION, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such exception breakpoint \"%s\"\n"), argv[1]); return false; } if(found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint already enabled!")); DebugUpdateBreakpointsViewAsync(); return true; } if(!BpEnable(found.addr, BPEXCEPTION, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable exception breakpoint %p (BpEnable)\n"), found.addr); return false; } DebugUpdateBreakpointsViewAsync(); dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint enabled!")); return true; } bool cbDebugDisableExceptionBPX(int argc, char* argv[]) { if(argc < 2) //disable all breakpoints { if(!BpGetCount(BPEXCEPTION)) { dputs(QT_TRANSLATE_NOOP("DBG", "No exception breakpoints to disable!")); return true; } if(!BpEnumAll(cbDisableAllExceptionBreakpoints)) //at least one deletion failed return false; dputs(QT_TRANSLATE_NOOP("DBG", "All exception breakpoints disabled!")); GuiUpdateAllViews(); return true; } BREAKPOINT found; if(BpGet(0, BPEXCEPTION, argv[1], &found)) //found a breakpoint with name { if(!BpEnable(found.addr, BPEXCEPTION, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable exception breakpoint %p (BpEnable)\n"), found.addr); return false; } GuiUpdateAllViews(); return true; } duint addr = 0; if((!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&addr)) && !valfromstring(argv[1], &addr)) || !BpGet(addr, BPEXCEPTION, 0, &found)) //invalid breakpoint { dprintf(QT_TRANSLATE_NOOP("DBG", "No such exception breakpoint \"%s\"\n"), argv[1]); return false; } if(!found.enabled) { dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint already disabled!")); return true; } if(!BpEnable(found.addr, BPEXCEPTION, false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable exception breakpoint %p (BpEnable)\n"), found.addr); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint disabled!")); GuiUpdateAllViews(); return true; } bool cbDebugSetBPGoto(int argc, char* argv[]) { if(argc != 3) { dputs(QT_TRANSLATE_NOOP("DBG", "argument count mismatch!\n")); return false; } char cmd[deflen]; sprintf_s(cmd, "SetBreakpointCondition %s, 0", argv[1]); if(!cmddirectexec(cmd)) return false; sprintf_s(cmd, "SetBreakpointCommand %s, \"bpgoto(%s)\"", argv[1], argv[2]); if(!cmddirectexec(cmd)) return false; sprintf_s(cmd, "SetBreakpointCommandCondition %s, 1", argv[1]); if(!cmddirectexec(cmd)) return false; sprintf_s(cmd, "SetBreakpointFastResume %s, 0", argv[1]); if(!cmddirectexec(cmd)) return false; return true; } static bool cbBreakpointList(const BREAKPOINT* bp) { const char* type = 0; if(bp->type == BPNORMAL) { if(bp->singleshoot) type = "SS"; else type = "BP"; } else if(bp->type == BPHARDWARE) type = "HW"; else if(bp->type == BPMEMORY) type = "GP"; else if(bp->type == BPDLL) type = "DLL"; else if(bp->type == BPEXCEPTION) type = "EX"; bool enabled = bp->enabled; if(bp->type == BPDLL) { if(*bp->name) dprintf_untranslated("%d:%s:\"%s\":\"%s\"\n", enabled, type, bp->mod, bp->name); else dprintf_untranslated("%d:%s:\"%s\"\n", enabled, type, bp->mod); } else if(*bp->name) dprintf_untranslated("%d:%s:%p:\"%s\"\n", enabled, type, bp->addr, bp->name); else dprintf_untranslated("%d:%s:%p\n", enabled, type, bp->addr); return true; } bool cbDebugBplist(int argc, char* argv[]) { if(!BpEnumAll(cbBreakpointList)) { dputs(QT_TRANSLATE_NOOP("DBG", "Something went wrong...")); return false; } return true; } bool cbDebugSetBPXOptions(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; DWORD type = 0; const char* strType = 0; duint setting_type; if(strstr(argv[1], "long")) { setting_type = 1; //break_int3long strType = "TYPE_LONG_INT3"; type = UE_BREAKPOINT_LONG_INT3; } else if(strstr(argv[1], "ud2")) { setting_type = 2; //break_ud2 strType = "TYPE_UD2"; type = UE_BREAKPOINT_UD2; } else if(strstr(argv[1], "short")) { setting_type = 0; //break_int3short strType = "TYPE_INT3"; type = UE_BREAKPOINT_INT3; } else { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid type specified!")); return false; } SetBPXOptions(type); BridgeSettingSetUint("Engine", "BreakpointType", setting_type); dprintf(QT_TRANSLATE_NOOP("DBG", "Default breakpoint type set to: %s\n"), strType); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-breakpoint-control.h
#pragma once #include "command.h" bool cbDebugSetBPX(int argc, char* argv[]); bool cbDebugDeleteBPX(int argc, char* argv[]); bool cbDebugEnableBPX(int argc, char* argv[]); bool cbDebugDisableBPX(int argc, char* argv[]); bool cbDebugSetHardwareBreakpoint(int argc, char* argv[]); bool cbDebugDeleteHardwareBreakpoint(int argc, char* argv[]); bool cbDebugEnableHardwareBreakpoint(int argc, char* argv[]); bool cbDebugDisableHardwareBreakpoint(int argc, char* argv[]); bool cbDebugSetMemoryBpx(int argc, char* argv[]); bool cbDebugDeleteMemoryBreakpoint(int argc, char* argv[]); bool cbDebugEnableMemoryBreakpoint(int argc, char* argv[]); bool cbDebugDisableMemoryBreakpoint(int argc, char* argv[]); bool cbDebugBpDll(int argc, char* argv[]); bool cbDebugBcDll(int argc, char* argv[]); bool cbDebugBpDllEnable(int argc, char* argv[]); bool cbDebugBpDllDisable(int argc, char* argv[]); bool cbDebugSetExceptionBPX(int argc, char* argv[]); bool cbDebugDeleteExceptionBPX(int argc, char* argv[]); bool cbDebugEnableExceptionBPX(int argc, char* argv[]); bool cbDebugDisableExceptionBPX(int argc, char* argv[]); bool cbDebugSetBPGoto(int argc, char* argv[]); bool cbDebugBplist(int argc, char* argv[]); bool cbDebugSetBPXOptions(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-conditional-breakpoint-control.cpp
#include "cmd-conditional-breakpoint-control.h" #include "breakpoint.h" #include "debugger.h" #include "console.h" #include "variable.h" #include "value.h" #include <functional> static bool cbDebugSetBPXTextCommon(BP_TYPE Type, int argc, char* argv[], const String & description, const std::function<bool(duint, BP_TYPE, const char*)> & setFunction) { BREAKPOINT bp; if(IsArgumentsLessThan(argc, 2)) return false; const char* value = ""; if(argc > 2) value = argv[2]; if(!BpGetAny(Type, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!setFunction(bp.addr, Type, value)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set %s on breakpoint \"%s\"\n"), description.c_str(), argv[1]); return false; } DebugUpdateBreakpointsViewAsync(); return true; } static bool cbDebugSetBPXNameCommon(BP_TYPE Type, int argc, char* argv[]) { return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "breakpoint name"))), BpSetName); } static bool cbDebugSetBPXConditionCommon(BP_TYPE Type, int argc, char* argv[]) { return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "break condition"))), BpSetBreakCondition); } static bool cbDebugSetBPXLogCommon(BP_TYPE Type, int argc, char* argv[]) { return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "logging text"))), BpSetLogText); } static bool cbDebugSetBPXLogConditionCommon(BP_TYPE Type, int argc, char* argv[]) { return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "logging condition"))), BpSetLogCondition); } static bool cbDebugSetBPXCommandCommon(BP_TYPE Type, int argc, char* argv[]) { return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "command on hit"))), BpSetCommandText); } static bool cbDebugSetBPXCommandConditionCommon(BP_TYPE Type, int argc, char* argv[]) { return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "command condition"))), BpSetCommandCondition); } static bool cbDebugSetBPXFastResumeCommon(BP_TYPE Type, int argc, char* argv[]) { BREAKPOINT bp; if(IsArgumentsLessThan(argc, 2)) return false; auto fastResume = true; if(argc > 2) { duint value; if(!valfromstring(argv[2], &value, false)) return false; fastResume = value != 0; } if(!BpGetAny(Type, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpSetFastResume(bp.addr, Type, fastResume)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set fast resume on breakpoint \"%s\"\n"), argv[1]); return false; } DebugUpdateBreakpointsViewAsync(); return true; } static bool cbDebugSetBPXSingleshootCommon(BP_TYPE Type, int argc, char* argv[]) { BREAKPOINT bp; if(IsArgumentsLessThan(argc, 2)) return false; auto singleshoot = true; if(argc > 2) { duint value; if(!valfromstring(argv[2], &value, false)) return false; singleshoot = value != 0; } if(!BpGetAny(Type, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpSetSingleshoot(bp.addr, Type, singleshoot)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set singleshoot on breakpoint \"%s\"\n"), argv[1]); return false; } DebugUpdateBreakpointsViewAsync(); return true; } static bool cbDebugSetBPXSilentCommon(BP_TYPE Type, int argc, char* argv[]) { BREAKPOINT bp; if(IsArgumentsLessThan(argc, 2)) return false; auto silent = true; if(argc > 2) { duint value; if(!valfromstring(argv[2], &value, false)) return false; silent = value != 0; } if(!BpGetAny(Type, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpSetSilent(bp.addr, Type, silent)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set silent on breakpoint \"%s\"\n"), argv[1]); return false; } DebugUpdateBreakpointsViewAsync(); return true; } static bool cbDebugGetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; BREAKPOINT bp; if(!BpGetAny(Type, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } varset("$result", bp.hitcount, false); return true; } static bool cbDebugResetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint value = 0; if(argc > 2) if(!valfromstring(argv[2], &value, false)) return false; BREAKPOINT bp; if(!BpGetAny(Type, argv[1], &bp)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]); return false; } if(!BpResetHitCount(bp.addr, Type, (uint32)value)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set hit count on breakpoint \"%s\"\n"), argv[1]); return false; } DebugUpdateBreakpointsViewAsync(); return true; } bool cbDebugSetBPXName(int argc, char* argv[]) { return cbDebugSetBPXNameCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXCondition(int argc, char* argv[]) { return cbDebugSetBPXConditionCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXLog(int argc, char* argv[]) { return cbDebugSetBPXLogCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXLogCondition(int argc, char* argv[]) { return cbDebugSetBPXLogConditionCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXCommand(int argc, char* argv[]) { return cbDebugSetBPXCommandCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXCommandCondition(int argc, char* argv[]) { return cbDebugSetBPXCommandConditionCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXFastResume(int argc, char* argv[]) { return cbDebugSetBPXFastResumeCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXSingleshoot(int argc, char* argv[]) { return cbDebugSetBPXSingleshootCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXSilent(int argc, char* argv[]) { return cbDebugSetBPXSilentCommon(BPNORMAL, argc, argv); } bool cbDebugGetBPXHitCount(int argc, char* argv[]) { return cbDebugGetBPXHitCountCommon(BPNORMAL, argc, argv); } bool cbDebugResetBPXHitCount(int argc, char* argv[]) { return cbDebugResetBPXHitCountCommon(BPNORMAL, argc, argv); } bool cbDebugSetBPXHardwareName(int argc, char* argv[]) { return cbDebugSetBPXNameCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareCondition(int argc, char* argv[]) { return cbDebugSetBPXConditionCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareLog(int argc, char* argv[]) { return cbDebugSetBPXLogCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareLogCondition(int argc, char* argv[]) { return cbDebugSetBPXLogConditionCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareCommand(int argc, char* argv[]) { return cbDebugSetBPXCommandCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[]) { return cbDebugSetBPXCommandConditionCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareFastResume(int argc, char* argv[]) { return cbDebugSetBPXFastResumeCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[]) { return cbDebugSetBPXSingleshootCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXHardwareSilent(int argc, char* argv[]) { return cbDebugSetBPXSilentCommon(BPHARDWARE, argc, argv); } bool cbDebugGetBPXHardwareHitCount(int argc, char* argv[]) { return cbDebugGetBPXHitCountCommon(BPHARDWARE, argc, argv); } bool cbDebugResetBPXHardwareHitCount(int argc, char* argv[]) { return cbDebugResetBPXHitCountCommon(BPHARDWARE, argc, argv); } bool cbDebugSetBPXMemoryName(int argc, char* argv[]) { return cbDebugSetBPXNameCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemoryCondition(int argc, char* argv[]) { return cbDebugSetBPXConditionCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemoryLog(int argc, char* argv[]) { return cbDebugSetBPXLogCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemoryLogCondition(int argc, char* argv[]) { return cbDebugSetBPXLogConditionCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemoryCommand(int argc, char* argv[]) { return cbDebugSetBPXCommandCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[]) { return cbDebugSetBPXCommandConditionCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemoryFastResume(int argc, char* argv[]) { return cbDebugSetBPXFastResumeCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemorySingleshoot(int argc, char* argv[]) { return cbDebugSetBPXSingleshootCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXMemorySilent(int argc, char* argv[]) { return cbDebugSetBPXSilentCommon(BPMEMORY, argc, argv); } bool cbDebugGetBPXMemoryHitCount(int argc, char* argv[]) { return cbDebugGetBPXHitCountCommon(BPMEMORY, argc, argv); } bool cbDebugResetBPXMemoryHitCount(int argc, char* argv[]) { return cbDebugResetBPXHitCountCommon(BPMEMORY, argc, argv); } bool cbDebugSetBPXDLLName(int argc, char* argv[]) { return cbDebugSetBPXNameCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLCondition(int argc, char* argv[]) { return cbDebugSetBPXConditionCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLLog(int argc, char* argv[]) { return cbDebugSetBPXLogCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLLogCondition(int argc, char* argv[]) { return cbDebugSetBPXLogConditionCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLCommand(int argc, char* argv[]) { return cbDebugSetBPXCommandCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLCommandCondition(int argc, char* argv[]) { return cbDebugSetBPXCommandConditionCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLFastResume(int argc, char* argv[]) { return cbDebugSetBPXFastResumeCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLSingleshoot(int argc, char* argv[]) { return cbDebugSetBPXSingleshootCommon(BPDLL, argc, argv); } bool cbDebugSetBPXDLLSilent(int argc, char* argv[]) { return cbDebugSetBPXSilentCommon(BPDLL, argc, argv); } bool cbDebugGetBPXDLLHitCount(int argc, char* argv[]) { return cbDebugGetBPXHitCountCommon(BPDLL, argc, argv); } bool cbDebugResetBPXDLLHitCount(int argc, char* argv[]) { return cbDebugResetBPXHitCountCommon(BPDLL, argc, argv); } bool cbDebugSetBPXExceptionName(int argc, char* argv[]) { return cbDebugSetBPXNameCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionCondition(int argc, char* argv[]) { return cbDebugSetBPXConditionCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionLog(int argc, char* argv[]) { return cbDebugSetBPXLogCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionLogCondition(int argc, char* argv[]) { return cbDebugSetBPXLogConditionCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionCommand(int argc, char* argv[]) { return cbDebugSetBPXCommandCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[]) { return cbDebugSetBPXCommandConditionCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionFastResume(int argc, char* argv[]) { return cbDebugSetBPXFastResumeCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[]) { return cbDebugSetBPXSingleshootCommon(BPEXCEPTION, argc, argv); } bool cbDebugSetBPXExceptionSilent(int argc, char* argv[]) { return cbDebugSetBPXSilentCommon(BPEXCEPTION, argc, argv); } bool cbDebugGetBPXExceptionHitCount(int argc, char* argv[]) { return cbDebugGetBPXHitCountCommon(BPEXCEPTION, argc, argv); } bool cbDebugResetBPXExceptionHitCount(int argc, char* argv[]) { return cbDebugResetBPXHitCountCommon(BPEXCEPTION, argc, argv); }
C/C++
x64dbg-development/src/dbg/commands/cmd-conditional-breakpoint-control.h
#pragma once #include "command.h" bool cbDebugSetBPXName(int argc, char* argv[]); bool cbDebugSetBPXCondition(int argc, char* argv[]); bool cbDebugSetBPXLog(int argc, char* argv[]); bool cbDebugSetBPXLogCondition(int argc, char* argv[]); bool cbDebugSetBPXCommand(int argc, char* argv[]); bool cbDebugSetBPXCommandCondition(int argc, char* argv[]); bool cbDebugSetBPXFastResume(int argc, char* argv[]); bool cbDebugSetBPXSingleshoot(int argc, char* argv[]); bool cbDebugSetBPXSilent(int argc, char* argv[]); bool cbDebugGetBPXHitCount(int argc, char* argv[]); bool cbDebugResetBPXHitCount(int argc, char* argv[]); bool cbDebugSetBPXHardwareName(int argc, char* argv[]); bool cbDebugSetBPXHardwareCondition(int argc, char* argv[]); bool cbDebugSetBPXHardwareLog(int argc, char* argv[]); bool cbDebugSetBPXHardwareLogCondition(int argc, char* argv[]); bool cbDebugSetBPXHardwareCommand(int argc, char* argv[]); bool cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[]); bool cbDebugSetBPXHardwareFastResume(int argc, char* argv[]); bool cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[]); bool cbDebugSetBPXHardwareSilent(int argc, char* argv[]); bool cbDebugGetBPXHardwareHitCount(int argc, char* argv[]); bool cbDebugResetBPXHardwareHitCount(int argc, char* argv[]); bool cbDebugSetBPXMemoryName(int argc, char* argv[]); bool cbDebugSetBPXMemoryCondition(int argc, char* argv[]); bool cbDebugSetBPXMemoryLog(int argc, char* argv[]); bool cbDebugSetBPXMemoryLogCondition(int argc, char* argv[]); bool cbDebugSetBPXMemoryCommand(int argc, char* argv[]); bool cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[]); bool cbDebugSetBPXMemoryFastResume(int argc, char* argv[]); bool cbDebugSetBPXMemorySingleshoot(int argc, char* argv[]); bool cbDebugSetBPXMemorySilent(int argc, char* argv[]); bool cbDebugGetBPXMemoryHitCount(int argc, char* argv[]); bool cbDebugResetBPXMemoryHitCount(int argc, char* argv[]); bool cbDebugSetBPXDLLName(int argc, char* argv[]); bool cbDebugSetBPXDLLCondition(int argc, char* argv[]); bool cbDebugSetBPXDLLLog(int argc, char* argv[]); bool cbDebugSetBPXDLLLogCondition(int argc, char* argv[]); bool cbDebugSetBPXDLLCommand(int argc, char* argv[]); bool cbDebugSetBPXDLLCommandCondition(int argc, char* argv[]); bool cbDebugSetBPXDLLFastResume(int argc, char* argv[]); bool cbDebugSetBPXDLLSingleshoot(int argc, char* argv[]); bool cbDebugSetBPXDLLSilent(int argc, char* argv[]); bool cbDebugGetBPXDLLHitCount(int argc, char* argv[]); bool cbDebugResetBPXDLLHitCount(int argc, char* argv[]); bool cbDebugSetBPXExceptionName(int argc, char* argv[]); bool cbDebugSetBPXExceptionCondition(int argc, char* argv[]); bool cbDebugSetBPXExceptionLog(int argc, char* argv[]); bool cbDebugSetBPXExceptionLogCondition(int argc, char* argv[]); bool cbDebugSetBPXExceptionCommand(int argc, char* argv[]); bool cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[]); bool cbDebugSetBPXExceptionFastResume(int argc, char* argv[]); bool cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[]); bool cbDebugSetBPXExceptionSilent(int argc, char* argv[]); bool cbDebugGetBPXExceptionHitCount(int argc, char* argv[]); bool cbDebugResetBPXExceptionHitCount(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-debug-control.cpp
#include "cmd-debug-control.h" #include "ntdll/ntdll.h" #include "console.h" #include "debugger.h" #include "animate.h" #include "historycontext.h" #include "threading.h" #include "memory.h" #include "disasm_fast.h" #include "plugin_loader.h" #include "value.h" #include "TraceRecord.h" #include "handle.h" #include "thread.h" #include "GetPeArch.h" #include "database.h" #include "exception.h" #include "stringformat.h" static bool isInt3Exception() { if(getLastExceptionInfo().ExceptionRecord.ExceptionCode != EXCEPTION_BREAKPOINT) return false; auto exceptionAddress = (duint)getLastExceptionInfo().ExceptionRecord.ExceptionAddress; unsigned char data[MAX_DISASM_BUFFER]; MemRead(exceptionAddress, data, sizeof(data)); Zydis zydis; return zydis.Disassemble(exceptionAddress, data) && zydis.IsInt3(); } static bool skipInt3Stepping(int argc, char* argv[]) { if(bSkipInt3Stepping && !dbgisrunning() && isInt3Exception()) { //Don't allow skipping of multiple consecutive INT3 instructions getLastExceptionInfo().ExceptionRecord.ExceptionCode = 0; dbgsetcontinuestatus(DBG_CONTINUE); // swallow the exception dputs(QT_TRANSLATE_NOOP("DBG", "Skipped INT3!")); return true; } return false; } bool cbDebugRunInternal(int argc, char* argv[], HistoryAction history) { // History handling if(history == history_record) HistoryRecord(); else HistoryClear(); // Set a singleshot breakpoint at the first parameter if(argc >= 2 && !DbgCmdExecDirect(StringUtils::sprintf("bp \"%s\", ss", argv[1]).c_str())) return false; // Don't "run" twice if the program is already running if(dbgisrunning()) return false; GuiSetDebugStateAsync(running); unlock(WAITID_RUN); PLUG_CB_RESUMEDEBUG callbackInfo; callbackInfo.reserved = 0; plugincbcall(CB_RESUMEDEBUG, &callbackInfo); return true; } bool cbDebugInit(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; EXCLUSIVE_ACQUIRE(LockDebugStartStop); cbDebugStop(argc, argv); ASSERT_TRUE(hDebugLoopThread == nullptr); char arg1[deflen] = ""; strcpy_s(arg1, argv[1]); char arg2[deflen] = ""; if(argc > 2) strcpy_s(arg2, argv[2]); char arg3[deflen] = ""; if(argc > 3) strcpy_s(arg3, argv[3]); // Process .lnk files std::wstring executable, arguments, workingDir; if(ResolveShortcut(GuiGetWindowHandle(), StringUtils::Utf8ToUtf16(arg1).c_str(), executable, arguments, workingDir)) { auto resolvedPathUtf8 = StringUtils::Utf16ToUtf8(executable); dprintf(QT_TRANSLATE_NOOP("DBG", "Resolved shortcut \"%s\" -> \"%s\"\n"), arg1, resolvedPathUtf8.c_str()); strcpy_s(arg1, resolvedPathUtf8.c_str()); // Assign a command line from the shortcut if it wasn't overwritten if(argc <= 2) { auto resolvedArgsUtf8 = StringUtils::Utf16ToUtf8(arguments); dprintf(QT_TRANSLATE_NOOP("DBG", "Resolved arguments from shortcut \"%s\"\n"), resolvedArgsUtf8.c_str()); strcpy_s(arg2, resolvedArgsUtf8.c_str()); } // Assign a working directory from the shortcut if it wasn't overwritten if(argc <= 3) { auto resolvedWorkingDirUtf8 = StringUtils::Utf16ToUtf8(workingDir); dprintf(QT_TRANSLATE_NOOP("DBG", "Resolved working directory from shortcut \"%s\"\n"), resolvedWorkingDirUtf8.c_str()); strcpy_s(arg3, resolvedWorkingDirUtf8.c_str()); } } if(!FileExists(arg1)) { dputs(QT_TRANSLATE_NOOP("DBG", "File does not exist!")); return false; } auto arg1w = StringUtils::Utf8ToUtf16(arg1); Handle hFile = CreateFileW(arg1w.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); if(hFile == INVALID_HANDLE_VALUE) { dputs(QT_TRANSLATE_NOOP("DBG", "Could not open file!")); return false; } GetFileNameFromHandle(hFile, arg1, _countof(arg1)); //get full path of the file dprintf(QT_TRANSLATE_NOOP("DBG", "Debugging: %s\n"), arg1); hFile.Close(); auto arch = GetPeArch(arg1w.c_str()); // Translate Any CPU to the actual architecture if(arch == PeArch::DotnetAnyCpu) arch = ArchValue(IsWow64() ? PeArch::Dotnet64 : PeArch::Dotnet86, PeArch::Dotnet64); // Make sure the architecture is right switch(arch) { case PeArch::Invalid: dputs(QT_TRANSLATE_NOOP("DBG", "Invalid PE file!")); return false; #ifdef _WIN64 case PeArch::Native86: case PeArch::Dotnet86: case PeArch::DotnetAnyCpuPrefer32: dputs(QT_TRANSLATE_NOOP("DBG", "Use x32dbg to debug this file!")); #else // x86 case PeArch::Native64: case PeArch::Dotnet64: dputs(QT_TRANSLATE_NOOP("DBG", "Use x64dbg to debug this file!")); #endif // _WIN64 return false; default: break; } // Default to the application folder char currentfolder[deflen] = ""; strcpy_s(currentfolder, arg1); int len = (int)strlen(currentfolder); while(currentfolder[len] != '\\' && len != 0) len--; currentfolder[len] = 0; // Allow the user to overwrite the working directory if(DirExists(arg3)) strcpy_s(currentfolder, arg3); static INIT_STRUCT init; init.exe = arg1; init.commandline = arg2; init.currentfolder = currentfolder; dbgcreatedebugthread(&init); return true; } bool cbDebugStop(int argc, char* argv[]) { EXCLUSIVE_ACQUIRE(LockDebugStartStop); if(!hDebugLoopThread) return false; // Give the plugins a chance to perform clean-up PLUG_CB_STOPPINGDEBUG stoppingInfo; stoppingInfo.reserved = 0; plugincbcall(CB_STOPPINGDEBUG, &stoppingInfo); auto hDebugLoopThreadCopy = hDebugLoopThread; hDebugLoopThread = nullptr; // HACK: TODO: Don't kill script on debugger ending a process //scriptreset(); //reset the currently-loaded script _dbg_animatestop(); StopDebug(); //history HistoryClear(); DWORD BeginTick = GetTickCount(); bool shownWarning = false; while(true) { switch(WaitForSingleObject(hDebugLoopThreadCopy, 100)) { case WAIT_OBJECT_0: CloseHandle(hDebugLoopThreadCopy); return true; case WAIT_TIMEOUT: { unlock(WAITID_RUN); DWORD CurrentTick = GetTickCount(); DWORD TimeElapsed = CurrentTick - BeginTick; if(TimeElapsed >= 10000) { if(!shownWarning) { shownWarning = true; dputs(QT_TRANSLATE_NOOP("DBG", "Finalizing the debugger thread took more than 10 seconds. This can happen if you are loading large symbol files or saving a large database.")); } if(IsFileBeingDebugged() || TimeElapsed >= 100000) { dputs(QT_TRANSLATE_NOOP("DBG", "The debuggee did not stop after 10 seconds of requesting termination. The debugger state may be corrupted. It is recommended to restart x64dbg.")); DbSave(DbLoadSaveType::All); TerminateThread(hDebugLoopThreadCopy, 1); // TODO: this will lose state and cause possible corruption if a critical section is still owned CloseHandle(hDebugLoopThreadCopy); return false; } } if(TimeElapsed >= 300) TerminateProcess(fdProcessInfo->hProcess, -1); } break; case WAIT_FAILED: String error = stringformatinline(StringUtils::sprintf("{winerror@%x}", GetLastError())); dprintf_untranslated("WAIT_FAILED, GetLastError() = %s\n", error.c_str()); return false; } } } bool cbDebugAttach(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint pid = 0; if(!valfromstring(argv[1], &pid, false)) return false; EXCLUSIVE_ACQUIRE(LockDebugStartStop); cbDebugStop(argc, argv); ASSERT_TRUE(hDebugLoopThread == nullptr); Handle hProcess = TitanOpenProcess(PROCESS_ALL_ACCESS, false, (DWORD)pid); if(!hProcess) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not open process %X!\n"), DWORD(pid)); return false; } BOOL debuggerPresent = FALSE; if(CheckRemoteDebuggerPresent(hProcess, &debuggerPresent) && debuggerPresent) { dputs(QT_TRANSLATE_NOOP("DBG", "Process is already being debugged!")); return false; } BOOL wow64 = false, meow64 = false; if(!IsWow64Process(hProcess, &wow64) || !IsWow64Process(GetCurrentProcess(), &meow64)) { dputs(QT_TRANSLATE_NOOP("DBG", "IsWow64Process failed!")); return false; } if(meow64 != wow64) { #ifdef _WIN64 dputs(QT_TRANSLATE_NOOP("DBG", "Use x32dbg to debug this process!")); #else dputs(QT_TRANSLATE_NOOP("DBG", "Use x64dbg to debug this process!")); #endif // _WIN64 return false; } if(!GetFileNameFromProcessHandle(hProcess, szDebuggeePath, _countof(szDebuggeePath))) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not get module filename %X!\n"), DWORD(pid)); return false; } if(argc > 2) //event handle (JIT) { duint eventHandle = 0; if(!valfromstring(argv[2], &eventHandle, false)) return false; if(eventHandle) dbgsetattachevent((HANDLE)eventHandle); } if(argc > 3) //thread id to resume (PLMDebug) { duint tid = 0; if(!valfromstring(argv[3], &tid, false)) return false; if(tid) dbgsetresumetid(tid); } static INIT_STRUCT init; init.attach = true; init.pid = (DWORD)pid; dbgcreatedebugthread(&init); return true; } static bool dbgdetachDisableAllBreakpoints(const BREAKPOINT* bp) { if(bp->enabled) { if(bp->type == BPNORMAL) DeleteBPX(bp->addr); else if(bp->type == BPMEMORY) RemoveMemoryBPX(bp->addr, 0); else if(bp->type == BPHARDWARE && TITANDRXVALID(bp->titantype)) DeleteHardwareBreakPoint(TITANGETDRX(bp->titantype)); } return true; } bool cbDebugDetach(int argc, char* argv[]) { PLUG_CB_DETACH detachInfo; detachInfo.fdProcessInfo = fdProcessInfo; plugincbcall(CB_DETACH, &detachInfo); BpEnumAll(dbgdetachDisableAllBreakpoints); // Disable all software breakpoints before detaching. if(!DetachDebuggerEx(fdProcessInfo->dwProcessId)) dputs(QT_TRANSLATE_NOOP("DBG", "DetachDebuggerEx failed...")); else dputs(QT_TRANSLATE_NOOP("DBG", "Detached!")); _dbg_animatestop(); // Stop animating unlock(WAITID_RUN); // run to resume the debug loop if necessary return true; } bool cbDebugRun(int argc, char* argv[]) { skipInt3Stepping(1, argv); return cbDebugRunInternal(argc, argv, history_clear); } bool cbDebugErun(int argc, char* argv[]) { if(!dbgisrunning()) dbgsetskipexceptions(true); else { dbgsetskipexceptions(false); return true; } return cbDebugRunInternal(argc, argv, history_clear); } bool cbDebugSerun(int argc, char* argv[]) { cbDebugContinue(argc, argv); return cbDebugRunInternal(argc, argv, history_clear); } bool cbDebugPause(int argc, char* argv[]) { if(_dbg_isanimating()) { _dbg_animatestop(); // pause when animating return true; } if(dbgtraceactive()) { dbgforcebreaktrace(); // pause when tracing return true; } if(dbgstepactive()) { dbgforcebreakstep(); // pause when stepping (out/user/system) return true; } if(!DbgIsDebugging()) { dputs(QT_TRANSLATE_NOOP("DBG", "Not debugging!")); return false; } if(!dbgisrunning()) { dputs(QT_TRANSLATE_NOOP("DBG", "Program is not running")); return false; } // Interesting behavior found by JustMagic, if the active thread is suspended pause would fail auto previousSuspendCount = SuspendThread(hActiveThread); if(previousSuspendCount != 0) { if(previousSuspendCount != -1) ResumeThread(hActiveThread); dputs(QT_TRANSLATE_NOOP("DBG", "The active thread is suspended, switch to a running thread to pause the process")); // TODO: perhaps inject an INT3 in the process as an alternative to failing? return false; } duint CIP = GetContextDataEx(hActiveThread, UE_CIP); if(!SetBPX(CIP, UE_BREAKPOINT, cbPauseBreakpoint)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (SetBPX)\n"), CIP); if(ResumeThread(hActiveThread) == -1) { dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread")); return false; } return false; } //WORKAROUND: If a program is stuck in NtUserGetMessage (GetMessage was called), this //will send a WM_NULL to stop the waiting. This only works if the message is not filtered. //OllyDbg also does this in a similar way. PostThreadMessageA(ThreadGetId(hActiveThread), WM_NULL, 0, 0); if(ResumeThread(hActiveThread) == -1) { dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread")); return false; } return true; } bool cbDebugContinue(int argc, char* argv[]) { if(argc < 2) { dbgsetcontinuestatus(DBG_CONTINUE); dputs(QT_TRANSLATE_NOOP("DBG", "Exception will be swallowed")); } else { dbgsetcontinuestatus(DBG_EXCEPTION_NOT_HANDLED); dputs(QT_TRANSLATE_NOOP("DBG", "Exception will be thrown in the program")); } return true; } bool cbDebugStepInto(int argc, char* argv[]) { duint steprepeat = 1; if(argc > 1 && !valfromstring(argv[1], &steprepeat, false)) return false; if(!steprepeat) //nothing to be done return true; if(skipInt3Stepping(1, argv) && !--steprepeat) return true; StepIntoWow64(cbStep); dbgsetsteprepeat(true, steprepeat); return cbDebugRunInternal(1, argv, steprepeat == 1 ? history_record : history_clear); } bool cbDebugeStepInto(int argc, char* argv[]) { dbgsetskipexceptions(true); return cbDebugStepInto(argc, argv); } bool cbDebugseStepInto(int argc, char* argv[]) { cbDebugContinue(argc, argv); return cbDebugStepInto(argc, argv); } static bool IsRepeated(const Zydis & zydis) { // https://www.felixcloutier.com/x86/rep:repe:repz:repne:repnz // TODO: allow extracting the affected range switch(zydis.GetId()) { // INS case ZYDIS_MNEMONIC_INSB: case ZYDIS_MNEMONIC_INSW: case ZYDIS_MNEMONIC_INSD: // OUTS case ZYDIS_MNEMONIC_OUTSB: case ZYDIS_MNEMONIC_OUTSW: case ZYDIS_MNEMONIC_OUTSD: // MOVS case ZYDIS_MNEMONIC_MOVSB: case ZYDIS_MNEMONIC_MOVSW: case ZYDIS_MNEMONIC_MOVSD: case ZYDIS_MNEMONIC_MOVSQ: // LODS case ZYDIS_MNEMONIC_LODSB: case ZYDIS_MNEMONIC_LODSW: case ZYDIS_MNEMONIC_LODSD: case ZYDIS_MNEMONIC_LODSQ: // STOS case ZYDIS_MNEMONIC_STOSB: case ZYDIS_MNEMONIC_STOSW: case ZYDIS_MNEMONIC_STOSD: case ZYDIS_MNEMONIC_STOSQ: // CMPS case ZYDIS_MNEMONIC_CMPSB: case ZYDIS_MNEMONIC_CMPSW: case ZYDIS_MNEMONIC_CMPSD: case ZYDIS_MNEMONIC_CMPSQ: // SCAS case ZYDIS_MNEMONIC_SCASB: case ZYDIS_MNEMONIC_SCASW: case ZYDIS_MNEMONIC_SCASD: case ZYDIS_MNEMONIC_SCASQ: return (zydis.GetInstr()->attributes & (ZYDIS_ATTRIB_HAS_REP | ZYDIS_ATTRIB_HAS_REPZ | ZYDIS_ATTRIB_HAS_REPNZ)) != 0; } return false; } bool cbDebugStepOver(int argc, char* argv[]) { duint steprepeat = 1; if(argc > 1 && !valfromstring(argv[1], &steprepeat, false)) return false; if(!steprepeat) //nothing to be done return true; if(skipInt3Stepping(1, argv) && !--steprepeat) return true; auto history = history_clear; if(steprepeat == 1) { Zydis zydis; disasm(zydis, GetContextDataEx(hActiveThread, UE_CIP)); if(!zydis.IsBranchType(Zydis::BTCallSem) && !IsRepeated(zydis)) history = history_record; } StepOverWrapper(cbStep); dbgsetsteprepeat(false, steprepeat); return cbDebugRunInternal(1, argv, history); } bool cbDebugeStepOver(int argc, char* argv[]) { dbgsetskipexceptions(true); return cbDebugStepOver(1, argv); } bool cbDebugseStepOver(int argc, char* argv[]) { cbDebugContinue(argc, argv); return cbDebugStepOver(argc, argv); } bool cbDebugStepOut(int argc, char* argv[]) { duint steprepeat = 1; if(argc > 1 && !valfromstring(argv[1], &steprepeat, false)) return false; if(!steprepeat) //nothing to be done return true; gRtrPreviousCSP = GetContextDataEx(hActiveThread, UE_CSP); StepOverWrapper(cbRtrStep); dbgsetsteprepeat(false, steprepeat); return cbDebugRunInternal(1, argv, history_clear); } bool cbDebugeStepOut(int argc, char* argv[]) { dbgsetskipexceptions(true); return cbDebugStepOut(argc, argv); } bool cbDebugSkip(int argc, char* argv[]) { duint skiprepeat = 1; if(argc > 1 && !valfromstring(argv[1], &skiprepeat, false)) return false; // Because an int3 causes CIP to be advanced we start disassembling from there duint cip; if(isInt3Exception()) cip = (duint)getLastExceptionInfo().ExceptionRecord.ExceptionAddress; else cip = GetContextDataEx(hActiveThread, UE_CIP); dbgsetcontinuestatus(DBG_CONTINUE); //swallow the exception BASIC_INSTRUCTION_INFO basicinfo; while(skiprepeat--) { disasmfast(cip, &basicinfo); cip += basicinfo.size; dbgtraceexecute(cip); } SetContextDataEx(hActiveThread, UE_CIP, cip); DebugUpdateGuiAsync(cip, false); //update GUI return true; } bool cbInstrInstrUndo(int argc, char* argv[]) { HistoryRestore(); GuiUpdateAllViews(); return true; } bool cbDebugStepUserInto(int argc, char* argv[]) { StepIntoUser(cbStep); return cbDebugRunInternal(1, argv, history_clear); } bool cbDebugStepSystemInto(int argc, char* argv[]) { StepIntoSystem(cbStep); return cbDebugRunInternal(1, argv, history_clear); }
C/C++
x64dbg-development/src/dbg/commands/cmd-debug-control.h
#pragma once #include "command.h" enum HistoryAction { history_clear, history_record, }; bool cbDebugRunInternal(int argc, char* argv[], HistoryAction history); bool cbDebugInit(int argc, char* argv[]); bool cbDebugStop(int argc, char* argv[]); bool cbDebugAttach(int argc, char* argv[]); bool cbDebugDetach(int argc, char* argv[]); bool cbDebugRun(int argc, char* argv[]); bool cbDebugErun(int argc, char* argv[]); bool cbDebugSerun(int argc, char* argv[]); bool cbDebugPause(int argc, char* argv[]); bool cbDebugContinue(int argc, char* argv[]); bool cbDebugStepInto(int argc, char* argv[]); bool cbDebugeStepInto(int argc, char* argv[]); bool cbDebugseStepInto(int argc, char* argv[]); bool cbDebugStepOver(int argc, char* argv[]); bool cbDebugeStepOver(int argc, char* argv[]); bool cbDebugseStepOver(int argc, char* argv[]); bool cbDebugStepOut(int argc, char* argv[]); bool cbDebugeStepOut(int argc, char* argv[]); bool cbDebugSkip(int argc, char* argv[]); bool cbInstrInstrUndo(int argc, char* argv[]); bool cbDebugStepUserInto(int argc, char* argv[]); bool cbDebugStepSystemInto(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-general-purpose.cpp
#include "cmd-general-purpose.h" #include "value.h" #include "memory.h" #include "variable.h" #include "_scriptapi_stack.h" #include "debugger.h" #include <intrin.h> static bool ReadWriteVariable(const char* varname, const std::function<bool(duint*, int)> & callback) { duint set_value = 0; bool isvar; int varsize; if(!valfromstring(varname, &set_value, true, true, &varsize, &isvar)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid variable \"%s\"\n"), varname); return false; } bool retVal = callback(&set_value, varsize); if(retVal != true) return retVal; duint temp = 0; valfromstring(varname, &temp, true, true, 0, nullptr, 0); //there is no return check on this because the destination might not exist yet if(!isvar) isvar = vargettype(varname, 0); if(!isvar || !valtostring(varname, set_value, true)) { duint value; if(valfromstring(varname, &value)) //if the var is a value already it's an invalid destination { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid variable \"%s\"\n"), varname); return false; } varnew(varname, set_value, VAR_USER); } return true; } bool cbInstrInc(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return cmddirectexec(StringUtils::sprintf("%s++", argv[1]).c_str()); } bool cbInstrDec(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return cmddirectexec(StringUtils::sprintf("%s--", argv[1]).c_str()); } bool cbInstrAdd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s+=%s", argv[1], argv[2]).c_str()); } bool cbInstrSub(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s-=%s", argv[1], argv[2]).c_str()); } bool cbInstrMul(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s*=%s", argv[1], argv[2]).c_str()); } bool cbInstrDiv(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s/=%s", argv[1], argv[2]).c_str()); } bool cbInstrAnd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s&=%s", argv[1], argv[2]).c_str()); } bool cbInstrOr(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s|=%s", argv[1], argv[2]).c_str()); } bool cbInstrXor(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; return cmddirectexec(StringUtils::sprintf("%s^=%s", argv[1], argv[2]).c_str()); } bool cbInstrNeg(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return cmddirectexec(StringUtils::sprintf("%s=-%s", argv[1], argv[1]).c_str()); } bool cbInstrNot(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return cmddirectexec(StringUtils::sprintf("%s=~%s", argv[1], argv[1]).c_str()); } bool cbInstrBswap(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return ReadWriteVariable(argv[1], [](duint * value, int size) { if(size == 2) *value = _byteswap_ushort((uint16) * value); else if(size == 4) *value = _byteswap_ulong((uint32) * value); #ifdef _WIN64 else if(size == 8) *value = _byteswap_uint64(*value); #endif //_WIN64 else if(size != 1) { dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported.")); return false; } return true; }); } bool cbInstrRol(int argc, char* argv[]) { duint value2; if(IsArgumentsLessThan(argc, 3) || !valfromstring(argv[2], &value2, false)) return false; return ReadWriteVariable(argv[1], [value2](duint * value, int size) { if(size == 1) *value = _rotl8((uint8_t) * value, value2 % 8); else if(size == 2) *value = _rotl16((uint16) * value, value2 % 16); else if(size == 4) *value = _rotl((uint32) * value, value2 % 32); #ifdef _WIN64 else if(size == 8) *value = _rotl64(*value, value2 % 64); #endif //_WIN64 else { dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported.")); return false; } return true; }); } bool cbInstrRor(int argc, char* argv[]) { duint value2; if(IsArgumentsLessThan(argc, 3) || !valfromstring(argv[2], &value2, false)) return false; return ReadWriteVariable(argv[1], [value2](duint * value, int size) { if(size == 1) *value = _rotr8((uint8_t) * value, value2 % 8); else if(size == 2) *value = _rotr16((uint16) * value, value2 % 16); else if(size == 4) *value = _rotr((uint32) * value, value2 % 32); #ifdef _WIN64 else if(size == 8) *value = _rotr64(*value, value2 % 64); #endif //_WIN64 else { dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported.")); return false; } return true; }); } bool cbInstrShl(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; //SHL and SAL have the same semantics return cmddirectexec(StringUtils::sprintf("%s<<=%s", argv[1], argv[2]).c_str()); } bool cbInstrShr(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; auto oldType = valuesignedcalc(); valuesetsignedcalc(false); //SHR is unsigned auto result = cmddirectexec(StringUtils::sprintf("%s>>=%s", argv[1], argv[2]).c_str()); valuesetsignedcalc(oldType); return result; } bool cbInstrSar(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; auto oldType = valuesignedcalc(); valuesetsignedcalc(true); //SAR is signed auto result = cmddirectexec(StringUtils::sprintf("%s>>=%s", argv[1], argv[2]).c_str()); valuesetsignedcalc(oldType); return result; } bool cbInstrPush(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint value; if(!valfromstring(argv[1], &value)) { dprintf(QT_TRANSLATE_NOOP("DBG", "invalid argument \"%s\"!\n"), argv[1]); return false; } Script::Stack::Push(value); duint csp = GetContextDataEx(hActiveThread, UE_CSP); DebugUpdateStack(csp, csp); GuiUpdateRegisterView(); return true; } bool cbInstrPop(int argc, char* argv[]) { duint value = Script::Stack::Pop(); duint csp = GetContextDataEx(hActiveThread, UE_CSP); DebugUpdateStack(csp, csp); GuiUpdateRegisterView(); if(argc > 1) { if(!valtostring(argv[1], value, false)) return false; } return true; } bool cbInstrTest(int argc, char* argv[]) { //TODO: test if(IsArgumentsLessThan(argc, 3)) return false; duint arg1 = 0; if(!valfromstring(argv[1], &arg1, false)) return false; duint arg2 = 0; if(!valfromstring(argv[2], &arg2, false)) return false; duint ezflag; duint bsflag = 0; if(!(arg1 & arg2)) ezflag = 1; else ezflag = 0; varset("$_EZ_FLAG", ezflag, true); varset("$_BS_FLAG", bsflag, true); //dprintf(QT_TRANSLATE_NOOP("DBG", "$_EZ_FLAG=%d, $_BS_FLAG=%d\n"), ezflag, bsflag); return true; } bool cbInstrCmp(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint arg1 = 0; if(!valfromstring(argv[1], &arg1, false)) return false; duint arg2 = 0; if(!valfromstring(argv[2], &arg2, false)) return false; duint ezflag; duint bsflag; if(arg1 == arg2) ezflag = 1; else ezflag = 0; if(valuesignedcalc()) //signed comparision { if((dsint)arg1 < (dsint)arg2) bsflag = 0; else bsflag = 1; } else //unsigned comparision { if(arg1 > arg2) bsflag = 1; else bsflag = 0; } varset("$_EZ_FLAG", ezflag, true); varset("$_BS_FLAG", bsflag, true); //dprintf(QT_TRANSLATE_NOOP("DBG", "$_EZ_FLAG=%d, $_BS_FLAG=%d\n"), ezflag, bsflag); return true; } bool cbInstrMov(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; String srcText = argv[2]; if(srcText[0] == '#' && srcText[srcText.length() - 1] == '#') //handle mov addr, #DATA# { //do some checks on the data String dataText = srcText.substr(1, srcText.length() - 2); std::vector<unsigned char> data; if(!StringUtils::FromCompressedHex(dataText, data)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid hex string \"%s\"\n"), dataText.c_str()); return false; } //Check the destination duint dest; if(!valfromstring(argv[1], &dest) || !MemIsValidReadPtr(dest)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid destination \"%s\"\n"), argv[1]); return false; } //Move data to destination if(!MemPatch(dest, data.data(), data.size())) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to write to %p\n"), dest); return false; } GuiUpdateAllViews(); //refresh disassembly/dump/etc return true; } else { duint set_value = 0; if(!valfromstring(srcText.c_str(), &set_value)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid src \"%s\"\n"), argv[2]); return false; } bool isvar = false; duint temp = 0; valfromstring(argv[1], &temp, true, true, 0, &isvar, 0); //there is no return check on this because the destination might not exist yet if(!isvar) isvar = vargettype(argv[1], 0); if(!isvar || !valtostring(argv[1], set_value, true)) { duint value; if(valfromstring(argv[1], &value)) //if the var is a value already it's an invalid destination { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid dest \"%s\"\n"), argv[1]); return false; } varnew(argv[1], set_value, VAR_USER); } } return true; } bool cbInstrMovdqu(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; String dstText = argv[1]; String srcText = argv[2]; duint address = 0; DWORD registerindex = 0; if(srcText[0] == '[' && srcText[srcText.length() - 1] == ']' && _memicmp(dstText.c_str(), "xmm", 3) == 0) { char newValue[16]; // movdqu xmm0, [address] dstText = dstText.substr(3); srcText = srcText.substr(1, srcText.size() - 2); DWORD registerindex; bool found = true; registerindex = atoi(dstText.c_str()); if(registerindex < ArchValue(8, 16)) { registerindex += UE_XMM0; } else { goto InvalidDest; } if(!valfromstring(srcText.c_str(), &address)) { goto InvalidSrc; } if(!MemRead(address, newValue, 16)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read (all) memory...")); return false; } SetContextDataEx(hActiveThread, registerindex, (ULONG_PTR)newValue); GuiUpdateAllViews(); //refresh disassembly/dump/etc return true; } else if(dstText[0] == '[' && dstText[dstText.length() - 1] == ']' && _memicmp(srcText.c_str(), "xmm", 3) == 0) { // movdqu [address], xmm0 srcText = srcText.substr(3); dstText = dstText.substr(1, dstText.size() - 2); DWORD registerindex; bool found = true; registerindex = atoi(srcText.c_str()); if(registerindex >= ArchValue(8, 16)) { goto InvalidSrc; } if(!valfromstring(dstText.c_str(), &address) || !MemIsValidReadPtr(address)) { goto InvalidDest; } REGDUMP registers; if(!DbgGetRegDumpEx(&registers, sizeof(registers))) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read register context...")); return false; } if(!MemWrite(address, &registers.regcontext.XmmRegisters[registerindex], 16)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to write to %p\n"), address); return false; } GuiUpdateAllViews(); //refresh disassembly/dump/etc return true; } else if(_memicmp(srcText.c_str(), "xmm", 3) == 0 && _memicmp(dstText.c_str(), "xmm", 3) == 0) { // movdqu xmm0, xmm1 srcText = srcText.substr(3); dstText = dstText.substr(3); DWORD registerindex[2]; bool found = true; registerindex[0] = atoi(srcText.c_str()); if(registerindex[0] >= ArchValue(8, 16)) { goto InvalidSrc; } registerindex[1] = atoi(dstText.c_str()); if(registerindex[1] < ArchValue(8, 16)) { registerindex[1] += UE_XMM0; } else { goto InvalidDest; } REGDUMP registers; if(!DbgGetRegDumpEx(&registers, sizeof(registers))) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read register context...")); return false; } SetContextDataEx(hActiveThread, registerindex[1], (ULONG_PTR)&registers.regcontext.XmmRegisters[registerindex[0]]); GuiUpdateAllViews(); //refresh disassembly/dump/etc return true; } else { dputs(QT_TRANSLATE_NOOP("DBG", "Usage: movdqu xmm0, [address] / movdqu [address], xmm0 / movdqu xmm0, xmm1")); return false; } InvalidSrc: dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid src \"%s\"\n"), argv[2]); return false; InvalidDest: dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid dest \"%s\"\n"), argv[1]); return false; }
C/C++
x64dbg-development/src/dbg/commands/cmd-general-purpose.h
#pragma once #include "command.h" bool cbInstrInc(int argc, char* argv[]); bool cbInstrDec(int argc, char* argv[]); bool cbInstrAdd(int argc, char* argv[]); bool cbInstrSub(int argc, char* argv[]); bool cbInstrMul(int argc, char* argv[]); bool cbInstrDiv(int argc, char* argv[]); bool cbInstrAnd(int argc, char* argv[]); bool cbInstrOr(int argc, char* argv[]); bool cbInstrXor(int argc, char* argv[]); bool cbInstrNeg(int argc, char* argv[]); bool cbInstrNot(int argc, char* argv[]); bool cbInstrBswap(int argc, char* argv[]); bool cbInstrRol(int argc, char* argv[]); bool cbInstrRor(int argc, char* argv[]); bool cbInstrShl(int argc, char* argv[]); bool cbInstrShr(int argc, char* argv[]); bool cbInstrSar(int argc, char* argv[]); bool cbInstrPush(int argc, char* argv[]); bool cbInstrPop(int argc, char* argv[]); bool cbInstrTest(int argc, char* argv[]); bool cbInstrCmp(int argc, char* argv[]); bool cbInstrMov(int argc, char* argv[]); bool cbInstrMovdqu(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-gui.cpp
#include "cmd-gui.h" #include "debugger.h" #include "console.h" #include "memory.h" #include "recursiveanalysis.h" #include "function.h" #include "stringformat.h" #include "value.h" #include "variable.h" bool cbDebugDisasm(int argc, char* argv[]) { duint addr = 0; if(argc > 1) { if(!valfromstring(argv[1], &addr)) addr = GetContextDataEx(hActiveThread, UE_CIP); } else { addr = GetContextDataEx(hActiveThread, UE_CIP); } DebugUpdateGui(addr, false); GuiShowCpu(); GuiFocusView(GUI_DISASSEMBLY); return true; } bool cbDebugDump(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]); return false; } if(argc > 2) { duint index = 0; if(!valfromstring(argv[2], &index)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[2]); return false; } GuiDumpAtN(addr, int(index)); } else { ACTIVEVIEW activeView; GuiGetActiveView(&activeView); int dumpIndex; if(sscanf_s(activeView.title, "Dump %d", &dumpIndex) == 1) GuiDumpAtN(addr, dumpIndex); else GuiDumpAt(addr); } GuiShowCpu(); GuiFocusView(GUI_DUMP); return true; } bool cbDebugStackDump(int argc, char* argv[]) { duint addr = 0; if(argc < 2) addr = GetContextDataEx(hActiveThread, UE_CSP); else if(!valfromstring(argv[1], &addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]); return false; } duint csp = GetContextDataEx(hActiveThread, UE_CSP); duint size = 0; duint base = MemFindBaseAddr(csp, &size); if(base && addr >= base && addr < (base + size)) DebugUpdateStack(addr, csp, true); else dputs(QT_TRANSLATE_NOOP("DBG", "Invalid stack address!")); GuiShowCpu(); GuiFocusView(GUI_STACK); return true; } bool cbDebugMemmapdump(int argc, char* argv[]) { if(argc < 2) return false; duint addr; if(!valfromstring(argv[1], &addr, false) || !MemIsValidReadPtr(addr, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]); return false; } GuiSelectInMemoryMap(addr); GuiFocusView(GUI_MEMMAP); return true; } bool cbInstrGraph(int argc, char* argv[]) { auto options = argc > 2 ? argv[2] : ""; auto force = !!strstr(options, "force"); auto silent = !!strstr(options, "silent"); duint entry; if(argc < 2 || !valfromstring(argv[1], &entry)) entry = GetContextDataEx(hActiveThread, UE_CIP); duint start, size, sel = entry; if(FunctionGet(entry, &start)) entry = start; auto base = MemFindBaseAddr(entry, &size); if(!base || !MemIsValidReadPtr(entry)) { if(!silent) dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address %p!\n"), entry); return false; } auto curEntry = GuiGraphAt(sel); if(curEntry) entry = curEntry; if(!curEntry || force) { auto modbase = ModBaseFromAddr(base); if(modbase) base = modbase, size = ModSizeFromAddr(modbase); RecursiveAnalysis analysis(base, size, entry, true); analysis.Analyse(); auto graph = analysis.GetFunctionGraph(entry); if(!graph) { if(!silent) dputs(QT_TRANSLATE_NOOP("DBG", "No graph generated...")); return false; } auto graphList = graph->ToGraphList(); if(!GuiLoadGraph(&graphList, sel)) return false; } GuiUpdateAllViews(); if(!silent) GuiFocusView(GUI_GRAPH); return true; } bool cbInstrEnableGuiUpdate(int argc, char* argv[]) { if(GuiIsUpdateDisabled()) GuiUpdateEnable(false); duint value; //argv[1]=="1" = update GUI if(argc > 1 && valfromstring(argv[1], &value) && value == 1) GuiUpdateAllViews(); return true; } bool cbInstrDisableGuiUpdate(int argc, char* argv[]) { if(!GuiIsUpdateDisabled()) GuiUpdateDisable(); return true; } bool cbDebugSetfreezestack(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; bool freeze = *argv[1] != '0'; dbgsetfreezestack(freeze); if(freeze) dputs(QT_TRANSLATE_NOOP("DBG", "Stack is now frozen\n")); else dputs(QT_TRANSLATE_NOOP("DBG", "Stack is now unfrozen\n")); return true; } static bool bRefinit = false; bool cbInstrRefinit(int argc, char* argv[]) { auto title = argc > 1 ? stringformatinline(argv[1]) : GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Script")); GuiReferenceInitialize(title.c_str()); GuiReferenceAddColumn(sizeof(duint) * 2, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Data"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); bRefinit = true; return true; } bool cbInstrRefadd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!bRefinit) cbInstrRefinit(argc, argv); int index = GuiReferenceGetRowCount(); GuiReferenceSetRowCount(index + 1); char addr_text[32] = ""; sprintf_s(addr_text, "%p", addr); GuiReferenceSetCellContent(index, 0, addr_text); GuiReferenceSetCellContent(index, 1, stringformatinline(argv[2]).c_str()); GuiReferenceReloadData(); return true; } bool cbInstrRefGet(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint row; if(!valfromstring(argv[1], &row, false)) return false; auto content = GuiReferenceGetCellContent(int(row), 0); duint addr = 0; valfromstring(content, &addr, false); varset("$result", addr, false); BridgeFree(content); return true; } bool cbInstrEnableLog(int argc, char* argv[]) { GuiEnableLog(); return true; } bool cbInstrDisableLog(int argc, char* argv[]) { GuiDisableLog(); return true; } bool cbInstrAddFavTool(int argc, char* argv[]) { // filename, description if(IsArgumentsLessThan(argc, 2)) return false; if(argc == 2) GuiAddFavouriteTool(argv[1], nullptr); else GuiAddFavouriteTool(argv[1], argv[2]); return true; } bool cbInstrAddFavCmd(int argc, char* argv[]) { // command, shortcut if(IsArgumentsLessThan(argc, 2)) return false; if(argc == 2) GuiAddFavouriteCommand(argv[1], nullptr); else GuiAddFavouriteCommand(argv[1], argv[2]); return true; } bool cbInstrSetFavToolShortcut(int argc, char* argv[]) { // filename, shortcut if(IsArgumentsLessThan(argc, 3)) return false; GuiSetFavouriteToolShortcut(argv[1], argv[2]); return true; } bool cbInstrFoldDisassembly(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint start, length; if(!valfromstring(argv[1], &start)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid argument 1 : %s\n"), argv[1]); return false; } if(!valfromstring(argv[2], &length)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid argument 2 : %s\n"), argv[2]); return false; } GuiFoldDisassembly(start, length); return true; } bool cbDebugUpdateTitle(int argc, char* argv[]) { duint addr = 0; if(argc > 1) { if(!valfromstring(argv[1], &addr)) addr = GetContextDataEx(hActiveThread, UE_CIP); } else { addr = GetContextDataEx(hActiveThread, UE_CIP); } DebugUpdateTitleAsync(addr, false); return true; } bool cbShowReferences(int argc, char* argv[]) { GuiShowReferences(); return true; } bool cbSymbolsFollow(int argc, char* argv[]) { if(argc < 2) return false; duint addr; if(!valfromstring(argv[1], &addr, false) || !MemIsValidReadPtr(addr, true)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]); return false; } duint base = ModBaseFromAddr(addr); if(!base) { dprintf(QT_TRANSLATE_NOOP("DBG", "Address \"%s\" doesn't belong to any module!\n"), argv[1]); return false; } GuiSelectInSymbolsTab(base); GuiFocusView(GUI_SYMMOD); return true; } bool cbGotoTrace(int argc, char* argv[]) { duint index = 0; if(IsArgumentsLessThan(argc, 2) || !valfromstring(argv[1], &index, false)) return false; GuiGotoTrace(index); GuiShowTrace(); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-gui.h
#pragma once #include "command.h" bool cbDebugDisasm(int argc, char* argv[]); bool cbDebugDump(int argc, char* argv[]); bool cbDebugStackDump(int argc, char* argv[]); bool cbDebugMemmapdump(int argc, char* argv[]); bool cbInstrGraph(int argc, char* argv[]); bool cbInstrEnableGuiUpdate(int argc, char* argv[]); bool cbInstrDisableGuiUpdate(int argc, char* argv[]); bool cbDebugSetfreezestack(int argc, char* argv[]); bool cbInstrRefinit(int argc, char* argv[]); bool cbInstrRefadd(int argc, char* argv[]); bool cbInstrRefGet(int argc, char* argv[]); bool cbInstrEnableLog(int argc, char* argv[]); bool cbInstrDisableLog(int argc, char* argv[]); bool cbInstrAddFavTool(int argc, char* argv[]); bool cbInstrAddFavCmd(int argc, char* argv[]); bool cbInstrSetFavToolShortcut(int argc, char* argv[]); bool cbInstrFoldDisassembly(int argc, char* argv[]); bool cbDebugUpdateTitle(int argc, char* argv[]); bool cbShowReferences(int argc, char* argv[]); bool cbSymbolsFollow(int argc, char* argv[]); bool cbGotoTrace(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-memory-operations.cpp
#include "cmd-memory-operations.h" #include "console.h" #include "debugger.h" #include "memory.h" #include "variable.h" #include "filehelper.h" #include "value.h" #include "stringformat.h" #include "comment.h" bool cbDebugAlloc(int argc, char* argv[]) { duint size = 0x1000, addr = 0; if(argc > 1) if(!valfromstring(argv[1], &size, false)) return false; if(argc > 2) if(!valfromstring(argv[2], &addr, false)) return false; duint mem = (duint)MemAllocRemote(addr, size); if(!mem) dputs(QT_TRANSLATE_NOOP("DBG", "VirtualAllocEx failed")); else dprintf("%p\n", mem); if(mem) varset("$lastalloc", mem, true); if(mem) CommentSet(mem, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "User-allocated memory")), true); //update memory map MemUpdateMap(); GuiUpdateMemoryView(); varset("$res", mem, false); return true; } bool cbDebugFree(int argc, char* argv[]) { duint lastalloc; varget("$lastalloc", &lastalloc, 0, 0); duint addr = lastalloc; if(argc > 1) { if(!valfromstring(argv[1], &addr, false)) return false; } else if(!lastalloc) { dputs(QT_TRANSLATE_NOOP("DBG", "$lastalloc is zero, provide a page address")); return false; } if(addr == lastalloc) varset("$lastalloc", (duint)0, true); bool ok = !!VirtualFreeEx(fdProcessInfo->hProcess, (void*)addr, 0, MEM_RELEASE); if(!ok) dputs(QT_TRANSLATE_NOOP("DBG", "VirtualFreeEx failed")); //update memory map MemUpdateMap(); GuiUpdateMemoryView(); varset("$res", ok, false); return true; } bool cbDebugMemset(int argc, char* argv[]) { duint addr; duint value; duint size; if(IsArgumentsLessThan(argc, 3)) return false; if(!valfromstring(argv[1], &addr, false) || !valfromstring(argv[2], &value, false)) return false; if(argc > 3) { if(!valfromstring(argv[3], &size, false)) return false; } else { duint base = MemFindBaseAddr(addr, &size, true); if(!base) { dputs(QT_TRANSLATE_NOOP("DBG", "Invalid address specified")); return false; } duint diff = addr - base; addr = base + diff; size -= diff; } BYTE fi = value & 0xFF; if(!Fill((void*)addr, size & 0xFFFFFFFF, &fi)) dputs(QT_TRANSLATE_NOOP("DBG", "Memset failed")); else dprintf(QT_TRANSLATE_NOOP("DBG", "Memory %p (size: %.8X) set to %.2X\n"), addr, DWORD(size & 0xFFFFFFFF), BYTE(value & 0xFF)); return true; } bool cbDebugMemcpy(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 4)) return false; duint dst = 0, src = 0, size = 0; if(!valfromstring(argv[1], &dst, false) || !valfromstring(argv[2], &src, false) || !valfromstring(argv[3], &size, false)) return false; duint totalNumberOfBytesWritten = 0; std::vector<uint8_t> buffer; buffer.resize(PAGE_SIZE); //copy a page at a time for(size_t i = 0; i < size; i += buffer.size()) { duint NumberOfBytesRead = 0; auto readOk = MemRead(src + i, buffer.data(), min(buffer.size(), size - i), &NumberOfBytesRead); duint NumberOfBytesWritten = 0; auto writeOk = MemWrite(dst + i, buffer.data(), NumberOfBytesRead, &NumberOfBytesWritten); totalNumberOfBytesWritten += NumberOfBytesWritten; if(!readOk || !writeOk) break; } GuiUpdateAllViews(); varset("$result", totalNumberOfBytesWritten, false); return true; } bool cbDebugGetPageRights(int argc, char* argv[]) { duint addr = 0; char rights[RIGHTS_STRING_SIZE]; if(argc != 2 || !valfromstring(argv[1], &addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: using an address as arg1\n")); return false; } if(!MemGetPageRights(addr, rights)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting rights of page: %s\n"), argv[1]); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "Page: %p, Rights: %s\n"), addr, rights); return true; } bool cbDebugSetPageRights(int argc, char* argv[]) { duint addr = 0; char rights[RIGHTS_STRING_SIZE]; if(argc < 3 || !valfromstring(argv[1], &addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: Using an address as arg1 and as arg2: Execute, ExecuteRead, ExecuteReadWrite, ExecuteWriteCopy, NoAccess, ReadOnly, ReadWrite, WriteCopy. You can add a G at first for add PAGE GUARD, example: GReadOnly\n")); return false; } if(!MemSetPageRights(addr, argv[2])) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error: Set rights of %p with Rights: %s\n"), addr, argv[2]); return false; } if(!MemGetPageRights(addr, rights)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting rights of page: %s\n"), argv[1]); return false; } //update the memory map MemUpdateMap(); GuiUpdateMemoryView(); dprintf(QT_TRANSLATE_NOOP("DBG", "New rights of %p: %s\n"), addr, rights); return true; } bool cbInstrSavedata(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 4)) return false; duint addr, size; if(!valfromstring(argv[2], &addr, false) || !valfromstring(argv[3], &size, false)) return false; bool success = true; Memory<unsigned char*> data(size); if(!MemReadDumb(addr, data(), data.size())) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read (all) memory...")); success = false; } String name = stringformatinline(argv[1]); if(name == ":memdump:") name = StringUtils::sprintf("%s\\memdumps\\memdump_%X_%p_%x.bin", szUserDir, fdProcessInfo->dwProcessId, addr, size); if(!FileHelper::WriteAllData(name, data(), data.size())) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to write file...")); return false; } #ifdef _WIN64 dprintf(QT_TRANSLATE_NOOP("DBG", "%p[%llX] written to \"%s\" !\n"), addr, size, name.c_str()); #else //x86 dprintf(QT_TRANSLATE_NOOP("DBG", "%p[%X] written to \"%s\" !\n"), addr, size, name.c_str()); #endif return success; } bool cbInstrMinidump(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(DbgIsRunning()) { dputs(QT_TRANSLATE_NOOP("DBG", "Cannot dump while running...")); return false; } HANDLE hFile = CreateFileA(argv[1], GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if(hFile == INVALID_HANDLE_VALUE) { dputs(QT_TRANSLATE_NOOP("DBG", "Could not open file!")); return false; } // Disable all software breakpoints std::vector<BREAKPOINT> disabledBreakpoints; { std::vector<BREAKPOINT> bplist; BpGetList(&bplist); for(const auto & bp : bplist) { if(bp.type == BPNORMAL && bp.active && DeleteBPX(bp.addr)) disabledBreakpoints.push_back(bp); } } CONTEXT context = {}; context.ContextFlags = CONTEXT_ALL; GetThreadContext(DbgGetThreadHandle(), &context); context.EFlags &= ~0x100; // remove trap flag EXCEPTION_POINTERS exceptionPointers = {}; exceptionPointers.ContextRecord = &context; exceptionPointers.ExceptionRecord = &getLastExceptionInfo().ExceptionRecord; if(exceptionPointers.ExceptionRecord->ExceptionCode == 0) { auto & exceptionRecord = *exceptionPointers.ExceptionRecord; exceptionRecord.ExceptionCode = 0xFFFFFFFF; #ifdef _WIN64 exceptionRecord.ExceptionAddress = PVOID(context.Rip); #else exceptionRecord.ExceptionAddress = PVOID(context.Eip); #endif // _WIN64 } MINIDUMP_EXCEPTION_INFORMATION exceptionInfo = {}; exceptionInfo.ThreadId = DbgGetThreadId(); exceptionInfo.ExceptionPointers = &exceptionPointers; exceptionInfo.ClientPointers = FALSE; auto dumpType = MINIDUMP_TYPE(MiniDumpWithFullMemory | MiniDumpWithFullMemoryInfo | MiniDumpIgnoreInaccessibleMemory | MiniDumpWithHandleData); auto dumpSaved = !!MiniDumpWriteDump(DbgGetProcessHandle(), DbgGetProcessId(), hFile, dumpType, &exceptionInfo, nullptr, nullptr); auto lastError = GetLastError() & 0xFFFF; // HRESULT_FROM_WIN32 // Re-enable all breakpoints that were previously disabled for(const auto & bp : disabledBreakpoints) { SetBPX(bp.addr, bp.titantype, cbUserBreakpoint); } if(dumpSaved) { dputs(QT_TRANSLATE_NOOP("DBG", "Dump saved!")); } else { String error = stringformatinline(StringUtils::sprintf("{winerror@%x}", lastError)); dprintf(QT_TRANSLATE_NOOP("DBG", "MiniDumpWriteDump failed. GetLastError() = %s.\n"), error.c_str()); } CloseHandle(hFile); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-memory-operations.h
#pragma once #include "command.h" bool cbDebugAlloc(int argc, char* argv[]); bool cbDebugFree(int argc, char* argv[]); bool cbDebugMemset(int argc, char* argv[]); bool cbDebugMemcpy(int argc, char* argv[]); bool cbDebugGetPageRights(int argc, char* argv[]); bool cbDebugSetPageRights(int argc, char* argv[]); bool cbInstrSavedata(int argc, char* argv[]); bool cbInstrMinidump(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-misc.cpp
#include "cmd-misc.h" #include "exprfunc.h" #include "variable.h" #include "value.h" #include "debugger.h" #include "threading.h" #include "thread.h" #include "assemble.h" #include "memory.h" #include "plugin_loader.h" #include "jit.h" #include "mnemonichelp.h" #include "commandline.h" #include "stringformat.h" bool cbInstrChd(int argc, char* argv[]) { String directory; if(argc < 2) { directory = szProgramDir; } else { directory = argv[1]; } if(!DirExists(argv[1])) { dprintf(QT_TRANSLATE_NOOP("DBG", "Directory '%s' doesn't exist\n"), directory.c_str()); return false; } SetCurrentDirectoryW(StringUtils::Utf8ToUtf16(directory).c_str()); dputs(QT_TRANSLATE_NOOP("DBG", "Current directory changed!")); return true; } bool cbInstrZzz(int argc, char* argv[]) { duint value = 100; if(argc > 1) if(!valfromstring(argv[1], &value, false)) return false; auto ms = DWORD(value); if(ms == INFINITE) ms = 100; Sleep(ms); return true; } bool cbDebugHide(int argc, char* argv[]) { if(HideDebugger(fdProcessInfo->hProcess, UE_HIDE_PEBONLY)) dputs(QT_TRANSLATE_NOOP("DBG", "Debugger hidden")); else dputs(QT_TRANSLATE_NOOP("DBG", "Something went wrong")); return true; } static duint LoadLibThreadID; static duint FreeLibThreadID; static duint DLLNameMem; static duint ASMAddr; static TITAN_ENGINE_CONTEXT_t backupctx = { 0 }; static void cbDebugLoadLibBPX() { HANDLE LoadLibThread = ThreadGetHandle((DWORD)LoadLibThreadID); #ifdef _WIN64 duint LibAddr = GetContextDataEx(LoadLibThread, UE_RAX); #else duint LibAddr = GetContextDataEx(LoadLibThread, UE_EAX); #endif //_WIN64 varset("$result", LibAddr, false); backupctx.eflags &= ~0x100; SetFullContextDataEx(LoadLibThread, &backupctx); MemFreeRemote(DLLNameMem); MemFreeRemote(ASMAddr); ThreadResumeAll(); //update GUI DebugUpdateGuiSetStateAsync(GetContextDataEx(hActiveThread, UE_CIP), paused); //lock lock(WAITID_RUN); dbgsetforeground(); PLUG_CB_PAUSEDEBUG pauseInfo = { nullptr }; plugincbcall(CB_PAUSEDEBUG, &pauseInfo); wait(WAITID_RUN); } bool cbDebugLoadLib(int argc, char* argv[]) { if(argc < 2) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: you must specify the name of the DLL to load\n")); return false; } #ifdef _WIN64 unsigned char loader[] = { 0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rcx, DLLNameAddr 0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rax, p_LoadLibraryW 0xFF, 0xD0, //call rax 0x90 //nop }; #else unsigned char loader[] = { 0x68, 0xFF, 0xFF, 0xFF, 0xFF, //push DLLNameMem 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, //mov eax, p_LoadLibraryW 0xFF, 0xD0, //call eax 0x90 //nop }; #endif //_WIN64 auto DLLNameOffset = ArchValue(1, 2), LoadLibraryOffset = ArchValue(6, 12); LoadLibThreadID = fdProcessInfo->dwThreadId; HANDLE LoadLibThread = ThreadGetHandle((DWORD)LoadLibThreadID); auto DLLNameW = StringUtils::Utf8ToUtf16(argv[1]); auto DLLNameSize = (DLLNameW.length() + 1) * 2; duint p_LoadLibraryW = 0; if(!valfromstring("kernel32:LoadLibraryW", &p_LoadLibraryW, false)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't get kernel32:LoadLibraryW")); return false; } ASMAddr = MemAllocRemote(0, sizeof(loader)); DLLNameMem = MemAllocRemote(0, DLLNameSize); if(!ASMAddr || !DLLNameMem) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't allocate memory in debuggee")); return false; } // Set addresses in the loader memcpy(loader + DLLNameOffset, &DLLNameMem, sizeof(duint)); memcpy(loader + LoadLibraryOffset, &p_LoadLibraryW, sizeof(duint)); if(!MemWrite(ASMAddr, loader, sizeof(loader)) || !MemWrite(DLLNameMem, DLLNameW.c_str(), DLLNameSize)) { MemFreeRemote(ASMAddr); dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't write process memory")); return false; } if(!SetBPX(ASMAddr + sizeof(loader) - 1, UE_SINGLESHOOT | UE_BREAKPOINT_TYPE_INT3, cbDebugLoadLibBPX)) { MemFreeRemote(ASMAddr); dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't SetBPX")); return false; } ThreadSuspendAll(); GetFullContextDataEx(LoadLibThread, &backupctx); SetContextDataEx(LoadLibThread, UE_CIP, ASMAddr); #ifdef _WIN64 // Allocate shadow space + align SetContextDataEx(LoadLibThread, UE_CSP, (backupctx.csp - 32) & ~0xF); #else SetContextDataEx(LoadLibThread, UE_CSP, backupctx.csp & ~0xF); #endif // _WIN64 ResumeThread(LoadLibThread); unlock(WAITID_RUN); return true; } static void cbDebugFreeLibBPX() { HANDLE FreeLibThread = ThreadGetHandle((DWORD)FreeLibThreadID); #ifdef _WIN64 duint LibAddr = GetContextDataEx(FreeLibThread, UE_RAX); #else duint LibAddr = GetContextDataEx(FreeLibThread, UE_EAX); #endif //_WIN64 varset("$result", LibAddr, false); backupctx.eflags &= ~0x100; SetFullContextDataEx(FreeLibThread, &backupctx); MemFreeRemote(ASMAddr); ThreadResumeAll(); //update GUI DebugUpdateGuiSetStateAsync(GetContextDataEx(hActiveThread, UE_CIP), paused); //lock lock(WAITID_RUN); dbgsetforeground(); PLUG_CB_PAUSEDEBUG pauseInfo = { nullptr }; plugincbcall(CB_PAUSEDEBUG, &pauseInfo); wait(WAITID_RUN); } bool cbDebugFreeLib(int argc, char* argv[]) { duint base = 0; if(IsArgumentsLessThan(argc, 2) || !valfromstring(argv[1], &base, false)) return false; base = ModBaseFromAddr(base); if(!base) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: the specified address does not point inside a module")); return false; } unsigned char loader[] = #ifdef _WIN64 { 0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rcx, ModuleBase 0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rax, p_FreeLibrary 0xFF, 0xD0, //call rax 0x90 //nop }; #else { 0x68, 0xFF, 0xFF, 0xFF, 0xFF, //push ModuleBase 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, //mov eax, p_FreeLibrary 0xFF, 0xD0, //call eax 0x90 //nop }; #endif //_WIN64 auto ModuleBaseOffset = ArchValue(1, 2), FreeLibraryOffset = ArchValue(6, 12); FreeLibThreadID = fdProcessInfo->dwThreadId; HANDLE UnLoadLibThread = ThreadGetHandle((DWORD)FreeLibThreadID); duint p_FreeLibrary = 0; if(!valfromstring("kernel32:FreeLibrary", &p_FreeLibrary, false)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't get kernel32:FreeLibrary")); return false; } ASMAddr = MemAllocRemote(0, sizeof(loader)); if(!ASMAddr) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't allocate memory in debuggee")); return false; } // Set addresses in the loader memcpy(loader + ModuleBaseOffset, &base, sizeof(duint)); memcpy(loader + FreeLibraryOffset, &p_FreeLibrary, sizeof(duint)); if(!MemWrite(ASMAddr, loader, sizeof(loader))) { MemFreeRemote(ASMAddr); dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't write process memory")); return false; } if(!SetBPX(ASMAddr + sizeof(loader) - 1, UE_SINGLESHOOT | UE_BREAKPOINT_TYPE_INT3, cbDebugFreeLibBPX)) { MemFreeRemote(ASMAddr); dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't SetBPX")); return false; } ThreadSuspendAll(); GetFullContextDataEx(UnLoadLibThread, &backupctx); SetContextDataEx(UnLoadLibThread, UE_CIP, ASMAddr); ResumeThread(UnLoadLibThread); unlock(WAITID_RUN); return true; } bool cbInstrAssemble(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\"!\n"), argv[1]); return false; } if(!DbgMemIsValidReadPtr(addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address: %p!\n"), addr); return false; } bool fillnop = false; if(argc > 3) fillnop = true; char error[MAX_ERROR_SIZE] = ""; int size = 0; auto asmFormat = stringformatinline(argv[2]); if(!assembleat(addr, asmFormat.c_str(), &size, error, fillnop)) { varset("$result", size, false); dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to assemble \"%s\" (%s)\n"), asmFormat.c_str(), error); return false; } varset("$result", size, false); GuiUpdateAllViews(); return true; } bool cbInstrGpa(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; char newcmd[deflen] = ""; if(argc >= 3) sprintf_s(newcmd, "\"%s\":%s", argv[2], argv[1]); else sprintf_s(newcmd, "%s", argv[1]); duint result = 0; if(!valfromstring(newcmd, &result, false)) return false; varset("$RESULT", result, false); return true; } bool cbDebugSetJIT(int argc, char* argv[]) { arch actual_arch = notfound; const char* jit_debugger_cmd = ""; Memory<char*> oldjit(MAX_SETTING_SIZE + 1); char path[JIT_ENTRY_DEF_SIZE]; if(!BridgeIsProcessElevated()) { dputs(QT_TRANSLATE_NOOP("DBG", "Error run the debugger as Admin to setjit\n")); return false; } if(argc < 2) { dbggetdefjit(path); jit_debugger_cmd = path; if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } } else if(argc == 2) { if(!_strcmpi(argv[1], "old")) { jit_debugger_cmd = oldjit(); if(!BridgeSettingGet("JIT", "Old", oldjit())) { dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored.")); return false; } if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } } else if(!_strcmpi(argv[1], "oldsave")) { dbggetdefjit(path); char get_entry[JIT_ENTRY_MAX_SIZE] = ""; bool get_last_jit = true; if(!dbggetjit(get_entry, notfound, &actual_arch, NULL)) { get_last_jit = false; } else strcpy_s(oldjit(), MAX_SETTING_SIZE, get_entry); jit_debugger_cmd = path; if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } if(get_last_jit) { if(_stricmp(oldjit(), path)) BridgeSettingSet("JIT", "Old", oldjit()); } } else if(!_strcmpi(argv[1], "restore")) { jit_debugger_cmd = oldjit(); if(!BridgeSettingGet("JIT", "Old", oldjit())) { dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored.")); return false; } if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } BridgeSettingSet("JIT", 0, 0); } else { jit_debugger_cmd = argv[1]; if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } } } else if(argc == 3) { readwritejitkey_error_t rw_error; if(!_strcmpi(argv[1], "old")) { BridgeSettingSet("JIT", "Old", argv[2]); dprintf(QT_TRANSLATE_NOOP("DBG", "New OLD JIT stored: %s\n"), argv[2]); return true; } else if(_strcmpi(argv[1], "x64") == 0) actual_arch = x64; else if(_strcmpi(argv[1], "x32") == 0) actual_arch = x32; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT entry type. Use OLD, x64 or x32 as parameter.")); return false; } jit_debugger_cmd = argv[2]; if(!dbgsetjit(jit_debugger_cmd, actual_arch, NULL, &rw_error)) { if(rw_error == ERROR_RW_NOTWOW64) dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg. The debugger is not a WOW64 process\n")); else dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } } else { dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use old, oldsave, restore, x86 or x64 as parameter.")); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "New JIT %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", jit_debugger_cmd); return true; } bool cbDebugGetJIT(int argc, char* argv[]) { char get_entry[JIT_ENTRY_MAX_SIZE] = ""; arch actual_arch; if(argc < 2) { if(!dbggetjit(get_entry, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } } else { readwritejitkey_error_t rw_error; Memory<char*> oldjit(MAX_SETTING_SIZE + 1); if(_strcmpi(argv[1], "OLD") == 0) { if(!BridgeSettingGet("JIT", "Old", oldjit())) { dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored.")); return false; } else { dprintf(QT_TRANSLATE_NOOP("DBG", "OLD JIT entry stored: %s\n"), oldjit()); return true; } } else if(_strcmpi(argv[1], "x64") == 0) actual_arch = x64; else if(_strcmpi(argv[1], "x32") == 0) actual_arch = x32; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT entry type. Use OLD, x64 or x32 as parameter.")); return false; } if(!dbggetjit(get_entry, actual_arch, NULL, &rw_error)) { if(rw_error == ERROR_RW_NOTWOW64) dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg. The debugger is not a WOW64 process\n")); else dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT %s\n"), argv[1]); return false; } } dprintf(QT_TRANSLATE_NOOP("DBG", "JIT %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", get_entry); return true; } bool cbDebugGetJITAuto(int argc, char* argv[]) { bool jit_auto = false; arch actual_arch = notfound; if(argc == 1) { if(!dbggetjitauto(&jit_auto, notfound, &actual_arch, NULL)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto %s\n"), (actual_arch == x64) ? "x64" : "x32"); return false; } } else if(argc == 2) { readwritejitkey_error_t rw_error; if(_strcmpi(argv[1], "x64") == 0) actual_arch = x64; else if(_strcmpi(argv[1], "x32") == 0) actual_arch = x32; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter.")); return false; } if(!dbggetjitauto(&jit_auto, actual_arch, NULL, &rw_error)) { if(rw_error == ERROR_RW_NOTWOW64) dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg the debugger is not a WOW64 process\n")); else dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto %s\n"), argv[1]); return false; } } else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter.")); } dprintf(QT_TRANSLATE_NOOP("DBG", "JIT auto %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", jit_auto ? "ON" : "OFF"); return true; } bool cbDebugSetJITAuto(int argc, char* argv[]) { arch actual_arch; bool set_jit_auto; if(!BridgeIsProcessElevated()) { dputs(QT_TRANSLATE_NOOP("DBG", "Error run the debugger as Admin to setjitauto\n")); return false; } if(argc < 2) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT Auto. Use ON:1 or OFF:0 arg or x64/x32, ON:1 or OFF:0.\n")); return false; } else if(argc == 2) { if(_strcmpi(argv[1], "1") == 0 || _strcmpi(argv[1], "ON") == 0) set_jit_auto = true; else if(_strcmpi(argv[1], "0") == 0 || _strcmpi(argv[1], "OFF") == 0) set_jit_auto = false; else { dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use ON:1 or OFF:0")); return false; } if(!dbgsetjitauto(set_jit_auto, notfound, &actual_arch, NULL)) { if(actual_arch == x64) dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT auto x64")); else dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT auto x32")); return false; } } else if(argc == 3) { readwritejitkey_error_t rw_error; actual_arch = x64; if(_strcmpi(argv[1], "x64") == 0) actual_arch = x64; else if(_strcmpi(argv[1], "x32") == 0) actual_arch = x32; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter.")); return false; } if(_strcmpi(argv[2], "1") == 0 || _strcmpi(argv[2], "ON") == 0) set_jit_auto = true; else if(_strcmpi(argv[2], "0") == 0 || _strcmpi(argv[2], "OFF") == 0) set_jit_auto = false; else { dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use x86 or x64 and ON:1 or OFF:0\n")); return false; } if(!dbgsetjitauto(set_jit_auto, actual_arch, NULL, &rw_error)) { if(rw_error == ERROR_RW_NOTWOW64) dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg the debugger is not a WOW64 process\n")); else { if(actual_arch == x64) dputs(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto x64")); else dputs(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto x32")); } return false; } } else { dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters use x86 or x64, ON/1 or OFF/0\n")); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "New JIT auto %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", set_jit_auto ? "ON" : "OFF"); return true; } bool cbDebugGetCmdline(int argc, char* argv[]) { char* cmd_line; cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 }; if(!dbggetcmdline(&cmd_line, &cmdline_error, fdProcessInfo->hProcess)) { showcommandlineerror(&cmdline_error); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "Command line: %s\n"), cmd_line); efree(cmd_line); return true; } bool cbDebugSetCmdline(int argc, char* argv[]) { cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 }; if(argc != 2) { dputs(QT_TRANSLATE_NOOP("DBG", "Error: write the arg1 with the new command line of the process debugged")); return false; } if(!dbgsetcmdline(argv[1], &cmdline_error)) { showcommandlineerror(&cmdline_error); return false; } //update the memory map MemUpdateMap(); GuiUpdateMemoryView(); dprintf(QT_TRANSLATE_NOOP("DBG", "New command line: %s\n"), argv[1]); return true; } bool cbInstrMnemonichelp(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; auto description = MnemonicHelp::getDescription(argv[1]); if(!description.length()) dputs(QT_TRANSLATE_NOOP("DBG", "No description or empty description")); else { auto padding = "================================================================"; String logText = padding; logText += '\n'; logText += description; logText += '\n'; logText += padding; logText += '\n'; GuiAddLogMessage(logText.c_str()); } return true; } bool cbInstrMnemonicbrief(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; dputs(MnemonicHelp::getBriefDescription(argv[1]).c_str()); return true; } bool cbInstrConfig(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint val = 0; if(argc == 3) { if(BridgeSettingGetUint(argv[1], argv[2], &val)) { varset("$result", val, false); return true; } else { dputs(QT_TRANSLATE_NOOP("DBG", "Error: Configuration not found.")); return false; } } else { if(valfromstring(argv[3], &val, true)) { if(BridgeSettingSetUint(argv[1], argv[2], val)) { DbgSettingsUpdated(); return true; } else { dputs(QT_TRANSLATE_NOOP("DBG", "Error updating configuration.")); return false; } } else { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\"!\n"), argv[3]); return false; } } } bool cbInstrRestartadmin(int argc, char* argv[]) { if(dbgrestartadmin()) GuiCloseApplication(); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-misc.h
#pragma once #include "command.h" bool cbInstrChd(int argc, char* argv[]); bool cbInstrZzz(int argc, char* argv[]); bool cbDebugHide(int argc, char* argv[]); bool cbDebugLoadLib(int argc, char* argv[]); bool cbDebugFreeLib(int argc, char* argv[]); bool cbInstrAssemble(int argc, char* argv[]); bool cbInstrGpa(int argc, char* argv[]); bool cbDebugSetJIT(int argc, char* argv[]); bool cbDebugGetJIT(int argc, char* argv[]); bool cbDebugGetJITAuto(int argc, char* argv[]); bool cbDebugSetJITAuto(int argc, char* argv[]); bool cbDebugGetCmdline(int argc, char* argv[]); bool cbDebugSetCmdline(int argc, char* argv[]); bool cbInstrMnemonichelp(int argc, char* argv[]); bool cbInstrMnemonicbrief(int argc, char* argv[]); bool cbInstrConfig(int argc, char* argv[]); bool cbInstrRestartadmin(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-operating-system-control.cpp
#include "cmd-operating-system-control.h" #include "variable.h" #include "debugger.h" #include "exception.h" #include "value.h" #include "stringformat.h" bool cbGetPrivilegeState(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; DWORD returnLength; LUID luid; if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0) { varset("$result", (duint)0, false); return true; } Memory <TOKEN_PRIVILEGES*> Privileges(64 * 16 + 8, "_dbg_getprivilegestate"); if(GetTokenInformation(hProcessToken, TokenPrivileges, Privileges(), 64 * 16 + 8, &returnLength) == 0) { if(returnLength > 4 * 1024 * 1024) { varset("$result", (duint)0, false); return true; } Privileges.realloc(returnLength, "_dbg_getprivilegestate"); if(GetTokenInformation(hProcessToken, TokenPrivileges, Privileges(), returnLength, &returnLength) == 0) return false; } for(unsigned int i = 0; i < Privileges()->PrivilegeCount; i++) { if(4 + sizeof(LUID_AND_ATTRIBUTES) * i > returnLength) return false; if(memcmp(&Privileges()->Privileges[i].Luid, &luid, sizeof(LUID)) == 0) { varset("$result", (duint)(Privileges()->Privileges[i].Attributes + 1), false); // 2=enabled, 3=default, 1=disabled return true; } } varset("$result", (duint)0, false); return true; } bool cbEnablePrivilege(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; LUID luid; if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not find the specified privilege: %s\n"), argv[1]); return false; } TOKEN_PRIVILEGES Privilege; Privilege.PrivilegeCount = 1; Privilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; Privilege.Privileges[0].Luid = luid; return AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR; } bool cbDisablePrivilege(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; LUID luid; if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0) { dprintf(QT_TRANSLATE_NOOP("DBG", "Could not find the specified privilege: %s\n"), argv[1]); return false; } TOKEN_PRIVILEGES Privilege; Privilege.PrivilegeCount = 1; Privilege.Privileges[0].Attributes = 0; Privilege.Privileges[0].Luid = luid; bool ret = AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR; return ret ? true : false; } bool cbHandleClose(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint handle; if(!valfromstring(argv[1], &handle, false)) return false; if(!handle || !DuplicateHandle(fdProcessInfo->hProcess, HANDLE(handle), NULL, NULL, 0, FALSE, DUPLICATE_CLOSE_SOURCE)) { String error = stringformatinline(StringUtils::sprintf("{winerror@%x}", GetLastError())); dprintf(QT_TRANSLATE_NOOP("DBG", "DuplicateHandle failed: %s\n"), error.c_str()); return false; } #ifdef _WIN64 dprintf(QT_TRANSLATE_NOOP("DBG", "Handle %llX closed!\n"), handle); #else //x86 dprintf(QT_TRANSLATE_NOOP("DBG", "Handle %X closed!\n"), handle); #endif return true; } bool cbEnableWindow(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint handle; if(!valfromstring(argv[1], &handle, false)) return false; if(!IsWindowEnabled((HWND)handle)) EnableWindow((HWND)handle, TRUE); return true; } bool cbDisableWindow(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint handle; if(!valfromstring(argv[1], &handle, false)) return false; if(IsWindowEnabled((HWND)handle)) EnableWindow((HWND)handle, FALSE); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-operating-system-control.h
#pragma once #include "command.h" bool cbGetPrivilegeState(int argc, char* argv[]); bool cbEnablePrivilege(int argc, char* argv[]); bool cbDisablePrivilege(int argc, char* argv[]); bool cbHandleClose(int argc, char* argv[]); bool cbEnableWindow(int argc, char* argv[]); bool cbDisableWindow(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-plugins.cpp
#include "cmd-plugins.h" #include "console.h" #include "debugger.h" #include "module.h" #include "plugin_loader.h" static bool bScyllaLoaded = false; static DWORD WINAPI scyllaThread(void* lpParam) { typedef INT(WINAPI * SCYLLASTARTGUI)(DWORD pid, HINSTANCE mod, DWORD_PTR entrypoint); SCYLLASTARTGUI ScyllaStartGui = 0; HINSTANCE hScylla = LoadLibraryW(L"Scylla.dll"); if(!hScylla) { dputs(QT_TRANSLATE_NOOP("DBG", "Error loading Scylla.dll!")); bScyllaLoaded = false; return 0; } ScyllaStartGui = (SCYLLASTARTGUI)GetProcAddress(hScylla, "ScyllaStartGui"); if(!ScyllaStartGui) { dputs(QT_TRANSLATE_NOOP("DBG", "Could not find export 'ScyllaStartGui' inside Scylla.dll")); bScyllaLoaded = false; FreeLibrary(hScylla); return 0; } auto cip = GetContextDataEx(hActiveThread, UE_CIP); auto cipModBase = ModBaseFromAddr(cip); ScyllaStartGui(fdProcessInfo->dwProcessId, (HINSTANCE)cipModBase, cip); FreeLibrary(hScylla); bScyllaLoaded = false; return 0; } bool cbDebugStartScylla(int argc, char* argv[]) { if(bScyllaLoaded) { dputs(QT_TRANSLATE_NOOP("DBG", "Scylla is already loaded")); return false; } bScyllaLoaded = true; CloseHandle(CreateThread(0, 0, scyllaThread, 0, 0, 0)); return true; } bool cbInstrPluginLoad(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return pluginload(argv[1]); } bool cbInstrPluginUnload(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return pluginunload(argv[1]); } bool cbInstrPluginReload(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(!pluginunload(argv[1])) return false; if(argc <= 2) { auto text = StringUtils::Utf8ToUtf16(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Press OK to reload the plugin..."))); auto title = StringUtils::Utf8ToUtf16(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Reload"))); if(MessageBoxW(GuiGetWindowHandle(), text.c_str(), title.c_str(), MB_OKCANCEL) != IDOK) return true; } return pluginload(argv[1]); }
C/C++
x64dbg-development/src/dbg/commands/cmd-plugins.h
#pragma once #include "command.h" bool cbDebugStartScylla(int argc, char* argv[]); bool cbInstrPluginLoad(int argc, char* argv[]); bool cbInstrPluginUnload(int argc, char* argv[]); bool cbInstrPluginReload(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-script.cpp
#include "cmd-script.h" #include "stringformat.h" #include "console.h" #include "variable.h" #include "stackinfo.h" #include "debugger.h" #include "simplescript.h" bool cbScriptLoad(int argc, char* argv[]) { if(argc < 2) return false; scriptload(argv[1]); return true; } bool cbScriptMsg(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; GuiScriptMessage(stringformatinline(argv[1]).c_str()); return true; } bool cbScriptMsgyn(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; varset("$RESULT", GuiScriptMsgyn(stringformatinline(argv[1]).c_str()), false); return true; } bool cbScriptCmd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; auto scriptcmd = strchr(argv[0], ' '); if(scriptcmd == nullptr) return false; while(isspace(*scriptcmd)) scriptcmd++; return scriptcmdexec(scriptcmd); } static bool cbGenericLog(int argc, char* argv[], void(*logputs)(const char* msg)) { if(argc == 1) //just log newline { logputs(""); return true; } if(argc == 2) //inline logging: log "format {rax}" { logputs(stringformatinline(argv[1]).c_str()); } else //log "format {0} string", arg1, arg2, argN { FormatValueVector formatArgs; for(auto i = 2; i < argc; i++) formatArgs.push_back(argv[i]); logputs(stringformat(argv[1], formatArgs).c_str()); } return true; } bool cbInstrLog(int argc, char* argv[]) { return cbGenericLog(argc, argv, [](const char* msg) { dputs_untranslated(msg); scriptlog(msg); }); } bool cbInstrHtmlLog(int argc, char* argv[]) { return cbGenericLog(argc, argv, [](const char* msg) { dprint_untranslated_html(msg); dprint_untranslated_html("\n"); }); } bool cbInstrPrintStack(int argc, char* argv[]) { duint csp = GetContextDataEx(hActiveThread, UE_CSP); std::vector<CALLSTACKENTRY> callstackVector; stackgetcallstack(csp, callstackVector, false); if(callstackVector.size() == 0) dputs(QT_TRANSLATE_NOOP("DBG", "No call stack.")); else { duint cip = GetContextDataEx(hActiveThread, UE_CIP); #ifdef _WIN64 duint cbp = GetContextDataEx(hActiveThread, UE_RBP); dprintf(QT_TRANSLATE_NOOP("DBG", "%llu call stack frames (RIP = %p , RSP = %p , RBP = %p ):\n"), callstackVector.size(), cip, csp, cbp); #else //x86 duint cbp = GetContextDataEx(hActiveThread, UE_EBP); dprintf(QT_TRANSLATE_NOOP("DBG", "%u call stack frames (EIP = %p , ESP = %p , EBP = %p ):\n"), callstackVector.size(), cip, csp, cbp); #endif //_WIN64 for(auto & i : callstackVector) dprintf_untranslated("%p %s\n", i.addr, i.comment); } return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-script.h
#pragma once #include "command.h" bool cbScriptLoad(int argc, char* argv[]); bool cbScriptMsg(int argc, char* argv[]); bool cbScriptMsgyn(int argc, char* argv[]); bool cbScriptCmd(int argc, char* argv[]); bool cbInstrLog(int argc, char* argv[]); bool cbInstrHtmlLog(int argc, char* argv[]); bool cbInstrPrintStack(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-searching.cpp
#include "cmd-searching.h" #include "memory.h" #include "value.h" #include "variable.h" #include "reference.h" #include "assemble.h" #include "debugger.h" #include "filehelper.h" #include "label.h" #include "stringformat.h" #include "disasm_helper.h" #include "symbolinfo.h" static int maxFindResults = 5000; static bool handlePatternArgument(const char* pattern, std::vector<PatternByte> & searchpattern, String* patternshort = nullptr) { searchpattern.clear(); auto handlePrefix = [&](const char* prefix, size_t size) -> bool { auto prefixLen = strlen(prefix); if(_strnicmp(pattern, prefix, prefixLen) == 0) { duint value = 0; if(!valfromstring(pattern + prefixLen, &value, false)) return true; auto data = (unsigned char*)&value; for(size_t i = 0; i < size; i++) { auto ch = data[i]; PatternByte b; b.nibble[0].data = (ch >> 4) & 0xF; b.nibble[0].wildcard = false; b.nibble[1].data = ch & 0xF; b.nibble[1].wildcard = false; searchpattern.push_back(b); } return true; } return false; }; auto result = (handlePrefix("byte:", 1) || handlePrefix("word:", 2) || handlePrefix("dword:", 4) #ifdef _WIN64 || handlePrefix("qword:", 8) #endif //_WIN64 || handlePrefix("ptr:", ArchValue(4, 8)) //remove # from the start and end of the pattern (ODBGScript support) || patterntransform(StringUtils::Trim(stringformatinline(pattern), "#"), searchpattern)) && !searchpattern.empty(); if(result && patternshort) { const auto maxShortSize = 16; for(size_t i = 0; i < min(searchpattern.size(), maxShortSize); i++) { auto doNibble = [&patternshort](const PatternByte::PatternNibble & n) { if(n.wildcard) *patternshort += "?"; else *patternshort += "0123456789ABCDEF"[n.data & 0xf]; }; doNibble(searchpattern[i].nibble[0]); doNibble(searchpattern[i].nibble[1]); } if(searchpattern.size() > maxShortSize) *patternshort += "..."; } return result; } bool cbInstrFind(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; std::vector<PatternByte> searchpattern; if(!handlePatternArgument(argv[2], searchpattern)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to transform pattern!")); return false; } duint size = 0; duint base = MemFindBaseAddr(addr, &size, true); if(!base) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid memory address %p!\n"), addr); return false; } Memory<unsigned char*> data(size, "cbInstrFind:data"); if(!MemRead(base, data(), size)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read memory!")); return false; } duint start = addr - base; duint find_size = 0; if(argc >= 4) { if(!valfromstring(argv[3], &find_size)) find_size = size - start; if(find_size > (size - start)) find_size = size - start; } else find_size = size - start; duint foundoffset = patternfind(data() + start, find_size, searchpattern); duint result = 0; if(foundoffset != -1) result = addr + foundoffset; varset("$result", result, false); return true; } bool cbInstrFindAll(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; std::vector<PatternByte> searchpattern; String patternshort; if(!handlePatternArgument(argv[2], searchpattern, &patternshort)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to transform pattern!")); return false; } duint size = 0; duint base = MemFindBaseAddr(addr, &size, true); if(!base) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid memory address %p!\n"), addr); return false; } Memory<unsigned char*> data(size, "cbInstrFindAll:data"); if(!MemRead(base, data(), size)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read memory!")); return false; } duint start = addr - base; duint find_size = 0; bool findData = false; if(argc >= 4) { if(!_stricmp(argv[3], "&data&")) { find_size = size - start; findData = true; } else if(!valfromstring(argv[3], &find_size)) find_size = size - start; if(find_size > (size - start)) find_size = size - start; } else find_size = size - start; //setup reference view String patterntitle = StringUtils::sprintf(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Pattern: %s")), patternshort.c_str()); GuiReferenceInitialize(patterntitle.c_str()); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); if(findData) GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Data"))); else GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); DWORD ticks = GetTickCount(); int refCount = 0; duint i = 0; duint result = 0; while(refCount < maxFindResults) { duint foundoffset = patternfind(data() + start + i, find_size - i, searchpattern); if(foundoffset == -1) break; i += foundoffset + 1; result = addr + i - 1; char msg[deflen] = ""; sprintf_s(msg, "%p", result); GuiReferenceSetRowCount(refCount + 1); GuiReferenceSetCellContent(refCount, 0, msg); if(findData) { Memory<unsigned char*> printData(searchpattern.size(), "cbInstrFindAll:printData"); MemRead(result, printData(), printData.size()); for(size_t j = 0, k = 0; j < printData.size(); j++) { if(j) k += sprintf_s(msg + k, sizeof(msg) - k, " "); k += sprintf_s(msg + k, sizeof(msg) - k, "%.2X", printData()[j]); } } else { if(!GuiGetDisassembly(result, msg)) strcpy_s(msg, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "[Error disassembling]"))); } GuiReferenceSetCellContent(refCount, 1, msg); result++; refCount++; } GuiReferenceReloadData(); dprintf(QT_TRANSLATE_NOOP("DBG", "%d occurrences found in %ums\n"), refCount, GetTickCount() - ticks); varset("$result", refCount, false); return true; } bool cbInstrFindAllMem(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; std::vector<PatternByte> searchpattern; String patternshort; if(!handlePatternArgument(argv[2], searchpattern, &patternshort)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to transform pattern!")); return false; } duint find_size = -1; bool findData = false; REFFINDTYPE moduleFindType = CURRENT_REGION; if(argc >= 4) { if(!_stricmp(argv[3], "&data&")) findData = true; else if(!valfromstring(argv[3], &find_size)) findData = false; } if(argc >= 5) { if(!_stricmp(argv[4], "user")) moduleFindType = USER_MODULES; else if(!_stricmp(argv[4], "system")) moduleFindType = SYSTEM_MODULES; else if(!_stricmp(argv[4], "module")) moduleFindType = ALL_MODULES; } SHARED_ACQUIRE(LockMemoryPages); std::vector<SimplePage> searchPages; for(auto & itr : memoryPages) { if(itr.second.mbi.State != MEM_COMMIT) continue; SimplePage page(duint(itr.second.mbi.BaseAddress), itr.second.mbi.RegionSize); if(moduleFindType != CURRENT_REGION) { SHARED_ACQUIRE(LockModules); auto info = ModInfoFromAddr(page.address); if(info) { if(moduleFindType == ALL_MODULES) { // Looking for modules and this region is in a module } else if(moduleFindType == USER_MODULES && info->party == mod_user) { // Looking for user modules and this region is in a user module } else if(moduleFindType == SYSTEM_MODULES && info->party == mod_system) { // Looking for system modules and this region is in a system module } else { // Module type is not matching continue; } } else { // Region is not a module continue; } } if(page.address >= addr && (find_size == -1 || page.address + page.size <= addr + find_size)) searchPages.push_back(page); } SHARED_RELEASE(); DWORD ticks = GetTickCount(); std::vector<duint> results; if(!MemFindInMap(searchPages, searchpattern, results, maxFindResults)) { dputs(QT_TRANSLATE_NOOP("DBG", "MemFindInMap failed!")); return false; } //setup reference view String patterntitle = StringUtils::sprintf(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Pattern: %s")), patternshort.c_str()); GuiReferenceInitialize(patterntitle.c_str()); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); if(findData) GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Data"))); else GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); int refCount = 0; for(duint result : results) { char msg[deflen] = ""; sprintf_s(msg, "%p", result); GuiReferenceSetRowCount(refCount + 1); GuiReferenceSetCellContent(refCount, 0, msg); if(findData) { Memory<unsigned char*> printData(searchpattern.size(), "cbInstrFindAll:printData"); MemRead(result, printData(), printData.size()); for(size_t j = 0, k = 0; j < printData.size(); j++) { if(j) k += sprintf_s(msg + k, sizeof(msg) - k, " "); k += sprintf_s(msg + k, sizeof(msg) - k, "%.2X", printData()[j]); } } else { if(!GuiGetDisassembly(result, msg)) strcpy_s(msg, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "[Error disassembling]"))); } GuiReferenceSetCellContent(refCount, 1, msg); refCount++; } GuiReferenceReloadData(); dprintf(QT_TRANSLATE_NOOP("DBG", "%d occurrences found in %ums\n"), refCount, GetTickCount() - ticks); varset("$result", refCount, false); return true; } static bool cbFindAsm(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo) { if(!disasm || !basicinfo) //initialize { GuiReferenceInitialize(refinfo->name); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); return true; } const char* instruction = (const char*)refinfo->userinfo; bool found = !_stricmp(instruction, basicinfo->instruction); if(found) { char addrText[20] = ""; sprintf_s(addrText, "%p", disasm->Address()); GuiReferenceSetRowCount(refinfo->refcount + 1); GuiReferenceSetCellContent(refinfo->refcount, 0, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly((duint)disasm->Address(), disassembly)) GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly); else GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str()); } return found; } bool cbInstrFindAsm(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(argc < 3 || !valfromstring(argv[2], &addr)) addr = GetContextDataEx(hActiveThread, UE_CIP); duint size = 0; if(argc >= 4) if(!valfromstring(argv[3], &size)) size = 0; duint refFindType = CURRENT_REGION; if(argc >= 5 && valfromstring(argv[4], &refFindType, true)) if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES) refFindType = CURRENT_REGION; unsigned char dest[16]; int asmsize = 0; char error[MAX_ERROR_SIZE] = ""; auto asmFormat = stringformatinline(argv[1]); if(!assemble(addr + size / 2, dest, &asmsize, asmFormat.c_str(), error)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to assemble \"%s\" (%s)!\n"), asmFormat.c_str(), error); return false; } BASIC_INSTRUCTION_INFO basicinfo; memset(&basicinfo, 0, sizeof(BASIC_INSTRUCTION_INFO)); disasmfast(dest, addr + size / 2, &basicinfo); duint ticks = GetTickCount(); char title[256] = ""; sprintf_s(title, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Command: \"%s\"")), basicinfo.instruction); int found = RefFind(addr, size, cbFindAsm, (void*)&basicinfo.instruction[0], false, title, (REFFINDTYPE)refFindType, true); dprintf(QT_TRANSLATE_NOOP("DBG", "%u result(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks)); varset("$result", found, false); return true; } bool cbInstrRefFind(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; std::string newCommand = std::string("reffindrange ") + argv[1] + std::string(",") + argv[1]; if(argc > 2) newCommand += std::string(",") + argv[2]; if(argc > 3) newCommand += std::string(",") + argv[3]; if(argc > 4) newCommand += std::string(",") + argv[4]; return cmddirectexec(newCommand.c_str()); } struct VALUERANGE { duint start; duint end; }; static bool cbRefFind(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo) { if(!disasm || !basicinfo) //initialize { GuiReferenceInitialize(refinfo->name); GuiReferenceAddColumn(sizeof(duint) * 2, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); return true; } bool found = false; VALUERANGE* range = (VALUERANGE*)refinfo->userinfo; duint start = range->start; duint end = range->end; if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE) { duint value = basicinfo->value.value; if(value >= start && value <= end) found = true; // Workaround for sign-extended values, see: https://github.com/x64dbg/x64dbg/issues/2824 if((value & ArchValue(0x80000000, 0x800000000000)) != 0) { switch(basicinfo->value.size) { case size_byte: value &= 0xFF; break; case size_word: value &= 0xFFFF; break; case size_dword: value &= 0xFFFFFFFF; break; default: break; } if(value >= start && value <= end) found = true; } } if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY) { duint value = basicinfo->memory.value; if(value >= start && value <= end) found = true; } if((basicinfo->type & TYPE_ADDR) == TYPE_ADDR) { duint value = basicinfo->addr; if(value >= start && value <= end) found = true; } if(found) { char addrText[20] = ""; sprintf_s(addrText, "%p", disasm->Address()); GuiReferenceSetRowCount(refinfo->refcount + 1); GuiReferenceSetCellContent(refinfo->refcount, 0, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly((duint)disasm->Address(), disassembly)) GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly); else GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str()); } return found; } bool cbInstrRefFindRange(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; VALUERANGE range; if(!valfromstring(argv[1], &range.start, false)) return false; if(argc < 3 || !valfromstring(argv[2], &range.end, false)) range.end = range.start; duint addr = 0; if(argc < 4 || !valfromstring(argv[3], &addr)) addr = GetContextDataEx(hActiveThread, UE_CIP); duint size = 0; if(argc >= 5) if(!valfromstring(argv[4], &size)) size = 0; duint ticks = GetTickCount(); char title[256] = ""; if(range.start == range.end) sprintf_s(title, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Constant: %p")), range.start); else sprintf_s(title, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Range: %p-%p")), range.start, range.end); duint refFindType = CURRENT_REGION; if(argc >= 6 && valfromstring(argv[5], &refFindType, true)) if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES) refFindType = CURRENT_REGION; int found = RefFind(addr, size, cbRefFind, &range, false, title, (REFFINDTYPE)refFindType, false); dprintf(QT_TRANSLATE_NOOP("DBG", "%u reference(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks)); varset("$result", found, false); return true; } static bool cbRefStr(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo) { if(!disasm || !basicinfo) //initialize { GuiReferenceInitialize(refinfo->name); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "String Address"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "String"))); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Follow in Disassembly and Dump")), "disasm $0;dump $2"); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Follow string in Dump")), "dump $2"); GuiReferenceSetSearchStartCol(2); //only search the strings GuiReferenceSetRowCount(0); GuiReferenceReloadData(); return true; } bool found = false; char string[MAX_STRING_SIZE] = ""; if(basicinfo->branch) //branches have no strings (jmp dword [401000]) return false; auto addRef = [&](duint strAddr) { char addrText[20] = ""; sprintf_s(addrText, "%p", disasm->Address()); char strAddrText[20] = ""; sprintf_s(strAddrText, "%p", strAddr); GuiReferenceSetRowCount(refinfo->refcount + 1); GuiReferenceSetCellContent(refinfo->refcount, 0, addrText); char disassembly[4096] = ""; if(GuiGetDisassembly((duint)disasm->Address(), disassembly)) GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly); else GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str()); GuiReferenceSetCellContent(refinfo->refcount, 2, strAddrText); GuiReferenceSetCellContent(refinfo->refcount, 3, string); refinfo->refcount++; }; if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE) { if(DbgGetStringAt(basicinfo->value.value, string)) addRef(basicinfo->value.value); } if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY) { if(DbgGetStringAt(basicinfo->memory.value, string)) addRef(basicinfo->memory.value); } return false; } static bool cbRefFuncPtr(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo) { if(!disasm || !basicinfo) //initialize { GuiReferenceInitialize(refinfo->name); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Function pointer"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label"))); GuiReferenceSetSearchStartCol(2); //only search the function pointers GuiReferenceSetRowCount(0); GuiReferenceReloadData(); return true; } bool found = false; if(basicinfo->branch) //we doesn't look for function pointers in jmp & calls return false; auto addRef = [&](duint pointer) { char addrText[20] = ""; sprintf_s(addrText, "%p", disasm->Address()); GuiReferenceSetRowCount(refinfo->refcount + 1); GuiReferenceSetCellContent(refinfo->refcount, 0, addrText); char disassembly[4096] = ""; if(GuiGetDisassembly((duint)disasm->Address(), disassembly)) GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly); else GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str()); char label[MAX_LABEL_SIZE]; sprintf_s(addrText, "%p", pointer); memset(label, 0, sizeof(label)); DbgGetLabelAt(pointer, SEG_DEFAULT, label); GuiReferenceSetCellContent(refinfo->refcount, 2, addrText); GuiReferenceSetCellContent(refinfo->refcount, 3, label); refinfo->refcount++; }; if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE) { if(MemIsCodePage(basicinfo->value.value, false)) addRef(basicinfo->value.value); } if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY) { if(MemIsCodePage(basicinfo->memory.value, false)) addRef(basicinfo->memory.value); } return false; } bool cbInstrRefStr(int argc, char* argv[]) { duint ticks = GetTickCount(); duint addr; duint size = 0; String TranslatedString; // If not specified, assume CURRENT_REGION by default if(argc < 2 || !valfromstring(argv[1], &addr, true)) addr = GetContextDataEx(hActiveThread, UE_CIP); if(argc >= 3) if(!valfromstring(argv[2], &size, true)) size = 0; duint refFindType = CURRENT_REGION; if(argc >= 4 && valfromstring(argv[3], &refFindType, true)) if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES) refFindType = CURRENT_REGION; TranslatedString = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Strings")); int found = RefFind(addr, size, cbRefStr, 0, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false); dprintf(QT_TRANSLATE_NOOP("DBG", "%u string(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks)); varset("$result", found, false); return true; } bool cbInstrRefFuncionPointer(int argc, char* argv[]) { duint ticks = GetTickCount(); duint addr; duint size = 0; String TranslatedString; // If not specified, assume CURRENT_REGION by default if(argc < 2 || !valfromstring(argv[1], &addr, true)) addr = GetContextDataEx(hActiveThread, UE_CIP); if(argc >= 3) if(!valfromstring(argv[2], &size, true)) size = 0; duint refFindType = CURRENT_REGION; if(argc >= 4 && valfromstring(argv[3], &refFindType, true)) if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != ALL_MODULES) refFindType = CURRENT_REGION; TranslatedString = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Function pointers")); int found = RefFind(addr, size, cbRefFuncPtr, 0, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false); dprintf(QT_TRANSLATE_NOOP("DBG", "%u function pointer(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks)); varset("$result", found, false); return true; } static bool cbModCallFind(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo) { if(!disasm || !basicinfo) //initialize { GuiReferenceInitialize(refinfo->name); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Destination"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); return true; } duint foundaddr = 0; char label[MAX_LABEL_SIZE] = ""; char module[MAX_MODULE_SIZE] = ""; duint base = ModBaseFromAddr(disasm->Address()), size = 0; if(!base) base = MemFindBaseAddr(disasm->Address(), &size); else size = ModSizeFromAddr(base); if(!base || !size) return false; //__debugbreak if(basicinfo->call) //we are looking for calls { if(basicinfo->addr && MemIsValidReadPtr(basicinfo->addr, true)) { if(basicinfo->addr < base || basicinfo->addr >= base + size) //call api foundaddr = basicinfo->addr; else //call [jmp.api] { BASIC_INSTRUCTION_INFO info; memset(&info, 0, sizeof(BASIC_INSTRUCTION_INFO)); if(disasmfast(basicinfo->addr, &info, true) && info.branch && !info.call && info.memory.value) //jmp [addr] { duint memaddr; if(MemRead(info.memory.value, &memaddr, sizeof(memaddr), nullptr, true)) { if((memaddr < base || memaddr >= base + size) && MemIsValidReadPtr(memaddr, true)) foundaddr = memaddr; } } } } } switch(disasm->GetId()) { case ZYDIS_MNEMONIC_CALL: //call dword ptr: [&api] case ZYDIS_MNEMONIC_MOV: //mov reg, dword ptr:[&api] if(!foundaddr && basicinfo->memory.value) { duint memaddr; if(MemRead(basicinfo->memory.value, &memaddr, sizeof(memaddr), nullptr, true)) { if((memaddr < base || memaddr >= base + size) && ModBaseFromAddr(memaddr)) foundaddr = memaddr; } } break; } if(foundaddr) { char addrText[20] = ""; sprintf_s(addrText, "%p", disasm->Address()); GuiReferenceSetRowCount(refinfo->refcount + 1); GuiReferenceSetCellContent(refinfo->refcount, 0, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly((duint)disasm->Address(), disassembly)) { GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly); } else { GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str()); } GuiReferenceSetCellContent(refinfo->refcount, 2, SymGetSymbolicName(foundaddr).c_str()); } return foundaddr != 0; } bool cbInstrModCallFind(int argc, char* argv[]) { duint addr; if(argc < 2 || !valfromstring(argv[1], &addr, true)) addr = GetContextDataEx(hActiveThread, UE_CIP); duint size = 0; if(argc >= 3) if(!valfromstring(argv[2], &size, true)) size = 0; duint refFindType = CURRENT_REGION; if(argc >= 4 && valfromstring(argv[3], &refFindType, true)) if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES) refFindType = CURRENT_REGION; duint ticks = GetTickCount(); String Calls = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Calls")); int found = RefFind(addr, size, cbModCallFind, 0, false, Calls.c_str(), (REFFINDTYPE)refFindType, false); dprintf(QT_TRANSLATE_NOOP("DBG", "%u call(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks)); varset("$result", found, false); return true; } struct GUIDHashObject { inline size_t operator()(const GUID & ref) const { size_t* p = (size_t*)&ref; #ifdef _WIN64 static_assert(sizeof(size_t) == 8, "The system is not 64-bit!"); return p[0] + p[1]; #else //x86 static_assert(sizeof(size_t) == 4, "The system is not 32-bit!"); return p[0] + p[1] + p[2] + p[3]; #endif //_WIN64 }; }; struct GUIDEqualObject { inline bool operator()(const GUID & a, const GUID & b) const { return memcmp(&a, &b, sizeof(GUID)) == 0; }; }; class GUIDInfo { public: String ProgId; String Description; String Path; GUIDInfo(const GUID & ref, HKEY CLSID) { wchar_t subkey[40]; HKEY hKey; StringFromGUID2(ref, subkey, 40); if(RegOpenKeyExW(CLSID, subkey, 0, KEY_READ, &hKey) == ERROR_SUCCESS) { Description = ReadValue(nullptr, hKey); HKEY hProgIdKey; if(RegOpenKeyExW(hKey, L"ProgId", 0, KEY_READ, &hProgIdKey) == ERROR_SUCCESS) { ProgId = ReadValue(nullptr, hProgIdKey); RegCloseKey(hProgIdKey); } else { ProgId = ""; } HKEY hPathKey; if(RegOpenKeyExW(hKey, L"InprocServer32", 0, KEY_READ, &hPathKey) == ERROR_SUCCESS) { Path = ReadValue(nullptr, hPathKey); RegCloseKey(hPathKey); } else { Path = ""; } RegCloseKey(hKey); } } private: String ReadValue(const wchar_t* name, HKEY hKey) { DWORD regType = 0; DWORD cbData = 0; if(RegQueryValueExW(hKey, name, nullptr, &regType, nullptr, &cbData)) return ""; if(regType != REG_SZ) return ""; Memory<wchar_t*> buffer(cbData + 2, "GUIDInfo::ReadValue"); buffer()[cbData / 2] = 0; //ensure the buffer is null-terminated if(RegQueryValueExW(hKey, name, nullptr, nullptr, reinterpret_cast<LPBYTE>(buffer()), &cbData)) return ""; return StringUtils::Utf16ToUtf8(buffer()); } }; struct GUIDRefInfo { std::unordered_map<GUID, size_t, GUIDHashObject, GUIDEqualObject>* allRegisteredGUIDs; std::vector<GUIDInfo>* allQueriedGUIDs; HKEY CLSID; }; static bool cbGUIDFind(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo) { if(!disasm || !basicinfo) //initialize { GuiReferenceInitialize(refinfo->name); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(40, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "GUID"))); GuiReferenceAddColumn(20, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "ProgId"))); GuiReferenceAddColumn(40, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Path"))); GuiReferenceAddColumn(40, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Description"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); return true; } duint value = 0; if(basicinfo->branch) //cannot branch to a GUID return false; GUIDRefInfo* refInfo = reinterpret_cast<GUIDRefInfo*>(refinfo->userinfo); if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE) value = basicinfo->value.value; if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY) value = basicinfo->memory.value; if((basicinfo->type & TYPE_ADDR) == TYPE_ADDR) value = basicinfo->addr; GUID guid; unsigned char membuffer[38 * 2]; bool found = false; memset(&membuffer, 0, sizeof(membuffer)); if(MemRead(value, &membuffer, sizeof(membuffer), nullptr, true)) { std::unordered_map<GUID, size_t, GUIDHashObject, GUIDEqualObject>::iterator iterator; if(membuffer[0] == '{' && membuffer[37] == '}' && membuffer[24] == '-' && membuffer[9] == '-' && membuffer[14] == '-' && membuffer[19] == '-') { //very likely a ASCII string representation of GUID wchar_t wideguid[39]; for(size_t i = 0; i < 38; i++) wideguid[i] = membuffer[i]; wideguid[38] = 0; if(CLSIDFromString(wideguid, &guid) == S_OK) { iterator = refInfo->allRegisteredGUIDs->find(guid); if(iterator != refInfo->allRegisteredGUIDs->end()) found = true; } } if(!found) { wchar_t* wideguid = reinterpret_cast<wchar_t*>(membuffer); if(wideguid[0] == L'{' && wideguid[37] == L'}' && wideguid[24] == L'-' && wideguid[9] == L'-' && wideguid[14] == L'-' && wideguid[19] == L'-') { //very likely a Unicode string representation of GUID if(CLSIDFromString(wideguid, &guid) == S_OK) { iterator = refInfo->allRegisteredGUIDs->find(guid); if(iterator != refInfo->allRegisteredGUIDs->end()) found = true; } } } if(!found) { memcpy(&guid, membuffer, sizeof(guid)); iterator = refInfo->allRegisteredGUIDs->find(guid); if(iterator != refInfo->allRegisteredGUIDs->end()) found = true; } if(found) { char addrText[20] = ""; sprintf_s(addrText, "%p", disasm->Address()); GuiReferenceSetRowCount(refinfo->refcount + 1); GuiReferenceSetCellContent(refinfo->refcount, 0, addrText); char disassembly[4096] = ""; if(GuiGetDisassembly((duint)disasm->Address(), disassembly)) GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly); else GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str()); wchar_t guidText[40]; StringFromGUID2(guid, guidText, 40); GuiReferenceSetCellContent(refinfo->refcount, 2, StringUtils::Utf16ToUtf8(guidText).c_str()); size_t infoIndex = iterator->second; if(infoIndex == 0) { refInfo->allQueriedGUIDs->push_back(GUIDInfo(guid, refInfo->CLSID)); infoIndex = refInfo->allQueriedGUIDs->size(); refInfo->allRegisteredGUIDs->at(guid) = infoIndex; } infoIndex--; GuiReferenceSetCellContent(refinfo->refcount, 3, refInfo->allQueriedGUIDs->at(infoIndex).ProgId.c_str()); GuiReferenceSetCellContent(refinfo->refcount, 4, refInfo->allQueriedGUIDs->at(infoIndex).Path.c_str()); GuiReferenceSetCellContent(refinfo->refcount, 5, refInfo->allQueriedGUIDs->at(infoIndex).Description.c_str()); } } return found; } bool cbInstrGUIDFind(int argc, char* argv[]) { duint ticks = GetTickCount(); duint addr; duint size = 0; String TranslatedString; std::unordered_map<GUID, size_t, GUIDHashObject, GUIDEqualObject> allRegisteredGUIDs; std::vector<GUIDInfo> allQueriedGUIDs; GUIDRefInfo refInfo; // If not specified, assume CURRENT_REGION by default if(argc < 2 || !valfromstring(argv[1], &addr, true)) addr = GetContextDataEx(hActiveThread, UE_CIP); if(argc >= 3) if(!valfromstring(argv[2], &size, true)) size = 0; duint refFindType = CURRENT_REGION; if(argc >= 4 && valfromstring(argv[3], &refFindType, true)) if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != ALL_MODULES) refFindType = CURRENT_REGION; HKEY CLSID; if(RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_READ, &CLSID)) { dputs(QT_TRANSLATE_NOOP("DBG", "RegOpenKeyExW() failed. Cannot enumerate GUIDs.")); return false; } wchar_t subkeyName[40]; subkeyName[39] = 0; DWORD i = 0; DWORD subkeyNameLen = 40; LONG result; while(result = RegEnumKeyExW(CLSID, i++, subkeyName, &subkeyNameLen, nullptr, nullptr, nullptr, nullptr), result == ERROR_SUCCESS || result == ERROR_MORE_DATA) { if(subkeyNameLen == 38 && result != ERROR_MORE_DATA) { if(subkeyName[0] == '{' && subkeyName[37] == '}' && subkeyName[24] == '-' && subkeyName[9] == '-' && subkeyName[14] == '-' && subkeyName[19] == '-') { //very likely a GUID GUID temp; if(CLSIDFromString(subkeyName, &temp) == S_OK) allRegisteredGUIDs.insert(std::make_pair(temp, 0)); } } subkeyNameLen = 40; subkeyName[39] = 0; } refInfo.allQueriedGUIDs = &allQueriedGUIDs; refInfo.allRegisteredGUIDs = &allRegisteredGUIDs; refInfo.CLSID = CLSID; TranslatedString = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "GUID")); int found = RefFind(addr, size, cbGUIDFind, &refInfo, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false); dprintf(QT_TRANSLATE_NOOP("DBG", "%u GUID(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks)); varset("$result", found, false); RegCloseKey(CLSID); return true; } bool cbInstrSetMaxFindResult(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint num; if(!valfromstring(argv[1], &num)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\""), argv[1]); return false; } maxFindResults = int(num & 0x7FFFFFFF); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-searching.h
#pragma once #include "command.h" bool cbInstrFind(int argc, char* argv[]); bool cbInstrFindAll(int argc, char* argv[]); bool cbInstrFindAllMem(int argc, char* argv[]); bool cbInstrFindAsm(int argc, char* argv[]); bool cbInstrRefFind(int argc, char* argv[]); bool cbInstrRefFindRange(int argc, char* argv[]); bool cbInstrRefStr(int argc, char* argv[]); bool cbInstrRefFuncionPointer(int argc, char* argv[]); bool cbInstrModCallFind(int argc, char* argv[]); bool cbInstrGUIDFind(int argc, char* argv[]); bool cbInstrSetMaxFindResult(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-thread-control.cpp
#include "cmd-thread-control.h" #include "variable.h" #include "memory.h" #include "value.h" #include "debugger.h" #include "console.h" #include "label.h" #include "historycontext.h" #include "thread.h" bool cbDebugCreatethread(int argc, char* argv[]) { if(argc < 2) return false; duint Entry = 0; duint Argument = 0; if(!valfromstring(argv[1], &Entry)) return false; if(!MemIsCodePage(Entry, false)) return false; if(argc > 2) { if(!valfromstring(argv[2], &Argument)) return false; } DWORD ThreadId = 0; auto hThread = CreateRemoteThread(fdProcessInfo->hProcess, nullptr, 0, LPTHREAD_START_ROUTINE(Entry), LPVOID(Argument), 0, &ThreadId); if(!hThread) { dputs(QT_TRANSLATE_NOOP("DBG", "Create thread failed!")); return false; } else { CloseHandle(hThread); char label[MAX_LABEL_SIZE]; if(!LabelGet(Entry, label)) label[0] = 0; #ifdef _WIN64 dprintf(QT_TRANSLATE_NOOP("DBG", "Thread %s created at %s %p(Argument=%llX)\n"), formatpidtid(ThreadId).c_str(), label, Entry, Argument); #else //x86 dprintf(QT_TRANSLATE_NOOP("DBG", "Thread %s created at %s %p(Argument=%X)\n"), formatpidtid(ThreadId).c_str(), label, Entry, Argument); #endif varset("$result", ThreadId, false); return true; } } bool cbDebugSwitchthread(int argc, char* argv[]) { duint threadid = fdProcessInfo->dwThreadId; //main thread if(argc > 1) if(!valfromstring(argv[1], &threadid, false)) return false; if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } //switch thread if(ThreadGetId(hActiveThread) != threadid) { hActiveThread = ThreadGetHandle((DWORD)threadid); HistoryClear(); DebugUpdateGuiAsync(GetContextDataEx(hActiveThread, UE_CIP), true); dputs(QT_TRANSLATE_NOOP("DBG", "Thread switched!")); } return true; } bool cbDebugSuspendthread(int argc, char* argv[]) { duint threadid = fdProcessInfo->dwThreadId; if(argc > 1) if(!valfromstring(argv[1], &threadid, false)) return false; if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } //suspend thread if(SuspendThread(ThreadGetHandle((DWORD)threadid)) == -1) { dputs(QT_TRANSLATE_NOOP("DBG", "Error suspending thread")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Thread suspended")); GuiUpdateAllViews(); return true; } bool cbDebugResumethread(int argc, char* argv[]) { duint threadid = fdProcessInfo->dwThreadId; if(argc > 1) if(!valfromstring(argv[1], &threadid, false)) return false; if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } //resume thread if(ResumeThread(ThreadGetHandle((DWORD)threadid)) == -1) { dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Thread resumed!")); GuiUpdateAllViews(); return true; } bool cbDebugKillthread(int argc, char* argv[]) { duint threadid = fdProcessInfo->dwThreadId; if(argc > 1) if(!valfromstring(argv[1], &threadid, false)) return false; duint exitcode = 0; if(argc > 2) if(!valfromstring(argv[2], &exitcode, false)) return false; if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } //terminate thread if(TerminateThread(ThreadGetHandle((DWORD)threadid), (DWORD)exitcode) != 0) { GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "Thread terminated")); return true; } dputs(QT_TRANSLATE_NOOP("DBG", "Error terminating thread!")); return false; } bool cbDebugSuspendAllThreads(int argc, char* argv[]) { dprintf(QT_TRANSLATE_NOOP("DBG", "%d/%d thread(s) suspended\n"), ThreadSuspendAll(), ThreadGetCount()); GuiUpdateAllViews(); return true; } bool cbDebugResumeAllThreads(int argc, char* argv[]) { dprintf(QT_TRANSLATE_NOOP("DBG", "%d/%d thread(s) resumed\n"), ThreadResumeAll(), ThreadGetCount()); GuiUpdateAllViews(); return true; } bool cbDebugSetPriority(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint threadid; if(!valfromstring(argv[1], &threadid, false)) return false; duint priority; if(!valfromstring(argv[2], &priority)) { if(_strcmpi(argv[2], "Normal") == 0) priority = THREAD_PRIORITY_NORMAL; else if(_strcmpi(argv[2], "AboveNormal") == 0) priority = THREAD_PRIORITY_ABOVE_NORMAL; else if(_strcmpi(argv[2], "TimeCritical") == 0) priority = THREAD_PRIORITY_TIME_CRITICAL; else if(_strcmpi(argv[2], "Idle") == 0) priority = THREAD_PRIORITY_IDLE; else if(_strcmpi(argv[2], "BelowNormal") == 0) priority = THREAD_PRIORITY_BELOW_NORMAL; else if(_strcmpi(argv[2], "Highest") == 0) priority = THREAD_PRIORITY_HIGHEST; else if(_strcmpi(argv[2], "Lowest") == 0) priority = THREAD_PRIORITY_LOWEST; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown priority value, read the help!")); return false; } } else { switch((int)priority) //check if the priority value is valid { case THREAD_PRIORITY_NORMAL: case THREAD_PRIORITY_ABOVE_NORMAL: case THREAD_PRIORITY_TIME_CRITICAL: case THREAD_PRIORITY_IDLE: case THREAD_PRIORITY_BELOW_NORMAL: case THREAD_PRIORITY_HIGHEST: case THREAD_PRIORITY_LOWEST: break; default: dputs(QT_TRANSLATE_NOOP("DBG", "Unknown priority value, read the help!")); return false; } } if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } //set thread priority if(SetThreadPriority(ThreadGetHandle((DWORD)threadid), (int)priority) == 0) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting thread priority")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Thread priority changed!")); GuiUpdateAllViews(); return true; } bool cbDebugSetthreadname(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint threadid; if(!valfromstring(argv[1], &threadid, false)) return false; THREADINFO info; if(!ThreadGetInfo((DWORD)threadid, info)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } auto newname = argc > 2 ? argv[2] : ""; if(!ThreadSetName((DWORD)threadid, newname)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to change the name for thread %s\n"), formatpidtid((DWORD)threadid).c_str()); return false; } if(!*info.threadName) dprintf(QT_TRANSLATE_NOOP("DBG", "Thread name set to \"%s\"!\n"), newname); else dprintf(QT_TRANSLATE_NOOP("DBG", "Thread name changed from \"%s\" to \"%s\"!\n"), info.threadName, newname); GuiUpdateAllViews(); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-thread-control.h
#pragma once #include "command.h" bool cbDebugCreatethread(int argc, char* argv[]); bool cbDebugSwitchthread(int argc, char* argv[]); bool cbDebugSuspendthread(int argc, char* argv[]); bool cbDebugResumethread(int argc, char* argv[]); bool cbDebugKillthread(int argc, char* argv[]); bool cbDebugSuspendAllThreads(int argc, char* argv[]); bool cbDebugResumeAllThreads(int argc, char* argv[]); bool cbDebugSetPriority(int argc, char* argv[]); bool cbDebugSetthreadname(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-tracing.cpp
#include "cmd-tracing.h" #include "debugger.h" #include "threading.h" #include "module.h" #include "console.h" #include "cmd-debug-control.h" #include "value.h" #include "variable.h" #include "TraceRecord.h" extern std::vector<std::pair<duint, duint>> RunToUserCodeBreakpoints; static bool genericConditionalTraceCommand(TITANCBSTEP callback, STEPFUNCTION stepFunction, int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(dbgtraceactive()) { dputs(QT_TRANSLATE_NOOP("DBG", "Trace already active")); return false; } if(dbgisrunning()) { dputs(QT_TRANSLATE_NOOP("DBG", "Cannot start a trace when running, pause execution first.")); return false; } duint maxCount; if(!BridgeSettingGetUint("Engine", "MaxTraceCount", &maxCount) || !maxCount) maxCount = 50000; if(argc > 2 && !valfromstring(argv[2], &maxCount, false)) return false; if(!dbgsettracecondition(*argv[1] ? argv[1] : "0", maxCount)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), argv[1]); return false; } stepFunction(callback); return cbDebugRunInternal(1, argv, history_clear); } static bool conditionalTraceIntoCommand(TITANCBSTEP callback, int argc, char* argv[]) { return genericConditionalTraceCommand(callback, StepIntoWow64, argc, argv); } static bool conditionalTraceOverCommand(TITANCBSTEP callback, int argc, char* argv[]) { return genericConditionalTraceCommand(callback, StepOverWrapper, argc, argv); } bool cbDebugTraceIntoConditional(int argc, char* argv[]) { return conditionalTraceIntoCommand(cbTraceIntoConditionalStep, argc, argv); } bool cbDebugTraceOverConditional(int argc, char* argv[]) { return conditionalTraceOverCommand(cbTraceOverConditionalStep, argc, argv); } bool cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[]) { if(argc == 1) { const char* new_argv[] = { "tibt", "0" }; return conditionalTraceIntoCommand(cbTraceIntoBeyondTraceRecordStep, 2, (char**)new_argv); } else return conditionalTraceIntoCommand(cbTraceIntoBeyondTraceRecordStep, argc, argv); } bool cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[]) { if(argc == 1) { const char* new_argv[] = { "tobt", "0" }; return conditionalTraceOverCommand(cbTraceOverBeyondTraceRecordStep, 2, (char**)new_argv); } else return conditionalTraceOverCommand(cbTraceOverBeyondTraceRecordStep, argc, argv); } bool cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[]) { if(argc == 1) { const char* new_argv[] = { "tiit", "0" }; return conditionalTraceIntoCommand(cbTraceIntoIntoTraceRecordStep, 2, (char**)new_argv); } else return conditionalTraceIntoCommand(cbTraceIntoIntoTraceRecordStep, argc, argv); } bool cbDebugTraceOverIntoTraceRecord(int argc, char* argv[]) { if(argc == 1) { const char* new_argv[] = { "toit", "0" }; return conditionalTraceOverCommand(cbTraceOverIntoTraceRecordStep, 2, (char**)new_argv); } else return conditionalTraceOverCommand(cbTraceOverIntoTraceRecordStep, argc, argv); } bool cbDebugRunToParty(int argc, char* argv[]) { if(dbgisrunning()) { dputs(QT_TRANSLATE_NOOP("DBG", "Cannot start a trace when running, pause execution first.")); return false; } EXCLUSIVE_ACQUIRE(LockRunToUserCode); if(!RunToUserCodeBreakpoints.empty()) { dputs(QT_TRANSLATE_NOOP("DBG", "Run to party is busy.\n")); return false; } if(IsArgumentsLessThan(argc, 2)) return false; int party = atoi(argv[1]); // party is a signed integer ModEnum([party](const MODINFO & i) { if(i.party == party) { for(auto j : i.sections) { BREAKPOINT bp; if(!BpGet(j.addr, BPMEMORY, nullptr, &bp)) { size_t size = DbgMemGetPageSize(j.addr); RunToUserCodeBreakpoints.push_back(std::make_pair(j.addr, size)); SetMemoryBPXEx(j.addr, size, UE_MEMORY_EXECUTE, false, cbRunToUserCodeBreakpoint); } } } }); return cbDebugRunInternal(1, argv, history_clear); } bool cbDebugRunToUserCode(int argc, char* argv[]) { const char* newargv[] = { "RunToParty", "0" }; return cbDebugRunToParty(2, (char**)newargv); } bool cbDebugTraceSetLog(int argc, char* argv[]) { auto text = argc > 1 ? argv[1] : ""; auto condition = argc > 2 ? argv[2] : ""; if(!dbgsettracelog(condition, text)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), condition); return false; } return true; } bool cbDebugTraceSetCommand(int argc, char* argv[]) { auto text = argc > 1 ? argv[1] : ""; auto condition = argc > 2 ? argv[2] : ""; if(!dbgsettracecmd(condition, text)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), condition); return false; } return true; } bool cbDebugTraceSetLogFile(int argc, char* argv[]) { auto fileName = argc > 1 ? argv[1] : ""; return dbgsettracelogfile(fileName); } bool cbDebugStartTraceRecording(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; return TraceRecord.enableTraceRecording(true, argv[1]); } bool cbDebugStopTraceRecording(int argc, char* argv[]) { return TraceRecord.enableTraceRecording(false, nullptr); }
C/C++
x64dbg-development/src/dbg/commands/cmd-tracing.h
#pragma once #include "command.h" bool cbDebugTraceIntoConditional(int argc, char* argv[]); bool cbDebugTraceOverConditional(int argc, char* argv[]); bool cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[]); bool cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[]); bool cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[]); bool cbDebugTraceOverIntoTraceRecord(int argc, char* argv[]); bool cbDebugRunToParty(int argc, char* argv[]); bool cbDebugRunToUserCode(int argc, char* argv[]); bool cbDebugTraceSetLog(int argc, char* argv[]); bool cbDebugTraceSetCommand(int argc, char* argv[]); bool cbDebugTraceSetLogFile(int argc, char* argv[]); bool cbDebugStartTraceRecording(int argc, char* argv[]); bool cbDebugStopTraceRecording(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-types.cpp
#include "cmd-types.h" #include "console.h" #include "encodemap.h" #include "value.h" #include "types.h" #include "memory.h" #include "variable.h" #include "filehelper.h" #include "label.h" using namespace Types; static bool cbInstrDataGeneric(ENCODETYPE type, int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr; if(!valfromstring(argv[1], &addr, false)) return false; duint size = 1; if(argc >= 3) if(!valfromstring(argv[2], &size, false)) return false; bool created; if(!EncodeMapSetType(addr, size, type, &created)) { dputs(QT_TRANSLATE_NOOP("DBG", "EncodeMapSetType failed...")); return false; } if(created) DbgCmdExec("disasm dis.sel()"); else GuiUpdateDisassemblyView(); return false; } bool cbInstrDataUnknown(int argc, char* argv[]) { return cbInstrDataGeneric(enc_unknown, argc, argv); } bool cbInstrDataByte(int argc, char* argv[]) { return cbInstrDataGeneric(enc_byte, argc, argv); } bool cbInstrDataWord(int argc, char* argv[]) { return cbInstrDataGeneric(enc_word, argc, argv); } bool cbInstrDataDword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_dword, argc, argv); } bool cbInstrDataFword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_fword, argc, argv); } bool cbInstrDataQword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_qword, argc, argv); } bool cbInstrDataTbyte(int argc, char* argv[]) { return cbInstrDataGeneric(enc_tbyte, argc, argv); } bool cbInstrDataOword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_oword, argc, argv); } bool cbInstrDataMmword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_mmword, argc, argv); } bool cbInstrDataXmmword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_xmmword, argc, argv); } bool cbInstrDataYmmword(int argc, char* argv[]) { return cbInstrDataGeneric(enc_ymmword, argc, argv); } bool cbInstrDataFloat(int argc, char* argv[]) { return cbInstrDataGeneric(enc_real4, argc, argv); } bool cbInstrDataDouble(int argc, char* argv[]) { return cbInstrDataGeneric(enc_real8, argc, argv); } bool cbInstrDataLongdouble(int argc, char* argv[]) { return cbInstrDataGeneric(enc_real10, argc, argv); } bool cbInstrDataAscii(int argc, char* argv[]) { return cbInstrDataGeneric(enc_ascii, argc, argv); } bool cbInstrDataUnicode(int argc, char* argv[]) { return cbInstrDataGeneric(enc_unicode, argc, argv); } bool cbInstrDataCode(int argc, char* argv[]) { return cbInstrDataGeneric(enc_code, argc, argv); } bool cbInstrDataJunk(int argc, char* argv[]) { return cbInstrDataGeneric(enc_junk, argc, argv); } bool cbInstrDataMiddle(int argc, char* argv[]) { return cbInstrDataGeneric(enc_middle, argc, argv); } #define towner "cmd" bool cbInstrAddType(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; if(!AddType(towner, argv[1], argv[2])) { dputs(QT_TRANSLATE_NOOP("DBG", "AddType failed")); return false; } dprintf_untranslated("typedef %s %s;\n", argv[2], argv[1]); return true; } bool cbInstrAddStruct(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(!AddStruct(towner, argv[1])) { dputs(QT_TRANSLATE_NOOP("DBG", "AddStruct failed")); return false; } dprintf_untranslated("struct %s;\n", argv[1]); return true; } bool cbInstrAddUnion(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(!AddUnion(towner, argv[1])) { dputs(QT_TRANSLATE_NOOP("DBG", "AddUnion failed")); return false; } dprintf_untranslated("union %s;\n", argv[1]); return true; } bool cbInstrAddMember(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 4)) return false; auto parent = argv[1]; auto type = argv[2]; auto name = argv[3]; int arrsize = 0, offset = -1; if(argc > 4) { duint value; if(!valfromstring(argv[4], &value, false)) return false; arrsize = int(value); if(argc > 5) { if(!valfromstring(argv[5], &value, false)) return false; offset = int(value); } } if(!AddMember(parent, type, name, arrsize, offset)) { dputs(QT_TRANSLATE_NOOP("DBG", "AddMember failed")); return false; } dprintf_untranslated("%s: %s %s", parent, type, name); if(arrsize > 0) dprintf_untranslated("[%d]", arrsize); if(offset >= 0) dprintf_untranslated(" (offset: %d)", offset); dputs_untranslated(";"); return true; } bool cbInstrAppendMember(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; auto type = argv[1]; auto name = argv[2]; int arrsize = 0, offset = -1; if(argc > 3) { duint value; if(!valfromstring(argv[3], &value, false)) return false; arrsize = int(value); if(argc > 4) { if(!valfromstring(argv[4], &value, false)) return false; offset = int(value); } } if(!AppendMember(type, name, arrsize, offset)) { dputs(QT_TRANSLATE_NOOP("DBG", "AppendMember failed")); return false; } dprintf_untranslated("%s %s", type, name); if(arrsize > 0) dprintf_untranslated("[%d]", arrsize); if(offset >= 0) dprintf_untranslated(" (offset: %d)", offset); dputs_untranslated(";"); return true; } bool cbInstrAddFunction(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; auto name = argv[1]; auto rettype = argv[2]; auto callconv = Cdecl; auto noreturn = false; if(argc > 3) { if(scmp(argv[3], "cdecl")) callconv = Cdecl; else if(scmp(argv[3], "stdcall")) callconv = Stdcall; else if(scmp(argv[3], "thiscall")) callconv = Thiscall; else if(scmp(argv[3], "delphi")) callconv = Delphi; else { dprintf(QT_TRANSLATE_NOOP("DBG", "Unknown calling convention \"%s\"\n"), argv[3]); return false; } if(argc > 4) { duint value; if(!valfromstring(argv[4], &value, false)) return false; noreturn = value != 0; } } if(!AddFunction(towner, name, rettype, callconv, noreturn)) { dputs(QT_TRANSLATE_NOOP("DBG", "AddFunction failed")); return false; } dprintf_untranslated("%s %s();\n", rettype, name); return true; } bool cbInstrAddArg(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 4)) return false; if(!AddArg(argv[1], argv[2], argv[3])) { dputs(QT_TRANSLATE_NOOP("DBG", "AddArg failed")); return false; } dprintf_untranslated("%s: %s %s;\n", argv[1], argv[2], argv[3]); return true; } bool cbInstrAppendArg(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; if(!AppendArg(argv[1], argv[2])) { dputs(QT_TRANSLATE_NOOP("DBG", "AppendArg failed")); return false; } dprintf_untranslated("%s %s;\n", argv[1], argv[2]); return true; } bool cbInstrSizeofType(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; auto size = SizeofType(argv[1]); if(!size) { dputs(QT_TRANSLATE_NOOP("DBG", "SizeofType failed")); return false; } dprintf_untranslated("sizeof(%s) = %d\n", argv[1], size); varset("$result", size, false); return true; } struct PrintVisitor : TypeManager::Visitor { explicit PrintVisitor(duint data = 0, int maxPtrDepth = 0) : mAddr(data), mMaxPtrDepth(maxPtrDepth) { } template<typename T> static String basicPrint(void* data, const char* format) { return StringUtils::sprintf(format, *(T*)data); } template<typename T, typename U> static String basicPrint(void* data, const char* format) { return StringUtils::sprintf(format, *(T*)data, *(U*)data); } static bool cbPrintPrimitive(const TYPEDESCRIPTOR* type, char* dest, size_t* destCount) { if(!type->addr) { *dest = '\0'; return true; } String valueStr; Memory<unsigned char*> data(type->size); if(MemRead(type->addr + type->offset, data(), data.size())) { if(type->reverse) std::reverse(data(), data() + data.size()); switch(Primitive(type->id)) { case Void: valueStr.clear(); break; case Int8: valueStr += StringUtils::sprintf("0x%02X, '%s'", *(unsigned char*)data(), StringUtils::Escape(*(char*)data()).c_str()); break; case Uint8: valueStr += basicPrint<unsigned char, unsigned char>(data(), "0x%02X, %d"); break; case Int16: valueStr += basicPrint<unsigned short, short>(data(), "0x%04X, %d"); break; case Uint16: valueStr += basicPrint<unsigned short, unsigned short>(data(), "0x%04X, %u"); break; case Int32: valueStr += basicPrint<unsigned int, int>(data(), "0x%08X, %d"); break; case Uint32: valueStr += basicPrint<unsigned int, unsigned int>(data(), "0x%08X, %u"); break; case Int64: valueStr += basicPrint<unsigned long long, long long>(data(), "0x%016llX, %lld"); break; case Uint64: valueStr += basicPrint<unsigned long long, unsigned long long>(data(), "0x%016llX, %llu"); break; case Dsint: #ifdef _WIN64 valueStr += basicPrint<duint, dsint>(data(), "0x%016llX, %lld"); #else valueStr += basicPrint<duint, dsint>(data(), "0x%08X, %d"); #endif //_WIN64 break; case Duint: #ifdef _WIN64 valueStr += basicPrint<duint, duint>(data(), "0x%016llX, %llu"); #else valueStr += basicPrint<duint, duint>(data(), "0x%08X, %u"); #endif //_WIN64 break; case Float: valueStr += basicPrint<float>(data(), "%f"); break; case Double: valueStr += basicPrint<double>(data(), "%f"); break; case Pointer: valueStr += basicPrint<void*>(data(), "0x%p"); break; case PtrString: { valueStr += basicPrint<char*>(data(), "0x%p "); Memory<char*> strdata(MAX_STRING_SIZE + 1); if(MemRead(*(duint*)data(), strdata(), strdata.size() - 1)) { valueStr += "\""; valueStr += StringUtils::Escape(strdata()); valueStr.push_back('\"'); } else valueStr += "???"; } break; case PtrWString: { valueStr += basicPrint<wchar_t*>(data(), "0x%p "); Memory<wchar_t*> strdata(MAX_STRING_SIZE * 2 + 2); if(MemRead(*(duint*)data(), strdata(), strdata.size() - 2)) { valueStr += "L\""; valueStr += StringUtils::Utf16ToUtf8(strdata()); valueStr.push_back('\"'); } else valueStr += "???"; } break; default: return false; } } else valueStr = "???"; if(*destCount <= valueStr.size()) { *destCount = valueStr.size() + 1; return false; } strcpy_s(dest, *destCount, valueStr.c_str()); return true; } bool visitType(const Member & member, const Type & type) override { if(!mParents.empty() && parent().type == Parent::Union) mOffset = parent().offset; String tname; auto ptype = mParents.empty() ? Parent::Struct : parent().type; if(ptype == Parent::Array) { tname = StringUtils::sprintf("%s[%u]", member.name.c_str(), parent().index++); } else { tname = StringUtils::sprintf("%s %s", type.name.c_str(), member.name.c_str()); // Prepend struct/union to pointer types if(!type.pointto.empty()) { auto ptrname = StructUnionPtrType(type.pointto); if(!ptrname.empty()) tname = ptrname + " " + tname; } } std::string path; for(size_t i = 0; i < mPath.size(); i++) { if(ptype == Parent::Array && i + 1 == mPath.size()) break; path.append(mPath[i]); } path.append(member.name); auto ptr = mAddr + mOffset; if(MemIsValidReadPtr(ptr)) { if(!LabelGet(ptr, nullptr) && (parent().index == 1 || ptype != Parent::Array)) LabelSet(ptr, path.c_str(), false, true); } TYPEDESCRIPTOR td; td.expanded = false; td.reverse = false; td.name = tname.c_str(); td.addr = mAddr; td.offset = mOffset; td.id = type.primitive; td.size = type.size; td.callback = cbPrintPrimitive; td.userdata = nullptr; mNode = GuiTypeAddNode(mParents.empty() ? nullptr : parent().node, &td); mOffset += type.size; return true; } bool visitStructUnion(const Member & member, const StructUnion & type) override { if(!mParents.empty() && parent().type == Parent::Type::Union) mOffset = parent().offset; String tname = StringUtils::sprintf("%s %s %s", type.isunion ? "union" : "struct", type.name.c_str(), member.name.c_str()); TYPEDESCRIPTOR td; td.expanded = true; td.reverse = false; td.name = tname.c_str(); td.addr = mAddr; td.offset = mOffset; td.id = Void; td.size = type.size; td.callback = nullptr; td.userdata = nullptr; auto node = GuiTypeAddNode(mParents.empty() ? nullptr : parent().node, &td); mPath.push_back((member.name == "visit" ? type.name : member.name) + "."); mParents.push_back(Parent(type.isunion ? Parent::Union : Parent::Struct)); parent().node = node; parent().size = td.size; parent().offset = mOffset; return true; } bool visitArray(const Member & member) override { String tname = StringUtils::sprintf("%s %s[%d]", member.type.c_str(), member.name.c_str(), member.arrsize); TYPEDESCRIPTOR td; td.expanded = member.arrsize <= 5; td.reverse = false; td.name = tname.c_str(); td.addr = mAddr; td.offset = mOffset; td.id = Void; td.size = member.arrsize * SizeofType(member.type); td.callback = nullptr; td.userdata = nullptr; auto node = GuiTypeAddNode(mParents.empty() ? nullptr : parent().node, &td); mPath.push_back(member.name + "."); mParents.push_back(Parent(Parent::Array)); parent().node = node; parent().size = td.size; return true; } bool visitPtr(const Member & member, const Type & type) override { auto offset = mOffset; auto res = visitType(member, type); //print the pointer value if(mPtrDepth >= mMaxPtrDepth) return false; duint value = 0; if(!mAddr || !MemRead(mAddr + offset, &value, sizeof(value))) return false; mPath.push_back(member.name + "->"); mParents.push_back(Parent(Parent::Pointer)); parent().offset = mOffset; parent().addr = mAddr; parent().node = mNode; parent().size = type.size; mOffset = 0; mAddr = value; mPtrDepth++; return res; } bool visitBack(const Member & member) override { if(parent().type == Parent::Pointer) { mOffset = parent().offset; mAddr = parent().addr; mPtrDepth--; } else if(parent().type == Parent::Union) { mOffset = parent().offset + parent().size; } mParents.pop_back(); mPath.pop_back(); return true; } private: struct Parent { enum Type { Struct, Union, Array, Pointer }; Type type; unsigned int index = 0; duint addr = 0; duint offset = 0; void* node = nullptr; int size = 0; explicit Parent(Type type) : type(type) { } }; Parent & parent() { return mParents[mParents.size() - 1]; } std::vector<Parent> mParents; duint mOffset = 0; duint mAddr = 0; int mPtrDepth = 0; int mMaxPtrDepth = 0; void* mNode = nullptr; std::vector<String> mPath; }; bool cbInstrVisitType(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; auto type = argv[1]; auto name = "visit"; duint addr = 0; auto maxPtrDepth = 0; if(argc > 2) { if(!valfromstring(argv[2], &addr, false)) return false; if(argc > 3) { duint value; if(!valfromstring(argv[3], &value, false)) return false; maxPtrDepth = int(value); if(argc > 4) name = argv[4]; } } PrintVisitor visitor(addr, maxPtrDepth); if(!VisitType(type, name, visitor)) { dputs(QT_TRANSLATE_NOOP("DBG", "VisitType failed")); return false; } GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "Done!")); return true; } bool cbInstrClearTypes(int argc, char* argv[]) { auto owner = towner; if(argc > 1) owner = argv[1]; ClearTypes(owner); return true; } bool cbInstrRemoveType(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(!RemoveType(argv[1])) { dputs(QT_TRANSLATE_NOOP("DBG", "RemoveType failed")); return false; } dprintf(QT_TRANSLATE_NOOP("DBG", "Type %s removed\n"), argv[1]); return true; } bool cbInstrEnumTypes(int argc, char* argv[]) { std::vector<TypeManager::Summary> typeList; EnumTypes(typeList); for(auto & type : typeList) { if(type.owner.empty()) type.owner.assign("x64dbg"); dprintf_untranslated("%s: %s %s, sizeof(%s) = %d\n", type.owner.c_str(), type.kind.c_str(), type.name.c_str(), type.name.c_str(), type.size); } return true; } bool cbInstrLoadTypes(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; auto owner = FileHelper::GetFileName(argv[1]); ClearTypes(owner); if(!LoadTypesFile(argv[1], owner)) { dputs(QT_TRANSLATE_NOOP("DBG", "LoadTypes failed")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Types loaded")); return true; } bool cbInstrParseTypes(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; auto owner = FileHelper::GetFileName(argv[1]); ClearTypes(owner); std::string data; if(!FileHelper::ReadAllText(argv[1], data)) { dputs("failed to read file!"); return false; } if(!ParseTypes(data, owner)) return false; dprintf("Parsed header: %s\n", argv[1]); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-types.h
#pragma once #include "command.h" bool cbInstrDataUnknown(int argc, char* argv[]); bool cbInstrDataByte(int argc, char* argv[]); bool cbInstrDataWord(int argc, char* argv[]); bool cbInstrDataDword(int argc, char* argv[]); bool cbInstrDataFword(int argc, char* argv[]); bool cbInstrDataQword(int argc, char* argv[]); bool cbInstrDataTbyte(int argc, char* argv[]); bool cbInstrDataOword(int argc, char* argv[]); bool cbInstrDataMmword(int argc, char* argv[]); bool cbInstrDataXmmword(int argc, char* argv[]); bool cbInstrDataYmmword(int argc, char* argv[]); bool cbInstrDataFloat(int argc, char* argv[]); bool cbInstrDataDouble(int argc, char* argv[]); bool cbInstrDataLongdouble(int argc, char* argv[]); bool cbInstrDataAscii(int argc, char* argv[]); bool cbInstrDataUnicode(int argc, char* argv[]); bool cbInstrDataCode(int argc, char* argv[]); bool cbInstrDataJunk(int argc, char* argv[]); bool cbInstrDataMiddle(int argc, char* argv[]); bool cbInstrAddType(int argc, char* argv[]); bool cbInstrAddStruct(int argc, char* argv[]); bool cbInstrAddUnion(int argc, char* argv[]); bool cbInstrAddMember(int argc, char* argv[]); bool cbInstrAppendMember(int argc, char* argv[]); bool cbInstrAddFunction(int argc, char* argv[]); bool cbInstrAddArg(int argc, char* argv[]); bool cbInstrAppendArg(int argc, char* argv[]); bool cbInstrSizeofType(int argc, char* argv[]); bool cbInstrVisitType(int argc, char* argv[]); bool cbInstrClearTypes(int argc, char* argv[]); bool cbInstrRemoveType(int argc, char* argv[]); bool cbInstrEnumTypes(int argc, char* argv[]); bool cbInstrLoadTypes(int argc, char* argv[]); bool cbInstrParseTypes(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-undocumented.cpp
#include "cmd-undocumented.h" #include "console.h" #include "function.h" #include "bookmark.h" #include "label.h" #include "comment.h" #include "debugger.h" #include "variable.h" #include "loop.h" #include "zydis_wrapper.h" #include "mnemonichelp.h" #include "value.h" #include "symbolinfo.h" #include "argument.h" #include "expressionparser.h" bool cbBadCmd(int argc, char* argv[]) { duint value = 0; int valsize = 0; bool isvar = false; bool hexonly = false; bool silent = false; bool baseonly = false; bool allowassign = true; ExpressionParser parser(argv[0]); ExpressionParser::EvalValue evalue(0); if(parser.Calculate(evalue, valuesignedcalc(), allowassign, silent, baseonly, &valsize, &isvar, &hexonly)) { if(evalue.isString) { dputs_untranslated(StringUtils::Escape(evalue.data).c_str()); } else if(evalue.DoEvaluate(value, silent, baseonly, &valsize, &isvar, &hexonly)) { varset("$ans", value, true); if(valsize) valsize *= 2; else valsize = 1; char format_str[deflen] = ""; auto symbolic = SymGetSymbolicName(value, false); if(symbolic.length()) symbolic = " " + symbolic; if(isvar) // and *cmd!='.' and *cmd!='x') //prevent stupid 0=0 stuff { if(value > 9 && !hexonly) { if(!valuesignedcalc()) //signed numbers #ifdef _WIN64 sprintf_s(format_str, "%%s=%%.%dllX (%%llud)%%s\n", valsize); // TODO: This and the following statements use "%llX" for a "int"-typed variable. Maybe we can use "%X" everywhere? #else //x86 sprintf_s(format_str, "%%s=%%.%dX (%%ud)%%s\n", valsize); #endif //_WIN64 else #ifdef _WIN64 sprintf_s(format_str, "%%s=%%.%dllX (%%lld)%%s\n", valsize); #else //x86 sprintf_s(format_str, "%%s=%%.%dX (%%d)%%s\n", valsize); #endif //_WIN64 dprintf_untranslated(format_str, *argv, value, value, symbolic.c_str()); } else { sprintf_s(format_str, "%%s=%%.%dX%%s\n", valsize); dprintf_untranslated(format_str, *argv, value, symbolic.c_str()); } } else { if(value > 9 && !hexonly) { if(!valuesignedcalc()) //signed numbers #ifdef _WIN64 sprintf_s(format_str, "%%s=%%.%dllX (%%llud)%%s\n", valsize); #else //x86 sprintf_s(format_str, "%%s=%%.%dX (%%ud)%%s\n", valsize); #endif //_WIN64 else #ifdef _WIN64 sprintf_s(format_str, "%%s=%%.%dllX (%%lld)%%s\n", valsize); #else //x86 sprintf_s(format_str, "%%s=%%.%dX (%%d)%%s\n", valsize); #endif //_WIN64 #ifdef _WIN64 sprintf_s(format_str, "%%.%dllX (%%llud)%%s\n", valsize); #else //x86 sprintf_s(format_str, "%%.%dX (%%ud)%%s\n", valsize); #endif //_WIN64 dprintf_untranslated(format_str, value, value, symbolic.c_str()); } else { #ifdef _WIN64 sprintf_s(format_str, "%%.%dllX%%s\n", valsize); #else //x86 sprintf_s(format_str, "%%.%dX%%s\n", valsize); #endif //_WIN64 dprintf_untranslated(format_str, value, symbolic.c_str()); } } } else //unknown command { dprintf_untranslated("Unknown command/expression: \"%s\"\n", *argv); return false; } } return true; } bool cbDebugBenchmark(int argc, char* argv[]) { duint addr = MemFindBaseAddr(GetContextDataEx(hActiveThread, UE_CIP), 0); DWORD ticks = GetTickCount(); for(duint i = addr; i < addr + 100000; i++) { CommentSet(i, "test", false); LabelSet(i, "test", false); BookmarkSet(i, false); FunctionAdd(i, i, false); ArgumentAdd(i, i, false); LoopAdd(i, i, false); } dprintf_untranslated("%ums\n", GetTickCount() - ticks); return true; } bool cbInstrSetstr(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; varnew(argv[1], 0, VAR_USER); if(!vargettype(argv[1], 0)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such variable \"%s\"!\n"), argv[1]); return false; } if(!varset(argv[1], argv[2], false)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to set variable \"%s\"!\n"), argv[1]); return false; } cmddirectexec(StringUtils::sprintf("getstr \"%s\"", argv[1]).c_str()); return true; } bool cbInstrGetstr(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; VAR_VALUE_TYPE valtype; if(!vargettype(argv[1], 0, &valtype)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such variable \"%s\"!\n"), argv[1]); return false; } if(valtype != VAR_STRING) { dprintf(QT_TRANSLATE_NOOP("DBG", "Variable \"%s\" is not a string!\n"), argv[1]); return false; } int size; if(!varget(argv[1], (char*)0, &size, 0) || !size) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable size \"%s\"!\n"), argv[1]); return false; } Memory<char*> string(size + 1, "cbInstrGetstr:string"); if(!varget(argv[1], string(), &size, 0)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable data \"%s\"!\n"), argv[1]); return false; } dprintf_untranslated("%s=\"%s\"\n", argv[1], string()); return true; } bool cbInstrCopystr(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; VAR_VALUE_TYPE valtype; if(!vargettype(argv[2], 0, &valtype)) { dprintf(QT_TRANSLATE_NOOP("DBG", "No such variable \"%s\"!\n"), argv[2]); return false; } if(valtype != VAR_STRING) { dprintf(QT_TRANSLATE_NOOP("DBG", "Variable \"%s\" is not a string!\n"), argv[2]); return false; } int size; if(!varget(argv[2], (char*)0, &size, 0) || !size) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable size \"%s\"!\n"), argv[2]); return false; } Memory<char*> string(size + 1, "cbInstrGetstr:string"); if(!varget(argv[2], string(), &size, 0)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable data \"%s\"!\n"), argv[2]); return false; } duint addr; if(!valfromstring(argv[1], &addr)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]); return false; } if(!MemPatch(addr, string(), strlen(string()))) { dputs(QT_TRANSLATE_NOOP("DBG", "MemPatch failed!")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "String written!")); GuiUpdateAllViews(); GuiUpdatePatches(); return true; } bool cbInstrZydis(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr) || !MemIsValidReadPtr(addr)) { dprintf_untranslated("Invalid address \"%s\"\n", argv[1]); return false; } unsigned char data[16]; if(!MemRead(addr, data, sizeof(data))) { dprintf_untranslated("Could not read memory at %p\n", addr); return false; } if(argc > 2) if(!valfromstring(argv[2], &addr, false)) return false; Zydis cp; if(!cp.Disassemble(addr, data)) { dputs_untranslated("Failed to disassemble!\n"); return false; } auto instr = cp.GetInstr(); int argcount = instr->operandCount; dputs_untranslated(cp.InstructionText(true).c_str()); dprintf_untranslated("prefix size: %d\n", instr->raw.prefixes.count); if(instr->attributes & ZYDIS_ATTRIB_HAS_REX) dprintf_untranslated("rex.W: %d, rex.R: %d, rex.X: %d, rex.B: %d, rex.data: %02x\n", instr->raw.rex.W, instr->raw.rex.R, instr->raw.rex.X, instr->raw.rex.B, instr->raw.rex.data[0]); dprintf_untranslated("disp.offset: %d, disp.size: %d\n", instr->raw.disp.offset, instr->raw.disp.size); dprintf_untranslated("imm[0].offset: %d, imm[0].size: %d\n", instr->raw.imm[0].offset, instr->raw.imm[0].size); dprintf_untranslated("imm[1].offset: %d, imm[1].size: %d\n", instr->raw.imm[1].offset, instr->raw.imm[1].size); dprintf_untranslated("size: %d, id: %d, opcount: %d\n", cp.Size(), cp.GetId(), instr->operandCount); auto rwstr = [](uint8_t action) { switch(action) { case ZYDIS_OPERAND_ACTION_READ: case ZYDIS_OPERAND_ACTION_CONDREAD: return "read"; case ZYDIS_OPERAND_ACTION_WRITE: case ZYDIS_OPERAND_ACTION_CONDWRITE: return "write"; case ZYDIS_OPERAND_ACTION_READWRITE: case ZYDIS_OPERAND_ACTION_READ_CONDWRITE: case ZYDIS_OPERAND_ACTION_CONDREAD_WRITE: return "read+write"; default: return "???"; } }; auto vis = [](uint8_t visibility) { switch(visibility) { case ZYDIS_OPERAND_VISIBILITY_INVALID: return "invalid"; case ZYDIS_OPERAND_VISIBILITY_EXPLICIT: return "explicit"; case ZYDIS_OPERAND_VISIBILITY_IMPLICIT: return "implicit"; case ZYDIS_OPERAND_VISIBILITY_HIDDEN: return "hidden"; default: return "???"; } }; for(int i = 0; i < argcount; i++) { const auto & op = instr->operands[i]; dprintf("operand %d (size: %d, access: %s, visibility: %s) \"%s\", ", i + 1, op.size, rwstr(op.action), vis(op.visibility), cp.OperandText(i).c_str()); switch(op.type) { case ZYDIS_OPERAND_TYPE_REGISTER: dprintf_untranslated("register: %s\n", cp.RegName(op.reg.value)); break; case ZYDIS_OPERAND_TYPE_IMMEDIATE: dprintf_untranslated("immediate: 0x%p\n", op.imm.value.u); break; case ZYDIS_OPERAND_TYPE_MEMORY: { //[base + index * scale +/- disp] const auto & mem = op.mem; dprintf_untranslated("memory segment: %s, base: %s, index: %s, scale: %d, displacement: 0x%p\n", cp.RegName(mem.segment), cp.RegName(mem.base), cp.RegName(mem.index), mem.scale, mem.disp.value); } break; case ZYDIS_OPERAND_TYPE_POINTER: dprintf_untranslated("pointer: %X:%p\n", op.ptr.segment, op.ptr.offset); break; } } return true; } bool cbInstrVisualize(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint start; duint maxaddr; if(!valfromstring(argv[1], &start) || !valfromstring(argv[2], &maxaddr)) { dputs_untranslated("Invalid arguments!"); return false; } //actual algorithm //make sure to set these options in the INI (rest the default theme of x64dbg): //DisassemblyBookmarkBackgroundColor = #00FFFF //DisassemblyBookmarkColor = #000000 //DisassemblyHardwareBreakpointBackgroundColor = #00FF00 //DisassemblyHardwareBreakpointColor = #000000 //DisassemblyBreakpointBackgroundColor = #FF0000 //DisassemblyBreakpointColor = #000000 { //initialize Zydis _cp; duint _base = start; duint _size = maxaddr - start; Memory<unsigned char*> _data(_size); MemRead(_base, _data(), _size); FunctionClear(); //linear search with some trickery duint end = 0; duint jumpback = 0; for(duint addr = start, fardest = 0; addr < maxaddr;) { //update GUI BpClear(); BookmarkClear(); LabelClear(); SetContextDataEx(hActiveThread, UE_CIP, addr); if(end) BpNew(end, true, false, 0, BPNORMAL, 0, nullptr); if(jumpback) BookmarkSet(jumpback, false); if(fardest) BpNew(fardest, true, false, 0, BPHARDWARE, 0, nullptr); DebugUpdateGuiAsync(addr, false); Sleep(300); //continue algorithm const unsigned char* curData = (addr >= _base && addr < _base + _size) ? _data() + (addr - _base) : nullptr; if(_cp.Disassemble(addr, curData, MAX_DISASM_BUFFER)) { if(addr + _cp.Size() > maxaddr) //we went past the maximum allowed address break; if((_cp.IsJump() || _cp.IsLoop()) && _cp.OpCount() && _cp[0].type == ZYDIS_OPERAND_TYPE_IMMEDIATE) //jump { duint dest = (duint)_cp[0].imm.value.u; if(dest >= maxaddr) //jump across function boundaries { //currently unused } else if(dest > addr && dest > fardest) //save the farthest JXX destination forward { fardest = dest; } else if(end && dest < end && _cp.GetId() == ZYDIS_MNEMONIC_JMP) //save the last JMP backwards { jumpback = addr; } } else if(_cp.IsRet()) //possible function end? { end = addr; if(fardest < addr) //we stop if the farthest JXX destination forward is before this RET break; } addr += _cp.Size(); } else addr++; } end = end < jumpback ? jumpback : end; //update GUI FunctionAdd(start, end, false); BpClear(); BookmarkClear(); SetContextDataEx(hActiveThread, UE_CIP, start); DebugUpdateGuiAsync(start, false); } return true; } bool cbInstrMeminfo(int argc, char* argv[]) { if(argc < 3) { dputs_untranslated("Usage: meminfo a/r, addr[, size]"); return false; } duint addr; if(!valfromstring(argv[2], &addr)) { dputs_untranslated("Invalid argument"); return false; } if(argv[1][0] == 'a') { duint size = 1; if(argc > 3 && !valfromstring(argv[3], &size)) { dputs_untranslated("Invalid argument"); return false; } std::vector<uint8_t> buf; buf.resize(size); SIZE_T NumberOfBytesRead = 0; ReadProcessMemory(fdProcessInfo->hProcess, (const void*)addr, buf.data(), buf.size(), &NumberOfBytesRead); dprintf_untranslated("Data: %s\n", StringUtils::ToHex(buf.data(), NumberOfBytesRead).c_str()); } else if(argv[1][0] == 'r') { MemUpdateMap(); GuiUpdateMemoryView(); dputs_untranslated("Memory map updated!"); } return true; } bool cbInstrBriefcheck(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr; if(!valfromstring(argv[1], &addr, false)) return false; duint size; auto base = DbgMemFindBaseAddr(addr, &size); if(!base) return false; Memory<unsigned char*> buffer(size + 16); DbgMemRead(base, buffer(), size); Zydis cp; std::unordered_set<String> reported; for(duint i = 0; i < size;) { if(!cp.Disassemble(base + i, buffer() + i, 16)) { i++; continue; } i += cp.Size(); auto mnem = StringUtils::ToLower(cp.Mnemonic()); auto brief = MnemonicHelp::getBriefDescription(mnem.c_str()); if(brief.length() || reported.count(mnem)) continue; reported.insert(mnem); dprintf_untranslated("%p: %s\n", cp.Address(), mnem.c_str()); } return true; } bool cbInstrFocusinfo(int argc, char* argv[]) { ACTIVEVIEW activeView; GuiGetActiveView(&activeView); dprintf_untranslated("activeTitle: %s, activeClass: %s\n", activeView.title, activeView.className); return true; } bool cbInstrFlushlog(int argc, char* argv[]) { GuiFlushLog(); return true; } extern char animate_command[deflen]; bool cbInstrAnimateWait(int argc, char* argv[]) { while(DbgIsDebugging() && dbgisrunning() && animate_command[0] != 0) //while not locked (NOTE: possible deadlock) { Sleep(1); } return true; } #include <lz4/lz4file.h> bool cbInstrDbdecompress(int argc, char* argv[]) { if(argc < 2) { dprintf_untranslated("Usage: dbdecompress \"c:\\path\\to\\db\"\n"); return false; } auto dbFile = StringUtils::Utf8ToUtf16(argv[1]); if(LZ4_decompress_fileW(dbFile.c_str(), dbFile.c_str()) != LZ4_SUCCESS) { dprintf_untranslated("Failed to decompress '%s'\n", argv[1]); return false; } dprintf_untranslated("Decompressed '%s'\n", argv[1]); return true; } bool cbInstrDebugFlags(int argc, char* argv[]) { if(argc < 2) { dprintf_untranslated("Usage: DebugFlags 0xFFFFFFFF\n"); return false; } auto debugFlags = (DWORD)DbgValFromString(argv[1]); dbgsetdebugflags(debugFlags); dprintf_untranslated("DebugFlags = 0x%08X\n", debugFlags); return true; } bool cbInstrLabelRuntimeFunctions(int argc, char* argv[]) { #ifdef _WIN64 if(argc < 2) { dputs_untranslated("Usage: LabelRuntimeFunctions modaddr"); return false; } auto modaddr = DbgValFromString(argv[1]); SHARED_ACQUIRE(LockModules); auto info = ModInfoFromAddr(modaddr); if(info) { std::vector<COMMENTSINFO> comments; CommentGetList(comments); for(const auto & comment : comments) { if(comment.modhash == info->hash) { if(!comment.manual && comment.text.find("RUNTIME_FUNCTION") == 0) { CommentDelete(comment.addr + info->base); } } } for(const auto & runtimeFunction : info->runtimeFunctions) { auto setComment = [info](duint addr, const char* prefix) { char comment[MAX_COMMENT_SIZE] = ""; if(!CommentGet(addr, comment)) strncpy_s(comment, "RUNTIME_FUNCTION", _TRUNCATE); strncat_s(comment, " ", _TRUNCATE); strncat_s(comment, prefix, _TRUNCATE); CommentSet(addr, comment, false); }; setComment(info->base + runtimeFunction.BeginAddress, "BeginAddress"); setComment(info->base + runtimeFunction.EndAddress, "EndAddress"); } GuiUpdateAllViews(); } else { dprintf_untranslated("No module found at %p\n", modaddr); } return true; #else return false; #endif // _WIN64 } bool cbInstrCmdTest(int argc, char* argv[]) { for(int i = 0; i < argc; i++) dprintf_untranslated("argv[%d]:%s\n", i, argv[i]); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-undocumented.h
#pragma once #include "command.h" bool cbBadCmd(int argc, char* argv[]); bool cbDebugBenchmark(int argc, char* argv[]); bool cbInstrSetstr(int argc, char* argv[]); bool cbInstrGetstr(int argc, char* argv[]); bool cbInstrCopystr(int argc, char* argv[]); bool cbInstrZydis(int argc, char* argv[]); bool cbInstrVisualize(int argc, char* argv[]); bool cbInstrMeminfo(int argc, char* argv[]); bool cbInstrBriefcheck(int argc, char* argv[]); bool cbInstrFocusinfo(int argc, char* argv[]); bool cbInstrFlushlog(int argc, char* argv[]); bool cbInstrAnimateWait(int argc, char* argv[]); bool cbInstrDbdecompress(int argc, char* argv[]); bool cbInstrDebugFlags(int argc, char* argv[]); bool cbInstrLabelRuntimeFunctions(int argc, char* argv[]); bool cbInstrCmdTest(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-user-database.cpp
#include "cmd-user-database.h" #include "database.h" #include "console.h" #include "comment.h" #include "value.h" #include "variable.h" #include "label.h" #include "bookmark.h" #include "function.h" #include "argument.h" #include "loop.h" #include "debugger.h" #include "stringformat.h" #include "_exports.h" bool cbInstrDbsave(int argc, char* argv[]) { DbSave(DbLoadSaveType::All, argc > 1 ? argv[1] : nullptr, argc > 1); return true; } bool cbInstrDbload(int argc, char* argv[]) { if(argc <= 1) { DebugRemoveBreakpoints(); DbClear(); } DbLoad(DbLoadSaveType::All, argc > 1 ? argv[1] : nullptr); DebugSetBreakpoints(); GuiUpdateAllViews(); return true; } bool cbInstrDbclear(int argc, char* argv[]) { DebugRemoveBreakpoints(); DbClear(); dputs(QT_TRANSLATE_NOOP("DBG", "Database cleared!")); GuiUpdateAllViews(); return true; } bool cbInstrCommentSet(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!CommentSet(addr, argv[2], true)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting comment")); return false; } GuiUpdateAllViews(); return true; } bool cbInstrCommentDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!CommentDelete(addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error deleting comment")); return false; } GuiUpdateAllViews(); return true; } bool cbInstrCommentList(int argc, char* argv[]) { auto listAuto = argc >= 2 && *argv[1] == '1'; //setup reference view GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comments"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comment"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); size_t cbsize; CommentEnum(0, &cbsize); if(!cbsize) { dputs(QT_TRANSLATE_NOOP("DBG", "No comments")); return true; } Memory<COMMENTSINFO*> comments(cbsize, "cbInstrCommentList:comments"); CommentEnum(comments(), 0); int total = 0; for(int i = 0; i < (int)(cbsize / sizeof(COMMENTSINFO)); i++) { if(!listAuto && !comments()[i].manual) continue; GuiReferenceSetRowCount(total + 1); char addrText[20] = ""; sprintf_s(addrText, "%p", comments()[i].addr); GuiReferenceSetCellContent(total, 0, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly(comments()[i].addr, disassembly)) GuiReferenceSetCellContent(total, 1, disassembly); GuiReferenceSetCellContent(total, 2, comments()[i].text.c_str()); total++; } varset("$result", total, false); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "commentdel $0"); dprintf(QT_TRANSLATE_NOOP("DBG", "%d comment(s) listed in Reference View\n"), total); GuiReferenceReloadData(); return true; } bool cbInstrCommentClear(int argc, char* argv[]) { CommentClear(); GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "All comments deleted!")); return true; } bool cbInstrLabelSet(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; auto temporaryLabel = argc > 3; if(!LabelSet(addr, stringformatinline(argv[2]).c_str(), true, temporaryLabel)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error setting label")); return false; } GuiUpdateAllViews(); return true; } bool cbInstrLabelDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!LabelDelete(addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error deleting label")); return false; } return true; } bool cbInstrLabelList(int argc, char* argv[]) { //setup reference view GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Labels"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); std::vector<LABELSINFO> labels; LabelGetList(labels); if(labels.empty()) { dputs(QT_TRANSLATE_NOOP("DBG", "No labels")); return true; } auto count = int(labels.size()); for(int i = 0; i < count; i++) { labels[i].addr += ModBaseFromName(labels[i].mod().c_str()); GuiReferenceSetRowCount(i + 1); char addrText[20] = ""; sprintf_s(addrText, "%p", labels[i].addr); GuiReferenceSetCellContent(i, 0, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly(labels[i].addr, disassembly)) GuiReferenceSetCellContent(i, 1, disassembly); GuiReferenceSetCellContent(i, 2, labels[i].text.c_str()); } varset("$result", count, false); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "labeldel $0"); dprintf(QT_TRANSLATE_NOOP("DBG", "%d label(s) listed in Reference View\n"), count); GuiReferenceReloadData(); return true; } bool cbInstrLabelClear(int argc, char* argv[]) { LabelClear(); GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "All labels deleted!")); return true; } bool cbInstrBookmarkSet(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!BookmarkSet(addr, true)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to set bookmark!")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Bookmark set!")); return true; } bool cbInstrBookmarkDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!BookmarkDelete(addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete bookmark!")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Bookmark deleted!")); return true; } bool cbInstrBookmarkList(int argc, char* argv[]) { //setup reference view GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Bookmarks"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comment"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); size_t cbsize; BookmarkEnum(0, &cbsize); if(!cbsize) { dputs(QT_TRANSLATE_NOOP("DBG", "No bookmarks found")); return true; } Memory<BOOKMARKSINFO*> bookmarks(cbsize, "cbInstrBookmarkList:bookmarks"); BookmarkEnum(bookmarks(), 0); int count = (int)(cbsize / sizeof(BOOKMARKSINFO)); for(int i = 0; i < count; i++) { GuiReferenceSetRowCount(i + 1); char addrText[20] = ""; sprintf_s(addrText, "%p", bookmarks()[i].addr); GuiReferenceSetCellContent(i, 0, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly(bookmarks()[i].addr, disassembly)) GuiReferenceSetCellContent(i, 1, disassembly); char comment[MAX_COMMENT_SIZE] = ""; if(CommentGet(bookmarks()[i].addr, comment)) GuiReferenceSetCellContent(i, 3, comment); char label[MAX_LABEL_SIZE] = ""; if(LabelGet(bookmarks()[i].addr, label)) GuiReferenceSetCellContent(i, 2, label); } varset("$result", count, false); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "bookmarkdel $0"); dprintf(QT_TRANSLATE_NOOP("DBG", "%d bookmark(s) listed\n"), count); GuiReferenceReloadData(); return true; } bool cbInstrBookmarkClear(int argc, char* argv[]) { LabelClear(); GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "All bookmarks deleted!")); return true; } bool cbInstrFunctionAdd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint start = 0; duint end = 0; if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false)) return false; if(!FunctionAdd(start, end, true)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to add function")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Function added!")); GuiUpdateAllViews(); return true; } bool cbInstrFunctionDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!FunctionDelete(addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete function")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Function deleted!")); GuiUpdateAllViews(); return true; } bool cbInstrFunctionList(int argc, char* argv[]) { //setup reference view GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Functions"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Start"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "End"))); GuiReferenceAddColumn(5, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Size"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly (Start)"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comment"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); size_t cbsize; FunctionEnum(0, &cbsize); if(!cbsize) { dputs(QT_TRANSLATE_NOOP("DBG", "No functions")); return true; } Memory<FUNCTIONSINFO*> functions(cbsize, "cbInstrFunctionList:functions"); FunctionEnum(functions(), 0); int count = (int)(cbsize / sizeof(FUNCTIONSINFO)); for(int i = 0; i < count; i++) { GuiReferenceSetRowCount(i + 1); char addrText[20] = ""; sprintf_s(addrText, "%p", functions()[i].start); GuiReferenceSetCellContent(i, 0, addrText); sprintf_s(addrText, "%p", functions()[i].end); GuiReferenceSetCellContent(i, 1, addrText); sprintf_s(addrText, ArchValue("%X", "%llX"), functions()[i].end - functions()[i].start); GuiReferenceSetCellContent(i, 2, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly(functions()[i].start, disassembly)) GuiReferenceSetCellContent(i, 4, disassembly); char label[MAX_LABEL_SIZE] = ""; BRIDGE_ADDRINFO labelinfo; labelinfo.flags = flaglabel; if(_dbg_addrinfoget(functions()[i].start, SEG_DEFAULT, &labelinfo)) GuiReferenceSetCellContent(i, 3, labelinfo.label); char comment[MAX_COMMENT_SIZE] = ""; if(CommentGet(functions()[i].start, comment)) GuiReferenceSetCellContent(i, 5, comment); } varset("$result", count, false); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "functiondel $0"); dprintf(QT_TRANSLATE_NOOP("DBG", "%d function(s) listed\n"), count); GuiReferenceReloadData(); return true; } bool cbInstrFunctionClear(int argc, char* argv[]) { FunctionClear(); GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "All functions deleted!")); return true; } bool cbInstrArgumentAdd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint start = 0; duint end = 0; if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false)) return false; if(!ArgumentAdd(start, end, true)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to add argument")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Argument added!")); GuiUpdateAllViews(); return true; } bool cbInstrArgumentDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; if(!ArgumentDelete(addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete argument")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Argument deleted!")); GuiUpdateAllViews(); return true; } bool cbInstrArgumentList(int argc, char* argv[]) { //setup reference view GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Arguments"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Start"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "End"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly (Start)"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label/Comment"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); size_t cbsize; ArgumentEnum(0, &cbsize); if(!cbsize) { dputs(QT_TRANSLATE_NOOP("DBG", "No arguments")); return true; } Memory<ARGUMENTSINFO*> arguments(cbsize, "cbInstrArgumentList:arguments"); ArgumentEnum(arguments(), 0); int count = (int)(cbsize / sizeof(ARGUMENTSINFO)); for(int i = 0; i < count; i++) { GuiReferenceSetRowCount(i + 1); char addrText[20] = ""; sprintf_s(addrText, "%p", arguments()[i].start); GuiReferenceSetCellContent(i, 0, addrText); sprintf_s(addrText, "%p", arguments()[i].end); GuiReferenceSetCellContent(i, 1, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly(arguments()[i].start, disassembly)) GuiReferenceSetCellContent(i, 2, disassembly); char label[MAX_LABEL_SIZE] = ""; if(LabelGet(arguments()[i].start, label)) GuiReferenceSetCellContent(i, 3, label); else { char comment[MAX_COMMENT_SIZE] = ""; if(CommentGet(arguments()[i].start, comment)) GuiReferenceSetCellContent(i, 3, comment); } } varset("$result", count, false); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "argumentdel $0"); dprintf(QT_TRANSLATE_NOOP("DBG", "%d argument(s) listed\n"), count); GuiReferenceReloadData(); return true; } bool cbInstrArgumentClear(int argc, char* argv[]) { ArgumentClear(); GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "All arguments deleted!")); return true; } bool cbInstrLoopAdd(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 3)) return false; duint start = 0; duint end = 0; if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false)) return false; if(!LoopAdd(start, end, true)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to add loop")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Loop added!")); GuiUpdateAllViews(); return true; } bool cbInstrLoopDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; duint addr = 0; if(!valfromstring(argv[1], &addr, false)) return false; duint depth = 0; if(argc >= 3 && !valfromstring(argv[2], &depth, false)) return false; if(!LoopDelete(int(depth), addr)) { dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete loop")); return false; } dputs(QT_TRANSLATE_NOOP("DBG", "Loop deleted!")); GuiUpdateAllViews(); return true; } bool cbInstrLoopList(int argc, char* argv[]) { //setup reference view GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Loops"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Start"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "End"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Depth"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Parent"))); GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly (Start)"))); GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label/Comment"))); GuiReferenceSetRowCount(0); GuiReferenceReloadData(); size_t cbsize; LoopEnum(0, &cbsize); if(!cbsize) { dputs(QT_TRANSLATE_NOOP("DBG", "No loops")); return true; } Memory<LOOPSINFO*> loops(cbsize, "cbInstrLoopList:loops"); LoopEnum(loops(), 0); int count = (int)(cbsize / sizeof(LOOPSINFO)); for(int i = 0; i < count; i++) { GuiReferenceSetRowCount(i + 1); char addrText[20] = ""; sprintf_s(addrText, "%p", loops()[i].start); GuiReferenceSetCellContent(i, 0, addrText); sprintf_s(addrText, "%p", loops()[i].end); GuiReferenceSetCellContent(i, 1, addrText); sprintf_s(addrText, "%d", loops()[i].depth); GuiReferenceSetCellContent(i, 2, addrText); sprintf_s(addrText, "%p", loops()[i].parent); GuiReferenceSetCellContent(i, 3, addrText); char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = ""; if(GuiGetDisassembly(loops()[i].start, disassembly)) GuiReferenceSetCellContent(i, 4, disassembly); char label[MAX_LABEL_SIZE] = ""; if(LabelGet(loops()[i].start, label)) GuiReferenceSetCellContent(i, 5, label); else { char comment[MAX_COMMENT_SIZE] = ""; if(CommentGet(loops()[i].start, comment)) GuiReferenceSetCellContent(i, 5, comment); } } varset("$result", count, false); GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "loopdel $0"); dprintf(QT_TRANSLATE_NOOP("DBG", "%d loop(s) listed\n"), count); GuiReferenceReloadData(); return true; } bool cbInstrLoopClear(int argc, char* argv[]) { LoopClear(); GuiUpdateAllViews(); dputs(QT_TRANSLATE_NOOP("DBG", "All loops deleted!")); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-user-database.h
#pragma once #include "command.h" bool cbInstrDbsave(int argc, char* argv[]); bool cbInstrDbload(int argc, char* argv[]); bool cbInstrDbclear(int argc, char* argv[]); bool cbInstrCommentSet(int argc, char* argv[]); bool cbInstrCommentDel(int argc, char* argv[]); bool cbInstrCommentList(int argc, char* argv[]); bool cbInstrCommentClear(int argc, char* argv[]); bool cbInstrLabelSet(int argc, char* argv[]); bool cbInstrLabelDel(int argc, char* argv[]); bool cbInstrLabelList(int argc, char* argv[]); bool cbInstrLabelClear(int argc, char* argv[]); bool cbInstrBookmarkSet(int argc, char* argv[]); bool cbInstrBookmarkDel(int argc, char* argv[]); bool cbInstrBookmarkList(int argc, char* argv[]); bool cbInstrBookmarkClear(int argc, char* argv[]); bool cbInstrFunctionAdd(int argc, char* argv[]); bool cbInstrFunctionDel(int argc, char* argv[]); bool cbInstrFunctionList(int argc, char* argv[]); bool cbInstrFunctionClear(int argc, char* argv[]); bool cbInstrArgumentAdd(int argc, char* argv[]); bool cbInstrArgumentDel(int argc, char* argv[]); bool cbInstrArgumentList(int argc, char* argv[]); bool cbInstrArgumentClear(int argc, char* argv[]); bool cbInstrLoopAdd(int argc, char* argv[]); bool cbInstrLoopDel(int argc, char* argv[]); bool cbInstrLoopList(int argc, char* argv[]); bool cbInstrLoopClear(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-variables.cpp
#include "cmd-variables.h" #include "console.h" #include "variable.h" #include "value.h" bool cbInstrVar(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; char arg2[deflen] = ""; //var value (optional) if(argc > 2) strcpy_s(arg2, argv[2]); duint value = 0; int add = 0; if(*argv[1] == '$') add++; if(valfromstring(argv[1] + add, &value)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid variable name \"%s\"\n"), argv[1]); return false; } if(!valfromstring(arg2, &value)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid value \"%s\"\n"), arg2); return false; } if(!varnew(argv[1], value, VAR_USER)) { dprintf(QT_TRANSLATE_NOOP("DBG", "Error creating variable \"%s\"\n"), argv[1]); return false; } else { if(value > 15) #ifdef _WIN64 dprintf_untranslated("%s=%llX (%llud)\n", argv[1], value, value); #else //x86 dprintf_untranslated("%s=%X (%ud)\n", argv[1], value, value); #endif //_WIN64 else #ifdef _WIN64 dprintf_untranslated("%s=%llX\n", argv[1], value); #else //x86 dprintf_untranslated("%s=%X\n", argv[1], value); #endif //_WIN64 } return true; } bool cbInstrVarDel(int argc, char* argv[]) { if(IsArgumentsLessThan(argc, 2)) return false; if(!vardel(argv[1], false)) dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete variable \"%s\"\n"), argv[1]); else dprintf(QT_TRANSLATE_NOOP("DBG", "Deleted variable \"%s\"\n"), argv[1]); return true; } bool cbInstrVarList(int argc, char* argv[]) { int filter = 0; if(argc > 1) { if(!_stricmp(argv[1], "USER")) filter = VAR_USER; else if(!_stricmp(argv[1], "READONLY")) filter = VAR_READONLY; else if(!_stricmp(argv[1], "SYSTEM")) filter = VAR_SYSTEM; } size_t cbsize = 0; if(!varenum(0, &cbsize)) { dputs(QT_TRANSLATE_NOOP("DBG", "No variables!")); return true; } Memory<VAR*> variables(cbsize, "cbInstrVarList:variables"); if(!varenum(variables(), 0)) { dputs(QT_TRANSLATE_NOOP("DBG", "Error listing variables!")); return false; } GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Variables"))); GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Value (Hex)"))); //The GUI only follows address in column 0 GuiReferenceAddColumn(30, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Variable"))); GuiReferenceAddColumn(3 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Value (Decimal)"))); GuiReferenceAddColumn(20, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Property"))); int varcount = (int)cbsize / sizeof(VAR); int realvarcount = 0; GuiReferenceSetRowCount(0); for(int i = 0; i < varcount; i++) { char value[32]; if(variables()[i].alias.length()) continue; if(variables()[i].type != VAR_HIDDEN) { GuiReferenceSetRowCount(realvarcount + 1); GuiReferenceSetCellContent(realvarcount, 1, variables()[i].name.c_str()); #ifdef _WIN64 sprintf_s(value, "%llX", variables()[i].value.u.value); GuiReferenceSetCellContent(realvarcount, 0, value); sprintf_s(value, "%llu", variables()[i].value.u.value); GuiReferenceSetCellContent(realvarcount, 2, value); #else //x86 sprintf_s(value, "%X", variables()[i].value.u.value); GuiReferenceSetCellContent(realvarcount, 0, value); sprintf_s(value, "%u", variables()[i].value.u.value); GuiReferenceSetCellContent(realvarcount, 2, value); #endif //_WIN64 const char* szType; switch(variables()[i].type) { case VAR_USER: szType = QT_TRANSLATE_NOOP("DBG", "User Variable"); break; case VAR_SYSTEM: szType = QT_TRANSLATE_NOOP("DBG", "System Variable"); break; case VAR_READONLY: szType = QT_TRANSLATE_NOOP("DBG", "Read Only Variable"); break; default://other variables szType = QT_TRANSLATE_NOOP("DBG", "System Variable"); break; } GuiReferenceSetCellContent(realvarcount, 3, GuiTranslateText(szType)); realvarcount++; } } GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "vardel $1"); GuiReferenceReloadData(); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-variables.h
#pragma once #include "command.h" bool cbInstrVar(int argc, char* argv[]); bool cbInstrVarDel(int argc, char* argv[]); bool cbInstrVarList(int argc, char* argv[]);
C++
x64dbg-development/src/dbg/commands/cmd-watch-control.cpp
#include "cmd-watch-control.h" #include "variable.h" #include "watch.h" #include "console.h" #include "threading.h" bool cbAddWatch(int argc, char* argv[]) { if(argc < 2) { dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for addwatch\n")); return false; } WATCHVARTYPE newtype = WATCHVARTYPE::TYPE_UINT; if(argc > 2) { if(_stricmp(argv[2], "uint") == 0) newtype = WATCHVARTYPE::TYPE_UINT; else if(_stricmp(argv[2], "int") == 0) newtype = WATCHVARTYPE::TYPE_INT; else if(_stricmp(argv[2], "float") == 0) newtype = WATCHVARTYPE::TYPE_FLOAT; else if(_stricmp(argv[2], "ascii") == 0) newtype = WATCHVARTYPE::TYPE_ASCII; else if(_stricmp(argv[2], "unicode") == 0) newtype = WATCHVARTYPE::TYPE_UNICODE; } unsigned int newid = WatchAddExpr(argv[1], newtype); varset("$result", newid, false); return true; } bool cbDelWatch(int argc, char* argv[]) { if(argc < 2) { dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for delwatch\n")); return false; } duint id; bool ok = valfromstring(argv[1], &id); if(!ok) { dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n")); return false; } WatchDelete((unsigned int)id); return true; } bool cbSetWatchdog(int argc, char* argv[]) { if(argc < 2) { dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for delwatch\n")); return false; } duint id; bool ok = valfromstring(argv[1], &id); if(!ok) { dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n")); return false; } WATCHDOGMODE mode; if(argc > 2) { if(_stricmp(argv[2], "disabled") == 0) mode = WATCHDOGMODE::MODE_DISABLED; else if(_stricmp(argv[2], "changed") == 0) mode = WATCHDOGMODE::MODE_CHANGED; else if(_stricmp(argv[2], "unchanged") == 0) mode = WATCHDOGMODE::MODE_UNCHANGED; else if(_stricmp(argv[2], "istrue") == 0) mode = WATCHDOGMODE::MODE_ISTRUE; else if(_stricmp(argv[2], "isfalse") == 0) mode = WATCHDOGMODE::MODE_ISFALSE; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown watchdog mode.\n")); return false; } } else mode = (WatchGetWatchdogEnabled((unsigned int)id) == WATCHDOGMODE::MODE_DISABLED) ? WATCHDOGMODE::MODE_CHANGED : WATCHDOGMODE::MODE_DISABLED; WatchSetWatchdogMode((unsigned int)id, mode); return true; } bool cbSetWatchType(int argc, char* argv[]) { if(argc < 3) { dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchType\n")); return false; } duint id; bool ok = valfromstring(argv[1], &id); if(!ok) { dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n")); return false; } WATCHVARTYPE newtype; if(_stricmp(argv[2], "uint") == 0) newtype = WATCHVARTYPE::TYPE_UINT; else if(_stricmp(argv[2], "int") == 0) newtype = WATCHVARTYPE::TYPE_INT; else if(_stricmp(argv[2], "float") == 0) newtype = WATCHVARTYPE::TYPE_FLOAT; else if(_stricmp(argv[2], "ascii") == 0) newtype = WATCHVARTYPE::TYPE_ASCII; else if(_stricmp(argv[2], "unicode") == 0) newtype = WATCHVARTYPE::TYPE_UNICODE; else { dputs(QT_TRANSLATE_NOOP("DBG", "Unknown watch type.\n")); return false; } WatchSetType((unsigned int)id, newtype); return true; } bool cbSetWatchExpression(int argc, char* argv[]) { if(argc < 3) { dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchExpression")); return false; } duint id; bool ok = valfromstring(argv[1], &id); if(ok) { WATCHVARTYPE varType; if(argc > 3) { if(_stricmp(argv[3], "uint") == 0) varType = WATCHVARTYPE::TYPE_UINT; else if(_stricmp(argv[3], "int") == 0) varType = WATCHVARTYPE::TYPE_INT; else if(_stricmp(argv[3], "float") == 0) varType = WATCHVARTYPE::TYPE_FLOAT; else if(_stricmp(argv[3], "ascii") == 0) varType = WATCHVARTYPE::TYPE_ASCII; else if(_stricmp(argv[3], "unicode") == 0) varType = WATCHVARTYPE::TYPE_UNICODE; else varType = WATCHVARTYPE::TYPE_UINT; } else varType = WATCHVARTYPE::TYPE_UINT; WatchModifyExpr((unsigned int)id, argv[2], varType); return true; } else { dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n")); return false; } } bool cbSetWatchName(int argc, char* argv[]) { if(argc < 3) { dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchName")); return false; } duint id; bool ok = valfromstring(argv[1], &id); if(ok) { WatchModifyName((unsigned int)id, argv[2]); return true; } else { dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n")); return false; } } bool cbCheckWatchdog(int argc, char* argv[]) { EXCLUSIVE_ACQUIRE(LockWatch); bool watchdogTriggered = false; for(auto j = watchexpr.begin(); j != watchexpr.end(); ++j) { std::pair<unsigned int, WatchExpr*> i = *j; i.second->watchdogTriggered = false; duint intVal = i.second->getIntValue(); watchdogTriggered |= i.second->watchdogTriggered; } EXCLUSIVE_RELEASE(); if(watchdogTriggered) GuiUpdateWatchViewAsync(); varset("$result", watchdogTriggered ? 1 : 0, false); return true; }
C/C++
x64dbg-development/src/dbg/commands/cmd-watch-control.h
#pragma once #include "command.h" bool cbAddWatch(int argc, char* argv[]); bool cbDelWatch(int argc, char* argv[]); bool cbSetWatchdog(int argc, char* argv[]); bool cbSetWatchExpression(int argc, char* argv[]); bool cbSetWatchName(int argc, char* argv[]); bool cbSetWatchType(int argc, char* argv[]); bool cbCheckWatchdog(int argc, char* argv[]);
C/C++
x64dbg-development/src/dbg/dbghelp/dbghelp.h
#ifndef _DBGHELP_ #define _DBGHELP_ // As a general principal always call the 64 bit version // of every API, if a choice exists. The 64 bit version // works great on 32 bit platforms, and is forward // compatible to 64 bit platforms. #ifdef _WIN64 #ifndef _IMAGEHLP64 #define _IMAGEHLP64 #endif #endif #pragma pack(push,8) // For those without specstrings.h // Since there are different versions of this header, I need to // individually test each item and define it if it is not around. #ifndef __in #define __in #endif #ifndef __out #define __out #endif #ifndef __inout #define __inout #endif #ifndef __in_opt #define __in_opt #endif #ifndef __out_opt #define __out_opt #endif #ifndef __inout_opt #define __inout_opt #endif #ifndef __in_ecount #define __in_ecount(x) #endif #ifndef __out_ecount #define __out_ecount(x) #endif #ifndef __inout_ecount #define __inout_ecount(x) #endif #ifndef __in_bcount #define __in_bcount(x) #endif #ifndef __out_bcount #define __out_bcount(x) #endif #ifndef __inout_bcount #define __inout_bcount(x) #endif #ifndef __out_xcount #define __out_xcount(x) #endif #ifndef __deref_opt_out #define __deref_opt_out #endif #ifndef __deref_out #define __deref_out #endif #ifndef __out_ecount_opt #define __out_ecount_opt(x) #endif #ifndef __in_bcount_opt #define __in_bcount_opt(x) #endif #ifndef __out_bcount_opt #define __out_bcount_opt(x) #endif #ifndef __deref_out_opt #define __deref_out_opt #endif #ifdef __cplusplus extern "C" { #endif #ifdef _IMAGEHLP_SOURCE_ #define IMAGEAPI __stdcall #define DBHLP_DEPRECIATED #else #define IMAGEAPI DECLSPEC_IMPORT __stdcall #if (_MSC_VER >= 1300) && !defined(MIDL_PASS) #define DBHLP_DEPRECIATED __declspec(deprecated) #else #define DBHLP_DEPRECIATED #endif #endif #define DBHLPAPI IMAGEAPI #define IMAGE_SEPARATION (64*1024) // Observant readers may notice that 2 new fields, // 'fReadOnly' and 'Version' have been added to // the LOADED_IMAGE structure after 'fDOSImage'. // This does not change the size of the structure // from previous headers. That is because while // 'fDOSImage' is a byte, it is padded by the // compiler to 4 bytes. So the 2 new fields are // slipped into the extra space. typedef struct _LOADED_IMAGE { PSTR ModuleName; HANDLE hFile; PUCHAR MappedAddress; #ifdef _IMAGEHLP64 PIMAGE_NT_HEADERS64 FileHeader; #else PIMAGE_NT_HEADERS32 FileHeader; #endif PIMAGE_SECTION_HEADER LastRvaSection; ULONG NumberOfSections; PIMAGE_SECTION_HEADER Sections; ULONG Characteristics; BOOLEAN fSystemImage; BOOLEAN fDOSImage; BOOLEAN fReadOnly; UCHAR Version; LIST_ENTRY Links; ULONG SizeOfImage; } LOADED_IMAGE, *PLOADED_IMAGE; #define MAX_SYM_NAME 2000 // Error codes set by dbghelp functions. Call GetLastError // to see them. // Dbghelp also sets error codes found in winerror.h #define ERROR_IMAGE_NOT_STRIPPED 0x8800 // the image is not stripped. No dbg file available. #define ERROR_NO_DBG_POINTER 0x8801 // image is stripped but there is no pointer to a dbg file #define ERROR_NO_PDB_POINTER 0x8802 // image does not point to a pdb file typedef BOOL (CALLBACK* PFIND_DEBUG_FILE_CALLBACK)( __in HANDLE FileHandle, __in PCSTR FileName, __in PVOID CallerData ); HANDLE IMAGEAPI SymFindDebugInfoFile( __in HANDLE hProcess, __in PCSTR FileName, __out_ecount(MAX_PATH + 1) PSTR DebugFilePath, __in_opt PFIND_DEBUG_FILE_CALLBACK Callback, __in_opt PVOID CallerData ); typedef BOOL (CALLBACK* PFIND_DEBUG_FILE_CALLBACKW)( __in HANDLE FileHandle, __in PCWSTR FileName, __in PVOID CallerData ); HANDLE IMAGEAPI SymFindDebugInfoFileW( __in HANDLE hProcess, __in PCWSTR FileName, __out_ecount(MAX_PATH + 1) PWSTR DebugFilePath, __in_opt PFIND_DEBUG_FILE_CALLBACKW Callback, __in_opt PVOID CallerData ); HANDLE IMAGEAPI FindDebugInfoFile( __in PCSTR FileName, __in PCSTR SymbolPath, __out_ecount(MAX_PATH + 1) PSTR DebugFilePath ); HANDLE IMAGEAPI FindDebugInfoFileEx( __in PCSTR FileName, __in PCSTR SymbolPath, __out_ecount(MAX_PATH + 1) PSTR DebugFilePath, __in_opt PFIND_DEBUG_FILE_CALLBACK Callback, __in_opt PVOID CallerData ); HANDLE IMAGEAPI FindDebugInfoFileExW( __in PCWSTR FileName, __in PCWSTR SymbolPath, __out_ecount(MAX_PATH + 1) PWSTR DebugFilePath, __in_opt PFIND_DEBUG_FILE_CALLBACKW Callback, __in_opt PVOID CallerData ); typedef BOOL (CALLBACK* PFINDFILEINPATHCALLBACK)( __in PCSTR filename, __in PVOID context ); BOOL IMAGEAPI SymFindFileInPath( __in HANDLE hprocess, __in_opt PCSTR SearchPath, __in PCSTR FileName, __in_opt PVOID id, __in DWORD two, __in DWORD three, __in DWORD flags, __out_ecount(MAX_PATH + 1) PSTR FoundFile, __in_opt PFINDFILEINPATHCALLBACK callback, __in_opt PVOID context ); typedef BOOL (CALLBACK* PFINDFILEINPATHCALLBACKW)( __in PCWSTR filename, __in PVOID context ); BOOL IMAGEAPI SymFindFileInPathW( __in HANDLE hprocess, __in_opt PCWSTR SearchPath, __in PCWSTR FileName, __in_opt PVOID id, __in DWORD two, __in DWORD three, __in DWORD flags, __out_ecount(MAX_PATH + 1) PWSTR FoundFile, __in_opt PFINDFILEINPATHCALLBACKW callback, __in_opt PVOID context ); typedef BOOL (CALLBACK* PFIND_EXE_FILE_CALLBACK)( __in HANDLE FileHandle, __in PCSTR FileName, __in_opt PVOID CallerData ); HANDLE IMAGEAPI SymFindExecutableImage( __in HANDLE hProcess, __in PCSTR FileName, __out_ecount(MAX_PATH + 1) PSTR ImageFilePath, __in PFIND_EXE_FILE_CALLBACK Callback, __in PVOID CallerData ); typedef BOOL (CALLBACK* PFIND_EXE_FILE_CALLBACKW)( __in HANDLE FileHandle, __in PCWSTR FileName, __in_opt PVOID CallerData ); HANDLE IMAGEAPI SymFindExecutableImageW( __in HANDLE hProcess, __in PCWSTR FileName, __out_ecount(MAX_PATH + 1) PWSTR ImageFilePath, __in PFIND_EXE_FILE_CALLBACKW Callback, __in PVOID CallerData ); HANDLE IMAGEAPI FindExecutableImage( __in PCSTR FileName, __in PCSTR SymbolPath, __out_ecount(MAX_PATH + 1) PSTR ImageFilePath ); HANDLE IMAGEAPI FindExecutableImageEx( __in PCSTR FileName, __in PCSTR SymbolPath, __out_ecount(MAX_PATH + 1) PSTR ImageFilePath, __in_opt PFIND_EXE_FILE_CALLBACK Callback, __in_opt PVOID CallerData ); HANDLE IMAGEAPI FindExecutableImageExW( __in PCWSTR FileName, __in PCWSTR SymbolPath, __out_ecount(MAX_PATH + 1) PWSTR ImageFilePath, __in_opt PFIND_EXE_FILE_CALLBACKW Callback, __in PVOID CallerData ); PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader( __in PVOID Base ); PVOID IMAGEAPI ImageDirectoryEntryToDataEx( __in PVOID Base, __in BOOLEAN MappedAsImage, __in USHORT DirectoryEntry, __out PULONG Size, __out_opt PIMAGE_SECTION_HEADER* FoundHeader ); PVOID IMAGEAPI ImageDirectoryEntryToData( __in PVOID Base, __in BOOLEAN MappedAsImage, __in USHORT DirectoryEntry, __out PULONG Size ); PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection( __in PIMAGE_NT_HEADERS NtHeaders, __in PVOID Base, __in ULONG Rva ); PVOID IMAGEAPI ImageRvaToVa( __in PIMAGE_NT_HEADERS NtHeaders, __in PVOID Base, __in ULONG Rva, __in_opt OUT PIMAGE_SECTION_HEADER* LastRvaSection ); #ifndef _WIN64 // This api won't be ported to Win64 - Fix your code. typedef struct _IMAGE_DEBUG_INFORMATION { LIST_ENTRY List; DWORD ReservedSize; PVOID ReservedMappedBase; USHORT ReservedMachine; USHORT ReservedCharacteristics; DWORD ReservedCheckSum; DWORD ImageBase; DWORD SizeOfImage; DWORD ReservedNumberOfSections; PIMAGE_SECTION_HEADER ReservedSections; DWORD ReservedExportedNamesSize; PSTR ReservedExportedNames; DWORD ReservedNumberOfFunctionTableEntries; PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries; DWORD ReservedLowestFunctionStartingAddress; DWORD ReservedHighestFunctionEndingAddress; DWORD ReservedNumberOfFpoTableEntries; PFPO_DATA ReservedFpoTableEntries; DWORD SizeOfCoffSymbols; PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols; DWORD ReservedSizeOfCodeViewSymbols; PVOID ReservedCodeViewSymbols; PSTR ImageFilePath; PSTR ImageFileName; PSTR ReservedDebugFilePath; DWORD ReservedTimeDateStamp; BOOL ReservedRomImage; PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory; DWORD ReservedNumberOfDebugDirectories; DWORD ReservedOriginalFunctionTableBaseAddress; DWORD Reserved[ 2 ]; } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION; PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation( __in_opt HANDLE FileHandle, __in PCSTR FileName, __in_opt PCSTR SymbolPath, __in ULONG ImageBase ); BOOL IMAGEAPI UnmapDebugInformation( __out_xcount(unknown) PIMAGE_DEBUG_INFORMATION DebugInfo ); #endif BOOL IMAGEAPI SearchTreeForFile( __in PCSTR RootPath, __in PCSTR InputPathName, __out_ecount(MAX_PATH + 1) PSTR OutputPathBuffer ); BOOL IMAGEAPI SearchTreeForFileW( __in PCWSTR RootPath, __in PCWSTR InputPathName, __out_ecount(MAX_PATH + 1) PWSTR OutputPathBuffer ); typedef BOOL (CALLBACK* PENUMDIRTREE_CALLBACK)( __in PCSTR FilePath, __in_opt PVOID CallerData ); BOOL IMAGEAPI EnumDirTree( __in_opt HANDLE hProcess, __in PCSTR RootPath, __in PCSTR InputPathName, __out_ecount_opt(MAX_PATH + 1) PSTR OutputPathBuffer, __in_opt PENUMDIRTREE_CALLBACK cb, __in_opt PVOID data ); typedef BOOL (CALLBACK* PENUMDIRTREE_CALLBACKW)( __in PCWSTR FilePath, __in_opt PVOID CallerData ); BOOL IMAGEAPI EnumDirTreeW( __in_opt HANDLE hProcess, __in PCWSTR RootPath, __in PCWSTR InputPathName, __out_ecount_opt(MAX_PATH + 1) PWSTR OutputPathBuffer, __in_opt PENUMDIRTREE_CALLBACKW cb, __in_opt PVOID data ); BOOL IMAGEAPI MakeSureDirectoryPathExists( __in PCSTR DirPath ); // // UnDecorateSymbolName Flags // #define UNDNAME_COMPLETE (0x0000) // Enable full undecoration #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) // Remove leading underscores from MS extended keywords #define UNDNAME_NO_MS_KEYWORDS (0x0002) // Disable expansion of MS extended keywords #define UNDNAME_NO_FUNCTION_RETURNS (0x0004) // Disable expansion of return type for primary declaration #define UNDNAME_NO_ALLOCATION_MODEL (0x0008) // Disable expansion of the declaration model #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010) // Disable expansion of the declaration language specifier #define UNDNAME_NO_MS_THISTYPE (0x0020) // NYI Disable expansion of MS keywords on the 'this' type for primary declaration #define UNDNAME_NO_CV_THISTYPE (0x0040) // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration #define UNDNAME_NO_THISTYPE (0x0060) // Disable all modifiers on the 'this' type #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) // Disable expansion of access specifiers for members #define UNDNAME_NO_THROW_SIGNATURES (0x0100) // Disable expansion of 'throw-signatures' for functions and pointers to functions #define UNDNAME_NO_MEMBER_TYPE (0x0200) // Disable expansion of 'static' or 'virtual'ness of members #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400) // Disable expansion of MS model for UDT returns #define UNDNAME_32_BIT_DECODE (0x0800) // Undecorate 32-bit decorated names #define UNDNAME_NAME_ONLY (0x1000) // Crack only the name for primary declaration; // return just [scope::]name. Does expand template params #define UNDNAME_NO_ARGUMENTS (0x2000) // Don't undecorate arguments to function #define UNDNAME_NO_SPECIAL_SYMS (0x4000) // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc) DWORD IMAGEAPI WINAPI UnDecorateSymbolName( __in PCSTR name, __out_ecount(maxStringLength) PSTR outputString, __in DWORD maxStringLength, __in DWORD flags ); DWORD IMAGEAPI WINAPI UnDecorateSymbolNameW( __in PCWSTR name, __out_ecount(maxStringLength) PWSTR outputString, __in DWORD maxStringLength, __in DWORD flags ); // // these values are used for synthesized file types // that can be passed in as image headers instead of // the standard ones from ntimage.h // #define DBHHEADER_DEBUGDIRS 0x1 #define DBHHEADER_CVMISC 0x2 #define DBHHEADER_PDBGUID 0x3 typedef struct _MODLOAD_DATA { DWORD ssize; // size of this struct DWORD ssig; // signature identifying the passed data PVOID data; // pointer to passed data DWORD size; // size of passed data DWORD flags; // options } MODLOAD_DATA, *PMODLOAD_DATA; typedef struct _MODLOAD_CVMISC { DWORD oCV; // ofset to the codeview record size_t cCV; // size of the codeview record DWORD oMisc; // offset to the misc record size_t cMisc; // size of the misc record DWORD dtImage; // datetime stamp of the image DWORD cImage; // size of the image } MODLOAD_CVMISC, *PMODLOAD_CVMISC; typedef struct _MODLOAD_PDBGUID_PDBAGE { GUID PdbGuid; // Pdb Guid DWORD PdbAge; // Pdb Age } MODLOAD_PDBGUID_PDBAGE, *PMODLOAD_PDBGUID_PDBAGE; // // StackWalking API // typedef enum { AddrMode1616, AddrMode1632, AddrModeReal, AddrModeFlat } ADDRESS_MODE; typedef struct _tagADDRESS64 { DWORD64 Offset; WORD Segment; ADDRESS_MODE Mode; } ADDRESS64, *LPADDRESS64; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define ADDRESS ADDRESS64 #define LPADDRESS LPADDRESS64 #else typedef struct _tagADDRESS { DWORD Offset; WORD Segment; ADDRESS_MODE Mode; } ADDRESS, *LPADDRESS; __inline void Address32To64( __in LPADDRESS a32, __out LPADDRESS64 a64 ) { a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset; a64->Segment = a32->Segment; a64->Mode = a32->Mode; } __inline void Address64To32( __in LPADDRESS64 a64, __out LPADDRESS a32 ) { a32->Offset = (ULONG)a64->Offset; a32->Segment = a64->Segment; a32->Mode = a64->Mode; } #endif // // This structure is included in the STACKFRAME structure, // and is used to trace through usermode callbacks in a thread's // kernel stack. The values must be copied by the kernel debugger // from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets. // // // New KDHELP structure for 64 bit system support. // This structure is preferred in new code. // typedef struct _KDHELP64 { // // address of kernel thread object, as provided in the // WAIT_STATE_CHANGE packet. // DWORD64 Thread; // // offset in thread object to pointer to the current callback frame // in kernel stack. // DWORD ThCallbackStack; // // offset in thread object to pointer to the current callback backing // store frame in kernel stack. // DWORD ThCallbackBStore; // // offsets to values in frame: // // address of next callback frame DWORD NextCallback; // address of saved frame pointer (if applicable) DWORD FramePointer; // // Address of the kernel function that calls out to user mode // DWORD64 KiCallUserMode; // // Address of the user mode dispatcher function // DWORD64 KeUserCallbackDispatcher; // // Lowest kernel mode address // DWORD64 SystemRangeStart; // // Address of the user mode exception dispatcher function. // Added in API version 10. // DWORD64 KiUserExceptionDispatcher; // // Stack bounds, added in API version 11. // DWORD64 StackBase; DWORD64 StackLimit; DWORD64 Reserved[5]; } KDHELP64, *PKDHELP64; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define KDHELP KDHELP64 #define PKDHELP PKDHELP64 #else typedef struct _KDHELP { // // address of kernel thread object, as provided in the // WAIT_STATE_CHANGE packet. // DWORD Thread; // // offset in thread object to pointer to the current callback frame // in kernel stack. // DWORD ThCallbackStack; // // offsets to values in frame: // // address of next callback frame DWORD NextCallback; // address of saved frame pointer (if applicable) DWORD FramePointer; // // Address of the kernel function that calls out to user mode // DWORD KiCallUserMode; // // Address of the user mode dispatcher function // DWORD KeUserCallbackDispatcher; // // Lowest kernel mode address // DWORD SystemRangeStart; // // offset in thread object to pointer to the current callback backing // store frame in kernel stack. // DWORD ThCallbackBStore; // // Address of the user mode exception dispatcher function. // Added in API version 10. // DWORD KiUserExceptionDispatcher; // // Stack bounds, added in API version 11. // DWORD StackBase; DWORD StackLimit; DWORD Reserved[5]; } KDHELP, *PKDHELP; __inline void KdHelp32To64( __in PKDHELP p32, __out PKDHELP64 p64 ) { p64->Thread = p32->Thread; p64->ThCallbackStack = p32->ThCallbackStack; p64->NextCallback = p32->NextCallback; p64->FramePointer = p32->FramePointer; p64->KiCallUserMode = p32->KiCallUserMode; p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher; p64->SystemRangeStart = p32->SystemRangeStart; p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher; p64->StackBase = p32->StackBase; p64->StackLimit = p32->StackLimit; } #endif typedef struct _tagSTACKFRAME64 { ADDRESS64 AddrPC; // program counter ADDRESS64 AddrReturn; // return address ADDRESS64 AddrFrame; // frame pointer ADDRESS64 AddrStack; // stack pointer ADDRESS64 AddrBStore; // backing store pointer PVOID FuncTableEntry; // pointer to pdata/fpo or NULL DWORD64 Params[4]; // possible arguments to the function BOOL Far; // WOW far call BOOL Virtual; // is this a virtual frame? DWORD64 Reserved[3]; KDHELP64 KdHelp; } STACKFRAME64, *LPSTACKFRAME64; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define STACKFRAME STACKFRAME64 #define LPSTACKFRAME LPSTACKFRAME64 #else typedef struct _tagSTACKFRAME { ADDRESS AddrPC; // program counter ADDRESS AddrReturn; // return address ADDRESS AddrFrame; // frame pointer ADDRESS AddrStack; // stack pointer PVOID FuncTableEntry; // pointer to pdata/fpo or NULL DWORD Params[4]; // possible arguments to the function BOOL Far; // WOW far call BOOL Virtual; // is this a virtual frame? DWORD Reserved[3]; KDHELP KdHelp; ADDRESS AddrBStore; // backing store pointer } STACKFRAME, *LPSTACKFRAME; #endif typedef BOOL (__stdcall* PREAD_PROCESS_MEMORY_ROUTINE64)( __in HANDLE hProcess, __in DWORD64 qwBaseAddress, __out_bcount(nSize) PVOID lpBuffer, __in DWORD nSize, __out LPDWORD lpNumberOfBytesRead ); typedef PVOID (__stdcall* PFUNCTION_TABLE_ACCESS_ROUTINE64)( __in HANDLE ahProcess, __in DWORD64 AddrBase ); typedef DWORD64 (__stdcall* PGET_MODULE_BASE_ROUTINE64)( __in HANDLE hProcess, __in DWORD64 Address ); typedef DWORD64 (__stdcall* PTRANSLATE_ADDRESS_ROUTINE64)( __in HANDLE hProcess, __in HANDLE hThread, __in LPADDRESS64 lpaddr ); BOOL IMAGEAPI StackWalk64( __in DWORD MachineType, __in HANDLE hProcess, __in HANDLE hThread, __inout LPSTACKFRAME64 StackFrame, __inout PVOID ContextRecord, __in_opt PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, __in_opt PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, __in_opt PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64 #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64 #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64 #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64 #define StackWalk StackWalk64 #else typedef BOOL (__stdcall* PREAD_PROCESS_MEMORY_ROUTINE)( __in HANDLE hProcess, __in DWORD lpBaseAddress, __out_bcount(nSize) PVOID lpBuffer, __in DWORD nSize, __out PDWORD lpNumberOfBytesRead ); typedef PVOID (__stdcall* PFUNCTION_TABLE_ACCESS_ROUTINE)( __in HANDLE hProcess, __in DWORD AddrBase ); typedef DWORD (__stdcall* PGET_MODULE_BASE_ROUTINE)( __in HANDLE hProcess, __in DWORD Address ); typedef DWORD (__stdcall* PTRANSLATE_ADDRESS_ROUTINE)( __in HANDLE hProcess, __in HANDLE hThread, __out LPADDRESS lpaddr ); BOOL IMAGEAPI StackWalk( DWORD MachineType, __in HANDLE hProcess, __in HANDLE hThread, __inout LPSTACKFRAME StackFrame, __inout PVOID ContextRecord, __in_opt PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, __in_opt PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, __in_opt PTRANSLATE_ADDRESS_ROUTINE TranslateAddress ); #endif #define API_VERSION_NUMBER 11 typedef struct API_VERSION { USHORT MajorVersion; USHORT MinorVersion; USHORT Revision; USHORT Reserved; } API_VERSION, *LPAPI_VERSION; LPAPI_VERSION IMAGEAPI ImagehlpApiVersion( VOID ); LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx( __in LPAPI_VERSION AppVersion ); DWORD IMAGEAPI GetTimestampForLoadedLibrary( __in HMODULE Module ); // // typedefs for function pointers // typedef BOOL (CALLBACK* PSYM_ENUMMODULES_CALLBACK64)( __in PCSTR ModuleName, __in DWORD64 BaseOfDll, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMMODULES_CALLBACKW64)( __in PCWSTR ModuleName, __in DWORD64 BaseOfDll, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PENUMLOADED_MODULES_CALLBACK64)( __in PCSTR ModuleName, __in DWORD64 ModuleBase, __in ULONG ModuleSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PENUMLOADED_MODULES_CALLBACKW64)( __in PCWSTR ModuleName, __in DWORD64 ModuleBase, __in ULONG ModuleSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMSYMBOLS_CALLBACK64)( __in PCSTR SymbolName, __in DWORD64 SymbolAddress, __in ULONG SymbolSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMSYMBOLS_CALLBACK64W)( __in PCWSTR SymbolName, __in DWORD64 SymbolAddress, __in ULONG SymbolSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYMBOL_REGISTERED_CALLBACK64)( __in HANDLE hProcess, __in ULONG ActionCode, __in_opt ULONG64 CallbackData, __in_opt ULONG64 UserContext ); typedef PVOID (CALLBACK* PSYMBOL_FUNCENTRY_CALLBACK)( __in HANDLE hProcess, __in DWORD AddrBase, __in_opt PVOID UserContext ); typedef PVOID (CALLBACK* PSYMBOL_FUNCENTRY_CALLBACK64)( __in HANDLE hProcess, __in ULONG64 AddrBase, __in ULONG64 UserContext ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64 #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64 #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64 #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64 #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64 #else typedef BOOL (CALLBACK* PSYM_ENUMMODULES_CALLBACK)( __in PCSTR ModuleName, __in ULONG BaseOfDll, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMSYMBOLS_CALLBACK)( __in PCSTR SymbolName, __in ULONG SymbolAddress, __in ULONG SymbolSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMSYMBOLS_CALLBACKW)( __in PCWSTR SymbolName, __in ULONG SymbolAddress, __in ULONG SymbolSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PENUMLOADED_MODULES_CALLBACK)( __in PCSTR ModuleName, __in ULONG ModuleBase, __in ULONG ModuleSize, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYMBOL_REGISTERED_CALLBACK)( __in HANDLE hProcess, __in ULONG ActionCode, __in_opt PVOID CallbackData, __in_opt PVOID UserContext ); #endif // values found in SYMBOL_INFO.Tag // // This was taken from cvconst.h and should // not override any values found there. // // #define _NO_CVCONST_H_ if you don't // have access to that file... #ifdef _NO_CVCONST_H // 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, SymTagMax }; #endif // // flags found in SYMBOL_INFO.Flags // #define SYMFLAG_VALUEPRESENT 0x00000001 #define SYMFLAG_REGISTER 0x00000008 #define SYMFLAG_REGREL 0x00000010 #define SYMFLAG_FRAMEREL 0x00000020 #define SYMFLAG_PARAMETER 0x00000040 #define SYMFLAG_LOCAL 0x00000080 #define SYMFLAG_CONSTANT 0x00000100 #define SYMFLAG_EXPORT 0x00000200 #define SYMFLAG_FORWARDER 0x00000400 #define SYMFLAG_FUNCTION 0x00000800 #define SYMFLAG_VIRTUAL 0x00001000 #define SYMFLAG_THUNK 0x00002000 #define SYMFLAG_TLSREL 0x00004000 #define SYMFLAG_SLOT 0x00008000 #define SYMFLAG_ILREL 0x00010000 #define SYMFLAG_METADATA 0x00020000 #define SYMFLAG_CLR_TOKEN 0x00040000 // this resets SymNext/Prev to the beginning // of the module passed in the address field #define SYMFLAG_RESET 0x80000000 // // symbol type enumeration // typedef enum { SymNone = 0, SymCoff, SymCv, SymPdb, SymExport, SymDeferred, SymSym, // .sym file SymDia, SymVirtual, NumSymTypes } SYM_TYPE; // // symbol data structure // typedef struct _IMAGEHLP_SYMBOL64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL64) DWORD64 Address; // virtual address including dll base address DWORD Size; // estimated size of symbol, can be zero DWORD Flags; // info about the symbols, see the SYMF defines DWORD MaxNameLength; // maximum size of symbol name in 'Name' CHAR Name[1]; // symbol name (null terminated string) } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64; typedef struct _IMAGEHLP_SYMBOL64_PACKAGE { IMAGEHLP_SYMBOL64 sym; CHAR name[MAX_SYM_NAME + 1]; } IMAGEHLP_SYMBOL64_PACKAGE, *PIMAGEHLP_SYMBOL64_PACKAGE; typedef struct _IMAGEHLP_SYMBOLW64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOLW64) DWORD64 Address; // virtual address including dll base address DWORD Size; // estimated size of symbol, can be zero DWORD Flags; // info about the symbols, see the SYMF defines DWORD MaxNameLength; // maximum size of symbol name in 'Name' WCHAR Name[1]; // symbol name (null terminated string) } IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64; typedef struct _IMAGEHLP_SYMBOLW64_PACKAGE { IMAGEHLP_SYMBOLW64 sym; WCHAR name[MAX_SYM_NAME + 1]; } IMAGEHLP_SYMBOLW64_PACKAGE, *PIMAGEHLP_SYMBOLW64_PACKAGE; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64 #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE #define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64 #define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64 #define IMAGEHLP_SYMBOLW_PACKAGE IMAGEHLP_SYMBOLW64_PACKAGE #define PIMAGEHLP_SYMBOLW_PACKAGE PIMAGEHLP_SYMBOLW64_PACKAGE #else typedef struct _IMAGEHLP_SYMBOL { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL) DWORD Address; // virtual address including dll base address DWORD Size; // estimated size of symbol, can be zero DWORD Flags; // info about the symbols, see the SYMF defines DWORD MaxNameLength; // maximum size of symbol name in 'Name' CHAR Name[1]; // symbol name (null terminated string) } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL; typedef struct _IMAGEHLP_SYMBOL_PACKAGE { IMAGEHLP_SYMBOL sym; CHAR name[MAX_SYM_NAME + 1]; } IMAGEHLP_SYMBOL_PACKAGE, *PIMAGEHLP_SYMBOL_PACKAGE; typedef struct _IMAGEHLP_SYMBOLW { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOLW) DWORD Address; // virtual address including dll base address DWORD Size; // estimated size of symbol, can be zero DWORD Flags; // info about the symbols, see the SYMF defines DWORD MaxNameLength; // maximum size of symbol name in 'Name' WCHAR Name[1]; // symbol name (null terminated string) } IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW; typedef struct _IMAGEHLP_SYMBOLW_PACKAGE { IMAGEHLP_SYMBOLW sym; WCHAR name[MAX_SYM_NAME + 1]; } IMAGEHLP_SYMBOLW_PACKAGE, *PIMAGEHLP_SYMBOLW_PACKAGE; #endif // // module data structure // typedef struct _IMAGEHLP_MODULE64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64) DWORD64 BaseOfImage; // base load address of module DWORD ImageSize; // virtual size of the loaded module DWORD TimeDateStamp; // date/time stamp from pe header DWORD CheckSum; // checksum from the pe header DWORD NumSyms; // number of symbols in the symbol table SYM_TYPE SymType; // type of symbols loaded CHAR ModuleName[32]; // module name CHAR ImageName[256]; // image name CHAR LoadedImageName[256]; // symbol file name // new elements: 07-Jun-2002 CHAR LoadedPdbName[256]; // pdb file name DWORD CVSig; // Signature of the CV record in the debug directories CHAR CVData[MAX_PATH * 3]; // Contents of the CV record DWORD PdbSig; // Signature of PDB GUID PdbSig70; // Signature of PDB (VC 7 and up) DWORD PdbAge; // DBI age of pdb BOOL PdbUnmatched; // loaded an unmatched pdb BOOL DbgUnmatched; // loaded an unmatched dbg BOOL LineNumbers; // we have line number information BOOL GlobalSymbols; // we have internal symbol information BOOL TypeInfo; // we have type information // new elements: 17-Dec-2003 BOOL SourceIndexed; // pdb supports source server BOOL Publics; // contains public symbols } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; typedef struct _IMAGEHLP_MODULEW64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64) DWORD64 BaseOfImage; // base load address of module DWORD ImageSize; // virtual size of the loaded module DWORD TimeDateStamp; // date/time stamp from pe header DWORD CheckSum; // checksum from the pe header DWORD NumSyms; // number of symbols in the symbol table SYM_TYPE SymType; // type of symbols loaded WCHAR ModuleName[32]; // module name WCHAR ImageName[256]; // image name // new elements: 07-Jun-2002 WCHAR LoadedImageName[256]; // symbol file name WCHAR LoadedPdbName[256]; // pdb file name DWORD CVSig; // Signature of the CV record in the debug directories WCHAR CVData[MAX_PATH * 3]; // Contents of the CV record DWORD PdbSig; // Signature of PDB GUID PdbSig70; // Signature of PDB (VC 7 and up) DWORD PdbAge; // DBI age of pdb BOOL PdbUnmatched; // loaded an unmatched pdb BOOL DbgUnmatched; // loaded an unmatched dbg BOOL LineNumbers; // we have line number information BOOL GlobalSymbols; // we have internal symbol information BOOL TypeInfo; // we have type information // new elements: 17-Dec-2003 BOOL SourceIndexed; // pdb supports source server BOOL Publics; // contains public symbols } IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define IMAGEHLP_MODULE IMAGEHLP_MODULE64 #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64 #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64 #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64 #else typedef struct _IMAGEHLP_MODULE { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE) DWORD BaseOfImage; // base load address of module DWORD ImageSize; // virtual size of the loaded module DWORD TimeDateStamp; // date/time stamp from pe header DWORD CheckSum; // checksum from the pe header DWORD NumSyms; // number of symbols in the symbol table SYM_TYPE SymType; // type of symbols loaded CHAR ModuleName[32]; // module name CHAR ImageName[256]; // image name CHAR LoadedImageName[256]; // symbol file name } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE; typedef struct _IMAGEHLP_MODULEW { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE) DWORD BaseOfImage; // base load address of module DWORD ImageSize; // virtual size of the loaded module DWORD TimeDateStamp; // date/time stamp from pe header DWORD CheckSum; // checksum from the pe header DWORD NumSyms; // number of symbols in the symbol table SYM_TYPE SymType; // type of symbols loaded WCHAR ModuleName[32]; // module name WCHAR ImageName[256]; // image name WCHAR LoadedImageName[256]; // symbol file name } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW; #endif // // source file line data structure // typedef struct _IMAGEHLP_LINE64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64) PVOID Key; // internal DWORD LineNumber; // line number in file PCHAR FileName; // full filename DWORD64 Address; // first instruction of line } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64; typedef struct _IMAGEHLP_LINEW64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64) PVOID Key; // internal DWORD LineNumber; // line number in file PWSTR FileName; // full filename DWORD64 Address; // first instruction of line } IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define IMAGEHLP_LINE IMAGEHLP_LINE64 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64 #else typedef struct _IMAGEHLP_LINE { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE) PVOID Key; // internal DWORD LineNumber; // line number in file PCHAR FileName; // full filename DWORD Address; // first instruction of line } IMAGEHLP_LINE, *PIMAGEHLP_LINE; typedef struct _IMAGEHLP_LINEW { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64) PVOID Key; // internal DWORD LineNumber; // line number in file PCHAR FileName; // full filename DWORD64 Address; // first instruction of line } IMAGEHLP_LINEW, *PIMAGEHLP_LINEW; #endif // // source file structure // typedef struct _SOURCEFILE { DWORD64 ModBase; // base address of loaded module PCHAR FileName; // full filename of source } SOURCEFILE, *PSOURCEFILE; typedef struct _SOURCEFILEW { DWORD64 ModBase; // base address of loaded module PWSTR FileName; // full filename of source } SOURCEFILEW, *PSOURCEFILEW; // // data structures used for registered symbol callbacks // #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 #define CBA_SYMBOLS_UNLOADED 0x00000004 #define CBA_DUPLICATE_SYMBOL 0x00000005 #define CBA_READ_MEMORY 0x00000006 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 #define CBA_SET_OPTIONS 0x00000008 #define CBA_EVENT 0x00000010 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 #define CBA_DEBUG_INFO 0x10000000 #define CBA_SRCSRV_INFO 0x20000000 #define CBA_SRCSRV_EVENT 0x40000000 typedef struct _IMAGEHLP_CBA_READ_MEMORY { DWORD64 addr; // address to read from PVOID buf; // buffer to read to DWORD bytes; // amount of bytes to read DWORD* bytesread; // pointer to store amount of bytes read } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY; enum { sevInfo = 0, sevProblem, sevAttn, sevFatal, sevMax // unused }; #define EVENT_SRCSPEW_START 100 #define EVENT_SRCSPEW 100 #define EVENT_SRCSPEW_END 199 typedef struct _IMAGEHLP_CBA_EVENT { DWORD severity; // values from sevInfo to sevFatal DWORD code; // numerical code IDs the error PCHAR desc; // may contain a text description of the error PVOID object; // value dependant upon the error code } IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT; typedef struct _IMAGEHLP_CBA_EVENTW { DWORD severity; // values from sevInfo to sevFatal DWORD code; // numerical code IDs the error PCWSTR desc; // may contain a text description of the error PVOID object; // value dependant upon the error code } IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW; typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64) DWORD64 BaseOfImage; // base load address of module DWORD CheckSum; // checksum from the pe header DWORD TimeDateStamp; // date/time stamp from pe header CHAR FileName[MAX_PATH]; // symbols file or image name BOOLEAN Reparse; // load failure reparse HANDLE hFile; // file handle, if passed DWORD Flags; // } IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOADW64) DWORD64 BaseOfImage; // base load address of module DWORD CheckSum; // checksum from the pe header DWORD TimeDateStamp; // date/time stamp from pe header WCHAR FileName[MAX_PATH + 1]; // symbols file or image name BOOLEAN Reparse; // load failure reparse HANDLE hFile; // file handle, if passed DWORD Flags; // } IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64; #define DSLFLAG_MISMATCHED_PDB 0x1 #define DSLFLAG_MISMATCHED_DBG 0x2 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 #else typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD) DWORD BaseOfImage; // base load address of module DWORD CheckSum; // checksum from the pe header DWORD TimeDateStamp; // date/time stamp from pe header CHAR FileName[MAX_PATH]; // symbols file or image name BOOLEAN Reparse; // load failure reparse HANDLE hFile; // file handle, if passed } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD; #endif typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64) DWORD NumberOfDups; // number of duplicates in the Symbol array PIMAGEHLP_SYMBOL64 Symbol; // array of duplicate symbols DWORD SelectedSymbol; // symbol selected (-1 to start) } IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64; #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64 #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64 #else typedef struct _IMAGEHLP_DUPLICATE_SYMBOL { DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL) DWORD NumberOfDups; // number of duplicates in the Symbol array PIMAGEHLP_SYMBOL Symbol; // array of duplicate symbols DWORD SelectedSymbol; // symbol selected (-1 to start) } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL; #endif // If dbghelp ever needs to display graphical UI, it will use this as the parent window. BOOL IMAGEAPI SymSetParentWindow( __in HWND hwnd ); PCHAR IMAGEAPI SymSetHomeDirectory( __in_opt HANDLE hProcess, __in_opt PCSTR dir ); PWSTR IMAGEAPI SymSetHomeDirectoryW( __in_opt HANDLE hProcess, __in_opt PCWSTR dir ); PCHAR IMAGEAPI SymGetHomeDirectory( __in DWORD type, __out_ecount(size) PSTR dir, __in size_t size ); PWSTR IMAGEAPI SymGetHomeDirectoryW( __in DWORD type, __out_ecount(size) PWSTR dir, __in size_t size ); enum { hdBase = 0, // root directory for dbghelp hdSym, // where symbols are stored hdSrc, // where source is stored hdMax // end marker }; typedef struct _OMAP { ULONG rva; ULONG rvaTo; } OMAP, *POMAP; BOOL IMAGEAPI SymGetOmaps( __in HANDLE hProcess, __in DWORD64 BaseOfDll, __out POMAP* OmapTo, __out PDWORD64 cOmapTo, __out POMAP* OmapFrom, __out PDWORD64 cOmapFrom ); // // options that are set/returned by SymSetOptions() & SymGetOptions() // these are used as a mask // #define SYMOPT_CASE_INSENSITIVE 0x00000001 #define SYMOPT_UNDNAME 0x00000002 #define SYMOPT_DEFERRED_LOADS 0x00000004 #define SYMOPT_NO_CPP 0x00000008 #define SYMOPT_LOAD_LINES 0x00000010 #define SYMOPT_OMAP_FIND_NEAREST 0x00000020 #define SYMOPT_LOAD_ANYTHING 0x00000040 #define SYMOPT_IGNORE_CVREC 0x00000080 #define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100 #define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200 #define SYMOPT_EXACT_SYMBOLS 0x00000400 #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 #define SYMOPT_PUBLICS_ONLY 0x00004000 #define SYMOPT_NO_PUBLICS 0x00008000 #define SYMOPT_AUTO_PUBLICS 0x00010000 #define SYMOPT_NO_IMAGE_SEARCH 0x00020000 #define SYMOPT_SECURE 0x00040000 #define SYMOPT_NO_PROMPTS 0x00080000 #define SYMOPT_OVERWRITE 0x00100000 #define SYMOPT_IGNORE_IMAGEDIR 0x00200000 #define SYMOPT_FLAT_DIRECTORY 0x00400000 #define SYMOPT_FAVOR_COMPRESSED 0x00800000 #define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000 #define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000 #define SYMOPT_DEBUG 0x80000000 DWORD IMAGEAPI SymSetOptions( __in DWORD SymOptions ); DWORD IMAGEAPI SymGetOptions( VOID ); BOOL IMAGEAPI SymCleanup( __in HANDLE hProcess ); BOOL IMAGEAPI SymMatchString( __in PCSTR string, __in PCSTR expression, __in BOOL fCase ); BOOL IMAGEAPI SymMatchStringA( __in PCSTR string, __in PCSTR expression, __in BOOL fCase ); BOOL IMAGEAPI SymMatchStringW( __in PCWSTR string, __in PCWSTR expression, __in BOOL fCase ); typedef BOOL (CALLBACK* PSYM_ENUMSOURCEFILES_CALLBACK)( __in PSOURCEFILE pSourceFile, __in_opt PVOID UserContext ); // for backwards compatibility - don't use this #define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK BOOL IMAGEAPI SymEnumSourceFiles( __in HANDLE hProcess, __in ULONG64 ModBase, __in_opt PCSTR Mask, __in PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMSOURCEFILES_CALLBACKW)( __in PSOURCEFILEW pSourceFile, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumSourceFilesW( __in HANDLE hProcess, __in ULONG64 ModBase, __in_opt PCWSTR Mask, __in PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumerateModules64( __in HANDLE hProcess, __in PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumerateModulesW64( __in HANDLE hProcess, __in PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, __in_opt PVOID UserContext ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymEnumerateModules SymEnumerateModules64 #else BOOL IMAGEAPI SymEnumerateModules( __in HANDLE hProcess, __in PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, __in_opt PVOID UserContext ); #endif BOOL IMAGEAPI EnumerateLoadedModulesEx( __in HANDLE hProcess, __in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI EnumerateLoadedModulesExW( __in HANDLE hProcess, __in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI EnumerateLoadedModules64( __in HANDLE hProcess, __in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI EnumerateLoadedModulesW64( __in HANDLE hProcess, __in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, __in_opt PVOID UserContext ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define EnumerateLoadedModules EnumerateLoadedModules64 #else BOOL IMAGEAPI EnumerateLoadedModules( __in HANDLE hProcess, __in PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, __in_opt PVOID UserContext ); #endif PVOID IMAGEAPI SymFunctionTableAccess64( __in HANDLE hProcess, __in DWORD64 AddrBase ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymFunctionTableAccess SymFunctionTableAccess64 #else PVOID IMAGEAPI SymFunctionTableAccess( __in HANDLE hProcess, __in DWORD AddrBase ); #endif BOOL IMAGEAPI SymGetUnwindInfo( __in HANDLE hProcess, __in DWORD64 Address, __out_bcount_opt(*Size) PVOID Buffer, __inout PULONG Size ); BOOL IMAGEAPI SymGetModuleInfo64( __in HANDLE hProcess, __in DWORD64 qwAddr, __out PIMAGEHLP_MODULE64 ModuleInfo ); BOOL IMAGEAPI SymGetModuleInfoW64( __in HANDLE hProcess, __in DWORD64 qwAddr, __out PIMAGEHLP_MODULEW64 ModuleInfo ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetModuleInfo SymGetModuleInfo64 #define SymGetModuleInfoW SymGetModuleInfoW64 #else BOOL IMAGEAPI SymGetModuleInfo( __in HANDLE hProcess, __in DWORD dwAddr, __out PIMAGEHLP_MODULE ModuleInfo ); BOOL IMAGEAPI SymGetModuleInfoW( __in HANDLE hProcess, __in DWORD dwAddr, __out PIMAGEHLP_MODULEW ModuleInfo ); #endif DWORD64 IMAGEAPI SymGetModuleBase64( __in HANDLE hProcess, __in DWORD64 qwAddr ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetModuleBase SymGetModuleBase64 #else DWORD IMAGEAPI SymGetModuleBase( __in HANDLE hProcess, __in DWORD dwAddr ); #endif typedef struct _SRCCODEINFO { DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO) PVOID Key; // not used DWORD64 ModBase; // base address of module this applies to CHAR Obj[MAX_PATH + 1]; // the object file within the module CHAR FileName[MAX_PATH + 1]; // full filename DWORD LineNumber; // line number in file DWORD64 Address; // first instruction of line } SRCCODEINFO, *PSRCCODEINFO; typedef struct _SRCCODEINFOW { DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO) PVOID Key; // not used DWORD64 ModBase; // base address of module this applies to WCHAR Obj[MAX_PATH + 1]; // the object file within the module WCHAR FileName[MAX_PATH + 1]; // full filename DWORD LineNumber; // line number in file DWORD64 Address; // first instruction of line } SRCCODEINFOW, *PSRCCODEINFOW; typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)( __in PSRCCODEINFO LineInfo, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumLines( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCSTR Obj, __in_opt PCSTR File, __in PSYM_ENUMLINES_CALLBACK EnumLinesCallback, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)( __in PSRCCODEINFOW LineInfo, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumLinesW( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCWSTR Obj, __in_opt PCWSTR File, __in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymGetLineFromAddr64( __in HANDLE hProcess, __in DWORD64 qwAddr, __out PDWORD pdwDisplacement, __out PIMAGEHLP_LINE64 Line64 ); BOOL IMAGEAPI SymGetLineFromAddrW64( __in HANDLE hProcess, __in DWORD64 dwAddr, __out PDWORD pdwDisplacement, __out PIMAGEHLP_LINEW64 Line ); BOOL IMAGEAPI SymEnumSourceLines( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCSTR Obj, __in_opt PCSTR File, __in_opt DWORD Line, __in DWORD Flags, __in PSYM_ENUMLINES_CALLBACK EnumLinesCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumSourceLinesW( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCWSTR Obj, __in_opt PCWSTR File, __in_opt DWORD Line, __in DWORD Flags, __in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback, __in_opt PVOID UserContext ); // flags for SymEnumSourceLines #define ESLFLAG_FULLPATH 0x1 #define ESLFLAG_NEAREST 0x2 #define ESLFLAG_PREV 0x4 #define ESLFLAG_NEXT 0x8 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetLineFromAddr SymGetLineFromAddr64 #define SymGetLineFromAddrW SymGetLineFromAddrW64 #else BOOL IMAGEAPI SymGetLineFromAddr( __in HANDLE hProcess, __in DWORD dwAddr, __out PDWORD pdwDisplacement, __out PIMAGEHLP_LINE Line ); BOOL IMAGEAPI SymGetLineFromAddrW( __in HANDLE hProcess, __in DWORD dwAddr, __out PDWORD pdwDisplacement, __out PIMAGEHLP_LINEW Line ); #endif BOOL IMAGEAPI SymGetLineFromName64( __in HANDLE hProcess, __in_opt PCSTR ModuleName, __in_opt PCSTR FileName, __in DWORD dwLineNumber, __out PLONG plDisplacement, __inout PIMAGEHLP_LINE64 Line ); BOOL IMAGEAPI SymGetLineFromNameW64( __in HANDLE hProcess, __in_opt PCWSTR ModuleName, __in_opt PCWSTR FileName, __in DWORD dwLineNumber, __out PLONG plDisplacement, __inout PIMAGEHLP_LINEW64 Line ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetLineFromName SymGetLineFromName64 #else BOOL IMAGEAPI SymGetLineFromName( __in HANDLE hProcess, __in_opt PCSTR ModuleName, __in_opt PCSTR FileName, __in DWORD dwLineNumber, __out PLONG plDisplacement, __inout PIMAGEHLP_LINE Line ); #endif BOOL IMAGEAPI SymGetLineNext64( __in HANDLE hProcess, __inout PIMAGEHLP_LINE64 Line ); BOOL IMAGEAPI SymGetLineNextW64( __in HANDLE hProcess, __inout PIMAGEHLP_LINEW64 Line ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetLineNext SymGetLineNext64 #else BOOL IMAGEAPI SymGetLineNext( __in HANDLE hProcess, __inout PIMAGEHLP_LINE Line ); BOOL IMAGEAPI SymGetLineNextW( __in HANDLE hProcess, __inout PIMAGEHLP_LINEW Line ); #endif BOOL IMAGEAPI SymGetLinePrev64( __in HANDLE hProcess, __inout PIMAGEHLP_LINE64 Line ); BOOL IMAGEAPI SymGetLinePrevW64( __in HANDLE hProcess, __inout PIMAGEHLP_LINEW64 Line ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetLinePrev SymGetLinePrev64 #else BOOL IMAGEAPI SymGetLinePrev( __in HANDLE hProcess, __inout PIMAGEHLP_LINE Line ); BOOL IMAGEAPI SymGetLinePrevW( __in HANDLE hProcess, __inout PIMAGEHLP_LINEW Line ); #endif ULONG IMAGEAPI SymGetFileLineOffsets64( __in HANDLE hProcess, __in_opt PCSTR ModuleName, __in PCSTR FileName, __out_ecount(BufferLines) PDWORD64 Buffer, __in ULONG BufferLines ); BOOL IMAGEAPI SymMatchFileName( __in PCSTR FileName, __in PCSTR Match, __deref_opt_out PSTR* FileNameStop, __deref_opt_out PSTR* MatchStop ); BOOL IMAGEAPI SymMatchFileNameW( __in PCWSTR FileName, __in PCWSTR Match, __deref_opt_out PWSTR* FileNameStop, __deref_opt_out PWSTR* MatchStop ); BOOL IMAGEAPI SymGetSourceFile( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCSTR Params, __in PCSTR FileSpec, __out_ecount(Size) PSTR FilePath, __in DWORD Size ); BOOL IMAGEAPI SymGetSourceFileW( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCWSTR Params, __in PCWSTR FileSpec, __out_ecount(Size) PWSTR FilePath, __in DWORD Size ); BOOL IMAGEAPI SymGetSourceFileToken( __in HANDLE hProcess, __in ULONG64 Base, __in PCSTR FileSpec, __deref_out PVOID* Token, __out DWORD* Size ); BOOL IMAGEAPI SymGetSourceFileTokenW( __in HANDLE hProcess, __in ULONG64 Base, __in PCWSTR FileSpec, __deref_out PVOID* Token, __out DWORD* Size ); BOOL IMAGEAPI SymGetSourceFileFromToken( __in HANDLE hProcess, __in PVOID Token, __in_opt PCSTR Params, __out_ecount(Size) PSTR FilePath, __in DWORD Size ); BOOL IMAGEAPI SymGetSourceFileFromTokenW( __in HANDLE hProcess, __in PVOID Token, __in_opt PCWSTR Params, __out_ecount(Size) PWSTR FilePath, __in DWORD Size ); BOOL IMAGEAPI SymGetSourceVarFromToken( __in HANDLE hProcess, __in PVOID Token, __in_opt PCSTR Params, __in PCSTR VarName, __out_ecount(Size) PSTR Value, __in DWORD Size ); BOOL IMAGEAPI SymGetSourceVarFromTokenW( __in HANDLE hProcess, __in PVOID Token, __in_opt PCWSTR Params, __in PCWSTR VarName, __out_ecount(Size) PWSTR Value, __in DWORD Size ); typedef BOOL (CALLBACK* PENUMSOURCEFILETOKENSCALLBACK)(__in PVOID token, __in size_t size); BOOL IMAGEAPI SymEnumSourceFileTokens( __in HANDLE hProcess, __in ULONG64 Base, __in PENUMSOURCEFILETOKENSCALLBACK Callback ); BOOL IMAGEAPI SymInitialize( __in HANDLE hProcess, __in_opt PCSTR UserSearchPath, __in BOOL fInvadeProcess ); BOOL IMAGEAPI SymInitializeW( __in HANDLE hProcess, __in_opt PCWSTR UserSearchPath, __in BOOL fInvadeProcess ); BOOL IMAGEAPI SymGetSearchPath( __in HANDLE hProcess, __out_ecount(SearchPathLength) PSTR SearchPath, __in DWORD SearchPathLength ); BOOL IMAGEAPI SymGetSearchPathW( __in HANDLE hProcess, __out_ecount(SearchPathLength) PWSTR SearchPath, __in DWORD SearchPathLength ); BOOL IMAGEAPI SymSetSearchPath( __in HANDLE hProcess, __in_opt PCSTR SearchPath ); BOOL IMAGEAPI SymSetSearchPathW( __in HANDLE hProcess, __in_opt PCWSTR SearchPath ); #define SLMFLAG_VIRTUAL 0x1 #define SLMFLAG_ALT_INDEX 0x2 #define SLMFLAG_NO_SYMBOLS 0x4 DWORD64 IMAGEAPI SymLoadModuleEx( __in HANDLE hProcess, __in_opt HANDLE hFile, __in_opt PCSTR ImageName, __in_opt PCSTR ModuleName, __in DWORD64 BaseOfDll, __in DWORD DllSize, __in_opt PMODLOAD_DATA Data, __in_opt DWORD Flags ); DWORD64 IMAGEAPI SymLoadModuleExW( __in HANDLE hProcess, __in_opt HANDLE hFile, __in_opt PCWSTR ImageName, __in_opt PCWSTR ModuleName, __in DWORD64 BaseOfDll, __in DWORD DllSize, __in_opt PMODLOAD_DATA Data, __in_opt DWORD Flags ); BOOL IMAGEAPI SymUnloadModule64( __in HANDLE hProcess, __in DWORD64 BaseOfDll ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymUnloadModule SymUnloadModule64 #else BOOL IMAGEAPI SymUnloadModule( __in HANDLE hProcess, __in DWORD BaseOfDll ); #endif BOOL IMAGEAPI SymUnDName64( __in PIMAGEHLP_SYMBOL64 sym, // Symbol to undecorate __out_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorated name in __in DWORD UnDecNameLength // Size of the buffer ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymUnDName SymUnDName64 #else BOOL IMAGEAPI SymUnDName( __in PIMAGEHLP_SYMBOL sym, // Symbol to undecorate __out_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorated name in __in DWORD UnDecNameLength // Size of the buffer ); #endif BOOL IMAGEAPI SymRegisterCallback64( __in HANDLE hProcess, __in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, __in ULONG64 UserContext ); BOOL IMAGEAPI SymRegisterCallbackW64( __in HANDLE hProcess, __in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, __in ULONG64 UserContext ); BOOL IMAGEAPI SymRegisterFunctionEntryCallback64( __in HANDLE hProcess, __in PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction, __in ULONG64 UserContext ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymRegisterCallback SymRegisterCallback64 #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64 #else BOOL IMAGEAPI SymRegisterCallback( __in HANDLE hProcess, __in PSYMBOL_REGISTERED_CALLBACK CallbackFunction, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymRegisterFunctionEntryCallback( __in HANDLE hProcess, __in PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction, __in_opt PVOID UserContext ); #endif typedef struct _IMAGEHLP_SYMBOL_SRC { DWORD sizeofstruct; DWORD type; char file[MAX_PATH]; } IMAGEHLP_SYMBOL_SRC, *PIMAGEHLP_SYMBOL_SRC; typedef struct _MODULE_TYPE_INFO // AKA TYPTYP { USHORT dataLength; USHORT leaf; BYTE data[1]; } MODULE_TYPE_INFO, *PMODULE_TYPE_INFO; typedef struct _SYMBOL_INFO { ULONG SizeOfStruct; ULONG TypeIndex; // Type Index of symbol ULONG64 Reserved[2]; ULONG Index; ULONG Size; ULONG64 ModBase; // Base Address of module comtaining this symbol ULONG Flags; ULONG64 Value; // Value of symbol, ValuePresent should be 1 ULONG64 Address; // Address of symbol including base address of module ULONG Register; // register holding value or pointer to value ULONG Scope; // scope of the symbol ULONG Tag; // pdb classification ULONG NameLen; // Actual length of name ULONG MaxNameLen; CHAR Name[1]; // Name of symbol } SYMBOL_INFO, *PSYMBOL_INFO; typedef struct _SYMBOL_INFO_PACKAGE { SYMBOL_INFO si; CHAR name[MAX_SYM_NAME + 1]; } SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE; typedef struct _SYMBOL_INFOW { ULONG SizeOfStruct; ULONG TypeIndex; // Type Index of symbol ULONG64 Reserved[2]; ULONG Index; ULONG Size; ULONG64 ModBase; // Base Address of module comtaining this symbol ULONG Flags; ULONG64 Value; // Value of symbol, ValuePresent should be 1 ULONG64 Address; // Address of symbol including base address of module ULONG Register; // register holding value or pointer to value ULONG Scope; // scope of the symbol ULONG Tag; // pdb classification ULONG NameLen; // Actual length of name ULONG MaxNameLen; WCHAR Name[1]; // Name of symbol } SYMBOL_INFOW, *PSYMBOL_INFOW; typedef struct _SYMBOL_INFO_PACKAGEW { SYMBOL_INFOW si; WCHAR name[MAX_SYM_NAME + 1]; } SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW; typedef struct _IMAGEHLP_STACK_FRAME { ULONG64 InstructionOffset; ULONG64 ReturnOffset; ULONG64 FrameOffset; ULONG64 StackOffset; ULONG64 BackingStoreOffset; ULONG64 FuncTableEntry; ULONG64 Params[4]; ULONG64 Reserved[5]; BOOL Virtual; ULONG Reserved2; } IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME; typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT; BOOL IMAGEAPI SymSetContext( __in HANDLE hProcess, __in PIMAGEHLP_STACK_FRAME StackFrame, __in_opt PIMAGEHLP_CONTEXT Context ); BOOL IMAGEAPI SymSetScopeFromAddr( __in HANDLE hProcess, __in ULONG64 Address ); BOOL IMAGEAPI SymSetScopeFromIndex( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in DWORD Index ); typedef BOOL (CALLBACK* PSYM_ENUMPROCESSES_CALLBACK)( __in HANDLE hProcess, __in PVOID UserContext ); BOOL IMAGEAPI SymEnumProcesses( __in PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback, __in PVOID UserContext ); BOOL IMAGEAPI SymFromAddr( __in HANDLE hProcess, __in DWORD64 Address, __out_opt PDWORD64 Displacement, __inout PSYMBOL_INFO Symbol ); BOOL IMAGEAPI SymFromAddrW( __in HANDLE hProcess, __in DWORD64 Address, __out_opt PDWORD64 Displacement, __inout PSYMBOL_INFOW Symbol ); BOOL IMAGEAPI SymFromToken( __in HANDLE hProcess, __in DWORD64 Base, __in DWORD Token, __inout PSYMBOL_INFO Symbol ); BOOL IMAGEAPI SymFromTokenW( __in HANDLE hProcess, __in DWORD64 Base, __in DWORD Token, __inout PSYMBOL_INFOW Symbol ); BOOL IMAGEAPI SymNext( __in HANDLE hProcess, __inout PSYMBOL_INFO si ); BOOL IMAGEAPI SymNextW( __in HANDLE hProcess, __inout PSYMBOL_INFOW siw ); BOOL IMAGEAPI SymPrev( __in HANDLE hProcess, __inout PSYMBOL_INFO si ); BOOL IMAGEAPI SymPrevW( __in HANDLE hProcess, __inout PSYMBOL_INFOW siw ); // While SymFromName will provide a symbol from a name, // SymEnumSymbols can provide the same matching information // for ALL symbols with a matching name, even regular // expressions. That way you can search across modules // and differentiate between identically named symbols. BOOL IMAGEAPI SymFromName( __in HANDLE hProcess, __in PCSTR Name, __inout PSYMBOL_INFO Symbol ); BOOL IMAGEAPI SymFromNameW( __in HANDLE hProcess, __in PCWSTR Name, __inout PSYMBOL_INFOW Symbol ); typedef BOOL (CALLBACK* PSYM_ENUMERATESYMBOLS_CALLBACK)( __in PSYMBOL_INFO pSymInfo, __in ULONG SymbolSize, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumSymbols( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt PCSTR Mask, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext ); typedef BOOL (CALLBACK* PSYM_ENUMERATESYMBOLS_CALLBACKW)( __in PSYMBOL_INFOW pSymInfo, __in ULONG SymbolSize, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumSymbolsW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt PCWSTR Mask, __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumSymbolsForAddr( __in HANDLE hProcess, __in DWORD64 Address, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumSymbolsForAddrW( __in HANDLE hProcess, __in DWORD64 Address, __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext ); #define SYMSEARCH_MASKOBJS 0x01 // used internally to implement other APIs #define SYMSEARCH_RECURSE 0X02 // recurse scopes #define SYMSEARCH_GLOBALSONLY 0X04 // search only for global symbols #define SYMSEARCH_ALLITEMS 0X08 // search for everything in the pdb, not just normal scoped symbols BOOL IMAGEAPI SymSearch( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt DWORD Index, __in_opt DWORD SymTag, __in_opt PCSTR Mask, __in_opt DWORD64 Address, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext, __in DWORD Options ); BOOL IMAGEAPI SymSearchW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt DWORD Index, __in_opt DWORD SymTag, __in_opt PCWSTR Mask, __in_opt DWORD64 Address, __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext, __in DWORD Options ); BOOL IMAGEAPI SymGetScope( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in DWORD Index, __inout PSYMBOL_INFO Symbol ); BOOL IMAGEAPI SymGetScopeW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in DWORD Index, __inout PSYMBOL_INFOW Symbol ); BOOL IMAGEAPI SymFromIndex( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in DWORD Index, __inout PSYMBOL_INFO Symbol ); BOOL IMAGEAPI SymFromIndexW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in DWORD Index, __inout PSYMBOL_INFOW Symbol ); typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO { TI_GET_SYMTAG, TI_GET_SYMNAME, TI_GET_LENGTH, TI_GET_TYPE, TI_GET_TYPEID, TI_GET_BASETYPE, TI_GET_ARRAYINDEXTYPEID, TI_FINDCHILDREN, TI_GET_DATAKIND, TI_GET_ADDRESSOFFSET, TI_GET_OFFSET, TI_GET_VALUE, TI_GET_COUNT, TI_GET_CHILDRENCOUNT, TI_GET_BITPOSITION, TI_GET_VIRTUALBASECLASS, TI_GET_VIRTUALTABLESHAPEID, TI_GET_VIRTUALBASEPOINTEROFFSET, TI_GET_CLASSPARENTID, TI_GET_NESTED, TI_GET_SYMINDEX, TI_GET_LEXICALPARENT, TI_GET_ADDRESS, TI_GET_THISADJUST, TI_GET_UDTKIND, TI_IS_EQUIV_TO, TI_GET_CALLING_CONVENTION, TI_IS_CLOSE_EQUIV_TO, TI_GTIEX_REQS_VALID, TI_GET_VIRTUALBASEOFFSET, TI_GET_VIRTUALBASEDISPINDEX, TI_GET_IS_REFERENCE, TI_GET_INDIRECTVIRTUALBASECLASS, IMAGEHLP_SYMBOL_TYPE_INFO_MAX, } IMAGEHLP_SYMBOL_TYPE_INFO; typedef struct _TI_FINDCHILDREN_PARAMS { ULONG Count; ULONG Start; ULONG ChildId[1]; } TI_FINDCHILDREN_PARAMS; BOOL IMAGEAPI SymGetTypeInfo( __in HANDLE hProcess, __in DWORD64 ModBase, __in ULONG TypeId, __in IMAGEHLP_SYMBOL_TYPE_INFO GetType, __out PVOID pInfo ); #define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001 #define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002 typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS { IN ULONG SizeOfStruct; IN ULONG Flags; IN ULONG NumIds; IN PULONG TypeIds; IN ULONG64 TagFilter; IN ULONG NumReqs; IN IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds; IN PULONG_PTR ReqOffsets; IN PULONG ReqSizes; IN ULONG_PTR ReqStride; IN ULONG_PTR BufferSize; OUT PVOID Buffer; OUT ULONG EntriesMatched; OUT ULONG EntriesFilled; OUT ULONG64 TagsFound; OUT ULONG64 AllReqsValid; IN ULONG NumReqsValid; OUT PULONG64 ReqsValid OPTIONAL; } IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS; BOOL IMAGEAPI SymGetTypeInfoEx( __in HANDLE hProcess, __in DWORD64 ModBase, __inout PIMAGEHLP_GET_TYPE_INFO_PARAMS Params ); BOOL IMAGEAPI SymEnumTypes( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumTypesW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumTypesByName( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt PCSTR mask, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymEnumTypesByNameW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt PCWSTR mask, __in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext ); BOOL IMAGEAPI SymGetTypeFromName( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PCSTR Name, __inout PSYMBOL_INFO Symbol ); BOOL IMAGEAPI SymGetTypeFromNameW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PCWSTR Name, __inout PSYMBOL_INFOW Symbol ); BOOL IMAGEAPI SymAddSymbol( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PCSTR Name, __in DWORD64 Address, __in DWORD Size, __in DWORD Flags ); BOOL IMAGEAPI SymAddSymbolW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PCWSTR Name, __in DWORD64 Address, __in DWORD Size, __in DWORD Flags ); BOOL IMAGEAPI SymDeleteSymbol( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt PCSTR Name, __in DWORD64 Address, __in DWORD Flags ); BOOL IMAGEAPI SymDeleteSymbolW( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in_opt PCWSTR Name, __in DWORD64 Address, __in DWORD Flags ); BOOL IMAGEAPI SymRefreshModuleList( __in HANDLE hProcess ); BOOL IMAGEAPI SymAddSourceStream( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCSTR StreamFile, __in_bcount_opt(Size) PBYTE Buffer, __in size_t Size ); typedef BOOL (WINAPI* SYMADDSOURCESTREAM)(HANDLE, ULONG64, PCSTR, PBYTE, size_t); BOOL IMAGEAPI SymAddSourceStreamA( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCSTR StreamFile, __in_bcount_opt(Size) PBYTE Buffer, __in size_t Size ); typedef BOOL (WINAPI* SYMADDSOURCESTREAMA)(HANDLE, ULONG64, PCSTR, PBYTE, size_t); BOOL IMAGEAPI SymAddSourceStreamW( __in HANDLE hProcess, __in ULONG64 Base, __in_opt PCWSTR FileSpec, __in_bcount_opt(Size) PBYTE Buffer, __in size_t Size ); BOOL IMAGEAPI SymSrvIsStoreW( __in_opt HANDLE hProcess, __in PCWSTR path ); BOOL IMAGEAPI SymSrvIsStore( __in_opt HANDLE hProcess, __in PCSTR path ); PCSTR IMAGEAPI SymSrvDeltaName( __in HANDLE hProcess, __in_opt PCSTR SymPath, __in PCSTR Type, __in PCSTR File1, __in PCSTR File2 ); PCWSTR IMAGEAPI SymSrvDeltaNameW( __in HANDLE hProcess, __in_opt PCWSTR SymPath, __in PCWSTR Type, __in PCWSTR File1, __in PCWSTR File2 ); PCSTR IMAGEAPI SymSrvGetSupplement( __in HANDLE hProcess, __in_opt PCSTR SymPath, __in PCSTR Node, __in PCSTR File ); PCWSTR IMAGEAPI SymSrvGetSupplementW( __in HANDLE hProcess, __in_opt PCWSTR SymPath, __in PCWSTR Node, __in PCWSTR File ); BOOL IMAGEAPI SymSrvGetFileIndexes( __in PCSTR File, __out GUID* Id, __out PDWORD Val1, __out_opt PDWORD Val2, __in DWORD Flags ); BOOL IMAGEAPI SymSrvGetFileIndexesW( __in PCWSTR File, __out GUID* Id, __out PDWORD Val1, __out_opt PDWORD Val2, __in DWORD Flags ); BOOL IMAGEAPI SymSrvGetFileIndexStringW( __in HANDLE hProcess, __in_opt PCWSTR SrvPath, __in PCWSTR File, __out_ecount(Size) PWSTR Index, __in size_t Size, __in DWORD Flags ); BOOL IMAGEAPI SymSrvGetFileIndexString( __in HANDLE hProcess, __in_opt PCSTR SrvPath, __in PCSTR File, __out_ecount(Size) PSTR Index, __in size_t Size, __in DWORD Flags ); typedef struct { DWORD sizeofstruct; char file[MAX_PATH + 1]; BOOL stripped; DWORD timestamp; DWORD size; char dbgfile[MAX_PATH + 1]; char pdbfile[MAX_PATH + 1]; GUID guid; DWORD sig; DWORD age; } SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO; typedef struct { DWORD sizeofstruct; WCHAR file[MAX_PATH + 1]; BOOL stripped; DWORD timestamp; DWORD size; WCHAR dbgfile[MAX_PATH + 1]; WCHAR pdbfile[MAX_PATH + 1]; GUID guid; DWORD sig; DWORD age; } SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW; BOOL IMAGEAPI SymSrvGetFileIndexInfo( __in PCSTR File, __out PSYMSRV_INDEX_INFO Info, __in DWORD Flags ); BOOL IMAGEAPI SymSrvGetFileIndexInfoW( __in PCWSTR File, __out PSYMSRV_INDEX_INFOW Info, __in DWORD Flags ); PCSTR IMAGEAPI SymSrvStoreSupplement( __in HANDLE hProcess, __in_opt PCSTR SrvPath, __in PCSTR Node, __in PCSTR File, __in DWORD Flags ); PCWSTR IMAGEAPI SymSrvStoreSupplementW( __in HANDLE hProcess, __in_opt PCWSTR SymPath, __in PCWSTR Node, __in PCWSTR File, __in DWORD Flags ); PCSTR IMAGEAPI SymSrvStoreFile( __in HANDLE hProcess, __in_opt PCSTR SrvPath, __in PCSTR File, __in DWORD Flags ); PCWSTR IMAGEAPI SymSrvStoreFileW( __in HANDLE hProcess, __in_opt PCWSTR SrvPath, __in PCWSTR File, __in DWORD Flags ); // used by SymGetSymbolFile's "Type" parameter enum { sfImage = 0, sfDbg, sfPdb, sfMpd, sfMax }; BOOL IMAGEAPI SymGetSymbolFile( __in_opt HANDLE hProcess, __in_opt PCSTR SymPath, __in PCSTR ImageFile, __in DWORD Type, __out_ecount(cSymbolFile) PSTR SymbolFile, __in size_t cSymbolFile, __out_ecount(cDbgFile) PSTR DbgFile, __in size_t cDbgFile ); BOOL IMAGEAPI SymGetSymbolFileW( __in_opt HANDLE hProcess, __in_opt PCWSTR SymPath, __in PCWSTR ImageFile, __in DWORD Type, __out_ecount(cSymbolFile) PWSTR SymbolFile, __in size_t cSymbolFile, __out_ecount(cDbgFile) PWSTR DbgFile, __in size_t cDbgFile ); // // Full user-mode dump creation. // typedef BOOL (WINAPI* PDBGHELP_CREATE_USER_DUMP_CALLBACK)( __in DWORD DataType, __in PVOID* Data, __out LPDWORD DataLength, __in_opt PVOID UserData ); BOOL WINAPI DbgHelpCreateUserDump( __in_opt LPCSTR FileName, __in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback, __in_opt PVOID UserData ); BOOL WINAPI DbgHelpCreateUserDumpW( __in_opt LPCWSTR FileName, __in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback, __in_opt PVOID UserData ); // ----------------------------------------------------------------- // The following 4 legacy APIs are fully supported, but newer // ones are recommended. SymFromName and SymFromAddr provide // much more detailed info on the returned symbol. BOOL IMAGEAPI SymGetSymFromAddr64( __in HANDLE hProcess, __in DWORD64 qwAddr, __out_opt PDWORD64 pdwDisplacement, __inout PIMAGEHLP_SYMBOL64 Symbol ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetSymFromAddr SymGetSymFromAddr64 #else BOOL IMAGEAPI SymGetSymFromAddr( __in HANDLE hProcess, __in DWORD dwAddr, __out_opt PDWORD pdwDisplacement, __inout PIMAGEHLP_SYMBOL Symbol ); #endif // While following two APIs will provide a symbol from a name, // SymEnumSymbols can provide the same matching information // for ALL symbols with a matching name, even regular // expressions. That way you can search across modules // and differentiate between identically named symbols. BOOL IMAGEAPI SymGetSymFromName64( __in HANDLE hProcess, __in PCSTR Name, __inout PIMAGEHLP_SYMBOL64 Symbol ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetSymFromName SymGetSymFromName64 #else BOOL IMAGEAPI SymGetSymFromName( __in HANDLE hProcess, __in PCSTR Name, __inout PIMAGEHLP_SYMBOL Symbol ); #endif // Symbol server exports typedef BOOL (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR); typedef BOOL (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR); typedef BOOL (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR); typedef BOOL (WINAPI* PSYMBOLSERVERBYINDEXPROC)(PCSTR, PCSTR, PCSTR, PSTR); typedef BOOL (WINAPI* PSYMBOLSERVERBYINDEXPROCA)(PCSTR, PCSTR, PCSTR, PSTR); typedef BOOL (WINAPI* PSYMBOLSERVERBYINDEXPROCW)(PCWSTR, PCWSTR, PCWSTR, PWSTR); typedef BOOL (WINAPI* PSYMBOLSERVEROPENPROC)(VOID); typedef BOOL (WINAPI* PSYMBOLSERVERCLOSEPROC)(VOID); typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64); typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSWPROC)(UINT_PTR, ULONG64); typedef BOOL (CALLBACK WINAPI* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action, ULONG64 data, ULONG64 context); typedef UINT_PTR(WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(); typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR); typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR); typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR); typedef BOOL (WINAPI* PSYMBOLSERVERGETVERSION)(LPAPI_VERSION); typedef BOOL (WINAPI* PSYMBOLSERVERDELTANAME)(PCSTR, PVOID, DWORD, DWORD, PVOID, DWORD, DWORD, PSTR, size_t); typedef BOOL (WINAPI* PSYMBOLSERVERDELTANAMEW)(PCWSTR, PVOID, DWORD, DWORD, PVOID, DWORD, DWORD, PWSTR, size_t); typedef BOOL (WINAPI* PSYMBOLSERVERGETSUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, size_t); typedef BOOL (WINAPI* PSYMBOLSERVERGETSUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR, size_t); typedef BOOL (WINAPI* PSYMBOLSERVERSTORESUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, size_t, DWORD); typedef BOOL (WINAPI* PSYMBOLSERVERSTORESUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR, size_t, DWORD); typedef BOOL (WINAPI* PSYMBOLSERVERGETINDEXSTRING)(PVOID, DWORD, DWORD, PSTR, size_t); typedef BOOL (WINAPI* PSYMBOLSERVERGETINDEXSTRINGW)(PVOID, DWORD, DWORD, PWSTR, size_t); typedef BOOL (WINAPI* PSYMBOLSERVERSTOREFILE)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR, size_t, DWORD); typedef BOOL (WINAPI* PSYMBOLSERVERSTOREFILEW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR, size_t, DWORD); typedef BOOL (WINAPI* PSYMBOLSERVERISSTORE)(PCSTR); typedef BOOL (WINAPI* PSYMBOLSERVERISSTOREW)(PCWSTR); typedef DWORD (WINAPI* PSYMBOLSERVERVERSION)(); typedef BOOL (CALLBACK WINAPI* PSYMBOLSERVERMESSAGEPROC)(UINT_PTR action, ULONG64 data, ULONG64 context); #define SYMSRV_VERSION 2 #define SSRVOPT_CALLBACK 0x00000001 #define SSRVOPT_DWORD 0x00000002 #define SSRVOPT_DWORDPTR 0x00000004 #define SSRVOPT_GUIDPTR 0x00000008 #define SSRVOPT_OLDGUIDPTR 0x00000010 #define SSRVOPT_UNATTENDED 0x00000020 #define SSRVOPT_NOCOPY 0x00000040 #define SSRVOPT_GETPATH 0x00000040 #define SSRVOPT_PARENTWIN 0x00000080 #define SSRVOPT_PARAMTYPE 0x00000100 #define SSRVOPT_SECURE 0x00000200 #define SSRVOPT_TRACE 0x00000400 #define SSRVOPT_SETCONTEXT 0x00000800 #define SSRVOPT_PROXY 0x00001000 #define SSRVOPT_DOWNSTREAM_STORE 0x00002000 #define SSRVOPT_OVERWRITE 0x00004000 #define SSRVOPT_RESETTOU 0x00008000 #define SSRVOPT_CALLBACKW 0x00010000 #define SSRVOPT_FLAT_DEFAULT_STORE 0x00020000 #define SSRVOPT_PROXYW 0x00040000 #define SSRVOPT_MESSAGE 0x00080000 #define SSRVOPT_SERVICE 0x00100000 // deprecated #define SSRVOPT_FAVOR_COMPRESSED 0x00200000 #define SSRVOPT_STRING 0x00400000 #define SSRVOPT_WINHTTP 0x00800000 #define SSRVOPT_WININET 0x01000000 #define SSRVOPT_MAX 0x0100000 #define SSRVOPT_RESET ((ULONG_PTR)-1) #define NUM_SSRVOPTS 30 #define SSRVACTION_TRACE 1 #define SSRVACTION_QUERYCANCEL 2 #define SSRVACTION_EVENT 3 #define SSRVACTION_EVENTW 4 #define SSRVACTION_SIZE 5 #define SYMSTOREOPT_COMPRESS 0x01 #define SYMSTOREOPT_OVERWRITE 0x02 #define SYMSTOREOPT_RETURNINDEX 0x04 #define SYMSTOREOPT_POINTER 0x08 #define SYMSTOREOPT_ALT_INDEX 0x10 #define SYMSTOREOPT_UNICODE 0x20 #define SYMSTOREOPT_PASS_IF_EXISTS 0x40 #ifdef DBGHELP_TRANSLATE_TCHAR #define SymInitialize SymInitializeW #define SymAddSymbol SymAddSymbolW #define SymDeleteSymbol SymDeleteSymbolW #define SearchTreeForFile SearchTreeForFileW #define UnDecorateSymbolName UnDecorateSymbolNameW #define SymGetLineFromName64 SymGetLineFromNameW64 #define SymGetLineFromAddr64 SymGetLineFromAddrW64 #define SymGetLineNext64 SymGetLineNextW64 #define SymGetLinePrev64 SymGetLinePrevW64 #define SymFromName SymFromNameW #define SymFindExecutableImage SymFindExecutableImageW #define FindExecutableImageEx FindExecutableImageExW #define SymSearch SymSearchW #define SymEnumLines SymEnumLinesW #define SymEnumSourceLines SymEnumSourceLinesW #define SymGetTypeFromName SymGetTypeFromNameW #define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW #define SymFromAddr SymFromAddrW #define SymMatchString SymMatchStringW #define SymEnumSourceFiles SymEnumSourceFilesW #define SymEnumSymbols SymEnumSymbolsW #define SymLoadModuleEx SymLoadModuleExW #define SymSetSearchPath SymSetSearchPathW #define SymGetSearchPath SymGetSearchPathW #define EnumDirTree EnumDirTreeW #define SymFromToken SymFromTokenW #define SymFromIndex SymFromIndexW #define SymGetScope SymGetScopeW #define SymNext SymNextW #define SymPrev SymPrevW #define SymEnumTypes SymEnumTypesW #define SymEnumTypesByName SymEnumTypesByNameW #define SymRegisterCallback64 SymRegisterCallbackW64 #define SymFindDebugInfoFile SymFindDebugInfoFileW #define FindDebugInfoFileEx FindDebugInfoFileExW #define SymFindFileInPath SymFindFileInPathW #define SymEnumerateModules64 SymEnumerateModulesW64 #define SymSetHomeDirectory SymSetHomeDirectoryW #define SymGetHomeDirectory SymGetHomeDirectoryW #define SymGetSourceFile SymGetSourceFileW #define SymGetSourceFileToken SymGetSourceFileTokenW #define SymGetSourceFileFromToken SymGetSourceFileFromTokenW #define SymGetSourceVarFromToken SymGetSourceVarFromTokenW #define SymGetSourceFileToken SymGetSourceFileTokenW #define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64 #define SymFindFileInPath SymFindFileInPathW #define SymMatchFileName SymMatchFileNameW #define SymGetSourceFileFromToken SymGetSourceFileFromTokenW #define SymGetSourceVarFromToken SymGetSourceVarFromTokenW #define SymGetModuleInfo64 SymGetModuleInfoW64 #define SymSrvIsStore SymSrvIsStoreW #define SymSrvDeltaName SymSrvDeltaNameW #define SymSrvGetSupplement SymSrvGetSupplementW #define SymSrvStoreSupplement SymSrvStoreSupplementW #define SymSrvGetFileIndexes SymSrvGetFileIndexes #define SymSrvGetFileIndexString SymSrvGetFileIndexStringW #define SymSrvStoreFile SymSrvStoreFileW #define SymGetSymbolFile SymGetSymbolFileW #define EnumerateLoadedModules64 EnumerateLoadedModulesW64 #define EnumerateLoadedModulesEx EnumerateLoadedModulesExW #define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW #define IMAGEHLP_LINE64 IMAGEHLP_LINEW64 #define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64 #define SYMBOL_INFO SYMBOL_INFOW #define PSYMBOL_INFO PSYMBOL_INFOW #define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW #define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW #define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW #define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW #define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW #define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW #define SRCCODEINFO SRCCODEINFOW #define PSRCCODEINFO PSRCCODEINFOW #define SOURCEFILE SOURCEFILEW #define PSOURCEFILE PSOURCEFILEW #define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW #define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW #define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW #define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW #define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW #define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64 #define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW #define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW #define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64 #define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64 #define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOW #define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW #define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW #define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW #endif // ----------------------------------------------------------------- // The following APIs exist only for backwards compatibility // with a pre-release version documented in an MSDN release. // You should use SymFindFileInPath if you want to maintain // future compatibility. DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInPath( __in HANDLE hprocess, __in PCSTR SearchPath, __in PCSTR FileName, __in PVOID id, __in DWORD two, __in DWORD three, __in DWORD flags, __out_ecount(MAX_PATH + 1) PSTR FilePath ); // You should use SymFindFileInPath if you want to maintain // future compatibility. DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInSearchPath( __in HANDLE hprocess, __in PCSTR SearchPath, __in PCSTR FileName, __in DWORD one, __in DWORD two, __in DWORD three, __out_ecount(MAX_PATH + 1) PSTR FilePath ); DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumSym( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext ); DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumerateSymbols64( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback, __in_opt PVOID UserContext ); DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumerateSymbolsW64( __in HANDLE hProcess, __in ULONG64 BaseOfDll, __in PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback, __in_opt PVOID UserContext ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymEnumerateSymbols SymEnumerateSymbols64 #define SymEnumerateSymbolsW SymEnumerateSymbolsW64 #else DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumerateSymbols( __in HANDLE hProcess, __in ULONG BaseOfDll, __in PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, __in_opt PVOID UserContext ); DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumerateSymbolsW( __in HANDLE hProcess, __in ULONG BaseOfDll, __in PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback, __in_opt PVOID UserContext ); #endif // use SymLoadModuleEx DWORD64 IMAGEAPI SymLoadModule64( __in HANDLE hProcess, __in_opt HANDLE hFile, __in_opt PCSTR ImageName, __in_opt PCSTR ModuleName, __in DWORD64 BaseOfDll, __in DWORD SizeOfDll ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymLoadModule SymLoadModule64 #else DWORD IMAGEAPI SymLoadModule( __in HANDLE hProcess, __in_opt HANDLE hFile, __in_opt PCSTR ImageName, __in_opt PCSTR ModuleName, __in DWORD BaseOfDll, __in DWORD SizeOfDll ); #endif BOOL IMAGEAPI SymGetSymNext64( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOL64 Symbol ); BOOL IMAGEAPI SymGetSymNextW64( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOLW64 Symbol ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetSymNext SymGetSymNext64 #define SymGetSymNextW SymGetSymNextW64 #else BOOL IMAGEAPI SymGetSymNext( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOL Symbol ); BOOL IMAGEAPI SymGetSymNextW( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOLW Symbol ); #endif BOOL IMAGEAPI SymGetSymPrev64( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOL64 Symbol ); BOOL IMAGEAPI SymGetSymPrevW64( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOLW64 Symbol ); #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64) #define SymGetSymPrev SymGetSymPrev64 #define SymGetSymPrevW SymGetSymPrevW64 #else BOOL IMAGEAPI SymGetSymPrev( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOL Symbol ); BOOL IMAGEAPI SymGetSymPrevW( __in HANDLE hProcess, __inout PIMAGEHLP_SYMBOLW Symbol ); #endif // These values should not be used. // They have been replaced by SYMFLAG_ values. #define SYMF_OMAP_GENERATED 0x00000001 #define SYMF_OMAP_MODIFIED 0x00000002 #define SYMF_REGISTER 0x00000008 #define SYMF_REGREL 0x00000010 #define SYMF_FRAMEREL 0x00000020 #define SYMF_PARAMETER 0x00000040 #define SYMF_LOCAL 0x00000080 #define SYMF_CONSTANT 0x00000100 #define SYMF_EXPORT 0x00000200 #define SYMF_FORWARDER 0x00000400 #define SYMF_FUNCTION 0x00000800 #define SYMF_VIRTUAL 0x00001000 #define SYMF_THUNK 0x00002000 #define SYMF_TLSREL 0x00004000 // These values should also not be used. // They have been replaced by SYMFLAG_ values. #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1 #define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER // 0x0008 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL // 0x0010 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL // 0x0020 #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER // 0x0040 #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL // 0x0080 #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT // 0x0100 #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION // 0x0800 #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL // 0x1000 #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK // 0x2000 #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL // 0x4000 #pragma pack(pop) #pragma pack(push,4) #define MINIDUMP_SIGNATURE ('PMDM') #define MINIDUMP_VERSION (42899) typedef DWORD RVA; typedef ULONG64 RVA64; typedef struct _MINIDUMP_LOCATION_DESCRIPTOR { ULONG32 DataSize; RVA Rva; } MINIDUMP_LOCATION_DESCRIPTOR; typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 { ULONG64 DataSize; RVA64 Rva; } MINIDUMP_LOCATION_DESCRIPTOR64; typedef struct _MINIDUMP_MEMORY_DESCRIPTOR { ULONG64 StartOfMemoryRange; MINIDUMP_LOCATION_DESCRIPTOR Memory; } MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR; // DESCRIPTOR64 is used for full-memory minidumps where // all of the raw memory is laid out sequentially at the // end of the dump. There is no need for individual RVAs // as the RVA is the base RVA plus the sum of the preceeding // data blocks. typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 { ULONG64 StartOfMemoryRange; ULONG64 DataSize; } MINIDUMP_MEMORY_DESCRIPTOR64, *PMINIDUMP_MEMORY_DESCRIPTOR64; typedef struct _MINIDUMP_HEADER { ULONG32 Signature; ULONG32 Version; ULONG32 NumberOfStreams; RVA StreamDirectoryRva; ULONG32 CheckSum; union { ULONG32 Reserved; ULONG32 TimeDateStamp; }; ULONG64 Flags; } MINIDUMP_HEADER, *PMINIDUMP_HEADER; // // The MINIDUMP_HEADER field StreamDirectoryRva points to // an array of MINIDUMP_DIRECTORY structures. // typedef struct _MINIDUMP_DIRECTORY { ULONG32 StreamType; MINIDUMP_LOCATION_DESCRIPTOR Location; } MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY; typedef struct _MINIDUMP_STRING { ULONG32 Length; // Length in bytes of the string WCHAR Buffer [0]; // Variable size buffer } MINIDUMP_STRING, *PMINIDUMP_STRING; // // The MINIDUMP_DIRECTORY field StreamType may be one of the following types. // Types will be added in the future, so if a program reading the minidump // header encounters a stream type it does not understand it should ignore // the data altogether. Any tag above LastReservedStream will not be used by // the system and is reserved for program-specific information. // typedef enum _MINIDUMP_STREAM_TYPE { UnusedStream = 0, ReservedStream0 = 1, ReservedStream1 = 2, ThreadListStream = 3, ModuleListStream = 4, MemoryListStream = 5, ExceptionStream = 6, SystemInfoStream = 7, ThreadExListStream = 8, Memory64ListStream = 9, CommentStreamA = 10, CommentStreamW = 11, HandleDataStream = 12, FunctionTableStream = 13, UnloadedModuleListStream = 14, MiscInfoStream = 15, MemoryInfoListStream = 16, ThreadInfoListStream = 17, HandleOperationListStream = 18, TokenStream = 19, ceStreamNull = 0x8000, ceStreamSystemInfo = 0x8001, ceStreamException = 0x8002, ceStreamModuleList = 0x8003, ceStreamProcessList = 0x8004, ceStreamThreadList = 0x8005, ceStreamThreadContextList = 0x8006, ceStreamThreadCallStackList = 0x8007, ceStreamMemoryVirtualList = 0x8008, ceStreamMemoryPhysicalList = 0x8009, ceStreamBucketParameters = 0x800A, ceStreamProcessModuleMap = 0x800B, ceStreamDiagnosisList = 0x800C, LastReservedStream = 0xffff } MINIDUMP_STREAM_TYPE; // // The minidump system information contains processor and // Operating System specific information. // // // CPU information is obtained from one of two places. // // 1) On x86 computers, CPU_INFORMATION is obtained from the CPUID // instruction. You must use the X86 portion of the union for X86 // computers. // // 2) On non-x86 architectures, CPU_INFORMATION is obtained by calling // IsProcessorFeatureSupported(). // typedef union _CPU_INFORMATION { // // X86 platforms use CPUID function to obtain processor information. // struct { // // CPUID Subfunction 0, register EAX (VendorId [0]), // EBX (VendorId [1]) and ECX (VendorId [2]). // ULONG32 VendorId [ 3 ]; // // CPUID Subfunction 1, register EAX // ULONG32 VersionInformation; // // CPUID Subfunction 1, register EDX // ULONG32 FeatureInformation; // // CPUID, Subfunction 80000001, register EBX. This will only // be obtained if the vendor id is "AuthenticAMD". // ULONG32 AMDExtendedCpuFeatures; } X86CpuInfo; // // Non-x86 platforms use processor feature flags. // struct { ULONG64 ProcessorFeatures [ 2 ]; } OtherCpuInfo; } CPU_INFORMATION, *PCPU_INFORMATION; typedef struct _MINIDUMP_SYSTEM_INFO { // // ProcessorArchitecture, ProcessorLevel and ProcessorRevision are all // taken from the SYSTEM_INFO structure obtained by GetSystemInfo( ). // USHORT ProcessorArchitecture; USHORT ProcessorLevel; USHORT ProcessorRevision; union { USHORT Reserved0; struct { UCHAR NumberOfProcessors; UCHAR ProductType; }; }; // // MajorVersion, MinorVersion, BuildNumber, PlatformId and // CSDVersion are all taken from the OSVERSIONINFO structure // returned by GetVersionEx( ). // ULONG32 MajorVersion; ULONG32 MinorVersion; ULONG32 BuildNumber; ULONG32 PlatformId; // // RVA to a CSDVersion string in the string table. // RVA CSDVersionRva; union { ULONG32 Reserved1; struct { USHORT SuiteMask; USHORT Reserved2; }; }; CPU_INFORMATION Cpu; } MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO; // // The minidump thread contains standard thread // information plus an RVA to the memory for this // thread and an RVA to the CONTEXT structure for // this thread. // // // ThreadId must be 4 bytes on all architectures. // C_ASSERT(sizeof(((PPROCESS_INFORMATION)0)->dwThreadId) == 4); typedef struct _MINIDUMP_THREAD { ULONG32 ThreadId; ULONG32 SuspendCount; ULONG32 PriorityClass; ULONG32 Priority; ULONG64 Teb; MINIDUMP_MEMORY_DESCRIPTOR Stack; MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; } MINIDUMP_THREAD, *PMINIDUMP_THREAD; // // The thread list is a container of threads. // typedef struct _MINIDUMP_THREAD_LIST { ULONG32 NumberOfThreads; MINIDUMP_THREAD Threads [0]; } MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST; typedef struct _MINIDUMP_THREAD_EX { ULONG32 ThreadId; ULONG32 SuspendCount; ULONG32 PriorityClass; ULONG32 Priority; ULONG64 Teb; MINIDUMP_MEMORY_DESCRIPTOR Stack; MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; MINIDUMP_MEMORY_DESCRIPTOR BackingStore; } MINIDUMP_THREAD_EX, *PMINIDUMP_THREAD_EX; // // The thread list is a container of threads. // typedef struct _MINIDUMP_THREAD_EX_LIST { ULONG32 NumberOfThreads; MINIDUMP_THREAD_EX Threads [0]; } MINIDUMP_THREAD_EX_LIST, *PMINIDUMP_THREAD_EX_LIST; // // The MINIDUMP_EXCEPTION is the same as EXCEPTION on Win64. // typedef struct _MINIDUMP_EXCEPTION { ULONG32 ExceptionCode; ULONG32 ExceptionFlags; ULONG64 ExceptionRecord; ULONG64 ExceptionAddress; ULONG32 NumberParameters; ULONG32 __unusedAlignment; ULONG64 ExceptionInformation [ EXCEPTION_MAXIMUM_PARAMETERS ]; } MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION; // // The exception information stream contains the id of the thread that caused // the exception (ThreadId), the exception record for the exception // (ExceptionRecord) and an RVA to the thread context where the exception // occured. // typedef struct MINIDUMP_EXCEPTION_STREAM { ULONG32 ThreadId; ULONG32 __alignment; MINIDUMP_EXCEPTION ExceptionRecord; MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; } MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM; // // The MINIDUMP_MODULE contains information about a // a specific module. It includes the CheckSum and // the TimeDateStamp for the module so the module // can be reloaded during the analysis phase. // typedef struct _MINIDUMP_MODULE { ULONG64 BaseOfImage; ULONG32 SizeOfImage; ULONG32 CheckSum; ULONG32 TimeDateStamp; RVA ModuleNameRva; VS_FIXEDFILEINFO VersionInfo; MINIDUMP_LOCATION_DESCRIPTOR CvRecord; MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; ULONG64 Reserved0; // Reserved for future use. ULONG64 Reserved1; // Reserved for future use. } MINIDUMP_MODULE, *PMINIDUMP_MODULE; // // The minidump module list is a container for modules. // typedef struct _MINIDUMP_MODULE_LIST { ULONG32 NumberOfModules; MINIDUMP_MODULE Modules [ 0 ]; } MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST; // // Memory Ranges // typedef struct _MINIDUMP_MEMORY_LIST { ULONG32 NumberOfMemoryRanges; MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0]; } MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST; typedef struct _MINIDUMP_MEMORY64_LIST { ULONG64 NumberOfMemoryRanges; RVA64 BaseRva; MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0]; } MINIDUMP_MEMORY64_LIST, *PMINIDUMP_MEMORY64_LIST; // // Support for user supplied exception information. // typedef struct _MINIDUMP_EXCEPTION_INFORMATION { DWORD ThreadId; PEXCEPTION_POINTERS ExceptionPointers; BOOL ClientPointers; } MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION; typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 { DWORD ThreadId; ULONG64 ExceptionRecord; ULONG64 ContextRecord; BOOL ClientPointers; } MINIDUMP_EXCEPTION_INFORMATION64, *PMINIDUMP_EXCEPTION_INFORMATION64; // // Support for capturing system handle state at the time of the dump. // // Per-handle object information varies according to // the OS, the OS version, the processor type and // so on. The minidump gives a minidump identifier // to each possible data format for identification // purposes but does not control nor describe the actual data. typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE { MiniHandleObjectInformationNone, MiniThreadInformation1, MiniMutantInformation1, MiniMutantInformation2, MiniProcessInformation1, MiniProcessInformation2, MiniHandleObjectInformationTypeMax } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE; typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION { RVA NextInfoRva; ULONG32 InfoType; ULONG32 SizeOfInfo; // Raw information follows. } MINIDUMP_HANDLE_OBJECT_INFORMATION; typedef struct _MINIDUMP_HANDLE_DESCRIPTOR { ULONG64 Handle; RVA TypeNameRva; RVA ObjectNameRva; ULONG32 Attributes; ULONG32 GrantedAccess; ULONG32 HandleCount; ULONG32 PointerCount; } MINIDUMP_HANDLE_DESCRIPTOR, *PMINIDUMP_HANDLE_DESCRIPTOR; typedef struct _MINIDUMP_HANDLE_DESCRIPTOR_2 { ULONG64 Handle; RVA TypeNameRva; RVA ObjectNameRva; ULONG32 Attributes; ULONG32 GrantedAccess; ULONG32 HandleCount; ULONG32 PointerCount; RVA ObjectInfoRva; ULONG32 Reserved0; } MINIDUMP_HANDLE_DESCRIPTOR_2, *PMINIDUMP_HANDLE_DESCRIPTOR_2; // The latest MINIDUMP_HANDLE_DESCRIPTOR definition. typedef MINIDUMP_HANDLE_DESCRIPTOR_2 MINIDUMP_HANDLE_DESCRIPTOR_N; typedef MINIDUMP_HANDLE_DESCRIPTOR_N* PMINIDUMP_HANDLE_DESCRIPTOR_N; typedef struct _MINIDUMP_HANDLE_DATA_STREAM { ULONG32 SizeOfHeader; ULONG32 SizeOfDescriptor; ULONG32 NumberOfDescriptors; ULONG32 Reserved; } MINIDUMP_HANDLE_DATA_STREAM, *PMINIDUMP_HANDLE_DATA_STREAM; // Some operating systems can track the last operations // performed on a handle. For example, Application Verifier // can enable this for some versions of Windows. The // handle operation list collects handle operations // known for the dump target. // Each entry is an AVRF_HANDLE_OPERATION. typedef struct _MINIDUMP_HANDLE_OPERATION_LIST { ULONG32 SizeOfHeader; ULONG32 SizeOfEntry; ULONG32 NumberOfEntries; ULONG32 Reserved; } MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST; // // Support for capturing dynamic function table state at the time of the dump. // typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR { ULONG64 MinimumAddress; ULONG64 MaximumAddress; ULONG64 BaseAddress; ULONG32 EntryCount; ULONG32 SizeOfAlignPad; } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR, *PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR; typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM { ULONG32 SizeOfHeader; ULONG32 SizeOfDescriptor; ULONG32 SizeOfNativeDescriptor; ULONG32 SizeOfFunctionEntry; ULONG32 NumberOfDescriptors; ULONG32 SizeOfAlignPad; } MINIDUMP_FUNCTION_TABLE_STREAM, *PMINIDUMP_FUNCTION_TABLE_STREAM; // // The MINIDUMP_UNLOADED_MODULE contains information about a // a specific module that was previously loaded but no // longer is. This can help with diagnosing problems where // callers attempt to call code that is no longer loaded. // typedef struct _MINIDUMP_UNLOADED_MODULE { ULONG64 BaseOfImage; ULONG32 SizeOfImage; ULONG32 CheckSum; ULONG32 TimeDateStamp; RVA ModuleNameRva; } MINIDUMP_UNLOADED_MODULE, *PMINIDUMP_UNLOADED_MODULE; // // The minidump unloaded module list is a container for unloaded modules. // typedef struct _MINIDUMP_UNLOADED_MODULE_LIST { ULONG32 SizeOfHeader; ULONG32 SizeOfEntry; ULONG32 NumberOfEntries; } MINIDUMP_UNLOADED_MODULE_LIST, *PMINIDUMP_UNLOADED_MODULE_LIST; // // The miscellaneous information stream contains a variety // of small pieces of information. A member is valid if // it's within the available size and its corresponding // bit is set. // #define MINIDUMP_MISC1_PROCESS_ID 0x00000001 #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 #define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004 #define MINIDUMP_MISC3_PROCESS_INTEGRITY 0x00000010 #define MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS 0x00000020 #define MINIDUMP_MISC3_TIMEZONE 0x00000040 #define MINIDUMP_MISC3_PROTECTED_PROCESS 0x00000080 typedef struct _MINIDUMP_MISC_INFO { ULONG32 SizeOfInfo; ULONG32 Flags1; ULONG32 ProcessId; ULONG32 ProcessCreateTime; ULONG32 ProcessUserTime; ULONG32 ProcessKernelTime; } MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO; typedef struct _MINIDUMP_MISC_INFO_2 { ULONG32 SizeOfInfo; ULONG32 Flags1; ULONG32 ProcessId; ULONG32 ProcessCreateTime; ULONG32 ProcessUserTime; ULONG32 ProcessKernelTime; ULONG32 ProcessorMaxMhz; ULONG32 ProcessorCurrentMhz; ULONG32 ProcessorMhzLimit; ULONG32 ProcessorMaxIdleState; ULONG32 ProcessorCurrentIdleState; } MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2; typedef struct _MINIDUMP_MISC_INFO_3 { ULONG32 SizeOfInfo; ULONG32 Flags1; ULONG32 ProcessId; ULONG32 ProcessCreateTime; ULONG32 ProcessUserTime; ULONG32 ProcessKernelTime; ULONG32 ProcessorMaxMhz; ULONG32 ProcessorCurrentMhz; ULONG32 ProcessorMhzLimit; ULONG32 ProcessorMaxIdleState; ULONG32 ProcessorCurrentIdleState; ULONG32 ProcessIntegrityLevel; ULONG32 ProcessExecuteFlags; ULONG32 ProtectedProcess; ULONG32 TimeZoneId; TIME_ZONE_INFORMATION TimeZone; } MINIDUMP_MISC_INFO_3, *PMINIDUMP_MISC_INFO_3; // The latest MINIDUMP_MISC_INFO definition. typedef MINIDUMP_MISC_INFO_3 MINIDUMP_MISC_INFO_N; typedef MINIDUMP_MISC_INFO_N* PMINIDUMP_MISC_INFO_N; // // The memory information stream contains memory region // description information. This stream corresponds to // what VirtualQuery would return for the process the // dump was created for. // typedef struct _MINIDUMP_MEMORY_INFO { ULONG64 BaseAddress; ULONG64 AllocationBase; ULONG32 AllocationProtect; ULONG32 __alignment1; ULONG64 RegionSize; ULONG32 State; ULONG32 Protect; ULONG32 Type; ULONG32 __alignment2; } MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO; typedef struct _MINIDUMP_MEMORY_INFO_LIST { ULONG SizeOfHeader; ULONG SizeOfEntry; ULONG64 NumberOfEntries; } MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST; // // The memory information stream contains memory region // description information. This stream corresponds to // what VirtualQuery would return for the process the // dump was created for. // // Thread dump writer status flags. #define MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001 #define MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002 #define MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004 #define MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008 #define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010 #define MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020 typedef struct _MINIDUMP_THREAD_INFO { ULONG32 ThreadId; ULONG32 DumpFlags; ULONG32 DumpError; ULONG32 ExitStatus; ULONG64 CreateTime; ULONG64 ExitTime; ULONG64 KernelTime; ULONG64 UserTime; ULONG64 StartAddress; ULONG64 Affinity; } MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO; typedef struct _MINIDUMP_THREAD_INFO_LIST { ULONG SizeOfHeader; ULONG SizeOfEntry; ULONG NumberOfEntries; } MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST; // // Support for token information. // typedef struct _MINIDUMP_TOKEN_INFO_HEADER { ULONG TokenSize; // The size of the token structure. ULONG TokenId; // The PID in NtOpenProcessToken() call or TID in NtOpenThreadToken() call. ULONG64 TokenHandle; // The handle value returned. } MINIDUMP_TOKEN_INFO_HEADER, *PMINIDUMP_TOKEN_INFO_HEADER; typedef struct _MINIDUMP_TOKEN_INFO_LIST { ULONG TokenListSize; ULONG TokenListEntries; ULONG ListHeaderSize; ULONG ElementHeaderSize; } MINIDUMP_TOKEN_INFO_LIST, *PMINIDUMP_TOKEN_INFO_LIST; // // Support for arbitrary user-defined information. // typedef struct _MINIDUMP_USER_RECORD { ULONG32 Type; MINIDUMP_LOCATION_DESCRIPTOR Memory; } MINIDUMP_USER_RECORD, *PMINIDUMP_USER_RECORD; typedef struct _MINIDUMP_USER_STREAM { ULONG32 Type; ULONG BufferSize; PVOID Buffer; } MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM; typedef struct _MINIDUMP_USER_STREAM_INFORMATION { ULONG UserStreamCount; PMINIDUMP_USER_STREAM UserStreamArray; } MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION; // // Callback support. // typedef enum _MINIDUMP_CALLBACK_TYPE { ModuleCallback, ThreadCallback, ThreadExCallback, IncludeThreadCallback, IncludeModuleCallback, MemoryCallback, CancelCallback, WriteKernelMinidumpCallback, KernelMinidumpStatusCallback, RemoveMemoryCallback, IncludeVmRegionCallback, IoStartCallback, IoWriteAllCallback, IoFinishCallback, ReadMemoryFailureCallback, SecondaryFlagsCallback, } MINIDUMP_CALLBACK_TYPE; typedef struct _MINIDUMP_THREAD_CALLBACK { ULONG ThreadId; HANDLE ThreadHandle; CONTEXT Context; ULONG SizeOfContext; ULONG64 StackBase; ULONG64 StackEnd; } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK; typedef struct _MINIDUMP_THREAD_EX_CALLBACK { ULONG ThreadId; HANDLE ThreadHandle; CONTEXT Context; ULONG SizeOfContext; ULONG64 StackBase; ULONG64 StackEnd; ULONG64 BackingStoreBase; ULONG64 BackingStoreEnd; } MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK; typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK { ULONG ThreadId; } MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK; typedef enum _THREAD_WRITE_FLAGS { ThreadWriteThread = 0x0001, ThreadWriteStack = 0x0002, ThreadWriteContext = 0x0004, ThreadWriteBackingStore = 0x0008, ThreadWriteInstructionWindow = 0x0010, ThreadWriteThreadData = 0x0020, ThreadWriteThreadInfo = 0x0040, } THREAD_WRITE_FLAGS; typedef struct _MINIDUMP_MODULE_CALLBACK { PWCHAR FullPath; ULONG64 BaseOfImage; ULONG SizeOfImage; ULONG CheckSum; ULONG TimeDateStamp; VS_FIXEDFILEINFO VersionInfo; PVOID CvRecord; ULONG SizeOfCvRecord; PVOID MiscRecord; ULONG SizeOfMiscRecord; } MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK; typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK { ULONG64 BaseOfImage; } MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK; typedef enum _MODULE_WRITE_FLAGS { ModuleWriteModule = 0x0001, ModuleWriteDataSeg = 0x0002, ModuleWriteMiscRecord = 0x0004, ModuleWriteCvRecord = 0x0008, ModuleReferencedByMemory = 0x0010, ModuleWriteTlsData = 0x0020, ModuleWriteCodeSegs = 0x0040, } MODULE_WRITE_FLAGS; typedef struct _MINIDUMP_IO_CALLBACK { HANDLE Handle; ULONG64 Offset; PVOID Buffer; ULONG BufferBytes; } MINIDUMP_IO_CALLBACK, *PMINIDUMP_IO_CALLBACK; typedef struct _MINIDUMP_READ_MEMORY_FAILURE_CALLBACK { ULONG64 Offset; ULONG Bytes; HRESULT FailureStatus; } MINIDUMP_READ_MEMORY_FAILURE_CALLBACK, *PMINIDUMP_READ_MEMORY_FAILURE_CALLBACK; typedef struct _MINIDUMP_CALLBACK_INPUT { ULONG ProcessId; HANDLE ProcessHandle; ULONG CallbackType; union { HRESULT Status; MINIDUMP_THREAD_CALLBACK Thread; MINIDUMP_THREAD_EX_CALLBACK ThreadEx; MINIDUMP_MODULE_CALLBACK Module; MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; MINIDUMP_IO_CALLBACK Io; MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure; ULONG SecondaryFlags; }; } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT; typedef struct _MINIDUMP_CALLBACK_OUTPUT { union { ULONG ModuleWriteFlags; ULONG ThreadWriteFlags; ULONG SecondaryFlags; struct { ULONG64 MemoryBase; ULONG MemorySize; }; struct { BOOL CheckCancel; BOOL Cancel; }; HANDLE Handle; struct { MINIDUMP_MEMORY_INFO VmRegion; BOOL Continue; }; HRESULT Status; }; } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; // // A normal minidump contains just the information // necessary to capture stack traces for all of the // existing threads in a process. // // A minidump with data segments includes all of the data // sections from loaded modules in order to capture // global variable contents. This can make the dump much // larger if many modules have global data. // // A minidump with full memory includes all of the accessible // memory in the process and can be very large. A minidump // with full memory always has the raw memory data at the end // of the dump so that the initial structures in the dump can // be mapped directly without having to include the raw // memory information. // // Stack and backing store memory can be filtered to remove // data unnecessary for stack walking. This can improve // compression of stacks and also deletes data that may // be private and should not be stored in a dump. // Memory can also be scanned to see what modules are // referenced by stack and backing store memory to allow // omission of other modules to reduce dump size. // In either of these modes the ModuleReferencedByMemory flag // is set for all modules referenced before the base // module callbacks occur. // // On some operating systems a list of modules that were // recently unloaded is kept in addition to the currently // loaded module list. This information can be saved in // the dump if desired. // // Stack and backing store memory can be scanned for referenced // pages in order to pick up data referenced by locals or other // stack memory. This can increase the size of a dump significantly. // // Module paths may contain undesired information such as user names // or other important directory names so they can be stripped. This // option reduces the ability to locate the proper image later // and should only be used in certain situations. // // Complete operating system per-process and per-thread information can // be gathered and stored in the dump. // // The virtual address space can be scanned for various types // of memory to be included in the dump. // // Code which is concerned with potentially private information // getting into the minidump can set a flag that automatically // modifies all existing and future flags to avoid placing // unnecessary data in the dump. Basic data, such as stack // information, will still be included but optional data, such // as indirect memory, will not. // // When doing a full memory dump it's possible to store all // of the enumerated memory region descriptive information // in a memory information stream. // // Additional thread information beyond the basic thread // structure can be collected if desired. // // A minidump with code segments includes all of the code // and code-related sections from loaded modules in order // to capture executable content. // // MiniDumpWithoutAuxiliaryState turns off any secondary, // auxiliary-supported memory gathering. // // MiniDumpWithFullAuxiliaryState asks any present auxiliary // data providers to include all of their state in the dump. // The exact set of what is provided depends on the auxiliary. // This can be quite large. // typedef enum _MINIDUMP_TYPE { MiniDumpNormal = 0x00000000, MiniDumpWithDataSegs = 0x00000001, MiniDumpWithFullMemory = 0x00000002, MiniDumpWithHandleData = 0x00000004, MiniDumpFilterMemory = 0x00000008, MiniDumpScanMemory = 0x00000010, MiniDumpWithUnloadedModules = 0x00000020, MiniDumpWithIndirectlyReferencedMemory = 0x00000040, MiniDumpFilterModulePaths = 0x00000080, MiniDumpWithProcessThreadData = 0x00000100, MiniDumpWithPrivateReadWriteMemory = 0x00000200, MiniDumpWithoutOptionalData = 0x00000400, MiniDumpWithFullMemoryInfo = 0x00000800, MiniDumpWithThreadInfo = 0x00001000, MiniDumpWithCodeSegs = 0x00002000, MiniDumpWithoutAuxiliaryState = 0x00004000, MiniDumpWithFullAuxiliaryState = 0x00008000, MiniDumpWithPrivateWriteCopyMemory = 0x00010000, MiniDumpIgnoreInaccessibleMemory = 0x00020000, MiniDumpWithTokenInformation = 0x00040000, MiniDumpValidTypeFlags = 0x0007ffff, } MINIDUMP_TYPE; // // In addition to the primary flags provided to // MiniDumpWriteDump there are additional, less // frequently used options queried via the secondary // flags callback. // // MiniSecondaryWithoutPowerInfo suppresses the minidump // query that retrieves processor power information for // MINIDUMP_MISC_INFO. // typedef enum _MINIDUMP_SECONDARY_FLAGS { MiniSecondaryWithoutPowerInfo = 0x00000001, MiniSecondaryValidFlags = 0x00000001, } MINIDUMP_SECONDARY_FLAGS; // // The minidump callback should modify the FieldsToWrite parameter to reflect // what portions of the specified thread or module should be written to the // file. // typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)( __inout PVOID CallbackParam, __in PMINIDUMP_CALLBACK_INPUT CallbackInput, __inout PMINIDUMP_CALLBACK_OUTPUT CallbackOutput ); typedef struct _MINIDUMP_CALLBACK_INFORMATION { MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; PVOID CallbackParam; } MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION; //++ // // PVOID // RVA_TO_ADDR( // PVOID Mapping, // ULONG Rva // ) // // Routine Description: // // Map an RVA that is contained within a mapped file to it's associated // flat address. // // Arguments: // // Mapping - Base address of mapped file containing the RVA. // // Rva - An Rva to fixup. // // Return Values: // // A pointer to the desired data. // //-- #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva))) BOOL WINAPI MiniDumpWriteDump( __in HANDLE hProcess, __in DWORD ProcessId, __in HANDLE hFile, __in MINIDUMP_TYPE DumpType, __in_opt PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, __in_opt PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, __in_opt PMINIDUMP_CALLBACK_INFORMATION CallbackParam ); BOOL WINAPI MiniDumpReadDumpStream( __in PVOID BaseOfDump, __in ULONG StreamNumber, __deref_out_opt PMINIDUMP_DIRECTORY* Dir, __deref_out_opt PVOID* StreamPointer, __out_opt ULONG* StreamSize ); #pragma pack(pop) #ifdef __cplusplus } #endif #endif // _DBGHELP_
C/C++
x64dbg-development/src/dbg/DeviceNameResolver/DeviceNameResolver.h
#ifndef _DEVICENAMERESOLVER_H #define _DEVICENAMERESOLVER_H #include <windows.h> #ifdef __cplusplus extern "C" { #endif __declspec(dllexport) bool DevicePathToPathW(const wchar_t* szDevicePath, wchar_t* szPath, size_t nSizeInChars); __declspec(dllexport) bool DevicePathToPathA(const char* szDevicePath, char* szPath, size_t nSizeInChars); __declspec(dllexport) bool DevicePathFromFileHandleW(HANDLE hFile, wchar_t* szDevicePath, size_t nSizeInChars); __declspec(dllexport) bool DevicePathFromFileHandleA(HANDLE hFile, char* szDevicePath, size_t nSizeInChars); __declspec(dllexport) bool PathFromFileHandleW(HANDLE hFile, wchar_t* szPath, size_t nSizeInChars); __declspec(dllexport) bool PathFromFileHandleA(HANDLE hFile, char* szPath, size_t nSizeInChars); #ifdef __cplusplus } #endif #endif // _DEVICENAMERESOLVER_H
C/C++
x64dbg-development/src/dbg/jansson/jansson.h
/* * Copyright (c) 2009-2016 Petri Lehtinen <[email protected]> * * Jansson is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See LICENSE for details. */ #ifndef JANSSON_H #define JANSSON_H #include <stdio.h> #include <stdlib.h> /* for size_t */ #include <stdarg.h> #include "jansson_config.h" #ifdef __cplusplus extern "C" { #endif /* version */ #define JANSSON_MAJOR_VERSION 2 #define JANSSON_MINOR_VERSION 9 #define JANSSON_MICRO_VERSION 0 /* Micro version is omitted if it's 0 */ #define JANSSON_VERSION "2.9" /* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */ #define JANSSON_VERSION_HEX ((JANSSON_MAJOR_VERSION << 16) | \ (JANSSON_MINOR_VERSION << 8) | \ (JANSSON_MICRO_VERSION << 0)) /* types */ typedef enum { JSON_OBJECT, JSON_ARRAY, JSON_STRING, JSON_INTEGER, JSON_REAL, JSON_TRUE, JSON_FALSE, JSON_NULL } json_type; typedef struct json_t { json_type type; size_t refcount; } json_t; #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */ #if JSON_INTEGER_IS_LONG_LONG #ifdef _WIN32 #define JSON_INTEGER_FORMAT "I64d" #else #define JSON_INTEGER_FORMAT "lld" #endif typedef long long json_int_t; #else #define JSON_INTEGER_FORMAT "ld" typedef long json_int_t; #endif /* JSON_INTEGER_IS_LONG_LONG */ #endif #define json_typeof(json) ((json)->type) #define json_is_object(json) ((json) && json_typeof(json) == JSON_OBJECT) #define json_is_array(json) ((json) && json_typeof(json) == JSON_ARRAY) #define json_is_string(json) ((json) && json_typeof(json) == JSON_STRING) #define json_is_integer(json) ((json) && json_typeof(json) == JSON_INTEGER) #define json_is_real(json) ((json) && json_typeof(json) == JSON_REAL) #define json_is_number(json) (json_is_integer(json) || json_is_real(json)) #define json_is_true(json) ((json) && json_typeof(json) == JSON_TRUE) #define json_is_false(json) ((json) && json_typeof(json) == JSON_FALSE) #define json_boolean_value json_is_true #define json_is_boolean(json) (json_is_true(json) || json_is_false(json)) #define json_is_null(json) ((json) && json_typeof(json) == JSON_NULL) /* construction, destruction, reference counting */ __declspec(dllimport) json_t* json_object(void); __declspec(dllimport) json_t* json_array(void); __declspec(dllimport) json_t* json_string(const char* value); __declspec(dllimport) json_t* json_stringn(const char* value, size_t len); __declspec(dllimport) json_t* json_string_nocheck(const char* value); __declspec(dllimport) json_t* json_stringn_nocheck(const char* value, size_t len); __declspec(dllimport) json_t* json_integer(json_int_t value); __declspec(dllimport) json_t* json_real(double value); __declspec(dllimport) json_t* json_true(void); __declspec(dllimport) json_t* json_false(void); #define json_boolean(val) ((val) ? json_true() : json_false()) __declspec(dllimport) json_t* json_null(void); static JSON_INLINE json_t* json_incref(json_t* json) { if(json && json->refcount != (size_t) - 1) ++json->refcount; return json; } /* do not call json_delete directly */ __declspec(dllimport) void json_delete(json_t* json); static JSON_INLINE void json_decref(json_t* json) { if(json && json->refcount != (size_t) - 1 && --json->refcount == 0) json_delete(json); } #if defined(__GNUC__) || defined(__clang__) static JSON_INLINE void json_decrefp(json_t** json) { if(json) { json_decref(*json); *json = NULL; } } #define json_auto_t json_t __attribute__((cleanup(json_decrefp))) #endif /* error reporting */ #define JSON_ERROR_TEXT_LENGTH 160 #define JSON_ERROR_SOURCE_LENGTH 80 typedef struct { int line; int column; int position; char source[JSON_ERROR_SOURCE_LENGTH]; char text[JSON_ERROR_TEXT_LENGTH]; } json_error_t; /* getters, setters, manipulation */ __declspec(dllimport) void json_object_seed(size_t seed); __declspec(dllimport) size_t json_object_size(const json_t* object); __declspec(dllimport) json_t* json_object_get(const json_t* object, const char* key); __declspec(dllimport) int json_object_set_new(json_t* object, const char* key, json_t* value); __declspec(dllimport) int json_object_set_new_nocheck(json_t* object, const char* key, json_t* value); __declspec(dllimport) int json_object_del(json_t* object, const char* key); __declspec(dllimport) int json_object_clear(json_t* object); __declspec(dllimport) int json_object_update(json_t* object, json_t* other); __declspec(dllimport) int json_object_update_existing(json_t* object, json_t* other); __declspec(dllimport) int json_object_update_missing(json_t* object, json_t* other); __declspec(dllimport) void* json_object_iter(json_t* object); __declspec(dllimport) void* json_object_iter_at(json_t* object, const char* key); __declspec(dllimport) void* json_object_key_to_iter(const char* key); __declspec(dllimport) void* json_object_iter_next(json_t* object, void* iter); __declspec(dllimport) const char* json_object_iter_key(void* iter); __declspec(dllimport) json_t* json_object_iter_value(void* iter); __declspec(dllimport) int json_object_iter_set_new(json_t* object, void* iter, json_t* value); #define json_object_foreach(object, key, value) \ for(key = json_object_iter_key(json_object_iter(object)); \ key && (value = json_object_iter_value(json_object_key_to_iter(key))); \ key = json_object_iter_key(json_object_iter_next(object, json_object_key_to_iter(key)))) #define json_object_foreach_safe(object, n, key, value) \ for(key = json_object_iter_key(json_object_iter(object)), \ n = json_object_iter_next(object, json_object_key_to_iter(key)); \ key && (value = json_object_iter_value(json_object_key_to_iter(key))); \ key = json_object_iter_key(n), \ n = json_object_iter_next(object, json_object_key_to_iter(key))) #define json_array_foreach(array, index, value) \ for(index = 0; \ index < json_array_size(array) && (value = json_array_get(array, index)); \ index++) static JSON_INLINE int json_object_set(json_t* object, const char* key, json_t* value) { return json_object_set_new(object, key, json_incref(value)); } static JSON_INLINE int json_object_set_nocheck(json_t* object, const char* key, json_t* value) { return json_object_set_new_nocheck(object, key, json_incref(value)); } static JSON_INLINE int json_object_iter_set(json_t* object, void* iter, json_t* value) { return json_object_iter_set_new(object, iter, json_incref(value)); } __declspec(dllimport) size_t json_array_size(const json_t* array); __declspec(dllimport) json_t* json_array_get(const json_t* array, size_t index); __declspec(dllimport) int json_array_set_new(json_t* array, size_t index, json_t* value); __declspec(dllimport) int json_array_append_new(json_t* array, json_t* value); __declspec(dllimport) int json_array_insert_new(json_t* array, size_t index, json_t* value); __declspec(dllimport) int json_array_remove(json_t* array, size_t index); __declspec(dllimport) int json_array_clear(json_t* array); __declspec(dllimport) int json_array_extend(json_t* array, json_t* other); static JSON_INLINE int json_array_set(json_t* array, size_t ind, json_t* value) { return json_array_set_new(array, ind, json_incref(value)); } static JSON_INLINE int json_array_append(json_t* array, json_t* value) { return json_array_append_new(array, json_incref(value)); } static JSON_INLINE int json_array_insert(json_t* array, size_t ind, json_t* value) { return json_array_insert_new(array, ind, json_incref(value)); } __declspec(dllimport) const char* json_string_value(const json_t* string); __declspec(dllimport) size_t json_string_length(const json_t* string); __declspec(dllimport) json_int_t json_integer_value(const json_t* integer); __declspec(dllimport) double json_real_value(const json_t* real); __declspec(dllimport) double json_number_value(const json_t* json); __declspec(dllimport) int json_string_set(json_t* string, const char* value); __declspec(dllimport) int json_string_setn(json_t* string, const char* value, size_t len); __declspec(dllimport) int json_string_set_nocheck(json_t* string, const char* value); __declspec(dllimport) int json_string_setn_nocheck(json_t* string, const char* value, size_t len); __declspec(dllimport) int json_integer_set(json_t* integer, json_int_t value); __declspec(dllimport) int json_real_set(json_t* real, double value); /* pack, unpack */ __declspec(dllimport) json_t* json_pack(const char* fmt, ...); __declspec(dllimport) json_t* json_pack_ex(json_error_t* error, size_t flags, const char* fmt, ...); __declspec(dllimport) json_t* json_vpack_ex(json_error_t* error, size_t flags, const char* fmt, va_list ap); #define JSON_VALIDATE_ONLY 0x1 #define JSON_STRICT 0x2 __declspec(dllimport) int json_unpack(json_t* root, const char* fmt, ...); __declspec(dllimport) int json_unpack_ex(json_t* root, json_error_t* error, size_t flags, const char* fmt, ...); __declspec(dllimport) int json_vunpack_ex(json_t* root, json_error_t* error, size_t flags, const char* fmt, va_list ap); /* equality */ __declspec(dllimport) int json_equal(json_t* value1, json_t* value2); /* copying */ __declspec(dllimport) json_t* json_copy(json_t* value); __declspec(dllimport) json_t* json_deep_copy(const json_t* value); /* decoding */ #define JSON_REJECT_DUPLICATES 0x1 #define JSON_DISABLE_EOF_CHECK 0x2 #define JSON_DECODE_ANY 0x4 #define JSON_DECODE_INT_AS_REAL 0x8 #define JSON_ALLOW_NUL 0x10 typedef size_t (*json_load_callback_t)(void* buffer, size_t buflen, void* data); __declspec(dllimport) json_t* json_loads(const char* input, size_t flags, json_error_t* error); __declspec(dllimport) json_t* json_loadb(const char* buffer, size_t buflen, size_t flags, json_error_t* error); __declspec(dllimport) json_t* json_loadf(FILE* input, size_t flags, json_error_t* error); __declspec(dllimport) json_t* json_load_file(const char* path, size_t flags, json_error_t* error); __declspec(dllimport) json_t* json_load_callback(json_load_callback_t callback, void* data, size_t flags, json_error_t* error); /* encoding */ #define JSON_MAX_INDENT 0x1F #define JSON_INDENT(n) ((n) & JSON_MAX_INDENT) #define JSON_COMPACT 0x20 #define JSON_ENSURE_ASCII 0x40 #define JSON_SORT_KEYS 0x80 #define JSON_PRESERVE_ORDER 0x100 #define JSON_ENCODE_ANY 0x200 #define JSON_ESCAPE_SLASH 0x400 #define JSON_REAL_PRECISION(n) (((n) & 0x1F) << 11) typedef int (*json_dump_callback_t)(const char* buffer, size_t size, void* data); __declspec(dllimport) char* json_dumps(const json_t* json, size_t flags); __declspec(dllimport) int json_dumpf(const json_t* json, FILE* output, size_t flags); __declspec(dllimport) int json_dump_file(const json_t* json, const char* path, size_t flags); __declspec(dllimport) int json_dump_callback(const json_t* json, json_dump_callback_t callback, void* data, size_t flags); /* custom memory allocation */ typedef void* (*json_malloc_t)(size_t); typedef void (*json_free_t)(void*); __declspec(dllimport) void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn); __declspec(dllimport) void json_get_alloc_funcs(json_malloc_t* malloc_fn, json_free_t* free_fn); #ifdef __cplusplus } #endif #endif
C/C++
x64dbg-development/src/dbg/jansson/jansson_config.h
/* * Copyright (c) 2010-2016 Petri Lehtinen <[email protected]> * * Jansson is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See LICENSE for details. * * * This file specifies a part of the site-specific configuration for * Jansson, namely those things that affect the public API in * jansson.h. * * The CMake system will generate the jansson_config.h file and * copy it to the build and install directories. */ #ifndef JANSSON_CONFIG_H #define JANSSON_CONFIG_H /* Define this so that we can disable scattered automake configuration in source files */ #ifndef JANSSON_USING_CMAKE #define JANSSON_USING_CMAKE #endif /* Note: when using cmake, JSON_INTEGER_IS_LONG_LONG is not defined nor used, * as we will also check for __int64 etc types. * (the definition was used in the automake system) */ /* Bring in the cmake-detected defines */ #define HAVE_STDINT_H 1 /* #undef HAVE_INTTYPES_H */ /* #undef HAVE_SYS_TYPES_H */ /* Include our standard type header for the integer typedef */ #if defined(HAVE_STDINT_H) # include <stdint.h> #elif defined(HAVE_INTTYPES_H) # include <inttypes.h> #elif defined(HAVE_SYS_TYPES_H) # include <sys/types.h> #endif /* If your compiler supports the inline keyword in C, JSON_INLINE is defined to `inline', otherwise empty. In C++, the inline is always supported. */ #ifdef __cplusplus #define JSON_INLINE inline #else #define JSON_INLINE __inline #endif #define json_int_t long long #define json_strtoint strtoll #define JSON_INTEGER_FORMAT "I64d" /* If locale.h and localeconv() are available, define to 1, otherwise to 0. */ #define JSON_HAVE_LOCALECONV 1 /* Maximum recursion depth for parsing JSON input. This limits the depth of e.g. array-within-array constructions. */ #define JSON_PARSER_MAX_DEPTH 2048 #endif
C/C++
x64dbg-development/src/dbg/jansson/jansson_x64dbg.h
#pragma once #include "jansson.h" typedef json_t* JSON; static JSON_INLINE json_t* json_hex(unsigned json_int_t value) { char hexvalue[20]; sprintf_s(hexvalue, "0x%llX", value); return json_string(hexvalue); } static JSON_INLINE unsigned json_int_t json_hex_value(const json_t* hex) { unsigned json_int_t ret = 0; const char* hexvalue; hexvalue = json_string_value(hex); if(!hexvalue) return 0; sscanf_s(hexvalue, "0x%llX", &ret); return ret; }
x64dbg-development/src/dbg/jansson/jansson_x86.lib
!<arch> / 1403015379 0 3412 ` ‰2\’% % &N&N%æ%æ%z%z0–0–*z*z)ª)ª**)>)>(Î(Î5Ô5Ô;ä;ä4(4(3À3À<P<P;x;x;;+º+º1ð1ð--,”,”,$,$-p-p-Þ-Þ.Â.Â.P.P/¬/¬/6/60 0 &¶&¶ää$ $ #^#^!ž!ž!.!.7 7 :4:49Ê9Ê9Z9Z6°6°8ä8ä8v8v'†'†(^(^'ð'ð4’4’5f5f4ú4ú+J+J:¦:¦''*â*â1v1v11$4$4"î"î L L" " "~"~ À À6F6F887’7’2^2^2Î2Î3H3H#Ì#Ì__IMPORT_DESCRIPTOR_jansson__NULL_IMPORT_DESCRIPTORjansson_NULL_THUNK_DATA__imp__json_dump_callback_json_dump_callback__imp__json_dumps_json_dumps__imp__json_dumpf_json_dumpf__imp__json_dump_file_json_dump_file__imp__json_object_seed_json_object_seed__imp__json_loads_json_loads__imp__json_loadb_json_loadb__imp__json_loadf_json_loadf__imp__json_load_file_json_load_file__imp__json_load_callback_json_load_callback__imp__json_set_alloc_funcs_json_set_alloc_funcs__imp__json_vpack_ex_json_vpack_ex__imp__json_pack_ex_json_pack_ex__imp__json_pack_json_pack__imp__json_vunpack_ex_json_vunpack_ex__imp__json_unpack_ex_json_unpack_ex__imp__json_unpack_json_unpack__imp__json_object_json_object__imp__json_object_size_json_object_size__imp__json_object_get_json_object_get__imp__json_object_del_json_object_del__imp__json_object_clear_json_object_clear__imp__json_object_iter_json_object_iter__imp__json_object_iter_at_json_object_iter_at__imp__json_object_iter_next_json_object_iter_next__imp__json_object_iter_key_json_object_iter_key__imp__json_object_iter_value_json_object_iter_value__imp__json_object_iter_set_new_json_object_iter_set_new__imp__json_object_key_to_iter_json_object_key_to_iter__imp__json_equal_json_equal__imp__json_array_json_array__imp__json_delete_json_delete__imp__json_array_size_json_array_size__imp__json_array_get_json_array_get__imp__json_array_extend_json_array_extend__imp__json_string_nocheck_json_string_nocheck__imp__json_stringn_nocheck_json_stringn_nocheck__imp__json_stringn_json_stringn__imp__json_string_value_json_string_value__imp__json_string_length_json_string_length__imp__json_string_setn_nocheck_json_string_setn_nocheck__imp__json_string_setn_json_string_setn__imp__json_integer_json_integer__imp__json_integer_value_json_integer_value__imp__json_integer_set_json_integer_set__imp__json_real_json_real__imp__json_real_value_json_real_value__imp__json_real_set_json_real_set__imp__json_number_value_json_number_value__imp__json_true_json_true__imp__json_false_json_false__imp__json_null_json_null__imp__json_object_set_new_nocheck_json_object_set_new_nocheck__imp__json_object_set_new_json_object_set_new__imp__json_deep_copy_json_deep_copy__imp__json_array_set_new_json_array_set_new__imp__json_array_append_new_json_array_append_new__imp__json_array_insert_new_json_array_insert_new__imp__json_array_remove_json_array_remove__imp__json_array_clear_json_array_clear__imp__json_string_json_string__imp__json_string_set_nocheck_json_string_set_nocheck__imp__json_string_set_json_string_set__imp__json_object_update_json_object_update__imp__json_object_update_existing_json_object_update_existing__imp__json_object_update_missing_json_object_update_missing__imp__json_copy_json_copy/ 1403015379 0 3422 ` F2\’ %N&æ%z%–0z*ª)*>)Î(Ô5ä;(4À3P<x;;º+ð1-”,$,p-Þ-Â.P.¬/6/ 0¶&ä $^#ž!.! 74:Ê9Z9°6ä8v8†'^(ð'’4f5ú4J+¦:'â*v114$î"L "~"À F68’7^2Î2H3Ì#‰"<?&%=>;$F:#!6.0/ 74 98CDE132@+'BA-,*)(5"<?&%=>;$F:#!6.0/ 74 98CDE132@+'BA-,*)(5__IMPORT_DESCRIPTOR_jansson__NULL_IMPORT_DESCRIPTOR__imp__json_array__imp__json_array_append_new__imp__json_array_clear__imp__json_array_extend__imp__json_array_get__imp__json_array_insert_new__imp__json_array_remove__imp__json_array_set_new__imp__json_array_size__imp__json_copy__imp__json_deep_copy__imp__json_delete__imp__json_dump_callback__imp__json_dump_file__imp__json_dumpf__imp__json_dumps__imp__json_equal__imp__json_false__imp__json_integer__imp__json_integer_set__imp__json_integer_value__imp__json_load_callback__imp__json_load_file__imp__json_loadb__imp__json_loadf__imp__json_loads__imp__json_null__imp__json_number_value__imp__json_object__imp__json_object_clear__imp__json_object_del__imp__json_object_get__imp__json_object_iter__imp__json_object_iter_at__imp__json_object_iter_key__imp__json_object_iter_next__imp__json_object_iter_set_new__imp__json_object_iter_value__imp__json_object_key_to_iter__imp__json_object_seed__imp__json_object_set_new__imp__json_object_set_new_nocheck__imp__json_object_size__imp__json_object_update__imp__json_object_update_existing__imp__json_object_update_missing__imp__json_pack__imp__json_pack_ex__imp__json_real__imp__json_real_set__imp__json_real_value__imp__json_set_alloc_funcs__imp__json_string__imp__json_string_length__imp__json_string_nocheck__imp__json_string_set__imp__json_string_set_nocheck__imp__json_string_setn__imp__json_string_setn_nocheck__imp__json_string_value__imp__json_stringn__imp__json_stringn_nocheck__imp__json_true__imp__json_unpack__imp__json_unpack_ex__imp__json_vpack_ex__imp__json_vunpack_ex_json_array_json_array_append_new_json_array_clear_json_array_extend_json_array_get_json_array_insert_new_json_array_remove_json_array_set_new_json_array_size_json_copy_json_deep_copy_json_delete_json_dump_callback_json_dump_file_json_dumpf_json_dumps_json_equal_json_false_json_integer_json_integer_set_json_integer_value_json_load_callback_json_load_file_json_loadb_json_loadf_json_loads_json_null_json_number_value_json_object_json_object_clear_json_object_del_json_object_get_json_object_iter_json_object_iter_at_json_object_iter_key_json_object_iter_next_json_object_iter_set_new_json_object_iter_value_json_object_key_to_iter_json_object_seed_json_object_set_new_json_object_set_new_nocheck_json_object_size_json_object_update_json_object_update_existing_json_object_update_missing_json_pack_json_pack_ex_json_real_json_real_set_json_real_value_json_set_alloc_funcs_json_string_json_string_length_json_string_nocheck_json_string_set_json_string_set_nocheck_json_string_setn_json_string_setn_nocheck_json_string_value_json_stringn_json_stringn_nocheck_json_true_json_unpack_json_unpack_ex_json_vpack_ex_json_vunpack_exjansson_NULL_THUNK_DATAjansson.dll/ 1403015379 0 493 ` LÓP S .debug$SAŒ@B.idata$2Íá@0À.idata$6 ÿá@ À jansson.dll' ovMicrosoft (R) LINK jansson.dll@comp.idovœÿÿ.idata$2@Àh.idata$6.idata$4@Àh.idata$5@Àh 9R__IMPORT_DESCRIPTOR_jansson__NULL_IMPORT_DESCRIPTORjansson_NULL_THUNK_DATA jansson.dll/ 1403015379 0 250 ` LÓP S¹.debug$SAd@B.idata$3¥@0À jansson.dll' ovMicrosoft (R) LINK@comp.idovœÿÿ__NULL_IMPORT_DESCRIPTORjansson.dll/ 1403015379 0 278 ` LÓP SÕ.debug$SAŒ@B.idata$5Í@0À.idata$4Ñ@0À jansson.dll' ovMicrosoft (R) LINK@comp.idovœÿÿjansson_NULL_THUNK_DATAjansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_arrayjansson.dlljansson.dll/ 1403015379 0 55 ` ÿÿLÓP S#_json_array_append_newjansson.dll jansson.dll/ 1403015379 0 50 ` ÿÿLÓP S_json_array_clearjansson.dlljansson.dll/ 1403015379 0 51 ` ÿÿLÓP S_json_array_extendjansson.dll jansson.dll/ 1403015379 0 48 ` ÿÿLÓP S_json_array_getjansson.dlljansson.dll/ 1403015379 0 55 ` ÿÿLÓP S#_json_array_insert_newjansson.dll jansson.dll/ 1403015379 0 51 ` ÿÿLÓP S_json_array_removejansson.dll jansson.dll/ 1403015379 0 52 ` ÿÿLÓP S _json_array_set_newjansson.dlljansson.dll/ 1403015379 0 49 ` ÿÿLÓP S_json_array_sizejansson.dll jansson.dll/ 1403015379 0 43 ` ÿÿLÓP S _json_copyjansson.dll jansson.dll/ 1403015379 0 48 ` ÿÿLÓP S _json_deep_copyjansson.dlljansson.dll/ 1403015379 0 45 ` ÿÿLÓP S _json_deletejansson.dll jansson.dll/ 1403015379 0 52 ` ÿÿLÓP S _json_dump_callbackjansson.dlljansson.dll/ 1403015379 0 48 ` ÿÿLÓP S _json_dump_filejansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_dumpfjansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_dumpsjansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_equaljansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_falsejansson.dlljansson.dll/ 1403015379 0 46 ` ÿÿLÓP S_json_integerjansson.dlljansson.dll/ 1403015379 0 50 ` ÿÿLÓP S_json_integer_setjansson.dlljansson.dll/ 1403015379 0 52 ` ÿÿLÓP S _json_integer_valuejansson.dlljansson.dll/ 1403015379 0 52 ` ÿÿLÓP S _json_load_callbackjansson.dlljansson.dll/ 1403015379 0 48 ` ÿÿLÓP S_json_load_filejansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_loadbjansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_loadfjansson.dlljansson.dll/ 1403015379 0 44 ` ÿÿLÓP S_json_loadsjansson.dlljansson.dll/ 1403015379 0 43 ` ÿÿLÓP S_json_nulljansson.dll jansson.dll/ 1403015379 0 51 ` ÿÿLÓP S_json_number_valuejansson.dll jansson.dll/ 1403015379 0 45 ` ÿÿLÓP S_json_objectjansson.dll jansson.dll/ 1403015379 0 51 ` ÿÿLÓP S_json_object_clearjansson.dll jansson.dll/ 1403015379 0 49 ` ÿÿLÓP S_json_object_deljansson.dll jansson.dll/ 1403015379 0 49 ` ÿÿLÓP S_json_object_getjansson.dll jansson.dll/ 1403015379 0 50 ` ÿÿLÓP S _json_object_iterjansson.dlljansson.dll/ 1403015379 0 53 ` ÿÿLÓP S!!_json_object_iter_atjansson.dll jansson.dll/ 1403015379 0 54 ` ÿÿLÓP S""_json_object_iter_keyjansson.dlljansson.dll/ 1403015379 0 55 ` ÿÿLÓP S##_json_object_iter_nextjansson.dll jansson.dll/ 1403015379 0 58 ` ÿÿLÓP S&$_json_object_iter_set_newjansson.dlljansson.dll/ 1403015379 0 56 ` ÿÿLÓP S$%_json_object_iter_valuejansson.dlljansson.dll/ 1403015379 0 57 ` ÿÿLÓP S%&_json_object_key_to_iterjansson.dll jansson.dll/ 1403015379 0 50 ` ÿÿLÓP S'_json_object_seedjansson.dlljansson.dll/ 1403015379 0 53 ` ÿÿLÓP S!(_json_object_set_newjansson.dll jansson.dll/ 1403015379 0 61 ` ÿÿLÓP S))_json_object_set_new_nocheckjansson.dll jansson.dll/ 1403015379 0 50 ` ÿÿLÓP S*_json_object_sizejansson.dlljansson.dll/ 1403015379 0 52 ` ÿÿLÓP S +_json_object_updatejansson.dlljansson.dll/ 1403015379 0 61 ` ÿÿLÓP S),_json_object_update_existingjansson.dll jansson.dll/ 1403015379 0 60 ` ÿÿLÓP S(-_json_object_update_missingjansson.dlljansson.dll/ 1403015379 0 43 ` ÿÿLÓP S._json_packjansson.dll jansson.dll/ 1403015379 0 46 ` ÿÿLÓP S/_json_pack_exjansson.dlljansson.dll/ 1403015379 0 43 ` ÿÿLÓP S0_json_realjansson.dll jansson.dll/ 1403015379 0 47 ` ÿÿLÓP S1_json_real_setjansson.dll jansson.dll/ 1403015379 0 49 ` ÿÿLÓP S2_json_real_valuejansson.dll jansson.dll/ 1403015379 0 54 ` ÿÿLÓP S"3_json_set_alloc_funcsjansson.dlljansson.dll/ 1403015379 0 45 ` ÿÿLÓP S4_json_stringjansson.dll jansson.dll/ 1403015379 0 52 ` ÿÿLÓP S 5_json_string_lengthjansson.dlljansson.dll/ 1403015379 0 53 ` ÿÿLÓP S!6_json_string_nocheckjansson.dll jansson.dll/ 1403015379 0 49 ` ÿÿLÓP S7_json_string_setjansson.dll jansson.dll/ 1403015379 0 57 ` ÿÿLÓP S%8_json_string_set_nocheckjansson.dll jansson.dll/ 1403015379 0 50 ` ÿÿLÓP S9_json_string_setnjansson.dlljansson.dll/ 1403015379 0 58 ` ÿÿLÓP S&:_json_string_setn_nocheckjansson.dlljansson.dll/ 1403015379 0 51 ` ÿÿLÓP S;_json_string_valuejansson.dll jansson.dll/ 1403015379 0 46 ` ÿÿLÓP S<_json_stringnjansson.dlljansson.dll/ 1403015379 0 54 ` ÿÿLÓP S"=_json_stringn_nocheckjansson.dlljansson.dll/ 1403015379 0 43 ` ÿÿLÓP S>_json_truejansson.dll jansson.dll/ 1403015379 0 45 ` ÿÿLÓP S?_json_unpackjansson.dll jansson.dll/ 1403015379 0 48 ` ÿÿLÓP S@_json_unpack_exjansson.dlljansson.dll/ 1403015379 0 47 ` ÿÿLÓP SA_json_vpack_exjansson.dll jansson.dll/ 1403015379 0 49 ` ÿÿLÓP SB_json_vunpack_exjansson.dll
C/C++
x64dbg-development/src/dbg/LLVMDemangle/LLVMDemangle.h
#pragma once #ifdef __cplusplus extern "C" { #endif __declspec(dllexport) char* LLVMDemangle(const char* MangledName); __declspec(dllexport) void LLVMDemangleFree(char* DemangledName); #ifdef __cplusplus } #endif
x64dbg-development/src/dbg/LLVMDemangle/LLVMDemangle_x64.lib
!<arch> / 1652535369 0 192 ` X–Ò66¤¤__IMPORT_DESCRIPTOR_LLVMDemangle__NULL_IMPORT_DESCRIPTORLLVMDemangle_NULL_THUNK_DATALLVMDemangle__imp_LLVMDemangleLLVMDemangleFree__imp_LLVMDemangleFree/ 1652535369 0 202 ` X–Ò6¤LLVMDemangleLLVMDemangleFree__IMPORT_DESCRIPTOR_LLVMDemangle__NULL_IMPORT_DESCRIPTOR__imp_LLVMDemangle__imp_LLVMDemangleFreeLLVMDemangle_NULL_THUNK_DATA// 1652535369 0 17 ` LLVMDemangle.dll /0 1652535369 0 514 ` d†I°b.debug$SFŒ@B.idata$2Òæ@0À.idata$6æ@ À LLVMDemangle.dll'б^Microsoft (R) LINK LLVMDemangle.dll@comp.id±^ÿÿ.idata$2@Àh.idata$6.idata$4@Àh.idata$5@Àh%>\__IMPORT_DESCRIPTOR_LLVMDemangle__NULL_IMPORT_DESCRIPTORLLVMDemangle_NULL_THUNK_DATA/0 1652535369 0 255 ` d†I°b¾.debug$SFd@B.idata$3ª@0À LLVMDemangle.dll'б^Microsoft (R) LINK@comp.id±^ÿÿ__NULL_IMPORT_DESCRIPTOR /0 1652535369 0 296 ` d†I°bâ.debug$SFŒ@B.idata$5Ò@@À.idata$4Ú@@À LLVMDemangle.dll'б^Microsoft (R) LINK@comp.id±^ÿÿ"LLVMDemangle_NULL_THUNK_DATA/0 1652535369 0 50 ` ÿÿd†I°bLLVMDemangleLLVMDemangle.dll/0 1652535369 0 54 ` ÿÿd†I°b"LLVMDemangleFreeLLVMDemangle.dll
x64dbg-development/src/dbg/LLVMDemangle/LLVMDemangle_x86.lib
!<arch> / 1652535421 0 196 ` `žÚ66¦¦__IMPORT_DESCRIPTOR_LLVMDemangle__NULL_IMPORT_DESCRIPTORLLVMDemangle_NULL_THUNK_DATA_LLVMDemangle__imp__LLVMDemangle_LLVMDemangleFree__imp__LLVMDemangleFree/ 1652535421 0 206 ` `žÚ6¦_LLVMDemangle_LLVMDemangleFree__IMPORT_DESCRIPTOR_LLVMDemangle__NULL_IMPORT_DESCRIPTOR__imp__LLVMDemangle__imp__LLVMDemangleFreeLLVMDemangle_NULL_THUNK_DATA// 1652535421 0 17 ` LLVMDemangle.dll /0 1652535421 0 514 ` L}°b.debug$SFŒ@B.idata$2Òæ@0À.idata$6æ@ À LLVMDemangle.dll'±^Microsoft (R) LINK LLVMDemangle.dll@comp.id±^ÿÿ.idata$2@Àh.idata$6.idata$4@Àh.idata$5@Àh%>\__IMPORT_DESCRIPTOR_LLVMDemangle__NULL_IMPORT_DESCRIPTORLLVMDemangle_NULL_THUNK_DATA/0 1652535421 0 255 ` L}°b¾.debug$SFd@B.idata$3ª@0À LLVMDemangle.dll'±^Microsoft (R) LINK@comp.id±^ÿÿ__NULL_IMPORT_DESCRIPTOR /0 1652535421 0 288 ` L}°bÚ.debug$SFŒ@B.idata$5Ò@0À.idata$4Ö@0À LLVMDemangle.dll'±^Microsoft (R) LINK@comp.id±^ÿÿ"LLVMDemangle_NULL_THUNK_DATA/0 1652535421 0 51 ` ÿÿL}°b_LLVMDemangleLLVMDemangle.dll /0 1652535421 0 55 ` ÿÿL}°b#_LLVMDemangleFreeLLVMDemangle.dll
C/C++
x64dbg-development/src/dbg/lz4/lz4.h
/* LZ4 - Fast LZ compression algorithm Header File Copyright (C) 2011-2014, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html - LZ4 source repository : http://code.google.com/p/lz4/ */ #ifndef _LZ4_H #define _LZ4_H #if defined (__cplusplus) extern "C" { #endif /************************************** Version **************************************/ #define LZ4_VERSION_MAJOR 1 /* for major interface/format changes */ #define LZ4_VERSION_MINOR 1 /* for minor interface/format changes */ #define LZ4_VERSION_RELEASE 3 /* for tweaks, bug-fixes, or development */ /************************************** Compiler Options **************************************/ #if (defined(__GNUC__) && defined(__STRICT_ANSI__)) || (defined(_MSC_VER) && !defined(__cplusplus)) /* Visual Studio */ # define inline __inline /* Visual C is not C99, but supports some kind of inline */ #endif /************************************** Simple Functions **************************************/ __declspec(dllimport) int LZ4_compress(const char* source, char* dest, int inputSize); __declspec(dllimport) int LZ4_decompress_safe(const char* source, char* dest, int inputSize, int maxOutputSize); /* LZ4_compress() : Compresses 'inputSize' bytes from 'source' into 'dest'. Destination buffer must be already allocated, and must be sized to handle worst cases situations (input data not compressible) Worst case size evaluation is provided by function LZ4_compressBound() inputSize : Max supported value is LZ4_MAX_INPUT_VALUE return : the number of bytes written in buffer dest or 0 if the compression fails LZ4_decompress_safe() : maxOutputSize : is the size of the destination buffer (which must be already allocated) return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize) If the source stream is detected malformed, the function will stop decoding and return a negative result. This function is protected against buffer overflow exploits (never writes outside of output buffer, and never reads outside of input buffer). Therefore, it is protected against malicious data packets */ /************************************** Advanced Functions **************************************/ #define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */ #define LZ4_COMPRESSBOUND(isize) ((unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16) /* LZ4_compressBound() : Provides the maximum size that LZ4 may output in a "worst case" scenario (input data not compressible) primarily useful for memory allocation of output buffer. inline function is recommended for the general case, macro is also provided when result needs to be evaluated at compilation (such as stack memory allocation). isize : is the input size. Max supported value is LZ4_MAX_INPUT_SIZE return : maximum output size in a "worst case" scenario or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE) */ __declspec(dllimport) int LZ4_compressBound(int isize); /* LZ4_compress_limitedOutput() : Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'. If it cannot achieve it, compression will stop, and result of the function will be zero. This function never writes outside of provided output buffer. inputSize : Max supported value is LZ4_MAX_INPUT_VALUE maxOutputSize : is the size of the destination buffer (which must be already allocated) return : the number of bytes written in buffer 'dest' or 0 if the compression fails */ __declspec(dllimport) int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize); /* LZ4_decompress_fast() : originalSize : is the original and therefore uncompressed size return : the number of bytes read from the source buffer (in other words, the compressed size) If the source stream is malformed, the function will stop decoding and return a negative result. note : This function is a bit faster than LZ4_decompress_safe() This function never writes outside of output buffers, but may read beyond input buffer in case of malicious data packet. Use this function preferably into a trusted environment (data to decode comes from a trusted source). Destination buffer must be already allocated. Its size must be a minimum of 'outputSize' bytes. */ __declspec(dllimport) int LZ4_decompress_fast(const char* source, char* dest, int originalSize); /* LZ4_decompress_safe_partial() : This function decompress a compressed block of size 'inputSize' at position 'source' into output buffer 'dest' of size 'maxOutputSize'. The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached, reducing decompression time. return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize) Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller. Always control how many bytes were decoded. If the source stream is detected malformed, the function will stop decoding and return a negative result. This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets */ __declspec(dllimport) int LZ4_decompress_safe_partial(const char* source, char* dest, int inputSize, int targetOutputSize, int maxOutputSize); /* These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods. To know how much memory must be allocated for the compression tables, use : int LZ4_sizeofState(); Note that tables must be aligned on 4-bytes boundaries, otherwise compression will fail (return code 0). The allocated memory can be provided to the compressions functions using 'void* state' parameter. LZ4_compress_withState() and LZ4_compress_limitedOutput_withState() are equivalent to previously described functions. They just use the externally allocated memory area instead of allocating their own (on stack, or on heap). */ __declspec(dllimport) int LZ4_sizeofState(void); __declspec(dllimport) int LZ4_compress_withState(void* state, const char* source, char* dest, int inputSize); __declspec(dllimport) int LZ4_compress_limitedOutput_withState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize); /************************************** Streaming Functions **************************************/ __declspec(dllimport) void* LZ4_create(const char* inputBuffer); __declspec(dllimport) int LZ4_compress_continue(void* LZ4_Data, const char* source, char* dest, int inputSize); __declspec(dllimport) int LZ4_compress_limitedOutput_continue(void* LZ4_Data, const char* source, char* dest, int inputSize, int maxOutputSize); __declspec(dllimport) char* LZ4_slideInputBuffer(void* LZ4_Data); __declspec(dllimport) int LZ4_free(void* LZ4_Data); /* These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks. In order to achieve this, it is necessary to start creating the LZ4 Data Structure, thanks to the function : void* LZ4_create (const char* inputBuffer); The result of the function is the (void*) pointer on the LZ4 Data Structure. This pointer will be needed in all other functions. If the pointer returned is NULL, then the allocation has failed, and compression must be aborted. The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. The input buffer must be already allocated, and size at least 192KB. 'inputBuffer' will also be the 'const char* source' of the first block. All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'. To compress each block, use either LZ4_compress_continue() or LZ4_compress_limitedOutput_continue(). Their behavior are identical to LZ4_compress() or LZ4_compress_limitedOutput(), but require the LZ4 Data Structure as their first argument, and check that each block starts right after the previous one. If next block does not begin immediately after the previous one, the compression will fail (return 0). When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to : char* LZ4_slideInputBuffer(void* LZ4_Data); must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer. Note that, for this function to work properly, minimum size of an input buffer must be 192KB. ==> The memory position where the next input data block must start is provided as the result of the function. Compression can then resume, using LZ4_compress_continue() or LZ4_compress_limitedOutput_continue(), as usual. When compression is completed, a call to LZ4_free() will release the memory used by the LZ4 Data Structure. */ __declspec(dllimport) int LZ4_sizeofStreamState(void); __declspec(dllimport) int LZ4_resetStreamState(void* state, const char* inputBuffer); /* These functions achieve the same result as : void* LZ4_create (const char* inputBuffer); They are provided here to allow the user program to allocate memory using its own routines. To know how much space must be allocated, use LZ4_sizeofStreamState(); Note also that space must be 4-bytes aligned. Once space is allocated, you must initialize it using : LZ4_resetStreamState(void* state, const char* inputBuffer); void* state is a pointer to the space allocated. It must be aligned on 4-bytes boundaries, and be large enough. The parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. The input buffer must be already allocated, and size at least 192KB. 'inputBuffer' will also be the 'const char* source' of the first block. The same space can be re-used multiple times, just by initializing it each time with LZ4_resetStreamState(). return value of LZ4_resetStreamState() must be 0 is OK. Any other value means there was an error (typically, pointer is not aligned on 4-bytes boundaries). */ __declspec(dllimport) int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int inputSize, int maxOutputSize); __declspec(dllimport) int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int outputSize); /* *_withPrefix64k() : These decoding functions work the same as their "normal name" versions, but can use up to 64KB of data in front of 'char* dest'. These functions are necessary to decode inter-dependant blocks. */ /************************************** Obsolete Functions **************************************/ /* These functions are deprecated and should no longer be used. They are provided here for compatibility with existing user programs. */ __declspec(dllimport) int LZ4_uncompress(const char* source, char* dest, int outputSize); __declspec(dllimport) int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize, int maxOutputSize); #if defined (__cplusplus) } #endif #endif //_LZ4_H
C/C++
x64dbg-development/src/dbg/lz4/lz4file.h
#ifndef _LZ4FILE_H #define _LZ4FILE_H typedef enum _LZ4_STATUS { LZ4_SUCCESS, LZ4_FAILED_OPEN_INPUT, LZ4_FAILED_OPEN_OUTPUT, LZ4_NOT_ENOUGH_MEMORY, LZ4_INVALID_ARCHIVE, LZ4_CORRUPTED_ARCHIVE } LZ4_STATUS; #if defined (__cplusplus) extern "C" { #endif __declspec(dllimport) LZ4_STATUS LZ4_compress_file(const char* input_filename, const char* output_filename); __declspec(dllimport) LZ4_STATUS LZ4_compress_fileW(const wchar_t* input_filename, const wchar_t* output_filename); __declspec(dllimport) LZ4_STATUS LZ4_decompress_file(const char* input_filename, const char* output_filename); __declspec(dllimport) LZ4_STATUS LZ4_decompress_fileW(const wchar_t* input_filename, const wchar_t* output_filename); #if defined (__cplusplus) } #endif #endif //_LZ4FILE_H
C/C++
x64dbg-development/src/dbg/lz4/lz4hc.h
/* LZ4 HC - High Compression Mode of LZ4 Header File Copyright (C) 2011-2014, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html - LZ4 source repository : http://code.google.com/p/lz4/ */ #ifndef _LZ4HC_H #define _LZ4HC_H #if defined (__cplusplus) extern "C" { #endif __declspec(dllimport) int LZ4_compressHC(const char* source, char* dest, int inputSize); /* LZ4_compressHC : return : the number of bytes in compressed buffer dest or 0 if compression fails. note : destination buffer must be already allocated. To avoid any problem, size it to handle worst cases situations (input data not compressible) Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h") */ __declspec(dllimport) int LZ4_compressHC_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize); /* LZ4_compress_limitedOutput() : Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'. If it cannot achieve it, compression will stop, and result of the function will be zero. This function never writes outside of provided output buffer. inputSize : Max supported value is 1 GB maxOutputSize : is maximum allowed size into the destination buffer (which must be already allocated) return : the number of output bytes written in buffer 'dest' or 0 if compression fails. */ __declspec(dllimport) int LZ4_compressHC2(const char* source, char* dest, int inputSize, int compressionLevel); __declspec(dllimport) int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); /* Same functions as above, but with programmable 'compressionLevel'. Recommended values are between 4 and 9, although any value between 0 and 16 will work. 'compressionLevel'==0 means use default 'compressionLevel' value. Values above 16 behave the same as 16. Equivalent variants exist for all other compression functions below. */ /* Note : Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license) */ /************************************** Using an external allocation **************************************/ __declspec(dllimport) int LZ4_sizeofStateHC(void); __declspec(dllimport) int LZ4_compressHC_withStateHC(void* state, const char* source, char* dest, int inputSize); __declspec(dllimport) int LZ4_compressHC_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize); __declspec(dllimport) int LZ4_compressHC2_withStateHC(void* state, const char* source, char* dest, int inputSize, int compressionLevel); __declspec(dllimport) int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); /* These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods. To know how much memory must be allocated for the compression tables, use : int LZ4_sizeofStateHC(); Note that tables must be aligned for pointer (32 or 64 bits), otherwise compression will fail (return code 0). The allocated memory can be provided to the compressions functions using 'void* state' parameter. LZ4_compress_withStateHC() and LZ4_compress_limitedOutput_withStateHC() are equivalent to previously described functions. They just use the externally allocated memory area instead of allocating their own (on stack, or on heap). */ /************************************** Streaming Functions **************************************/ __declspec(dllimport) void* LZ4_createHC(const char* inputBuffer); __declspec(dllimport) int LZ4_compressHC_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize); __declspec(dllimport) int LZ4_compressHC_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize); __declspec(dllimport) char* LZ4_slideInputBufferHC(void* LZ4HC_Data); __declspec(dllimport) int LZ4_freeHC(void* LZ4HC_Data); __declspec(dllimport) int LZ4_compressHC2_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel); __declspec(dllimport) int LZ4_compressHC2_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); /* These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks. In order to achieve this, it is necessary to start creating the LZ4HC Data Structure, thanks to the function : void* LZ4_createHC (const char* inputBuffer); The result of the function is the (void*) pointer on the LZ4HC Data Structure. This pointer will be needed in all other functions. If the pointer returned is NULL, then the allocation has failed, and compression must be aborted. The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. The input buffer must be already allocated, and size at least 192KB. 'inputBuffer' will also be the 'const char* source' of the first block. All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'. To compress each block, use either LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(). Their behavior are identical to LZ4_compressHC() or LZ4_compressHC_limitedOutput(), but require the LZ4HC Data Structure as their first argument, and check that each block starts right after the previous one. If next block does not begin immediately after the previous one, the compression will fail (return 0). When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to : char* LZ4_slideInputBufferHC(void* LZ4HC_Data); must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer. Note that, for this function to work properly, minimum size of an input buffer must be 192KB. ==> The memory position where the next input data block must start is provided as the result of the function. Compression can then resume, using LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(), as usual. When compression is completed, a call to LZ4_freeHC() will release the memory used by the LZ4HC Data Structure. */ __declspec(dllimport) int LZ4_sizeofStreamStateHC(void); __declspec(dllimport) int LZ4_resetStreamStateHC(void* state, const char* inputBuffer); /* These functions achieve the same result as : void* LZ4_createHC (const char* inputBuffer); They are provided here to allow the user program to allocate memory using its own routines. To know how much space must be allocated, use LZ4_sizeofStreamStateHC(); Note also that space must be aligned for pointers (32 or 64 bits). Once space is allocated, you must initialize it using : LZ4_resetStreamStateHC(void* state, const char* inputBuffer); void* state is a pointer to the space allocated. It must be aligned for pointers (32 or 64 bits), and be large enough. The parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. The input buffer must be already allocated, and size at least 192KB. 'inputBuffer' will also be the 'const char* source' of the first block. The same space can be re-used multiple times, just by initializing it each time with LZ4_resetStreamState(). return value of LZ4_resetStreamStateHC() must be 0 is OK. Any other value means there was an error (typically, state is not aligned for pointers (32 or 64 bits)). */ #if defined (__cplusplus) } #endif #endif //_LZ4HC_H
C/C++
x64dbg-development/src/dbg/msdia/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; 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 }; // 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_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_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, // 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<regnum><H/L>, these //values reprsesent the bit patterns of the registers as 64-bit integers, not //the representation of these registers as a double. CV_AMD64_XMM0IL = 400, CV_AMD64_XMM1IL = 401, CV_AMD64_XMM2IL = 402, CV_AMD64_XMM3IL = 403, CV_AMD64_XMM4IL = 404, CV_AMD64_XMM5IL = 405, CV_AMD64_XMM6IL = 406, CV_AMD64_XMM7IL = 407, CV_AMD64_XMM8IL = 408, CV_AMD64_XMM9IL = 409, CV_AMD64_XMM10IL = 410, CV_AMD64_XMM11IL = 411, CV_AMD64_XMM12IL = 412, CV_AMD64_XMM13IL = 413, CV_AMD64_XMM14IL = 414, CV_AMD64_XMM15IL = 415, CV_AMD64_XMM0IH = 416, CV_AMD64_XMM1IH = 417, CV_AMD64_XMM2IH = 418, CV_AMD64_XMM3IH = 419, CV_AMD64_XMM4IH = 420, CV_AMD64_XMM5IH = 421, CV_AMD64_XMM6IH = 422, CV_AMD64_XMM7IH = 423, CV_AMD64_XMM8IH = 424, CV_AMD64_XMM9IH = 425, CV_AMD64_XMM10IH = 426, CV_AMD64_XMM11IH = 427, CV_AMD64_XMM12IH = 428, CV_AMD64_XMM13IH = 429, CV_AMD64_XMM14IH = 430, CV_AMD64_XMM15IH = 431, CV_AMD64_YMM0I0 = 432, // AVX integer registers CV_AMD64_YMM0I1 = 433, CV_AMD64_YMM0I2 = 434, CV_AMD64_YMM0I3 = 435, CV_AMD64_YMM1I0 = 436, CV_AMD64_YMM1I1 = 437, CV_AMD64_YMM1I2 = 438, CV_AMD64_YMM1I3 = 439, CV_AMD64_YMM2I0 = 440, CV_AMD64_YMM2I1 = 441, CV_AMD64_YMM2I2 = 442, CV_AMD64_YMM2I3 = 443, CV_AMD64_YMM3I0 = 444, CV_AMD64_YMM3I1 = 445, CV_AMD64_YMM3I2 = 446, CV_AMD64_YMM3I3 = 447, CV_AMD64_YMM4I0 = 448, CV_AMD64_YMM4I1 = 449, CV_AMD64_YMM4I2 = 450, CV_AMD64_YMM4I3 = 451, CV_AMD64_YMM5I0 = 452, CV_AMD64_YMM5I1 = 453, CV_AMD64_YMM5I2 = 454, CV_AMD64_YMM5I3 = 455, CV_AMD64_YMM6I0 = 456, CV_AMD64_YMM6I1 = 457, CV_AMD64_YMM6I2 = 458, CV_AMD64_YMM6I3 = 459, CV_AMD64_YMM7I0 = 460, CV_AMD64_YMM7I1 = 461, CV_AMD64_YMM7I2 = 462, CV_AMD64_YMM7I3 = 463, CV_AMD64_YMM8I0 = 464, CV_AMD64_YMM8I1 = 465, CV_AMD64_YMM8I2 = 466, CV_AMD64_YMM8I3 = 467, CV_AMD64_YMM9I0 = 468, CV_AMD64_YMM9I1 = 469, CV_AMD64_YMM9I2 = 470, CV_AMD64_YMM9I3 = 471, CV_AMD64_YMM10I0 = 472, CV_AMD64_YMM10I1 = 473, CV_AMD64_YMM10I2 = 474, CV_AMD64_YMM10I3 = 475, CV_AMD64_YMM11I0 = 476, CV_AMD64_YMM11I1 = 477, CV_AMD64_YMM11I2 = 478, CV_AMD64_YMM11I3 = 479, CV_AMD64_YMM12I0 = 480, CV_AMD64_YMM12I1 = 481, CV_AMD64_YMM12I2 = 482, CV_AMD64_YMM12I3 = 483, CV_AMD64_YMM13I0 = 484, CV_AMD64_YMM13I1 = 485, CV_AMD64_YMM13I2 = 486, CV_AMD64_YMM13I3 = 487, CV_AMD64_YMM14I0 = 488, CV_AMD64_YMM14I1 = 489, CV_AMD64_YMM14I2 = 490, CV_AMD64_YMM14I3 = 491, CV_AMD64_YMM15I0 = 492, CV_AMD64_YMM15I1 = 493, CV_AMD64_YMM15I2 = 494, CV_AMD64_YMM15I3 = 495, CV_AMD64_YMM0F0 = 496, // AVX floating-point single precise registers CV_AMD64_YMM0F1 = 497, CV_AMD64_YMM0F2 = 498, CV_AMD64_YMM0F3 = 499, CV_AMD64_YMM0F4 = 500, CV_AMD64_YMM0F5 = 501, CV_AMD64_YMM0F6 = 502, CV_AMD64_YMM0F7 = 503, CV_AMD64_YMM1F0 = 504, CV_AMD64_YMM1F1 = 505, CV_AMD64_YMM1F2 = 506, CV_AMD64_YMM1F3 = 507, CV_AMD64_YMM1F4 = 508, CV_AMD64_YMM1F5 = 509, CV_AMD64_YMM1F6 = 510, CV_AMD64_YMM1F7 = 511, CV_AMD64_YMM2F0 = 512, CV_AMD64_YMM2F1 = 513, CV_AMD64_YMM2F2 = 514, CV_AMD64_YMM2F3 = 515, CV_AMD64_YMM2F4 = 516, CV_AMD64_YMM2F5 = 517, CV_AMD64_YMM2F6 = 518, CV_AMD64_YMM2F7 = 519, CV_AMD64_YMM3F0 = 520, CV_AMD64_YMM3F1 = 521, CV_AMD64_YMM3F2 = 522, CV_AMD64_YMM3F3 = 523, CV_AMD64_YMM3F4 = 524, CV_AMD64_YMM3F5 = 525, CV_AMD64_YMM3F6 = 526, CV_AMD64_YMM3F7 = 527, CV_AMD64_YMM4F0 = 528, CV_AMD64_YMM4F1 = 529, CV_AMD64_YMM4F2 = 530, CV_AMD64_YMM4F3 = 531, CV_AMD64_YMM4F4 = 532, CV_AMD64_YMM4F5 = 533, CV_AMD64_YMM4F6 = 534, CV_AMD64_YMM4F7 = 535, CV_AMD64_YMM5F0 = 536, CV_AMD64_YMM5F1 = 537, CV_AMD64_YMM5F2 = 538, CV_AMD64_YMM5F3 = 539, CV_AMD64_YMM5F4 = 540, CV_AMD64_YMM5F5 = 541, CV_AMD64_YMM5F6 = 542, CV_AMD64_YMM5F7 = 543, CV_AMD64_YMM6F0 = 544, CV_AMD64_YMM6F1 = 545, CV_AMD64_YMM6F2 = 546, CV_AMD64_YMM6F3 = 547, CV_AMD64_YMM6F4 = 548, CV_AMD64_YMM6F5 = 549, CV_AMD64_YMM6F6 = 550, CV_AMD64_YMM6F7 = 551, CV_AMD64_YMM7F0 = 552, CV_AMD64_YMM7F1 = 553, CV_AMD64_YMM7F2 = 554, CV_AMD64_YMM7F3 = 555, CV_AMD64_YMM7F4 = 556, CV_AMD64_YMM7F5 = 557, CV_AMD64_YMM7F6 = 558, CV_AMD64_YMM7F7 = 559, CV_AMD64_YMM8F0 = 560, CV_AMD64_YMM8F1 = 561, CV_AMD64_YMM8F2 = 562, CV_AMD64_YMM8F3 = 563, CV_AMD64_YMM8F4 = 564, CV_AMD64_YMM8F5 = 565, CV_AMD64_YMM8F6 = 566, CV_AMD64_YMM8F7 = 567, CV_AMD64_YMM9F0 = 568, CV_AMD64_YMM9F1 = 569, CV_AMD64_YMM9F2 = 570, CV_AMD64_YMM9F3 = 571, CV_AMD64_YMM9F4 = 572, CV_AMD64_YMM9F5 = 573, CV_AMD64_YMM9F6 = 574, CV_AMD64_YMM9F7 = 575, CV_AMD64_YMM10F0 = 576, CV_AMD64_YMM10F1 = 577, CV_AMD64_YMM10F2 = 578, CV_AMD64_YMM10F3 = 579, CV_AMD64_YMM10F4 = 580, CV_AMD64_YMM10F5 = 581, CV_AMD64_YMM10F6 = 582, CV_AMD64_YMM10F7 = 583, CV_AMD64_YMM11F0 = 584, CV_AMD64_YMM11F1 = 585, CV_AMD64_YMM11F2 = 586, CV_AMD64_YMM11F3 = 587, CV_AMD64_YMM11F4 = 588, CV_AMD64_YMM11F5 = 589, CV_AMD64_YMM11F6 = 590, CV_AMD64_YMM11F7 = 591, CV_AMD64_YMM12F0 = 592, CV_AMD64_YMM12F1 = 593, CV_AMD64_YMM12F2 = 594, CV_AMD64_YMM12F3 = 595, CV_AMD64_YMM12F4 = 596, CV_AMD64_YMM12F5 = 597, CV_AMD64_YMM12F6 = 598, CV_AMD64_YMM12F7 = 599, CV_AMD64_YMM13F0 = 600, CV_AMD64_YMM13F1 = 601, CV_AMD64_YMM13F2 = 602, CV_AMD64_YMM13F3 = 603, CV_AMD64_YMM13F4 = 604, CV_AMD64_YMM13F5 = 605, CV_AMD64_YMM13F6 = 606, CV_AMD64_YMM13F7 = 607, CV_AMD64_YMM14F0 = 608, CV_AMD64_YMM14F1 = 609, CV_AMD64_YMM14F2 = 610, CV_AMD64_YMM14F3 = 611, CV_AMD64_YMM14F4 = 612, CV_AMD64_YMM14F5 = 613, CV_AMD64_YMM14F6 = 614, CV_AMD64_YMM14F7 = 615, CV_AMD64_YMM15F0 = 616, CV_AMD64_YMM15F1 = 617, CV_AMD64_YMM15F2 = 618, CV_AMD64_YMM15F3 = 619, CV_AMD64_YMM15F4 = 620, CV_AMD64_YMM15F5 = 621, CV_AMD64_YMM15F6 = 622, CV_AMD64_YMM15F7 = 623, CV_AMD64_YMM0D0 = 624, // AVX floating-point double precise registers CV_AMD64_YMM0D1 = 625, CV_AMD64_YMM0D2 = 626, CV_AMD64_YMM0D3 = 627, CV_AMD64_YMM1D0 = 628, CV_AMD64_YMM1D1 = 629, CV_AMD64_YMM1D2 = 630, CV_AMD64_YMM1D3 = 631, CV_AMD64_YMM2D0 = 632, CV_AMD64_YMM2D1 = 633, CV_AMD64_YMM2D2 = 634, CV_AMD64_YMM2D3 = 635, CV_AMD64_YMM3D0 = 636, CV_AMD64_YMM3D1 = 637, CV_AMD64_YMM3D2 = 638, CV_AMD64_YMM3D3 = 639, CV_AMD64_YMM4D0 = 640, CV_AMD64_YMM4D1 = 641, CV_AMD64_YMM4D2 = 642, CV_AMD64_YMM4D3 = 643, CV_AMD64_YMM5D0 = 644, CV_AMD64_YMM5D1 = 645, CV_AMD64_YMM5D2 = 646, CV_AMD64_YMM5D3 = 647, CV_AMD64_YMM6D0 = 648, CV_AMD64_YMM6D1 = 649, CV_AMD64_YMM6D2 = 650, CV_AMD64_YMM6D3 = 651, CV_AMD64_YMM7D0 = 652, CV_AMD64_YMM7D1 = 653, CV_AMD64_YMM7D2 = 654, CV_AMD64_YMM7D3 = 655, CV_AMD64_YMM8D0 = 656, CV_AMD64_YMM8D1 = 657, CV_AMD64_YMM8D2 = 658, CV_AMD64_YMM8D3 = 659, CV_AMD64_YMM9D0 = 660, CV_AMD64_YMM9D1 = 661, CV_AMD64_YMM9D2 = 662, CV_AMD64_YMM9D3 = 663, CV_AMD64_YMM10D0 = 664, CV_AMD64_YMM10D1 = 665, CV_AMD64_YMM10D2 = 666, CV_AMD64_YMM10D3 = 667, CV_AMD64_YMM11D0 = 668, CV_AMD64_YMM11D1 = 669, CV_AMD64_YMM11D2 = 670, CV_AMD64_YMM11D3 = 671, CV_AMD64_YMM12D0 = 672, CV_AMD64_YMM12D1 = 673, CV_AMD64_YMM12D2 = 674, CV_AMD64_YMM12D3 = 675, CV_AMD64_YMM13D0 = 676, CV_AMD64_YMM13D1 = 677, CV_AMD64_YMM13D2 = 678, CV_AMD64_YMM13D3 = 679, CV_AMD64_YMM14D0 = 680, CV_AMD64_YMM14D1 = 681, CV_AMD64_YMM14D2 = 682, CV_AMD64_YMM14D3 = 683, CV_AMD64_YMM15D0 = 684, CV_AMD64_YMM15D1 = 685, CV_AMD64_YMM15D2 = 686, CV_AMD64_YMM15D3 = 687, 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, // 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, }; #endif
C/C++
x64dbg-development/src/dbg/msdia/dia2.h
/* this ALWAYS GENERATED file contains the definitions for the interfaces */ /* File created by MIDL compiler version 8.01.0622 */ /* @@MIDL_FILE_HEADING( ) */ #pragma warning( disable: 4049 ) /* more than 64k source lines */ /* verify that the <rpcndr.h> version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ #define __REQUIRED_RPCNDR_H_VERSION__ 475 #endif /* verify that the <rpcsal.h> version is high enough to compile this file*/ #ifndef __REQUIRED_RPCSAL_H_VERSION__ #define __REQUIRED_RPCSAL_H_VERSION__ 100 #endif #include "rpc.h" #include "rpcndr.h" #ifndef __RPCNDR_H_VERSION__ #error this stub requires an updated version of <rpcndr.h> #endif /* __RPCNDR_H_VERSION__ */ #ifndef COM_NO_WINDOWS_H #include "windows.h" #include "ole2.h" #endif /*COM_NO_WINDOWS_H*/ #ifndef __dia2_h__ #define __dia2_h__ #if defined(_MSC_VER) && (_MSC_VER >= 1020) #pragma once #endif /* Forward Declarations */ #ifndef __IDiaLoadCallback_FWD_DEFINED__ #define __IDiaLoadCallback_FWD_DEFINED__ typedef interface IDiaLoadCallback IDiaLoadCallback; #endif /* __IDiaLoadCallback_FWD_DEFINED__ */ #ifndef __IDiaLoadCallback2_FWD_DEFINED__ #define __IDiaLoadCallback2_FWD_DEFINED__ typedef interface IDiaLoadCallback2 IDiaLoadCallback2; #endif /* __IDiaLoadCallback2_FWD_DEFINED__ */ #ifndef __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ #define __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ typedef interface IDiaReadExeAtOffsetCallback IDiaReadExeAtOffsetCallback; #endif /* __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ */ #ifndef __IDiaReadExeAtRVACallback_FWD_DEFINED__ #define __IDiaReadExeAtRVACallback_FWD_DEFINED__ typedef interface IDiaReadExeAtRVACallback IDiaReadExeAtRVACallback; #endif /* __IDiaReadExeAtRVACallback_FWD_DEFINED__ */ #ifndef __IDiaDataSource_FWD_DEFINED__ #define __IDiaDataSource_FWD_DEFINED__ typedef interface IDiaDataSource IDiaDataSource; #endif /* __IDiaDataSource_FWD_DEFINED__ */ #ifndef __IDiaEnumSymbols_FWD_DEFINED__ #define __IDiaEnumSymbols_FWD_DEFINED__ typedef interface IDiaEnumSymbols IDiaEnumSymbols; #endif /* __IDiaEnumSymbols_FWD_DEFINED__ */ #ifndef __IDiaEnumSymbolsByAddr_FWD_DEFINED__ #define __IDiaEnumSymbolsByAddr_FWD_DEFINED__ typedef interface IDiaEnumSymbolsByAddr IDiaEnumSymbolsByAddr; #endif /* __IDiaEnumSymbolsByAddr_FWD_DEFINED__ */ #ifndef __IDiaEnumSourceFiles_FWD_DEFINED__ #define __IDiaEnumSourceFiles_FWD_DEFINED__ typedef interface IDiaEnumSourceFiles IDiaEnumSourceFiles; #endif /* __IDiaEnumSourceFiles_FWD_DEFINED__ */ #ifndef __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 __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 __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 __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_0016 */ /* [local] */ struct DiaAddressMapEntry { DWORD rva; DWORD rvaTo; } ; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0016_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0016_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 __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_0025 */ /* [local] */ enum __MIDL___MIDL_itf_dia2_0000_0025_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_0025_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0025_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_0031 */ /* [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_0031_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_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_0034 */ /* [local] */ typedef /* [public] */ struct __MIDL___MIDL_itf_dia2_0000_0034_0001 { DWORD ulOffStart; DWORD cbProcSize; DWORD cdwLocals; WORD cdwParams; WORD cdwFlags; } FPODATA; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0034_v0_0_c_ifspec; extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0034_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
C++
x64dbg-development/src/dbg/msdia/diacreate.cpp
#include <windows.h> #include "diacreate.h" typedef HRESULT(__stdcall* pDllGetClassObject)( _In_ REFCLSID rclsid, _In_ REFIID riid, _Out_ LPVOID* ppv ); HRESULT STDMETHODCALLTYPE NoRegCoCreate(const __wchar_t* dllName, REFCLSID rclsid, REFIID riid, void** ppv) { HRESULT hr; HMODULE hModule = LoadLibraryW(dllName); pDllGetClassObject DllGetClassObject; if(hModule && (DllGetClassObject = (pDllGetClassObject)GetProcAddress(hModule, "DllGetClassObject"))) { IClassFactory* classFactory; hr = DllGetClassObject(rclsid, IID_IClassFactory, (LPVOID*)&classFactory); if(SUCCEEDED(hr)) { hr = classFactory->CreateInstance(nullptr, riid, ppv); classFactory->AddRef(); } } else { hr = GetLastError(); if(hr > 0) hr |= REASON_LEGACY_API; } return hr; }
C/C++
x64dbg-development/src/dbg/msdia/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
C/C++
x64dbg-development/src/dbg/ntdll/ntdll.h
#ifndef NTDLL_H #define NTDLL_H #pragma once #ifdef __cplusplus extern "C" { #endif #ifndef NOMINMAX #define NOMINMAX #endif #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #ifndef WIN32_NO_STATUS #define WIN32_NO_STATUS #endif #include <Windows.h> #undef WIN32_NO_STATUS #include <ntstatus.h> #include <intrin.h> #define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0) #define NT_ERROR(Status) ((((ULONG)(Status)) >> 30) == 3) #ifndef FASTCALL #define FASTCALL __fastcall #endif #ifndef _Reserved_ #define _Reserved_ #endif #if (defined(_MSC_VER) && !defined(__clang__)) #define BUILTIN_OFFSETOF_REQUIRES_CPP (_MSC_VER < 9999 ? 1 : 0) // Update this number if/when MS ever fix this #else #define BUILTIN_OFFSETOF_REQUIRES_CPP 0 #endif #if ((!BUILTIN_OFFSETOF_REQUIRES_CPP || defined(__cplusplus)) && \ ((defined(_MSC_VER) && (_MSC_VER >= 1910)) || \ defined(__clang__)) && \ (!defined(__RESHARPER__) && !defined(__INTELLISENSE__))) #undef FIELD_OFFSET #undef UFIELD_OFFSET #define FIELD_OFFSET(type, field) ((LONG)(LONG_PTR)__builtin_offsetof(type, field)) #define UFIELD_OFFSET(type, field) ((ULONG)(LONG_PTR)__builtin_offsetof(type, field)) #undef CONTAINING_RECORD #define CONTAINING_RECORD(address, type, field) ((type *)( \ (PCHAR)(address) - \ (ULONG_PTR)(__builtin_offsetof(type, field)))) #endif #define PAGE_SIZE 0x1000 #define ALIGN_DOWN(length, type) \ ((ULONG_PTR)(length) & ~(sizeof(type) - 1)) #define ALIGN_UP(length, type) \ (ALIGN_DOWN(((ULONG_PTR)(length) + sizeof(type) - 1), type)) #define MIN(a,b) (((a) < (b)) ? (a) : (b)) #define MAX(a,b) (((a) > (b)) ? (a) : (b)) typedef _Return_type_success_(return >= 0) LONG NTSTATUS, *PNTSTATUS; typedef LONG KPRIORITY, *PKPRIORITY; typedef ULONG LOGICAL, *PLOGICAL; typedef enum _NT_PRODUCT_TYPE { NtProductWinNt = 1, NtProductLanManNt, NtProductServer } NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE; typedef enum _SUITE_TYPE { SmallBusiness, Enterprise, BackOffice, CommunicationServer, TerminalServer, SmallBusinessRestricted, EmbeddedNT, DataCenter, SingleUserTS, Personal, Blade, EmbeddedRestricted, SecurityAppliance, StorageServer, ComputeServer, WHServer, PhoneNT, MaxSuiteType } SUITE_TYPE; typedef struct _CLIENT_ID { HANDLE UniqueProcess; HANDLE UniqueThread; } CLIENT_ID, *PCLIENT_ID; enum KPROCESSOR_MODE { KernelMode, UserMode }; typedef enum _KTHREAD_STATE { Initialized, Ready, Running, Standby, Terminated, Waiting, Transition, DeferredReady, GateWaitObsolete, WaitingForProcessInSwap, MaximumThreadState } KTHREAD_STATE, *PKTHREAD_STATE; typedef enum _KWAIT_REASON { Executive, FreePage, PageIn, PoolAllocation, DelayExecution, Suspended, UserRequest, WrExecutive, WrFreePage, WrPageIn, WrPoolAllocation, WrDelayExecution, WrSuspended, WrUserRequest, WrEventPair, WrQueue, WrLpcReceive, WrLpcReply, WrVirtualMemory, WrPageOut, WrRendezvous, WrKeyedEvent, WrTerminated, WrProcessInSwap, WrCpuRateControl, WrCalloutStack, WrKernel, WrResource, WrPushLock, WrMutex, WrQuantumEnd, WrDispatchInt, WrPreempted, WrYieldExecution, WrFastMutex, WrGuardedMutex, WrRundown, WrAlertByThreadId, WrDeferredPreempt, WrPhysicalFault, MaximumWaitReason } KWAIT_REASON; typedef enum _EVENT_TYPE { NotificationEvent, SynchronizationEvent } EVENT_TYPE; typedef enum _TIMER_TYPE { NotificationTimer, SynchronizationTimer } TIMER_TYPE; typedef enum _WAIT_TYPE { WaitAll, WaitAny, WaitNotification, WaitDequeue } WAIT_TYPE; typedef enum _SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2 } SECTION_INHERIT; #define HARDERROR_OVERRIDE_ERRORMODE 0x10000000 typedef enum _HARDERROR_RESPONSE_OPTION { OptionAbortRetryIgnore, OptionOk, OptionOkCancel, OptionRetryCancel, OptionYesNo, OptionYesNoCancel, OptionShutdownSystem, OptionOkNoWait, OptionCancelTryContinue } HARDERROR_RESPONSE_OPTION, *PHARDERROR_RESPONSE_OPTION; typedef enum _HARDERROR_RESPONSE { ResponseReturnToCaller, ResponseNotHandled, ResponseAbort, ResponseCancel, ResponseIgnore, ResponseNo, ResponseOk, ResponseRetry, ResponseYes, ResponseTryAgain, ResponseContinue } HARDERROR_RESPONSE, *PHARDERROR_RESPONSE; typedef struct _UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } UNICODE_STRING, *PUNICODE_STRING; typedef const UNICODE_STRING* PCUNICODE_STRING; #define DECLARE_UNICODE_STRING_SIZE(_var, _size) \ WCHAR _var ## _buffer[_size]; \ __pragma(warning(push)) \ __pragma(warning(disable:4221)) __pragma(warning(disable:4204)) \ UNICODE_STRING _var = { 0, (_size) * sizeof(WCHAR) , _var ## _buffer } \ __pragma(warning(pop)) #define DECLARE_STATIC_UNICODE_STRING_SIZE(_var, _size) \ WCHAR _var ## _buffer[_size]; \ __pragma(warning(push)) \ __pragma(warning(disable:4221)) __pragma(warning(disable:4204)) \ static UNICODE_STRING _var = { 0, (_size) * sizeof(WCHAR) , _var ## _buffer } \ __pragma(warning(pop)) #if !defined(__cplusplus) #define RTL_CONSTANT_STRING(s) { sizeof(s) - sizeof(*(s)), sizeof(s), (PWSTR)(s) } #define RTL_CONSTANT_ANSI_STRING(s) { sizeof(s) - sizeof(*(s)), sizeof(s), (PSTR)(s) } #else extern "C++" { template <typename T> struct remove_constref { typedef T type; }; template <typename T> struct remove_constref<const T> { typedef T type; }; template <typename T> struct remove_constref<T &> { typedef T type; }; template <typename T> struct remove_constref<const T &> { typedef T type; }; template <typename T> struct remove_constref < T && > { typedef T type; }; template <typename T> struct remove_constref < const T && > { typedef T type; }; } #define RTL_CONSTANT_STRING(s) { sizeof(s) - sizeof(*(s)), sizeof(s), (remove_constref<decltype(*(s))>::type*)(s) } #define RTL_CONSTANT_ANSI_STRING(s) RTL_CONSTANT_STRING(s) #endif FORCEINLINE VOID RtlInitEmptyUnicodeString( _Out_ PUNICODE_STRING UnicodeString, _In_ PWCHAR Buffer, _In_ USHORT BufferSize) { UnicodeString->Length = 0; UnicodeString->MaximumLength = BufferSize; UnicodeString->Buffer = Buffer; } typedef struct _STRING { USHORT Length; USHORT MaximumLength; PCHAR Buffer; } STRING, *PSTRING, ANSI_STRING, *PANSI_STRING, OEM_STRING, *POEM_STRING; typedef struct _SYSTEM_SESSION_PROCESS_INFORMATION { ULONG SessionId; ULONG SizeOfBuf; PVOID Buffer; } SYSTEM_SESSION_PROCESS_INFORMATION, *PSYSTEM_SESSION_PROCESS_INFORMATION; typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION { BOOLEAN KernelDebuggerEnabled; BOOLEAN KernelDebuggerNotPresent; } SYSTEM_KERNEL_DEBUGGER_INFORMATION, *PSYSTEM_KERNEL_DEBUGGER_INFORMATION; typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX { BOOLEAN DebuggerAllowed; BOOLEAN DebuggerEnabled; BOOLEAN DebuggerPresent; } SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX, *PSYSTEM_KERNEL_DEBUGGER_INFORMATION_EX; typedef struct _LDT_INFORMATION { ULONG Start; ULONG Length; LDT_ENTRY LdtEntries[1]; } PROCESS_LDT_INFORMATION, *PPROCESS_LDT_INFORMATION; typedef struct _KERNEL_USER_TIMES { LARGE_INTEGER CreateTime; LARGE_INTEGER ExitTime; LARGE_INTEGER KernelTime; LARGE_INTEGER UserTime; } KERNEL_USER_TIMES, *PKERNEL_USER_TIMES; typedef struct _SYSTEM_THREAD_INFORMATION { LARGE_INTEGER KernelTime; LARGE_INTEGER UserTime; LARGE_INTEGER CreateTime; ULONG WaitTime; PVOID StartAddress; CLIENT_ID ClientId; KPRIORITY Priority; LONG BasePriority; ULONG ContextSwitches; KTHREAD_STATE ThreadState; KWAIT_REASON WaitReason; } SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION; typedef struct _SYSTEM_EXTENDED_THREAD_INFORMATION { SYSTEM_THREAD_INFORMATION ThreadInfo; PVOID StackBase; PVOID StackLimit; PVOID Win32StartAddress; _TEB* TebBase; // since Vista ULONG_PTR Reserved2; ULONG_PTR Reserved3; ULONG_PTR Reserved4; } SYSTEM_EXTENDED_THREAD_INFORMATION, *PSYSTEM_EXTENDED_THREAD_INFORMATION; typedef union _ENERGY_STATE_DURATION { ULONGLONG Value; struct { ULONG LastChangeTime; ULONG Duration : 31; ULONG IsInState : 1; } s; } ENERGY_STATE_DURATION, *PENERGY_STATE_DURATION; typedef struct _PROCESS_ENERGY_VALUES { ULONGLONG Cycles[4][2]; ULONGLONG DiskEnergy; ULONGLONG NetworkTailEnergy; ULONGLONG MBBTailEnergy; ULONGLONG NetworkTxRxBytes; ULONGLONG MBBTxRxBytes; union { ENERGY_STATE_DURATION Durations[3]; struct { ENERGY_STATE_DURATION ForegroundDuration; ENERGY_STATE_DURATION DesktopVisibleDuration; ENERGY_STATE_DURATION PSMForegroundDuration; } s; } u; ULONG CompositionRendered; ULONG CompositionDirtyGenerated; ULONG CompositionDirtyPropagated; ULONG Reserved1; ULONGLONG AttributedCycles[4][2]; ULONGLONG WorkOnBehalfCycles[4][2]; } PROCESS_ENERGY_VALUES, *PPROCESS_ENERGY_VALUES; typedef struct _PROCESS_DISK_COUNTERS { ULONGLONG BytesRead; ULONGLONG BytesWritten; ULONGLONG ReadOperationCount; ULONGLONG WriteOperationCount; ULONGLONG FlushOperationCount; } PROCESS_DISK_COUNTERS, *PPROCESS_DISK_COUNTERS; typedef enum _SYSTEM_PROCESS_CLASSIFICATION { SystemProcessClassificationNormal, SystemProcessClassificationSystem, SystemProcessClassificationSecureSystem, SystemProcessClassificationMemCompression, SystemProcessClassificationRegistry, SystemProcessClassificationMaximum } SYSTEM_PROCESS_CLASSIFICATION; typedef struct _SYSTEM_PROCESS_INFORMATION_EXTENSION { PROCESS_DISK_COUNTERS DiskCounters; ULONGLONG ContextSwitches; union { ULONG Flags; struct { ULONG HasStrongId : 1; ULONG Classification : 4; // SYSTEM_PROCESS_CLASSIFICATION ULONG BackgroundActivityModerated : 1; ULONG Spare : 26; } s; } u; ULONG UserSidOffset; ULONG PackageFullNameOffset; PROCESS_ENERGY_VALUES EnergyValues; ULONG AppIdOffset; SIZE_T SharedCommitCharge; ULONG JobObjectId; ULONG SpareUlong; ULONGLONG ProcessSequenceNumber; } SYSTEM_PROCESS_INFORMATION_EXTENSION, *PSYSTEM_PROCESS_INFORMATION_EXTENSION; typedef struct _HV_DETAILS { ULONG Data[4]; } HV_DETAILS, *PHV_DETAILS; typedef struct _SYSTEM_HYPERVISOR_DETAIL_INFORMATION { HV_DETAILS HvVendorAndMaxFunction; HV_DETAILS HypervisorInterface; HV_DETAILS HypervisorVersion; HV_DETAILS HvFeatures; HV_DETAILS HwFeatures; HV_DETAILS EnlightenmentInfo; HV_DETAILS ImplementationLimits; } SYSTEM_HYPERVISOR_DETAIL_INFORMATION, *PSYSTEM_HYPERVISOR_DETAIL_INFORMATION; typedef struct _SYSTEM_PROCESS_INFORMATION { ULONG NextEntryOffset; ULONG NumberOfThreads; LARGE_INTEGER WorkingSetPrivateSize; // Since Vista ULONG HardFaultCount; // Since Windows 7 ULONG NumberOfThreadsHighWatermark; // Since Windows 7 ULONGLONG CycleTime; // Since Windows 7 LARGE_INTEGER CreateTime; LARGE_INTEGER UserTime; LARGE_INTEGER KernelTime; UNICODE_STRING ImageName; KPRIORITY BasePriority; HANDLE UniqueProcessId; HANDLE InheritedFromUniqueProcessId; ULONG HandleCount; ULONG SessionId; ULONG_PTR UniqueProcessKey; // Since Vista (requires SystemExtendedProcessInformation) SIZE_T PeakVirtualSize; SIZE_T VirtualSize; ULONG PageFaultCount; SIZE_T PeakWorkingSetSize; SIZE_T WorkingSetSize; SIZE_T QuotaPeakPagedPoolUsage; SIZE_T QuotaPagedPoolUsage; SIZE_T QuotaPeakNonPagedPoolUsage; SIZE_T QuotaNonPagedPoolUsage; SIZE_T PagefileUsage; SIZE_T PeakPagefileUsage; SIZE_T PrivatePageCount; LARGE_INTEGER ReadOperationCount; LARGE_INTEGER WriteOperationCount; LARGE_INTEGER OtherOperationCount; LARGE_INTEGER ReadTransferCount; LARGE_INTEGER WriteTransferCount; LARGE_INTEGER OtherTransferCount; SYSTEM_THREAD_INFORMATION Threads[1]; // SystemProcessInformation // SYSTEM_EXTENDED_THREAD_INFORMATION Threads[1]; // SystemExtendedProcessinformation // SYSTEM_EXTENDED_THREAD_INFORMATION + SYSTEM_PROCESS_INFORMATION_EXTENSION // SystemFullProcessInformation } SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION; typedef struct _PROCESS_SESSION_INFORMATION { ULONG SessionId; } PROCESS_SESSION_INFORMATION, *PPROCESS_SESSION_INFORMATION; // File attribute values #define FILE_ATTRIBUTE_READONLY 0x00000001 #define FILE_ATTRIBUTE_HIDDEN 0x00000002 #define FILE_ATTRIBUTE_SYSTEM 0x00000004 #define FILE_ATTRIBUTE_DIRECTORY 0x00000010 #define FILE_ATTRIBUTE_ARCHIVE 0x00000020 #define FILE_ATTRIBUTE_DEVICE 0x00000040 #define FILE_ATTRIBUTE_NORMAL 0x00000080 #define FILE_ATTRIBUTE_TEMPORARY 0x00000100 #define FILE_ATTRIBUTE_SPARSE_FILE 0x00000200 #define FILE_ATTRIBUTE_REPARSE_POINT 0x00000400 #define FILE_ATTRIBUTE_COMPRESSED 0x00000800 #define FILE_ATTRIBUTE_OFFLINE 0x00001000 #define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000 #define FILE_ATTRIBUTE_ENCRYPTED 0x00004000 #define FILE_ATTRIBUTE_INTEGRITY_STREAM 0x00008000 #define FILE_ATTRIBUTE_VIRTUAL 0x00010000 #define FILE_ATTRIBUTE_NO_SCRUB_DATA 0x00020000 #define FILE_ATTRIBUTE_EA 0x00040000 #define FILE_ATTRIBUTE_PINNED 0x00080000 #define FILE_ATTRIBUTE_UNPINNED 0x00100000 #define FILE_ATTRIBUTE_RECALL_ON_OPEN 0x00040000 #define FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS 0x00400000 #if NTDDI_VERSION < NTDDI_WIN8 #define FILE_ATTRIBUTE_VALID_FLAGS 0x00007fb7 #define FILE_ATTRIBUTE_VALID_SET_FLAGS 0x000031a7 #elif NTDDI_VERSION < NTDDI_WIN10_RS2 #define FILE_ATTRIBUTE_VALID_FLAGS 0x0002ffb7 #define FILE_ATTRIBUTE_VALID_SET_FLAGS 0x000231a7 #else #define FILE_ATTRIBUTE_VALID_FLAGS 0x005affb7 #define FILE_ATTRIBUTE_VALID_SET_FLAGS 0x001a31a7 #endif // File create disposition values #define FILE_SUPERSEDE 0x00000000 #define FILE_OPEN 0x00000001 #define FILE_CREATE 0x00000002 #define FILE_OPEN_IF 0x00000003 #define FILE_OVERWRITE 0x00000004 #define FILE_OVERWRITE_IF 0x00000005 #define FILE_MAXIMUM_DISPOSITION 0x00000005 // File create/open option flags #define FILE_DIRECTORY_FILE 0x00000001 #define FILE_WRITE_THROUGH 0x00000002 #define FILE_SEQUENTIAL_ONLY 0x00000004 #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008 #define FILE_SYNCHRONOUS_IO_ALERT 0x00000010 #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020 #define FILE_NON_DIRECTORY_FILE 0x00000040 #define FILE_CREATE_TREE_CONNECTION 0x00000080 #define FILE_COMPLETE_IF_OPLOCKED 0x00000100 #define FILE_NO_EA_KNOWLEDGE 0x00000200 #define FILE_OPEN_FOR_RECOVERY 0x00000400 #define FILE_RANDOM_ACCESS 0x00000800 #define FILE_DELETE_ON_CLOSE 0x00001000 #define FILE_OPEN_BY_FILE_ID 0x00002000 #define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000 #define FILE_NO_COMPRESSION 0x00008000 #if NTDDI_VERSION >= NTDDI_WIN7 #define FILE_OPEN_REQUIRING_OPLOCK 0x00010000 #define FILE_DISALLOW_EXCLUSIVE 0x00020000 #endif #if NTDDI_VERSION >= NTDDI_WIN8 #define FILE_SESSION_AWARE 0x00040000 #endif #define FILE_RESERVE_OPFILTER 0x00100000 #define FILE_OPEN_REPARSE_POINT 0x00200000 #define FILE_OPEN_NO_RECALL 0x00400000 #define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000 #define FILE_VALID_OPTION_FLAGS 0x00ffffff #define FILE_VALID_PIPE_OPTION_FLAGS 0x00000032 #define FILE_VALID_MAILSLOT_OPTION_FLAGS 0x00000032 #define FILE_VALID_SET_FLAGS 0x00000036 // Named pipe type flags #define FILE_PIPE_BYTE_STREAM_TYPE 0x00000000 #define FILE_PIPE_MESSAGE_TYPE 0x00000001 #define FILE_PIPE_ACCEPT_REMOTE_CLIENTS 0x00000000 #define FILE_PIPE_REJECT_REMOTE_CLIENTS 0x00000002 #define FILE_PIPE_TYPE_VALID_MASK 0x00000003 // Named pipe completion mode flags #define FILE_PIPE_QUEUE_OPERATION 0x00000000 #define FILE_PIPE_COMPLETE_OPERATION 0x00000001 // Named pipe read mode flags #define FILE_PIPE_BYTE_STREAM_MODE 0x00000000 #define FILE_PIPE_MESSAGE_MODE 0x00000001 // NamedPipeConfiguration flags #define FILE_PIPE_INBOUND 0x00000000 #define FILE_PIPE_OUTBOUND 0x00000001 #define FILE_PIPE_FULL_DUPLEX 0x00000002 // NamedPipeState flags #define FILE_PIPE_DISCONNECTED_STATE 0x00000001 #define FILE_PIPE_LISTENING_STATE 0x00000002 #define FILE_PIPE_CONNECTED_STATE 0x00000003 #define FILE_PIPE_CLOSING_STATE 0x00000004 // NamedPipeEnd flags #define FILE_PIPE_CLIENT_END 0x00000000 #define FILE_PIPE_SERVER_END 0x00000001 typedef struct _FILE_BASIC_INFORMATION { LARGE_INTEGER CreationTime; LARGE_INTEGER LastAccessTime; LARGE_INTEGER LastWriteTime; LARGE_INTEGER ChangeTime; ULONG FileAttributes; } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION; typedef struct _FILE_STANDARD_INFORMATION { LARGE_INTEGER AllocationSize; LARGE_INTEGER EndOfFile; ULONG NumberOfLinks; BOOLEAN DeletePending; BOOLEAN Directory; } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION; typedef struct _FILE_STANDARD_INFORMATION_EX { LARGE_INTEGER AllocationSize; LARGE_INTEGER EndOfFile; ULONG NumberOfLinks; BOOLEAN DeletePending; BOOLEAN Directory; BOOLEAN AlternateStream; BOOLEAN MetadataAttribute; } FILE_STANDARD_INFORMATION_EX, *PFILE_STANDARD_INFORMATION_EX; typedef struct _FILE_INTERNAL_INFORMATION { union { LARGE_INTEGER IndexNumber; struct { LONGLONG MftRecordIndex : 48; LONGLONG SequenceNumber : 16; } s; } u; } FILE_INTERNAL_INFORMATION, *PFILE_INTERNAL_INFORMATION; typedef struct _FILE_EA_INFORMATION { ULONG EaSize; } FILE_EA_INFORMATION, *PFILE_EA_INFORMATION; typedef struct _FILE_ACCESS_INFORMATION { ACCESS_MASK AccessFlags; } FILE_ACCESS_INFORMATION, *PFILE_ACCESS_INFORMATION; typedef struct _FILE_POSITION_INFORMATION { LARGE_INTEGER CurrentByteOffset; } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION; typedef struct _FILE_MODE_INFORMATION { ULONG Mode; } FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION; typedef struct _FILE_ALIGNMENT_INFORMATION { ULONG AlignmentRequirement; } FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION; typedef struct _FILE_NAME_INFORMATION { ULONG FileNameLength; _Field_size_bytes_(FileNameLength) WCHAR FileName[1]; } FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION; typedef struct _FILE_ALL_INFORMATION { FILE_BASIC_INFORMATION BasicInformation; FILE_STANDARD_INFORMATION StandardInformation; FILE_INTERNAL_INFORMATION InternalInformation; FILE_EA_INFORMATION EaInformation; FILE_ACCESS_INFORMATION AccessInformation; FILE_POSITION_INFORMATION PositionInformation; FILE_MODE_INFORMATION ModeInformation; FILE_ALIGNMENT_INFORMATION AlignmentInformation; FILE_NAME_INFORMATION NameInformation; } FILE_ALL_INFORMATION, *PFILE_ALL_INFORMATION; typedef struct _FILE_NETWORK_OPEN_INFORMATION { LARGE_INTEGER CreationTime; LARGE_INTEGER LastAccessTime; LARGE_INTEGER LastWriteTime; LARGE_INTEGER ChangeTime; LARGE_INTEGER AllocationSize; LARGE_INTEGER EndOfFile; ULONG FileAttributes; } FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION; typedef struct _FILE_ATTRIBUTE_TAG_INFORMATION { ULONG FileAttributes; ULONG ReparseTag; } FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION; typedef struct _FILE_ALLOCATION_INFORMATION { LARGE_INTEGER AllocationSize; } FILE_ALLOCATION_INFORMATION, *PFILE_ALLOCATION_INFORMATION; typedef struct _FILE_COMPRESSION_INFORMATION { LARGE_INTEGER CompressedFileSize; USHORT CompressionFormat; UCHAR CompressionUnitShift; UCHAR ChunkShift; UCHAR ClusterShift; UCHAR Reserved[3]; } FILE_COMPRESSION_INFORMATION, *PFILE_COMPRESSION_INFORMATION; typedef struct _FILE_DISPOSITION_INFORMATION { BOOLEAN DeleteFile; } FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION; typedef struct _FILE_END_OF_FILE_INFORMATION { LARGE_INTEGER EndOfFile; } FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION; typedef struct _FILE_VALID_DATA_LENGTH_INFORMATION { LARGE_INTEGER ValidDataLength; } FILE_VALID_DATA_LENGTH_INFORMATION, *PFILE_VALID_DATA_LENGTH_INFORMATION; #define FILE_LINK_REPLACE_IF_EXISTS 0x00000001 // since RS5 #define FILE_LINK_POSIX_SEMANTICS 0x00000002 #define FILE_LINK_SUPPRESS_STORAGE_RESERVE_INHERITANCE 0x00000008 #define FILE_LINK_NO_INCREASE_AVAILABLE_SPACE 0x00000010 #define FILE_LINK_NO_DECREASE_AVAILABLE_SPACE 0x00000020 #define FILE_LINK_PRESERVE_AVAILABLE_SPACE 0x00000030 #define FILE_LINK_IGNORE_READONLY_ATTRIBUTE 0x00000040 #define FILE_LINK_FORCE_RESIZE_TARGET_SR 0x00000080 // since 19H1 #define FILE_LINK_FORCE_RESIZE_SOURCE_SR 0x00000100 #define FILE_LINK_FORCE_RESIZE_SR 0x00000180 typedef struct _FILE_LINK_INFORMATION { BOOLEAN ReplaceIfExists; HANDLE RootDirectory; ULONG FileNameLength; _Field_size_bytes_(FileNameLength) WCHAR FileName[1]; } FILE_LINK_INFORMATION, *PFILE_LINK_INFORMATION; typedef struct _FILE_LINK_INFORMATION_EX { ULONG Flags; HANDLE RootDirectory; ULONG FileNameLength; _Field_size_bytes_(FileNameLength) WCHAR FileName[1]; } FILE_LINK_INFORMATION_EX, *PFILE_LINK_INFORMATION_EX; typedef struct _FILE_MOVE_CLUSTER_INFORMATION { ULONG ClusterCount; HANDLE RootDirectory; ULONG FileNameLength; _Field_size_bytes_(FileNameLength) WCHAR FileName[1]; } FILE_MOVE_CLUSTER_INFORMATION, *PFILE_MOVE_CLUSTER_INFORMATION; typedef struct _FILE_RENAME_INFORMATION { BOOLEAN ReplaceIfExists; HANDLE RootDirectory; ULONG FileNameLength; _Field_size_bytes_(FileNameLength) WCHAR FileName[1]; } FILE_RENAME_INFORMATION, *PFILE_RENAME_INFORMATION; #define FILE_RENAME_REPLACE_IF_EXISTS 0x00000001 // since REDSTONE #define FILE_RENAME_POSIX_SEMANTICS 0x00000002 #define FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE 0x00000004 // since REDSTONE3 #define FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE 0x00000008 // since REDSTONE5 #define FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE 0x00000010 #define FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE 0x00000020 #define FILE_RENAME_PRESERVE_AVAILABLE_SPACE 0x00000030 #define FILE_RENAME_IGNORE_READONLY_ATTRIBUTE 0x00000040 #define FILE_RENAME_FORCE_RESIZE_TARGET_SR 0x00000080 // since 19H1 #define FILE_RENAME_FORCE_RESIZE_SOURCE_SR 0x00000100 #define FILE_RENAME_FORCE_RESIZE_SR 0x00000180 typedef struct _FILE_RENAME_INFORMATION_EX { ULONG Flags; HANDLE RootDirectory; ULONG FileNameLength; _Field_size_bytes_(FileNameLength) WCHAR FileName[1]; } FILE_RENAME_INFORMATION_EX, *PFILE_RENAME_INFORMATION_EX; typedef struct _FILE_STREAM_INFORMATION { ULONG NextEntryOffset; ULONG StreamNameLength; LARGE_INTEGER StreamSize; LARGE_INTEGER StreamAllocationSize; _Field_size_bytes_(StreamNameLength) WCHAR StreamName[1]; } FILE_STREAM_INFORMATION, *PFILE_STREAM_INFORMATION; typedef struct _FILE_TRACKING_INFORMATION { HANDLE DestinationFile; ULONG ObjectInformationLength; _Field_size_bytes_(ObjectInformationLength) CHAR ObjectInformation[1]; } FILE_TRACKING_INFORMATION, *PFILE_TRACKING_INFORMATION; typedef struct _FILE_COMPLETION_INFORMATION { HANDLE Port; PVOID Key; } FILE_COMPLETION_INFORMATION, *PFILE_COMPLETION_INFORMATION; typedef struct _FILE_PROCESS_IDS_USING_FILE_INFORMATION { ULONG NumberOfProcessIdsInList; ULONG_PTR ProcessIdList[1]; } FILE_PROCESS_IDS_USING_FILE_INFORMATION, *PFILE_PROCESS_IDS_USING_FILE_INFORMATION; // Privileges #define SE_MIN_WELL_KNOWN_PRIVILEGE (2L) #define SE_CREATE_TOKEN_PRIVILEGE (2L) #define SE_ASSIGNPRIMARYTOKEN_PRIVILEGE (3L) #define SE_LOCK_MEMORY_PRIVILEGE (4L) #define SE_INCREASE_QUOTA_PRIVILEGE (5L) #define SE_MACHINE_ACCOUNT_PRIVILEGE (6L) #define SE_TCB_PRIVILEGE (7L) #define SE_SECURITY_PRIVILEGE (8L) #define SE_TAKE_OWNERSHIP_PRIVILEGE (9L) #define SE_LOAD_DRIVER_PRIVILEGE (10L) #define SE_SYSTEM_PROFILE_PRIVILEGE (11L) #define SE_SYSTEMTIME_PRIVILEGE (12L) #define SE_PROF_SINGLE_PROCESS_PRIVILEGE (13L) #define SE_INC_BASE_PRIORITY_PRIVILEGE (14L) #define SE_CREATE_PAGEFILE_PRIVILEGE (15L) #define SE_CREATE_PERMANENT_PRIVILEGE (16L) #define SE_BACKUP_PRIVILEGE (17L) #define SE_RESTORE_PRIVILEGE (18L) #define SE_SHUTDOWN_PRIVILEGE (19L) #define SE_DEBUG_PRIVILEGE (20L) #define SE_AUDIT_PRIVILEGE (21L) #define SE_SYSTEM_ENVIRONMENT_PRIVILEGE (22L) #define SE_CHANGE_NOTIFY_PRIVILEGE (23L) #define SE_REMOTE_SHUTDOWN_PRIVILEGE (24L) #define SE_UNDOCK_PRIVILEGE (25L) #define SE_SYNC_AGENT_PRIVILEGE (26L) #define SE_ENABLE_DELEGATION_PRIVILEGE (27L) #define SE_MANAGE_VOLUME_PRIVILEGE (28L) #define SE_IMPERSONATE_PRIVILEGE (29L) #define SE_CREATE_GLOBAL_PRIVILEGE (30L) #define SE_TRUSTED_CREDMAN_ACCESS_PRIVILEGE (31L) #define SE_RELABEL_PRIVILEGE (32L) #define SE_INC_WORKING_SET_PRIVILEGE (33L) #define SE_TIME_ZONE_PRIVILEGE (34L) #define SE_CREATE_SYMBOLIC_LINK_PRIVILEGE (35L) #define SE_MAX_WELL_KNOWN_PRIVILEGE SE_CREATE_SYMBOLIC_LINK_PRIVILEGE typedef struct _THREAD_BASIC_INFORMATION { NTSTATUS ExitStatus; PVOID TebBaseAddress; CLIENT_ID ClientId; ULONG_PTR AffinityMask; KPRIORITY Priority; LONG BasePriority; } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION; typedef struct _MEMORY_REGION_INFORMATION { PVOID AllocationBase; ULONG AllocationProtect; union { ULONG RegionType; struct { ULONG Private : 1; ULONG MappedDataFile : 1; ULONG MappedImage : 1; ULONG MappedPageFile : 1; ULONG MappedPhysical : 1; ULONG DirectMapped : 1; ULONG SoftwareEnclave : 1; //REDSTONE3 ULONG PageSize64K : 1; ULONG Reserved : 24; } s; } u; SIZE_T RegionSize; SIZE_T CommitSize; } MEMORY_REGION_INFORMATION, *PMEMORY_REGION_INFORMATION; typedef struct _MEMORY_IMAGE_INFORMATION { PVOID ImageBase; SIZE_T SizeOfImage; union { ULONG ImageFlags; struct { ULONG ImagePartialMap : 1; ULONG ImageNotExecutable : 1; ULONG ImageSigningLevel : 1; // REDSTONE3 ULONG Reserved : 30; } s1; } u1; } MEMORY_IMAGE_INFORMATION, *PMEMORY_IMAGE_INFORMATION; typedef struct _SECTION_BASIC_INFORMATION { PVOID BaseAddress; ULONG AllocationAttributes; LARGE_INTEGER MaximumSize; } SECTION_BASIC_INFORMATION, *PSECTION_BASIC_INFORMATION; typedef struct _SECTION_IMAGE_INFORMATION { PVOID TransferAddress; // Entry point ULONG ZeroBits; SIZE_T MaximumStackSize; SIZE_T CommittedStackSize; ULONG SubSystemType; union { struct { USHORT SubSystemMinorVersion; USHORT SubSystemMajorVersion; } s1; ULONG SubSystemVersion; } u1; union { struct { USHORT MajorOperatingSystemVersion; USHORT MinorOperatingSystemVersion; } s2; ULONG OperatingSystemVersion; } u2; USHORT ImageCharacteristics; USHORT DllCharacteristics; USHORT Machine; BOOLEAN ImageContainsCode; union { UCHAR ImageFlags; struct { UCHAR ComPlusNativeReady : 1; UCHAR ComPlusILOnly : 1; UCHAR ImageDynamicallyRelocated : 1; UCHAR ImageMappedFlat : 1; UCHAR BaseBelow4gb : 1; UCHAR ComPlusPrefer32bit : 1; UCHAR Reserved : 2; } s3; } u3; ULONG LoaderFlags; ULONG ImageFileSize; ULONG CheckSum; } SECTION_IMAGE_INFORMATION, *PSECTION_IMAGE_INFORMATION; typedef struct _SECTION_INTERNAL_IMAGE_INFORMATION { SECTION_IMAGE_INFORMATION SectionInformation; union { ULONG ExtendedFlags; struct { ULONG ImageExportSuppressionEnabled : 1; ULONG Reserved : 31; } s; } u; } SECTION_INTERNAL_IMAGE_INFORMATION, *PSECTION_INTERNAL_IMAGE_INFORMATION; typedef struct _IMAGE_INFO { union { ULONG Properties; struct { ULONG ImageAddressingMode : 8; // Code addressing mode ULONG SystemModeImage : 1; // System mode image ULONG ImageMappedToAllPids : 1; // Image mapped into all processes ULONG ExtendedInfoPresent : 1; // IMAGE_INFO_EX available ULONG MachineTypeMismatch : 1; // Architecture type mismatch ULONG ImageSignatureLevel : 4; // Signature level ULONG ImageSignatureType : 3; // Signature type ULONG ImagePartialMap : 1; // Nonzero if entire image is not mapped ULONG Reserved : 12; } s1; } u1; PVOID ImageBase; ULONG ImageSelector; SIZE_T ImageSize; ULONG ImageSectionNumber; } IMAGE_INFO, *PIMAGE_INFO; typedef struct _PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION { ULONG Version; // Set to 0 for x64, 1 for native x86, and use as PVOID Callback on WOW64 ULONG Reserved; PVOID Callback; } PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION, *PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION; typedef struct _THREAD_LAST_SYSCALL_INFORMATION { PVOID FirstArgument; USHORT SystemCallNumber; #ifdef _WIN64 USHORT Pad[0x3]; #else USHORT Pad[0x1]; #endif ULONG64 WaitTime; // may be omitted } THREAD_LAST_SYSCALL_INFORMATION, *PTHREAD_LAST_SYSCALL_INFORMATION; typedef struct _OBJECT_ATTRIBUTES { ULONG Length; HANDLE RootDirectory; PUNICODE_STRING ObjectName; ULONG Attributes; PVOID SecurityDescriptor; PVOID SecurityQualityOfService; } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES; // https://stackoverflow.com/questions/36961152/detect-windows-kit-8-0-and-windows-kit-8-1-sdks #if defined(WINAPI_PARTITION_APP) #if defined(WINAPI_FAMILY_SYSTEM) #define USING_WINDOWS_10_SDK #elif (WINAPI_PARTITION_APP == 0x00000002) || (WINAPI_PARTITION_APP == 1) #define USING_WINDOWS_8_x_SDK #endif #endif // This struct was included in winnt.h starting in the Windows 8.0 SDK #if !(defined(USING_WINDOWS_8_x_SDK) || defined(USING_WINDOWS_10_SDK)) typedef struct _EXCEPTION_REGISTRATION_RECORD { _EXCEPTION_REGISTRATION_RECORD* Next; _EXCEPTION_DISPOSITION Handler; } EXCEPTION_REGISTRATION_RECORD, *PEXCEPTION_REGISTRATION_RECORD; #endif #define LDR_GET_DLL_HANDLE_EX_UNCHANGED_REFCOUNT 0x00000001 #define LDR_GET_DLL_HANDLE_EX_PIN 0x00000002 #define LDR_GET_PROCEDURE_ADDRESS_EX_DONT_RECORD_FORWARDER 0x00000001 #define LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS 0x00000001 #define LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY 0x00000002 #define LDR_LOCK_LOADER_LOCK_DISPOSITION_INVALID 0 #define LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED 1 #define LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED 2 #define LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS 0x00000001 typedef struct _LDR_RESOURCE_INFO { ULONG_PTR Type; ULONG_PTR Name; ULONG_PTR Language; } LDR_RESOURCE_INFO, *PLDR_RESOURCE_INFO; typedef struct _LDR_ENUM_RESOURCE_INFO { ULONG_PTR Type; ULONG_PTR Name; ULONG_PTR Language; PVOID Data; SIZE_T Size; ULONG_PTR Reserved; } LDR_ENUM_RESOURCE_INFO, *PLDR_ENUM_RESOURCE_INFO; #define LDR_FIND_RESOURCE_LANGUAGE_CAN_FALLBACK 0x00000000 #define LDR_FIND_RESOURCE_LANGUAGE_EXACT 0x00000004 #define LDR_FIND_RESOURCE_LANGUAGE_REDIRECT_VERSION 0x00000008 typedef struct _RTL_PROCESS_MODULE_INFORMATION { HANDLE Section; PVOID MappedBase; PVOID ImageBase; ULONG ImageSize; ULONG Flags; USHORT LoadOrderIndex; USHORT InitOrderIndex; USHORT LoadCount; USHORT OffsetToFileName; UCHAR FullPathName[256]; } RTL_PROCESS_MODULE_INFORMATION, *PRTL_PROCESS_MODULE_INFORMATION; typedef struct _RTL_PROCESS_MODULES { ULONG NumberOfModules; RTL_PROCESS_MODULE_INFORMATION Modules[1]; } RTL_PROCESS_MODULES, *PRTL_PROCESS_MODULES; typedef struct _RTL_PROCESS_MODULE_INFORMATION_EX { USHORT NextOffset; RTL_PROCESS_MODULE_INFORMATION BaseInfo; ULONG ImageChecksum; ULONG TimeDateStamp; PVOID DefaultBase; } RTL_PROCESS_MODULE_INFORMATION_EX, *PRTL_PROCESS_MODULE_INFORMATION_EX; typedef struct _SYSTEM_PROCESS_ID_INFORMATION { HANDLE ProcessId; UNICODE_STRING ImageName; } SYSTEM_PROCESS_ID_INFORMATION, *PSYSTEM_PROCESS_ID_INFORMATION; typedef struct _SYSTEM_HYPERVISOR_QUERY_INFORMATION { BOOLEAN HypervisorConnected; BOOLEAN HypervisorDebuggingEnabled; BOOLEAN HypervisorPresent; BOOLEAN Spare0[5]; ULONGLONG EnabledEnlightenments; } SYSTEM_HYPERVISOR_QUERY_INFORMATION, *PSYSTEM_HYPERVISOR_QUERY_INFORMATION; typedef struct _SYSTEM_CODEINTEGRITY_INFORMATION { ULONG Length; ULONG CodeIntegrityOptions; } SYSTEM_CODEINTEGRITY_INFORMATION, *PSYSTEM_CODEINTEGRITY_INFORMATION; #define CODEINTEGRITY_OPTION_ENABLED 0x01 #define CODEINTEGRITY_OPTION_TESTSIGN 0x02 #define CODEINTEGRITY_OPTION_UMCI_ENABLED 0x04 #define CODEINTEGRITY_OPTION_UMCI_AUDITMODE_ENABLED 0x08 #define CODEINTEGRITY_OPTION_UMCI_EXCLUSIONPATHS_ENABLED 0x10 #define CODEINTEGRITY_OPTION_TEST_BUILD 0x20 #define CODEINTEGRITY_OPTION_PREPRODUCTION_BUILD 0x40 #define CODEINTEGRITY_OPTION_DEBUGMODE_ENABLED 0x80 #define CODEINTEGRITY_OPTION_FLIGHT_BUILD 0x100 #define CODEINTEGRITY_OPTION_FLIGHTING_ENABLED 0x200 #define CODEINTEGRITY_OPTION_HVCI_KMCI_ENABLED 0x400 #define CODEINTEGRITY_OPTION_HVCI_KMCI_AUDITMODE_ENABLED 0x800 #define CODEINTEGRITY_OPTION_HVCI_KMCI_STRICTMODE_ENABLED 0x1000 #define CODEINTEGRITY_OPTION_HVCI_IUM_ENABLED 0x2000 #define CODEINTEGRITY_OPTION_WHQL_ENFORCEMENT_ENABLED 0x4000 #define CODEINTEGRITY_OPTION_WHQL_AUDITMODE_ENABLED 0x8000 typedef struct _SYSTEM_SECUREBOOT_POLICY_INFORMATION { GUID PolicyPublisher; ULONG PolicyVersion; ULONG PolicyOptions; } SYSTEM_SECUREBOOT_POLICY_INFORMATION, *PSYSTEM_SECUREBOOT_POLICY_INFORMATION; typedef struct _SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION { SYSTEM_SECUREBOOT_POLICY_INFORMATION PolicyInformation; ULONG PolicySize; UCHAR Policy[1]; } SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION, *PSYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION; typedef struct _SYSTEM_ISOLATED_USER_MODE_INFORMATION { BOOLEAN SecureKernelRunning : 1; BOOLEAN HvciEnabled : 1; BOOLEAN HvciStrictMode : 1; BOOLEAN DebugEnabled : 1; BOOLEAN FirmwarePageProtection : 1; BOOLEAN EncryptionKeyAvailable : 1; BOOLEAN SpareFlags : 2; BOOLEAN TrustletRunning : 1; BOOLEAN HvciDisableAllowed : 1; BOOLEAN SpareFlags2 : 6; BOOLEAN Spare0[6]; ULONGLONG Spare1; } SYSTEM_ISOLATED_USER_MODE_INFORMATION, *PSYSTEM_ISOLATED_USER_MODE_INFORMATION; typedef struct _SYSTEM_TPM_INFORMATION { ULONG Flags; } SYSTEM_TPM_INFORMATION, *PSYSTEM_TPM_INFORMATION; typedef struct _SYSTEM_VSM_PROTECTION_INFORMATION { BOOLEAN DmaProtectionsAvailable; BOOLEAN DmaProtectionsInUse; BOOLEAN HardwareMbecAvailable; BOOLEAN ApicVirtualizationAvailable; } SYSTEM_VSM_PROTECTION_INFORMATION, *PSYSTEM_VSM_PROTECTION_INFORMATION; typedef struct _SYSTEM_KERNEL_DEBUGGER_FLAGS { BOOLEAN KernelDebuggerIgnoreUmExceptions; } SYSTEM_KERNEL_DEBUGGER_FLAGS, *PSYSTEM_KERNEL_DEBUGGER_FLAGS; typedef struct _SYSTEM_SINGLE_MODULE_INFORMATION { PVOID TargetModuleAddress; RTL_PROCESS_MODULE_INFORMATION_EX ExInfo; } SYSTEM_SINGLE_MODULE_INFORMATION, *PSYSTEM_SINGLE_MODULE_INFORMATION; // SYSTEM_CODEINTEGRITYPOLICY_INFORMATION Options #define CODEINTEGRITYPOLICY_OPTION_ENABLED 0x01 #define CODEINTEGRITYPOLICY_OPTION_AUDIT 0x02 #define CODEINTEGRITYPOLICY_OPTION_REQUIRE_WHQL 0x04 #define CODEINTEGRITYPOLICY_OPTION_DISABLED_FLIGHTSIGNING 0x08 #define CODEINTEGRITYPOLICY_OPTION_ENABLED_UMCI 0x10 #define CODEINTEGRITYPOLICY_OPTION_ENABLED_UPDATE_POLICY_NOREBOOT 0x20 #define CODEINTEGRITYPOLICY_OPTION_ENABLED_SECURE_SETTING_POLICY 0x40 #define CODEINTEGRITYPOLICY_OPTION_ENABLED_UNSIGNED_SYSTEMINTEGRITY_POLICY 0x80 #define CODEINTEGRITYPOLICY_OPTION_DYNAMIC_CODE_POLICY_ENABLED 0x100 #define CODEINTEGRITYPOLICY_OPTION_RELOAD_POLICY_NO_REBOOT 0x10000000 // NtSetSystemInformation reloads SiPolicy.p7b #define CODEINTEGRITYPOLICY_OPTION_CONDITIONAL_LOCKDOWN 0x20000000 #define CODEINTEGRITYPOLICY_OPTION_NOLOCKDOWN 0x40000000 #define CODEINTEGRITYPOLICY_OPTION_LOCKDOWN 0x80000000 // SYSTEM_CODEINTEGRITYPOLICY_INFORMATION HVCIOptions #define CODEINTEGRITYPOLICY_HVCIOPTION_ENABLED 0x01 #define CODEINTEGRITYPOLICY_HVCIOPTION_STRICT 0x02 #define CODEINTEGRITYPOLICY_HVCIOPTION_DEBUG 0x04 typedef struct _SYSTEM_CODEINTEGRITYPOLICY_INFORMATION { ULONG Options; ULONG HVCIOptions; ULONGLONG Version; GUID PolicyGuid; } SYSTEM_CODEINTEGRITYPOLICY_INFORMATION, *PSYSTEM_CODEINTEGRITYPOLICY_INFORMATION; typedef struct _SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION { HANDLE ImageFile; } SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION, *PSYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION; typedef struct _SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION { union { ULONG Flags; struct { ULONG Locked : 1; ULONG UnlockApplied : 1; // Unlockable field removed 19H1 ULONG UnlockIdValid : 1; ULONG Reserved : 29; } s1; } u1; UCHAR UnlockId[32]; // REDSTONE4 } SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION, *PSYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION; typedef struct _SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION { HANDLE FileHandle; ULONG ImageSize; PVOID Image; } SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION, *PSYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION; typedef struct _SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION { ULONG ExtentCount; ULONG ValidStructureSize; ULONG NextExtentIndex; ULONG ExtentRestart; ULONG CycleCount; ULONG TimeoutCount; ULONGLONG CycleTime; ULONGLONG CycleTimeMax; ULONGLONG ExtentTime; ULONG ExtentTimeIndex; ULONG ExtentTimeMaxIndex; ULONGLONG ExtentTimeMax; ULONGLONG HyperFlushTimeMax; ULONGLONG TranslateVaTimeMax; ULONGLONG DebugExemptionCount; ULONGLONG TbHitCount; ULONGLONG TbMissCount; ULONGLONG VinaPendingYield; ULONGLONG HashCycles; ULONG HistogramOffset; ULONG HistogramBuckets; ULONG HistogramShift; ULONG Reserved1; ULONGLONG PageNotPresentCount; } SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION, *PSYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION; typedef struct _SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION { ULONG PlatformManifestSize; UCHAR PlatformManifest[1]; } SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION, *PSYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION; typedef struct _SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION { PVOID HypervisorSharedUserVa; } SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION, *PSYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION; typedef struct _SYSTEM_FIRMWARE_PARTITION_INFORMATION { UNICODE_STRING FirmwarePartition; } SYSTEM_FIRMWARE_PARTITION_INFORMATION, *PSYSTEM_FIRMWARE_PARTITION_INFORMATION; typedef struct _SYSTEM_DMA_GUARD_POLICY_INFORMATION { BOOLEAN DmaGuardPolicyEnabled; } SYSTEM_DMA_GUARD_POLICY_INFORMATION, *PSYSTEM_DMA_GUARD_POLICY_INFORMATION; typedef struct _SYSTEM_SHADOW_STACK_INFORMATION { union { ULONG Flags; struct { ULONG CetCapable : 1; ULONG UserCetAllowed : 1; ULONG ReservedForUserCet : 6; ULONG KernelCetEnabled : 1; ULONG KernelCetAuditModeEnabled : 1; ULONG ReservedForKernelCet : 6; // since Windows 10 build 21387 ULONG Reserved : 16; } s; } u; } SYSTEM_SHADOW_STACK_INFORMATION, *PSYSTEM_SHADOW_STACK_INFORMATION; typedef union _SYSTEM_BUILD_VERSION_INFORMATION_FLAGS { ULONG Value32; struct { ULONG IsTopLevel : 1; ULONG IsChecked : 1; } s; } SYSTEM_BUILD_VERSION_INFORMATION_FLAGS, *PSYSTEM_BUILD_VERSION_INFORMATION_FLAGS; typedef struct _SYSTEM_BUILD_VERSION_INFORMATION { USHORT LayerNumber; USHORT LayerCount; ULONG OsMajorVersion; ULONG OsMinorVersion; ULONG NtBuildNumber; ULONG NtBuildQfe; UCHAR LayerName[128]; UCHAR NtBuildBranch[128]; UCHAR NtBuildLab[128]; UCHAR NtBuildLabEx[128]; UCHAR NtBuildStamp[26]; UCHAR NtBuildArch[16]; SYSTEM_BUILD_VERSION_INFORMATION_FLAGS Flags; } SYSTEM_BUILD_VERSION_INFORMATION, *PSYSTEM_BUILD_VERSION_INFORMATION; typedef struct _SYSTEM_XFG_FAILURE_INFORMATION { PVOID ReturnAddress; PVOID TargetAddress; ULONG DispatchMode; ULONGLONG XfgValue; } SYSTEM_XFG_FAILURE_INFORMATION, *PSYSTEM_XFG_FAILURE_INFORMATION; typedef enum _SYSTEM_IOMMU_STATE { IommuStateBlock, IommuStateUnblock } SYSTEM_IOMMU_STATE; typedef struct _SYSTEM_IOMMU_STATE_INFORMATION { SYSTEM_IOMMU_STATE State; PVOID Pdo; } SYSTEM_IOMMU_STATE_INFORMATION, *PSYSTEM_IOMMU_STATE_INFORMATION; typedef struct _SYSTEM_HYPERVISOR_BOOT_PAGES_INFORMATION { ULONG RangeCount; ULONG_PTR RangeArray[1]; } SYSTEM_HYPERVISOR_BOOT_PAGES_INFORMATION, *PSYSTEM_HYPERVISOR_BOOT_PAGES_INFORMATION; typedef struct _SYSTEM_POINTER_AUTH_INFORMATION { union { USHORT SupportedFlags; struct { USHORT AddressAuthSupported : 1; USHORT AddressAuthQarma : 1; USHORT GenericAuthSupported : 1; USHORT GenericAuthQarma : 1; USHORT SupportedReserved : 12; } s1; } u1; union { USHORT EnabledFlags; struct { USHORT UserPerProcessIpAuthEnabled : 1; USHORT UserGlobalIpAuthEnabled : 1; USHORT UserEnabledReserved : 6; USHORT KernelIpAuthEnabled : 1; USHORT KernelEnabledReserved : 7; } s2; } u2; } SYSTEM_POINTER_AUTH_INFORMATION, *PSYSTEM_POINTER_AUTH_INFORMATION; typedef NTSTATUS NTAPI RTL_QUERY_REGISTRY_ROUTINE( _In_z_ PWSTR ValueName, _In_ ULONG ValueType, _In_opt_ PVOID ValueData, _In_ ULONG ValueLength, _In_opt_ PVOID Context, _In_opt_ PVOID EntryContext ); typedef RTL_QUERY_REGISTRY_ROUTINE* PRTL_QUERY_REGISTRY_ROUTINE; typedef struct _RTL_QUERY_REGISTRY_TABLE { PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine; ULONG Flags; PWSTR Name; PVOID EntryContext; ULONG DefaultType; PVOID DefaultData; ULONG DefaultLength; } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE; // RtlQueryRegistryValues flags #define RTL_QUERY_REGISTRY_SUBKEY 0x00000001 #define RTL_QUERY_REGISTRY_TOPKEY 0x00000002 #define RTL_QUERY_REGISTRY_REQUIRED 0x00000004 #define RTL_QUERY_REGISTRY_NOVALUE 0x00000008 #define RTL_QUERY_REGISTRY_NOEXPAND 0x00000010 #define RTL_QUERY_REGISTRY_DIRECT 0x00000020 #define RTL_QUERY_REGISTRY_DELETE 0x00000040 #define RTL_QUERY_REGISTRY_NOSTRING 0x00000080 #define RTL_QUERY_REGISTRY_TYPECHECK 0x00000100 #define RTL_QUERY_REGISTRY_TYPECHECK_SHIFT 24 #define RTL_QUERY_REGISTRY_TYPECHECK_MASK (0xff << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) // RtlWriteRegistryValue RelativeTo values #define RTL_REGISTRY_ABSOLUTE 0 // Path is a full path #define RTL_REGISTRY_SERVICES 1 // \Registry\Machine\System\CurrentControlSet\Services #define RTL_REGISTRY_CONTROL 2 // \Registry\Machine\System\CurrentControlSet\Control #define RTL_REGISTRY_WINDOWS_NT 3 // \Registry\Machine\Software\Microsoft\Windows NT\CurrentVersion #define RTL_REGISTRY_DEVICEMAP 4 // \Registry\Machine\Hardware\DeviceMap #define RTL_REGISTRY_USER 5 // \Registry\User\CurrentUser #define RTL_REGISTRY_MAXIMUM 6 #define RTL_REGISTRY_HANDLE 0x40000000 // Low order bits are registry handle #define RTL_REGISTRY_OPTIONAL 0x80000000 // Indicates the key node is optional typedef struct _PROCESS_HANDLE_INFORMATION { ULONG HandleCount; ULONG HandleCountHighWatermark; } PROCESS_HANDLE_INFORMATION, *PPROCESS_HANDLE_INFORMATION; #if NTDDI_VERSION >= NTDDI_VISTA typedef struct _PROCESS_MITIGATION_POLICY_INFORMATION { PROCESS_MITIGATION_POLICY Policy; union { PROCESS_MITIGATION_ASLR_POLICY ASLRPolicy; PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY StrictHandleCheckPolicy; PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY SystemCallDisablePolicy; PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY ExtensionPointDisablePolicy; PROCESS_MITIGATION_DYNAMIC_CODE_POLICY DynamicCodePolicy; PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY ControlFlowGuardPolicy; PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY SignaturePolicy; PROCESS_MITIGATION_FONT_DISABLE_POLICY FontDisablePolicy; PROCESS_MITIGATION_IMAGE_LOAD_POLICY ImageLoadPolicy; PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY SystemCallFilterPolicy; PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY PayloadRestrictionPolicy; PROCESS_MITIGATION_CHILD_PROCESS_POLICY ChildProcessPolicy; }; } PROCESS_MITIGATION_POLICY_INFORMATION, *PPROCESS_MITIGATION_POLICY_INFORMATION; #endif typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO { USHORT UniqueProcessId; USHORT CreatorBackTraceIndex; UCHAR ObjectTypeIndex; UCHAR HandleAttributes; USHORT HandleValue; PVOID Object; ULONG GrantedAccess; } SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO; typedef struct _SYSTEM_HANDLE_INFORMATION { ULONG NumberOfHandles; SYSTEM_HANDLE_TABLE_ENTRY_INFO Handles[1]; } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION; typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX { PVOID Object; ULONG_PTR UniqueProcessId; ULONG_PTR HandleValue; ULONG GrantedAccess; USHORT CreatorBackTraceIndex; USHORT ObjectTypeIndex; ULONG HandleAttributes; ULONG Reserved; } SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX; typedef struct _SYSTEM_HANDLE_INFORMATION_EX { ULONG_PTR NumberOfHandles; ULONG_PTR Reserved; SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX Handles[1]; } SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX; typedef struct _OBJECT_BASIC_INFORMATION { ULONG Attributes; ACCESS_MASK GrantedAccess; ULONG HandleCount; ULONG PointerCount; ULONG PagedPoolCharge; ULONG NonPagedPoolCharge; ULONG Reserved[ 3 ]; ULONG NameInfoSize; ULONG TypeInfoSize; ULONG SecurityDescriptorSize; LARGE_INTEGER CreationTime; } OBJECT_BASIC_INFORMATION, *POBJECT_BASIC_INFORMATION; typedef struct _OBJECT_NAME_INFORMATION { UNICODE_STRING Name; } OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION; typedef struct _OBJECT_TYPE_INFORMATION { UNICODE_STRING TypeName; ULONG TotalNumberOfObjects; ULONG TotalNumberOfHandles; ULONG TotalPagedPoolUsage; ULONG TotalNonPagedPoolUsage; ULONG TotalNamePoolUsage; ULONG TotalHandleTableUsage; ULONG HighWaterNumberOfObjects; ULONG HighWaterNumberOfHandles; ULONG HighWaterPagedPoolUsage; ULONG HighWaterNonPagedPoolUsage; ULONG HighWaterNamePoolUsage; ULONG HighWaterHandleTableUsage; ULONG InvalidAttributes; GENERIC_MAPPING GenericMapping; ULONG ValidAccessMask; BOOLEAN SecurityRequired; BOOLEAN MaintainHandleCount; UCHAR TypeIndex; // Since Windows 8.1 CHAR ReservedByte; ULONG PoolType; ULONG DefaultPagedPoolCharge; ULONG DefaultNonPagedPoolCharge; } OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION; typedef struct _OBJECT_TYPES_INFORMATION { ULONG NumberOfTypes; OBJECT_TYPE_INFORMATION TypeInformation[1]; } OBJECT_TYPES_INFORMATION, *POBJECT_TYPES_INFORMATION; typedef struct _OBJECT_HANDLE_FLAG_INFORMATION { BOOLEAN Inherit; BOOLEAN ProtectFromClose; } OBJECT_HANDLE_FLAG_INFORMATION, *POBJECT_HANDLE_FLAG_INFORMATION; typedef struct _OBJECT_DIRECTORY_INFORMATION { UNICODE_STRING Name; UNICODE_STRING TypeName; } OBJECT_DIRECTORY_INFORMATION, *POBJECT_DIRECTORY_INFORMATION; typedef struct _SYSTEM_BIGPOOL_ENTRY { union { PVOID VirtualAddress; ULONG_PTR NonPaged : 1; } u1; SIZE_T SizeInBytes; union { UCHAR Tag[4]; ULONG TagUlong; } u2; } SYSTEM_BIGPOOL_ENTRY, *PSYSTEM_BIGPOOL_ENTRY; typedef struct _SYSTEM_BIGPOOL_INFORMATION { ULONG Count; SYSTEM_BIGPOOL_ENTRY AllocatedInfo[1]; } SYSTEM_BIGPOOL_INFORMATION, *PSYSTEM_BIGPOOL_INFORMATION; typedef struct _DBGKM_EXCEPTION { EXCEPTION_RECORD ExceptionRecord; ULONG FirstChance; } DBGKM_EXCEPTION, *PDBGKM_EXCEPTION; typedef struct _DBGKM_CREATE_THREAD { ULONG SubSystemKey; PVOID StartAddress; } DBGKM_CREATE_THREAD, *PDBGKM_CREATE_THREAD; typedef struct _DBGKM_CREATE_PROCESS { ULONG SubSystemKey; HANDLE FileHandle; PVOID BaseOfImage; ULONG DebugInfoFileOffset; ULONG DebugInfoSize; DBGKM_CREATE_THREAD InitialThread; } DBGKM_CREATE_PROCESS, *PDBGKM_CREATE_PROCESS; typedef struct _DBGKM_EXIT_THREAD { NTSTATUS ExitStatus; } DBGKM_EXIT_THREAD, *PDBGKM_EXIT_THREAD; typedef struct _DBGKM_EXIT_PROCESS { NTSTATUS ExitStatus; } DBGKM_EXIT_PROCESS, *PDBGKM_EXIT_PROCESS; typedef struct _DBGKM_LOAD_DLL { HANDLE FileHandle; PVOID BaseOfDll; ULONG DebugInfoFileOffset; ULONG DebugInfoSize; PVOID NamePointer; } DBGKM_LOAD_DLL, *PDBGKM_LOAD_DLL; typedef struct _DBGKM_UNLOAD_DLL { PVOID BaseAddress; } DBGKM_UNLOAD_DLL, *PDBGKM_UNLOAD_DLL; typedef enum _DBG_STATE { DbgIdle, DbgReplyPending, DbgCreateThreadStateChange, DbgCreateProcessStateChange, DbgExitThreadStateChange, DbgExitProcessStateChange, DbgExceptionStateChange, DbgBreakpointStateChange, DbgSingleStepStateChange, DbgLoadDllStateChange, DbgUnloadDllStateChange } DBG_STATE, *PDBG_STATE; typedef struct _DBGUI_CREATE_THREAD { HANDLE HandleToThread; DBGKM_CREATE_THREAD NewThread; } DBGUI_CREATE_THREAD, *PDBGUI_CREATE_THREAD; typedef struct _DBGUI_CREATE_PROCESS { HANDLE HandleToProcess; HANDLE HandleToThread; DBGKM_CREATE_PROCESS NewProcess; } DBGUI_CREATE_PROCESS, *PDBGUI_CREATE_PROCESS; typedef struct _DBGUI_WAIT_STATE_CHANGE { DBG_STATE NewState; CLIENT_ID AppClientId; union { DBGKM_EXCEPTION Exception; DBGUI_CREATE_THREAD CreateThread; DBGUI_CREATE_PROCESS CreateProcessInfo; DBGKM_EXIT_THREAD ExitThread; DBGKM_EXIT_PROCESS ExitProcess; DBGKM_LOAD_DLL LoadDll; DBGKM_UNLOAD_DLL UnloadDll; } StateInfo; } DBGUI_WAIT_STATE_CHANGE, *PDBGUI_WAIT_STATE_CHANGE; typedef struct _DBGSS_THREAD_DATA { struct _DBGSS_THREAD_DATA* Next; HANDLE ThreadHandle; HANDLE ProcessHandle; ULONG ProcessId; ULONG ThreadId; BOOLEAN HandleMarked; } DBGSS_THREAD_DATA, *PDBGSS_THREAD_DATA; #define DbgSsSetThreadData(d) \ NtCurrentTeb()->DbgSsReserved[0] = d #define DbgSsGetThreadData() \ ((PDBGSS_THREAD_DATA)NtCurrentTeb()->DbgSsReserved[0]) typedef USHORT RTL_ATOM, *PRTL_ATOM; typedef long SECURITY_STATUS; typedef struct _RTL_SPLAY_LINKS { struct _RTL_SPLAY_LINKS* Parent; struct _RTL_SPLAY_LINKS* LeftChild; struct _RTL_SPLAY_LINKS* RightChild; } RTL_SPLAY_LINKS, *PRTL_SPLAY_LINKS; #define RtlInitializeSplayLinks(Links) \ { \ PRTL_SPLAY_LINKS _SplayLinks; \ _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \ _SplayLinks->Parent = _SplayLinks; \ _SplayLinks->LeftChild = NULL; \ _SplayLinks->RightChild = NULL; \ } typedef struct _PREFIX_TABLE_ENTRY { SHORT NodeTypeCode; SHORT NameLength; struct _PREFIX_TABLE_ENTRY* NextPrefixTree; RTL_SPLAY_LINKS Links; PANSI_STRING Prefix; } PREFIX_TABLE_ENTRY, *PPREFIX_TABLE_ENTRY; typedef struct _PREFIX_TABLE { SHORT NodeTypeCode; SHORT NameLength; PPREFIX_TABLE_ENTRY NextPrefixTree; } PREFIX_TABLE, *PPREFIX_TABLE; typedef struct _RTL_BITMAP { ULONG SizeOfBitMap; PULONG Buffer; } RTL_BITMAP, *PRTL_BITMAP; typedef struct _RTL_BITMAP_RUN { ULONG StartingIndex; ULONG NumberOfBits; } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN; typedef enum { RtlBsdItemVersionNumber = 0x00, RtlBsdItemProductType, RtlBsdItemAabEnabled, RtlBsdItemAabTimeout, RtlBsdItemBootGood, RtlBsdItemBootShutdown, RtlBsdItemMax } RTL_BSD_ITEM_TYPE, *PRTL_BSD_ITEM_TYPE; #define DUPLICATE_CLOSE_SOURCE 0x00000001 #define DUPLICATE_SAME_ACCESS 0x00000002 #define DUPLICATE_SAME_ATTRIBUTES 0x00000004 #define RTL_WALK_MAX_STACK_DEPTH 128 // These cannot be ORed together #define RTL_WALK_KERNEL_MODE_STACK 0x00000000 // Kernel mode callers only #define RTL_WALK_USER_MODE_STACK 0x00000001 #define RTL_WALK_TRACE_HANDLES 0x00000300 typedef struct _RTL_PROCESS_VERIFIER_OPTIONS { ULONG SizeStruct; ULONG Option; UCHAR OptionData[1]; } RTL_PROCESS_VERIFIER_OPTIONS, *PRTL_PROCESS_VERIFIER_OPTIONS; typedef struct _RTL_DEBUG_INFORMATION { HANDLE SectionHandleClient; PVOID ViewBaseClient; PVOID ViewBaseTarget; ULONG_PTR ViewBaseDelta; HANDLE EventPairClient; HANDLE EventPairTarget; HANDLE TargetProcessId; HANDLE TargetThreadHandle; ULONG Flags; SIZE_T OffsetFree; SIZE_T CommitSize; SIZE_T ViewSize; union { PRTL_PROCESS_MODULES Modules; PRTL_PROCESS_MODULE_INFORMATION_EX ModulesEx; }; struct _RTL_PROCESS_BACKTRACES* BackTraces; struct _RTL_PROCESS_HEAPS* Heaps; struct _RTL_PROCESS_LOCKS* Locks; PVOID SpecificHeap; HANDLE TargetProcessHandle; PRTL_PROCESS_VERIFIER_OPTIONS VerifierOptions; PVOID ProcessHeap; HANDLE CriticalSectionHandle; HANDLE CriticalSectionOwnerThread; PVOID Reserved[4]; } RTL_DEBUG_INFORMATION, *PRTL_DEBUG_INFORMATION; typedef VOID (*PPS_APC_ROUTINE)( _In_opt_ PVOID ApcArgument1, _In_opt_ PVOID ApcArgument2, _In_opt_ PVOID ApcArgument3 ); typedef struct _RTLP_CURDIR_REF* PRTLP_CURDIR_REF; typedef struct _RTL_RELATIVE_NAME_U { UNICODE_STRING RelativeName; HANDLE ContainingDirectory; PRTLP_CURDIR_REF CurDirRef; } RTL_RELATIVE_NAME_U, *PRTL_RELATIVE_NAME_U; typedef enum _RTL_PATH_TYPE { RtlPathTypeUnknown, RtlPathTypeUncAbsolute, RtlPathTypeDriveAbsolute, RtlPathTypeDriveRelative, RtlPathTypeRooted, RtlPathTypeRelative, RtlPathTypeLocalDevice, RtlPathTypeRootLocalDevice, } RTL_PATH_TYPE; #define DOS_MAX_COMPONENT_LENGTH 255 #define DOS_MAX_PATH_LENGTH (DOS_MAX_COMPONENT_LENGTH + 5) #define NT_MAX_PATH_LENGTH ( (sizeof("\\??\\UNC\\") - sizeof(CHAR) ) + DOS_MAX_PATH_LENGTH + 1) typedef struct _CURDIR { UNICODE_STRING DosPath; HANDLE Handle; } CURDIR, *PCURDIR; #define RTL_USER_PROC_CURDIR_CLOSE 0x00000002 #define RTL_USER_PROC_CURDIR_INHERIT 0x00000003 typedef struct _RTL_DRIVE_LETTER_CURDIR { USHORT Flags; USHORT Length; ULONG TimeStamp; UNICODE_STRING DosPath; } RTL_DRIVE_LETTER_CURDIR, *PRTL_DRIVE_LETTER_CURDIR; #define RTL_MAX_DRIVE_LETTERS 32 #define RTL_DRIVE_LETTER_VALID (USHORT)0x0001 typedef struct _LDR_SERVICE_TAG_RECORD { struct _LDR_SERVICE_TAG_RECORD* Next; ULONG ServiceTag; } LDR_SERVICE_TAG_RECORD, *PLDR_SERVICE_TAG_RECORD; typedef struct _LDRP_CSLIST { PSINGLE_LIST_ENTRY Tail; } LDRP_CSLIST, *PLDRP_CSLIST; typedef enum _LDR_DDAG_STATE { LdrModulesMerged = -5, LdrModulesInitError = -4, LdrModulesSnapError = -3, LdrModulesUnloaded = -2, LdrModulesUnloading = -1, LdrModulesPlaceHolder = 0, LdrModulesMapping = 1, LdrModulesMapped = 2, LdrModulesWaitingForDependencies = 3, LdrModulesSnapping = 4, LdrModulesSnapped = 5, LdrModulesCondensed = 6, LdrModulesReadyToInit = 7, LdrModulesInitializing = 8, LdrModulesReadyToRun = 9 } LDR_DDAG_STATE; typedef struct _LDR_DDAG_NODE { LIST_ENTRY Modules; PLDR_SERVICE_TAG_RECORD ServiceTagList; ULONG LoadCount; ULONG LoadWhileUnloadingCount; ULONG LowestLink; union { LDRP_CSLIST Dependencies; SINGLE_LIST_ENTRY RemovalLink; }; LDRP_CSLIST IncomingDependencies; LDR_DDAG_STATE State; SINGLE_LIST_ENTRY CondenseLink; ULONG PreorderNumber; } LDR_DDAG_NODE, *PLDR_DDAG_NODE; typedef struct _LDR_DEPENDENCY_RECORD { SINGLE_LIST_ENTRY DependencyLink; PLDR_DDAG_NODE DependencyNode; SINGLE_LIST_ENTRY IncomingDependencyLink; PLDR_DDAG_NODE IncomingDependencyNode; } LDR_DEPENDENCY_RECORD, *PLDR_DEPENDENCY_RECORD; typedef enum _LDR_DLL_LOAD_REASON { LoadReasonStaticDependency, LoadReasonStaticForwarderDependency, LoadReasonDynamicForwarderDependency, LoadReasonDelayloadDependency, LoadReasonDynamicLoad, LoadReasonAsImageLoad, LoadReasonAsDataLoad, LoadReasonEnclavePrimary, // REDSTONE3 LoadReasonEnclaveDependency, LoadReasonUnknown = -1 } LDR_DLL_LOAD_REASON, *PLDR_DLL_LOAD_REASON; #define LDRP_PACKAGED_BINARY 0x00000001 #define LDRP_IMAGE_DLL 0x00000004 #define LDRP_LOAD_IN_PROGRESS 0x00001000 #define LDRP_ENTRY_PROCESSED 0x00004000 #define LDRP_DONT_CALL_FOR_THREADS 0x00040000 #define LDRP_PROCESS_ATTACH_CALLED 0x00080000 #define LDRP_PROCESS_ATTACH_FAILED 0x00100000 #define LDRP_IMAGE_NOT_AT_BASE 0x00200000 // Vista and below #define LDRP_COR_IMAGE 0x00400000 #define LDRP_DONT_RELOCATE 0x00800000 #define LDRP_REDIRECTED 0x10000000 #define LDRP_COMPAT_DATABASE_PROCESSED 0x80000000 #define LDR_DATA_TABLE_ENTRY_SIZE_WINXP FIELD_OFFSET(LDR_DATA_TABLE_ENTRY, DdagNode) #define LDR_DATA_TABLE_ENTRY_SIZE_WIN7 FIELD_OFFSET(LDR_DATA_TABLE_ENTRY, BaseNameHashValue) #define LDR_DATA_TABLE_ENTRY_SIZE_WIN8 FIELD_OFFSET(LDR_DATA_TABLE_ENTRY, ImplicitPathOptions) #define RTL_BALANCED_NODE_RESERVED_PARENT_MASK 3 typedef struct _RTL_BALANCED_NODE { union { struct _RTL_BALANCED_NODE* Children[2]; struct { struct _RTL_BALANCED_NODE* Left; struct _RTL_BALANCED_NODE* Right; } s; } u1; union { UCHAR Red : 1; UCHAR Balance : 2; ULONG_PTR ParentValue; } u2; } RTL_BALANCED_NODE, *PRTL_BALANCED_NODE; typedef struct _LDR_DATA_TABLE_ENTRY { LIST_ENTRY InLoadOrderLinks; LIST_ENTRY InMemoryOrderLinks; union { LIST_ENTRY InInitializationOrderLinks; LIST_ENTRY InProgressLinks; }; PVOID DllBase; PVOID EntryPoint; ULONG SizeOfImage; UNICODE_STRING FullDllName; UNICODE_STRING BaseDllName; union { UCHAR FlagGroup[4]; ULONG Flags; struct { ULONG PackagedBinary : 1; ULONG MarkedForRemoval : 1; ULONG ImageDll : 1; ULONG LoadNotificationsSent : 1; ULONG TelemetryEntryProcessed : 1; ULONG ProcessStaticImport : 1; ULONG InLegacyLists : 1; ULONG InIndexes : 1; ULONG ShimDll : 1; ULONG InExceptionTable : 1; ULONG ReservedFlags1 : 2; ULONG LoadInProgress : 1; ULONG LoadConfigProcessed : 1; ULONG EntryProcessed : 1; ULONG ProtectDelayLoad : 1; ULONG ReservedFlags3 : 2; ULONG DontCallForThreads : 1; ULONG ProcessAttachCalled : 1; ULONG ProcessAttachFailed : 1; ULONG CorDeferredValidate : 1; ULONG CorImage : 1; ULONG DontRelocate : 1; ULONG CorILOnly : 1; ULONG ReservedFlags5 : 3; ULONG Redirected : 1; ULONG ReservedFlags6 : 2; ULONG CompatDatabaseProcessed : 1; } s; } u; USHORT ObsoleteLoadCount; USHORT TlsIndex; LIST_ENTRY HashLinks; ULONG TimeDateStamp; struct _ACTIVATION_CONTEXT* EntryPointActivationContext; PVOID Lock; PLDR_DDAG_NODE DdagNode; LIST_ENTRY NodeModuleLink; struct _LDRP_LOAD_CONTEXT* LoadContext; PVOID ParentDllBase; PVOID SwitchBackContext; RTL_BALANCED_NODE BaseAddressIndexNode; RTL_BALANCED_NODE MappingInfoIndexNode; ULONG_PTR OriginalBase; LARGE_INTEGER LoadTime; ULONG BaseNameHashValue; LDR_DLL_LOAD_REASON LoadReason; ULONG ImplicitPathOptions; ULONG ReferenceCount; ULONG DependentLoadFlags; UCHAR SigningLevel; // Since Windows 10 RS2 } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY; typedef struct _INITIAL_TEB { struct { PVOID OldStackBase; PVOID OldStackLimit; } OldInitialTeb; PVOID StackBase; PVOID StackLimit; PVOID StackAllocationBase; } INITIAL_TEB, *PINITIAL_TEB; typedef struct _IO_STATUS_BLOCK { union { NTSTATUS Status; PVOID Pointer; }; ULONG_PTR Information; } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; typedef VOID (NTAPI* PIO_APC_ROUTINE)( _In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved ); typedef struct _FILE_IO_COMPLETION_INFORMATION { PVOID KeyContext; PVOID ApcContext; IO_STATUS_BLOCK IoStatusBlock; } FILE_IO_COMPLETION_INFORMATION, *PFILE_IO_COMPLETION_INFORMATION; #ifdef __cplusplus typedef enum _PRIORITY_CLASS : UCHAR { Undefined, Idle, Normal, High, Realtime, BelowNormal, AboveNormal } PRIORITY_CLASS; #else typedef UCHAR PRIORITY_CLASS; #endif typedef struct _PROCESS_PRIORITY_CLASS { BOOLEAN Foreground; PRIORITY_CLASS PriorityClass; } PROCESS_PRIORITY_CLASS, *PPROCESS_PRIORITY_CLASS; typedef struct _PS_ATTRIBUTE { ULONG_PTR Attribute; // PROC_THREAD_ATTRIBUTE_XXX | PROC_THREAD_ATTRIBUTE_XXX modifiers, see ProcThreadAttributeValue macro and Windows Internals 6 (372) SIZE_T Size; // Size of Value or *ValuePtr union { ULONG_PTR Value; // Reserve 8 bytes for data (such as a Handle or a data pointer) PVOID ValuePtr; // data pointer }; PSIZE_T ReturnLength; // Either 0 or specifies size of data returned to caller via "ValuePtr" } PS_ATTRIBUTE, *PPS_ATTRIBUTE; typedef struct _PS_ATTRIBUTE_LIST { SIZE_T TotalLength; // sizeof(PS_ATTRIBUTE_LIST) + <attribute count> * sizeof(PS_ATTRIBUTE) PS_ATTRIBUTE Attributes[1]; // Depends on how many attribute entries should be supplied to NtCreateUserProcess } PS_ATTRIBUTE_LIST, *PPS_ATTRIBUTE_LIST; typedef struct _PS_MEMORY_RESERVE { PVOID ReserveAddress; SIZE_T ReserveSize; } PS_MEMORY_RESERVE, *PPS_MEMORY_RESERVE; #define PS_ATTRIBUTE_NUMBER_MASK 0x0000ffff #define PS_ATTRIBUTE_THREAD 0x00010000 // Attribute may be used with thread creation #define PS_ATTRIBUTE_INPUT 0x00020000 // Attribute is input only #define PS_ATTRIBUTE_ADDITIVE 0x00040000 // Attribute may be "accumulated", e.g. bitmasks, counters, etc. typedef enum _PS_ATTRIBUTE_NUM { PsAttributeParentProcess, // in HANDLE PsAttributeDebugPort, // in HANDLE PsAttributeToken, // in HANDLE PsAttributeClientId, // out PCLIENT_ID PsAttributeTebAddress, // out PTEB PsAttributeImageName, // in PWSTR PsAttributeImageInfo, // out PSECTION_IMAGE_INFORMATION PsAttributeMemoryReserve, // in PPS_MEMORY_RESERVE PsAttributePriorityClass, // in UCHAR PsAttributeErrorMode, // in ULONG PsAttributeStdHandleInfo, // in PPS_STD_HANDLE_INFO PsAttributeHandleList, // in PHANDLE PsAttributeGroupAffinity, // in PGROUP_AFFINITY PsAttributePreferredNode, // in PUSHORT PsAttributeIdealProcessor, // in PPROCESSOR_NUMBER PsAttributeUmsThread, // see MSDN UpdateProceThreadAttributeList (CreateProcessW) - in PUMS_CREATE_THREAD_ATTRIBUTES PsAttributeMitigationOptions, // in UCHAR PsAttributeProtectionLevel, // in ULONG PsAttributeSecureProcess, // since THRESHOLD (Virtual Secure Mode, Device Guard) PsAttributeJobList, PsAttributeChildProcessPolicy, // since THRESHOLD2 PsAttributeAllApplicationPackagesPolicy, // since REDSTONE PsAttributeWin32kFilter, PsAttributeSafeOpenPromptOriginClaim, PsAttributeBnoIsolation, PsAttributeDesktopAppPolicy, PsAttributeChpe, // since REDSTONE3 PsAttributeMax } PS_ATTRIBUTE_NUM; #define PsAttributeValue(Number, Thread, Input, Additive) \ (((Number) & PS_ATTRIBUTE_NUMBER_MASK) | \ ((Thread) ? PS_ATTRIBUTE_THREAD : 0) | \ ((Input) ? PS_ATTRIBUTE_INPUT : 0) | \ ((Additive) ? PS_ATTRIBUTE_ADDITIVE : 0)) #define PS_ATTRIBUTE_PARENT_PROCESS \ PsAttributeValue(PsAttributeParentProcess, FALSE, TRUE, TRUE) // 0x60000 #define PS_ATTRIBUTE_DEBUG_PORT \ PsAttributeValue(PsAttributeDebugPort, FALSE, TRUE, TRUE) // 0x60001 #define PS_ATTRIBUTE_TOKEN \ PsAttributeValue(PsAttributeToken, FALSE, TRUE, TRUE) // 0x60002 #define PS_ATTRIBUTE_CLIENT_ID \ PsAttributeValue(PsAttributeClientId, TRUE, FALSE, FALSE) // 0x10003 #define PS_ATTRIBUTE_TEB_ADDRESS \ PsAttributeValue(PsAttributeTebAddress, TRUE, FALSE, FALSE) // 0x10004 #define PS_ATTRIBUTE_IMAGE_NAME \ PsAttributeValue(PsAttributeImageName, FALSE, TRUE, FALSE) // 0x20005 #define PS_ATTRIBUTE_IMAGE_INFO \ PsAttributeValue(PsAttributeImageInfo, FALSE, FALSE, FALSE) // 0x6 #define PS_ATTRIBUTE_MEMORY_RESERVE \ PsAttributeValue(PsAttributeMemoryReserve, FALSE, TRUE, FALSE) // 0x20007 #define PS_ATTRIBUTE_PRIORITY_CLASS \ PsAttributeValue(PsAttributePriorityClass, FALSE, TRUE, FALSE) // 0x20008 #define PS_ATTRIBUTE_ERROR_MODE \ PsAttributeValue(PsAttributeErrorMode, FALSE, TRUE, FALSE) // 0x20009 #define PS_ATTRIBUTE_STD_HANDLE_INFO \ PsAttributeValue(PsAttributeStdHandleInfo, FALSE, TRUE, FALSE) // 0x2000A #define PS_ATTRIBUTE_HANDLE_LIST \ PsAttributeValue(PsAttributeHandleList, FALSE, TRUE, FALSE) // 0x2000B #define PS_ATTRIBUTE_GROUP_AFFINITY \ PsAttributeValue(PsAttributeGroupAffinity, TRUE, TRUE, FALSE) // 0x2000C #define PS_ATTRIBUTE_PREFERRED_NODE \ PsAttributeValue(PsAttributePreferredNode, FALSE, TRUE, FALSE) // 0x2000D #define PS_ATTRIBUTE_IDEAL_PROCESSOR \ PsAttributeValue(PsAttributeIdealProcessor, TRUE, TRUE, FALSE) // 0x2000E #define PS_ATTRIBUTE_MITIGATION_OPTIONS \ PsAttributeValue(PsAttributeMitigationOptions, FALSE, TRUE, TRUE) // 0x60010 #define PS_ATTRIBUTE_PROTECTION_LEVEL \ PsAttributeValue(PsAttributeProtectionLevel, FALSE, TRUE, FALSE) // 0x20011 #define PS_ATTRIBUTE_SECURE_PROCESS \ PsAttributeValue(PsAttributeSecureProcess, FALSE, TRUE, FALSE) // 0x20012 #define PS_ATTRIBUTE_JOB_LIST \ PsAttributeValue(PsAttributeJobList, FALSE, TRUE, FALSE) // 0x20013 #define PS_ATTRIBUTE_CHILD_PROCESS_POLICY \ PsAttributeValue(PsAttributeChildProcessPolicy, FALSE, TRUE, FALSE) // 0x20014 #define PS_ATTRIBUTE_ALL_APPLICATION_PACKAGES_POLICY \ PsAttributeValue(PsAttributeAllApplicationPackagesPolicy, FALSE, TRUE, FALSE) // 0x20015 #define PS_ATTRIBUTE_WIN32K_FILTER \ PsAttributeValue(PsAttributeWin32kFilter, FALSE, TRUE, FALSE) // 0x20016 #define PS_ATTRIBUTE_SAFE_OPEN_PROMPT_ORIGIN_CLAIM \ PsAttributeValue(PsAttributeSafeOpenPromptOriginClaim, FALSE, TRUE, FALSE) // 0x20017 #define PS_ATTRIBUTE_BNO_ISOLATION \ PsAttributeValue(PsAttributeBnoIsolation, FALSE, TRUE, FALSE) // 0x20018 #define PS_ATTRIBUTE_DESKTOP_APP_POLICY \ PsAttributeValue(PsAttributeDesktopAppPolicy, FALSE, TRUE, FALSE) // 0x20019 typedef enum _PS_STD_HANDLE_STATE { PsNeverDuplicate, PsRequestDuplicate, // Duplicate standard handles specified by PseudoHandleMask, and only if StdHandleSubsystemType matches the image subsystem PsAlwaysDuplicate, // Always duplicate standard handles PsMaxStdHandleStates } PS_STD_HANDLE_STATE; #define HANDLE_DETACHED_PROCESS ((HANDLE)-1) #define HANDLE_CREATE_NEW_CONSOLE ((HANDLE)-2) #define HANDLE_CREATE_NO_WINDOW ((HANDLE)-3) #define PS_STD_INPUT_HANDLE 0x1 #define PS_STD_OUTPUT_HANDLE 0x2 #define PS_STD_ERROR_HANDLE 0x4 typedef struct _PS_STD_HANDLE_INFO { union { ULONG Flags; struct { ULONG StdHandleState : 2; // PS_STD_HANDLE_STATE ULONG PseudoHandleMask : 3; // PS_STD_* } s; } u; ULONG StdHandleSubsystemType; } PS_STD_HANDLE_INFO, *PPS_STD_HANDLE_INFO; typedef struct _PS_BNO_ISOLATION_PARAMETERS { UNICODE_STRING IsolationPrefix; ULONG HandleCount; PVOID* Handles; BOOLEAN IsolationEnabled; } PS_BNO_ISOLATION_PARAMETERS, *PPS_BNO_ISOLATION_PARAMETERS; typedef enum _PS_MITIGATION_OPTION { PS_MITIGATION_OPTION_NX, PS_MITIGATION_OPTION_SEHOP, PS_MITIGATION_OPTION_FORCE_RELOCATE_IMAGES, PS_MITIGATION_OPTION_HEAP_TERMINATE, PS_MITIGATION_OPTION_BOTTOM_UP_ASLR, PS_MITIGATION_OPTION_HIGH_ENTROPY_ASLR, PS_MITIGATION_OPTION_STRICT_HANDLE_CHECKS, PS_MITIGATION_OPTION_WIN32K_SYSTEM_CALL_DISABLE, PS_MITIGATION_OPTION_EXTENSION_POINT_DISABLE, PS_MITIGATION_OPTION_PROHIBIT_DYNAMIC_CODE, PS_MITIGATION_OPTION_CONTROL_FLOW_GUARD, PS_MITIGATION_OPTION_BLOCK_NON_MICROSOFT_BINARIES, PS_MITIGATION_OPTION_FONT_DISABLE, PS_MITIGATION_OPTION_IMAGE_LOAD_NO_REMOTE, PS_MITIGATION_OPTION_IMAGE_LOAD_NO_LOW_LABEL, PS_MITIGATION_OPTION_IMAGE_LOAD_PREFER_SYSTEM32, PS_MITIGATION_OPTION_RETURN_FLOW_GUARD, PS_MITIGATION_OPTION_LOADER_INTEGRITY_CONTINUITY, PS_MITIGATION_OPTION_STRICT_CONTROL_FLOW_GUARD, PS_MITIGATION_OPTION_RESTRICT_SET_THREAD_CONTEXT, PS_MITIGATION_OPTION_ROP_STACKPIVOT, // since REDSTONE3 PS_MITIGATION_OPTION_ROP_CALLER_CHECK, PS_MITIGATION_OPTION_ROP_SIMEXEC, PS_MITIGATION_OPTION_EXPORT_ADDRESS_FILTER, PS_MITIGATION_OPTION_EXPORT_ADDRESS_FILTER_PLUS, PS_MITIGATION_OPTION_RESTRICT_CHILD_PROCESS_CREATION, PS_MITIGATION_OPTION_IMPORT_ADDRESS_FILTER, PS_MITIGATION_OPTION_MODULE_TAMPERING_PROTECTION } PS_MITIGATION_OPTION; typedef enum _PS_CREATE_STATE { PsCreateInitialState, PsCreateFailOnFileOpen, PsCreateFailOnSectionCreate, PsCreateFailExeFormat, PsCreateFailMachineMismatch, PsCreateFailExeName, // Debugger specified PsCreateSuccess, PsCreateMaximumStates } PS_CREATE_STATE; typedef struct _PS_CREATE_INFO { SIZE_T Size; PS_CREATE_STATE State; union { // PsCreateInitialState struct { union { ULONG InitFlags; struct { UCHAR WriteOutputOnExit : 1; UCHAR DetectManifest : 1; UCHAR IFEOSkipDebugger : 1; UCHAR IFEODoNotPropagateKeyState : 1; UCHAR SpareBits1 : 4; UCHAR SpareBits2 : 8; USHORT ProhibitedImageCharacteristics : 16; } s1; } u2; ACCESS_MASK AdditionalFileAccess; } InitState; // PsCreateFailOnSectionCreate struct { HANDLE FileHandle; } FailSection; // PsCreateFailExeFormat struct { USHORT DllCharacteristics; } ExeFormat; // PsCreateFailExeName struct { HANDLE IFEOKey; } ExeName; // PsCreateSuccess struct { union { ULONG OutputFlags; struct { UCHAR ProtectedProcess : 1; UCHAR AddressSpaceOverride : 1; UCHAR DevOverrideEnabled : 1; // From Image File Execution Options UCHAR ManifestDetected : 1; UCHAR ProtectedProcessLight : 1; UCHAR SpareBits1 : 3; UCHAR SpareBits2 : 8; USHORT SpareBits3 : 16; } s2; } u3; HANDLE FileHandle; HANDLE SectionHandle; ULONGLONG UserProcessParametersNative; ULONG UserProcessParametersWow64; ULONG CurrentParameterFlags; ULONGLONG PebAddressNative; ULONG PebAddressWow64; ULONGLONG ManifestAddress; ULONG ManifestSize; } SuccessState; } u1; } PS_CREATE_INFO, *PPS_CREATE_INFO; #define PROCESS_CREATE_FLAGS_BREAKAWAY 0x00000001 #define PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT 0x00000002 #define PROCESS_CREATE_FLAGS_INHERIT_HANDLES 0x00000004 #define PROCESS_CREATE_FLAGS_OVERRIDE_ADDRESS_SPACE 0x00000008 #define PROCESS_CREATE_FLAGS_LARGE_PAGES 0x00000010 // Only usable with NtCreateUserProcess (Vista+): #define PROCESS_CREATE_FLAGS_LARGE_PAGE_SYSTEM_DLL 0x00000020 #define PROCESS_CREATE_FLAGS_PROTECTED_PROCESS 0x00000040 // Only allowed if the calling process is itself protected #define PROCESS_CREATE_FLAGS_CREATE_SESSION 0x00000080 #define PROCESS_CREATE_FLAGS_INHERIT_FROM_PARENT 0x00000100 #define PROCESS_CREATE_FLAGS_SUSPENDED 0x00000200 #define PROCESS_CREATE_FLAGS_EXTENDED_UNKNOWN 0x00000400 typedef enum _MEMORY_RESERVE_TYPE { MemoryReserveUserApc, MemoryReserveIoCompletion, MemoryReserveTypeMax } MEMORY_RESERVE_TYPE; typedef struct _PROCESS_HANDLE_TRACING_ENABLE { ULONG Flags; } PROCESS_HANDLE_TRACING_ENABLE, *PPROCESS_HANDLE_TRACING_ENABLE; #define PROCESS_HANDLE_TRACING_MAX_SLOTS 0x20000 typedef struct _PROCESS_HANDLE_TRACING_ENABLE_EX { ULONG Flags; ULONG TotalSlots; } PROCESS_HANDLE_TRACING_ENABLE_EX, *PPROCESS_HANDLE_TRACING_ENABLE_EX; typedef enum _PROCESSINFOCLASS { ProcessBasicInformation, // q: PROCESS_BASIC_INFORMATION, PROCESS_EXTENDED_BASIC_INFORMATION ProcessQuotaLimits, // qs: QUOTA_LIMITS, QUOTA_LIMITS_EX ProcessIoCounters, // q: IO_COUNTERS ProcessVmCounters, // q: VM_COUNTERS, VM_COUNTERS_EX, VM_COUNTERS_EX2 ProcessTimes, // q: KERNEL_USER_TIMES ProcessBasePriority, // s: KPRIORITY ProcessRaisePriority, // s: ULONG ProcessDebugPort, // q: HANDLE ProcessExceptionPort, // s: PROCESS_EXCEPTION_PORT (requires SeTcbPrivilege) ProcessAccessToken, // s: PROCESS_ACCESS_TOKEN ProcessLdtInformation, // qs: PROCESS_LDT_INFORMATION // 10 ProcessLdtSize, // s: PROCESS_LDT_SIZE ProcessDefaultHardErrorMode, // qs: ULONG ProcessIoPortHandlers, // (kernel-mode only) // PROCESS_IO_PORT_HANDLER_INFORMATION ProcessPooledUsageAndLimits, // q: POOLED_USAGE_AND_LIMITS ProcessWorkingSetWatch, // q: PROCESS_WS_WATCH_INFORMATION[]; s: void ProcessUserModeIOPL, // qs: ULONG (requires SeTcbPrivilege) ProcessEnableAlignmentFaultFixup, // s: BOOLEAN ProcessPriorityClass, // qs: PROCESS_PRIORITY_CLASS ProcessWx86Information, // qs: ULONG (requires SeTcbPrivilege) (VdmAllowed) ProcessHandleCount, // q: ULONG, PROCESS_HANDLE_INFORMATION // 20 ProcessAffinityMask, // (q >WIN7)s: KAFFINITY, qs: GROUP_AFFINITY ProcessPriorityBoost, // qs: ULONG ProcessDeviceMap, // qs: PROCESS_DEVICEMAP_INFORMATION, PROCESS_DEVICEMAP_INFORMATION_EX ProcessSessionInformation, // q: PROCESS_SESSION_INFORMATION ProcessForegroundInformation, // s: PROCESS_FOREGROUND_BACKGROUND ProcessWow64Information, // q: ULONG_PTR ProcessImageFileName, // q: UNICODE_STRING ProcessLUIDDeviceMapsEnabled, // q: ULONG ProcessBreakOnTermination, // qs: ULONG ProcessDebugObjectHandle, // q: HANDLE // 30 ProcessDebugFlags, // qs: ULONG ProcessHandleTracing, // q: PROCESS_HANDLE_TRACING_QUERY; s: size 0 disables, otherwise enables ProcessIoPriority, // qs: IO_PRIORITY_HINT ProcessExecuteFlags, // qs: ULONG ProcessTlsInformation, // PROCESS_TLS_INFORMATION // ProcessResourceManagement ProcessCookie, // q: ULONG ProcessImageInformation, // q: SECTION_IMAGE_INFORMATION ProcessCycleTime, // q: PROCESS_CYCLE_TIME_INFORMATION // since VISTA ProcessPagePriority, // qs: PAGE_PRIORITY_INFORMATION ProcessInstrumentationCallback, // s: PVOID or PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION // 40 ProcessThreadStackAllocation, // s: PROCESS_STACK_ALLOCATION_INFORMATION, PROCESS_STACK_ALLOCATION_INFORMATION_EX ProcessWorkingSetWatchEx, // q: PROCESS_WS_WATCH_INFORMATION_EX[] ProcessImageFileNameWin32, // q: UNICODE_STRING ProcessImageFileMapping, // q: HANDLE (input) ProcessAffinityUpdateMode, // qs: PROCESS_AFFINITY_UPDATE_MODE ProcessMemoryAllocationMode, // qs: PROCESS_MEMORY_ALLOCATION_MODE ProcessGroupInformation, // q: USHORT[] ProcessTokenVirtualizationEnabled, // s: ULONG ProcessConsoleHostProcess, // q: ULONG_PTR // ProcessOwnerInformation ProcessWindowInformation, // q: PROCESS_WINDOW_INFORMATION // 50 ProcessHandleInformation, // q: PROCESS_HANDLE_SNAPSHOT_INFORMATION // since WIN8 ProcessMitigationPolicy, // s: PROCESS_MITIGATION_POLICY_INFORMATION ProcessDynamicFunctionTableInformation, ProcessHandleCheckingMode, // qs: ULONG; s: 0 disables, otherwise enables ProcessKeepAliveCount, // q: PROCESS_KEEPALIVE_COUNT_INFORMATION ProcessRevokeFileHandles, // s: PROCESS_REVOKE_FILE_HANDLES_INFORMATION ProcessWorkingSetControl, // s: PROCESS_WORKING_SET_CONTROL ProcessHandleTable, // q: ULONG[] // since WINBLUE ProcessCheckStackExtentsMode, // qs: ULONG // KPROCESS->CheckStackExtents (CFG) ProcessCommandLineInformation, // q: UNICODE_STRING // 60 ProcessProtectionInformation, // q: PS_PROTECTION ProcessMemoryExhaustion, // PROCESS_MEMORY_EXHAUSTION_INFO // since THRESHOLD ProcessFaultInformation, // PROCESS_FAULT_INFORMATION ProcessTelemetryIdInformation, // q: PROCESS_TELEMETRY_ID_INFORMATION ProcessCommitReleaseInformation, // PROCESS_COMMIT_RELEASE_INFORMATION ProcessDefaultCpuSetsInformation, // SYSTEM_CPU_SET_INFORMATION[5] ProcessAllowedCpuSetsInformation, // SYSTEM_CPU_SET_INFORMATION[5] ProcessSubsystemProcess, ProcessJobMemoryInformation, // q: PROCESS_JOB_MEMORY_INFO ProcessInPrivate, // s: void // ETW // since THRESHOLD2 // 70 ProcessRaiseUMExceptionOnInvalidHandleClose, // qs: ULONG; s: 0 disables, otherwise enables ProcessIumChallengeResponse, ProcessChildProcessInformation, // q: PROCESS_CHILD_PROCESS_INFORMATION ProcessHighGraphicsPriorityInformation, // qs: BOOLEAN (requires SeTcbPrivilege) ProcessSubsystemInformation, // q: SUBSYSTEM_INFORMATION_TYPE // since REDSTONE2 ProcessEnergyValues, // q: PROCESS_ENERGY_VALUES, PROCESS_EXTENDED_ENERGY_VALUES ProcessPowerThrottlingState, // qs: POWER_THROTTLING_PROCESS_STATE ProcessReserved3Information, // ProcessActivityThrottlePolicy // PROCESS_ACTIVITY_THROTTLE_POLICY ProcessWin32kSyscallFilterInformation, // q: WIN32K_SYSCALL_FILTER ProcessDisableSystemAllowedCpuSets, // 80 ProcessWakeInformation, // PROCESS_WAKE_INFORMATION ProcessEnergyTrackingState, // PROCESS_ENERGY_TRACKING_STATE ProcessManageWritesToExecutableMemory, // MANAGE_WRITES_TO_EXECUTABLE_MEMORY // since REDSTONE3 ProcessCaptureTrustletLiveDump, ProcessTelemetryCoverage, ProcessEnclaveInformation, ProcessEnableReadWriteVmLogging, // PROCESS_READWRITEVM_LOGGING_INFORMATION ProcessUptimeInformation, // q: PROCESS_UPTIME_INFORMATION ProcessImageSection, // q: HANDLE ProcessDebugAuthInformation, // since REDSTONE4 // 90 ProcessSystemResourceManagement, // PROCESS_SYSTEM_RESOURCE_MANAGEMENT ProcessSequenceNumber, // q: ULONGLONG ProcessLoaderDetour, // since REDSTONE5 ProcessSecurityDomainInformation, // PROCESS_SECURITY_DOMAIN_INFORMATION ProcessCombineSecurityDomainsInformation, // PROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION ProcessEnableLogging, // PROCESS_LOGGING_INFORMATION ProcessLeapSecondInformation, // PROCESS_LEAP_SECOND_INFORMATION ProcessFiberShadowStackAllocation, // PROCESS_FIBER_SHADOW_STACK_ALLOCATION_INFORMATION // since 19H1 ProcessFreeFiberShadowStackAllocation, // PROCESS_FREE_FIBER_SHADOW_STACK_ALLOCATION_INFORMATION ProcessAltSystemCallInformation, // qs: BOOLEAN (kernel-mode only) // INT2E // since 20H1 // 100 ProcessDynamicEHContinuationTargets, // PROCESS_DYNAMIC_EH_CONTINUATION_TARGETS_INFORMATION ProcessDynamicEnforcedCetCompatibleRanges, // PROCESS_DYNAMIC_ENFORCED_ADDRESS_RANGE_INFORMATION // since 20H2 ProcessCreateStateChange, // since WIN11 ProcessApplyStateChange, ProcessEnableOptionalXStateFeatures, ProcessAltPrefetchParam, // since 22H1 ProcessAssignCpuPartitions, ProcessPriorityClassEx, // s: PROCESS_PRIORITY_CLASS_EX ProcessMembershipInformation, ProcessEffectiveIoPriority, // q: IO_PRIORITY_HINT ProcessEffectivePagePriority, // q: ULONG MaxProcessInfoClass } PROCESSINFOCLASS; typedef enum _SYSTEM_INFORMATION_CLASS { SystemBasicInformation, // q: SYSTEM_BASIC_INFORMATION SystemProcessorInformation, // q: SYSTEM_PROCESSOR_INFORMATION SystemPerformanceInformation, // q: SYSTEM_PERFORMANCE_INFORMATION SystemTimeOfDayInformation, // q: SYSTEM_TIMEOFDAY_INFORMATION SystemPathInformation, // not implemented SystemProcessInformation, // q: SYSTEM_PROCESS_INFORMATION SystemCallCountInformation, // q: SYSTEM_CALL_COUNT_INFORMATION SystemDeviceInformation, // q: SYSTEM_DEVICE_INFORMATION SystemProcessorPerformanceInformation, // q: SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION (EX in: USHORT ProcessorGroup) SystemFlagsInformation, // q: SYSTEM_FLAGS_INFORMATION SystemCallTimeInformation, // not implemented // SYSTEM_CALL_TIME_INFORMATION // 10 SystemModuleInformation, // q: RTL_PROCESS_MODULES SystemLocksInformation, // q: RTL_PROCESS_LOCKS SystemStackTraceInformation, // q: RTL_PROCESS_BACKTRACES SystemPagedPoolInformation, // not implemented SystemNonPagedPoolInformation, // not implemented SystemHandleInformation, // q: SYSTEM_HANDLE_INFORMATION SystemObjectInformation, // q: SYSTEM_OBJECTTYPE_INFORMATION mixed with SYSTEM_OBJECT_INFORMATION SystemPageFileInformation, // q: SYSTEM_PAGEFILE_INFORMATION SystemVdmInstemulInformation, // q: SYSTEM_VDM_INSTEMUL_INFO SystemVdmBopInformation, // not implemented // 20 SystemFileCacheInformation, // q: SYSTEM_FILECACHE_INFORMATION; s (requires SeIncreaseQuotaPrivilege) (info for WorkingSetTypeSystemCache) SystemPoolTagInformation, // q: SYSTEM_POOLTAG_INFORMATION SystemInterruptInformation, // q: SYSTEM_INTERRUPT_INFORMATION (EX in: USHORT ProcessorGroup) SystemDpcBehaviorInformation, // q: SYSTEM_DPC_BEHAVIOR_INFORMATION; s: SYSTEM_DPC_BEHAVIOR_INFORMATION (requires SeLoadDriverPrivilege) SystemFullMemoryInformation, // not implemented // SYSTEM_MEMORY_USAGE_INFORMATION SystemLoadGdiDriverInformation, // s (kernel-mode only) SystemUnloadGdiDriverInformation, // s (kernel-mode only) SystemTimeAdjustmentInformation, // q: SYSTEM_QUERY_TIME_ADJUST_INFORMATION; s: SYSTEM_SET_TIME_ADJUST_INFORMATION (requires SeSystemtimePrivilege) SystemSummaryMemoryInformation, // not implemented // SYSTEM_MEMORY_USAGE_INFORMATION SystemMirrorMemoryInformation, // s (requires license value "Kernel-MemoryMirroringSupported") (requires SeShutdownPrivilege) // 30 SystemPerformanceTraceInformation, // q; s: (type depends on EVENT_TRACE_INFORMATION_CLASS) SystemObsolete0, // not implemented SystemExceptionInformation, // q: SYSTEM_EXCEPTION_INFORMATION SystemCrashDumpStateInformation, // s: SYSTEM_CRASH_DUMP_STATE_INFORMATION (requires SeDebugPrivilege) SystemKernelDebuggerInformation, // q: SYSTEM_KERNEL_DEBUGGER_INFORMATION SystemContextSwitchInformation, // q: SYSTEM_CONTEXT_SWITCH_INFORMATION SystemRegistryQuotaInformation, // q: SYSTEM_REGISTRY_QUOTA_INFORMATION; s (requires SeIncreaseQuotaPrivilege) SystemExtendServiceTableInformation, // s (requires SeLoadDriverPrivilege) // loads win32k only SystemPrioritySeperation, // s (requires SeTcbPrivilege) SystemVerifierAddDriverInformation, // s (requires SeDebugPrivilege) // 40 SystemVerifierRemoveDriverInformation, // s (requires SeDebugPrivilege) SystemProcessorIdleInformation, // q: SYSTEM_PROCESSOR_IDLE_INFORMATION (EX in: USHORT ProcessorGroup) SystemLegacyDriverInformation, // q: SYSTEM_LEGACY_DRIVER_INFORMATION SystemCurrentTimeZoneInformation, // q; s: RTL_TIME_ZONE_INFORMATION SystemLookasideInformation, // q: SYSTEM_LOOKASIDE_INFORMATION SystemTimeSlipNotification, // s: HANDLE (NtCreateEvent) (requires SeSystemtimePrivilege) SystemSessionCreate, // not implemented SystemSessionDetach, // not implemented SystemSessionInformation, // not implemented (SYSTEM_SESSION_INFORMATION) SystemRangeStartInformation, // q: SYSTEM_RANGE_START_INFORMATION // 50 SystemVerifierInformation, // q: SYSTEM_VERIFIER_INFORMATION; s (requires SeDebugPrivilege) SystemVerifierThunkExtend, // s (kernel-mode only) SystemSessionProcessInformation, // q: SYSTEM_SESSION_PROCESS_INFORMATION SystemLoadGdiDriverInSystemSpace, // s: SYSTEM_GDI_DRIVER_INFORMATION (kernel-mode only) (same as SystemLoadGdiDriverInformation) SystemNumaProcessorMap, // q: SYSTEM_NUMA_INFORMATION SystemPrefetcherInformation, // q; s: PREFETCHER_INFORMATION // PfSnQueryPrefetcherInformation SystemExtendedProcessInformation, // q: SYSTEM_PROCESS_INFORMATION SystemRecommendedSharedDataAlignment, // q: ULONG // KeGetRecommendedSharedDataAlignment SystemComPlusPackage, // q; s: ULONG SystemNumaAvailableMemory, // q: SYSTEM_NUMA_INFORMATION // 60 SystemProcessorPowerInformation, // q: SYSTEM_PROCESSOR_POWER_INFORMATION (EX in: USHORT ProcessorGroup) SystemEmulationBasicInformation, // q: SYSTEM_BASIC_INFORMATION SystemEmulationProcessorInformation, // q: SYSTEM_PROCESSOR_INFORMATION SystemExtendedHandleInformation, // q: SYSTEM_HANDLE_INFORMATION_EX SystemLostDelayedWriteInformation, // q: ULONG SystemBigPoolInformation, // q: SYSTEM_BIGPOOL_INFORMATION SystemSessionPoolTagInformation, // q: SYSTEM_SESSION_POOLTAG_INFORMATION SystemSessionMappedViewInformation, // q: SYSTEM_SESSION_MAPPED_VIEW_INFORMATION SystemHotpatchInformation, // q; s: SYSTEM_HOTPATCH_CODE_INFORMATION SystemObjectSecurityMode, // q: ULONG // 70 SystemWatchdogTimerHandler, // s: SYSTEM_WATCHDOG_HANDLER_INFORMATION // (kernel-mode only) SystemWatchdogTimerInformation, // q: SYSTEM_WATCHDOG_TIMER_INFORMATION // (kernel-mode only) SystemLogicalProcessorInformation, // q: SYSTEM_LOGICAL_PROCESSOR_INFORMATION (EX in: USHORT ProcessorGroup) SystemWow64SharedInformationObsolete, // not implemented SystemRegisterFirmwareTableInformationHandler, // s: SYSTEM_FIRMWARE_TABLE_HANDLER // (kernel-mode only) SystemFirmwareTableInformation, // SYSTEM_FIRMWARE_TABLE_INFORMATION SystemModuleInformationEx, // q: RTL_PROCESS_MODULE_INFORMATION_EX SystemVerifierTriageInformation, // not implemented SystemSuperfetchInformation, // q; s: SUPERFETCH_INFORMATION // PfQuerySuperfetchInformation SystemMemoryListInformation, // q: SYSTEM_MEMORY_LIST_INFORMATION; s: SYSTEM_MEMORY_LIST_COMMAND (requires SeProfileSingleProcessPrivilege) // 80 SystemFileCacheInformationEx, // q: SYSTEM_FILECACHE_INFORMATION; s (requires SeIncreaseQuotaPrivilege) (same as SystemFileCacheInformation) SystemThreadPriorityClientIdInformation, // s: SYSTEM_THREAD_CID_PRIORITY_INFORMATION (requires SeIncreaseBasePriorityPrivilege) SystemProcessorIdleCycleTimeInformation, // q: SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION[] (EX in: USHORT ProcessorGroup) SystemVerifierCancellationInformation, // SYSTEM_VERIFIER_CANCELLATION_INFORMATION // name:wow64:whNT32QuerySystemVerifierCancellationInformation SystemProcessorPowerInformationEx, // not implemented SystemRefTraceInformation, // q; s: SYSTEM_REF_TRACE_INFORMATION // ObQueryRefTraceInformation SystemSpecialPoolInformation, // q; s: SYSTEM_SPECIAL_POOL_INFORMATION (requires SeDebugPrivilege) // MmSpecialPoolTag, then MmSpecialPoolCatchOverruns != 0 SystemProcessIdInformation, // q: SYSTEM_PROCESS_ID_INFORMATION SystemErrorPortInformation, // s (requires SeTcbPrivilege) SystemBootEnvironmentInformation, // q: SYSTEM_BOOT_ENVIRONMENT_INFORMATION // 90 SystemHypervisorInformation, // q: SYSTEM_HYPERVISOR_QUERY_INFORMATION SystemVerifierInformationEx, // q; s: SYSTEM_VERIFIER_INFORMATION_EX SystemTimeZoneInformation, // q; s: RTL_TIME_ZONE_INFORMATION (requires SeTimeZonePrivilege) SystemImageFileExecutionOptionsInformation, // s: SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION (requires SeTcbPrivilege) SystemCoverageInformation, // q: COVERAGE_MODULES s: COVERAGE_MODULE_REQUEST // ExpCovQueryInformation (requires SeDebugPrivilege) SystemPrefetchPatchInformation, // SYSTEM_PREFETCH_PATCH_INFORMATION SystemVerifierFaultsInformation, // s: SYSTEM_VERIFIER_FAULTS_INFORMATION (requires SeDebugPrivilege) SystemSystemPartitionInformation, // q: SYSTEM_SYSTEM_PARTITION_INFORMATION SystemSystemDiskInformation, // q: SYSTEM_SYSTEM_DISK_INFORMATION SystemProcessorPerformanceDistribution, // q: SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION (EX in: USHORT ProcessorGroup) // 100 SystemNumaProximityNodeInformation, // q; s: SYSTEM_NUMA_PROXIMITY_MAP SystemDynamicTimeZoneInformation, // q; s: RTL_DYNAMIC_TIME_ZONE_INFORMATION (requires SeTimeZonePrivilege) SystemCodeIntegrityInformation, // q: SYSTEM_CODEINTEGRITY_INFORMATION // SeCodeIntegrityQueryInformation SystemProcessorMicrocodeUpdateInformation, // s: SYSTEM_PROCESSOR_MICROCODE_UPDATE_INFORMATION SystemProcessorBrandString, // q: CHAR[] // HaliQuerySystemInformation -> HalpGetProcessorBrandString, info class 23 SystemVirtualAddressInformation, // q: SYSTEM_VA_LIST_INFORMATION[]; s: SYSTEM_VA_LIST_INFORMATION[] (requires SeIncreaseQuotaPrivilege) // MmQuerySystemVaInformation SystemLogicalProcessorAndGroupInformation, // q: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX (EX in: LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType) // since WIN7 // KeQueryLogicalProcessorRelationship SystemProcessorCycleTimeInformation, // q: SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION[] (EX in: USHORT ProcessorGroup) SystemStoreInformation, // q; s: SYSTEM_STORE_INFORMATION (requires SeProfileSingleProcessPrivilege) // SmQueryStoreInformation SystemRegistryAppendString, // s: SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS // 110 SystemAitSamplingValue, // s: ULONG (requires SeProfileSingleProcessPrivilege) SystemVhdBootInformation, // q: SYSTEM_VHD_BOOT_INFORMATION SystemCpuQuotaInformation, // q; s: PS_CPU_QUOTA_QUERY_INFORMATION SystemNativeBasicInformation, // q: SYSTEM_BASIC_INFORMATION SystemErrorPortTimeouts, // SYSTEM_ERROR_PORT_TIMEOUTS SystemLowPriorityIoInformation, // q: SYSTEM_LOW_PRIORITY_IO_INFORMATION SystemTpmBootEntropyInformation, // q: TPM_BOOT_ENTROPY_NT_RESULT // ExQueryTpmBootEntropyInformation SystemVerifierCountersInformation, // q: SYSTEM_VERIFIER_COUNTERS_INFORMATION SystemPagedPoolInformationEx, // q: SYSTEM_FILECACHE_INFORMATION; s (requires SeIncreaseQuotaPrivilege) (info for WorkingSetTypePagedPool) SystemSystemPtesInformationEx, // q: SYSTEM_FILECACHE_INFORMATION; s (requires SeIncreaseQuotaPrivilege) (info for WorkingSetTypeSystemPtes) // 120 SystemNodeDistanceInformation, // q: USHORT[4*NumaNodes] // (EX in: USHORT NodeNumber) SystemAcpiAuditInformation, // q: SYSTEM_ACPI_AUDIT_INFORMATION // HaliQuerySystemInformation -> HalpAuditQueryResults, info class 26 SystemBasicPerformanceInformation, // q: SYSTEM_BASIC_PERFORMANCE_INFORMATION // name:wow64:whNtQuerySystemInformation_SystemBasicPerformanceInformation SystemQueryPerformanceCounterInformation, // q: SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION // since WIN7 SP1 SystemSessionBigPoolInformation, // q: SYSTEM_SESSION_POOLTAG_INFORMATION // since WIN8 SystemBootGraphicsInformation, // q; s: SYSTEM_BOOT_GRAPHICS_INFORMATION (kernel-mode only) SystemScrubPhysicalMemoryInformation, // q; s: MEMORY_SCRUB_INFORMATION SystemBadPageInformation, SystemProcessorProfileControlArea, // q; s: SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA SystemCombinePhysicalMemoryInformation, // s: MEMORY_COMBINE_INFORMATION, MEMORY_COMBINE_INFORMATION_EX, MEMORY_COMBINE_INFORMATION_EX2 // 130 SystemEntropyInterruptTimingInformation, // q; s: SYSTEM_ENTROPY_TIMING_INFORMATION SystemConsoleInformation, // q; s: SYSTEM_CONSOLE_INFORMATION SystemPlatformBinaryInformation, // q: SYSTEM_PLATFORM_BINARY_INFORMATION (requires SeTcbPrivilege) SystemPolicyInformation, // q: SYSTEM_POLICY_INFORMATION SystemHypervisorProcessorCountInformation, // q: SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION SystemDeviceDataInformation, // q: SYSTEM_DEVICE_DATA_INFORMATION SystemDeviceDataEnumerationInformation, // q: SYSTEM_DEVICE_DATA_INFORMATION SystemMemoryTopologyInformation, // q: SYSTEM_MEMORY_TOPOLOGY_INFORMATION SystemMemoryChannelInformation, // q: SYSTEM_MEMORY_CHANNEL_INFORMATION SystemBootLogoInformation, // q: SYSTEM_BOOT_LOGO_INFORMATION // 140 SystemProcessorPerformanceInformationEx, // q: SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX // (EX in: USHORT ProcessorGroup) // since WINBLUE SystemCriticalProcessErrorLogInformation, SystemSecureBootPolicyInformation, // q: SYSTEM_SECUREBOOT_POLICY_INFORMATION SystemPageFileInformationEx, // q: SYSTEM_PAGEFILE_INFORMATION_EX SystemSecureBootInformation, // q: SYSTEM_SECUREBOOT_INFORMATION SystemEntropyInterruptTimingRawInformation, SystemPortableWorkspaceEfiLauncherInformation, // q: SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION SystemFullProcessInformation, // q: SYSTEM_PROCESS_INFORMATION with SYSTEM_PROCESS_INFORMATION_EXTENSION (requires admin) SystemKernelDebuggerInformationEx, // q: SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX SystemBootMetadataInformation, // 150 SystemSoftRebootInformation, // q: ULONG SystemElamCertificateInformation, // s: SYSTEM_ELAM_CERTIFICATE_INFORMATION SystemOfflineDumpConfigInformation, // q: OFFLINE_CRASHDUMP_CONFIGURATION_TABLE_V2 SystemProcessorFeaturesInformation, // q: SYSTEM_PROCESSOR_FEATURES_INFORMATION SystemRegistryReconciliationInformation, // s: NULL (requires admin) (flushes registry hives) SystemEdidInformation, // q: SYSTEM_EDID_INFORMATION SystemManufacturingInformation, // q: SYSTEM_MANUFACTURING_INFORMATION // since THRESHOLD SystemEnergyEstimationConfigInformation, // q: SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION SystemHypervisorDetailInformation, // q: SYSTEM_HYPERVISOR_DETAIL_INFORMATION SystemProcessorCycleStatsInformation, // q: SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION (EX in: USHORT ProcessorGroup) // 160 SystemVmGenerationCountInformation, SystemTrustedPlatformModuleInformation, // q: SYSTEM_TPM_INFORMATION SystemKernelDebuggerFlags, // SYSTEM_KERNEL_DEBUGGER_FLAGS SystemCodeIntegrityPolicyInformation, // q; s: SYSTEM_CODEINTEGRITYPOLICY_INFORMATION SystemIsolatedUserModeInformation, // q: SYSTEM_ISOLATED_USER_MODE_INFORMATION SystemHardwareSecurityTestInterfaceResultsInformation, SystemSingleModuleInformation, // q: SYSTEM_SINGLE_MODULE_INFORMATION SystemAllowedCpuSetsInformation, SystemVsmProtectionInformation, // q: SYSTEM_VSM_PROTECTION_INFORMATION (previously SystemDmaProtectionInformation) SystemInterruptCpuSetsInformation, // q: SYSTEM_INTERRUPT_CPU_SET_INFORMATION // 170 SystemSecureBootPolicyFullInformation, // q: SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION SystemCodeIntegrityPolicyFullInformation, SystemAffinitizedInterruptProcessorInformation, // (requires SeIncreaseBasePriorityPrivilege) SystemRootSiloInformation, // q: SYSTEM_ROOT_SILO_INFORMATION SystemCpuSetInformation, // q: SYSTEM_CPU_SET_INFORMATION // since THRESHOLD2 SystemCpuSetTagInformation, // q: SYSTEM_CPU_SET_TAG_INFORMATION SystemWin32WerStartCallout, SystemSecureKernelProfileInformation, // q: SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION SystemCodeIntegrityPlatformManifestInformation, // q: SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION // since REDSTONE SystemInterruptSteeringInformation, // SYSTEM_INTERRUPT_STEERING_INFORMATION_INPUT // 180 SystemSupportedProcessorArchitectures, // p: in opt: HANDLE, out: SYSTEM_SUPPORTED_PROCESSOR_ARCHITECTURES_INFORMATION[] // NtQuerySystemInformationEx SystemMemoryUsageInformation, // q: SYSTEM_MEMORY_USAGE_INFORMATION SystemCodeIntegrityCertificateInformation, // q: SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION SystemPhysicalMemoryInformation, // q: SYSTEM_PHYSICAL_MEMORY_INFORMATION // since REDSTONE2 SystemControlFlowTransition, SystemKernelDebuggingAllowed, // s: ULONG SystemActivityModerationExeState, // SYSTEM_ACTIVITY_MODERATION_EXE_STATE SystemActivityModerationUserSettings, // SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS SystemCodeIntegrityPoliciesFullInformation, SystemCodeIntegrityUnlockInformation, // SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION // 190 SystemIntegrityQuotaInformation, SystemFlushInformation, // q: SYSTEM_FLUSH_INFORMATION SystemProcessorIdleMaskInformation, // q: ULONG_PTR[ActiveGroupCount] // since REDSTONE3 SystemSecureDumpEncryptionInformation, SystemWriteConstraintInformation, // SYSTEM_WRITE_CONSTRAINT_INFORMATION SystemKernelVaShadowInformation, // SYSTEM_KERNEL_VA_SHADOW_INFORMATION SystemHypervisorSharedPageInformation, // SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION // since REDSTONE4 SystemFirmwareBootPerformanceInformation, SystemCodeIntegrityVerificationInformation, // SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION SystemFirmwarePartitionInformation, // SYSTEM_FIRMWARE_PARTITION_INFORMATION // 200 SystemSpeculationControlInformation, // SYSTEM_SPECULATION_CONTROL_INFORMATION // (CVE-2017-5715) REDSTONE3 and above. SystemDmaGuardPolicyInformation, // SYSTEM_DMA_GUARD_POLICY_INFORMATION SystemEnclaveLaunchControlInformation, // SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION SystemWorkloadAllowedCpuSetsInformation, // SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION // since REDSTONE5 SystemCodeIntegrityUnlockModeInformation, SystemLeapSecondInformation, // SYSTEM_LEAP_SECOND_INFORMATION SystemFlags2Information, // q: SYSTEM_FLAGS_INFORMATION SystemSecurityModelInformation, // SYSTEM_SECURITY_MODEL_INFORMATION // since 19H1 SystemCodeIntegritySyntheticCacheInformation, SystemFeatureConfigurationInformation, // SYSTEM_FEATURE_CONFIGURATION_INFORMATION // since 20H1 // 210 SystemFeatureConfigurationSectionInformation, // SYSTEM_FEATURE_CONFIGURATION_SECTIONS_INFORMATION SystemFeatureUsageSubscriptionInformation, // SYSTEM_FEATURE_USAGE_SUBSCRIPTION_DETAILS SystemSecureSpeculationControlInformation, // SECURE_SPECULATION_CONTROL_INFORMATION SystemSpacesBootInformation, // since 20H2 SystemFwRamdiskInformation, // SYSTEM_FIRMWARE_RAMDISK_INFORMATION SystemWheaIpmiHardwareInformation, SystemDifSetRuleClassInformation, SystemDifClearRuleClassInformation, SystemDifApplyPluginVerificationOnDriver, SystemDifRemovePluginVerificationOnDriver, // 220 SystemShadowStackInformation, // SYSTEM_SHADOW_STACK_INFORMATION SystemBuildVersionInformation, // SYSTEM_BUILD_VERSION_INFORMATION SystemPoolLimitInformation, // SYSTEM_POOL_LIMIT_INFORMATION SystemCodeIntegrityAddDynamicStore, SystemCodeIntegrityClearDynamicStores, SystemDifPoolTrackingInformation, SystemPoolZeroingInformation, // SYSTEM_POOL_ZEROING_INFORMATION SystemDpcWatchdogInformation, SystemDpcWatchdogInformation2, SystemSupportedProcessorArchitectures2, // q: in opt: HANDLE, out: SYSTEM_SUPPORTED_PROCESSOR_ARCHITECTURES_INFORMATION[] // NtQuerySystemInformationEx // 230 SystemSingleProcessorRelationshipInformation, // q: SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX // (EX in: PROCESSOR_NUMBER Processor) SystemXfgCheckFailureInformation, SystemIommuStateInformation, // SYSTEM_IOMMU_STATE_INFORMATION // since 22H1 SystemHypervisorMinrootInformation, // SYSTEM_HYPERVISOR_MINROOT_INFORMATION SystemHypervisorBootPagesInformation, // SYSTEM_HYPERVISOR_BOOT_PAGES_INFORMATION SystemPointerAuthInformation, // SYSTEM_POINTER_AUTH_INFORMATION SystemSecureKernelDebuggerInformation, SystemOriginalImageFeatureInformation, MaxSystemInfoClass } SYSTEM_INFORMATION_CLASS; typedef enum _OBJECT_INFORMATION_CLASS { ObjectBasicInformation, // OBJECT_BASIC_INFORMATION ObjectNameInformation, // OBJECT_NAME_INFORMATION ObjectTypeInformation, // OBJECT_TYPE_INFORMATION ObjectTypesInformation, // OBJECT_TYPES_INFORMATION ObjectHandleFlagInformation, // OBJECT_HANDLE_FLAG_INFORMATION ObjectSessionInformation, ObjectSessionObjectInformation, MaxObjectInfoClass } OBJECT_INFORMATION_CLASS; // Source: http://processhacker.sourceforge.net typedef enum _THREADINFOCLASS { ThreadBasicInformation, // q: THREAD_BASIC_INFORMATION ThreadTimes, // q: KERNEL_USER_TIMES ThreadPriority, // s: KPRIORITY (requires SeIncreaseBasePriorityPrivilege) ThreadBasePriority, // s: KPRIORITY ThreadAffinityMask, // s: KAFFINITY ThreadImpersonationToken, // s: HANDLE ThreadDescriptorTableEntry, // q: DESCRIPTOR_TABLE_ENTRY (or WOW64_DESCRIPTOR_TABLE_ENTRY) ThreadEnableAlignmentFaultFixup, // s: BOOLEAN ThreadEventPair, ThreadQuerySetWin32StartAddress, // q: ULONG_PTR ThreadZeroTlsCell, // s: ULONG // TlsIndex // 10 ThreadPerformanceCount, // q: LARGE_INTEGER ThreadAmILastThread, // q: ULONG ThreadIdealProcessor, // s: ULONG ThreadPriorityBoost, // qs: ULONG ThreadSetTlsArrayAddress, // s: ULONG_PTR ThreadIsIoPending, // q: ULONG ThreadHideFromDebugger, // q: BOOLEAN; s: void ThreadBreakOnTermination, // qs: ULONG ThreadSwitchLegacyState, // s: void // NtCurrentThread // NPX/FPU ThreadIsTerminated, // q: ULONG // 20 ThreadLastSystemCall, // q: THREAD_LAST_SYSCALL_INFORMATION ThreadIoPriority, // qs: IO_PRIORITY_HINT (requires SeIncreaseBasePriorityPrivilege) ThreadCycleTime, // q: THREAD_CYCLE_TIME_INFORMATION ThreadPagePriority, // qs: PAGE_PRIORITY_INFORMATION ThreadActualBasePriority, // s: LONG (requires SeIncreaseBasePriorityPrivilege) ThreadTebInformation, // q: THREAD_TEB_INFORMATION (requires THREAD_GET_CONTEXT + THREAD_SET_CONTEXT) ThreadCSwitchMon, ThreadCSwitchPmu, ThreadWow64Context, // qs: WOW64_CONTEXT ThreadGroupInformation, // qs: GROUP_AFFINITY // 30 ThreadUmsInformation, // q: THREAD_UMS_INFORMATION ThreadCounterProfiling, // q: BOOLEAN; s: THREAD_PROFILING_INFORMATION? ThreadIdealProcessorEx, // qs: PROCESSOR_NUMBER; s: previous PROCESSOR_NUMBER on return ThreadCpuAccountingInformation, // q: BOOLEAN; s: HANDLE (NtOpenSession) // NtCurrentThread // since WIN8 ThreadSuspendCount, // q: ULONG // since WINBLUE ThreadHeterogeneousCpuPolicy, // q: KHETERO_CPU_POLICY // since THRESHOLD ThreadContainerId, // q: GUID ThreadNameInformation, // qs: THREAD_NAME_INFORMATION ThreadSelectedCpuSets, ThreadSystemThreadInformation, // q: SYSTEM_THREAD_INFORMATION // 40 ThreadActualGroupAffinity, // q: GROUP_AFFINITY // since THRESHOLD2 ThreadDynamicCodePolicyInfo, // q: ULONG; s: ULONG (NtCurrentThread) ThreadExplicitCaseSensitivity, // qs: ULONG; s: 0 disables, otherwise enables ThreadWorkOnBehalfTicket, // RTL_WORK_ON_BEHALF_TICKET_EX ThreadSubsystemInformation, // q: SUBSYSTEM_INFORMATION_TYPE // since REDSTONE2 ThreadDbgkWerReportActive, // s: ULONG; s: 0 disables, otherwise enables ThreadAttachContainer, // s: HANDLE (job object) // NtCurrentThread ThreadManageWritesToExecutableMemory, // MANAGE_WRITES_TO_EXECUTABLE_MEMORY // since REDSTONE3 ThreadPowerThrottlingState, // POWER_THROTTLING_THREAD_STATE ThreadWorkloadClass, // THREAD_WORKLOAD_CLASS // since REDSTONE5 // 50 ThreadCreateStateChange, // since WIN11 ThreadApplyStateChange, ThreadStrongerBadHandleChecks, // since 22H1 ThreadEffectiveIoPriority, // q: IO_PRIORITY_HINT ThreadEffectivePagePriority, // q: ULONG MaxThreadInfoClass } THREADINFOCLASS; // JOBOBJECTINFOCLASS // Source: http://processhacker.sourceforge.net // Note: We don't use an enum since it conflicts with the Windows SDK. #define JobObjectBasicAccountingInformation ((JOBOBJECTINFOCLASS)1) // JOBOBJECT_BASIC_ACCOUNTING_INFORMATION #define JobObjectBasicLimitInformation ((JOBOBJECTINFOCLASS)2) // JOBOBJECT_BASIC_LIMIT_INFORMATION #define JobObjectBasicProcessIdList ((JOBOBJECTINFOCLASS)3) // JOBOBJECT_BASIC_PROCESS_ID_LIST #define JobObjectBasicUIRestrictions ((JOBOBJECTINFOCLASS)4) // JOBOBJECT_BASIC_UI_RESTRICTIONS #define JobObjectSecurityLimitInformation ((JOBOBJECTINFOCLASS)5) // JOBOBJECT_SECURITY_LIMIT_INFORMATION #define JobObjectEndOfJobTimeInformation ((JOBOBJECTINFOCLASS)6) // JOBOBJECT_END_OF_JOB_TIME_INFORMATION #define JobObjectAssociateCompletionPortInformation ((JOBOBJECTINFOCLASS)7) // JOBOBJECT_ASSOCIATE_COMPLETION_PORT #define JobObjectBasicAndIoAccountingInformation ((JOBOBJECTINFOCLASS)8) // JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION #define JobObjectExtendedLimitInformation ((JOBOBJECTINFOCLASS)9) // JOBOBJECT_EXTENDED_LIMIT_INFORMATION #define JobObjectJobSetInformation ((JOBOBJECTINFOCLASS)10) // JOBOBJECT_JOBSET_INFORMATION #define JobObjectGroupInformation ((JOBOBJECTINFOCLASS)11) // USHORT #define JobObjectNotificationLimitInformation ((JOBOBJECTINFOCLASS)12) // JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION #define JobObjectLimitViolationInformation ((JOBOBJECTINFOCLASS)13) // JOBOBJECT_LIMIT_VIOLATION_INFORMATION #define JobObjectGroupInformationEx ((JOBOBJECTINFOCLASS)14) // GROUP_AFFINITY (ARRAY) #define JobObjectCpuRateControlInformation ((JOBOBJECTINFOCLASS)15) // JOBOBJECT_CPU_RATE_CONTROL_INFORMATION #define JobObjectCompletionFilter ((JOBOBJECTINFOCLASS)16) #define JobObjectCompletionCounter ((JOBOBJECTINFOCLASS)17) #define JobObjectFreezeInformation ((JOBOBJECTINFOCLASS)18) // JOBOBJECT_FREEZE_INFORMATION #define JobObjectExtendedAccountingInformation ((JOBOBJECTINFOCLASS)19) // JOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION #define JobObjectWakeInformation ((JOBOBJECTINFOCLASS)20) // JOBOBJECT_WAKE_INFORMATION #define JobObjectBackgroundInformation ((JOBOBJECTINFOCLASS)21) #define JobObjectSchedulingRankBiasInformation ((JOBOBJECTINFOCLASS)22) #define JobObjectTimerVirtualizationInformation ((JOBOBJECTINFOCLASS)23) #define JobObjectCycleTimeNotification ((JOBOBJECTINFOCLASS)24) #define JobObjectClearEvent ((JOBOBJECTINFOCLASS)25) #define JobObjectInterferenceInformation ((JOBOBJECTINFOCLASS)26) // JOBOBJECT_INTERFERENCE_INFORMATION #define JobObjectClearPeakJobMemoryUsed ((JOBOBJECTINFOCLASS)27) #define JobObjectMemoryUsageInformation ((JOBOBJECTINFOCLASS)28) // JOBOBJECT_MEMORY_USAGE_INFORMATION // JOBOBJECT_MEMORY_USAGE_INFORMATION_V2 #define JobObjectSharedCommit ((JOBOBJECTINFOCLASS)29) #define JobObjectContainerId ((JOBOBJECTINFOCLASS)30) #define JobObjectIoRateControlInformation ((JOBOBJECTINFOCLASS)31) #define JobObjectNetRateControlInformation ((JOBOBJECTINFOCLASS)32) // JOBOBJECT_NET_RATE_CONTROL_INFORMATION #define JobObjectNotificationLimitInformation2 ((JOBOBJECTINFOCLASS)33) // JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2 #define JobObjectLimitViolationInformation2 ((JOBOBJECTINFOCLASS)34) // JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2 #define JobObjectCreateSilo ((JOBOBJECTINFOCLASS)35) #define JobObjectSiloBasicInformation ((JOBOBJECTINFOCLASS)36) // SILOOBJECT_BASIC_INFORMATION #define JobObjectSiloRootDirectory ((JOBOBJECTINFOCLASS)37) // SILOOBJECT_ROOT_DIRECTORY #define JobObjectServerSiloBasicInformation ((JOBOBJECTINFOCLASS)38) // SERVERSILO_BASIC_INFORMATION #define JobObjectServerSiloUserSharedData ((JOBOBJECTINFOCLASS)39) // SILO_USER_SHARED_DATA #define JobObjectServerSiloInitialize ((JOBOBJECTINFOCLASS)40) #define JobObjectServerSiloRunningState ((JOBOBJECTINFOCLASS)41) #define JobObjectIoAttribution ((JOBOBJECTINFOCLASS)42) #define JobObjectMemoryPartitionInformation ((JOBOBJECTINFOCLASS)43) #define JobObjectContainerTelemetryId ((JOBOBJECTINFOCLASS)44) #define JobObjectSiloSystemRoot ((JOBOBJECTINFOCLASS)45) #define JobObjectEnergyTrackingState ((JOBOBJECTINFOCLASS)46) // JOBOBJECT_ENERGY_TRACKING_STATE #define JobObjectThreadImpersonationInformation ((JOBOBJECTINFOCLASS)47) #define MaxJobObjectInfoClass ((JOBOBJECTINFOCLASS)48) typedef enum _FSINFOCLASS { FileFsVolumeInformation = 1, // FILE_FS_VOLUME_INFORMATION FileFsLabelInformation = 2, // FILE_FS_LABEL_INFORMATION FileFsSizeInformation = 3, // FILE_FS_SIZE_INFORMATION FileFsDeviceInformation = 4, // FILE_FS_DEVICE_INFORMATION FileFsAttributeInformation = 5, // FILE_FS_ATTRIBUTE_INFORMATION FileFsControlInformation = 6, // FILE_FS_CONTROL_INFORMATION FileFsFullSizeInformation = 7, // FILE_FS_FULL_SIZE_INFORMATION FileFsObjectIdInformation = 8, // FILE_FS_OBJECTID_INFORMATION FileFsDriverPathInformation = 9, // FILE_FS_DRIVER_PATH_INFORMATION FileFsVolumeFlagsInformation = 10, // FILE_FS_VOLUME_FLAGS_INFORMATION FileFsSectorSizeInformation = 11, // FILE_FS_SECTOR_SIZE_INFORMATION // since WIN8 FileFsDataCopyInformation = 12, // FILE_FS_DATA_COPY_INFORMATION FileFsMetadataSizeInformation = 13, // FILE_FS_METADATA_SIZE_INFORMATION // since THRESHOLD FileFsMaximumInformation } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS; typedef enum _MEMORY_INFORMATION_CLASS { MemoryBasicInformation, // MEMORY_BASIC_INFORMATION MemoryWorkingSetInformation, // MEMORY_WORKING_SET_INFORMATION MemoryMappedFilenameInformation, // UNICODE_STRING MemoryRegionInformation, // MEMORY_REGION_INFORMATION MemoryWorkingSetExInformation, // MEMORY_WORKING_SET_EX_INFORMATION MemorySharedCommitInformation, // MEMORY_SHARED_COMMIT_INFORMATION MemoryImageInformation, // MEMORY_IMAGE_INFORMATION MemoryRegionInformationEx, MemoryPrivilegedBasicInformation } MEMORY_INFORMATION_CLASS; typedef enum _SECTION_INFORMATION_CLASS { SectionBasicInformation, // q; SECTION_BASIC_INFORMATION SectionImageInformation, // q; SECTION_IMAGE_INFORMATION SectionRelocationInformation, // name:wow64:whNtQuerySection_SectionRelocationInformation SectionOriginalBaseInformation, // PVOID BaseAddress SectionInternalImageInformation, // SECTION_INTERNAL_IMAGE_INFORMATION // since REDSTONE2 MaxSectionInfoClass } SECTION_INFORMATION_CLASS; // Boot condition flags (NtInitializeRegistry) #define REG_INIT_BOOT_SM 0x0000 #define REG_INIT_BOOT_SETUP 0x0001 #define REG_INIT_BOOT_ACCEPTED_BASE 0x0002 #define REG_INIT_BOOT_ACCEPTED_MAX (REG_INIT_BOOT_ACCEPTED_BASE + 999) #define REG_MAX_KEY_VALUE_NAME_LENGTH 32767 #define REG_MAX_KEY_NAME_LENGTH 512 typedef enum _KEY_INFORMATION_CLASS { KeyBasicInformation, // KEY_BASIC_INFORMATION KeyNodeInformation, // KEY_NODE_INFORMATION KeyFullInformation, // KEY_FULL_INFORMATION KeyNameInformation, // KEY_NAME_INFORMATION KeyCachedInformation, // KEY_CACHED_INFORMATION KeyFlagsInformation, // KEY_FLAGS_INFORMATION KeyVirtualizationInformation, // KEY_VIRTUALIZATION_INFORMATION KeyHandleTagsInformation, // KEY_HANDLE_TAGS_INFORMATION KeyTrustInformation, // KEY_TRUST_INFORMATION KeyLayerInformation, // KEY_LAYER_INFORMATION MaxKeyInfoClass } KEY_INFORMATION_CLASS; typedef struct _KEY_BASIC_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG NameLength; WCHAR Name[1]; } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION; typedef struct _KEY_NODE_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG NameLength; WCHAR Name[1]; // ... // WCHAR Class[1]; } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION; typedef struct _KEY_FULL_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG ClassOffset; ULONG ClassLength; ULONG SubKeys; ULONG MaxNameLen; ULONG MaxClassLen; ULONG Values; ULONG MaxValueNameLen; ULONG MaxValueDataLen; WCHAR Class[1]; } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION; typedef struct _KEY_NAME_INFORMATION { ULONG NameLength; WCHAR Name[1]; } KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION; typedef struct _KEY_CACHED_INFORMATION { LARGE_INTEGER LastWriteTime; ULONG TitleIndex; ULONG SubKeys; ULONG MaxNameLen; ULONG Values; ULONG MaxValueNameLen; ULONG MaxValueDataLen; ULONG NameLength; WCHAR Name[1]; } KEY_CACHED_INFORMATION, *PKEY_CACHED_INFORMATION; typedef struct _KEY_FLAGS_INFORMATION { ULONG UserFlags; } KEY_FLAGS_INFORMATION, *PKEY_FLAGS_INFORMATION; typedef struct _KEY_VIRTUALIZATION_INFORMATION { ULONG VirtualizationCandidate : 1; // Tells whether the key is part of the virtualization namespace scope (only HKLM\Software for now). ULONG VirtualizationEnabled : 1; // Tells whether virtualization is enabled on this key. Can be 1 only if above flag is 1. ULONG VirtualTarget : 1; // Tells if the key is a virtual key. Can be 1 only if above 2 are 0. Valid only on the virtual store key handles. ULONG VirtualStore : 1; // Tells if the key is a part of the virtual store path. Valid only on the virtual store key handles. ULONG VirtualSource : 1; // Tells if the key has ever been virtualized, can be 1 only if VirtualizationCandidate is 1. ULONG Reserved : 27; } KEY_VIRTUALIZATION_INFORMATION, *PKEY_VIRTUALIZATION_INFORMATION; // private typedef struct _KEY_TRUST_INFORMATION { ULONG TrustedKey : 1; ULONG Reserved : 31; } KEY_TRUST_INFORMATION, *PKEY_TRUST_INFORMATION; // private typedef struct _KEY_LAYER_INFORMATION { ULONG IsTombstone; ULONG IsSupersedeLocal; ULONG IsSupersedeTree; ULONG ClassIsInherited; ULONG Reserved; } KEY_LAYER_INFORMATION, *PKEY_LAYER_INFORMATION; typedef enum _KEY_SET_INFORMATION_CLASS { KeyWriteTimeInformation, // KEY_WRITE_TIME_INFORMATION KeyWow64FlagsInformation, // KEY_WOW64_FLAGS_INFORMATION KeyControlFlagsInformation, // KEY_CONTROL_FLAGS_INFORMATION KeySetVirtualizationInformation, // KEY_SET_VIRTUALIZATION_INFORMATION KeySetDebugInformation, KeySetHandleTagsInformation, // KEY_HANDLE_TAGS_INFORMATION KeySetLayerInformation, // KEY_SET_LAYER_INFORMATION MaxKeySetInfoClass } KEY_SET_INFORMATION_CLASS; typedef struct _KEY_WRITE_TIME_INFORMATION { LARGE_INTEGER LastWriteTime; } KEY_WRITE_TIME_INFORMATION, *PKEY_WRITE_TIME_INFORMATION; typedef struct _KEY_WOW64_FLAGS_INFORMATION { ULONG UserFlags; } KEY_WOW64_FLAGS_INFORMATION, *PKEY_WOW64_FLAGS_INFORMATION; typedef struct _KEY_HANDLE_TAGS_INFORMATION { ULONG HandleTags; } KEY_HANDLE_TAGS_INFORMATION, *PKEY_HANDLE_TAGS_INFORMATION; typedef struct _KEY_SET_LAYER_INFORMATION { ULONG IsTombstone : 1; ULONG IsSupersedeLocal : 1; ULONG IsSupersedeTree : 1; ULONG ClassIsInherited : 1; ULONG Reserved : 28; } KEY_SET_LAYER_INFORMATION, *PKEY_SET_LAYER_INFORMATION; typedef struct _KEY_CONTROL_FLAGS_INFORMATION { ULONG ControlFlags; } KEY_CONTROL_FLAGS_INFORMATION, *PKEY_CONTROL_FLAGS_INFORMATION; typedef struct _KEY_SET_VIRTUALIZATION_INFORMATION { ULONG VirtualTarget : 1; ULONG VirtualStore : 1; ULONG VirtualSource : 1; // true if key has been virtualized at least once ULONG Reserved : 29; } KEY_SET_VIRTUALIZATION_INFORMATION, *PKEY_SET_VIRTUALIZATION_INFORMATION; typedef enum _KEY_VALUE_INFORMATION_CLASS { KeyValueBasicInformation, // KEY_VALUE_BASIC_INFORMATION KeyValueFullInformation, // KEY_VALUE_FULL_INFORMATION KeyValuePartialInformation, // KEY_VALUE_PARTIAL_INFORMATION KeyValueFullInformationAlign64, KeyValuePartialInformationAlign64, // KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 KeyValueLayerInformation, // KEY_VALUE_LAYER_INFORMATION MaxKeyValueInfoClass } KEY_VALUE_INFORMATION_CLASS; typedef struct _KEY_VALUE_BASIC_INFORMATION { ULONG TitleIndex; ULONG Type; ULONG NameLength; WCHAR Name[1]; } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION; typedef struct _KEY_VALUE_FULL_INFORMATION { ULONG TitleIndex; ULONG Type; ULONG DataOffset; ULONG DataLength; ULONG NameLength; WCHAR Name[1]; // ... // UCHAR Data[1]; } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION; typedef struct _KEY_VALUE_PARTIAL_INFORMATION { ULONG TitleIndex; ULONG Type; ULONG DataLength; UCHAR Data[1]; } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION; typedef struct _KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 { ULONG Type; ULONG DataLength; UCHAR Data[1]; } KEY_VALUE_PARTIAL_INFORMATION_ALIGN64, *PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64; // private typedef struct _KEY_VALUE_LAYER_INFORMATION { ULONG IsTombstone; ULONG Reserved; } KEY_VALUE_LAYER_INFORMATION, *PKEY_VALUE_LAYER_INFORMATION; typedef struct _KEY_VALUE_ENTRY { PUNICODE_STRING ValueName; ULONG DataLength; ULONG DataOffset; ULONG Type; } KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY; typedef enum _REG_ACTION { KeyAdded, KeyRemoved, KeyModified } REG_ACTION; typedef struct _REG_NOTIFY_INFORMATION { ULONG NextEntryOffset; REG_ACTION Action; ULONG KeyLength; WCHAR Key[1]; } REG_NOTIFY_INFORMATION, *PREG_NOTIFY_INFORMATION; typedef struct _KEY_PID_ARRAY { HANDLE PID; UNICODE_STRING KeyName; } KEY_PID_ARRAY, *PKEY_PID_ARRAY; typedef struct _KEY_OPEN_SUBKEYS_INFORMATION { ULONG Count; KEY_PID_ARRAY KeyArray[1]; } KEY_OPEN_SUBKEYS_INFORMATION, *PKEY_OPEN_SUBKEYS_INFORMATION; typedef enum _SYSDBG_COMMAND { SysDbgQueryModuleInformation, SysDbgQueryTraceInformation, SysDbgSetTracepoint, SysDbgSetSpecialCall, SysDbgClearSpecialCalls, SysDbgQuerySpecialCalls, SysDbgBreakPoint, SysDbgQueryVersion, SysDbgReadVirtual, SysDbgWriteVirtual, SysDbgReadPhysical, SysDbgWritePhysical, SysDbgReadControlSpace, SysDbgWriteControlSpace, SysDbgReadIoSpace, SysDbgWriteIoSpace, SysDbgReadMsr, SysDbgWriteMsr, SysDbgReadBusData, SysDbgWriteBusData, SysDbgCheckLowMemory, SysDbgEnableKernelDebugger, SysDbgDisableKernelDebugger, SysDbgGetAutoKdEnable, SysDbgSetAutoKdEnable, SysDbgGetPrintBufferSize, SysDbgSetPrintBufferSize, SysDbgGetKdUmExceptionEnable, SysDbgSetKdUmExceptionEnable, SysDbgGetTriageDump, SysDbgGetKdBlockEnable, SysDbgSetKdBlockEnable, SysDbgRegisterForUmBreakInfo, SysDbgGetUmBreakPid, SysDbgClearUmBreakPid, SysDbgGetUmAttachPid, SysDbgClearUmAttachPid, SysDbgGetLiveKernelDump, SysDbgKdPullRemoteFile } SYSDBG_COMMAND, *PSYSDBG_COMMAND; typedef enum _SHUTDOWN_ACTION { ShutdownNoReboot, ShutdownReboot, ShutdownPowerOff } SHUTDOWN_ACTION, *PSHUTDOWN_ACTION; typedef enum _DEBUGOBJECTINFOCLASS { DebugObjectFlags = 1, MaxDebugObjectInfoClass } DEBUGOBJECTINFOCLASS, *PDEBUGOBJECTINFOCLASS; // Source: http://processhacker.sourceforge.net typedef enum _FILE_INFORMATION_CLASS { FileDirectoryInformation = 1, // FILE_DIRECTORY_INFORMATION FileFullDirectoryInformation, // FILE_FULL_DIR_INFORMATION FileBothDirectoryInformation, // FILE_BOTH_DIR_INFORMATION FileBasicInformation, // FILE_BASIC_INFORMATION FileStandardInformation, // FILE_STANDARD_INFORMATION FileInternalInformation, // FILE_INTERNAL_INFORMATION FileEaInformation, // FILE_EA_INFORMATION FileAccessInformation, // FILE_ACCESS_INFORMATION FileNameInformation, // FILE_NAME_INFORMATION FileRenameInformation, // FILE_RENAME_INFORMATION // 10 FileLinkInformation, // FILE_LINK_INFORMATION FileNamesInformation, // FILE_NAMES_INFORMATION FileDispositionInformation, // FILE_DISPOSITION_INFORMATION FilePositionInformation, // FILE_POSITION_INFORMATION FileFullEaInformation, // FILE_FULL_EA_INFORMATION FileModeInformation, // FILE_MODE_INFORMATION FileAlignmentInformation, // FILE_ALIGNMENT_INFORMATION FileAllInformation, // FILE_ALL_INFORMATION FileAllocationInformation, // FILE_ALLOCATION_INFORMATION FileEndOfFileInformation, // FILE_END_OF_FILE_INFORMATION // 20 FileAlternateNameInformation, // FILE_NAME_INFORMATION FileStreamInformation, // FILE_STREAM_INFORMATION FilePipeInformation, // FILE_PIPE_INFORMATION FilePipeLocalInformation, // FILE_PIPE_LOCAL_INFORMATION FilePipeRemoteInformation, // FILE_PIPE_REMOTE_INFORMATION FileMailslotQueryInformation, // FILE_MAILSLOT_QUERY_INFORMATION FileMailslotSetInformation, // FILE_MAILSLOT_SET_INFORMATION FileCompressionInformation, // FILE_COMPRESSION_INFORMATION FileObjectIdInformation, // FILE_OBJECTID_INFORMATION FileCompletionInformation, // FILE_COMPLETION_INFORMATION // 30 FileMoveClusterInformation, // FILE_MOVE_CLUSTER_INFORMATION FileQuotaInformation, // FILE_QUOTA_INFORMATION FileReparsePointInformation, // FILE_REPARSE_POINT_INFORMATION FileNetworkOpenInformation, // FILE_NETWORK_OPEN_INFORMATION FileAttributeTagInformation, // FILE_ATTRIBUTE_TAG_INFORMATION FileTrackingInformation, // FILE_TRACKING_INFORMATION FileIdBothDirectoryInformation, // FILE_ID_BOTH_DIR_INFORMATION FileIdFullDirectoryInformation, // FILE_ID_FULL_DIR_INFORMATION FileValidDataLengthInformation, // FILE_VALID_DATA_LENGTH_INFORMATION FileShortNameInformation, // FILE_NAME_INFORMATION // 40 FileIoCompletionNotificationInformation, // FILE_IO_COMPLETION_NOTIFICATION_INFORMATION // since VISTA FileIoStatusBlockRangeInformation, // FILE_IOSTATUSBLOCK_RANGE_INFORMATION FileIoPriorityHintInformation, // FILE_IO_PRIORITY_HINT_INFORMATION FileSfioReserveInformation, // FILE_SFIO_RESERVE_INFORMATION FileSfioVolumeInformation, // FILE_SFIO_VOLUME_INFORMATION FileHardLinkInformation, // FILE_LINKS_INFORMATION FileProcessIdsUsingFileInformation, // FILE_PROCESS_IDS_USING_FILE_INFORMATION FileNormalizedNameInformation, // FILE_NAME_INFORMATION FileNetworkPhysicalNameInformation, // FILE_NETWORK_PHYSICAL_NAME_INFORMATION FileIdGlobalTxDirectoryInformation, // FILE_ID_GLOBAL_TX_DIR_INFORMATION // since WIN7 // 50 FileIsRemoteDeviceInformation, // FILE_IS_REMOTE_DEVICE_INFORMATION FileUnusedInformation, FileNumaNodeInformation, // FILE_NUMA_NODE_INFORMATION FileStandardLinkInformation, // FILE_STANDARD_LINK_INFORMATION FileRemoteProtocolInformation, // FILE_REMOTE_PROTOCOL_INFORMATION FileRenameInformationBypassAccessCheck, // (kernel-mode only); FILE_RENAME_INFORMATION // since WIN8 FileLinkInformationBypassAccessCheck, // (kernel-mode only); FILE_LINK_INFORMATION FileVolumeNameInformation, // FILE_VOLUME_NAME_INFORMATION FileIdInformation, // FILE_ID_INFORMATION FileIdExtdDirectoryInformation, // FILE_ID_EXTD_DIR_INFORMATION FileReplaceCompletionInformation, // FILE_COMPLETION_INFORMATION // since WINBLUE FileHardLinkFullIdInformation, // FILE_LINK_ENTRY_FULL_ID_INFORMATION FileIdExtdBothDirectoryInformation, // FILE_ID_EXTD_BOTH_DIR_INFORMATION // since THRESHOLD FileDispositionInformationEx, // FILE_DISPOSITION_INFO_EX // since REDSTONE FileRenameInformationEx, // FILE_RENAME_INFORMATION_EX FileRenameInformationExBypassAccessCheck, // (kernel-mode only); FILE_RENAME_INFORMATION_EX FileDesiredStorageClassInformation, // FILE_DESIRED_STORAGE_CLASS_INFORMATION // since REDSTONE2 FileStatInformation, // FILE_STAT_INFORMATION FileMemoryPartitionInformation, // FILE_MEMORY_PARTITION_INFORMATION // since REDSTONE3 FileMaximumInformation } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS; typedef enum _DIRECTORY_NOTIFY_INFORMATION_CLASS { DirectoryNotifyInformation = 1, DirectoryNotifyExtendedInformation // 2 } DIRECTORY_NOTIFY_INFORMATION_CLASS, *PDIRECTORY_NOTIFY_INFORMATION_CLASS; typedef struct _SYSTEM_BASIC_INFORMATION { ULONG Reserved; ULONG TimerResolution; ULONG PageSize; ULONG NumberOfPhysicalPages; ULONG LowestPhysicalPageNumber; ULONG HighestPhysicalPageNumber; ULONG AllocationGranularity; ULONG_PTR MinimumUserModeAddress; ULONG_PTR MaximumUserModeAddress; ULONG_PTR ActiveProcessorsAffinityMask; CCHAR NumberOfProcessors; } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION; typedef struct _SYSTEM_PROCESSOR_INFORMATION { USHORT ProcessorArchitecture; USHORT ProcessorLevel; USHORT ProcessorRevision; USHORT MaximumProcessors; ULONG ProcessorFeatureBits; } SYSTEM_PROCESSOR_INFORMATION, *PSYSTEM_PROCESSOR_INFORMATION; // Named pipe FS control definitions #define DEVICE_NAMED_PIPE L"\\Device\\NamedPipe\\" #define FSCTL_PIPE_ASSIGN_EVENT CTL_CODE(FILE_DEVICE_NAMED_PIPE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_DISCONNECT CTL_CODE(FILE_DEVICE_NAMED_PIPE, 1, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_LISTEN CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_PEEK CTL_CODE(FILE_DEVICE_NAMED_PIPE, 3, METHOD_BUFFERED, FILE_READ_DATA) #define FSCTL_PIPE_QUERY_EVENT CTL_CODE(FILE_DEVICE_NAMED_PIPE, 4, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_TRANSCEIVE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 5, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA) #define FSCTL_PIPE_WAIT CTL_CODE(FILE_DEVICE_NAMED_PIPE, 6, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_IMPERSONATE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 7, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_SET_CLIENT_PROCESS CTL_CODE(FILE_DEVICE_NAMED_PIPE, 8, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_QUERY_CLIENT_PROCESS CTL_CODE(FILE_DEVICE_NAMED_PIPE, 9, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_GET_PIPE_ATTRIBUTE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 10, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_SET_PIPE_ATTRIBUTE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 11, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_GET_CONNECTION_ATTRIBUTE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 12, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_SET_CONNECTION_ATTRIBUTE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 13, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_GET_HANDLE_ATTRIBUTE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 14, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_SET_HANDLE_ATTRIBUTE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 15, METHOD_BUFFERED, FILE_ANY_ACCESS) #define FSCTL_PIPE_FLUSH CTL_CODE(FILE_DEVICE_NAMED_PIPE, 16, METHOD_BUFFERED, FILE_WRITE_DATA) #define FSCTL_PIPE_INTERNAL_READ CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2045, METHOD_BUFFERED, FILE_READ_DATA) #define FSCTL_PIPE_INTERNAL_WRITE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2046, METHOD_BUFFERED, FILE_WRITE_DATA) #define FSCTL_PIPE_INTERNAL_TRANSCEIVE CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2047, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA) #define FSCTL_PIPE_INTERNAL_READ_OVFLOW CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2048, METHOD_BUFFERED, FILE_READ_DATA) // Flags for query event #define FILE_PIPE_READ_DATA 0x00000000 #define FILE_PIPE_WRITE_SPACE 0x00000001 typedef struct _FILE_PIPE_PEEK_BUFFER { ULONG NamedPipeState; ULONG ReadDataAvailable; ULONG NumberOfMessages; ULONG MessageLength; CHAR Data[1]; } FILE_PIPE_PEEK_BUFFER, *PFILE_PIPE_PEEK_BUFFER; typedef struct _NAMED_PIPE_CREATE_PARAMETERS { ULONG NamedPipeType; ULONG ReadMode; ULONG CompletionMode; ULONG MaximumInstances; ULONG InboundQuota; ULONG OutboundQuota; LARGE_INTEGER DefaultTimeout; BOOLEAN TimeoutSpecified; } NAMED_PIPE_CREATE_PARAMETERS, *PNAMED_PIPE_CREATE_PARAMETERS; typedef struct _SYSTEM_TIMEOFDAY_INFORMATION { LARGE_INTEGER BootTime; LARGE_INTEGER CurrentTime; LARGE_INTEGER TimeZoneBias; ULONG TimeZoneId; ULONG Reserved; ULONGLONG BootTimeBias; ULONGLONG SleepTimeBias; } SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION; typedef struct _FILE_FS_DEVICE_INFORMATION { ULONG DeviceType; ULONG Characteristics; } FILE_FS_DEVICE_INFORMATION, *PFILE_FS_DEVICE_INFORMATION; typedef struct _TIME_FIELDS { SHORT Year; // range [1601...] SHORT Month; // range [1..12] SHORT Day; // range [1..31] SHORT Hour; // range [0..23] SHORT Minute; // range [0..59] SHORT Second; // range [0..59] SHORT Milliseconds; // range [0..999] SHORT Weekday; // range [0..6] == [Sunday..Saturday] } TIME_FIELDS, *PTIME_FIELDS; typedef struct _SYSTEM_CONSOLE_INFORMATION { ULONG DriverLoaded : 1; ULONG Spare : 31; } SYSTEM_CONSOLE_INFORMATION, *PSYSTEM_CONSOLE_INFORMATION; typedef struct _COMPRESSED_DATA_INFO { USHORT CompressionFormatAndEngine; // COMPRESSION_FORMAT_* and COMPRESSION_ENGINE_* UCHAR CompressionUnitShift; UCHAR ChunkShift; UCHAR ClusterShift; UCHAR Reserved; USHORT NumberOfChunks; ULONG CompressedChunkSizes[1]; } COMPRESSED_DATA_INFO, *PCOMPRESSED_DATA_INFO; typedef struct _KSYSTEM_TIME { ULONG LowPart; LONG High1Time; LONG High2Time; } KSYSTEM_TIME, *PKSYSTEM_TIME; typedef struct _PROCESS_ACCESS_TOKEN { HANDLE Token; // Needs TOKEN_ASSIGN_PRIMARY access HANDLE Thread; // Handle to initial/only thread; needs THREAD_QUERY_INFORMATION access } PROCESS_ACCESS_TOKEN, *PPROCESS_ACCESS_TOKEN; #ifdef __cplusplus typedef enum _PS_PROTECTED_TYPE : UCHAR { PsProtectedTypeNone, PsProtectedTypeProtectedLight, PsProtectedTypeProtected, PsProtectedTypeMax } PS_PROTECTED_TYPE; #else typedef UCHAR PS_PROTECTED_TYPE; #endif #ifdef __cplusplus typedef enum _PS_PROTECTED_SIGNER : UCHAR { PsProtectedSignerNone, PsProtectedSignerAuthenticode, PsProtectedSignerCodeGen, PsProtectedSignerAntimalware, PsProtectedSignerLsa, PsProtectedSignerWindows, PsProtectedSignerWinTcb, PsProtectedSignerWinSystem, PsProtectedSignerApp, PsProtectedSignerMax } PS_PROTECTED_SIGNER; #else typedef UCHAR PS_PROTECTED_SIGNER; #endif typedef struct _PS_PROTECTION { union { struct { PS_PROTECTED_TYPE Type : 3; BOOLEAN Audit : 1; PS_PROTECTED_SIGNER Signer : 4; } s; UCHAR Level; } u; } PS_PROTECTION, *PPS_PROTECTION; #define RTL_CREATE_ENVIRONMENT_TRANSLATE 0x1 // Translate from multi-byte to Unicode #define RTL_CREATE_ENVIRONMENT_TRANSLATE_FROM_OEM 0x2 // Translate from OEM to Unicode (Translate flag must also be set) #define RTL_CREATE_ENVIRONMENT_EMPTY 0x4 // Create empty environment block typedef struct _RTL_BUFFER { PUCHAR Buffer; PUCHAR StaticBuffer; SIZE_T Size; SIZE_T StaticSize; SIZE_T ReservedForAllocatedSize; // for future doubling PVOID ReservedForIMalloc; // for future pluggable growth } RTL_BUFFER, *PRTL_BUFFER; typedef struct _RTL_UNICODE_STRING_BUFFER { UNICODE_STRING String; RTL_BUFFER ByteBuffer; UCHAR MinimumStaticBufferForTerminalNul[sizeof(WCHAR)]; } RTL_UNICODE_STRING_BUFFER, *PRTL_UNICODE_STRING_BUFFER; typedef struct _RTL_USER_PROCESS_PARAMETERS { ULONG MaximumLength; ULONG Length; ULONG Flags; ULONG DebugFlags; HANDLE ConsoleHandle; ULONG ConsoleFlags; HANDLE StandardInput; HANDLE StandardOutput; HANDLE StandardError; CURDIR CurrentDirectory; UNICODE_STRING DllPath; UNICODE_STRING ImagePathName; UNICODE_STRING CommandLine; PWCHAR Environment; ULONG StartingX; ULONG StartingY; ULONG CountX; ULONG CountY; ULONG CountCharsX; ULONG CountCharsY; ULONG FillAttribute; ULONG WindowFlags; ULONG ShowWindowFlags; UNICODE_STRING WindowTitle; UNICODE_STRING DesktopInfo; UNICODE_STRING ShellInfo; UNICODE_STRING RuntimeData; RTL_DRIVE_LETTER_CURDIR CurrentDirectories[RTL_MAX_DRIVE_LETTERS]; ULONG_PTR EnvironmentSize; ULONG_PTR EnvironmentVersion; PVOID PackageDependencyData; ULONG ProcessGroupId; ULONG LoaderThreads; } RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS; #define RTL_USER_PROCESS_PARAMETERS_NORMALIZED 0x01 #define RTL_USER_PROCESS_PARAMETERS_PROFILE_USER 0x02 #define RTL_USER_PROCESS_PARAMETERS_PROFILE_KERNEL 0x04 #define RTL_USER_PROCESS_PARAMETERS_PROFILE_SERVER 0x08 #define RTL_USER_PROCESS_PARAMETERS_RESERVE_1MB 0x20 #define RTL_USER_PROCESS_PARAMETERS_RESERVE_16MB 0x40 #define RTL_USER_PROCESS_PARAMETERS_CASE_SENSITIVE 0x80 #define RTL_USER_PROCESS_PARAMETERS_DISABLE_HEAP_DECOMMIT 0x100 #define RTL_USER_PROCESS_PARAMETERS_DLL_REDIRECTION_LOCAL 0x1000 #define RTL_USER_PROCESS_PARAMETERS_APP_MANIFEST_PRESENT 0x2000 #define RTL_USER_PROCESS_PARAMETERS_IMAGE_KEY_MISSING 0x4000 #define RTL_USER_PROCESS_PARAMETERS_NX_OPTIN 0x20000 typedef struct _RTL_USER_PROCESS_INFORMATION { ULONG Length; HANDLE ProcessHandle; HANDLE ThreadHandle; CLIENT_ID ClientId; SECTION_IMAGE_INFORMATION ImageInformation; } RTL_USER_PROCESS_INFORMATION, *PRTL_USER_PROCESS_INFORMATION; // Handle tag bits for PEB stdio file handles #define PEB_STDIO_HANDLE_NATIVE 0 #define PEB_STDIO_HANDLE_SUBSYS 1 #define PEB_STDIO_HANDLE_PM 2 #define PEB_STDIO_HANDLE_RESERVED 3 #define GDI_HANDLE_BUFFER_SIZE32 34 #define GDI_HANDLE_BUFFER_SIZE64 60 #ifndef _WIN64 #define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE32 #else #define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE64 #endif typedef ULONG GDI_HANDLE_BUFFER32[GDI_HANDLE_BUFFER_SIZE32]; typedef ULONG GDI_HANDLE_BUFFER64[GDI_HANDLE_BUFFER_SIZE64]; typedef ULONG GDI_HANDLE_BUFFER[GDI_HANDLE_BUFFER_SIZE]; #define TLS_EXPANSION_SLOTS 1024 typedef struct _PEB_LDR_DATA { ULONG Length; BOOLEAN Initialized; HANDLE SsHandle; LIST_ENTRY InLoadOrderModuleList; LIST_ENTRY InMemoryOrderModuleList; LIST_ENTRY InInitializationOrderModuleList; PVOID EntryInProgress; BOOLEAN ShutdownInProgress; HANDLE ShutdownThreadId; } PEB_LDR_DATA, *PPEB_LDR_DATA; typedef struct _ACTIVATION_CONTEXT_STACK { struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME* ActiveFrame; LIST_ENTRY FrameListCache; ULONG Flags; ULONG NextCookieSequenceNumber; ULONG StackId; } ACTIVATION_CONTEXT_STACK, *PACTIVATION_CONTEXT_STACK; typedef struct _PEB { BOOLEAN InheritedAddressSpace; BOOLEAN ReadImageFileExecOptions; BOOLEAN BeingDebugged; union { BOOLEAN BitField; struct { BOOLEAN ImageUsesLargePages : 1; BOOLEAN IsProtectedProcess : 1; BOOLEAN IsImageDynamicallyRelocated : 1; BOOLEAN SkipPatchingUser32Forwarders : 1; BOOLEAN IsPackagedProcess : 1; BOOLEAN IsAppContainer : 1; BOOLEAN IsProtectedProcessLight : 1; BOOLEAN IsLongPathAwareProcess : 1; } s1; } u1; HANDLE Mutant; PVOID ImageBaseAddress; PPEB_LDR_DATA Ldr; PRTL_USER_PROCESS_PARAMETERS ProcessParameters; PVOID SubSystemData; PVOID ProcessHeap; PRTL_CRITICAL_SECTION FastPebLock; PVOID AtlThunkSListPtr; PVOID IFEOKey; union { ULONG CrossProcessFlags; struct { ULONG ProcessInJob : 1; ULONG ProcessInitializing : 1; ULONG ProcessUsingVEH : 1; ULONG ProcessUsingVCH : 1; ULONG ProcessUsingFTH : 1; ULONG ProcessPreviouslyThrottled : 1; ULONG ProcessCurrentlyThrottled : 1; ULONG ReservedBits0 : 25; } s2; } u2; union { PVOID KernelCallbackTable; PVOID UserSharedInfoPtr; } u3; ULONG SystemReserved[1]; ULONG AtlThunkSListPtr32; PVOID ApiSetMap; ULONG TlsExpansionCounter; PVOID TlsBitmap; ULONG TlsBitmapBits[2]; PVOID ReadOnlySharedMemoryBase; PVOID SharedData; // HotpatchInformation PVOID* ReadOnlyStaticServerData; PVOID AnsiCodePageData; // PCPTABLEINFO PVOID OemCodePageData; // PCPTABLEINFO PVOID UnicodeCaseTableData; // PNLSTABLEINFO ULONG NumberOfProcessors; ULONG NtGlobalFlag; LARGE_INTEGER CriticalSectionTimeout; SIZE_T HeapSegmentReserve; SIZE_T HeapSegmentCommit; SIZE_T HeapDeCommitTotalFreeThreshold; SIZE_T HeapDeCommitFreeBlockThreshold; ULONG NumberOfHeaps; ULONG MaximumNumberOfHeaps; PVOID* ProcessHeaps; // PHEAP PVOID GdiSharedHandleTable; PVOID ProcessStarterHelper; ULONG GdiDCAttributeList; PRTL_CRITICAL_SECTION LoaderLock; ULONG OSMajorVersion; ULONG OSMinorVersion; USHORT OSBuildNumber; USHORT OSCSDVersion; ULONG OSPlatformId; ULONG ImageSubsystem; ULONG ImageSubsystemMajorVersion; ULONG ImageSubsystemMinorVersion; ULONG_PTR ActiveProcessAffinityMask; GDI_HANDLE_BUFFER GdiHandleBuffer; PVOID PostProcessInitRoutine; PVOID TlsExpansionBitmap; ULONG TlsExpansionBitmapBits[32]; ULONG SessionId; ULARGE_INTEGER AppCompatFlags; ULARGE_INTEGER AppCompatFlagsUser; PVOID pShimData; PVOID AppCompatInfo; // APPCOMPAT_EXE_DATA UNICODE_STRING CSDVersion; PVOID ActivationContextData; // ACTIVATION_CONTEXT_DATA PVOID ProcessAssemblyStorageMap; // ASSEMBLY_STORAGE_MAP PVOID SystemDefaultActivationContextData; // ACTIVATION_CONTEXT_DATA PVOID SystemAssemblyStorageMap; // ASSEMBLY_STORAGE_MAP SIZE_T MinimumStackCommit; PVOID* FlsCallback; LIST_ENTRY FlsListHead; PVOID FlsBitmap; ULONG FlsBitmapBits[FLS_MAXIMUM_AVAILABLE / (sizeof(ULONG) * 8)]; ULONG FlsHighIndex; PVOID WerRegistrationData; PVOID WerShipAssertPtr; PVOID pUnused; // pContextData PVOID pImageHeaderHash; union { ULONG TracingFlags; struct { ULONG HeapTracingEnabled : 1; ULONG CritSecTracingEnabled : 1; ULONG LibLoaderTracingEnabled : 1; ULONG SpareTracingBits : 29; } s3; } u4; ULONGLONG CsrServerReadOnlySharedMemoryBase; PVOID TppWorkerpListLock; LIST_ENTRY TppWorkerpList; PVOID WaitOnAddressHashTable[128]; PVOID TelemetryCoverageHeader; // REDSTONE3 ULONG CloudFileFlags; } PEB, *PPEB; #define GDI_BATCH_BUFFER_SIZE 310 typedef struct _GDI_TEB_BATCH { ULONG Offset; ULONG_PTR HDC; ULONG Buffer[GDI_BATCH_BUFFER_SIZE]; } GDI_TEB_BATCH, *PGDI_TEB_BATCH; typedef struct _TEB_ACTIVE_FRAME_CONTEXT { ULONG Flags; PSTR 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 _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 ReservedForDebuggerInstrumentation[16]; #ifdef _WIN64 PVOID SystemReserved1[30]; #else PVOID SystemReserved1[26]; #endif CHAR PlaceholderCompatibilityMode; CHAR PlaceholderReserved[11]; ULONG ProxiedProcessId; ACTIVATION_CONTEXT_STACK ActivationStack; UCHAR WorkingOnBehalfTicket[8]; NTSTATUS ExceptionCode; PACTIVATION_CONTEXT_STACK ActivationContextStackPointer; ULONG_PTR InstrumentationCallbackSp; ULONG_PTR InstrumentationCallbackPreviousPc; ULONG_PTR InstrumentationCallbackPreviousSp; #ifdef _WIN64 ULONG TxFsContext; #endif BOOLEAN InstrumentationCallbackDisabled; #ifndef _WIN64 UCHAR SpareBytes[23]; ULONG TxFsContext; #endif GDI_TEB_BATCH GdiTebBatch; CLIENT_ID RealClientId; HANDLE GdiCachedProcessHandle; ULONG GdiClientPID; ULONG GdiClientTID; PVOID GdiThreadLocalInfo; ULONG_PTR Win32ClientInfo[62]; PVOID glDispatchTable[233]; ULONG_PTR 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]; ULONG HardErrorMode; #ifdef _WIN64 PVOID Instrumentation[11]; #else PVOID Instrumentation[9]; #endif GUID ActivityId; PVOID SubProcessTag; PVOID PerflibData; PVOID EtwTraceData; PVOID WinSockData; ULONG GdiBatchCount; union { PROCESSOR_NUMBER CurrentIdealProcessor; ULONG IdealProcessorValue; struct { UCHAR ReservedPad0; UCHAR ReservedPad1; UCHAR ReservedPad2; UCHAR IdealProcessor; } s1; } u1; ULONG GuaranteedStackBytes; PVOID ReservedForPerf; PVOID ReservedForOle; ULONG WaitingOnLoaderLock; PVOID SavedPriorityState; ULONG_PTR ReservedForCodeCoverage; PVOID ThreadPoolData; PVOID* TlsExpansionSlots; #ifdef _WIN64 PVOID DeallocationBStore; PVOID BStoreLimit; #endif ULONG MuiGeneration; ULONG IsImpersonating; PVOID NlsCache; PVOID pShimData; USHORT HeapVirtualAffinity; USHORT LowFragHeapDataSlot; HANDLE CurrentTransactionHandle; PTEB_ACTIVE_FRAME ActiveFrame; PVOID FlsData; PVOID PreferredLanguages; PVOID UserPrefLanguages; PVOID MergedPrefLanguages; ULONG MuiImpersonation; union { USHORT CrossTebFlags; USHORT SpareCrossTebBits : 16; } u2; union { USHORT SameTebFlags; struct { USHORT SafeThunkCall : 1; USHORT InDebugPrint : 1; USHORT HasFiberData : 1; USHORT SkipThreadAttach : 1; USHORT WerInShipAssertCode : 1; USHORT RanProcessInit : 1; USHORT ClonedThread : 1; USHORT SuppressDebugMsg : 1; USHORT DisableUserStackWalk : 1; USHORT RtlExceptionAttached : 1; USHORT InitialThread : 1; USHORT SessionAware : 1; USHORT LoadOwner : 1; USHORT LoaderWorker : 1; USHORT SkipLoaderInit : 1; USHORT SpareSameTebBits : 1; } s2; } u3; PVOID TxnScopeEnterCallback; PVOID TxnScopeExitCallback; PVOID TxnScopeContext; ULONG LockCount; LONG WowTebOffset; PVOID ResourceRetValue; PVOID ReservedForWdf; ULONGLONG ReservedForCrt; GUID EffectiveContainerId; } TEB, *PTEB; typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE { StandardDesign, NEC98x86, EndAlternatives } ALTERNATIVE_ARCHITECTURE_TYPE; #define PROCESSOR_FEATURE_MAX 64 #define MAX_WOW64_SHARED_ENTRIES 16 #define NX_SUPPORT_POLICY_ALWAYSOFF 0 #define NX_SUPPORT_POLICY_ALWAYSON 1 #define NX_SUPPORT_POLICY_OPTIN 2 #define NX_SUPPORT_POLICY_OPTOUT 3 #pragma pack(push, 4) typedef struct _KUSER_SHARED_DATA { ULONG TickCountLowDeprecated; ULONG TickCountMultiplier; volatile KSYSTEM_TIME InterruptTime; volatile KSYSTEM_TIME SystemTime; volatile KSYSTEM_TIME TimeZoneBias; USHORT ImageNumberLow; USHORT ImageNumberHigh; WCHAR NtSystemRoot[260]; ULONG MaxStackTraceDepth; ULONG CryptoExponent; ULONG TimeZoneId; ULONG LargePageMinimum; ULONG AitSamplingValue; ULONG AppCompatFlag; ULONGLONG RNGSeedVersion; ULONG GlobalValidationRunlevel; LONG TimeZoneBiasStamp; ULONG NtBuildNumber; NT_PRODUCT_TYPE NtProductType; BOOLEAN ProductTypeIsValid; UCHAR Reserved0[1]; USHORT NativeProcessorArchitecture; ULONG NtMajorVersion; ULONG NtMinorVersion; BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX]; ULONG Reserved1; ULONG Reserved3; volatile ULONG TimeSlip; ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture; ULONG BootId; LARGE_INTEGER SystemExpirationDate; ULONG SuiteMask; BOOLEAN KdDebuggerEnabled; union { UCHAR MitigationPolicies; struct { UCHAR NXSupportPolicy : 2; UCHAR SEHValidationPolicy : 2; UCHAR CurDirDevicesSkippedForDlls : 2; UCHAR Reserved : 2; } s1; } u1; UCHAR Reserved6[2]; volatile ULONG ActiveConsoleId; volatile ULONG DismountCount; ULONG ComPlusPackage; ULONG LastSystemRITEventTickCount; ULONG NumberOfPhysicalPages; BOOLEAN SafeBootMode; UCHAR VirtualizationFlags; UCHAR Reserved12[2]; union { ULONG SharedDataFlags; struct { ULONG DbgErrorPortPresent : 1; ULONG DbgElevationEnabled : 1; ULONG DbgVirtEnabled : 1; ULONG DbgInstallerDetectEnabled : 1; ULONG DbgLkgEnabled : 1; ULONG DbgDynProcessorEnabled : 1; ULONG DbgConsoleBrokerEnabled : 1; ULONG DbgSecureBootEnabled : 1; ULONG DbgMultiSessionSku : 1; ULONG DbgMultiUsersInSessionSku : 1; ULONG DbgStateSeparationEnabled : 1; ULONG SpareBits : 21; } s2; } u2; ULONG DataFlagsPad[1]; ULONGLONG TestRetInstruction; LONGLONG QpcFrequency; ULONG SystemCall; ULONG SystemCallPad0; ULONGLONG SystemCallPad[2]; union { volatile KSYSTEM_TIME TickCount; volatile ULONG64 TickCountQuad; ULONG ReservedTickCountOverlay[3]; }; ULONG TickCountPad[1]; ULONG Cookie; ULONG CookiePad[1]; LONGLONG ConsoleSessionForegroundProcessId; ULONGLONG TimeUpdateLock; ULONGLONG BaselineSystemTimeQpc; ULONGLONG BaselineInterruptTimeQpc; ULONGLONG QpcSystemTimeIncrement; ULONGLONG QpcInterruptTimeIncrement; UCHAR QpcSystemTimeIncrementShift; UCHAR QpcInterruptTimeIncrementShift; USHORT UnparkedProcessorCount; ULONG EnclaveFeatureMask[4]; ULONG TelemetryCoverageRound; USHORT UserModeGlobalLogger[16]; ULONG ImageFileExecutionOptions; ULONG LangGenerationCount; ULONGLONG Reserved4; volatile ULONG64 InterruptTimeBias; volatile ULONG64 QpcBias; ULONG ActiveProcessorCount; volatile UCHAR ActiveGroupCount; UCHAR Reserved9; union { USHORT QpcData; struct { UCHAR QpcBypassEnabled : 1; UCHAR QpcShift : 1; } s3; } u3; LARGE_INTEGER TimeZoneBiasEffectiveStart; LARGE_INTEGER TimeZoneBiasEffectiveEnd; XSTATE_CONFIGURATION XState; } KUSER_SHARED_DATA, *PKUSER_SHARED_DATA; #pragma pack(pop) #ifdef __cplusplus static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TickCountMultiplier) == 0x4, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, InterruptTime) == 0x8, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, SystemTime) == 0x14, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TimeZoneBias) == 0x20, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, ImageNumberLow) == 0x2c, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, ImageNumberHigh) == 0x2e, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, NtSystemRoot) == 0x30, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, MaxStackTraceDepth) == 0x238, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, CryptoExponent) == 0x23c, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TimeZoneId) == 0x240, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, LargePageMinimum) == 0x244, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, NtProductType) == 0x264, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, ProductTypeIsValid) == 0x268, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, NtMajorVersion) == 0x26c, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, NtMinorVersion) == 0x270, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, ProcessorFeatures) == 0x274, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, Reserved1) == 0x2b4, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, Reserved3) == 0x2b8, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TimeSlip) == 0x2bc, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, AlternativeArchitecture) == 0x2c0, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, SystemExpirationDate) == 0x2c8, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, SuiteMask) == 0x2d0, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, KdDebuggerEnabled) == 0x2d4, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, ActiveConsoleId) == 0x2d8, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, DismountCount) == 0x2dc, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, ComPlusPackage) == 0x2e0, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, LastSystemRITEventTickCount) == 0x2e4, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, NumberOfPhysicalPages) == 0x2e8, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, SafeBootMode) == 0x2ec, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TestRetInstruction) == 0x2f8, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, SystemCallPad) == 0x310, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TickCount) == 0x320, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, TickCountQuad) == 0x320, "Offset check"); static_assert(FIELD_OFFSET(KUSER_SHARED_DATA, XState) == 0x3d8, "Offset check"); #endif #if !defined(_KERNEL_MODE) && !defined(KERNELMODE) #define USER_SHARED_DATA 0x7FFE0000 #define SharedUserData ((KUSER_SHARED_DATA * const)USER_SHARED_DATA) #else #if defined(_M_IX86) #define KI_USER_SHARED_DATA 0xFFDF0000 #elif defined (_M_AMD64) #define KI_USER_SHARED_DATA 0xFFFFF78000000000Ui64 #elif defined (_M_ARM) #define KI_USER_SHARED_DATA 0xFFFF9000 #elif defined(M_ARM64) #define KI_USER_SHARED_DATA 0xFFFFF78000000000Ui64 #endif #define SharedUserData ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA) #endif typedef struct _PROCESS_BASIC_INFORMATION { NTSTATUS ExitStatus; PPEB PebBaseAddress; ULONG_PTR AffinityMask; KPRIORITY BasePriority; HANDLE UniqueProcessId; HANDLE InheritedFromUniqueProcessId; } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION; typedef struct _PROCESS_EXTENDED_BASIC_INFORMATION { SIZE_T Size; // Set to sizeof structure on input PROCESS_BASIC_INFORMATION BasicInfo; union { ULONG Flags; struct { ULONG IsProtectedProcess : 1; ULONG IsWow64Process : 1; ULONG IsProcessDeleting : 1; ULONG IsCrossSessionCreate : 1; ULONG IsFrozen : 1; ULONG IsBackground : 1; ULONG IsStronglyNamed : 1; ULONG IsSecureProcess : 1; ULONG IsSubsystemProcess : 1; ULONG SpareBits : 23; } s; } u; } PROCESS_EXTENDED_BASIC_INFORMATION, *PPROCESS_EXTENDED_BASIC_INFORMATION; typedef struct _VM_COUNTERS { SIZE_T PeakVirtualSize; SIZE_T VirtualSize; ULONG PageFaultCount; SIZE_T PeakWorkingSetSize; SIZE_T WorkingSetSize; SIZE_T QuotaPeakPagedPoolUsage; SIZE_T QuotaPagedPoolUsage; SIZE_T QuotaPeakNonPagedPoolUsage; SIZE_T QuotaNonPagedPoolUsage; SIZE_T PagefileUsage; SIZE_T PeakPagefileUsage; } VM_COUNTERS, *PVM_COUNTERS; typedef struct _VM_COUNTERS_EX { SIZE_T PeakVirtualSize; SIZE_T VirtualSize; ULONG PageFaultCount; SIZE_T PeakWorkingSetSize; SIZE_T WorkingSetSize; SIZE_T QuotaPeakPagedPoolUsage; SIZE_T QuotaPagedPoolUsage; SIZE_T QuotaPeakNonPagedPoolUsage; SIZE_T QuotaNonPagedPoolUsage; SIZE_T PagefileUsage; SIZE_T PeakPagefileUsage; SIZE_T PrivateUsage; } VM_COUNTERS_EX, *PVM_COUNTERS_EX; typedef struct _JOBOBJECT_WAKE_FILTER { ULONG HighEdgeFilter; ULONG LowEdgeFilter; } JOBOBJECT_WAKE_FILTER, *PJOBOBJECT_WAKE_FILTER; typedef struct _JOBOBJECT_FREEZE_INFORMATION { union { ULONG Flags; struct { ULONG FreezeOperation : 1; ULONG FilterOperation : 1; ULONG SwapOperation : 1; ULONG Reserved : 29; } s; } u; BOOLEAN Freeze; BOOLEAN Swap; UCHAR Reserved0[2]; JOBOBJECT_WAKE_FILTER WakeFilter; } JOBOBJECT_FREEZE_INFORMATION, *PJOBOBJECT_FREEZE_INFORMATION; #define PTR_ADD_OFFSET(Pointer, Offset) ((PVOID)((ULONG_PTR)(Pointer) + (ULONG_PTR)(Offset))) #define PTR_SUB_OFFSET(Pointer, Offset) ((PVOID)((ULONG_PTR)(Pointer) - (ULONG_PTR)(Offset))) #define ALIGN_DOWN_BY(Address, Align) ((ULONG_PTR)(Address) & ~((Align) - 1)) #define ALIGN_DOWN_POINTER_BY(Pointer, Align) ((PVOID)ALIGN_DOWN_BY(Pointer, Align)) #define ALIGN_DOWN_POINTER(Pointer, Type) ((PVOID)ALIGN_DOWN(Pointer, Type)) #define ALIGN_UP_BY(Address, Align) (((ULONG_PTR)(Address) + (Align) - 1) & ~((Align) - 1)) #define ALIGN_UP_POINTER_BY(Pointer, Align) ((PVOID)ALIGN_UP_BY(Pointer, Align)) #define ALIGN_UP_POINTER(Pointer, Type) ((PVOID)ALIGN_UP(Pointer, Type)) #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; \ } #if !defined(__cplusplus) #define RTL_CONSTANT_OBJECT_ATTRIBUTES(n, a) \ { sizeof(OBJECT_ATTRIBUTES), NULL, ((PUNICODE_STRING)(n)), (a), NULL, NULL } #else #define RTL_CONSTANT_OBJECT_ATTRIBUTES(n, a) \ { sizeof(OBJECT_ATTRIBUTES), nullptr, ((remove_constref<PUNICODE_STRING>::type)(n)), (a), nullptr, nullptr } #endif #define OBJ_INHERIT 0x00000002L #define OBJ_PERMANENT 0x00000010L #define OBJ_EXCLUSIVE 0x00000020L #define OBJ_CASE_INSENSITIVE 0x00000040L #define OBJ_OPENIF 0x00000080L #define OBJ_OPENLINK 0x00000100L #define OBJ_KERNEL_HANDLE 0x00000200L #define OBJ_FORCE_ACCESS_CHECK 0x00000400L #define OBJ_IGNORE_IMPERSONATED_DEVICEMAP 0x00000800 #define OBJ_DONT_REPARSE 0x00001000 #define OBJ_VALID_ATTRIBUTES 0x00001FF2 #if NTDDI_VERSION >= NTDDI_VISTA #ifndef THREAD_ALL_ACCESS #define THREAD_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFFF) #endif #else #ifndef THREAD_ALL_ACCESS #define THREAD_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0x3FF) #endif #endif #define THREAD_CREATE_FLAGS_CREATE_SUSPENDED 0x00000001 #define THREAD_CREATE_FLAGS_SUPPRESS_DLLMAINS 0x00000002 #define THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER 0x00000004 #define THREAD_CREATE_FLAGS_HAS_SECURITY_DESCRIPTOR 0x00000010 // ? #define THREAD_CREATE_FLAGS_ACCESS_CHECK_IN_TARGET 0x00000020 // ? #define THREAD_CREATE_FLAGS_BYPASS_PROCESS_FREEZE 0x00000040 // 19H1+ #define THREAD_CREATE_FLAGS_INITIAL_THREAD 0x00000080 #define DEBUG_READ_EVENT 0x0001 #define DEBUG_PROCESS_ASSIGN 0x0002 #define DEBUG_SET_INFORMATION 0x0004 #define DEBUG_QUERY_INFORMATION 0x0008 #define DEBUG_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ DEBUG_READ_EVENT | DEBUG_PROCESS_ASSIGN | DEBUG_SET_INFORMATION | \ DEBUG_QUERY_INFORMATION) #define DEBUG_KILL_ON_CLOSE 0x1 #ifndef IO_COMPLETION_QUERY_STATE #define IO_COMPLETION_QUERY_STATE 0x0001 #endif #ifndef IO_COMPLETION_MODIFY_STATE #define IO_COMPLETION_MODIFY_STATE 0x0002 #endif #ifndef IO_COMPLETION_ALL_ACCESS #define IO_COMPLETION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ IO_COMPLETION_QUERY_STATE | IO_COMPLETION_MODIFY_STATE) #endif #ifndef SEMAPHORE_ALL_ACCESS #define SEMAPHORE_QUERY_STATE 0x0001 #define SEMAPHORE_MODIFY_STATE 0x0002 #define SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ SEMAPHORE_QUERY_STATE | SEMAPHORE_MODIFY_STATE) #endif #ifndef MUTANT_ALL_ACCESS #define MUTANT_QUERY_STATE 0x0001 #define MUTANT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ MUTANT_QUERY_STATE) #endif #ifndef EVENT_ALL_ACCESS #define EVENT_QUERY_STATE 0x0001 #define EVENT_MODIFY_STATE 0x0002 #define EVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ EVENT_QUERY_STATE | EVENT_MODIFY_STATE) #endif #define KEYEDEVENT_WAIT 0x0001 #define KEYEDEVENT_WAKE 0x0002 #define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | \ KEYEDEVENT_WAIT | KEYEDEVENT_WAKE) #define DIRECTORY_QUERY 0x0001 #define DIRECTORY_TRAVERSE 0x0002 #define DIRECTORY_CREATE_OBJECT 0x0004 #define DIRECTORY_CREATE_SUBDIRECTORY 0x0008 #define DIRECTORY_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | \ DIRECTORY_QUERY | DIRECTORY_TRAVERSE | \ DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY) #define SYMBOLIC_LINK_QUERY 0x0001 #define SYMBOLIC_LINK_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | \ SYMBOLIC_LINK_QUERY) #ifndef TOKEN_ALL_ACCESS #define TOKEN_ASSIGN_PRIMARY 0x0001 #define TOKEN_DUPLICATE 0x0002 #define TOKEN_IMPERSONATE 0x0004 #define TOKEN_QUERY 0x0008 #define TOKEN_QUERY_SOURCE 0x0010 #define TOKEN_ADJUST_PRIVILEGES 0x0020 #define TOKEN_ADJUST_GROUPS 0x0040 #define TOKEN_ADJUST_DEFAULT 0x0080 #define TOKEN_ADJUST_SESSIONID 0x0100 #define TOKEN_ALL_ACCESS_P (STANDARD_RIGHTS_REQUIRED | \ TOKEN_ASSIGN_PRIMARY | \ TOKEN_DUPLICATE | \ TOKEN_IMPERSONATE | \ TOKEN_QUERY | \ TOKEN_QUERY_SOURCE | \ TOKEN_ADJUST_PRIVILEGES | \ TOKEN_ADJUST_GROUPS | \ TOKEN_ADJUST_DEFAULT) #define TOKEN_ALL_ACCESS (TOKEN_ALL_ACCESS_P | \ TOKEN_ADJUST_SESSIONID) #endif #define WORKER_FACTORY_RELEASE_WORKER 0x0001 #define WORKER_FACTORY_WAIT 0x0002 #define WORKER_FACTORY_SET_INFORMATION 0x0004 #define WORKER_FACTORY_QUERY_INFORMATION 0x0008 #define WORKER_FACTORY_READY_WORKER 0x0010 #define WORKER_FACTORY_SHUTDOWN 0x0020 #define WORKER_FACTORY_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | \ WORKER_FACTORY_RELEASE_WORKER | \ WORKER_FACTORY_WAIT | \ WORKER_FACTORY_SET_INFORMATION | \ WORKER_FACTORY_QUERY_INFORMATION | \ WORKER_FACTORY_READY_WORKER | \ WORKER_FACTORY_SHUTDOWN) typedef struct _WORKER_FACTORY_DEFERRED_WORK { struct _PORT_MESSAGE* AlpcSendMessage; HANDLE AlpcSendMessagePort; ULONG AlpcSendMessageFlags; ULONG Flags; } WORKER_FACTORY_DEFERRED_WORK, *PWORKER_FACTORY_DEFERRED_WORK; #define NtCurrentProcess ((HANDLE)(LONG_PTR)-1) #define NtCurrentThread ((HANDLE)(LONG_PTR)-2) FORCEINLINE PPEB NtCurrentPeb( VOID ) { #if defined(_M_AMD64) return (PPEB)__readgsqword(FIELD_OFFSET(TEB, ProcessEnvironmentBlock)); #elif defined(_M_IX86) return (PPEB)__readfsdword(FIELD_OFFSET(TEB, ProcessEnvironmentBlock)); #elif defined(_M_ARM) return (PPEB)(((PTEB)(ULONG_PTR)_MoveFromCoprocessor(CP15_TPIDRURW))->ProcessEnvironmentBlock); #elif defined(_M_ARM64) return (PPEB)(((PTEB)__getReg(18))->ProcessEnvironmentBlock); #elif defined(_M_IA64) return *(PPEB*)((size_t)_rdteb() + FIELD_OFFSET(TEB, ProcessEnvironmentBlock)); #elif defined(_M_ALPHA) return *(PPEB*)((size_t)_rdteb() + FIELD_OFFSET(TEB, ProcessEnvironmentBlock)); #elif defined(_M_MIPS) return *(PPEB*)((*(size_t*)(0x7ffff030)) + FIELD_OFFSET(TEB, ProcessEnvironmentBlock)); #elif defined(_M_PPC) return *(PPEB*)(__gregister_get(13) + FIELD_OFFSET(TEB, ProcessEnvironmentBlock)); #else #error "Unsupported architecture" #endif } #define NtCurrentProcessId() (NtCurrentTeb()->ClientId.UniqueProcess) #define NtCurrentThreadId() (NtCurrentTeb()->ClientId.UniqueThread) #define RtlProcessHeap() (NtCurrentPeb()->ProcessHeap) typedef struct _RTL_HEAP_ENTRY { SIZE_T Size; USHORT Flags; USHORT AllocatorBackTraceIndex; union { struct { SIZE_T Settable; ULONG Tag; } s1; struct { SIZE_T CommittedSize; PVOID FirstBlock; } s2; } u; } RTL_HEAP_ENTRY, *PRTL_HEAP_ENTRY; #define RTL_HEAP_BUSY (USHORT)0x0001 #define RTL_HEAP_SEGMENT (USHORT)0x0002 #define RTL_HEAP_SETTABLE_VALUE (USHORT)0x0010 #define RTL_HEAP_SETTABLE_FLAG1 (USHORT)0x0020 #define RTL_HEAP_SETTABLE_FLAG2 (USHORT)0x0040 #define RTL_HEAP_SETTABLE_FLAG3 (USHORT)0x0080 #define RTL_HEAP_SETTABLE_FLAGS (USHORT)0x00e0 #define RTL_HEAP_UNCOMMITTED_RANGE (USHORT)0x0100 #define RTL_HEAP_PROTECTED_ENTRY (USHORT)0x0200 typedef struct _RTL_HEAP_TAG { ULONG NumberOfAllocations; ULONG NumberOfFrees; SIZE_T BytesAllocated; USHORT TagIndex; USHORT CreatorBackTraceIndex; WCHAR TagName[24]; } RTL_HEAP_TAG, *PRTL_HEAP_TAG; typedef struct _RTL_HEAP_INFORMATION { PVOID BaseAddress; ULONG Flags; USHORT EntryOverhead; USHORT CreatorBackTraceIndex; SIZE_T BytesAllocated; SIZE_T BytesCommitted; ULONG NumberOfTags; ULONG NumberOfEntries; ULONG NumberOfPseudoTags; ULONG PseudoTagGranularity; ULONG Reserved[5]; PRTL_HEAP_TAG Tags; PRTL_HEAP_ENTRY Entries; } RTL_HEAP_INFORMATION, *PRTL_HEAP_INFORMATION; typedef struct _RTL_PROCESS_HEAPS { ULONG NumberOfHeaps; RTL_HEAP_INFORMATION Heaps[1]; } RTL_PROCESS_HEAPS, *PRTL_PROCESS_HEAPS; typedef NTSTATUS (NTAPI* PRTL_HEAP_COMMIT_ROUTINE)( _In_ PVOID Base, _Inout_ PVOID* CommitAddress, _Inout_ PSIZE_T CommitSize ); typedef struct _RTL_HEAP_PARAMETERS { ULONG Length; SIZE_T SegmentReserve; SIZE_T SegmentCommit; SIZE_T DeCommitFreeBlockThreshold; SIZE_T DeCommitTotalFreeThreshold; SIZE_T MaximumAllocationSize; SIZE_T VirtualMemoryThreshold; SIZE_T InitialCommit; SIZE_T InitialReserve; PRTL_HEAP_COMMIT_ROUTINE CommitRoutine; SIZE_T Reserved[2]; } RTL_HEAP_PARAMETERS, *PRTL_HEAP_PARAMETERS; #define HEAP_SETTABLE_USER_VALUE 0x00000100 #define HEAP_SETTABLE_USER_FLAG1 0x00000200 #define HEAP_SETTABLE_USER_FLAG2 0x00000400 #define HEAP_SETTABLE_USER_FLAG3 0x00000800 #define HEAP_SETTABLE_USER_FLAGS 0x00000e00 #define HEAP_CLASS_0 0x00000000 // Process heap #define HEAP_CLASS_1 0x00001000 // Private heap #define HEAP_CLASS_2 0x00002000 // Kernel heap #define HEAP_CLASS_3 0x00003000 // GDI heap #define HEAP_CLASS_4 0x00004000 // User heap #define HEAP_CLASS_5 0x00005000 // Console heap #define HEAP_CLASS_6 0x00006000 // User desktop heap #define HEAP_CLASS_7 0x00007000 // CSR shared heap #define HEAP_CLASS_8 0x00008000 // CSR port heap #define HEAP_CLASS_MASK 0x0000f000 typedef struct _RTL_HEAP_TAG_INFO { ULONG NumberOfAllocations; ULONG NumberOfFrees; SIZE_T BytesAllocated; } RTL_HEAP_TAG_INFO, *PRTL_HEAP_TAG_INFO; #define RTL_HEAP_MAKE_TAG HEAP_MAKE_TAG_FLAGS typedef struct _RTL_HEAP_WALK_ENTRY { PVOID DataAddress; SIZE_T DataSize; UCHAR OverheadBytes; UCHAR SegmentIndex; USHORT Flags; union { struct { SIZE_T Settable; USHORT TagIndex; USHORT AllocatorBackTraceIndex; ULONG Reserved[2]; } Block; struct { ULONG CommittedSize; ULONG UnCommittedSize; PVOID FirstEntry; PVOID LastEntry; } Segment; } u; } RTL_HEAP_WALK_ENTRY, *PRTL_HEAP_WALK_ENTRY; // HEAP_INFORMATION_CLASS. winnt.h is incomplete #define HeapCompatibilityInformation ((HEAP_INFORMATION_CLASS)0x0) // q; s: ULONG #define HeapEnableTerminationOnCorruption ((HEAP_INFORMATION_CLASS)0x1) // q; s: NULL #define HeapExtendedInformation ((HEAP_INFORMATION_CLASS)0x2) // q; s: HEAP_EXTENDED_INFORMATION #define HeapOptimizeResources ((HEAP_INFORMATION_CLASS)0x3) // q; s: HEAP_OPTIMIZE_RESOURCES_INFORMATION #define HeapTaggingInformation ((HEAP_INFORMATION_CLASS)0x4) #define HeapStackDatabase ((HEAP_INFORMATION_CLASS)0x5) #define HeapMemoryLimit ((HEAP_INFORMATION_CLASS)0x6) // 19H2 #define HeapDetailedFailureInformation ((HEAP_INFORMATION_CLASS)0x80000001) #define HeapSetDebuggingInformation ((HEAP_INFORMATION_CLASS)0x80000002) // q; s: HEAP_DEBUGGING_INFORMATION typedef struct _PROCESS_HEAP_INFORMATION { ULONG_PTR ReserveSize; ULONG_PTR CommitSize; ULONG NumberOfHeaps; ULONG_PTR FirstHeapInformationOffset; } PROCESS_HEAP_INFORMATION, *PPROCESS_HEAP_INFORMATION; typedef struct _HEAP_INFORMATION { ULONG_PTR Address; ULONG Mode; ULONG_PTR ReserveSize; ULONG_PTR CommitSize; ULONG_PTR FirstRegionInformationOffset; ULONG_PTR NextHeapInformationOffset; } HEAP_INFORMATION, *PHEAP_INFORMATION; typedef struct _HEAP_EXTENDED_INFORMATION { HANDLE Process; ULONG_PTR Heap; ULONG Level; PVOID CallbackRoutine; PVOID CallbackContext; PROCESS_HEAP_INFORMATION ProcessHeapInformation; HEAP_INFORMATION HeapInformation; } HEAP_EXTENDED_INFORMATION, *PHEAP_EXTENDED_INFORMATION; typedef NTSTATUS (NTAPI* PRTL_HEAP_LEAK_ENUMERATION_ROUTINE)( _In_ LONG Reserved, _In_ PVOID HeapHandle, _In_ PVOID BaseAddress, _In_ SIZE_T BlockSize, _In_ ULONG StackTraceDepth, _In_ PVOID* StackTrace ); typedef struct _HEAP_DEBUGGING_INFORMATION { PVOID InterceptorFunction; USHORT InterceptorValue; ULONG ExtendedOptions; ULONG StackTraceDepth; SIZE_T MinTotalBlockSize; SIZE_T MaxTotalBlockSize; PRTL_HEAP_LEAK_ENUMERATION_ROUTINE HeapLeakEnumerationRoutine; } HEAP_DEBUGGING_INFORMATION, *PHEAP_DEBUGGING_INFORMATION; typedef NTSTATUS (NTAPI* PRTL_ENUM_HEAPS_ROUTINE)( _In_ PVOID HeapHandle, _In_ PVOID Parameter ); typedef NTSTATUS (NTAPI* PUSER_THREAD_START_ROUTINE)( _In_ PVOID ThreadParameter ); #define LDR_FORMAT_MESSAGE_FROM_SYSTEM_MESSAGE_TABLE 11 #define RTL_ERRORMODE_FAILCRITICALERRORS 0x0010 #define RTL_ERRORMODE_NOGPFAULTERRORBOX 0x0020 #define RTL_ERRORMODE_NOOPENFILEERRORBOX 0x0040 #define RTL_ACQUIRE_PRIVILEGE_REVERT 0x00000001 #define RTL_ACQUIRE_PRIVILEGE_PROCESS 0x00000002 typedef VOID (NTAPI* PLDR_IMPORT_MODULE_CALLBACK)( _In_ PVOID Parameter, _In_ PSTR ModuleName ); typedef struct _LDR_IMPORT_CALLBACK_INFO { PLDR_IMPORT_MODULE_CALLBACK ImportCallbackRoutine; PVOID ImportCallbackParameter; } LDR_IMPORT_CALLBACK_INFO, *PLDR_IMPORT_CALLBACK_INFO; typedef struct _LDR_SECTION_INFO { HANDLE SectionHandle; ACCESS_MASK DesiredAccess; POBJECT_ATTRIBUTES ObjectAttributes; ULONG SectionPageProtection; ULONG AllocationAttributes; } LDR_SECTION_INFO, *PLDR_SECTION_INFO; typedef struct _LDR_VERIFY_IMAGE_INFO { ULONG Size; ULONG Flags; LDR_IMPORT_CALLBACK_INFO CallbackInfo; LDR_SECTION_INFO SectionInfo; USHORT ImageCharacteristics; } LDR_VERIFY_IMAGE_INFO, *PLDR_VERIFY_IMAGE_INFO; typedef enum _SEMAPHORE_INFORMATION_CLASS { SemaphoreBasicInformation } SEMAPHORE_INFORMATION_CLASS; typedef struct _SEMAPHORE_BASIC_INFORMATION { LONG CurrentCount; LONG MaximumCount; } SEMAPHORE_BASIC_INFORMATION, *PSEMAPHORE_BASIC_INFORMATION; typedef enum _TIMER_INFORMATION_CLASS { TimerBasicInformation } TIMER_INFORMATION_CLASS; typedef struct _TIMER_BASIC_INFORMATION { LARGE_INTEGER RemainingTime; BOOLEAN TimerState; } TIMER_BASIC_INFORMATION, *PTIMER_BASIC_INFORMATION; typedef VOID (NTAPI* PTIMER_APC_ROUTINE)( _In_ PVOID TimerContext, _In_ ULONG TimerLowValue, _In_ LONG TimerHighValue ); typedef enum _TIMER_SET_INFORMATION_CLASS { TimerSetCoalescableTimer, MaxTimerInfoClass } TIMER_SET_INFORMATION_CLASS; typedef struct _TIMER_SET_COALESCABLE_TIMER_INFO { _In_ LARGE_INTEGER DueTime; _In_opt_ PTIMER_APC_ROUTINE TimerApcRoutine; _In_opt_ PVOID TimerContext; _In_opt_ struct _COUNTED_REASON_CONTEXT* WakeContext; _In_opt_ ULONG Period; _In_ ULONG TolerableDelay; _Out_opt_ PBOOLEAN PreviousState; } TIMER_SET_COALESCABLE_TIMER_INFO, *PTIMER_SET_COALESCABLE_TIMER_INFO; typedef struct _TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE { ULONG64 Version; UNICODE_STRING Name; } TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE, *PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE; typedef struct _TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE { PVOID pValue; ULONG ValueLength; } TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE, *PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; typedef struct _TOKEN_SECURITY_ATTRIBUTE_V1 { UNICODE_STRING Name; USHORT ValueType; USHORT Reserved; ULONG Flags; ULONG ValueCount; union { PLONG64 pInt64; PULONG64 pUint64; PUNICODE_STRING pString; PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE pFqbn; PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE pOctetString; } Values; } TOKEN_SECURITY_ATTRIBUTE_V1, *PTOKEN_SECURITY_ATTRIBUTE_V1; #define TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1 1 #define TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1 typedef struct _TOKEN_SECURITY_ATTRIBUTES_INFORMATION { USHORT Version; USHORT Reserved; ULONG AttributeCount; union { PTOKEN_SECURITY_ATTRIBUTE_V1 pAttributeV1; } Attribute; } TOKEN_SECURITY_ATTRIBUTES_INFORMATION, *PTOKEN_SECURITY_ATTRIBUTES_INFORMATION; typedef enum _FILTER_BOOT_OPTION_OPERATION { FilterBootOptionOperationOpenSystemStore, FilterBootOptionOperationSetElement, FilterBootOptionOperationDeleteElement, FilterBootOptionOperationMax } FILTER_BOOT_OPTION_OPERATION; typedef enum _IO_SESSION_EVENT { IoSessionEventIgnore, IoSessionEventCreated, IoSessionEventTerminated, IoSessionEventConnected, IoSessionEventDisconnected, IoSessionEventLogon, IoSessionEventLogoff, IoSessionEventMax } IO_SESSION_EVENT; typedef enum _IO_SESSION_STATE { IoSessionStateCreated, IoSessionStateInitialized, IoSessionStateConnected, IoSessionStateDisconnected, IoSessionStateDisconnectedLoggedOn, IoSessionStateLoggedOn, IoSessionStateLoggedOff, IoSessionStateTerminated, IoSessionStateMax } IO_SESSION_STATE; typedef struct _PORT_MESSAGE PORT_MESSAGE, *PPORT_MESSAGE; typedef struct _TP_ALPC TP_ALPC, *PTP_ALPC; typedef VOID (NTAPI* PTP_ALPC_CALLBACK)( _Inout_ PTP_CALLBACK_INSTANCE Instance, _Inout_opt_ PVOID Context, _In_ PTP_ALPC Alpc ); typedef VOID (NTAPI* PTP_ALPC_CALLBACK_EX)( _Inout_ PTP_CALLBACK_INSTANCE Instance, _Inout_opt_ PVOID Context, _In_ PTP_ALPC Alpc, _In_ PVOID ApcContext ); typedef VOID (NTAPI* PTP_IO_CALLBACK)( _Inout_ PTP_CALLBACK_INSTANCE Instance, _Inout_opt_ PVOID Context, _In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoSB, _In_ PTP_IO Io ); typedef enum _IO_COMPLETION_INFORMATION_CLASS { IoCompletionBasicInformation } IO_COMPLETION_INFORMATION_CLASS; typedef struct _IO_COMPLETION_BASIC_INFORMATION { LONG Depth; } IO_COMPLETION_BASIC_INFORMATION, *PIO_COMPLETION_BASIC_INFORMATION; typedef enum _WORKERFACTORYINFOCLASS { WorkerFactoryTimeout, // q; s: LARGE_INTEGER WorkerFactoryRetryTimeout, // q; s: LARGE_INTEGER WorkerFactoryIdleTimeout, // q; s: LARGE_INTEGER WorkerFactoryBindingCount, WorkerFactoryThreadMinimum, // q; s: ULONG WorkerFactoryThreadMaximum, // q; s: ULONG WorkerFactoryPaused, // ULONG or BOOLEAN WorkerFactoryBasicInformation, // WORKER_FACTORY_BASIC_INFORMATION WorkerFactoryAdjustThreadGoal, WorkerFactoryCallbackType, WorkerFactoryStackInformation, // 10 WorkerFactoryThreadBasePriority, WorkerFactoryTimeoutWaiters, // since THRESHOLD WorkerFactoryFlags, WorkerFactoryThreadSoftMaximum, WorkerFactoryThreadCpuSets, // since REDSTONE5 MaxWorkerFactoryInfoClass } WORKERFACTORYINFOCLASS, *PWORKERFACTORYINFOCLASS; typedef struct _WORKER_FACTORY_BASIC_INFORMATION { LARGE_INTEGER Timeout; LARGE_INTEGER RetryTimeout; LARGE_INTEGER IdleTimeout; BOOLEAN Paused; BOOLEAN TimerSet; BOOLEAN QueuedToExWorker; BOOLEAN MayCreate; BOOLEAN CreateInProgress; BOOLEAN InsertedIntoQueue; BOOLEAN Shutdown; ULONG BindingCount; ULONG ThreadMinimum; ULONG ThreadMaximum; ULONG PendingWorkerCount; ULONG WaitingWorkerCount; ULONG TotalWorkerCount; ULONG ReleaseCount; LONGLONG InfiniteWaitGoal; PVOID StartRoutine; PVOID StartParameter; HANDLE ProcessId; SIZE_T StackReserve; SIZE_T StackCommit; NTSTATUS LastThreadCreationStatus; } WORKER_FACTORY_BASIC_INFORMATION, *PWORKER_FACTORY_BASIC_INFORMATION; typedef struct _BOOT_ENTRY { ULONG Version; ULONG Length; ULONG Id; ULONG Attributes; ULONG FriendlyNameOffset; ULONG BootFilePathOffset; ULONG OsOptionsLength; UCHAR OsOptions[1]; } BOOT_ENTRY, *PBOOT_ENTRY; typedef struct _BOOT_ENTRY_LIST { ULONG NextEntryOffset; BOOT_ENTRY BootEntry; } BOOT_ENTRY_LIST, *PBOOT_ENTRY_LIST; typedef struct _BOOT_OPTIONS { ULONG Version; ULONG Length; ULONG Timeout; ULONG CurrentBootEntryId; ULONG NextBootEntryId; WCHAR HeadlessRedirection[1]; } BOOT_OPTIONS, *PBOOT_OPTIONS; typedef struct _FILE_PATH { ULONG Version; ULONG Length; ULONG Type; UCHAR FilePath[1]; } FILE_PATH, *PFILE_PATH; typedef struct _EFI_DRIVER_ENTRY { ULONG Version; ULONG Length; ULONG Id; ULONG FriendlyNameOffset; ULONG DriverFilePathOffset; } EFI_DRIVER_ENTRY, *PEFI_DRIVER_ENTRY; typedef struct _EFI_DRIVER_ENTRY_LIST { ULONG NextEntryOffset; EFI_DRIVER_ENTRY DriverEntry; } EFI_DRIVER_ENTRY_LIST, *PEFI_DRIVER_ENTRY_LIST; FORCEINLINE VOID InitializeListHead( _Out_ PLIST_ENTRY ListHead ) { ListHead->Flink = ListHead->Blink = ListHead; } FORCEINLINE BOOLEAN IsListEmpty( _In_ PLIST_ENTRY ListHead ) { return ListHead->Flink == ListHead; } FORCEINLINE BOOLEAN RemoveEntryList( _In_ PLIST_ENTRY Entry ) { PLIST_ENTRY Flink = Entry->Flink; PLIST_ENTRY Blink = Entry->Blink; Blink->Flink = Flink; Flink->Blink = Blink; return Flink == Blink; } FORCEINLINE PLIST_ENTRY RemoveHeadList( _Inout_ PLIST_ENTRY ListHead ) { PLIST_ENTRY Entry = ListHead->Flink; PLIST_ENTRY Flink = Entry->Flink; ListHead->Flink = Flink; Flink->Blink = ListHead; return Entry; } FORCEINLINE PLIST_ENTRY RemoveTailList( _Inout_ PLIST_ENTRY ListHead ) { PLIST_ENTRY Entry = ListHead->Blink; PLIST_ENTRY Blink = Entry->Blink; ListHead->Blink = Blink; Blink->Flink = ListHead; return Entry; } FORCEINLINE VOID InsertTailList( _Inout_ PLIST_ENTRY ListHead, _Inout_ PLIST_ENTRY Entry ) { PLIST_ENTRY Blink = ListHead->Blink; Entry->Flink = ListHead; Entry->Blink = Blink; Blink->Flink = Entry; ListHead->Blink = Entry; } FORCEINLINE VOID InsertHeadList( _Inout_ PLIST_ENTRY ListHead, _Inout_ PLIST_ENTRY Entry ) { PLIST_ENTRY Flink = ListHead->Flink; Entry->Flink = Flink; Entry->Blink = ListHead; Flink->Blink = Entry; ListHead->Flink = Entry; } FORCEINLINE VOID AppendTailList( _Inout_ PLIST_ENTRY ListHead, _Inout_ PLIST_ENTRY ListToAppend ) { PLIST_ENTRY ListEnd = ListHead->Blink; ListHead->Blink->Flink = ListToAppend; ListHead->Blink = ListToAppend->Blink; ListToAppend->Blink->Flink = ListHead; ListToAppend->Blink = ListEnd; } FORCEINLINE PSINGLE_LIST_ENTRY PopEntryList( _Inout_ PSINGLE_LIST_ENTRY ListHead ) { PSINGLE_LIST_ENTRY FirstEntry = ListHead->Next; if(FirstEntry) ListHead->Next = FirstEntry->Next; return FirstEntry; } FORCEINLINE VOID PushEntryList( _Inout_ PSINGLE_LIST_ENTRY ListHead, _Inout_ PSINGLE_LIST_ENTRY Entry ) { Entry->Next = ListHead->Next; ListHead->Next = Entry; } NTSYSCALLAPI NTSTATUS NTAPI NtCreateProcess( _Out_ PHANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE ParentProcess, _In_ BOOLEAN InheritObjectTable, _In_opt_ HANDLE SectionHandle, _In_opt_ HANDLE DebugPort, _In_opt_ HANDLE TokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateProcessEx( _Out_ PHANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE ParentProcess, _In_ ULONG Flags, _In_opt_ HANDLE SectionHandle, _In_opt_ HANDLE DebugPort, _In_opt_ HANDLE TokenHandle, _In_ ULONG JobMemberLevel ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCreateUserProcess( _Out_ PHANDLE ProcessHandle, _Out_ PHANDLE ThreadHandle, _In_ ACCESS_MASK ProcessDesiredAccess, _In_ ACCESS_MASK ThreadDesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ProcessObjectAttributes, _In_opt_ POBJECT_ATTRIBUTES ThreadObjectAttributes, _In_ ULONG ProcessFlags, _In_ ULONG ThreadFlags, _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters, _Inout_ PPS_CREATE_INFO CreateInfo, _In_ PPS_ATTRIBUTE_LIST AttributeList ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationProcess( _In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _In_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationProcess( _In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _Out_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryObject( _In_opt_ HANDLE Handle, _In_ OBJECT_INFORMATION_CLASS ObjectInformationClass, _Out_opt_ PVOID ObjectInformation, _In_ ULONG ObjectInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySystemInformation( _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation, _In_ ULONG SystemInformationLength, _Out_opt_ PULONG ReturnLength ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtQuerySystemInformationEx( _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _In_reads_bytes_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(SystemInformationLength) PVOID SystemInformation, _In_ ULONG SystemInformationLength, _Out_opt_ PULONG ReturnLength ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtSetSystemInformation( _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _In_reads_bytes_opt_(SystemInformationLength) PVOID SystemInformation, _In_ ULONG SystemInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationThread( _In_ HANDLE ThreadHandle, _In_ THREADINFOCLASS ThreadInformationClass, _In_ PVOID ThreadInformation, _In_ ULONG ThreadInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationThread( _In_ HANDLE ThreadHandle, _In_ THREADINFOCLASS ThreadInformationClass, _Out_ PVOID ThreadInformation, _In_ ULONG ThreadInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtUnmapViewOfSection( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress ); #if NTDDI_VERSION >= NTDDI_WIN8 NTSYSCALLAPI NTSTATUS NTAPI NtUnmapViewOfSectionEx( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress, _In_ ULONG Flags ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtExtendSection( _In_ HANDLE SectionHandle, _Inout_ PLARGE_INTEGER NewSectionSize ); NTSYSCALLAPI NTSTATUS NTAPI NtSuspendThread( _In_ HANDLE ThreadHandle, _Out_opt_ PULONG PreviousSuspendCount ); NTSYSCALLAPI NTSTATUS NTAPI NtResumeThread( _In_ HANDLE ThreadHandle, _Out_opt_ PULONG PreviousSuspendCount ); NTSYSCALLAPI NTSTATUS NTAPI NtSuspendProcess( _In_ HANDLE ProcessHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtResumeProcess( _In_ HANDLE ProcessHandle ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSCALLAPI ULONG NTAPI NtGetCurrentProcessorNumber( VOID ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtSignalAndWaitForSingleObject( _In_ HANDLE SignalHandle, _In_ HANDLE WaitHandle, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); NTSYSCALLAPI NTSTATUS NTAPI NtWaitForSingleObject( _In_ HANDLE Handle, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); NTSYSCALLAPI NTSTATUS NTAPI NtWaitForMultipleObjects( _In_ ULONG Count, _In_reads_(Count) HANDLE Handles[], _In_ WAIT_TYPE WaitType, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSCALLAPI NTSTATUS NTAPI NtWaitForMultipleObjects32( _In_ ULONG Count, _In_reads_(Count) HANDLE Handles[], _In_ WAIT_TYPE WaitType, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtSetSecurityObject( _In_ HANDLE Handle, _In_ SECURITY_INFORMATION SecurityInformation, _In_ PSECURITY_DESCRIPTOR SecurityDescriptor ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySecurityObject( _In_ HANDLE Handle, _In_ SECURITY_INFORMATION SecurityInformation, _Out_writes_bytes_to_(Length, *LengthNeeded) PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ ULONG Length, _Out_ PULONG LengthNeeded ); NTSYSCALLAPI NTSTATUS NTAPI NtQueueApcThread( _In_ HANDLE ThreadHandle, _In_ PPS_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcArgument1, _In_opt_ PVOID ApcArgument2, _In_opt_ PVOID ApcArgument3 ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtQueueApcThreadEx( _In_ HANDLE ThreadHandle, _In_opt_ HANDLE UserApcReserveHandle, _In_ PPS_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcArgument1, _In_opt_ PVOID ApcArgument2, _In_opt_ PVOID ApcArgument3 ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtProtectVirtualMemory( _In_ HANDLE ProcessHandle, _Inout_ PVOID* BaseAddress, _Inout_ PSIZE_T RegionSize, _In_ ULONG NewProtect, _Out_ PULONG OldProtect ); NTSYSCALLAPI NTSTATUS NTAPI NtFlushBuffersFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock ); NTSYSCALLAPI NTSTATUS NTAPI NtFlushInstructionCache( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress, _In_ SIZE_T Length ); NTSYSCALLAPI NTSTATUS NTAPI NtFlushWriteBuffer( VOID ); NTSYSCALLAPI NTSTATUS NTAPI NtFsControlFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG FsControlCode, _In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength ); NTSYSCALLAPI NTSTATUS NTAPI NtLockFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ PLARGE_INTEGER ByteOffset, _In_ PLARGE_INTEGER Length, _In_ ULONG Key, _In_ BOOLEAN FailImmediately, _In_ BOOLEAN ExclusiveLock ); NTSYSCALLAPI NTSTATUS NTAPI NtUnlockFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ PLARGE_INTEGER ByteOffset, _In_ PLARGE_INTEGER Length, _In_ ULONG Key ); NTSYSCALLAPI NTSTATUS NTAPI NtFlushVirtualMemory( _In_ HANDLE ProcessHandle, _Inout_ PVOID* BaseAddress, _Inout_ PSIZE_T RegionSize, _Out_ PIO_STATUS_BLOCK IoStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryVirtualMemory( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress, _In_ MEMORY_INFORMATION_CLASS MemoryInformationClass, _Out_ PVOID MemoryInformation, _In_ SIZE_T MemoryInformationLength, _Out_opt_ PSIZE_T ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtLockVirtualMemory( _In_ HANDLE ProcessHandle, _Inout_ PVOID* BaseAddress, _Inout_ PSIZE_T RegionSize, _In_ ULONG MapType ); NTSYSCALLAPI NTSTATUS NTAPI NtUnlockVirtualMemory( _In_ HANDLE ProcessHandle, _Inout_ PVOID* BaseAddress, _Inout_ PSIZE_T RegionSize, _In_ ULONG MapType ); NTSYSCALLAPI NTSTATUS NTAPI NtSystemDebugControl( _In_ SYSDBG_COMMAND Command, _Inout_updates_bytes_opt_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtShutdownSystem( _In_ SHUTDOWN_ACTION Action ); NTSYSCALLAPI NTSTATUS NTAPI NtDisplayString( _In_ PUNICODE_STRING String ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtDrawText( _In_ PUNICODE_STRING Text ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtYieldExecution( VOID ); NTSYSCALLAPI NTSTATUS NTAPI NtClose( _In_ HANDLE Handle ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryAttributesFile( _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PFILE_BASIC_INFORMATION FileInformation ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryFullAttributesFile( _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PFILE_NETWORK_OPEN_INFORMATION FileInformation ); #if NTDDI_VERSION >= NTDDI_WIN10_RS2 NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationByName( _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass ); NTSYSCALLAPI NTSTATUS NTAPI NtSetQuotaInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length ); NTSYSCALLAPI NTSTATUS NTAPI NtSetVolumeInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID FsInformation, _In_ ULONG Length, _In_ FS_INFORMATION_CLASS FsInformationClass ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER AllocationSize, _In_ ULONG FileAttributes, _In_ ULONG ShareAccess, _In_ ULONG CreateDisposition, _In_ ULONG CreateOptions, _In_reads_bytes_opt_(EaLength) PVOID EaBuffer, _In_ ULONG EaLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateNamedPipeFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG ShareAccess, _In_ ULONG CreateDisposition, _In_ ULONG CreateOptions, _In_ ULONG NamedPipeType, _In_ ULONG ReadMode, _In_ ULONG CompletionMode, _In_ ULONG MaximumInstances, _In_ ULONG InboundQuota, _In_ ULONG OutboundQuota, _In_opt_ PLARGE_INTEGER DefaultTimeout ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateMailslotFile( _Out_ PHANDLE FileHandle, _In_ ULONG DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG CreateOptions, _In_ ULONG MailslotQuota, _In_ ULONG MaximumMessageSize, _In_ PLARGE_INTEGER ReadTimeout ); NTSYSCALLAPI NTSTATUS NTAPI NtCancelIoFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCancelIoFileEx( _In_ HANDLE FileHandle, _In_opt_ PIO_STATUS_BLOCK IoRequestToCancel, _Out_ PIO_STATUS_BLOCK IoStatusBlock ); NTSYSCALLAPI NTSTATUS NTAPI NtCancelSynchronousIoFile( _In_ HANDLE ThreadHandle, _In_opt_ PIO_STATUS_BLOCK IoRequestToCancel, _Out_ PIO_STATUS_BLOCK IoStatusBlock ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtCreateSymbolicLinkObject( _Out_ PHANDLE LinkHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ PUNICODE_STRING LinkTarget ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenSymbolicLinkObject( _Out_ PHANDLE LinkHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySymbolicLinkObject( _In_ HANDLE LinkHandle, _Inout_ PUNICODE_STRING LinkTarget, _Out_opt_ PULONG ReturnedLength ); NTSYSCALLAPI NTSTATUS NTAPI NtGetContextThread( _In_ HANDLE ThreadHandle, _Inout_ PCONTEXT ThreadContext ); NTSYSCALLAPI NTSTATUS NTAPI NtSetContextThread( _In_ HANDLE ThreadHandle, _In_ PCONTEXT ThreadContext ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenProcess( _Out_ PHANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PCLIENT_ID ClientId ); NTSYSCALLAPI NTSTATUS NTAPI NtTerminateProcess( _In_opt_ HANDLE ProcessHandle, _In_ NTSTATUS ExitStatus ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSCALLAPI NTSTATUS NTAPI NtGetNextProcess( _In_opt_ HANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG HandleAttributes, _In_ ULONG Flags, _Out_ PHANDLE NewProcessHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtGetNextThread( _In_ HANDLE ProcessHandle, _In_opt_ HANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG HandleAttributes, _In_ ULONG Flags, _Out_ PHANDLE NewThreadHandle ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtCreateDebugObject( _Out_ PHANDLE DebugObjectHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ULONG Flags ); NTSYSCALLAPI NTSTATUS NTAPI NtDebugActiveProcess( _In_ HANDLE ProcessHandle, _In_ HANDLE DebugObjectHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtContinue( _In_ PCONTEXT ContextRecord, _In_ BOOLEAN TestAlert ); NTSYSCALLAPI NTSTATUS NTAPI NtRaiseException( _In_ PEXCEPTION_RECORD ExceptionRecord, _In_ PCONTEXT ContextRecord, _In_ BOOLEAN FirstChance ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateThread( _Out_ PHANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE ProcessHandle, _Out_ PCLIENT_ID ClientId, _In_ PCONTEXT ThreadContext, _In_ PINITIAL_TEB InitialTeb, _In_ BOOLEAN CreateSuspended ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCreateThreadEx( _Out_ PHANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE ProcessHandle, _In_ PUSER_THREAD_START_ROUTINE StartRoutine, _In_opt_ PVOID Argument, _In_ ULONG CreateFlags, _In_opt_ SIZE_T ZeroBits, _In_opt_ SIZE_T StackSize, _In_opt_ SIZE_T MaximumStackSize, _In_opt_ PPS_ATTRIBUTE_LIST AttributeList ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtCreateJobObject( _Out_ PHANDLE JobHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenJobObject( _Out_ PHANDLE JobHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtAssignProcessToJobObject( _In_ HANDLE JobHandle, _In_ HANDLE ProcessHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtTerminateJobObject( _In_ HANDLE JobHandle, _In_ NTSTATUS ExitStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtIsProcessInJob( _In_ HANDLE ProcessHandle, _In_opt_ HANDLE JobHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationJobObject( _In_opt_ HANDLE JobHandle, _In_ JOBOBJECTINFOCLASS JobObjectInformationClass, _Out_writes_bytes_(JobObjectInformationLength) PVOID JobObjectInformation, _In_ ULONG JobObjectInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationJobObject( _In_ HANDLE JobHandle, _In_ JOBOBJECTINFOCLASS JobObjectInformationClass, _In_reads_bytes_(JobObjectInformationLength) PVOID JobObjectInformation, _In_ ULONG JobObjectInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateJobSet( _In_ ULONG NumJob, _In_reads_(NumJob) PJOB_SET_ARRAY UserJobSet, _In_ ULONG Flags ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtAllocateReserveObject( _Out_ PHANDLE MemoryReserveHandle, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ MEMORY_RESERVE_TYPE Type ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtRegisterThreadTerminatePort( _In_ HANDLE PortHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtRaiseHardError( _In_ NTSTATUS ErrorStatus, _In_ ULONG NumberOfParameters, _In_ ULONG UnicodeStringParameterMask, _In_reads_(NumberOfParameters) PULONG_PTR Parameters, _In_ HARDERROR_RESPONSE_OPTION ResponseOption, _Out_ PHARDERROR_RESPONSE Response ); NTSYSCALLAPI NTSTATUS NTAPI NtAllocateVirtualMemory( _In_ HANDLE ProcessHandle, _Inout_ _At_(*BaseAddress, _Readable_bytes_(*RegionSize) _Writable_bytes_(*RegionSize) _Post_readable_byte_size_(*RegionSize)) PVOID* BaseAddress, _In_ ULONG_PTR ZeroBits, _Inout_ PSIZE_T RegionSize, _In_ ULONG AllocationType, _In_ ULONG Protect ); NTSYSCALLAPI NTSTATUS NTAPI NtFreeVirtualMemory( _In_ HANDLE ProcessHandle, _Inout_ PVOID* BaseAddress, _Inout_ PSIZE_T RegionSize, _In_ ULONG FreeType ); NTSYSCALLAPI NTSTATUS NTAPI NtReadVirtualMemory( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress, _Out_writes_bytes_(BufferSize) PVOID Buffer, _In_ SIZE_T BufferSize, _Out_opt_ PSIZE_T NumberOfBytesRead ); NTSYSCALLAPI NTSTATUS NTAPI NtWriteVirtualMemory( _In_ HANDLE ProcessHandle, _In_opt_ PVOID BaseAddress, _In_reads_bytes_(BufferSize) CONST VOID* Buffer, _In_ SIZE_T BufferSize, _Out_opt_ PSIZE_T NumberOfBytesWritten ); NTSYSCALLAPI NTSTATUS NTAPI NtAllocateUserPhysicalPages( _In_ HANDLE ProcessHandle, _Inout_ PULONG_PTR NumberOfPages, _Out_writes_(*NumberOfPages) PULONG_PTR UserPfnArray ); NTSYSCALLAPI NTSTATUS NTAPI NtMapUserPhysicalPages( _In_ PVOID VirtualAddress, _In_ ULONG_PTR NumberOfPages, _In_reads_opt_(NumberOfPages) PULONG_PTR UserPfnArray ); NTSYSCALLAPI NTSTATUS NTAPI NtMapUserPhysicalPagesScatter( _In_reads_(NumberOfPages) PVOID* VirtualAddresses, _In_ ULONG_PTR NumberOfPages, _In_reads_opt_(NumberOfPages) PULONG_PTR UserPfnArray ); NTSYSCALLAPI NTSTATUS NTAPI NtFreeUserPhysicalPages( _In_ HANDLE ProcessHandle, _Inout_ PULONG_PTR NumberOfPages, _In_reads_(*NumberOfPages) PULONG_PTR UserPfnArray ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySection( _In_ HANDLE SectionHandle, _In_ SECTION_INFORMATION_CLASS SectionInformationClass, _Out_writes_bytes_(SectionInformationLength) PVOID SectionInformation, _In_ SIZE_T SectionInformationLength, _Out_opt_ PSIZE_T ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtAreMappedFilesTheSame( _In_ PVOID File1MappedAsAnImage, _In_ PVOID File2MappedAsFile ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateSection( _Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PLARGE_INTEGER MaximumSize, _In_ ULONG SectionPageProtection, _In_ ULONG AllocationAttributes, _In_opt_ HANDLE FileHandle ); #if NTDDI_VERSION >= NTDDI_WIN10_RS5 NTSYSCALLAPI NTSTATUS NTAPI NtCreateSectionEx( _Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PLARGE_INTEGER MaximumSize, _In_ ULONG SectionPageProtection, _In_ ULONG AllocationAttributes, _In_opt_ HANDLE FileHandle, _Inout_updates_opt_(ExtendedParameterCount) struct _MEM_EXTENDED_PARAMETER* ExtendedParameters, _In_ ULONG ExtendedParameterCount ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtOpenSection( _Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtMapViewOfSection( _In_ HANDLE SectionHandle, _In_ HANDLE ProcessHandle, _Inout_ _At_(*BaseAddress, _Readable_bytes_(*ViewSize) _Writable_bytes_(*ViewSize) _Post_readable_byte_size_(*ViewSize)) PVOID* BaseAddress, _In_ ULONG_PTR ZeroBits, _In_ SIZE_T CommitSize, _Inout_opt_ PLARGE_INTEGER SectionOffset, _Inout_ PSIZE_T ViewSize, _In_ SECTION_INHERIT InheritDisposition, _In_ ULONG AllocationType, _In_ ULONG Win32Protect ); #if NTDDI_VERSION >= NTDDI_WIN10_RS4 NTSYSCALLAPI NTSTATUS NTAPI NtMapViewOfSectionEx( _In_ HANDLE SectionHandle, _In_ HANDLE ProcessHandle, _Inout_opt_ PVOID* BaseAddress, _In_ PLARGE_INTEGER ViewOffset, _Inout_ PSIZE_T ViewSize, _In_ ULONG AllocationType, _In_ ULONG Win32Protect, _Inout_updates_opt_(ParameterCount) struct _MEM_EXTENDED_PARAMETER* ExtendedParameters, _In_ ULONG ParameterCount ); #endif #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtOpenSession( _Out_ PHANDLE SessionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtNotifyChangeDirectoryFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_ FILE_NOTIFY_INFORMATION Buffer, _In_ ULONG Length, _In_ ULONG CompletionFilter, _In_ BOOLEAN WatchTree ); #if NTDDI_VERSION >= NTDDI_WIN10_RS3 NTSYSCALLAPI NTSTATUS NTAPI NtNotifyChangeDirectoryFileEx( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _In_ ULONG CompletionFilter, _In_ BOOLEAN WatchTree, _In_opt_ DIRECTORY_NOTIFY_INFORMATION_CLASS DirectoryNotifyInformationClass ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtOpenFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG ShareAccess, _In_ ULONG OpenOptions ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryDirectoryFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass, _In_ BOOLEAN ReturnSingleEntry, _In_opt_ PUNICODE_STRING FileName, _In_ BOOLEAN RestartScan ); #if NTDDI_VERSION >= NTDDI_WIN10_RS3 NTSYSCALLAPI NTSTATUS NTAPI NtQueryDirectoryFileEx( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass, _In_ ULONG QueryFlags, _In_opt_ PUNICODE_STRING FileName ); #endif #if (NTDDI_VERSION >= NTDDI_WIN10_RS2) NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationByName( _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FileInformation, _In_ ULONG Length, _In_ FILE_INFORMATION_CLASS FileInformationClass ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtQueryEaFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _In_ BOOLEAN ReturnSingleEntry, _In_reads_bytes_opt_(EaListLength) PVOID EaList, _In_ ULONG EaListLength, _In_opt_ PULONG EaIndex, _In_ BOOLEAN RestartScan ); NTSYSCALLAPI NTSTATUS NTAPI NtSetEaFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length ); NTSYSCALLAPI NTSTATUS NTAPI NtLoadDriver( _In_ PUNICODE_STRING DriverServiceName ); NTSYSCALLAPI NTSTATUS NTAPI NtUnloadDriver( _In_ PUNICODE_STRING DriverServiceName ); NTSYSCALLAPI NTSTATUS NTAPI NtReadFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER ByteOffset, _In_opt_ PULONG Key ); NTSYSCALLAPI NTSTATUS NTAPI NtReadFileScatter( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ PFILE_SEGMENT_ELEMENT SegmentArray, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER ByteOffset, _In_opt_ PULONG Key ); NTSYSCALLAPI NTSTATUS NTAPI NtWriteFileGather( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ PFILE_SEGMENT_ELEMENT SegmentArray, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER ByteOffset, _In_opt_ PULONG Key ); NTSYSCALLAPI NTSTATUS NTAPI NtDeleteFile( _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtWriteFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _In_opt_ PLARGE_INTEGER ByteOffset, _In_opt_ PULONG Key ); NTSYSCALLAPI NTSTATUS NTAPI NtDeviceIoControlFile( _In_ HANDLE FileHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG IoControlCode, _In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationObject( _In_ HANDLE Handle, _In_ OBJECT_INFORMATION_CLASS ObjectInformationClass, _In_reads_bytes_(ObjectInformationLength) PVOID ObjectInformation, _In_ ULONG ObjectInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtDuplicateObject( _In_ HANDLE SourceProcessHandle, _In_ HANDLE SourceHandle, _In_opt_ HANDLE TargetProcessHandle, _Out_opt_ PHANDLE TargetHandle, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG HandleAttributes, _In_ ULONG Options ); NTSYSCALLAPI NTSTATUS NTAPI NtMakePermanentObject( _In_ HANDLE Object ); NTSYSCALLAPI NTSTATUS NTAPI NtMakeTemporaryObject( _In_ HANDLE Handle ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateDirectoryObject( _Out_ PHANDLE DirectoryHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenDirectoryObject( _Out_ PHANDLE DirectoryHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryDirectoryObject( _In_ HANDLE DirectoryHandle, _Out_writes_bytes_opt_(Length) PVOID Buffer, _In_ ULONG Length, _In_ BOOLEAN ReturnSingleEntry, _In_ BOOLEAN RestartScan, _Inout_ PULONG Context, _Out_opt_ PULONG ReturnLength ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCreatePrivateNamespace( _Out_ PHANDLE NamespaceHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE BoundaryDescriptor ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenPrivateNamespace( _Out_ PHANDLE NamespaceHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE BoundaryDescriptor ); NTSYSCALLAPI NTSTATUS NTAPI NtDeletePrivateNamespace( _In_ HANDLE NamespaceHandle ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtOpenThread( _Out_ PHANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PCLIENT_ID ClientId ); NTSYSCALLAPI NTSTATUS NTAPI NtTerminateThread( _In_opt_ HANDLE ThreadHandle, _In_ NTSTATUS ExitStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySystemTime( _Out_ PLARGE_INTEGER SystemTime ); NTSYSCALLAPI NTSTATUS NTAPI NtSetSystemTime( _In_opt_ PLARGE_INTEGER SystemTime, _Out_opt_ PLARGE_INTEGER PreviousTime ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryTimerResolution( _Out_ PULONG MaximumTime, _Out_ PULONG MinimumTime, _Out_ PULONG CurrentTime ); NTSYSCALLAPI NTSTATUS NTAPI NtSetTimerResolution( _In_ ULONG DesiredTime, _In_ BOOLEAN SetResolution, _Out_ PULONG ActualTime ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryPerformanceCounter( _Out_ PLARGE_INTEGER PerformanceCounter, _Out_opt_ PLARGE_INTEGER PerformanceFrequency ); NTSYSCALLAPI NTSTATUS NTAPI NtAllocateLocallyUniqueId( _Out_ PLUID Luid ); NTSYSCALLAPI NTSTATUS NTAPI NtSetUuidSeed( _In_ PCHAR Seed ); NTSYSCALLAPI NTSTATUS NTAPI NtAllocateUuids( _Out_ PULARGE_INTEGER Time, _Out_ PULONG Range, _Out_ PULONG Sequence, _Out_ PCHAR Seed ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateEvent( _Out_ PHANDLE EventHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ EVENT_TYPE EventType, _In_ BOOLEAN InitialState ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenEvent( _Out_ PHANDLE EventHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtSetEvent( _In_ HANDLE EventHandle, _Out_opt_ PLONG PreviousState ); NTSYSCALLAPI NTSTATUS NTAPI NtResetEvent( _In_ HANDLE EventHandle, _Out_opt_ PLONG PreviousState ); NTSYSCALLAPI NTSTATUS NTAPI NtClearEvent( _In_ HANDLE EventHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryQuotaInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_ PVOID Buffer, _In_ ULONG Length, _In_ BOOLEAN ReturnSingleEntry, _In_opt_ PVOID SidList, _In_ ULONG SidListLength, _In_opt_ PSID StartSid, _In_ BOOLEAN RestartScan ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryVolumeInformationFile( _In_ HANDLE FileHandle, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _Out_writes_bytes_(Length) PVOID FsInformation, _In_ ULONG Length, _In_ FS_INFORMATION_CLASS FsInformationClass ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateKey( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Reserved_ ULONG TitleIndex, _In_opt_ PUNICODE_STRING Class, _In_ ULONG CreateOptions, _Out_opt_ PULONG Disposition ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCreateKeyTransacted( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Reserved_ ULONG TitleIndex, _In_opt_ PUNICODE_STRING Class, _In_ ULONG CreateOptions, _In_ HANDLE TransactionHandle, _Out_opt_ PULONG Disposition ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtOpenKey( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtOpenKeyTransacted( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE TransactionHandle ); #endif #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtOpenKeyEx( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ULONG OpenOptions ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenKeyTransactedEx( _Out_ PHANDLE KeyHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ULONG OpenOptions, _In_ HANDLE TransactionHandle ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtDeleteKey( _In_ HANDLE KeyHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtRenameKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING NewName ); NTSYSCALLAPI NTSTATUS NTAPI NtDeleteValueKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryKey( _In_ HANDLE KeyHandle, _In_ KEY_INFORMATION_CLASS KeyInformationClass, _Out_writes_bytes_to_opt_(Length, *ResultLength) PVOID KeyInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationKey( _In_ HANDLE KeyHandle, _In_ KEY_SET_INFORMATION_CLASS KeySetInformationClass, _In_reads_bytes_(KeySetInformationLength) PVOID KeySetInformation, _In_ ULONG KeySetInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryValueKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName, _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, _Out_writes_bytes_to_opt_(Length, *ResultLength) PVOID KeyValueInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetValueKey( _In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName, _In_opt_ ULONG TitleIndex, _In_ ULONG Type, _In_reads_bytes_opt_(DataSize) PVOID Data, _In_ ULONG DataSize ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryMultipleValueKey( _In_ HANDLE KeyHandle, _Inout_updates_(EntryCount) PKEY_VALUE_ENTRY ValueEntries, _In_ ULONG EntryCount, _Out_writes_bytes_(*BufferLength) PVOID ValueBuffer, _Inout_ PULONG BufferLength, _Out_opt_ PULONG RequiredBufferLength ); NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateKey( _In_ HANDLE KeyHandle, _In_ ULONG Index, _In_ KEY_INFORMATION_CLASS KeyInformationClass, _Out_writes_bytes_to_opt_(Length, *ResultLength) PVOID KeyInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateValueKey( _In_ HANDLE KeyHandle, _In_ ULONG Index, _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, _Out_writes_bytes_to_opt_(Length, *ResultLength) PVOID KeyValueInformation, _In_ ULONG Length, _Out_ PULONG ResultLength ); NTSYSCALLAPI NTSTATUS NTAPI NtFlushKey( _In_ HANDLE KeyHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtCompactKeys( _In_ ULONG Count, _In_ PHANDLE KeyArray ); NTSYSCALLAPI NTSTATUS NTAPI NtCompressKey( _In_ HANDLE Key ); NTSYSCALLAPI NTSTATUS NTAPI NtLoadKey( _In_ POBJECT_ATTRIBUTES TargetKey, _In_ POBJECT_ATTRIBUTES SourceFile ); NTSYSCALLAPI NTSTATUS NTAPI NtLoadKey2( _In_ POBJECT_ATTRIBUTES TargetKey, _In_ POBJECT_ATTRIBUTES SourceFile, _In_ ULONG Flags ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSCALLAPI NTSTATUS NTAPI NtLoadKeyEx( _In_ POBJECT_ATTRIBUTES TargetKey, _In_ POBJECT_ATTRIBUTES SourceFile, _In_ ULONG Flags, _In_opt_ HANDLE TrustClassKey, _In_opt_ HANDLE Event, _In_opt_ ACCESS_MASK DesiredAccess, _Out_opt_ PHANDLE RootHandle, _Out_opt_ PIO_STATUS_BLOCK IoStatus ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtReplaceKey( _In_ POBJECT_ATTRIBUTES NewFile, _In_ HANDLE TargetHandle, _In_ POBJECT_ATTRIBUTES OldFile ); NTSYSCALLAPI NTSTATUS NTAPI NtSaveKey( _In_ HANDLE KeyHandle, _In_ HANDLE FileHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtSaveKeyEx( _In_ HANDLE KeyHandle, _In_ HANDLE FileHandle, _In_ ULONG Format ); NTSYSCALLAPI NTSTATUS NTAPI NtSaveMergedKeys( _In_ HANDLE HighPrecedenceKeyHandle, _In_ HANDLE LowPrecedenceKeyHandle, _In_ HANDLE FileHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtRestoreKey( _In_ HANDLE KeyHandle, _In_opt_ HANDLE FileHandle, _In_ ULONG Flags ); NTSYSCALLAPI NTSTATUS NTAPI NtUnloadKey( _In_ POBJECT_ATTRIBUTES TargetKey ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSCALLAPI NTSTATUS NTAPI NtUnloadKey2( _In_ POBJECT_ATTRIBUTES TargetKey, _In_ ULONG Flags ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtUnloadKeyEx( _In_ POBJECT_ATTRIBUTES TargetKey, _In_opt_ HANDLE Event ); NTSYSCALLAPI NTSTATUS NTAPI NtNotifyChangeKey( _In_ HANDLE KeyHandle, _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG CompletionFilter, _In_ BOOLEAN WatchTree, _Out_writes_bytes_opt_(BufferSize) PVOID Buffer, _In_ ULONG BufferSize, _In_ BOOLEAN Asynchronous ); NTSYSCALLAPI NTSTATUS NTAPI NtNotifyChangeMultipleKeys( _In_ HANDLE MasterKeyHandle, _In_opt_ ULONG Count, _In_reads_opt_(Count) OBJECT_ATTRIBUTES SubordinateObjects[], _In_opt_ HANDLE Event, _In_opt_ PIO_APC_ROUTINE ApcRoutine, _In_opt_ PVOID ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG CompletionFilter, _In_ BOOLEAN WatchTree, _Out_writes_bytes_opt_(BufferSize) PVOID Buffer, _In_ ULONG BufferSize, _In_ BOOLEAN Asynchronous ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryOpenSubKeys( _In_ POBJECT_ATTRIBUTES TargetKey, _Out_ PULONG HandleCount ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSCALLAPI NTSTATUS NTAPI NtQueryOpenSubKeysEx( _In_ POBJECT_ATTRIBUTES TargetKey, _In_ ULONG BufferLength, _Out_writes_bytes_opt_(BufferLength) PVOID Buffer, _Out_ PULONG RequiredSize ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtInitializeRegistry( _In_ USHORT BootCondition ); NTSYSCALLAPI NTSTATUS NTAPI NtLockRegistryKey( _In_ HANDLE KeyHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtLockProductActivationKeys( _Inout_opt_ ULONG* pPrivateVer, _Out_opt_ ULONG* pSafeMode ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtFreezeRegistry( _In_ ULONG TimeOutInSeconds ); NTSYSCALLAPI NTSTATUS NTAPI NtThawRegistry( ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtDelayExecution( _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER DelayInterval ); NTSYSCALLAPI NTSTATUS NTAPI NtCallbackReturn( _In_reads_bytes_opt_(OutputLength) PVOID OutputBuffer, _In_ ULONG OutputLength, _In_ NTSTATUS Status ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI VOID NTAPI NtFlushProcessWriteBuffers( ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtQueryDebugFilterState( _In_ ULONG ComponentId, _In_ ULONG Level ); NTSYSCALLAPI NTSTATUS NTAPI NtSetDebugFilterState( _In_ ULONG ComponentId, _In_ ULONG Level, _In_ BOOLEAN State ); NTSYSCALLAPI NTSTATUS NTAPI NtRemoveProcessDebug( _In_ HANDLE ProcessHandle, _In_ HANDLE DebugObjectHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtWaitForDebugEvent( _In_ HANDLE DebugObjectHandle, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout, _Out_ PDBGUI_WAIT_STATE_CHANGE WaitStateChange ); NTSYSCALLAPI NTSTATUS NTAPI NtDebugContinue( _In_ HANDLE DebugObjectHandle, _In_ PCLIENT_ID ClientId, _In_ NTSTATUS ContinueStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationDebugObject( _In_ HANDLE DebugObjectHandle, _In_ DEBUGOBJECTINFOCLASS DebugObjectInformationClass, _In_ PVOID DebugInformation, _In_ ULONG DebugInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenProcessToken( _In_ HANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE TokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenProcessTokenEx( _In_ HANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG HandleAttributes, _Out_ PHANDLE TokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenThreadToken( _In_ HANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_ BOOLEAN OpenAsSelf, _Out_ PHANDLE TokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenThreadTokenEx( _In_ HANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_ BOOLEAN OpenAsSelf, _In_ ULONG HandleAttributes, _Out_ PHANDLE TokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateToken( _Out_ PHANDLE TokenHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ TOKEN_TYPE TokenType, _In_ PLUID AuthenticationId, _In_ PLARGE_INTEGER ExpirationTime, _In_ PTOKEN_USER User, _In_ PTOKEN_GROUPS Groups, _In_ PTOKEN_PRIVILEGES Privileges, _In_opt_ PTOKEN_OWNER Owner, _In_ PTOKEN_PRIMARY_GROUP PrimaryGroup, _In_opt_ PTOKEN_DEFAULT_DACL DefaultDacl, _In_ PTOKEN_SOURCE TokenSource ); NTSYSCALLAPI NTSTATUS NTAPI NtDuplicateToken( _In_ HANDLE ExistingTokenHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ BOOLEAN EffectiveOnly, _In_ TOKEN_TYPE TokenType, _Out_ PHANDLE NewTokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationToken( _In_ HANDLE TokenHandle, _In_ TOKEN_INFORMATION_CLASS TokenInformationClass, _Out_writes_bytes_to_opt_(TokenInformationLength, *ReturnLength) PVOID TokenInformation, _In_ ULONG TokenInformationLength, _Out_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtAdjustPrivilegesToken( _In_ HANDLE TokenHandle, _In_ BOOLEAN DisableAllPrivileges, _In_opt_ PTOKEN_PRIVILEGES NewState, _In_ ULONG BufferLength, _Out_opt_ PTOKEN_PRIVILEGES PreviousState, _Out_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtAdjustGroupsToken( _In_ HANDLE TokenHandle, _In_ BOOLEAN ResetToDefault, _In_opt_ PTOKEN_GROUPS NewState, _In_range_( >=, sizeof(TOKEN_GROUPS)) ULONG BufferLength, _Out_writes_bytes_to_opt_(BufferLength, *ReturnLength) PTOKEN_GROUPS PreviousState, _Out_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtFilterToken( _In_ HANDLE ExistingTokenHandle, _In_ ULONG Flags, _In_opt_ PTOKEN_GROUPS SidsToDisable, _In_opt_ PTOKEN_PRIVILEGES PrivilegesToDelete, _In_opt_ PTOKEN_GROUPS RestrictedSids, _Out_ PHANDLE NewTokenHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationToken( _In_ HANDLE TokenHandle, _In_ TOKEN_INFORMATION_CLASS TokenInformationClass, _In_ PVOID TokenInformation, _In_ ULONG TokenInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCompareTokens( _In_ HANDLE FirstTokenHandle, _In_ HANDLE SecondTokenHandle, _Out_ PBOOLEAN Equal ); NTSYSCALLAPI NTSTATUS NTAPI NtPrivilegeCheck( _In_ HANDLE ClientToken, _Inout_ PPRIVILEGE_SET RequiredPrivileges, _Out_ PBOOLEAN Result ); NTSYSCALLAPI NTSTATUS NTAPI NtImpersonateAnonymousToken( _In_ HANDLE ThreadHandle ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtQuerySecurityAttributesToken( _In_ HANDLE TokenHandle, _In_reads_opt_(NumberOfAttributes) PUNICODE_STRING Attributes, _In_ ULONG NumberOfAttributes, _Out_ PTOKEN_SECURITY_ATTRIBUTES_INFORMATION Buffer, _In_ ULONG Length, _Out_ PULONG ReturnLength ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtAccessCheck( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ HANDLE ClientToken, _In_ ACCESS_MASK DesiredAccess, _In_ PGENERIC_MAPPING GenericMapping, _Out_ PPRIVILEGE_SET PrivilegeSet, _Inout_ PULONG PrivilegeSetLength, _Out_ PACCESS_MASK GrantedAccess, _Out_ PNTSTATUS AccessStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtAccessCheckByType( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_opt_ PSID PrincipalSelfSid, _In_ HANDLE ClientToken, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_TYPE_LIST ObjectTypeList, _In_ ULONG ObjectTypeListLength, _In_ PGENERIC_MAPPING GenericMapping, _Out_ PPRIVILEGE_SET PrivilegeSet, _Inout_ PULONG PrivilegeSetLength, _Out_ PACCESS_MASK GrantedAccess, _Out_ PNTSTATUS AccessStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtAccessCheckByTypeResultList( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_opt_ PSID PrincipalSelfSid, _In_ HANDLE ClientToken, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_TYPE_LIST ObjectTypeList, _In_ ULONG ObjectTypeListLength, _In_ PGENERIC_MAPPING GenericMapping, _Out_ PPRIVILEGE_SET PrivilegeSet, _Inout_ PULONG PrivilegeSetLength, _Out_ PACCESS_MASK GrantedAccess, _Out_ PNTSTATUS AccessStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateIoCompletion( _Out_ PHANDLE IoCompletionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG Count ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenIoCompletion( _Out_ PHANDLE IoCompletionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryIoCompletion( _In_ HANDLE IoCompletionHandle, _In_ IO_COMPLETION_INFORMATION_CLASS IoCompletionInformationClass, _Out_writes_bytes_(IoCompletionInformationLength) PVOID IoCompletionInformation, _In_ ULONG IoCompletionInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetIoCompletion( _In_ HANDLE IoCompletionHandle, _In_opt_ PVOID KeyContext, _In_opt_ PVOID ApcContext, _In_ NTSTATUS IoStatus, _In_ ULONG_PTR IoStatusInformation ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtSetIoCompletionEx( _In_ HANDLE IoCompletionHandle, _In_ HANDLE IoCompletionPacketHandle, _In_opt_ PVOID KeyContext, _In_opt_ PVOID ApcContext, _In_ NTSTATUS IoStatus, _In_ ULONG_PTR IoStatusInformation ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtRemoveIoCompletion( _In_ HANDLE IoCompletionHandle, _Out_ PVOID* KeyContext, _Out_ PVOID* ApcContext, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER Timeout ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtRemoveIoCompletionEx( _In_ HANDLE IoCompletionHandle, _Out_writes_to_(Count, *NumEntriesRemoved) PFILE_IO_COMPLETION_INFORMATION IoCompletionInformation, _In_ ULONG Count, _Out_ PULONG NumEntriesRemoved, _In_opt_ PLARGE_INTEGER Timeout, _In_ BOOLEAN Alertable ); #endif #if NTDDI_VERSION >= NTDDI_WIN8 NTSYSCALLAPI NTSTATUS NTAPI NtCreateWaitCompletionPacket( _Out_ PHANDLE WaitCompletionPacketHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtAssociateWaitCompletionPacket( _In_ HANDLE WaitCompletionPacketHandle, _In_ HANDLE IoCompletionHandle, _In_ HANDLE TargetObjectHandle, _In_opt_ PVOID KeyContext, _In_opt_ PVOID ApcContext, _In_ NTSTATUS IoStatus, _In_ ULONG_PTR IoStatusInformation, _Out_opt_ PBOOLEAN AlreadySignaled ); NTSYSCALLAPI NTSTATUS NTAPI NtCancelWaitCompletionPacket( _In_ HANDLE WaitCompletionPacketHandle, _In_ BOOLEAN RemoveSignaledPacket ); #endif #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtNotifyChangeSession( _In_ HANDLE SessionHandle, _In_ ULONG ChangeSequenceNumber, _In_ PLARGE_INTEGER ChangeTimeStamp, _In_ IO_SESSION_EVENT Event, _In_ IO_SESSION_STATE NewState, _In_ IO_SESSION_STATE PreviousState, _In_reads_bytes_opt_(PayloadSize) PVOID Payload, _In_ ULONG PayloadSize ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtCreateMutant( _Out_ PHANDLE MutantHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ BOOLEAN InitialOwner ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenMutant( _Out_ PHANDLE MutantHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtReleaseMutant( _In_ HANDLE MutantHandle, _Out_opt_ PLONG PreviousCount ); NTSYSCALLAPI NTSTATUS NTAPI NtAlertThread( _In_ HANDLE ThreadHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtAlertResumeThread( _In_ HANDLE ThreadHandle, _Out_opt_ PULONG PreviousSuspendCount ); NTSYSCALLAPI NTSTATUS NTAPI NtTestAlert( VOID ); NTSYSCALLAPI NTSTATUS NTAPI NtImpersonateThread( _In_ HANDLE ServerThreadHandle, _In_ HANDLE ClientThreadHandle, _In_ PSECURITY_QUALITY_OF_SERVICE SecurityQos ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateSemaphore( _Out_ PHANDLE SemaphoreHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ LONG InitialCount, _In_ LONG MaximumCount ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenSemaphore( _Out_ PHANDLE SemaphoreHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtReleaseSemaphore( _In_ HANDLE SemaphoreHandle, _In_ LONG ReleaseCount, _Out_opt_ PLONG PreviousCount ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySemaphore( _In_ HANDLE SemaphoreHandle, _In_ SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass, _Out_writes_bytes_(SemaphoreInformationLength) PVOID SemaphoreInformation, _In_ ULONG SemaphoreInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateTimer( _Out_ PHANDLE TimerHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ TIMER_TYPE TimerType ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenTimer( _Out_ PHANDLE TimerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtSetTimer( _In_ HANDLE TimerHandle, _In_ PLARGE_INTEGER DueTime, _In_opt_ PTIMER_APC_ROUTINE TimerApcRoutine, _In_opt_ PVOID TimerContext, _In_ BOOLEAN ResumeTimer, _In_opt_ LONG Period, _Out_opt_ PBOOLEAN PreviousState ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtSetTimerEx( _In_ HANDLE TimerHandle, _In_ TIMER_SET_INFORMATION_CLASS TimerSetInformationClass, _Inout_updates_bytes_opt_(TimerSetInformationLength) PVOID TimerSetInformation, _In_ ULONG TimerSetInformationLength ); #endif NTSYSCALLAPI NTSTATUS NTAPI NtCancelTimer( _In_ HANDLE TimerHandle, _Out_opt_ PBOOLEAN CurrentState ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryTimer( _In_ HANDLE TimerHandle, _In_ TIMER_INFORMATION_CLASS TimerInformationClass, _Out_ PVOID TimerInformation, _In_ ULONG TimerInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateKeyedEvent( _Out_ PHANDLE KeyedEventHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ULONG Flags ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenKeyedEvent( _Out_ PHANDLE KeyedEventHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtReleaseKeyedEvent( _In_ HANDLE KeyedEventHandle, _In_ PVOID KeyValue, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); NTSYSCALLAPI NTSTATUS NTAPI NtWaitForKeyedEvent( _In_ HANDLE KeyedEventHandle, _In_ PVOID KeyValue, _In_ BOOLEAN Alertable, _In_opt_ PLARGE_INTEGER Timeout ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtUmsThreadYield( _In_ PVOID SchedulerParam ); #endif #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCreateTransactionManager( _Out_ PHANDLE TmHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PUNICODE_STRING LogFileName, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG CommitStrength ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenTransactionManager( _Out_ PHANDLE TmHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PUNICODE_STRING LogFileName, _In_opt_ LPGUID TmIdentity, _In_opt_ ULONG OpenOptions ); NTSYSCALLAPI NTSTATUS NTAPI NtRenameTransactionManager( _In_ PUNICODE_STRING LogFileName, _In_ LPGUID ExistingTransactionManagerGuid ); NTSYSCALLAPI NTSTATUS NTAPI NtRollforwardTransactionManager( _In_ HANDLE TransactionManagerHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtRecoverTransactionManager( _In_ HANDLE TransactionManagerHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationTransactionManager( _In_ HANDLE TransactionManagerHandle, _In_ TRANSACTIONMANAGER_INFORMATION_CLASS TransactionManagerInformationClass, _Out_writes_bytes_(TransactionManagerInformationLength) PVOID TransactionManagerInformation, _In_ ULONG TransactionManagerInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationTransactionManager( _In_ HANDLE TmHandle, _In_ TRANSACTIONMANAGER_INFORMATION_CLASS TransactionManagerInformationClass, _In_ PVOID TransactionManagerInformation, _In_ ULONG TransactionManagerInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateTransactionObject( _In_opt_ HANDLE RootObjectHandle, _In_ KTMOBJECT_TYPE QueryType, _Inout_updates_bytes_(ObjectCursorLength) PKTMOBJECT_CURSOR ObjectCursor, _In_ ULONG ObjectCursorLength, _Out_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateTransaction( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ LPGUID Uow, _In_opt_ HANDLE TmHandle, _In_opt_ ULONG CreateOptions, _In_opt_ ULONG IsolationLevel, _In_opt_ ULONG IsolationFlags, _In_opt_ PLARGE_INTEGER Timeout, _In_opt_ PUNICODE_STRING Description ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenTransaction( _Out_ PHANDLE TransactionHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ LPGUID Uow, _In_opt_ HANDLE TmHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationTransaction( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _Out_writes_bytes_(TransactionInformationLength) PVOID TransactionInformation, _In_ ULONG TransactionInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationTransaction( _In_ HANDLE TransactionHandle, _In_ TRANSACTION_INFORMATION_CLASS TransactionInformationClass, _In_ PVOID TransactionInformation, _In_ ULONG TransactionInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtCommitTransaction( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); NTSYSCALLAPI NTSTATUS NTAPI NtRollbackTransaction( _In_ HANDLE TransactionHandle, _In_ BOOLEAN Wait ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateEnlistment( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE ResourceManagerHandle, _In_ HANDLE TransactionHandle, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions, _In_ NOTIFICATION_MASK NotificationMask, _In_opt_ PVOID EnlistmentKey ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenEnlistment( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE ResourceManagerHandle, _In_ LPGUID EnlistmentGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationEnlistment( _In_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS EnlistmentInformationClass, _Out_writes_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation, _In_ ULONG EnlistmentInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationEnlistment( _In_opt_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS EnlistmentInformationClass, _In_reads_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation, _In_ ULONG EnlistmentInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtRecoverEnlistment( _In_ HANDLE EnlistmentHandle, _In_opt_ PVOID EnlistmentKey ); NTSYSCALLAPI NTSTATUS NTAPI NtPrePrepareEnlistment( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtPrepareEnlistment( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtCommitEnlistment( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtRollbackEnlistment( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtPrePrepareComplete( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtPrepareComplete( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtCommitComplete( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtReadOnlyEnlistment( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtRollbackComplete( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtSinglePhaseReject( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock ); NTSYSCALLAPI NTSTATUS NTAPI NtCreateResourceManager( _Out_ PHANDLE ResourceManagerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE TmHandle, _In_opt_ LPGUID ResourceManagerGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ ULONG CreateOptions, _In_opt_ PUNICODE_STRING Description ); NTSYSCALLAPI NTSTATUS NTAPI NtOpenResourceManager( _Out_ PHANDLE ResourceManagerHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDLE TmHandle, _In_ LPGUID ResourceManagerGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes ); NTSYSCALLAPI NTSTATUS NTAPI NtRecoverResourceManager( _In_ HANDLE ResourceManagerHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtGetNotificationResourceManager( _In_ HANDLE ResourceManagerHandle, _Out_ PTRANSACTION_NOTIFICATION TransactionNotification, _In_ ULONG NotificationLength, _In_ PLARGE_INTEGER Timeout, _Out_opt_ PULONG ReturnLength, _In_ ULONG Asynchronous, _In_opt_ ULONG_PTR AsynchronousContext ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationResourceManager( _In_ HANDLE ResourceManagerHandle, _In_ RESOURCEMANAGER_INFORMATION_CLASS ResourceManagerInformationClass, _Out_writes_bytes_(ResourceManagerInformationLength) PVOID ResourceManagerInformation, _In_ ULONG ResourceManagerInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationResourceManager( _In_ HANDLE ResourceManagerHandle, _In_ RESOURCEMANAGER_INFORMATION_CLASS ResourceManagerInformationClass, _In_ PVOID ResourceManagerInformation, _In_ ULONG ResourceManagerInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtRegisterProtocolAddressInformation( _In_ HANDLE ResourceManager, _In_ PCRM_PROTOCOL_ID ProtocolId, _In_ ULONG ProtocolInformationSize, _In_ PVOID ProtocolInformation, _In_opt_ ULONG CreateOptions ); NTSYSCALLAPI NTSTATUS NTAPI NtPropagationComplete( _In_ HANDLE ResourceManagerHandle, _In_ ULONG RequestCookie, _In_ ULONG BufferLength, _In_ PVOID Buffer ); NTSYSCALLAPI NTSTATUS NTAPI NtPropagationFailed( _In_ HANDLE ResourceManagerHandle, _In_ ULONG RequestCookie, _In_ NTSTATUS PropStatus ); NTSYSCALLAPI NTSTATUS NTAPI NtFreezeTransactions( _In_ PLARGE_INTEGER FreezeTimeout, _In_ PLARGE_INTEGER ThawTimeout ); NTSYSCALLAPI NTSTATUS NTAPI NtThawTransactions( ); #endif #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtCreateWorkerFactory( _Out_ PHANDLE WorkerFactoryHandleReturn, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ HANDLE CompletionPortHandle, _In_ HANDLE WorkerProcessHandle, _In_ PUSER_THREAD_START_ROUTINE StartRoutine, _In_opt_ PVOID StartParameter, _In_opt_ ULONG MaxThreadCount, _In_opt_ SIZE_T StackReserve, _In_opt_ SIZE_T StackCommit ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryInformationWorkerFactory( _In_ HANDLE WorkerFactoryHandle, _In_ WORKERFACTORYINFOCLASS WorkerFactoryInformationClass, _Out_ PVOID WorkerFactoryInformation, _In_ ULONG WorkerFactoryInformationLength, _Out_opt_ PULONG ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetInformationWorkerFactory( _In_ HANDLE WorkerFactoryHandle, _In_ WORKERFACTORYINFOCLASS WorkerFactoryInformationClass, _In_ PVOID WorkerFactoryInformation, _In_ ULONG WorkerFactoryInformationLength ); NTSYSCALLAPI NTSTATUS NTAPI NtShutdownWorkerFactory( _In_ HANDLE WorkerFactoryHandle, _Inout_ volatile LONG* PendingWorkerCount ); NTSYSCALLAPI NTSTATUS NTAPI NtReleaseWorkerFactoryWorker( _In_ HANDLE WorkerFactoryHandle ); NTSYSCALLAPI NTSTATUS NTAPI NtWorkerFactoryWorkerReady( _In_ HANDLE WorkerFactoryHandle ); #if NTDDI_VERSION >= NTDDI_WIN8 || defined(_WIN64) // Windows 8+ declaration, can be used on Vista/7 x64 NTSYSCALLAPI NTSTATUS NTAPI NtWaitForWorkViaWorkerFactory( _In_ HANDLE WorkerFactoryHandle, _Out_writes_to_(Count, *PacketsReturned) PFILE_IO_COMPLETION_INFORMATION MiniPackets, _In_ ULONG Count, _Out_ PULONG PacketsReturned, _In_ PWORKER_FACTORY_DEFERRED_WORK DeferredWork ); #else // Allow Windows Vista/7 x86 to link (import '@8' decorated stdcall name from ntdll.lib instead of '@20') // If you're using a newer **x86 32 bit** version of Windows, use the previous declaration (or make a typedef) NTSYSCALLAPI NTSTATUS NTAPI ZwWaitForWorkViaWorkerFactory( _In_ HANDLE WorkerFactoryHandle, _Out_ PFILE_IO_COMPLETION_INFORMATION MiniPacket ); FORCEINLINE NTSTATUS NtWaitForWorkViaWorkerFactory( _In_ HANDLE WorkerFactoryHandle, _Out_ PFILE_IO_COMPLETION_INFORMATION MiniPackets, _Reserved_ ULONG Count, _Reserved_ PULONG PacketsReturned, _Reserved_ PWORKER_FACTORY_DEFERRED_WORK DeferredWork ) { UNREFERENCED_PARAMETER(Count); UNREFERENCED_PARAMETER(PacketsReturned); UNREFERENCED_PARAMETER(DeferredWork); return ZwWaitForWorkViaWorkerFactory(WorkerFactoryHandle, MiniPackets); } #endif #endif NTSYSCALLAPI NTSTATUS NTAPI NtQuerySystemEnvironmentValue( _In_ PUNICODE_STRING VariableName, _Out_writes_bytes_(ValueLength) PWSTR VariableValue, _In_ USHORT ValueLength, _Out_opt_ PUSHORT ReturnLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetSystemEnvironmentValue( _In_ PUNICODE_STRING VariableName, _In_ PUNICODE_STRING VariableValue ); NTSYSCALLAPI NTSTATUS NTAPI NtQuerySystemEnvironmentValueEx( _In_ PUNICODE_STRING VariableName, _In_ LPGUID VendorGuid, _Out_writes_bytes_opt_(*ValueLength) PVOID Value, _Inout_ PULONG ValueLength, _Out_opt_ PULONG Attributes ); NTSYSCALLAPI NTSTATUS NTAPI NtSetSystemEnvironmentValueEx( _In_ PUNICODE_STRING VariableName, _In_ LPGUID VendorGuid, _In_reads_bytes_opt_(ValueLength) PVOID Value, _In_ ULONG ValueLength, _In_ ULONG Attributes ); NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateSystemEnvironmentValuesEx( _In_ ULONG InformationClass, _Out_ PVOID Buffer, _Inout_ PULONG BufferLength ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSCALLAPI NTSTATUS NTAPI NtAddBootEntry( _In_ PBOOT_ENTRY BootEntry, _Out_opt_ PULONG Id ); NTSYSCALLAPI NTSTATUS NTAPI NtDeleteBootEntry( _In_ ULONG Id ); NTSYSCALLAPI NTSTATUS NTAPI NtModifyBootEntry( _In_ PBOOT_ENTRY BootEntry ); NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateBootEntries( _Out_writes_bytes_opt_(*BufferLength) PVOID Buffer, _Inout_ PULONG BufferLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryBootEntryOrder( _Out_writes_opt_(*Count) PULONG Ids, _Inout_ PULONG Count ); NTSYSCALLAPI NTSTATUS NTAPI NtSetBootEntryOrder( _In_reads_(Count) PULONG Ids, _In_ ULONG Count ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryBootOptions( _Out_writes_bytes_opt_(*BootOptionsLength) PBOOT_OPTIONS BootOptions, _Inout_ PULONG BootOptionsLength ); NTSYSCALLAPI NTSTATUS NTAPI NtSetBootOptions( _In_ PBOOT_OPTIONS BootOptions, _In_ ULONG FieldsToChange ); NTSYSCALLAPI NTSTATUS NTAPI NtTranslateFilePath( _In_ PFILE_PATH InputFilePath, _In_ ULONG OutputType, _Out_writes_bytes_opt_(*OutputFilePathLength) PFILE_PATH OutputFilePath, _Inout_opt_ PULONG OutputFilePathLength ); NTSYSCALLAPI NTSTATUS NTAPI NtAddDriverEntry( _In_ PEFI_DRIVER_ENTRY DriverEntry, _Out_opt_ PULONG Id ); NTSYSCALLAPI NTSTATUS NTAPI NtDeleteDriverEntry( _In_ ULONG Id ); NTSYSCALLAPI NTSTATUS NTAPI NtModifyDriverEntry( _In_ PEFI_DRIVER_ENTRY DriverEntry ); NTSYSCALLAPI NTSTATUS NTAPI NtEnumerateDriverEntries( _Out_writes_bytes_opt_(*BufferLength) PVOID Buffer, _Inout_ PULONG BufferLength ); NTSYSCALLAPI NTSTATUS NTAPI NtQueryDriverEntryOrder( _Out_writes_opt_(*Count) PULONG Ids, _Inout_ PULONG Count ); NTSYSCALLAPI NTSTATUS NTAPI NtSetDriverEntryOrder( _In_reads_(Count) PULONG Ids, _In_ ULONG Count ); #endif #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSCALLAPI NTSTATUS NTAPI NtSerializeBoot( ); NTSYSCALLAPI NTSTATUS NTAPI NtEnableLastKnownGood( ); NTSYSCALLAPI NTSTATUS NTAPI NtDisableLastKnownGood( ); #endif NTSYSAPI ULONG __cdecl DbgPrint( _In_ PCH Format, ... ); NTSYSAPI ULONG __cdecl DbgPrintEx( _In_ ULONG ComponentId, _In_ ULONG Level, _In_ PCSTR Format, ... ); NTSYSAPI VOID NTAPI DbgBreakPoint( VOID ); NTSYSAPI NTSTATUS NTAPI DbgUiConnectToDbg( VOID ); NTSYSAPI HANDLE NTAPI DbgUiGetThreadDebugObject( VOID ); NTSYSAPI VOID NTAPI DbgUiSetThreadDebugObject( _In_ HANDLE DebugObject ); NTSYSAPI NTSTATUS NTAPI DbgUiWaitStateChange( _Out_ PDBGUI_WAIT_STATE_CHANGE StateChange, _In_opt_ PLARGE_INTEGER Timeout ); NTSYSAPI NTSTATUS NTAPI DbgUiContinue( _In_ PCLIENT_ID AppClientId, _In_ NTSTATUS ContinueStatus ); NTSYSAPI NTSTATUS NTAPI DbgUiStopDebugging( _In_ HANDLE Process ); NTSYSAPI NTSTATUS NTAPI DbgUiDebugActiveProcess( _In_ HANDLE Process ); NTSYSAPI VOID NTAPI DbgUiRemoteBreakin( _In_ PVOID Context ); NTSYSAPI NTSTATUS NTAPI DbgUiIssueRemoteBreakin( _In_ HANDLE Process ); NTSYSAPI NTSTATUS NTAPI DbgUiConvertStateChangeStructure( _In_ PDBGUI_WAIT_STATE_CHANGE StateChange, _Out_ DEBUG_EVENT* DebugEvent ); NTSYSAPI NTSTATUS NTAPI LdrLoadDll( _In_opt_ PCWSTR DllPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_ PVOID* DllHandle ); NTSYSAPI NTSTATUS NTAPI LdrGetDllHandle( _In_opt_ PCWSTR DllPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_ PVOID* DllHandle ); NTSYSAPI NTSTATUS NTAPI LdrGetDllHandleEx( _In_ ULONG Flags, _In_opt_ PCWSTR DllPath, _In_opt_ PULONG DllCharacteristics, _In_ PUNICODE_STRING DllName, _Out_opt_ PVOID* DllHandle ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI LdrGetDllHandleByMapping( _In_ PVOID Base, _Out_ PVOID* DllHandle ); NTSYSAPI NTSTATUS NTAPI LdrGetDllHandleByName( _In_opt_ PUNICODE_STRING BaseDllName, _In_opt_ PUNICODE_STRING FullDllName, _Out_ PVOID* DllHandle ); #endif NTSYSAPI NTSTATUS NTAPI LdrGetProcedureAddress( _In_ PVOID DllHandle, _In_opt_ CONST PANSI_STRING ProcedureName, _In_opt_ ULONG ProcedureNumber, _Out_ PVOID* ProcedureAddress ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI LdrGetProcedureAddressEx( _In_ PVOID DllHandle, _In_opt_ PANSI_STRING ProcedureName, _In_opt_ ULONG ProcedureNumber, _Out_ PVOID* ProcedureAddress, _In_ ULONG Flags ); #endif NTSYSAPI NTSTATUS NTAPI LdrLockLoaderLock( _In_ ULONG Flags, _Out_opt_ ULONG* Disposition, _Out_ PVOID* Cookie ); NTSYSAPI NTSTATUS NTAPI LdrUnlockLoaderLock( _In_ ULONG Flags, _Inout_ PVOID Cookie ); NTSYSAPI PIMAGE_BASE_RELOCATION NTAPI LdrProcessRelocationBlock( _In_ ULONG_PTR VA, _In_ ULONG SizeOfBlock, _In_ PUSHORT NextOffset, _In_ LONG_PTR Diff ); NTSYSAPI NTSTATUS NTAPI LdrUnloadDll( _In_ PVOID DllHandle ); NTSYSAPI NTSTATUS NTAPI LdrDisableThreadCalloutsForDll( _In_ PVOID DllHandle ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI NTSTATUS NTAPI LdrOpenImageFileOptionsKey( _In_ PUNICODE_STRING SubKey, _In_ BOOLEAN Wow64, _Out_ PHANDLE NewKeyHandle ); NTSYSAPI NTSTATUS NTAPI LdrQueryImageFileKeyOption( _In_ HANDLE KeyHandle, _In_ PCWSTR ValueName, _In_ ULONG Type, _Out_ PVOID Buffer, _In_ ULONG BufferSize, _Out_opt_ PULONG ReturnedLength ); #endif NTSYSAPI NTSTATUS NTAPI LdrVerifyImageMatchesChecksum( _In_ HANDLE ImageFileHandle, _In_opt_ PLDR_IMPORT_MODULE_CALLBACK ImportCallbackRoutine, _In_ PVOID ImportCallbackParameter, _Out_opt_ PUSHORT ImageCharacteristics ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI LdrVerifyImageMatchesChecksumEx( _In_ HANDLE ImageFileHandle, _Inout_ PLDR_VERIFY_IMAGE_INFO VerifyInfo ); #endif NTSYSAPI NTSTATUS NTAPI LdrAccessResource( _In_ PVOID DllHandle, _In_ CONST PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry, _Out_opt_ PVOID* Address, _Out_ PULONG Size ); NTSYSAPI NTSTATUS NTAPI LdrFindResourceDirectory_U( _In_ PVOID DllHandle, _In_ CONST LDR_RESOURCE_INFO* ResourceIdPath, _In_ ULONG ResourceIdPathLength, _Out_ PIMAGE_RESOURCE_DIRECTORY* ResourceDirectory ); NTSYSAPI NTSTATUS NTAPI LdrFindResource_U( _In_ PVOID DllHandle, _In_ CONST LDR_RESOURCE_INFO* ResourceIdPath, _In_ ULONG ResourceIdPathLength, _Out_ PIMAGE_RESOURCE_DATA_ENTRY* ResourceDataEntry ); NTSYSAPI NTSTATUS NTAPI LdrFindResourceEx_U( _In_opt_ ULONG Flags, _In_ PVOID DllHandle, _In_ CONST LDR_RESOURCE_INFO* ResourceIdPath, _In_ ULONG ResourceIdPathLength, _Out_ PIMAGE_RESOURCE_DATA_ENTRY* ResourceDataEntry ); NTSYSAPI VOID NTAPI RtlAssert( _In_ PVOID VoidFailedAssertion, _In_ PVOID VoidFileName, _In_ ULONG LineNumber, _In_opt_ PSTR MutableMessage ); NTSYSAPI DECLSPEC_NORETURN VOID NTAPI RtlRaiseStatus( _In_ NTSTATUS Status ); NTSYSAPI VOID NTAPI RtlRaiseException( _In_ PEXCEPTION_RECORD ExceptionRecord ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI RtlConnectToSm( _In_ PUNICODE_STRING ApiPortName, _In_ HANDLE ApiPortHandle, _In_ DWORD ProcessImageType, _Out_ PHANDLE SmssConnection ); NTSYSAPI NTSTATUS NTAPI RtlSendMsgToSm( _In_ HANDLE ApiPortHandle, _In_ PPORT_MESSAGE MessageData ); NTSYSAPI NTSTATUS NTAPI RtlRegisterThreadWithCsrss( ); #endif NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection( _Inout_ PRTL_CRITICAL_SECTION CriticalSection ); NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection( _Inout_ PRTL_CRITICAL_SECTION CriticalSection ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI LOGICAL NTAPI RtlIsCriticalSectionLocked( _In_ PRTL_CRITICAL_SECTION CriticalSection ); NTSYSAPI LOGICAL NTAPI RtlIsCriticalSectionLockedByThread( _In_ PRTL_CRITICAL_SECTION CriticalSection ); NTSYSAPI ULONG NTAPI RtlGetCriticalSectionRecursionCount( _In_ PRTL_CRITICAL_SECTION CriticalSection ); #endif NTSYSAPI LOGICAL NTAPI RtlTryEnterCriticalSection( _Inout_ PRTL_CRITICAL_SECTION CriticalSection ); NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection( _Out_ PRTL_CRITICAL_SECTION CriticalSection ); NTSYSAPI VOID NTAPI RtlEnableEarlyCriticalSectionEventCreation( VOID ); NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSectionAndSpinCount( _Out_ PRTL_CRITICAL_SECTION CriticalSection, _In_ ULONG SpinCount ); NTSYSAPI ULONG NTAPI RtlSetCriticalSectionSpinCount( _Inout_ PRTL_CRITICAL_SECTION CriticalSection, _In_ ULONG SpinCount ); NTSYSAPI NTSTATUS NTAPI RtlDeleteCriticalSection( _Inout_ PRTL_CRITICAL_SECTION CriticalSection ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI BOOL NTAPI RtlQueryPerformanceFrequency( _Out_ PLARGE_INTEGER Frequency ); #else FORCEINLINE BOOL NTAPI RtlQueryPerformanceFrequency( _Out_ PLARGE_INTEGER Frequency ) { LARGE_INTEGER _; return NT_SUCCESS(NtQueryPerformanceCounter(&_, Frequency)); } #endif #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI BOOL NTAPI RtlQueryPerformanceCounter( _Out_ PLARGE_INTEGER PerformanceCount ); #else FORCEINLINE BOOL NTAPI RtlQueryPerformanceCounter( _Out_ PLARGE_INTEGER PerformanceCount ) { return NT_SUCCESS(NtQueryPerformanceCounter(PerformanceCount, NULL)); } #endif NTSYSAPI NTSTATUS NTAPI RtlGetCompressionWorkSpaceSize( _In_ USHORT CompressionFormatAndEngine, _Out_ PULONG CompressBufferWorkSpaceSize, _Out_ PULONG CompressFragmentWorkSpaceSize ); NTSYSAPI NTSTATUS NTAPI RtlCompressBuffer( _In_ USHORT CompressionFormatAndEngine, _In_ PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _Out_ PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_ ULONG UncompressedChunkSize, _Out_ PULONG FinalCompressedSize, _In_ PVOID WorkSpace ); NTSYSAPI NTSTATUS NTAPI RtlDecompressBuffer( _In_ USHORT CompressionFormat, _Out_ PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _In_ PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _Out_ PULONG FinalUncompressedSize ); #if NTDDI_VERSION >= NTDDI_WIN8 NTSYSAPI NTSTATUS NTAPI RtlDecompressBufferEx( _In_ USHORT CompressionFormat, _Out_writes_bytes_to_(UncompressedBufferSize, *FinalUncompressedSize) PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _Out_ PULONG FinalUncompressedSize, _In_opt_ PVOID WorkSpace ); #endif #if NTDDI_VERSION >= NTDDI_WINBLUE NTSYSAPI NTSTATUS NTAPI RtlDecompressBufferEx2( _In_ USHORT CompressionFormat, _Out_writes_bytes_to_(UncompressedBufferSize, *FinalUncompressedSize) PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_ ULONG UncompressedChunkSize, _Out_ PULONG FinalUncompressedSize, _In_opt_ PVOID WorkSpace ); #endif NTSYSAPI NTSTATUS NTAPI RtlDecompressFragment( _In_ USHORT CompressionFormat, _Out_writes_bytes_to_(UncompressedFragmentSize, *FinalUncompressedSize) PUCHAR UncompressedFragment, _In_ ULONG UncompressedFragmentSize, _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_range_( <, CompressedBufferSize) ULONG FragmentOffset, _Out_ PULONG FinalUncompressedSize, _In_ PVOID WorkSpace ); #if NTDDI_VERSION >= NTDDI_WINBLUE NTSYSAPI NTSTATUS NTAPI RtlDecompressFragmentEx( _In_ USHORT CompressionFormat, _Out_writes_bytes_to_(UncompressedFragmentSize, *FinalUncompressedSize) PUCHAR UncompressedFragment, _In_ ULONG UncompressedFragmentSize, _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_range_( <, CompressedBufferSize) ULONG FragmentOffset, _In_ ULONG UncompressedChunkSize, _Out_ PULONG FinalUncompressedSize, _In_ PVOID WorkSpace ); #endif NTSYSAPI NTSTATUS NTAPI RtlDescribeChunk( _In_ USHORT CompressionFormat, _Inout_ PUCHAR* CompressedBuffer, _In_ PUCHAR EndOfCompressedBufferPlus1, _Out_ PUCHAR* ChunkBuffer, _Out_ PULONG ChunkSize ); NTSYSAPI NTSTATUS NTAPI RtlReserveChunk( _In_ USHORT CompressionFormat, _Inout_ PUCHAR* CompressedBuffer, _In_ PUCHAR EndOfCompressedBufferPlus1, _Out_ PUCHAR* ChunkBuffer, _In_ ULONG ChunkSize ); NTSYSAPI NTSTATUS NTAPI RtlDecompressChunks( _Out_writes_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_reads_bytes_(CompressedTailSize) PUCHAR CompressedTail, _In_ ULONG CompressedTailSize, _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo ); NTSYSAPI NTSTATUS NTAPI RtlCompressChunks( _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _Out_writes_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer, _In_range_( >=, (UncompressedBufferSize - (UncompressedBufferSize / 16))) ULONG CompressedBufferSize, _Inout_updates_bytes_(CompressedDataInfoLength) PCOMPRESSED_DATA_INFO CompressedDataInfo, _In_range_( >, sizeof(COMPRESSED_DATA_INFO)) ULONG CompressedDataInfoLength, _In_ PVOID WorkSpace ); _Must_inspect_result_ NTSYSAPI PVOID NTAPI RtlCreateHeap( _In_ ULONG Flags, _In_opt_ PVOID HeapBase, _In_opt_ SIZE_T ReserveSize, _In_opt_ SIZE_T CommitSize, _In_opt_ PVOID Lock, _In_opt_ PRTL_HEAP_PARAMETERS Parameters ); NTSYSAPI PVOID NTAPI RtlDestroyHeap( _In_ PVOID HeapHandle ); _Must_inspect_result_ _Ret_maybenull_ _Post_writable_byte_size_(Size) NTSYSAPI PVOID NTAPI RtlAllocateHeap( _In_ PVOID HeapHandle, _In_opt_ ULONG Flags, _In_ SIZE_T Size ); NTSYSAPI BOOLEAN NTAPI RtlFreeHeap( _In_ PVOID HeapHandle, _In_opt_ ULONG Flags, _Inout_opt_ PVOID BaseAddress ); NTSYSAPI NTSTATUS NTAPI RtlWalkHeap( _In_ PVOID HeapHandle, _Inout_ PRTL_HEAP_WALK_ENTRY Entry ); NTSYSAPI NTSTATUS NTAPI RtlQueryHeapInformation( _In_opt_ PVOID HeapHandle, _In_ HEAP_INFORMATION_CLASS HeapInformationClass, _Out_opt_ PVOID HeapInformation, _In_opt_ SIZE_T HeapInformationLength, _Out_opt_ PSIZE_T ReturnLength ); NTSYSAPI NTSTATUS NTAPI RtlSetHeapInformation( _In_ PVOID HeapHandle, _In_ HEAP_INFORMATION_CLASS HeapInformationClass, _In_opt_ PVOID HeapInformation, _In_opt_ SIZE_T HeapInformationLength ); NTSYSAPI SIZE_T NTAPI RtlSizeHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_ PVOID BaseAddress ); NTSYSAPI NTSTATUS NTAPI RtlZeroHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags ); NTSYSAPI VOID NTAPI RtlProtectHeap( _In_ PVOID HeapHandle, _In_ BOOLEAN MakeReadOnly ); NTSYSAPI BOOLEAN NTAPI RtlLockHeap( _In_ PVOID HeapHandle ); NTSYSAPI BOOLEAN NTAPI RtlUnlockHeap( _In_ PVOID HeapHandle ); NTSYSAPI PVOID NTAPI RtlReAllocateHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _Inout_opt_ PVOID BaseAddress, _In_ SIZE_T Size ); NTSYSAPI BOOLEAN NTAPI RtlGetUserInfoHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_ PVOID BaseAddress, _Out_opt_ PVOID* UserValue, _Out_opt_ PULONG UserFlags ); NTSYSAPI BOOLEAN NTAPI RtlSetUserValueHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_ PVOID BaseAddress, _In_ PVOID UserValue ); NTSYSAPI BOOLEAN NTAPI RtlSetUserFlagsHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_ PVOID BaseAddress, _In_ ULONG UserFlagsReset, _In_ ULONG UserFlagsSet ); NTSYSAPI ULONG NTAPI RtlCreateTagHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_opt_ PWSTR TagPrefix, _In_ PWSTR TagNames ); NTSYSAPI PWSTR NTAPI RtlQueryTagHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_ USHORT TagIndex, _In_ BOOLEAN ResetCounters, _Out_opt_ PRTL_HEAP_TAG_INFO TagInfo ); NTSYSAPI SIZE_T NTAPI RtlCompactHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags ); NTSYSAPI BOOLEAN NTAPI RtlValidateHeap( _In_ PVOID HeapHandle, _In_ ULONG Flags, _In_ PVOID BaseAddress ); NTSYSAPI BOOLEAN NTAPI RtlValidateProcessHeaps( VOID ); NTSYSAPI ULONG NTAPI RtlGetProcessHeaps( _In_ ULONG NumberOfHeaps, _Out_ PVOID* ProcessHeaps ); NTSYSAPI NTSTATUS NTAPI RtlEnumProcessHeaps( _In_ PRTL_ENUM_HEAPS_ROUTINE EnumRoutine, _In_ PVOID Parameter ); NTSYSAPI VOID NTAPI RtlTimeToTimeFields( _In_ PLARGE_INTEGER Time, _Out_ PTIME_FIELDS TimeFields ); NTSYSAPI ULONG NTAPI RtlUniform( _Inout_ PULONG Seed ); _Ret_range_( <=, MAXLONG) NTSYSAPI ULONG NTAPI RtlRandom( _Inout_ PULONG Seed ); _Ret_range_( <=, MAXLONG) NTSYSAPI ULONG NTAPI RtlRandomEx( _Inout_ PULONG Seed ); NTSYSAPI NTSTATUS NTAPI RtlFindMessage( _In_ PVOID DllHandle, _In_ ULONG MessageTableId, _In_ ULONG MessageLanguageId, _In_ ULONG MessageId, _Out_ PMESSAGE_RESOURCE_ENTRY* MessageEntry ); NTSYSAPI NTSTATUS NTAPI RtlFormatMessage( _In_ PCWSTR MessageFormat, _In_ ULONG MaximumWidth, _In_ BOOLEAN IgnoreInserts, _In_ BOOLEAN ArgumentsAreAnsi, _In_ BOOLEAN ArgumentsAreAnArray, _In_ va_list* Arguments, _Out_ PWSTR Buffer, _In_ ULONG Length, _Out_opt_ PULONG ReturnLength ); NTSYSAPI ULONG NTAPI RtlNtStatusToDosError( _In_ NTSTATUS Status ); NTSYSAPI ULONG NTAPI RtlNtStatusToDosErrorNoTeb( _In_ NTSTATUS Status ); NTSYSAPI NTSTATUS NTAPI RtlGetLastNtStatus( VOID ); NTSYSAPI LONG NTAPI RtlGetLastWin32Error( VOID ); NTSYSAPI VOID NTAPI RtlSetLastWin32ErrorAndNtStatusFromNtStatus( _In_ NTSTATUS Status ); NTSYSAPI VOID NTAPI RtlSetLastWin32Error( _In_ LONG Win32Error ); NTSYSAPI VOID NTAPI RtlRestoreLastWin32Error( _In_ LONG Win32Error ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI ULONG NTAPI RtlGetThreadErrorMode( VOID ); NTSYSAPI NTSTATUS NTAPI RtlSetThreadErrorMode( _In_ ULONG NewMode, _Out_opt_ PULONG OldMode ); #endif _Success_(return != 0) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_z_ PCWSTR SourceString ); NTSYSAPI NTSTATUS NTAPI RtlUpcaseUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_ PCUNICODE_STRING SourceString, _In_ BOOLEAN AllocateDestinationString ); NTSYSAPI VOID NTAPI RtlInitUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_opt_z_ PCWSTR SourceString ); NTSYSAPI NTSTATUS NTAPI RtlInitUnicodeStringEx( _Out_ PUNICODE_STRING DestinationString, _In_opt_z_ PCWSTR SourceString ); NTSYSAPI VOID NTAPI RtlInitAnsiString( _Out_ PANSI_STRING DestinationString, _In_opt_ PSTR SourceString ); NTSYSAPI VOID NTAPI RtlCopyUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_ PCUNICODE_STRING SourceString ); NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeToString( _In_ PUNICODE_STRING Destination, _In_opt_ PCWSTR Source ); NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString( _Inout_ PUNICODE_STRING DestinationString, _In_ PANSI_STRING SourceString, _In_ BOOLEAN AllocateDestinationString ); NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString( _Inout_ PANSI_STRING DestinationString, _In_ PUNICODE_STRING SourceString, _In_ BOOLEAN AllocateDestinationString ); NTSYSAPI CHAR NTAPI RtlUpperChar( _In_ CHAR Character ); _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlPrefixString( _In_ PSTRING String1, _In_ PSTRING String2, _In_ BOOLEAN CaseInSensitive ); NTSYSAPI NTSTATUS NTAPI RtlAppendStringToString( _Inout_ PSTRING Destination, _In_ PSTRING Source ); NTSYSAPI VOID NTAPI RtlUpperString( _In_ PSTRING DestinationString, _In_ PSTRING SourceString ); NTSYSAPI VOID NTAPI RtlFreeAnsiString( _Inout_ PANSI_STRING AnsiString ); NTSYSAPI VOID NTAPI RtlFreeUnicodeString( _In_ PUNICODE_STRING UnicodeString ); NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToInteger( _In_ PCUNICODE_STRING String, _In_opt_ ULONG Base, _Out_ PULONG Value ); NTSYSAPI NTSTATUS NTAPI RtlDefaultNpAcl( _Out_ PACL* Dacl ); NTSYSAPI NTSTATUS NTAPI RtlCreateRegistryKey( _In_ ULONG RelativeTo, _In_ PWSTR Path ); NTSYSAPI NTSTATUS NTAPI RtlQueryRegistryValues( _In_ ULONG RelativeTo, _In_ PCWSTR Path, _Inout_ PRTL_QUERY_REGISTRY_TABLE QueryTable, _In_opt_ PVOID Context, _In_opt_ PVOID Environment ); NTSYSAPI NTSTATUS NTAPI RtlWriteRegistryValue( _In_ ULONG RelativeTo, _In_ PCWSTR Path, _In_ PCWSTR ValueName, _In_ ULONG ValueType, _In_opt_ PVOID ValueData, _In_ ULONG ValueLength ); NTSYSAPI NTSTATUS NTAPI RtlCreateEnvironment( _In_ BOOLEAN CloneCurrentEnvironment, _Out_ PVOID* Environment ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI RtlCreateEnvironmentEx( _In_ PVOID SourceEnv, _Out_ PVOID* Environment, _In_ ULONG Flags ); #endif NTSYSAPI NTSTATUS NTAPI RtlDestroyEnvironment( _In_ PVOID Environment ); NTSYSAPI NTSTATUS NTAPI RtlSetCurrentEnvironment( _In_ PVOID Environment, _Out_opt_ PVOID* PreviousEnvironment ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI RtlSetEnvironmentVar( _Inout_opt_ PVOID* Environment, _In_ PWSTR Name, _In_ SIZE_T NameLength, _In_ PWSTR Value, _In_ SIZE_T ValueLength ); #endif NTSYSAPI NTSTATUS NTAPI RtlSetEnvironmentVariable( _Inout_opt_ PVOID* Environment, _In_ PUNICODE_STRING Name, _In_ PUNICODE_STRING Value ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI RtlQueryEnvironmentVariable( _In_opt_ PVOID Environment, _In_ PWSTR Name, _In_ SIZE_T NameLength, _Out_ PWSTR Value, _In_ SIZE_T ValueLength, _Out_ PSIZE_T ReturnLength ); #endif NTSYSAPI NTSTATUS NTAPI RtlQueryEnvironmentVariable_U( _In_opt_ PVOID Environment, _In_ PUNICODE_STRING Name, _Inout_ PUNICODE_STRING Value ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI RtlExpandEnvironmentStrings( _In_opt_ PVOID Environment, _In_ PWSTR Src, _In_ SIZE_T SrcLength, _Out_ PWSTR Dst, _In_ SIZE_T DstLength, _Out_opt_ PSIZE_T ReturnLength ); #endif NTSYSAPI NTSTATUS NTAPI RtlExpandEnvironmentStrings_U( _In_opt_ PVOID Environment, _In_ PUNICODE_STRING Source, _Inout_ PUNICODE_STRING Destination, _Out_opt_ PULONG ReturnedLength ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI NTSTATUS NTAPI RtlSetEnvironmentStrings( _In_ PWCHAR NewEnvironment, _In_ SIZE_T NewEnvironmentSize ); #endif #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI HANDLE NTAPI RtlGetCurrentTransaction( ); NTSYSAPI LOGICAL NTAPI RtlSetCurrentTransaction( _In_ HANDLE TransactionHandle ); #endif NTSYSAPI NTSTATUS NTAPI RtlCreateProcessParameters( _Out_ PRTL_USER_PROCESS_PARAMETERS* pProcessParameters, _In_ PUNICODE_STRING ImagePathName, _In_opt_ PUNICODE_STRING DllPath, _In_opt_ PUNICODE_STRING CurrentDirectory, _In_opt_ PUNICODE_STRING CommandLine, _In_opt_ PVOID Environment, _In_opt_ PUNICODE_STRING WindowTitle, _In_opt_ PUNICODE_STRING DesktopInfo, _In_opt_ PUNICODE_STRING ShellInfo, _In_opt_ PUNICODE_STRING RuntimeData ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI NTSTATUS NTAPI RtlCreateProcessParametersEx( _Out_ PRTL_USER_PROCESS_PARAMETERS* pProcessParameters, _In_ PUNICODE_STRING ImagePathName, _In_opt_ PUNICODE_STRING DllPath, _In_opt_ PUNICODE_STRING CurrentDirectory, _In_opt_ PUNICODE_STRING CommandLine, _In_opt_ PVOID Environment, _In_opt_ PUNICODE_STRING WindowTitle, _In_opt_ PUNICODE_STRING DesktopInfo, _In_opt_ PUNICODE_STRING ShellInfo, _In_opt_ PUNICODE_STRING RuntimeData, _In_ ULONG Flags // Pass RTL_USER_PROCESS_PARAMETERS_NORMALIZED to keep parameters normalized ); #endif NTSYSAPI NTSTATUS NTAPI RtlDestroyProcessParameters( _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters ); NTSYSAPI PRTL_USER_PROCESS_PARAMETERS NTAPI RtlNormalizeProcessParams( _Inout_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters ); NTSYSAPI PRTL_USER_PROCESS_PARAMETERS NTAPI RtlDeNormalizeProcessParams( _Inout_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters ); NTSYSAPI NTSTATUS NTAPI RtlCreateUserProcess( _In_ PUNICODE_STRING NtImagePathName, _In_ ULONG AttributesDeprecated, _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters, _In_opt_ PSECURITY_DESCRIPTOR ProcessSecurityDescriptor, _In_opt_ PSECURITY_DESCRIPTOR ThreadSecurityDescriptor, _In_opt_ HANDLE ParentProcess, _In_ BOOLEAN InheritHandles, _In_opt_ HANDLE DebugPort, _In_opt_ HANDLE TokenHandle, // used to be ExceptionPort _Out_ PRTL_USER_PROCESS_INFORMATION ProcessInformation ); NTSYSAPI NTSTATUS NTAPI RtlCreateUserThread( _In_ HANDLE Process, _In_opt_ PSECURITY_DESCRIPTOR ThreadSecurityDescriptor, _In_ BOOLEAN CreateSuspended, _In_opt_ ULONG ZeroBits, _In_opt_ SIZE_T MaximumStackSize, _In_opt_ SIZE_T CommittedStackSize, _In_ PUSER_THREAD_START_ROUTINE StartAddress, _In_opt_ PVOID Parameter, _Out_opt_ PHANDLE Thread, _Out_opt_ PCLIENT_ID ClientId ); NTSYSAPI NTSTATUS NTAPI RtlExitUserThread( _In_ NTSTATUS ExitStatus ); NTSYSAPI NTSTATUS NTAPI RtlDosApplyFileIsolationRedirection_Ustr( _In_ ULONG Flags, _In_ PUNICODE_STRING OriginalName, _In_ PUNICODE_STRING Extension, _Inout_ PUNICODE_STRING StaticString, _Inout_ PUNICODE_STRING DynamicString, _Inout_ PUNICODE_STRING* NewName, _In_ PULONG NewFlags, _In_ PSIZE_T FileNameSize, _In_ PSIZE_T RequiredLength ); NTSYSAPI PIMAGE_NT_HEADERS NTAPI RtlImageNtHeader( _In_ PVOID ImageBase ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI NTSTATUS NTAPI RtlImageNtHeaderEx( _In_opt_ ULONG Flags, _In_ PVOID Base, _In_ ULONG64 Size, _Out_ PIMAGE_NT_HEADERS* OutHeaders ); #endif NTSYSAPI PVOID NTAPI RtlImageDirectoryEntryToData( _In_ PVOID ImageBase, _In_ BOOLEAN MappedAsImage, _In_ USHORT DirectoryEntry, _Out_ PULONG Size ); NTSYSAPI PVOID NTAPI RtlPcToFileHeader( _In_ PVOID PcValue, _Out_ PVOID* BaseOfImage ); NTSYSAPI PVOID NTAPI RtlAddressInSectionTable( _In_ PIMAGE_NT_HEADERS NtHeaders, _In_ PVOID BaseOfImage, _In_ ULONG VirtualAddress ); NTSYSAPI PIMAGE_SECTION_HEADER NTAPI RtlImageRvaToSection( _In_ PIMAGE_NT_HEADERS NtHeaders, _In_ PVOID Base, _In_ ULONG Rva ); NTSYSAPI PVOID NTAPI RtlImageRvaToVa( _In_ PIMAGE_NT_HEADERS NtHeaders, _In_ PVOID Base, _In_ ULONG Rva, _Inout_opt_ PIMAGE_SECTION_HEADER* LastRvaSection ); NTSYSAPI NTSTATUS NTAPI RtlQueryProcessHeapInformation( _Inout_ PRTL_DEBUG_INFORMATION Buffer ); NTSYSAPI PRTL_DEBUG_INFORMATION NTAPI RtlCreateQueryDebugBuffer( _In_opt_ ULONG MaximumCommit, _In_ BOOLEAN UseEventPair ); NTSYSAPI NTSTATUS NTAPI RtlQueryProcessDebugInformation( _In_ HANDLE UniqueProcessId, _In_ ULONG Flags, _Inout_ PRTL_DEBUG_INFORMATION Buffer ); #ifdef _WIN64 NTSYSAPI VOID WINAPI RtlRestoreContext( _In_ PCONTEXT ContextRecord, _In_opt_ PEXCEPTION_RECORD ExceptionRecord ); #endif NTSYSAPI NTSTATUS NTAPI RtlAdjustPrivilege( _In_ ULONG Privilege, _In_ BOOLEAN Enable, _In_ BOOLEAN Client, _Out_ PBOOLEAN WasEnabled ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI NTSTATUS NTAPI RtlAcquirePrivilege( _In_ PULONG Privilege, _In_ ULONG NumPriv, _In_ ULONG Flags, _Out_ PVOID* ReturnedState ); NTSYSAPI VOID NTAPI RtlReleasePrivilege( _In_ PVOID StatePointer ); #endif NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToNtPathName_U( _In_ PCWSTR DosFileName, _Out_ PUNICODE_STRING NtFileName, _Out_opt_ PWSTR* FilePart, _Reserved_ PVOID Reserved ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToRelativeNtPathName_U( _In_ PCWSTR DosFileName, _Out_ PUNICODE_STRING NtFileName, _Out_opt_ PWSTR* FilePart, _Out_opt_ PRTL_RELATIVE_NAME_U RelativeName ); NTSYSAPI NTSTATUS NTAPI RtlDosPathNameToRelativeNtPathName_U_WithStatus( _In_ PWSTR DosFileName, _Out_ PUNICODE_STRING NtFileName, _Out_opt_ PWSTR* FilePart, _Out_opt_ PRTL_RELATIVE_NAME_U RelativeName ); #endif NTSYSAPI RTL_PATH_TYPE NTAPI RtlDetermineDosPathNameType_U( _In_ PCWSTR Path ); NTSYSAPI ULONG NTAPI RtlIsDosDeviceName_U( _In_ PWSTR DosFileName ); NTSYSAPI ULONG NTAPI RtlGetFullPathName_U( _In_ PWSTR FileName, _In_ ULONG BufferLength, _Out_writes_bytes_(BufferLength) PWSTR Buffer, _Out_opt_ PWSTR* FilePart ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI RtlGetFullPathName_UEx( _In_ PWSTR FileName, _In_ ULONG BufferLength, _Out_writes_bytes_(BufferLength) PWSTR Buffer, _Out_opt_ PWSTR* FilePart, _Out_opt_ ULONG* BytesRequired ); #endif #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI NTSTATUS NTAPI RtlGetFullPathName_UstrEx( _In_ PUNICODE_STRING FileName, _Inout_ PUNICODE_STRING StaticString, _Out_opt_ PUNICODE_STRING DynamicString, _Out_opt_ PUNICODE_STRING* StringUsed, _Out_opt_ SIZE_T* FilePartPrefixCch, _Out_opt_ PBOOLEAN NameInvalid, _Out_ RTL_PATH_TYPE* InputPathType, _Out_opt_ SIZE_T* BytesRequired ); #endif NTSYSAPI ULONG NTAPI RtlGetCurrentDirectory_U( _In_ ULONG BufferLength, _Out_writes_bytes_(BufferLength) PWSTR Buffer ); NTSYSAPI NTSTATUS NTAPI RtlSetCurrentDirectory_U( _In_ PUNICODE_STRING PathName ); #if NTDDI_VERSION >= NTDDI_WS03 NTSYSAPI VOID NTAPI RtlReleaseRelativeName( _In_ PRTL_RELATIVE_NAME_U RelativeName ); #endif NTSYSAPI NTSTATUS NTAPI RtlNtPathNameToDosPathName( _In_ ULONG Flags, _Inout_ PRTL_UNICODE_STRING_BUFFER Path, _Out_opt_ PULONG Disposition, _Inout_opt_ PWSTR* FilePart ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI VOID NTAPI RtlInitializeSRWLock( _Out_ PRTL_SRWLOCK SRWLock ); NTSYSAPI VOID NTAPI RtlAcquireSRWLockExclusive( _Inout_ PRTL_SRWLOCK SRWLock ); NTSYSAPI VOID NTAPI RtlAcquireSRWLockShared( _Inout_ PRTL_SRWLOCK SRWLock ); NTSYSAPI VOID NTAPI RtlReleaseSRWLockExclusive( _Inout_ PRTL_SRWLOCK SRWLock ); NTSYSAPI VOID NTAPI RtlReleaseSRWLockShared( _Inout_ PRTL_SRWLOCK SRWLock ); #endif #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI BOOLEAN NTAPI RtlTryAcquireSRWLockExclusive( _Inout_ PRTL_SRWLOCK SRWLock ); NTSYSAPI BOOLEAN NTAPI RtlTryAcquireSRWLockShared( _Inout_ PRTL_SRWLOCK SRWLock ); NTSYSAPI VOID NTAPI RtlAcquireReleaseSRWLockExclusive( _Inout_ PRTL_SRWLOCK SRWLock ); #endif NTSYSAPI ULONG NTAPI RtlWalkFrameChain( _Out_ PVOID* Callers, _In_ ULONG Count, _In_ ULONG Flags ); NTSYSAPI PPREFIX_TABLE_ENTRY NTAPI PfxFindPrefix( _In_ PPREFIX_TABLE PrefixTable, _In_ PANSI_STRING FullName ); NTSYSAPI VOID NTAPI PfxInitialize( _Out_ PPREFIX_TABLE PrefixTable ); NTSYSAPI BOOLEAN NTAPI PfxInsertPrefix( _In_ PPREFIX_TABLE PrefixTable, _In_ PANSI_STRING Prefix, _Out_ PPREFIX_TABLE_ENTRY PrefixTableEntry ); NTSYSAPI VOID NTAPI PfxRemovePrefix( _In_ PPREFIX_TABLE PrefixTable, _In_ PPREFIX_TABLE_ENTRY PrefixTableEntry ); NTSYSAPI NTSTATUS NTAPI RtlAbsoluteToSelfRelativeSD( _In_ PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor, _Out_ PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor, _Inout_ PULONG BufferLength ); NTSYSAPI NTSTATUS NTAPI RtlAddAccessAllowedAce( _Inout_ PACL Acl, _In_ ULONG AceRevision, _In_ ACCESS_MASK AccessMask, _In_ PSID Sid ); NTSYSAPI NTSTATUS NTAPI RtlAddAccessAllowedAceEx( _Inout_ PACL Acl, _In_ ULONG AceRevision, _In_ ULONG AceFlags, _In_ ACCESS_MASK AccessMask, _In_ PSID Sid ); NTSYSAPI NTSTATUS NTAPI RtlAddAce( _Inout_ PACL Acl, _In_ ULONG AceRevision, _In_ ULONG StartingAceIndex, _In_ PVOID AceList, _In_ ULONG AceListLength ); NTSYSAPI NTSTATUS NTAPI RtlAddAtomToAtomTable( _In_ PVOID AtomTableHandle, _In_ PWSTR AtomName, _Inout_opt_ PRTL_ATOM Atom ); NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString( PUNICODE_STRING Destination, PCUNICODE_STRING Source ); NTSYSAPI BOOLEAN NTAPI RtlAreAllAccessesGranted( _In_ ACCESS_MASK GrantedAccess, _In_ ACCESS_MASK DesiredAccess ); NTSYSAPI BOOLEAN NTAPI RtlAreAnyAccessesGranted( _In_ ACCESS_MASK GrantedAccess, _In_ ACCESS_MASK DesiredAccess ); NTSYSAPI BOOLEAN NTAPI RtlAreBitsClear( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length ); NTSYSAPI BOOLEAN NTAPI RtlAreBitsSet( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length ); NTSYSAPI VOID NTAPI RtlCaptureContext( _Out_ PCONTEXT ContextRecord ); NTSYSAPI _Success_(return != 0) USHORT NTAPI RtlCaptureStackBackTrace( _In_ ULONG FramesToSkip, _In_ ULONG FramesToCapture, _Out_writes_to_(FramesToCapture, return) PVOID* BackTrace, _Out_opt_ PULONG BackTraceHash ); NTSYSAPI VOID NTAPI RtlClearAllBits( _In_ PRTL_BITMAP BitMapHeader ); NTSYSAPI VOID NTAPI RtlClearBits( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG NumberToClear ); NTSYSAPI NTSTATUS NTAPI RtlCreateSystemVolumeInformationFolder( _In_ PCUNICODE_STRING VolumeRootPath ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI LONG NTAPI RtlCompareAltitudes( _In_ PCUNICODE_STRING Altitude1, _In_ PCUNICODE_STRING Altitude2 ); #endif NTSYSAPI LONG NTAPI RtlCompareUnicodeString( _In_ PCUNICODE_STRING String1, _In_ PCUNICODE_STRING String2, _In_ BOOLEAN CaseInSensitive ); NTSYSAPI ULONG32 NTAPI RtlComputeCrc32( _In_ ULONG32 PartialCrc, _In_ PVOID Buffer, _In_ ULONG Length ); NTSYSAPI NTSTATUS NTAPI RtlConvertSidToUnicodeString( _Inout_ PUNICODE_STRING UnicodeString, _In_ PSID Sid, _In_ BOOLEAN AllocateDestinationString ); NTSYSAPI VOID NTAPI RtlCopyLuid( _Out_ PLUID DestinationLuid, _In_ PLUID SourceLuid ); _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlAllocateAndInitializeSid( _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, _In_ UCHAR SubAuthorityCount, _In_ ULONG SubAuthority0, _In_ ULONG SubAuthority1, _In_ ULONG SubAuthority2, _In_ ULONG SubAuthority3, _In_ ULONG SubAuthority4, _In_ ULONG SubAuthority5, _In_ ULONG SubAuthority6, _In_ ULONG SubAuthority7, _Outptr_ PSID* Sid ); #if NTDDI_VERSION >= NTDDI_WIN8 _Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlAllocateAndInitializeSidEx( _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, _In_ UCHAR SubAuthorityCount, _In_reads_(SubAuthorityCount) PULONG SubAuthorities, _Outptr_ PSID* Sid ); #endif NTSYSAPI NTSTATUS NTAPI RtlCopySid( _In_ ULONG DestinationSidLength, _Out_writes_bytes_(DestinationSidLength) PSID DestinationSid, _In_ PSID SourceSid ); NTSYSAPI NTSTATUS NTAPI RtlCreateServiceSid( _In_ PUNICODE_STRING ServiceName, _Out_writes_bytes_opt_(*ServiceSidLength) PSID ServiceSid, _Inout_ PULONG ServiceSidLength ); NTSYSAPI PVOID NTAPI RtlFreeSid( _Inout_ PSID Sid ); NTSYSAPI NTSTATUS NTAPI RtlCreateAcl( _Out_ PACL Acl, _In_ ULONG AclLength, _In_ ULONG AclRevision ); NTSYSAPI NTSTATUS NTAPI RtlCreateAtomTable( _In_ ULONG NumberOfBuckets, _Out_ PVOID* AtomTableHandle ); NTSYSAPI NTSTATUS NTAPI RtlDecompressFragment( _In_ USHORT CompressionFormat, _Out_ PUCHAR UncompressedFragment, _In_ ULONG UncompressedFragmentSize, _In_ PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_ ULONG FragmentOffset, _Out_ PULONG FinalUncompressedSize, _In_ PVOID WorkSpace ); NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlDelete( _In_ PRTL_SPLAY_LINKS Links ); NTSYSAPI NTSTATUS NTAPI RtlDeleteAce( _Inout_ PACL Acl, _In_ ULONG AceIndex ); NTSYSAPI NTSTATUS NTAPI RtlDeleteAtomFromAtomTable( _In_ PVOID AtomTableHandle, _In_ RTL_ATOM Atom ); NTSYSAPI VOID NTAPI RtlDeleteNoSplay( _In_ PRTL_SPLAY_LINKS Links, _Inout_ PRTL_SPLAY_LINKS* Root ); NTSYSAPI NTSTATUS NTAPI RtlDowncaseUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_ PCUNICODE_STRING SourceString, _In_ BOOLEAN AllocateDestinationString ); NTSYSAPI NTSTATUS NTAPI RtlDuplicateUnicodeString( _In_ ULONG Flags, _In_ UNICODE_STRING* StringIn, _Out_ UNICODE_STRING* StringOut ); NTSYSAPI NTSTATUS NTAPI RtlEmptyAtomTable( _In_ PVOID AtomTableHandle, _In_ BOOLEAN IncludePinnedAtoms ); _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlEqualSid( _In_ PSID Sid1, _In_ PSID Sid2 ); NTSYSAPI BOOLEAN NTAPI RtlEqualString( _In_ PANSI_STRING String1, _In_ PANSI_STRING String2, _In_ BOOLEAN CaseInSensitive ); NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString( _In_ PCUNICODE_STRING String1, _In_ PCUNICODE_STRING String2, _In_ BOOLEAN CaseInSensitive ); NTSYSAPI ULONG NTAPI RtlFindClearBits( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); NTSYSAPI ULONG NTAPI RtlFindClearBitsAndSet( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); NTSYSAPI ULONG NTAPI RtlFindClearRuns( _In_ PRTL_BITMAP BitMapHeader, _Out_ PRTL_BITMAP_RUN RunArray, _In_ ULONG SizeOfRunArray, _In_ BOOLEAN LocateLongestRuns ); NTSYSAPI ULONG NTAPI RtlFindLastBackwardRunClear( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _In_ PULONG StartingRunIndex ); NTSYSAPI CCHAR NTAPI RtlFindLeastSignificantBit( _In_ ULONGLONG Set ); NTSYSAPI ULONG NTAPI RtlFindLongestRunClear( _In_ PRTL_BITMAP BitMapHeader, _In_ PULONG StartingIndex ); NTSYSAPI CCHAR NTAPI RtlFindMostSignificantBit( _In_ ULONGLONG Set ); NTSYSAPI ULONG NTAPI RtlFindNextForwardRunClear( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _In_ PULONG StartingRunIndex ); NTSYSAPI ULONG NTAPI RtlFindSetBits( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); NTSYSAPI ULONG NTAPI RtlFindSetBitsAndClear( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG NumberToFind, _In_ ULONG HintIndex ); NTSYSAPI VOID NTAPI RtlGetCallersAddress( _Out_ PVOID* CallersAddress, _Out_ PVOID* CallersCaller ); NTSYSAPI NTSTATUS NTAPI RtlGetDaclSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _Out_ PBOOLEAN DaclPresent, _Outptr_result_maybenull_ PACL* Dacl, _Out_ PBOOLEAN DaclDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlGetGroupSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _Outptr_result_maybenull_ PSID* Group, _Out_ PBOOLEAN GroupDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlGetOwnerSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _Outptr_result_maybenull_ PSID* Owner, _Out_ PBOOLEAN OwnerDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlGetSaclSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _Out_ PBOOLEAN SaclPresent, _Out_ PACL* Sacl, _Out_ PBOOLEAN SaclDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlGetSetBootStatusData( _In_ HANDLE Handle, _In_ BOOLEAN Get, _In_ RTL_BSD_ITEM_TYPE DataItem, _In_ PVOID DataBuffer, _In_ ULONG DataBufferLength, _Out_opt_ PULONG ByteRead ); NTSYSAPI NTSTATUS NTAPI RtlCreateBootStatusDataFile( VOID ); NTSYSAPI NTSTATUS NTAPI RtlGetVersion( _Out_ PRTL_OSVERSIONINFOW lpVersionInformation ); NTSYSAPI NTSTATUS NTAPI RtlGUIDFromString( _In_ PUNICODE_STRING GuidString, _Out_ GUID* Guid ); NTSYSAPI NTSTATUS NTAPI RtlHashUnicodeString( _In_ UNICODE_STRING* String, _In_ BOOLEAN CaseInSensitive, _In_ ULONG HashAlgorithm, _Out_ PULONG HashValue ); NTSYSAPI NTSTATUS NTAPI RtlInitializeSid( _Out_ PSID Sid, _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, _In_ UCHAR SubAuthorityCount ); NTSYSAPI ULONG NTAPI RtlLengthRequiredSid( _In_ ULONG SubAuthorityCount ); NTSYSAPI ULONG NTAPI RtlLengthSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor ); NTSYSAPI ULONG NTAPI RtlLengthSid( _In_ PSID Sid ); NTSYSAPI NTSTATUS NTAPI RtlLockBootStatusData( _Out_ PHANDLE BootStatusDataHandle ); NTSYSAPI NTSTATUS NTAPI RtlLookupAtomInAtomTable( _In_ PVOID AtomTableHandle, _In_ PWSTR AtomName, _Out_opt_ PRTL_ATOM Atom ); NTSYSAPI NTSTATUS NTAPI RtlMapSecurityErrorToNtStatus( _In_ SECURITY_STATUS Error ); NTSYSAPI NTSTATUS NTAPI RtlMultiByteToUnicodeN( _Out_ PWCH UnicodeString, _In_ ULONG MaxBytesInUnicodeString, _Out_opt_ PULONG BytesInUnicodeString, _In_ PCSTR MultiByteString, _In_ ULONG BytesInMultiByteString ); NTSYSAPI NTSTATUS NTAPI RtlMultiByteToUnicodeSize( _Out_ PULONG BytesInUnicodeString, _In_ PCSTR MultiByteString, _In_ ULONG BytesInMultiByteString ); NTSYSAPI ULONG NTAPI RtlNumberOfClearBits( _In_ PRTL_BITMAP BitMapHeader ); NTSYSAPI ULONG NTAPI RtlNumberOfSetBits( _In_ PRTL_BITMAP BitMapHeader ); NTSYSAPI NTSTATUS NTAPI RtlQueryAtomInAtomTable( _In_ PVOID AtomTableHandle, _In_ RTL_ATOM Atom, _Out_opt_ PULONG AtomUsage, _Out_opt_ PULONG AtomFlags, _Inout_opt_ PWSTR AtomName, _Inout_opt_ PULONG AtomNameLength ); NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlRealPredecessor( _In_ PRTL_SPLAY_LINKS Links ); NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlRealSuccessor( _In_ PRTL_SPLAY_LINKS Links ); NTSYSAPI VOID NTAPI RtlRunDecodeUnicodeString( _In_ UCHAR Seed, _Inout_ PUNICODE_STRING String ); NTSYSAPI VOID NTAPI RtlRunEncodeUnicodeString( _In_opt_ PUCHAR Seed, _Inout_ PUNICODE_STRING String ); NTSYSAPI NTSTATUS NTAPI RtlSelfRelativeToAbsoluteSD( _In_ PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor, _Out_ PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor, _Inout_ PULONG AbsoluteSecurityDescriptorSize, _Out_ PACL Dacl, _Inout_ PULONG DaclSize, _Out_ PACL Sacl, _Inout_ PULONG SaclSize, _Out_opt_ PSID Owner, _Inout_ PULONG OwnerSize, _Out_opt_ PSID PrimaryGroup, _Inout_ PULONG PrimaryGroupSize ); NTSYSAPI NTSTATUS NTAPI RtlSelfRelativeToAbsoluteSD2( _Inout_ PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, _Inout_ PULONG pBufferSize ); NTSYSAPI VOID NTAPI RtlSetAllBits( _In_ PRTL_BITMAP BitMapHeader ); NTSYSAPI VOID NTAPI RtlSetBits( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG NumberToSet ); NTSYSAPI NTSTATUS NTAPI RtlSetDaclSecurityDescriptor( _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ BOOLEAN DaclPresent, _In_opt_ PACL Dacl, _In_ BOOLEAN DaclDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlSetGroupSecurityDescriptor( _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_opt_ PSID Group, _In_ BOOLEAN GroupDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlSetOwnerSecurityDescriptor( _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_opt_ PSID Owner, _In_ BOOLEAN OwnerDefaulted ); NTSYSAPI NTSTATUS NTAPI RtlSetSaclSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ BOOLEAN SaclPresent, _In_opt_ PACL Sacl, _In_opt_ BOOLEAN SaclDefaulted ); NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlSplay( _Inout_ PRTL_SPLAY_LINKS Links ); NTSYSAPI NTSTATUS NTAPI RtlStringFromGUID( _In_ REFGUID Guid, _Out_ PUNICODE_STRING GuidString ); NTSYSAPI PUCHAR NTAPI RtlSubAuthorityCountSid( _In_ PSID Sid ); NTSYSAPI PULONG NTAPI RtlSubAuthoritySid( _In_ PSID Sid, _In_ ULONG SubAuthority ); NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlSubtreePredecessor( _In_ PRTL_SPLAY_LINKS Links ); NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlSubtreeSuccessor( _In_ PRTL_SPLAY_LINKS Links ); #if NTDDI_VERSION >= NTDDI_VISTA NTSYSAPI BOOLEAN NTAPI RtlTestBit( _In_ PRTL_BITMAP BitMapHeader, _In_ ULONG BitNumber ); #endif NTSYSAPI VOID NTAPI RtlUnlockBootStatusData( _In_ HANDLE BootStatusDataHandle ); NTSYSAPI NTSTATUS NTAPI RtlCreateSecurityDescriptor( _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor, _In_ ULONG Revision ); NTSYSAPI BOOLEAN NTAPI RtlValidRelativeSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptorInput, _In_ ULONG SecurityDescriptorLength, _In_ SECURITY_INFORMATION RequiredInformation ); NTSYSAPI BOOLEAN NTAPI RtlValidSecurityDescriptor( _In_ PSECURITY_DESCRIPTOR SecurityDescriptor ); _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlValidSid( _In_ PSID Sid ); NTSYSAPI NTSTATUS NTAPI RtlVerifyVersionInfo( _In_ RTL_OSVERSIONINFOEXW VersionInfo, _In_ ULONG TypeMask, _In_ ULONGLONG ConditionMask ); NTSYSAPI ULONGLONG NTAPI VerSetConditionMask( _In_ ULONGLONG ConditionMask, _In_ ULONG TypeMask, _In_ UCHAR Condition ); #if NTDDI_VERSION >= NTDDI_VISTA _Check_return_ NTSYSAPI NTSTATUS NTAPI TpAllocPool( _Out_ PTP_POOL* PoolReturn, _Reserved_ PVOID Reserved ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI TpDisablePoolCallbackChecks( _Inout_ PTP_POOL Pool ); #endif NTSYSAPI VOID NTAPI TpReleasePool( _Inout_ PTP_POOL Pool ); NTSYSAPI VOID NTAPI TpSetPoolMaxThreads( _Inout_ PTP_POOL Pool, _In_ ULONG MaxThreads ); NTSYSAPI NTSTATUS NTAPI TpSetPoolMinThreads( _Inout_ PTP_POOL Pool, _In_ ULONG MinThreads ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI TpQueryPoolStackInformation( _In_ PTP_POOL Pool, _Out_ PTP_POOL_STACK_INFORMATION PoolStackInformation ); NTSYSAPI NTSTATUS NTAPI TpSetPoolStackInformation( _Inout_ PTP_POOL Pool, _In_ PTP_POOL_STACK_INFORMATION PoolStackInformation ); #endif _Check_return_ NTSYSAPI NTSTATUS NTAPI TpAllocCleanupGroup( _Out_ PTP_CLEANUP_GROUP* CleanupGroupReturn ); NTSYSAPI VOID NTAPI TpReleaseCleanupGroup( _Inout_ PTP_CLEANUP_GROUP CleanupGroup ); NTSYSAPI VOID NTAPI TpReleaseCleanupGroupMembers( _Inout_ PTP_CLEANUP_GROUP CleanupGroup, _In_ LOGICAL CancelPendingCallbacks, _Inout_opt_ PVOID CleanupParameter ); NTSYSAPI VOID NTAPI TpCallbackSetEventOnCompletion( _Inout_ PTP_CALLBACK_INSTANCE Instance, _In_ HANDLE Event ); NTSYSAPI VOID NTAPI TpCallbackReleaseSemaphoreOnCompletion( _Inout_ PTP_CALLBACK_INSTANCE Instance, _In_ HANDLE Semaphore, _In_ ULONG ReleaseCount ); NTSYSAPI VOID NTAPI TpCallbackReleaseMutexOnCompletion( _Inout_ PTP_CALLBACK_INSTANCE Instance, _In_ HANDLE Mutex ); NTSYSAPI VOID NTAPI TpCallbackLeaveCriticalSectionOnCompletion( _Inout_ PTP_CALLBACK_INSTANCE Instance, _Inout_ PRTL_CRITICAL_SECTION CriticalSection ); NTSYSAPI VOID NTAPI TpCallbackUnloadDllOnCompletion( _Inout_ PTP_CALLBACK_INSTANCE Instance, _In_ PVOID DllHandle ); NTSYSAPI NTSTATUS NTAPI TpCallbackMayRunLong( _Inout_ PTP_CALLBACK_INSTANCE Instance ); NTSYSAPI VOID NTAPI TpDisassociateCallback( _Inout_ PTP_CALLBACK_INSTANCE Instance ); _Check_return_ NTSYSAPI NTSTATUS NTAPI TpSimpleTryPost( _In_ PTP_SIMPLE_CALLBACK Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); _Check_return_ NTSYSAPI NTSTATUS NTAPI TpAllocWork( _Out_ PTP_WORK* WorkReturn, _In_ PTP_WORK_CALLBACK Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); NTSYSAPI VOID NTAPI TpReleaseWork( _Inout_ PTP_WORK Work ); NTSYSAPI VOID NTAPI TpPostWork( _Inout_ PTP_WORK Work ); NTSYSAPI VOID NTAPI TpWaitForWork( _Inout_ PTP_WORK Work, _In_ LOGICAL CancelPendingCallbacks ); _Check_return_ NTSYSAPI NTSTATUS NTAPI TpAllocTimer( _Out_ PTP_TIMER* Timer, _In_ PTP_TIMER_CALLBACK Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); NTSYSAPI VOID NTAPI TpReleaseTimer( _Inout_ PTP_TIMER Timer ); NTSYSAPI VOID NTAPI TpSetTimer( _Inout_ PTP_TIMER Timer, _In_opt_ PLARGE_INTEGER DueTime, _In_ ULONG Period, _In_opt_ ULONG WindowLength ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI TpSetTimerEx( _Inout_ PTP_TIMER Timer, _In_opt_ PLARGE_INTEGER DueTime, _In_ ULONG Period, _In_opt_ ULONG WindowLength ); #endif NTSYSAPI LOGICAL NTAPI TpIsTimerSet( _In_ PTP_TIMER Timer ); NTSYSAPI VOID NTAPI TpWaitForTimer( _Inout_ PTP_TIMER Timer, _In_ LOGICAL CancelPendingCallbacks ); _Check_return_ NTSYSAPI NTSTATUS NTAPI TpAllocWait( _Out_ PTP_WAIT* WaitReturn, _In_ PTP_WAIT_CALLBACK Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); NTSYSAPI VOID NTAPI TpReleaseWait( _Inout_ PTP_WAIT Wait ); NTSYSAPI VOID NTAPI TpSetWait( _Inout_ PTP_WAIT Wait, _In_opt_ HANDLE Handle, _In_opt_ PLARGE_INTEGER Timeout ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI TpSetWaitEx( _Inout_ PTP_WAIT Wait, _In_opt_ HANDLE Handle, _In_opt_ PLARGE_INTEGER Timeout, _In_opt_ PVOID Reserved ); #endif _Check_return_ NTSYSAPI NTSTATUS NTAPI TpAllocIoCompletion( _Out_ PTP_IO* IoReturn, _In_ HANDLE File, _In_ PTP_IO_CALLBACK Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); NTSYSAPI VOID NTAPI TpWaitForIoCompletion( _Inout_ PTP_IO Io, _In_ LOGICAL CancelPendingCallbacks ); NTSYSAPI NTSTATUS NTAPI TpAllocAlpcCompletion( _Out_ PTP_ALPC* AlpcReturn, _In_ HANDLE AlpcPort, _In_ PTP_ALPC_CALLBACK Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI TpAllocAlpcCompletionEx( _Out_ PTP_ALPC* AlpcReturn, _In_ HANDLE AlpcPort, _In_ PTP_ALPC_CALLBACK_EX Callback, _Inout_opt_ PVOID Context, _In_opt_ PTP_CALLBACK_ENVIRON CallbackEnviron ); #endif NTSYSAPI VOID NTAPI TpReleaseAlpcCompletion( _Inout_ PTP_ALPC Alpc ); NTSYSAPI VOID NTAPI TpWaitForAlpcCompletion( _Inout_ PTP_ALPC Alpc ); #endif #if NTDDI_VERSION >= NTDDI_WIN7 NTSYSAPI NTSTATUS NTAPI TpAlpcRegisterCompletionList( _Inout_ PTP_ALPC Alpc ); NTSYSAPI NTSTATUS NTAPI TpAlpcUnregisterCompletionList( _Inout_ PTP_ALPC Alpc ); #endif #ifdef __cplusplus } #endif #endif // NTDLL_H
C++
x64dbg-development/src/dbg/test/general/dll/main.cpp
#include "main.h" char global[10] = "0"; // a sample exported function void DLL_EXPORT SomeFunction(const LPCSTR sometext) { MessageBoxA(0, sometext, "DLL Message", MB_OK | MB_ICONINFORMATION); } extern "C" DLL_EXPORT BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { switch(fdwReason) { case DLL_PROCESS_ATTACH: { GetTickCount(); GetCurrentProcessId(); GetCurrentProcess(); DWORD old = 0; VirtualProtect(global, 10, PAGE_GUARD, &old); asm("int3"); } break; case DLL_PROCESS_DETACH: // detach from process break; case DLL_THREAD_ATTACH: // attach to thread break; case DLL_THREAD_DETACH: // detach from thread break; } return TRUE; // succesful }
C/C++
x64dbg-development/src/dbg/test/general/dll/main.h
#ifndef __MAIN_H__ #define __MAIN_H__ #include <windows.h> /* To use this exported function of dll, include this header * in your project. */ #ifdef BUILD_DLL #define DLL_EXPORT __declspec(dllexport) #else #define DLL_EXPORT __declspec(dllimport) #endif #ifdef __cplusplus extern "C" { #endif void DLL_EXPORT SomeFunction(const LPCSTR sometext); #ifdef __cplusplus } #endif #endif // __MAIN_H__
x64dbg-development/src/dbg/test/general/dll/test_dll.cbp
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <CodeBlocks_project_file> <FileVersion major="1" minor="6" /> <Project> <Option title="test_dll" /> <Option pch_mode="2" /> <Option compiler="gcc" /> <Build> <Target title="x32"> <Option output="bin/x32/test" prefix_auto="1" extension_auto="1" /> <Option object_output="obj/x32/" /> <Option type="3" /> <Option compiler="gcc" /> <Compiler> <Add option="-Wall" /> <Add option="-DBUILD_DLL" /> <Add option="-O2" /> </Compiler> <Linker> <Add option="-s" /> <Add library="user32" /> </Linker> </Target> <Target title="x64"> <Option output="bin/x64/test" prefix_auto="1" extension_auto="1" /> <Option object_output="obj/x64" /> <Option type="3" /> <Option compiler="gnu_gcc_compiler_x64" /> <Compiler> <Add option="-O2" /> <Add option="-Wall" /> <Add option="-DBUILD_DLL" /> </Compiler> <Linker> <Add option="-s" /> <Add library="user32" /> </Linker> </Target> </Build> <Unit filename="main.cpp" /> <Unit filename="main.h" /> <Extensions> <code_completion /> <envvars /> <debugger /> <lib_finder disable_auto="1" /> </Extensions> </Project> </CodeBlocks_project_file>
C++
x64dbg-development/src/dbg/test/general/exe/main.cpp
#include <windows.h> char global[10] = "0"; int main() { GetTickCount(); char* a = 0; GetCurrentProcessId(); GetCurrentProcess(); DWORD old = 0; VirtualProtect(global, 0x1000, PAGE_READWRITE | PAGE_GUARD, &old); /*throw exceptions*/ global[0] = 0; //PAGE_GUARD *a = 0; //ACCESS_VIOLATION asm("int3"); //BREAKPOINT return 0; }
x64dbg-development/src/dbg/test/general/exe/test_exe.cbp
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <CodeBlocks_project_file> <FileVersion major="1" minor="6" /> <Project> <Option title="test_exe" /> <Option pch_mode="2" /> <Option compiler="gcc" /> <Build> <Target title="x32"> <Option output="bin/x32/test" prefix_auto="1" extension_auto="1" /> <Option object_output="obj/x32/" /> <Option type="0" /> <Option compiler="gcc" /> <Compiler> <Add option="-fomit-frame-pointer" /> <Add option="-Os" /> </Compiler> <Linker> <Add option="-s" /> </Linker> </Target> <Target title="x64"> <Option output="bin/x64/test" prefix_auto="1" extension_auto="1" /> <Option object_output="obj/x64/" /> <Option type="0" /> <Option compiler="gnu_gcc_compiler_x64" /> <Compiler> <Add option="-fomit-frame-pointer" /> <Add option="-Os" /> </Compiler> <Linker> <Add option="-s" /> </Linker> </Target> </Build> <Compiler> <Add option="-Wall" /> <Add option="-fexceptions" /> </Compiler> <Unit filename="main.cpp" /> <Extensions> <code_completion /> <envvars /> <debugger /> <lib_finder disable_auto="1" /> </Extensions> </Project> </CodeBlocks_project_file>
x64dbg-development/src/dbg/test/guard_page/guard_page_test.cbp
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <CodeBlocks_project_file> <FileVersion major="1" minor="6" /> <Project> <Option title="guard_page_test" /> <Option pch_mode="2" /> <Option compiler="gcc" /> <Build> <Target title="x32"> <Option output="bin/x32/guardpage" prefix_auto="1" extension_auto="1" /> <Option object_output="obj/x32" /> <Option type="1" /> <Option compiler="gcc" /> <Compiler> <Add option="-fomit-frame-pointer" /> </Compiler> <Linker> <Add option="-s" /> </Linker> </Target> <Target title="x64"> <Option output="bin/x64/guardpage" prefix_auto="1" extension_auto="1" /> <Option object_output="obj/x64" /> <Option type="1" /> <Option compiler="gnu_gcc_compiler_x64" /> <Compiler> <Add option="-fomit-frame-pointer" /> </Compiler> <Linker> <Add option="-s" /> </Linker> </Target> </Build> <Compiler> <Add option="-Wall" /> <Add option="-fexceptions" /> </Compiler> <Unit filename="main.cpp" /> <Extensions> <code_completion /> <envvars /> <debugger /> </Extensions> </Project> </CodeBlocks_project_file>
C++
x64dbg-development/src/dbg/test/guard_page/main.cpp
#include <windows.h> #include <stdio.h> typedef bool (*CBRET)(); unsigned int globalvar = 0; int main() { unsigned int lol; unsigned char* page = (unsigned char*)VirtualAlloc(0, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); if(!page) { puts("error: VirtualAlloc"); return 1; } page[0] = 0x6A; puts("write"); page[1] = 0x01; puts("write"); page[2] = 0x58; puts("write"); page[3] = 0xC3; puts("write"); CBRET cb = (CBRET)page; cb(); puts("exec"); lol = globalvar; puts("read"); lol = page[1]; puts("read"); lol = page[3]; puts("read"); lol = page[2]; puts("read"); return 0; }
Assembly Language
x64dbg-development/src/dbg/test/highlighting/x32/highlighting.asm
global _start section .data @real: db 0 section .text _start: MOV EAX,DWORD [@real] MOV EAX,DWORD [EAX*4+@real] MOV EAX,DWORD [EAX+@real] MOV EAX,@real MOV EBX,DWORD [EAX] MOV EBX,4 XOR EDX,EDX DIV EBX MOV EAX,DWORD [EAX*4] JMP SHORT @next @next: RET
Assembly Language
x64dbg-development/src/dbg/test/mmx_sse_fpu/x32/fpu/fpu.asm
global _start section .data a: dq 1.1 b: dq 2.2 c: dq 3.3 d: dq 4.4 e: dq 5.5 f: dq 6.6 g: dq 7.7 h: dq 8.8 section .text _start: fld qword [a] fld qword [b] fld qword [c] fld qword [d] fld qword [e] fld qword [f] fld qword [g] fld qword [h] ret
x64dbg-development/src/dbg/test/mmx_sse_fpu/x32/fpu/fpu_build.bat
@echo off nasm -f win32 fpu.asm golink fpu.obj /entry _start del /Q *.obj move fpu.exe ..\fpu.exe > nul pause
Assembly Language
x64dbg-development/src/dbg/test/mmx_sse_fpu/x32/mmx/mmx.asm
global _start section .data a: dq 1111111122222222h b: dq 2222222233333333h c: dq 3333333344444444h d: dq 4444444455555555h e: dq 5555555566666666h f: dq 6666666677777777h g: dq 7777777788888888h h: dq 8888888811111111h section .text _start: movq mm0,[a] movq mm1,[b] movq mm2,[c] movq mm3,[d] movq mm4,[e] movq mm5,[f] movq mm6,[g] movq mm7,[h] ret
x64dbg-development/src/dbg/test/mmx_sse_fpu/x32/mmx/mmx_build.bat
@echo off nasm -fwin32 mmx.asm golink mmx.obj /entry _start del /Q *.obj move mmx.exe ..\mmx.exe > nul pause
Assembly Language
x64dbg-development/src/dbg/test/mmx_sse_fpu/x32/sse/sse.asm
global _start section .data align 16 v1: dd 1.1, 2.2, 3.3, 4.4 v2: dd 5.5, 6.6, 7.7, 8.8 v3: dd 9.9, 10.10, 11.11, 12.12 v4: dd 13.13, 14.14, 15.15, 16.16 v5: dd 17.17, 18.18, 19.19, 20.20 v6: dd 21.21, 22.22, 23.23, 24.24 v7: dd 25.25, 26.26, 27.27, 28.28 v8: dd 29.29, 30.30, 31.31, 32.32 section .bss mask1: resd 1 mask2: resd 1 mask3: resd 1 mask4: resd 1 section .text _start: movaps xmm0, [v1] movaps xmm1, [v2] movaps xmm2, [v3] movaps xmm3, [v4] movaps xmm4, [v5] movaps xmm5, [v6] movaps xmm6, [v7] movaps xmm7, [v8] ret
x64dbg-development/src/dbg/test/mmx_sse_fpu/x32/sse/sse_build.bat
@echo off nasm -fwin32 sse.asm golink sse.obj /entry _start del /Q *.obj move sse.exe ..\sse.exe > nul pause