1081 lines
30 KiB
C++
1081 lines
30 KiB
C++
//----------------------------------------------------------------------------
|
|
//
|
|
// Stack walking support.
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997-2001.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "ntsdp.hpp"
|
|
|
|
IMAGE_IA64_RUNTIME_FUNCTION_ENTRY g_EpcRfeBuffer;
|
|
PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY g_EpcRfe;
|
|
|
|
PFPO_DATA
|
|
SynthesizeKnownFpo(PSTR Symbol, ULONG64 OffStart, ULONG64 Disp)
|
|
{
|
|
static ULONG64 s_Nr2, s_Lu2, s_Eh3, s_Kuit;
|
|
|
|
if (!s_Nr2 || !s_Lu2 || !s_Eh3 || !s_Kuit)
|
|
{
|
|
GetOffsetFromSym("nt!_NLG_Return2", &s_Nr2, NULL);
|
|
GetOffsetFromSym("nt!_local_unwind2", &s_Lu2, NULL);
|
|
GetOffsetFromSym("nt!_except_handler3", &s_Eh3, NULL);
|
|
GetOffsetFromSym("nt!KiUnexpectedInterruptTail", &s_Kuit, NULL);
|
|
}
|
|
|
|
if (OffStart == s_Nr2 || OffStart == s_Lu2)
|
|
{
|
|
static FPO_DATA s_Lu2Fpo;
|
|
|
|
s_Lu2Fpo.ulOffStart = (ULONG)OffStart;
|
|
s_Lu2Fpo.cbProcSize = 0x68;
|
|
s_Lu2Fpo.cdwLocals = 4;
|
|
s_Lu2Fpo.cdwParams = 0;
|
|
s_Lu2Fpo.cbProlog = 0;
|
|
s_Lu2Fpo.cbRegs = 3;
|
|
s_Lu2Fpo.fHasSEH = 0;
|
|
s_Lu2Fpo.fUseBP = 0;
|
|
s_Lu2Fpo.reserved = 0;
|
|
s_Lu2Fpo.cbFrame = FRAME_FPO;
|
|
return &s_Lu2Fpo;
|
|
}
|
|
else if (OffStart == s_Eh3)
|
|
{
|
|
static FPO_DATA s_Eh3Fpo;
|
|
|
|
s_Eh3Fpo.ulOffStart = (ULONG)OffStart;
|
|
s_Eh3Fpo.cbProcSize = 0xbd;
|
|
s_Eh3Fpo.cdwLocals = 2;
|
|
s_Eh3Fpo.cdwParams = 4;
|
|
s_Eh3Fpo.cbProlog = 3;
|
|
s_Eh3Fpo.cbRegs = 4;
|
|
s_Eh3Fpo.fHasSEH = 0;
|
|
s_Eh3Fpo.fUseBP = 0;
|
|
s_Eh3Fpo.reserved = 0;
|
|
s_Eh3Fpo.cbFrame = FRAME_NONFPO;
|
|
return &s_Eh3Fpo;
|
|
}
|
|
else if (OffStart == s_Kuit)
|
|
{
|
|
//
|
|
// KiUnexpectedInterruptTail has three special stubs
|
|
// following it for CommonDispatchException[0-2]Args.
|
|
// These stubs set up for the appropriate number of
|
|
// arguments and then call CommonDispatchException.
|
|
// They do not have symbols or FPO data so fake some
|
|
// up if we're in the region immediately after KUIT.
|
|
//
|
|
|
|
PFPO_DATA KuitData = (PFPO_DATA)
|
|
SymFunctionTableAccess(g_CurrentProcess->Handle, OffStart);
|
|
if (KuitData != NULL &&
|
|
Disp >= (ULONG64)KuitData->cbProcSize &&
|
|
Disp < (ULONG64)KuitData->cbProcSize + 0x20)
|
|
{
|
|
static FPO_DATA s_CdeStubFpo;
|
|
|
|
s_CdeStubFpo.ulOffStart = (ULONG)OffStart;
|
|
s_CdeStubFpo.cbProcSize = 0x10;
|
|
s_CdeStubFpo.cdwLocals = 0;
|
|
s_CdeStubFpo.cdwParams = 0;
|
|
s_CdeStubFpo.cbProlog = 0;
|
|
s_CdeStubFpo.cbRegs = 0;
|
|
s_CdeStubFpo.fHasSEH = 0;
|
|
s_CdeStubFpo.fUseBP = 0;
|
|
s_CdeStubFpo.reserved = 0;
|
|
s_CdeStubFpo.cbFrame = FRAME_TRAP;
|
|
return &s_CdeStubFpo;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PFPO_DATA
|
|
SynthesizeFpoDataForModule(DWORD64 PCAddr)
|
|
{
|
|
DWORD64 Offset;
|
|
USHORT StdCallArgs;
|
|
CHAR symbuf[MAX_SYMBOL_LEN];
|
|
|
|
GetSymbolStdCall( PCAddr,
|
|
symbuf,
|
|
sizeof(symbuf),
|
|
&Offset,
|
|
&StdCallArgs);
|
|
|
|
if (Offset == PCAddr)
|
|
{
|
|
// No symbol.
|
|
return NULL;
|
|
}
|
|
|
|
PFPO_DATA KnownFpo =
|
|
SynthesizeKnownFpo(symbuf, PCAddr - Offset, Offset);
|
|
if (KnownFpo != NULL)
|
|
{
|
|
return KnownFpo;
|
|
}
|
|
|
|
if (StdCallArgs == 0xffff)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static FPO_DATA s_SynthFpo;
|
|
|
|
s_SynthFpo.ulOffStart = (ULONG)(PCAddr - Offset);
|
|
s_SynthFpo.cbProcSize = (ULONG)(Offset + 10);
|
|
s_SynthFpo.cdwLocals = 0;
|
|
s_SynthFpo.cdwParams = StdCallArgs;
|
|
s_SynthFpo.cbProlog = 0;
|
|
s_SynthFpo.cbRegs = 0;
|
|
s_SynthFpo.fHasSEH = 0;
|
|
s_SynthFpo.fUseBP = 0;
|
|
s_SynthFpo.reserved = 0;
|
|
s_SynthFpo.cbFrame = FRAME_NONFPO;
|
|
return &s_SynthFpo;
|
|
}
|
|
|
|
PFPO_DATA
|
|
SynthesizeFpoDataForFastSyscall(ULONG64 Offset)
|
|
{
|
|
static FPO_DATA s_FastFpo;
|
|
|
|
// XXX drewb - Temporary until the fake user-shared
|
|
// module is worked out.
|
|
|
|
s_FastFpo.ulOffStart = (ULONG)Offset;
|
|
s_FastFpo.cbProcSize = X86_SHARED_SYSCALL_SIZE;
|
|
s_FastFpo.cdwLocals = 0;
|
|
s_FastFpo.cdwParams = 0;
|
|
s_FastFpo.cbProlog = 0;
|
|
s_FastFpo.cbRegs = 0;
|
|
s_FastFpo.fHasSEH = 0;
|
|
s_FastFpo.fUseBP = 0;
|
|
s_FastFpo.reserved = 0;
|
|
s_FastFpo.cbFrame = FRAME_FPO;
|
|
return &s_FastFpo;
|
|
}
|
|
|
|
PFPO_DATA
|
|
ModifyFpoRecord(PDEBUG_IMAGE_INFO Image, PFPO_DATA FpoData)
|
|
{
|
|
if (FpoData->cdwLocals == 80)
|
|
{
|
|
static ULONG64 s_CommonDispatchException;
|
|
|
|
// Some versions of CommonDispatchException have
|
|
// the wrong locals size, which screws up stack
|
|
// traces. Detect and fix up these problems.
|
|
if (s_CommonDispatchException == 0)
|
|
{
|
|
GetOffsetFromSym("nt!CommonDispatchException",
|
|
&s_CommonDispatchException,
|
|
NULL);
|
|
}
|
|
|
|
if (Image->BaseOfImage + FpoData->ulOffStart ==
|
|
s_CommonDispatchException)
|
|
{
|
|
static FPO_DATA s_CdeFpo;
|
|
|
|
s_CdeFpo = *FpoData;
|
|
s_CdeFpo.cdwLocals = 20;
|
|
FpoData = &s_CdeFpo;
|
|
}
|
|
}
|
|
else if (FpoData->cdwLocals == 0 && FpoData->cdwParams == 0 &&
|
|
FpoData->cbRegs == 3)
|
|
{
|
|
static ULONG64 s_KiSwapThread;
|
|
|
|
// KiSwapThread has shrink-wrapping so that three registers
|
|
// are pushed in only a portion of the code. Unfortunately,
|
|
// the most important place in the code -- the call to
|
|
// KiSwapContext -- is outside of this region and therefore
|
|
// the register count is wrong much more often than it's
|
|
// correct. Switch the register count to two to make it
|
|
// correct more often than wrong.
|
|
if (s_KiSwapThread == 0)
|
|
{
|
|
GetOffsetFromSym("nt!KiSwapThread", &s_KiSwapThread, NULL);
|
|
}
|
|
|
|
if (Image->BaseOfImage + FpoData->ulOffStart ==
|
|
s_KiSwapThread)
|
|
{
|
|
static FPO_DATA s_KstFpo;
|
|
|
|
s_KstFpo = *FpoData;
|
|
s_KstFpo.cbRegs = 2;
|
|
FpoData = &s_KstFpo;
|
|
}
|
|
}
|
|
else if (FpoData->fHasSEH)
|
|
{
|
|
static FPO_DATA s_SehFpo;
|
|
|
|
s_SehFpo = *FpoData;
|
|
s_SehFpo.cbFrame = FRAME_NONFPO;
|
|
FpoData = &s_SehFpo;
|
|
}
|
|
|
|
return FpoData;
|
|
}
|
|
|
|
PFPO_DATA
|
|
FindFpoDataForModule(DWORD64 PCAddr)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Locates the fpo data structure in the process's linked list for the
|
|
requested module.
|
|
|
|
Arguments:
|
|
|
|
PCAddr - address contained in the program counter
|
|
|
|
Return Value:
|
|
|
|
null - could not locate the entry
|
|
valid address - found the entry at the adress retured
|
|
|
|
--*/
|
|
{
|
|
PPROCESS_INFO Process;
|
|
PDEBUG_IMAGE_INFO Image;
|
|
PFPO_DATA FpoData;
|
|
|
|
Process = g_CurrentProcess;
|
|
Image = Process->ImageHead;
|
|
FpoData = 0;
|
|
while (Image)
|
|
{
|
|
if ((PCAddr >= Image->BaseOfImage) &&
|
|
(PCAddr < Image->BaseOfImage + Image->SizeOfImage))
|
|
{
|
|
FpoData = (PFPO_DATA)
|
|
SymFunctionTableAccess(g_CurrentProcess->Handle, PCAddr);
|
|
if (!FpoData)
|
|
{
|
|
FpoData = SynthesizeFpoDataForModule(PCAddr);
|
|
}
|
|
else
|
|
{
|
|
FpoData = ModifyFpoRecord(Image, FpoData);
|
|
}
|
|
|
|
return FpoData;
|
|
}
|
|
|
|
Image = Image->Next;
|
|
}
|
|
|
|
ULONG64 FscBase;
|
|
|
|
switch(IsInFastSyscall(PCAddr, &FscBase))
|
|
{
|
|
case FSC_FOUND:
|
|
return SynthesizeFpoDataForFastSyscall(FscBase);
|
|
}
|
|
|
|
// the function is not part of any known loaded image
|
|
return NULL;
|
|
}
|
|
|
|
LPVOID
|
|
SwFunctionTableAccess(
|
|
HANDLE hProcess,
|
|
ULONG64 AddrBase
|
|
)
|
|
{
|
|
static IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY s_Axp32;
|
|
static IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY s_Axp64;
|
|
static IMAGE_IA64_RUNTIME_FUNCTION_ENTRY s_Ia64;
|
|
static _IMAGE_RUNTIME_FUNCTION_ENTRY s_Amd64;
|
|
|
|
PVOID pife;
|
|
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
return (LPVOID)FindFpoDataForModule( AddrBase );
|
|
}
|
|
|
|
pife = SymFunctionTableAccess64(hProcess, AddrBase);
|
|
|
|
switch (g_EffMachine)
|
|
{
|
|
case IMAGE_FILE_MACHINE_AXP64:
|
|
if (!pife)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
s_Axp64.BeginAddress =
|
|
((PIMAGE_FUNCTION_ENTRY64)pife)->StartingAddress;
|
|
s_Axp64.EndAddress =
|
|
((PIMAGE_FUNCTION_ENTRY64)pife)->EndingAddress;
|
|
s_Axp64.ExceptionHandler = 0;
|
|
s_Axp64.HandlerData = 0;
|
|
s_Axp64.PrologEndAddress =
|
|
((PIMAGE_FUNCTION_ENTRY64)pife)->EndOfPrologue;
|
|
return &s_Axp64;
|
|
|
|
case IMAGE_FILE_MACHINE_ALPHA:
|
|
if (!pife)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
s_Axp32.BeginAddress =
|
|
((PIMAGE_FUNCTION_ENTRY)pife)->StartingAddress;
|
|
s_Axp32.EndAddress =
|
|
((PIMAGE_FUNCTION_ENTRY)pife)->EndingAddress;
|
|
s_Axp32.ExceptionHandler = 0;
|
|
s_Axp32.HandlerData = 0;
|
|
s_Axp32.PrologEndAddress =
|
|
((PIMAGE_FUNCTION_ENTRY)pife)->EndOfPrologue;
|
|
return &s_Axp32;
|
|
|
|
case IMAGE_FILE_MACHINE_IA64:
|
|
if (pife)
|
|
{
|
|
s_Ia64 = *(PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY)pife;
|
|
return &s_Ia64;
|
|
}
|
|
else
|
|
{
|
|
if (IS_KERNEL_TARGET() &&
|
|
(AddrBase >= IA64_MM_EPC_VA) &&
|
|
(AddrBase < (IA64_MM_EPC_VA + IA64_PAGE_SIZE)))
|
|
{
|
|
return g_EpcRfe;
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IMAGE_FILE_MACHINE_AMD64:
|
|
if (pife)
|
|
{
|
|
s_Amd64 = *(_PIMAGE_RUNTIME_FUNCTION_ENTRY)pife;
|
|
return &s_Amd64;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
DWORD64
|
|
SwTranslateAddress(
|
|
HANDLE hProcess,
|
|
HANDLE hThread,
|
|
LPADDRESS64 lpaddress
|
|
)
|
|
{
|
|
//
|
|
// don't support 16bit stacks
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
|
|
BOOL
|
|
SwReadMemory32(
|
|
HANDLE hProcess,
|
|
ULONG dwBaseAddress,
|
|
LPVOID lpBuffer,
|
|
DWORD nSize,
|
|
LPDWORD lpNumberOfBytesRead
|
|
)
|
|
{
|
|
return SwReadMemory(hProcess,
|
|
EXTEND64(dwBaseAddress),
|
|
lpBuffer,
|
|
nSize,
|
|
lpNumberOfBytesRead);
|
|
}
|
|
|
|
BOOL
|
|
SwReadMemory(
|
|
HANDLE hProcess,
|
|
ULONG64 BaseAddress,
|
|
LPVOID lpBuffer,
|
|
DWORD nSize,
|
|
LPDWORD lpNumberOfBytesRead
|
|
)
|
|
{
|
|
DBG_ASSERT(hProcess == g_CurrentProcess->Handle);
|
|
|
|
if (IS_KERNEL_TARGET())
|
|
{
|
|
DWORD BytesRead;
|
|
HRESULT Status;
|
|
|
|
if ((LONG_PTR)lpNumberOfBytesRead == -1)
|
|
{
|
|
if (g_TargetMachineType == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
BaseAddress += g_TargetMachine->m_SizeTargetContext;
|
|
}
|
|
|
|
Status = g_Target->ReadControl(CURRENT_PROC,
|
|
(ULONG)BaseAddress,
|
|
lpBuffer,
|
|
nSize,
|
|
&BytesRead);
|
|
return Status == S_OK;
|
|
}
|
|
}
|
|
|
|
if (g_Target->ReadVirtual(BaseAddress, lpBuffer, nSize,
|
|
lpNumberOfBytesRead) != S_OK)
|
|
{
|
|
// Make sure bytes read is zero.
|
|
if (lpNumberOfBytesRead != NULL)
|
|
{
|
|
*lpNumberOfBytesRead = 0;
|
|
}
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
DWORD64
|
|
SwGetModuleBase(
|
|
HANDLE hProcess,
|
|
ULONG64 Address
|
|
)
|
|
{
|
|
PDEBUG_IMAGE_INFO Image = g_CurrentProcess->ImageHead;
|
|
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_IA64 &&
|
|
IS_KERNEL_TARGET() &&
|
|
(Address >= IA64_MM_EPC_VA) &&
|
|
(Address < (IA64_MM_EPC_VA + IA64_PAGE_SIZE)))
|
|
{
|
|
Address -= (IA64_MM_EPC_VA - g_SystemCallVirtualAddress);
|
|
}
|
|
|
|
while (Image)
|
|
{
|
|
if ((Address >= Image->BaseOfImage) &&
|
|
(Address < (Image->BaseOfImage + Image->SizeOfImage)))
|
|
{
|
|
return Image->BaseOfImage;
|
|
}
|
|
Image = Image->Next;
|
|
}
|
|
|
|
// If no regular module was found we need to look in
|
|
// the dynamic function tables to see if an entry
|
|
// there matches.
|
|
ULONG64 DynBase = g_Target->
|
|
GetDynamicFunctionTableBase(g_Machine, Address);
|
|
if (DynBase)
|
|
{
|
|
return DynBase;
|
|
}
|
|
|
|
if (IS_KERNEL_TARGET())
|
|
{
|
|
// If no modules have been loaded there's still a possibility
|
|
// of getting a kernel stack trace (without symbols) by going
|
|
// after the module base directly. This also makes it possible
|
|
// to get a stack trace when there are no symbols available.
|
|
|
|
if (g_CurrentProcess->ImageHead == NULL)
|
|
{
|
|
return GetKernelModuleBase( Address );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
SwGetModuleBase32(
|
|
HANDLE hProcess,
|
|
DWORD Address
|
|
)
|
|
{
|
|
return (DWORD)SwGetModuleBase(hProcess, Address);
|
|
}
|
|
|
|
|
|
void
|
|
PrintStackTraceHeaderLine(
|
|
ULONG Flags
|
|
)
|
|
{
|
|
if ( (Flags & DEBUG_STACK_COLUMN_NAMES) == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
StartOutLine(DEBUG_OUTPUT_NORMAL, OUT_LINE_NO_TIMESTAMP);
|
|
|
|
if (Flags & DEBUG_STACK_FRAME_NUMBERS)
|
|
{
|
|
dprintf(" # ");
|
|
}
|
|
|
|
if (Flags & DEBUG_STACK_FRAME_ADDRESSES)
|
|
{
|
|
g_Machine->PrintStackFrameAddressesTitle(Flags);
|
|
}
|
|
|
|
if (Flags & DEBUG_STACK_ARGUMENTS)
|
|
{
|
|
g_Machine->PrintStackArgumentsTitle(Flags);
|
|
}
|
|
|
|
g_Machine->PrintStackCallSiteTitle(Flags);
|
|
|
|
dprintf("\n");
|
|
}
|
|
|
|
VOID
|
|
PrintStackFrame(
|
|
PDEBUG_STACK_FRAME StackFrame,
|
|
ULONG Flags
|
|
)
|
|
{
|
|
DWORD64 displacement;
|
|
CHAR symbuf[MAX_SYMBOL_LEN];
|
|
USHORT StdCallArgs;
|
|
ULONG64 InstructionOffset = StackFrame->InstructionOffset;
|
|
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_IA64 &&
|
|
IS_KERNEL_TARGET() &&
|
|
(InstructionOffset >= IA64_MM_EPC_VA) &&
|
|
(InstructionOffset < (IA64_MM_EPC_VA + IA64_PAGE_SIZE)))
|
|
{
|
|
InstructionOffset = InstructionOffset -
|
|
(IA64_MM_EPC_VA - g_SystemCallVirtualAddress);
|
|
}
|
|
|
|
GetSymbolStdCall(InstructionOffset,
|
|
symbuf,
|
|
sizeof(symbuf),
|
|
&displacement,
|
|
&StdCallArgs);
|
|
|
|
|
|
StartOutLine(DEBUG_OUTPUT_NORMAL, OUT_LINE_NO_TIMESTAMP);
|
|
|
|
if (Flags & DEBUG_STACK_FRAME_NUMBERS)
|
|
{
|
|
dprintf("%02lx ", StackFrame->FrameNumber);
|
|
}
|
|
|
|
if (Flags & DEBUG_STACK_FRAME_ADDRESSES)
|
|
{
|
|
g_Machine->PrintStackFrameAddresses(Flags, StackFrame);
|
|
}
|
|
|
|
if (Flags & DEBUG_STACK_ARGUMENTS)
|
|
{
|
|
g_Machine->PrintStackArguments(Flags, StackFrame);
|
|
}
|
|
|
|
g_Machine->PrintStackCallSite(Flags, StackFrame,
|
|
symbuf, displacement,
|
|
StdCallArgs);
|
|
|
|
if (Flags & DEBUG_STACK_SOURCE_LINE)
|
|
{
|
|
OutputLineAddr(InstructionOffset, " [%s @ %d]");
|
|
}
|
|
|
|
dprintf( "\n" );
|
|
}
|
|
|
|
VOID
|
|
PrintStackTrace(
|
|
ULONG NumFrames,
|
|
PDEBUG_STACK_FRAME StackFrames,
|
|
ULONG Flags
|
|
)
|
|
{
|
|
ULONG i;
|
|
|
|
PrintStackTraceHeaderLine(Flags);
|
|
|
|
for (i = 0; i < NumFrames; i++)
|
|
{
|
|
PrintStackFrame(StackFrames + i, Flags);
|
|
}
|
|
}
|
|
|
|
void
|
|
GetStkTraceArgsForCurrentScope(
|
|
PULONG64 FramePointer,
|
|
PULONG64 StackPointer,
|
|
PULONG64 InstructionPointer,
|
|
PCROSS_PLATFORM_CONTEXT ContextCopyPointer
|
|
)
|
|
{
|
|
PCROSS_PLATFORM_CONTEXT ScopeContext = GetCurrentScopeContext();
|
|
if (ScopeContext != NULL)
|
|
{
|
|
g_Machine->PushContext(ScopeContext);
|
|
|
|
switch (g_EffMachine)
|
|
{
|
|
case IMAGE_FILE_MACHINE_I386:
|
|
if (*InstructionPointer == 0)
|
|
{
|
|
*InstructionPointer = g_Machine->GetReg64(X86_EIP);
|
|
}
|
|
if (*StackPointer == 0)
|
|
{
|
|
*StackPointer = g_Machine->GetReg64(X86_ESP);
|
|
}
|
|
if (*FramePointer == 0)
|
|
{
|
|
*FramePointer = g_Machine->GetReg64(X86_EBP);
|
|
}
|
|
break;
|
|
|
|
case IMAGE_FILE_MACHINE_IA64:
|
|
*InstructionPointer = g_Machine->GetReg64(STIIP);
|
|
*StackPointer = g_Machine->GetReg64(INTSP);
|
|
*FramePointer = g_Machine->GetReg64(RSBSP);
|
|
break;
|
|
|
|
case IMAGE_FILE_MACHINE_AXP64:
|
|
case IMAGE_FILE_MACHINE_ALPHA:
|
|
*InstructionPointer = g_Machine->GetReg64(ALPHA_FIR);
|
|
*StackPointer = g_Machine->GetReg64(SP_REG);
|
|
*FramePointer = g_Machine->GetReg64(FP_REG);
|
|
break;
|
|
|
|
case IMAGE_FILE_MACHINE_AMD64:
|
|
*InstructionPointer = g_Machine->GetReg64(AMD64_RIP);
|
|
*StackPointer = g_Machine->GetReg64(AMD64_RSP);
|
|
*FramePointer = g_Machine->GetReg64(AMD64_RBP);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (ContextCopyPointer)
|
|
{
|
|
*ContextCopyPointer = g_Machine->m_Context;
|
|
}
|
|
g_Machine->PopContext();
|
|
}
|
|
else
|
|
{
|
|
if (ContextCopyPointer)
|
|
{
|
|
*ContextCopyPointer = g_Machine->m_Context;
|
|
}
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
StackTrace(
|
|
ULONG64 FramePointer,
|
|
ULONG64 StackPointer,
|
|
ULONG64 InstructionPointer,
|
|
PDEBUG_STACK_FRAME StackFrames,
|
|
ULONG NumFrames,
|
|
ULONG64 ExtThread,
|
|
ULONG Flags,
|
|
BOOL EstablishingScope
|
|
)
|
|
{
|
|
STACKFRAME64 VirtualFrame;
|
|
DWORD i;
|
|
CROSS_PLATFORM_CONTEXT Context;
|
|
PVOID FunctionEntry;
|
|
ULONG64 Value;
|
|
ULONG result;
|
|
BOOL SymWarning = FALSE;
|
|
ULONG X86Ebp;
|
|
|
|
if (!EstablishingScope)
|
|
{
|
|
RequireCurrentScope();
|
|
}
|
|
|
|
//
|
|
// let's start clean
|
|
//
|
|
ZeroMemory( StackFrames, sizeof(StackFrames[0]) * NumFrames );
|
|
ZeroMemory( &VirtualFrame, sizeof(VirtualFrame) );
|
|
|
|
if (g_Machine->GetContextState(MCTX_FULL) != S_OK)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ULONG Seg;
|
|
|
|
if ((!FramePointer && !InstructionPointer && !StackPointer) ||
|
|
(g_EffMachine == IMAGE_FILE_MACHINE_I386))
|
|
{
|
|
// Do the default stack trace for current debug context
|
|
// For x86, set these if any of them is 0
|
|
GetStkTraceArgsForCurrentScope(&FramePointer, &StackPointer,
|
|
&InstructionPointer, &Context);
|
|
}
|
|
|
|
if (IS_KERNEL_TARGET())
|
|
{
|
|
//
|
|
// if debugger was initialized at boot, usermode addresses needed for
|
|
// stack traces on IA64 were not available. Try it now:
|
|
//
|
|
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_IA64 &&
|
|
!KdDebuggerData.KeUserCallbackDispatcher)
|
|
{
|
|
VerifyKernelBase (FALSE);
|
|
}
|
|
|
|
ULONG64 ThreadData;
|
|
|
|
// If no explicit thread is given then we use the
|
|
// current thread. However, the current thread is only
|
|
// valid if the current thread is the event thread since
|
|
// tracing back into user mode requires that the appropriate
|
|
// user-mode memory state be active.
|
|
if (ExtThread != 0)
|
|
{
|
|
ThreadData = ExtThread;
|
|
}
|
|
else if (g_CurrentProcess->CurrentThread != g_EventThread ||
|
|
g_CurrentProcess != g_EventProcess ||
|
|
GetImplicitThreadData(&ThreadData) != S_OK)
|
|
{
|
|
ThreadData = 0;
|
|
}
|
|
|
|
VirtualFrame.KdHelp.Thread = ThreadData;
|
|
VirtualFrame.KdHelp.ThCallbackStack = ThreadData ?
|
|
KdDebuggerData.ThCallbackStack : 0;
|
|
VirtualFrame.KdHelp.KiCallUserMode = KdDebuggerData.KiCallUserMode;
|
|
VirtualFrame.KdHelp.NextCallback = KdDebuggerData.NextCallback;
|
|
VirtualFrame.KdHelp.KeUserCallbackDispatcher =
|
|
KdDebuggerData.KeUserCallbackDispatcher;
|
|
VirtualFrame.KdHelp.FramePointer = KdDebuggerData.FramePointer;
|
|
VirtualFrame.KdHelp.SystemRangeStart = g_SystemRangeStart;
|
|
}
|
|
|
|
//
|
|
// setup the program counter
|
|
//
|
|
if (!InstructionPointer)
|
|
{
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
ADDR Addr;
|
|
|
|
VirtualFrame.AddrPC.Mode = AddrModeFlat;
|
|
g_Machine->GetPC(&Addr);
|
|
VirtualFrame.AddrPC.Segment = Addr.seg;
|
|
VirtualFrame.AddrPC.Offset = Flat(Addr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VirtualFrame.AddrPC.Mode = AddrModeFlat;
|
|
Seg = g_Machine->GetSegRegNum(SEGREG_CODE);
|
|
VirtualFrame.AddrPC.Segment =
|
|
Seg ? (WORD)GetRegVal32(Seg) : 0;
|
|
VirtualFrame.AddrPC.Offset = InstructionPointer;
|
|
}
|
|
|
|
//
|
|
// setup the frame pointer
|
|
//
|
|
if (!FramePointer)
|
|
{
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
ADDR Addr;
|
|
|
|
VirtualFrame.AddrFrame.Mode = AddrModeFlat;
|
|
g_Machine->GetFP(&Addr);
|
|
VirtualFrame.AddrFrame.Segment = Addr.seg;
|
|
VirtualFrame.AddrFrame.Offset = Flat(Addr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VirtualFrame.AddrFrame.Mode = AddrModeFlat;
|
|
Seg = g_Machine->GetSegRegNum(SEGREG_STACK);
|
|
VirtualFrame.AddrFrame.Segment =
|
|
Seg ? (WORD)GetRegVal32(Seg) : 0;
|
|
VirtualFrame.AddrFrame.Offset = FramePointer;
|
|
}
|
|
VirtualFrame.AddrBStore = VirtualFrame.AddrFrame;
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
X86Ebp = (ULONG) VirtualFrame.AddrFrame.Offset;
|
|
}
|
|
|
|
//
|
|
// setup the stack pointer
|
|
//
|
|
if (!StackPointer)
|
|
{
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
ADDR Addr;
|
|
|
|
VirtualFrame.AddrStack.Mode = AddrModeFlat;
|
|
g_Machine->GetSP(&Addr);
|
|
VirtualFrame.AddrStack.Segment = Addr.seg;
|
|
VirtualFrame.AddrStack.Offset = Flat(Addr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VirtualFrame.AddrStack.Mode = AddrModeFlat;
|
|
Seg = g_Machine->GetSegRegNum(SEGREG_STACK);
|
|
VirtualFrame.AddrStack.Segment =
|
|
Seg ? (WORD)GetRegVal32(Seg) : 0;
|
|
VirtualFrame.AddrStack.Offset = StackPointer;
|
|
}
|
|
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_IA64 &&
|
|
IS_KERNEL_TARGET() &&
|
|
g_SystemCallVirtualAddress)
|
|
{
|
|
PVOID functionEntry;
|
|
ULONG numberOfBytesRead;
|
|
|
|
functionEntry = SwFunctionTableAccess (g_CurrentProcess->Handle,
|
|
g_SystemCallVirtualAddress);
|
|
if (functionEntry != NULL)
|
|
{
|
|
RtlCopyMemory(&g_EpcRfeBuffer, functionEntry,
|
|
sizeof(IMAGE_IA64_RUNTIME_FUNCTION_ENTRY));
|
|
g_EpcRfe = &g_EpcRfeBuffer;
|
|
}
|
|
else
|
|
{
|
|
g_EpcRfe = NULL;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < NumFrames; i++)
|
|
{
|
|
// SwReadMemory doesn't currently use the thread handle
|
|
// but send in something reasonable in case of future changes.
|
|
if (!StackWalk64(g_EffMachine,
|
|
g_CurrentProcess->Handle,
|
|
OS_HANDLE(g_CurrentProcess->CurrentThread->Handle),
|
|
&VirtualFrame,
|
|
&Context,
|
|
SwReadMemory,
|
|
SwFunctionTableAccess,
|
|
SwGetModuleBase,
|
|
SwTranslateAddress))
|
|
{
|
|
break;
|
|
}
|
|
|
|
StackFrames[i].InstructionOffset = VirtualFrame.AddrPC.Offset;
|
|
StackFrames[i].ReturnOffset = VirtualFrame.AddrReturn.Offset;
|
|
StackFrames[i].FrameOffset = VirtualFrame.AddrFrame.Offset;
|
|
StackFrames[i].StackOffset = VirtualFrame.AddrStack.Offset;
|
|
StackFrames[i].FuncTableEntry = (ULONG64)VirtualFrame.FuncTableEntry;
|
|
StackFrames[i].Virtual = VirtualFrame.Virtual;
|
|
StackFrames[i].FrameNumber = i;
|
|
|
|
// NOTE - we have more reserved space in the DEBUG_STACK_FRAME
|
|
memcpy(StackFrames[i].Reserved, VirtualFrame.Reserved,
|
|
sizeof(VirtualFrame.Reserved));
|
|
memcpy(StackFrames[i].Params, VirtualFrame.Params,
|
|
sizeof(VirtualFrame.Params));
|
|
|
|
if (g_EffMachine == IMAGE_FILE_MACHINE_IA64 &&
|
|
IS_KERNEL_TARGET())
|
|
{
|
|
if ((VirtualFrame.AddrPC.Offset >= IA64_MM_EPC_VA) &&
|
|
(VirtualFrame.AddrPC.Offset <
|
|
(IA64_MM_EPC_VA + IA64_PAGE_SIZE)))
|
|
{
|
|
VirtualFrame.AddrPC.Offset -=
|
|
(IA64_MM_EPC_VA - g_SystemCallVirtualAddress);
|
|
}
|
|
|
|
if ((i != 0) &&
|
|
(StackFrames[i - 1].InstructionOffset >= IA64_MM_EPC_VA) &&
|
|
(VirtualFrame.AddrPC.Offset <
|
|
(IA64_MM_EPC_VA + IA64_PAGE_SIZE)))
|
|
{
|
|
StackFrames[i - 1].ReturnOffset =
|
|
VirtualFrame.AddrPC.Offset;
|
|
}
|
|
} else if (g_EffMachine == IMAGE_FILE_MACHINE_I386)
|
|
{
|
|
if (StackFrames[i].FuncTableEntry)
|
|
{
|
|
PFPO_DATA FpoData = (PFPO_DATA)StackFrames[i].FuncTableEntry;
|
|
if (FpoData->cbFrame == FRAME_FPO &&
|
|
!FpoData->fUseBP)
|
|
{
|
|
SAVE_EBP(&StackFrames[i]) = (ULONG64) (LONG64) (LONG) X86Ebp;
|
|
}
|
|
|
|
}
|
|
X86Ebp = Context.X86Context.Ebp;
|
|
}
|
|
|
|
|
|
if (Flags && i == 0)
|
|
{
|
|
PrintStackTraceHeaderLine(Flags);
|
|
}
|
|
|
|
IMAGEHLP_MODULE64 Mod;
|
|
|
|
// If the current frame's PC is in a loaded module and
|
|
// that module does not have symbols it's very possible
|
|
// that the stack trace will be incorrect since the
|
|
// debugger has to guess about how to unwind the stack.
|
|
// Non-x86 architectures have unwind info in the images
|
|
// themselves so restrict this check to x86.
|
|
Mod.SizeOfStruct = sizeof(Mod);
|
|
if (!SymWarning &&
|
|
NumFrames > 1 &&
|
|
g_EffMachine == IMAGE_FILE_MACHINE_I386 &&
|
|
StackFrames[i].InstructionOffset != -1 &&
|
|
SymGetModuleInfo64(g_CurrentProcess->Handle,
|
|
StackFrames[i].InstructionOffset, &Mod) &&
|
|
(Mod.SymType == SymNone || Mod.SymType == SymExport ||
|
|
Mod.SymType == SymDeferred))
|
|
{
|
|
WarnOut("WARNING: Stack unwind information not available. "
|
|
"Following frames may be wrong.\n");
|
|
// Only show one warning per trace.
|
|
SymWarning = TRUE;
|
|
}
|
|
|
|
if (Flags)
|
|
{
|
|
PrintStackFrame(StackFrames + i, Flags);
|
|
|
|
if (Flags & DEBUG_STACK_NONVOLATILE_REGISTERS)
|
|
{
|
|
g_Machine->PrintStackNonvolatileRegisters(Flags,
|
|
StackFrames + i,
|
|
&Context, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
#define BASIC_STACK \
|
|
(DEBUG_STACK_COLUMN_NAMES | DEBUG_STACK_FRAME_ADDRESSES | \
|
|
DEBUG_STACK_SOURCE_LINE)
|
|
|
|
ULONG g_StackTraceTypeFlags[STACK_TRACE_TYPE_MAX] =
|
|
{
|
|
BASIC_STACK, // Default
|
|
BASIC_STACK | DEBUG_STACK_ARGUMENTS, // kb
|
|
BASIC_STACK | DEBUG_STACK_ARGUMENTS | DEBUG_STACK_FUNCTION_INFO |
|
|
DEBUG_STACK_NONVOLATILE_REGISTERS, // kv
|
|
0, // kd
|
|
BASIC_STACK | DEBUG_STACK_PARAMETERS, // kp
|
|
BASIC_STACK | DEBUG_STACK_FRAME_NUMBERS, // kn
|
|
BASIC_STACK | DEBUG_STACK_ARGUMENTS | DEBUG_STACK_FRAME_NUMBERS, // kbn
|
|
BASIC_STACK | DEBUG_STACK_ARGUMENTS | DEBUG_STACK_FUNCTION_INFO |
|
|
DEBUG_STACK_NONVOLATILE_REGISTERS | DEBUG_STACK_FRAME_NUMBERS,// kvn
|
|
DEBUG_STACK_FRAME_NUMBERS, // kdn
|
|
BASIC_STACK | DEBUG_STACK_PARAMETERS | DEBUG_STACK_FRAME_NUMBERS // kpn
|
|
};
|
|
|
|
VOID
|
|
DoStackTrace(
|
|
ULONG64 FramePointer,
|
|
ULONG64 StackPointer,
|
|
ULONG64 InstructionPointer,
|
|
ULONG NumFrames,
|
|
STACK_TRACE_TYPE TraceType
|
|
)
|
|
{
|
|
PDEBUG_STACK_FRAME StackFrames;
|
|
ULONG NumFramesToRead;
|
|
DWORD FrameCount;
|
|
|
|
if (NumFrames == 0)
|
|
{
|
|
NumFrames = g_DefaultStackTraceDepth;
|
|
}
|
|
|
|
if (TraceType == STACK_TRACE_TYPE_KD)
|
|
{
|
|
NumFramesToRead = 1;
|
|
}
|
|
else
|
|
{
|
|
NumFramesToRead = NumFrames;
|
|
}
|
|
|
|
StackFrames = (PDEBUG_STACK_FRAME)
|
|
malloc( sizeof(StackFrames[0]) * NumFramesToRead );
|
|
if (!StackFrames)
|
|
{
|
|
ErrOut( "could not allocate memory for stack trace\n" );
|
|
return;
|
|
}
|
|
|
|
ULONG Flags = g_StackTraceTypeFlags[TraceType];
|
|
|
|
if ((TraceType == STACK_TRACE_TYPE_KB) && g_Machine->m_Ptr64)
|
|
{
|
|
Flags |= DEBUG_STACK_FRAME_ADDRESSES_RA_ONLY;
|
|
}
|
|
|
|
FrameCount = StackTrace( FramePointer,
|
|
StackPointer,
|
|
InstructionPointer,
|
|
StackFrames,
|
|
NumFramesToRead,
|
|
0,
|
|
Flags,
|
|
FALSE
|
|
);
|
|
|
|
if (FrameCount == 0)
|
|
{
|
|
ErrOut( "could not fetch any stack frames\n" );
|
|
free(StackFrames);
|
|
return;
|
|
}
|
|
|
|
if (TraceType == STACK_TRACE_TYPE_KD)
|
|
{
|
|
// Starting with the stack pointer, dump NumFrames DWORD's
|
|
// and the symbol if possible.
|
|
|
|
ADDR startAddr;
|
|
ADDRFLAT(&startAddr, StackFrames[0].FrameOffset);
|
|
|
|
fnDumpDwordMemory(&startAddr, NumFrames, TRUE);
|
|
}
|
|
|
|
free( StackFrames );
|
|
}
|