// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

//*****************************************************************************

// File: frameinfo.cpp

//

//

// Code to find control info about a stack frame.

//

//*****************************************************************************

#include "stdafx.h"

// Include so we can get information out of ComMethodFrame

#ifdef FEATURE_COMINTEROP

#include "COMToClrCall.h"

#endif

// Get a frame pointer from a RegDisplay.

// This is mostly used for chains and stub frames (i.e. internal frames), where we don't need an exact

// frame pointer. This is why it is okay to use the current SP instead of the caller SP on IA64.

// We should really rename this and possibly roll it into GetFramePointer() when we move the stackwalker

// to OOP.

FramePointer GetSP(REGDISPLAY * pRDSrc)

{

FramePointer fp = FramePointer::MakeFramePointer(

(LPVOID)GetRegdisplaySP(pRDSrc));

return fp;

}

// Get a frame pointer from a RegDisplay.

FramePointer GetFramePointer(REGDISPLAY * pRDSrc)

{

return FramePointer::MakeFramePointer(GetRegdisplaySP(pRDSrc));

}

//---------------------------------------------------------------------------------------

//

// Convert a FramePointer to a StackFrame and return it.

//

// Arguments:

// fp - the FramePointer to be converted

//

// Return Value:

// a StackFrame equivalent to the given FramePointer

//

// Notes:

// We really should consolidate the two abstractions for "stack frame identifiers"

// (StackFrame and FramePointer) when we move the debugger stackwalker to OOP.

//

FORCEINLINE StackFrame ConvertFPToStackFrame(FramePointer fp)

{

return StackFrame((UINT_PTR)fp.GetSPValue());

}

/* ------------------------------------------------------------------------- *

* DebuggerFrameInfo routines

* ------------------------------------------------------------------------- */

//struct DebuggerFrameData: Contains info used by the DebuggerWalkStackProc

// to do a stack walk. The info and pData fields are handed to the pCallback

// routine at each frame,

struct DebuggerFrameData

{

// Initialize this struct. Only done at the start of a stackwalk.

void Init(

Thread * _pThread,

FramePointer _targetFP,

BOOL fIgnoreNonmethodFrames, // generally true for stackwalking and false for stepping

DebuggerStackCallback _pCallback,

void *_pData

)

{

LIMITED_METHOD_CONTRACT;

this->pCallback = _pCallback;

this->pData = _pData;

this->cRealCounter = 0;

this->thread = _pThread;

this->targetFP = _targetFP;

this->targetFound = (_targetFP == LEAF_MOST_FRAME);

this->ignoreNonmethodFrames = fIgnoreNonmethodFrames;

// For now, we can tie these to flags together.

// In everett, we disable SIS (For backwards compat).

this->fProvideInternalFrames = (fIgnoreNonmethodFrames != 0);

this->fNeedToSendEnterManagedChain = false;

this->fTrackingUMChain = false;

this->fHitExitFrame = false;

this->info.eStubFrameType = STUBFRAME_NONE;

this->info.quickUnwind = false;

this->info.frame = NULL;

this->needParentInfo = false;

#ifdef FEATURE_EH_FUNCLETS

this->fpParent = LEAF_MOST_FRAME;

this->info.fIsLeaf = true;

this->info.fIsFunclet = false;

this->info.fIsFilter = false;

#endif // FEATURE_EH_FUNCLETS

// Look strange? Go to definition of this field. I dare you.

this->info.fIgnoreThisFrameIfSuppressingUMChainFromComPlusMethodFrameGeneric = false;

#if defined(_DEBUG)

this->previousFP = LEAF_MOST_FRAME;

#endif // _DEBUG

}

// True if we need the next CrawlFrame to fill out part of this FrameInfo's data.

bool needParentInfo;

// The FrameInfo that we'll dispatch to the pCallback. This matches against

// the CrawlFrame for that frame that the callback belongs too.

FrameInfo info;

// Regdisplay that the EE stackwalker is updating.

REGDISPLAY regDisplay;

#ifdef FEATURE_EH_FUNCLETS

// This is used to skip funclets in a stackwalk. It marks the frame pointer to which we should skip.

FramePointer fpParent;

#endif // FEATURE_EH_FUNCLETS

#if defined(_DEBUG)

// For debugging, track the previous FramePointer so we can assert that we're

// making progress through the stack.

FramePointer previousFP;

#endif // _DEBUG

// whether we have hit an exit frame or not (i.e. a M2U frame)

bool fHitExitFrame;

private:

// The scope of this field is each section of managed method frames on the stack.

bool fNeedToSendEnterManagedChain;

// Flag set when we first stack-walk to decide if we want to ignore certain frames.

// Stepping doesn't ignore these frames; end user stacktraces do.

BOOL ignoreNonmethodFrames;

// Do we want callbacks for internal frames?

// Steppers generally don't. User stack-walk does.

bool fProvideInternalFrames;

// Info for tracking unmanaged chains.

// We track the starting (leaf) context for an unmanaged chain, as well as the

// ending (root) framepointer.

bool fTrackingUMChain;

REGDISPLAY rdUMChainStart;

FramePointer fpUMChainEnd;

// Thread that the stackwalk is for.

Thread *thread;

// Target FP indicates at what point in the stackwalk we'll start dispatching callbacks.

// Naturally, if this is LEAF_MOST_FRAME, then all callbacks will be dispatched

FramePointer targetFP;

bool targetFound;

// Count # of callbacks we could have dispatched (assuming targetFP==LEAF_MOST_FRAME).

// Useful for detecting leaf.

int cRealCounter;

// Callback & user-data supplied to that callback.

DebuggerStackCallback pCallback;

void *pData;

private:

// Raw invoke. This just does some consistency asserts,

// and invokes the callback if we're in the requested target range.

StackWalkAction RawInvokeCallback(FrameInfo * pInfo)

{

#ifdef _DEBUG

_ASSERTE(pInfo != NULL);

MethodDesc * md = pInfo->md;

// Invoke the callback to the user. Log what we're invoking.

LOG((LF_CORDB, LL_INFO10000, "DSWCallback: MD=%s,0x%p, Chain=%x, Stub=%x, Frame=0x%p, Internal=%d\n",

((md == NULL) ? "None" : md->m_pszDebugMethodName), md,

pInfo->chainReason,

pInfo->eStubFrameType,

pInfo->frame, pInfo->internal));

// Make sure we're providing a valid FrameInfo for the callback.

pInfo->AssertValid();

#endif

// Update counter. This provides a convenient check for leaf FrameInfo.

this->cRealCounter++;

// Only invoke if we're past the target.

if (!this->targetFound && IsEqualOrCloserToLeaf(this->targetFP, this->info.fp))

{

this->targetFound = true;

}

if (this->targetFound)

{

return (pCallback)(pInfo, pData);

}

else

{

LOG((LF_CORDB, LL_INFO10000, "Not invoking yet.\n"));

}

return SWA_CONTINUE;

}

public:

// Invoke a callback. This may do extra logic to preserve the interface between

// the LS stackwalker and the LS:

// - don't invoke if we're not at the target yet

// - send EnterManagedChains if we need it.

StackWalkAction InvokeCallback(FrameInfo * pInfo)

{

// Track if we've sent any managed code yet.

// If we haven't, then don't send the enter-managed chain. This catches cases

// when we have leaf-most unmanaged chain.

if ((pInfo->frame == NULL) && (pInfo->md != NULL))

{

this->fNeedToSendEnterManagedChain = true;

}

// Do tracking to decide if we need to send a Enter-Managed chain.

if (pInfo->HasChainMarker())

{

if (pInfo->managed)

{

// If we're dispatching a managed-chain, then we don't need to send another one.

fNeedToSendEnterManagedChain = false;

}

else

{

// If we're dispatching an UM chain, then send the Managed one.

// Note that the only unmanaged chains are ThreadStart chains and UM chains.

if (fNeedToSendEnterManagedChain)

{

fNeedToSendEnterManagedChain = false;

FrameInfo f;

// Assume entry chain's FP is one pointer-width after the upcoming UM chain.

FramePointer fpRoot = FramePointer::MakeFramePointer(

(BYTE*) GetRegdisplaySP(&pInfo->registers) - sizeof(DWORD*));

f.InitForEnterManagedChain(fpRoot);

if (RawInvokeCallback(&f) == SWA_ABORT)

{

return SWA_ABORT;

}

}

}

}

return RawInvokeCallback(pInfo);

}

// Note that we should start tracking an Unmanaged Chain.

void BeginTrackingUMChain(FramePointer fpRoot, REGDISPLAY * pRDSrc)

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(!this->fTrackingUMChain);

CopyREGDISPLAY(&this->rdUMChainStart, pRDSrc);

this->fTrackingUMChain = true;

this->fpUMChainEnd = fpRoot;

this->fHitExitFrame = false;

LOG((LF_CORDB, LL_EVERYTHING, "UM Chain starting at Frame=0x%p\n", this->fpUMChainEnd.GetSPValue()));

// This UM chain may get cancelled later, so don't even worry about toggling the fNeedToSendEnterManagedChain bit here.

// Invoke() will track whether to send an Enter-Managed chain or not.

}

// For various heuristics, we may not want to send an UM chain.

void CancelUMChain()

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(this->fTrackingUMChain);

this->fTrackingUMChain = false;

}

// True iff we're currently tracking an unmanaged chain.

bool IsTrackingUMChain()

{

LIMITED_METHOD_CONTRACT;

return this->fTrackingUMChain;

}

// Get/Set Regdisplay that starts an Unmanaged chain.

REGDISPLAY * GetUMChainStartRD()

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(fTrackingUMChain);

return &rdUMChainStart;

}

// Get/Set FramePointer that ends an unmanaged chain.

void SetUMChainEnd(FramePointer fp)

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(fTrackingUMChain);

fpUMChainEnd = fp;

}

FramePointer GetUMChainEnd()

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(fTrackingUMChain);

return fpUMChainEnd;

}

// Get thread we're currently tracing.

Thread * GetThread()

{

LIMITED_METHOD_CONTRACT;

return thread;

}

// Returns true if we're on the leaf-callback (ie, we haven't dispatched a callback yet.

bool IsLeafCallback()

{

LIMITED_METHOD_CONTRACT;

return cRealCounter == 0;

}

bool ShouldProvideInternalFrames()

{

LIMITED_METHOD_CONTRACT;

return fProvideInternalFrames;

}

bool ShouldIgnoreNonmethodFrames()

{

LIMITED_METHOD_CONTRACT;

return ignoreNonmethodFrames != 0;

}

};

//---------------------------------------------------------------------------------------

//

// On IA64, the offset given by the OS during stackwalking is actually the offset at the call instruction.

// This is different from x86 and X64, where the offset is immediately after the call instruction. In order

// to have a uniform behaviour, we need to do adjust the relative offset on IA64. This function is a nop on

// other platforms.

//

// Arguments:

// pCF - the CrawlFrame for the current method frame

// pInfo - This is the FrameInfo for the current method frame. We need to use the fIsLeaf field,

// since no adjustment is necessary for leaf frames.

//

// Return Value:

// returns the adjusted relative offset

//

inline ULONG AdjustRelOffset(CrawlFrame *pCF,

FrameInfo *pInfo)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

PRECONDITION(pCF != NULL);

}

CONTRACTL_END;

#if defined(_TARGET_ARM_)

return pCF->GetRelOffset() & ~THUMB_CODE;

#else

return pCF->GetRelOffset();

#endif

}

//---------------------------------------------------------------------------------------

//

// Even when there is an exit frame in the explicit frame chain, it does not necessarily mean that we have

// actually called out to unmanaged code yet or that we actually have a managed call site. Given an exit

// frame, this function determines if we have a managed call site and have already called out to unmanaged

// code. If we have, then we return the caller SP as the potential frame pointer. Otherwise we return

// LEAF_MOST_FRAME.

//

// Arguments:

// pFrame - the exit frame to be checked

// pData - the state of the current frame maintained by the debugger stackwalker

// pPotentialFP - This is an out parameter. It returns the caller SP of the last managed caller if

// there is a managed call site and we have already called out to unmanaged code.

// Otherwise, LEAF_MOST_FRAME is returned.

//

// Return Value:

// true - we have a managed call site and we have called out to unmanaged code

// false - otherwise

//

bool HasExitRuntime(Frame *pFrame, DebuggerFrameData *pData, FramePointer *pPotentialFP)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER; // Callers demand this function be GC_NOTRIGGER.

MODE_ANY;

PRECONDITION(pFrame->GetFrameType() == Frame::TYPE_EXIT);

}

CONTRACTL_END;

#ifdef _TARGET_X86_

TADDR returnIP, returnSP;

EX_TRY

{

// This is a real issue. This may be called while holding GC-forbid locks, and so

// this function can't trigger a GC. However, the only impl we have calls GC-trigger functions.

CONTRACT_VIOLATION(GCViolation);

pFrame->GetUnmanagedCallSite(NULL, &returnIP, &returnSP);

}

EX_CATCH

{

// We never expect an actual exception here (maybe in oom).

// If we get an exception, then simulate the default behavior for GetUnmanagedCallSite.

returnIP = NULL;

returnSP = NULL; // this will cause us to return true.

}

EX_END_CATCH(SwallowAllExceptions);

LOG((LF_CORDB, LL_INFO100000,

"DWSP: TYPE_EXIT: returnIP=0x%08x, returnSP=0x%08x, frame=0x%08x, threadFrame=0x%08x, regSP=0x%08x\n",

returnIP, returnSP, pFrame, pData->GetThread()->GetFrame(), GetRegdisplaySP(&pData->regDisplay)));

if (pPotentialFP != NULL)

{

*pPotentialFP = FramePointer::MakeFramePointer((void*)returnSP);

}

return ((pFrame != pData->GetThread()->GetFrame()) ||

(returnSP == NULL) ||

((TADDR)GetRegdisplaySP(&pData->regDisplay) <= returnSP));

#else // _TARGET_X86_

// DebuggerExitFrame always return a NULL returnSP on x86.

if (pFrame->GetVTablePtr() == DebuggerExitFrame::GetMethodFrameVPtr())

{

if (pPotentialFP != NULL)

{

*pPotentialFP = LEAF_MOST_FRAME;

}

return true;

}

else if (pFrame->GetVTablePtr() == InlinedCallFrame::GetMethodFrameVPtr())

{

InlinedCallFrame *pInlinedFrame = static_cast<InlinedCallFrame *>(pFrame);

LPVOID sp = (LPVOID)pInlinedFrame->GetCallSiteSP();

// The sp returned below is the sp of the caller, which is either an IL stub in the normal case

// or a normal managed method in the inlined pinvoke case.

// This sp may be the same as the frame's address, so we need to use the largest

// possible bsp value to make sure that this frame pointer is closer to the root than

// the frame pointer made from the frame address itself.

if (pPotentialFP != NULL)

{

*pPotentialFP = FramePointer::MakeFramePointer( (LPVOID)sp );

}

return ((pFrame != pData->GetThread()->GetFrame()) ||

InlinedCallFrame::FrameHasActiveCall(pInlinedFrame));

}

else

{

// It'll be nice if there's a way to assert that the current frame is indeed of a

// derived class of TransitionFrame.

TransitionFrame *pTransFrame = static_cast<TransitionFrame*>(pFrame);

LPVOID sp = (LPVOID)pTransFrame->GetSP();

// The sp returned below is the sp of the caller, which is either an IL stub in the normal case

// or a normal managed method in the inlined pinvoke case.

// This sp may be the same as the frame's address, so we need to use the largest

// possible bsp value to make sure that this frame pointer is closer to the root than

// the frame pointer made from the frame address itself.

if (pPotentialFP != NULL)

{

*pPotentialFP = FramePointer::MakeFramePointer( (LPVOID)sp );

}

return true;

}

#endif // _TARGET_X86_

}

#ifdef _DEBUG

//-----------------------------------------------------------------------------

// Debug helpers to get name of Frame.

//-----------------------------------------------------------------------------

LPCUTF8 FrameInfo::DbgGetClassName()

{

return (md == NULL) ? ("None") : (md->m_pszDebugClassName);

}

LPCUTF8 FrameInfo::DbgGetMethodName()

{

return (md == NULL) ? ("None") : (md->m_pszDebugMethodName);

}

//-----------------------------------------------------------------------------

// Debug helper to asserts invariants about a FrameInfo before we dispatch it.

//-----------------------------------------------------------------------------

void FrameInfo::AssertValid()

{

LIMITED_METHOD_CONTRACT;

bool fMethod = this->HasMethodFrame();

bool fStub = this->HasStubFrame();

bool fChain = this->HasChainMarker();

// Can't be both Stub & Chain

_ASSERTE(!fStub || !fChain);

// Must be at least a Method, Stub or Chain or Internal

_ASSERTE(fMethod || fStub || fChain || this->internal);

// Check Managed status is consistent

if (fMethod)

{

_ASSERTE(this->managed); // We only report managed methods

}

if (fChain)

{

if (!managed)

{

// Only certain chains can be unmanaged

_ASSERTE((this->chainReason == CHAIN_THREAD_START) ||

(this->chainReason == CHAIN_ENTER_UNMANAGED));

}

else

{

// UM chains can never be managed.

_ASSERTE((this->chainReason != CHAIN_ENTER_UNMANAGED));

}

}

// FramePointer should be valid

_ASSERTE(this->fp != LEAF_MOST_FRAME);

_ASSERTE((this->fp != ROOT_MOST_FRAME) || (chainReason== CHAIN_THREAD_START) || (chainReason == CHAIN_ENTER_UNMANAGED));

// If we have a Method, then we need an AppDomain.

// (RS will need it to do lookup)

if (fMethod)

{

_ASSERTE(currentAppDomain != NULL);

_ASSERTE(managed);

// Stubs may have a method w/o any code (eg, PInvoke wrapper).

// @todo - Frame::TYPE_TP_METHOD_FRAME breaks this assert. Are there other cases too?

//_ASSERTE(fStub || (pIJM != NULL));

}

if (fStub)

{

// All stubs (except LightWeightFunctions) match up w/a Frame.

_ASSERTE(this->frame || (eStubFrameType == STUBFRAME_LIGHTWEIGHT_FUNCTION));

}

}

#endif

//-----------------------------------------------------------------------------

// Get the DJI associated w/ this frame. This is a convenience function.

// This is recommended over using MethodDescs because DJI's are version-aware.

//-----------------------------------------------------------------------------

DebuggerJitInfo * FrameInfo::GetJitInfoFromFrame() const

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

}

CONTRACTL_END;

// Not all FrameInfo objects correspond to actual code.

if (HasChainMarker() || HasStubFrame() || (frame != NULL))

{

return NULL;

}

DebuggerJitInfo *ji = NULL;

// @todo - we shouldn't need both a MD and an IP here.

EX_TRY

{

_ASSERTE(this->md != NULL);

ji = g_pDebugger->GetJitInfo(this->md, (const BYTE*)GetControlPC(&(this->registers)));

_ASSERTE(ji != NULL);

_ASSERTE(ji->m_nativeCodeVersion.GetMethodDesc() == this->md);

}

EX_CATCH

{

ji = NULL;

}

EX_END_CATCH(SwallowAllExceptions);

return ji;

}

//-----------------------------------------------------------------------------

// Get the DMI associated w/ this frame. This is a convenience function.

// DMIs are 1:1 with the (token, module) pair.

//-----------------------------------------------------------------------------

DebuggerMethodInfo * FrameInfo::GetMethodInfoFromFrameOrThrow()

{

CONTRACTL

{

THROWS;

GC_NOTRIGGER;

}

CONTRACTL_END;

MethodDesc * pDesc = this->md;

mdMethodDef token = pDesc-> GetMemberDef();

Module * pRuntimeModule = pDesc->GetModule();

DebuggerMethodInfo *dmi = g_pDebugger->GetOrCreateMethodInfo(pRuntimeModule, token);

return dmi;

}

//-----------------------------------------------------------------------------

// Init a FrameInfo for a UM chain.

// We need a stackrange to give to an unmanaged debugger.

// pRDSrc->Esp will provide the start (leaf) marker.

// fpRoot will provide the end (root) portion.

//-----------------------------------------------------------------------------

void FrameInfo::InitForUMChain(FramePointer fpRoot, REGDISPLAY * pRDSrc)

{

_ASSERTE(pRDSrc != NULL);

// Mark that we're an UM Chain (and nothing else).

this->frame = NULL;

this->md = NULL;

// Fp will be the end (root) of the stack range.

// pRDSrc->Sp will be the start (leaf) of the stack range.

CopyREGDISPLAY(&(this->registers), pRDSrc);

this->fp = fpRoot;

this->quickUnwind = false;

this->internal = false;

this->managed = false;

// These parts of the FrameInfo can be ignored for a UM chain.

this->relOffset = 0;

this->pIJM = NULL;

this->MethodToken = METHODTOKEN(NULL, 0);

this->currentAppDomain = NULL;

this->exactGenericArgsToken = NULL;

InitForScratchFrameInfo();

this->chainReason = CHAIN_ENTER_UNMANAGED;

this->eStubFrameType = STUBFRAME_NONE;

#ifdef _DEBUG

FramePointer fpLeaf = GetSP(pRDSrc);

_ASSERTE(IsCloserToLeaf(fpLeaf, fpRoot));

#endif

#ifdef _DEBUG

// After we just init it, it had better be valid.

this->AssertValid();

#endif

}

//---------------------------------------------------------------------------------------

//

// This is just a small helper to initialize the fields which are specific to 64-bit. Note that you should

// only call this function on a scratch FrameInfo. Never call it on the FrameInfo used by the debugger

// stackwalker to store information on the current frame.

//

void FrameInfo::InitForScratchFrameInfo()

{

#ifdef FEATURE_EH_FUNCLETS

// The following flags cannot be trashed when we are calling this function on the curret FrameInfo

// (the one we keep track of across multiple stackwalker callbacks). Thus, make sure you do not call

// this function from InitForDynamicMethod(). In all other cases, we can call this method after we

// call InitFromStubHelper() because we are working on a local scratch variable.

this->fIsLeaf = false;

this->fIsFunclet = false;

this->fIsFilter = false;

#endif // FEATURE_EH_FUNCLETS

}

//-----------------------------------------------------------------------------

//

// Init a FrameInfo for a stub. Stub frames map to internal frames on the RS. Stubs which we care about

// usually contain an explicit frame which translates to an internal frame on the RS. Dynamic method is

// the sole exception.

//

// Arguments:

// pCF - the CrawlFrame containing the state of the current frame

// pMDHint - some stubs have associated MethodDesc but others don't,

// which is why this argument can be NULL

// type - the type of the stub/internal frame

//

void FrameInfo::InitFromStubHelper(

CrawlFrame * pCF,

MethodDesc * pMDHint, // NULL ok

CorDebugInternalFrameType type

)

{

_ASSERTE(pCF != NULL);

Frame * pFrame = pCF->GetFrame();

LOG((LF_CORDB, LL_EVERYTHING, "InitFromStubHelper. Frame=0x%p, type=%d\n", pFrame, type));

// All Stubs have a Frame except for LightWeight methods

_ASSERTE((type == STUBFRAME_LIGHTWEIGHT_FUNCTION) || (pFrame != NULL));

REGDISPLAY *pRDSrc = pCF->GetRegisterSet();

this->frame = pFrame;

// Stub frames may be associated w/ a Method (as a hint). However this method

// will never have a JitManager b/c it will never have IL (if it had IL, we'd be a

// regulare frame, not a stub frame)

this->md = pMDHint;

CopyREGDISPLAY(&this->registers, pRDSrc);

// FramePointer must match up w/ an EE Frame b/c that's how we match

// we Exception callbacks.

if (pFrame != NULL)

{

this->fp = FramePointer::MakeFramePointer(

(LPVOID) pFrame);

}

else

{

this->fp = GetSP(pRDSrc);

}

this->quickUnwind = false;

this->internal = false;

this->managed = true;

this->relOffset = 0;

this->ambientSP = NULL;

// Method associated w/a stub will never have a JitManager.

this->pIJM = NULL;

this->MethodToken = METHODTOKEN(NULL, 0);

this->currentAppDomain = pCF->GetAppDomain();

this->exactGenericArgsToken = NULL;

// Stub frames are mutually exclusive with chain markers.

this->chainReason = CHAIN_NONE;

this->eStubFrameType = type;

#ifdef _DEBUG

// After we just init it, it had better be valid.

this->AssertValid();

#endif

}

//-----------------------------------------------------------------------------

// Initialize a FrameInfo to be used for an "InternalFrame"

// Frame should be a derived class of FramedMethodFrame.

// FrameInfo's MethodDesc will be for managed wrapper for native call.

//-----------------------------------------------------------------------------

void FrameInfo::InitForM2UInternalFrame(CrawlFrame * pCF)

{

// For a M2U call, there's a managed method wrapping the unmanaged call. Use that.

Frame * pFrame = pCF->GetFrame();

_ASSERTE(pFrame->GetTransitionType() == Frame::TT_M2U);

FramedMethodFrame * pM2U = static_cast<FramedMethodFrame*> (pFrame);

MethodDesc * pMDWrapper = pM2U->GetFunction();

// Soem M2U transitions may not have a function associated w/ them,

// so pMDWrapper may be NULL. PInvokeCalliFrame is an example.

InitFromStubHelper(pCF, pMDWrapper, STUBFRAME_M2U);

InitForScratchFrameInfo();

}

//-----------------------------------------------------------------------------

// Initialize for the U2M case...

//-----------------------------------------------------------------------------

void FrameInfo::InitForU2MInternalFrame(CrawlFrame * pCF)

{

PREFIX_ASSUME(pCF != NULL);

MethodDesc * pMDHint = NULL;

#ifdef FEATURE_COMINTEROP

Frame * pFrame = pCF->GetFrame();

PREFIX_ASSUME(pFrame != NULL);

// For regular U2M PInvoke cases, we don't care about MD b/c it's just going to

// be the next frame.

// If we're a COM2CLR call, perhaps we can get the MD for the interface.

if (pFrame->GetVTablePtr() == ComMethodFrame::GetMethodFrameVPtr())

{

ComMethodFrame* pCOMFrame = static_cast<ComMethodFrame*> (pFrame);

ComCallMethodDesc* pCMD = reinterpret_cast<ComCallMethodDesc *> (pCOMFrame->ComMethodFrame::GetDatum());

pMDHint = pCMD->GetInterfaceMethodDesc();

// Some COM-interop cases don't have an intermediate interface method desc, so

// pMDHint may be null.

}

#endif

InitFromStubHelper(pCF, pMDHint, STUBFRAME_U2M);

InitForScratchFrameInfo();

}

//-----------------------------------------------------------------------------

// Init for an AD transition

//-----------------------------------------------------------------------------

void FrameInfo::InitForADTransition(CrawlFrame * pCF)

{

Frame * pFrame;

pFrame = pCF->GetFrame();

_ASSERTE(pFrame->GetTransitionType() == Frame::TT_AppDomain);

MethodDesc * pMDWrapper = NULL;

InitFromStubHelper(pCF, pMDWrapper, STUBFRAME_APPDOMAIN_TRANSITION);

InitForScratchFrameInfo();

}

//-----------------------------------------------------------------------------

// Init frame for a dynamic method.

//-----------------------------------------------------------------------------

void FrameInfo::InitForDynamicMethod(CrawlFrame * pCF)

{

// These are just stack markers that there's a dynamic method on the callstack.

InitFromStubHelper(pCF, NULL, STUBFRAME_LIGHTWEIGHT_FUNCTION);

// Do not call InitForScratchFrameInfo() here! Please refer to the comment in that function.

}

//-----------------------------------------------------------------------------

// Init an internal frame to mark a func-eval.

//-----------------------------------------------------------------------------

void FrameInfo::InitForFuncEval(CrawlFrame * pCF)

{

// We don't store a MethodDesc hint referring to the method we're going to invoke because

// uses of stub frames will assume the MD is relative to the AppDomain the frame is in.

// For cross-AD funcevals, we're invoking a method in a domain other than the one this frame

// is in.

MethodDesc * pMDHint = NULL;

// Add a stub frame here to mark that there is a FuncEvalFrame on the stack.

InitFromStubHelper(pCF, pMDHint, STUBFRAME_FUNC_EVAL);

InitForScratchFrameInfo();

}

//---------------------------------------------------------------------------------------

//

// Initialize a FrameInfo for sending the CHAIN_THREAD_START reason.

// The common case is that the chain is NOT managed, since the lowest (closest to the root) managed method

// is usually called from unmanaged code. In fact, in Whidbey, we should never have a managed chain.

//

// Arguments:

// pRDSrc - a REGDISPLAY for the beginning (the leafmost frame) of the chain

//

void FrameInfo::InitForThreadStart(Thread * pThread, REGDISPLAY * pRDSrc)

{

this->frame = (Frame *) FRAME_TOP;

this->md = NULL;

CopyREGDISPLAY(&(this->registers), pRDSrc);

this->fp = FramePointer::MakeFramePointer(pThread->GetCachedStackBase());

this->quickUnwind = false;

this->internal = false;

this->managed = false;

this->relOffset = 0;

this->pIJM = NULL;

this->MethodToken = METHODTOKEN(NULL, 0);

this->currentAppDomain = NULL;

this->exactGenericArgsToken = NULL;

InitForScratchFrameInfo();

this->chainReason = CHAIN_THREAD_START;

this->eStubFrameType = STUBFRAME_NONE;

#ifdef _DEBUG

// After we just init it, it had better be valid.

this->AssertValid();

#endif

}

//---------------------------------------------------------------------------------------

//

// Initialize a FrameInfo for sending a CHAIN_ENTER_MANAGED.

// A Enter-Managed chain is always sent immediately before an UM chain, meaning that the Enter-Managed chain

// is closer to the leaf than the UM chain.

//

// Arguments:

// fpRoot - This is the frame pointer for the Enter-Managed chain. It is currently arbitrarily set

// to be one stack slot higher (closer to the leaf) than the frame pointer of the beginning

// of the upcoming UM chain.

//

void FrameInfo::InitForEnterManagedChain(FramePointer fpRoot)

{

// Nobody should use a EnterManagedChain's Frame*, but there's no

// good value to enforce that.

this->frame = (Frame *) FRAME_TOP;

this->md = NULL;

memset((void *)&this->registers, 0, sizeof(this->registers));

this->fp = fpRoot;

this->quickUnwind = true;

this->internal = false;

this->managed = true;

this->relOffset = 0;

this->pIJM = NULL;

this->MethodToken = METHODTOKEN(NULL, 0);

this->currentAppDomain = NULL;

this->exactGenericArgsToken = NULL;

InitForScratchFrameInfo();

this->chainReason = CHAIN_ENTER_MANAGED;

this->eStubFrameType = STUBFRAME_NONE;

}

//-----------------------------------------------------------------------------

// Do tracking for UM chains.

// This may invoke the UMChain callback and M2U callback.

//-----------------------------------------------------------------------------

StackWalkAction TrackUMChain(CrawlFrame *pCF, DebuggerFrameData *d)

{

Frame *frame = g_pEEInterface->GetFrame(pCF);

// If we encounter an ExitFrame out in the wild, then we'll convert it to an UM chain.

if (!d->IsTrackingUMChain())

{

if ((frame != NULL) && (frame != FRAME_TOP) && (frame->GetFrameType() == Frame::TYPE_EXIT))

{

LOG((LF_CORDB, LL_EVERYTHING, "DWSP. ExitFrame while not tracking\n"));

REGDISPLAY* pRDSrc = pCF->GetRegisterSet();

d->BeginTrackingUMChain(GetSP(pRDSrc), pRDSrc);

// fall through and we'll send the UM chain.

}

else

{

return SWA_CONTINUE;

}

}

_ASSERTE(d->IsTrackingUMChain());

// If we're tracking an UM chain, then we need to:

// - possibly refine the start & end values as we get new information in the stacktrace.

// - possibly cancel the UM chain for various heuristics.

// - possibly dispatch if we've hit managed code again.

bool fDispatchUMChain = false;

// UM Chain stops when managed code starts again.

if (frame != NULL)

{

// If it's just a EE Frame, then update this as a possible end of stack range for the UM chain.

// (The end of a stack range is closer to the root.)

d->SetUMChainEnd(FramePointer::MakeFramePointer((LPVOID)(frame)));

Frame::ETransitionType t = frame->GetTransitionType();

int ft = frame->GetFrameType();

// Sometimes we may not want to show an UM chain b/c we know it's just

// code inside of mscorwks. (Eg: Funcevals & AD transitions both fall into this category).