windows-xp/Source/XPSP1/NT/sdktools/debuggers/ntsd64/stkwalk.cpp

//----------------------------------------------------------------------------
//
// 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 );
}