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(®isters, sizeof(registers)))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read register context..."));
return false;
}
if(!MemWrite(address, ®isters.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(®isters, sizeof(registers)))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read register context..."));
return false;
}
SetContextDataEx(hActiveThread, registerindex[1], (ULONG_PTR)®isters.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, ®Type, 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 %z 0– 0– *z *z )ª )ª * * )> )> (Î (Î 5Ô 5Ô ;ä ;ä 4( 4( 3À 3À <P <P ;x ;x ; ; +º +º 1ð 1ð - - ,” ,” ,$ ,$ -p -p -Þ -Þ . . .P .P /¬ /¬ /6 /6 0 0 &¶ &¶ ä ä $ $ #^ #^ !ž !ž !. !. 7 7 :4 :4 9Ê 9Ê 9Z 9Z 6° 6° 8ä 8ä 8v 8v '† '† (^ (^ 'ð 'ð 4’ 4’ 5f 5f 4ú 4ú +J +J :¦ :¦ ' ' *â *â 1v 1v 1 1 $4 $4 "î "î L L "
"
"~ "~ À À 6F 6F 8 8 7’ 7’ 2^ 2^ 2Î 2Î 3H 3H #Ì #Ì__IMPORT_DESCRIPTOR_jansson __NULL_IMPORT_DESCRIPTOR jansson_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 `
F 2 \ ’
% N& æ% z% –0 z* ª) * >) Î( Ô5 ä; (4 À3 P< x; ; º+ ð1 - ”, $, p- Þ- Â. P. ¬/ 6/ 0 ¶& ä $ ^# ž! .! 7 4: Ê9 Z9 °6 ä8 v8 †' ^( ð' ’4 f5 ú4 J+ ¦: ' â* v1 1 4$ î" L
" ~" À F6 8 ’7 ^2 Î2 H3 Ì# ‰ " < ? & % = > ; $ F : # ! 6 . 0 /
7 4 9 8 C D E 1 3 2 @ + ' B A - , * ) ( 5 " < ? & % = > ; $ F : # ! 6 . 0 /
7 4 9 8 C D E 1 3 2 @ + ' B A - , * ) ( 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_ex jansson_NULL_THUNK_DATA jansson.dll/ 1403015379 0 493 `
L ÓP S .debug$S A Œ @ 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 9 R __IMPORT_DESCRIPTOR_jansson __NULL_IMPORT_DESCRIPTOR jansson_NULL_THUNK_DATA
jansson.dll/ 1403015379 0 250 `
L ÓP S¹ .debug$S A d @ B.idata$3 ¥ @ 0À jansson.dll'
ovMicrosoft (R) LINK @comp.idovœ ÿÿ __NULL_IMPORT_DESCRIPTOR jansson.dll/ 1403015379 0 278 `
L ÓP SÕ .debug$S A Œ @ B.idata$5 Í @ 0À.idata$4 Ñ @ 0À jansson.dll'
ovMicrosoft (R) LINK @comp.idovœ ÿÿ jansson_NULL_THUNK_DATA jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_array jansson.dll jansson.dll/ 1403015379 0 55 `
ÿÿ LÓP S# _json_array_append_new jansson.dll
jansson.dll/ 1403015379 0 50 `
ÿÿ LÓP S _json_array_clear jansson.dll jansson.dll/ 1403015379 0 51 `
ÿÿ LÓP S _json_array_extend jansson.dll
jansson.dll/ 1403015379 0 48 `
ÿÿ LÓP S _json_array_get jansson.dll jansson.dll/ 1403015379 0 55 `
ÿÿ LÓP S# _json_array_insert_new jansson.dll
jansson.dll/ 1403015379 0 51 `
ÿÿ LÓP S _json_array_remove jansson.dll
jansson.dll/ 1403015379 0 52 `
ÿÿ LÓP S _json_array_set_new jansson.dll jansson.dll/ 1403015379 0 49 `
ÿÿ LÓP S _json_array_size jansson.dll
jansson.dll/ 1403015379 0 43 `
ÿÿ LÓP S _json_copy jansson.dll
jansson.dll/ 1403015379 0 48 `
ÿÿ LÓP S
_json_deep_copy jansson.dll jansson.dll/ 1403015379 0 45 `
ÿÿ LÓP S _json_delete jansson.dll
jansson.dll/ 1403015379 0 52 `
ÿÿ LÓP S _json_dump_callback jansson.dll jansson.dll/ 1403015379 0 48 `
ÿÿ LÓP S
_json_dump_file jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_dumpf jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_dumps jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_equal jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_false jansson.dll jansson.dll/ 1403015379 0 46 `
ÿÿ LÓP S _json_integer jansson.dll jansson.dll/ 1403015379 0 50 `
ÿÿ LÓP S _json_integer_set jansson.dll jansson.dll/ 1403015379 0 52 `
ÿÿ LÓP S _json_integer_value jansson.dll jansson.dll/ 1403015379 0 52 `
ÿÿ LÓP S _json_load_callback jansson.dll jansson.dll/ 1403015379 0 48 `
ÿÿ LÓP S _json_load_file jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_loadb jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_loadf jansson.dll jansson.dll/ 1403015379 0 44 `
ÿÿ LÓP S _json_loads jansson.dll jansson.dll/ 1403015379 0 43 `
ÿÿ LÓP S _json_null jansson.dll
jansson.dll/ 1403015379 0 51 `
ÿÿ LÓP S _json_number_value jansson.dll
jansson.dll/ 1403015379 0 45 `
ÿÿ LÓP S _json_object jansson.dll
jansson.dll/ 1403015379 0 51 `
ÿÿ LÓP S _json_object_clear jansson.dll
jansson.dll/ 1403015379 0 49 `
ÿÿ LÓP S _json_object_del jansson.dll
jansson.dll/ 1403015379 0 49 `
ÿÿ LÓP S _json_object_get jansson.dll
jansson.dll/ 1403015379 0 50 `
ÿÿ LÓP S _json_object_iter jansson.dll jansson.dll/ 1403015379 0 53 `
ÿÿ LÓP S! ! _json_object_iter_at jansson.dll
jansson.dll/ 1403015379 0 54 `
ÿÿ LÓP S" " _json_object_iter_key jansson.dll jansson.dll/ 1403015379 0 55 `
ÿÿ LÓP S# # _json_object_iter_next jansson.dll
jansson.dll/ 1403015379 0 58 `
ÿÿ LÓP S& $ _json_object_iter_set_new jansson.dll jansson.dll/ 1403015379 0 56 `
ÿÿ LÓP S$ % _json_object_iter_value jansson.dll jansson.dll/ 1403015379 0 57 `
ÿÿ LÓP S% & _json_object_key_to_iter jansson.dll
jansson.dll/ 1403015379 0 50 `
ÿÿ LÓP S ' _json_object_seed jansson.dll jansson.dll/ 1403015379 0 53 `
ÿÿ LÓP S! ( _json_object_set_new jansson.dll
jansson.dll/ 1403015379 0 61 `
ÿÿ LÓP S) ) _json_object_set_new_nocheck jansson.dll
jansson.dll/ 1403015379 0 50 `
ÿÿ LÓP S * _json_object_size jansson.dll jansson.dll/ 1403015379 0 52 `
ÿÿ LÓP S + _json_object_update jansson.dll jansson.dll/ 1403015379 0 61 `
ÿÿ LÓP S) , _json_object_update_existing jansson.dll
jansson.dll/ 1403015379 0 60 `
ÿÿ LÓP S( - _json_object_update_missing jansson.dll jansson.dll/ 1403015379 0 43 `
ÿÿ LÓP S . _json_pack jansson.dll
jansson.dll/ 1403015379 0 46 `
ÿÿ LÓP S / _json_pack_ex jansson.dll jansson.dll/ 1403015379 0 43 `
ÿÿ LÓP S 0 _json_real jansson.dll
jansson.dll/ 1403015379 0 47 `
ÿÿ LÓP S 1 _json_real_set jansson.dll
jansson.dll/ 1403015379 0 49 `
ÿÿ LÓP S 2 _json_real_value jansson.dll
jansson.dll/ 1403015379 0 54 `
ÿÿ LÓP S" 3 _json_set_alloc_funcs jansson.dll jansson.dll/ 1403015379 0 45 `
ÿÿ LÓP S 4 _json_string jansson.dll
jansson.dll/ 1403015379 0 52 `
ÿÿ LÓP S 5 _json_string_length jansson.dll jansson.dll/ 1403015379 0 53 `
ÿÿ LÓP S! 6 _json_string_nocheck jansson.dll
jansson.dll/ 1403015379 0 49 `
ÿÿ LÓP S 7 _json_string_set jansson.dll
jansson.dll/ 1403015379 0 57 `
ÿÿ LÓP S% 8 _json_string_set_nocheck jansson.dll
jansson.dll/ 1403015379 0 50 `
ÿÿ LÓP S 9 _json_string_setn jansson.dll jansson.dll/ 1403015379 0 58 `
ÿÿ LÓP S& : _json_string_setn_nocheck jansson.dll jansson.dll/ 1403015379 0 51 `
ÿÿ LÓP S ; _json_string_value jansson.dll
jansson.dll/ 1403015379 0 46 `
ÿÿ LÓP S < _json_stringn jansson.dll jansson.dll/ 1403015379 0 54 `
ÿÿ LÓP S" = _json_stringn_nocheck jansson.dll jansson.dll/ 1403015379 0 43 `
ÿÿ LÓP S > _json_true jansson.dll
jansson.dll/ 1403015379 0 45 `
ÿÿ LÓP S ? _json_unpack jansson.dll
jansson.dll/ 1403015379 0 48 `
ÿÿ LÓP S @ _json_unpack_ex jansson.dll jansson.dll/ 1403015379 0 47 `
ÿÿ LÓP S A _json_vpack_ex jansson.dll
jansson.dll/ 1403015379 0 49 `
ÿÿ LÓP S B _json_vunpack_ex jansson.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 – Ò 6 6 ¤ ¤__IMPORT_DESCRIPTOR_LLVMDemangle __NULL_IMPORT_DESCRIPTOR LLVMDemangle_NULL_THUNK_DATA LLVMDemangle __imp_LLVMDemangle LLVMDemangleFree __imp_LLVMDemangleFree / 1652535369 0 202 `
X – Ò 6 ¤ LLVMDemangle LLVMDemangleFree __IMPORT_DESCRIPTOR_LLVMDemangle __NULL_IMPORT_DESCRIPTOR __imp_LLVMDemangle __imp_LLVMDemangleFree LLVMDemangle_NULL_THUNK_DATA // 1652535369 0 17 `
LLVMDemangle.dll
/0 1652535369 0 514 `
d† I°b .debug$S F Œ @ 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_DESCRIPTOR LLVMDemangle_NULL_THUNK_DATA /0 1652535369 0 255 `
d† I°b¾ .debug$S F d @ B.idata$3 ª @ 0À LLVMDemangle.dll' Ð ±^Microsoft (R) LINK @comp.id±^ÿÿ __NULL_IMPORT_DESCRIPTOR
/0 1652535369 0 296 `
d† I°bâ .debug$S F Œ @ B.idata$5 Ò @ @À.idata$4 Ú @ @À LLVMDemangle.dll' Ð ±^Microsoft (R) LINK @comp.id±^ÿÿ " LLVMDemangle_NULL_THUNK_DATA /0 1652535369 0 50 `
ÿÿ d†I°b LLVMDemangle LLVMDemangle.dll /0 1652535369 0 54 `
ÿÿ d†I°b" LLVMDemangleFree LLVMDemangle.dll |
|
x64dbg-development/src/dbg/LLVMDemangle/LLVMDemangle_x86.lib | !<arch>
/ 1652535421 0 196 `
` ž Ú 6 6 ¦ ¦__IMPORT_DESCRIPTOR_LLVMDemangle __NULL_IMPORT_DESCRIPTOR LLVMDemangle_NULL_THUNK_DATA _LLVMDemangle __imp__LLVMDemangle _LLVMDemangleFree __imp__LLVMDemangleFree / 1652535421 0 206 `
` ž Ú 6 ¦ _LLVMDemangle _LLVMDemangleFree __IMPORT_DESCRIPTOR_LLVMDemangle __NULL_IMPORT_DESCRIPTOR __imp__LLVMDemangle __imp__LLVMDemangleFree LLVMDemangle_NULL_THUNK_DATA // 1652535421 0 17 `
LLVMDemangle.dll
/0 1652535421 0 514 `
L }°b .debug$S F Œ @ 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_DESCRIPTOR LLVMDemangle_NULL_THUNK_DATA /0 1652535421 0 255 `
L }°b¾ .debug$S F d @ B.idata$3 ª @ 0À LLVMDemangle.dll' ±^Microsoft (R) LINK @comp.id±^ÿÿ __NULL_IMPORT_DESCRIPTOR
/0 1652535421 0 288 `
L }°bÚ .debug$S F Œ @ B.idata$5 Ò @ 0À.idata$4 Ö @ 0À LLVMDemangle.dll' ±^Microsoft (R) LINK @comp.id±^ÿÿ " LLVMDemangle_NULL_THUNK_DATA /0 1652535421 0 51 `
ÿÿ L}°b _LLVMDemangle LLVMDemangle.dll
/0 1652535421 0 55 `
ÿÿ L}°b# _LLVMDemangleFree LLVMDemangle.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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.