void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD)
{
// Frame pointer
LPVOID FPAddress = GetRegdisplayFPAddress(pRD);
pDRD->FP = (FPAddress == NULL ? 0 : *((SIZE_T *)FPAddress));
pDRD->pFP = PushedRegAddr(pRD, FPAddress);
// All that's needed for now
pDRD->SP = pRD->SP;
pDRD->PC = (SIZE_T)*(pRD->pPC);
}
//
// Callback for walking a thread's stack. Sends required frame data to the
// DI as send buffers fill up.
//
StackWalkAction DebuggerThread::TraceAndSendStackCallback(FrameInfo *pInfo, VOID* data)
{
_RefreshStackFramesData *rsfd = (_RefreshStackFramesData*) data;
Thread *t = rsfd->thread;
DebuggerIPCEvent *pEvent = NULL;
if (rsfd->iWhich == IPC_TARGET_INPROC)
{
pEvent = rsfd->pEvent;
}
else
{
_ASSERTE( rsfd->iWhich == IPC_TARGET_OUTOFPROC );
pEvent = rsfd->rcThread->GetIPCEventSendBuffer(rsfd->iWhich);
}
// Record registers for the start of the next chain, if appropriate.
if (rsfd->needChainRegisters)
{
rsfd->chainRegisters = pInfo->registers;
rsfd->needChainRegisters = false;
}
// Only report frames which are chain boundaries, or are not marked internal.
LOG((LF_CORDB, LL_INFO1000, "DT::TASSC:chainReason:0x%x internal:0x%x "
"md:0x%x **************************\n", pInfo->chainReason,
pInfo->internal, pInfo->md));
if (pInfo->chainReason == 0 && (pInfo->internal || pInfo->md == NULL))
return SWA_CONTINUE;
#ifdef LOGGING
if( pInfo->quickUnwind == true )
LOG((LF_CORDB, LL_INFO10000, "DT::TASSC: rsfd => Doing quick unwind\n"));
#endif
//
// If we've filled this event, send it off to the Right Side
// before continuing the walk.
//
if ((rsfd->eventSize + sizeof(DebuggerIPCE_STRData)) >= rsfd->eventMaxSize)
{
//
//
pEvent->StackTraceResultData.threadUserState = g_pEEInterface->GetUserState(t);
if (rsfd->iWhich == IPC_TARGET_OUTOFPROC)
{
rsfd->rcThread->SendIPCEvent(rsfd->iWhich);
}
else
{
DebuggerIPCEvent *peT;
peT = rsfd->rcThread->GetIPCEventSendBufferContinuation(pEvent);
if (peT == NULL)
{
pEvent->hr = E_OUTOFMEMORY;
return SWA_ABORT;
}
CopyEventInfo(pEvent, peT);
pEvent = peT;
rsfd->pEvent = peT;
rsfd->eventSize = 0;
}
//
// Reset for the next set of frames.
//
pEvent->StackTraceResultData.traceCount = 0;
rsfd->currentSTRData = &(pEvent->StackTraceResultData.traceData);
rsfd->eventSize = (UINT_PTR)(rsfd->currentSTRData) - (UINT_PTR)(pEvent);
}
MethodDesc* fd = pInfo->md;
if (fd != NULL && !pInfo->internal)
{
//
// Send a frame
//
rsfd->currentSTRData->isChain = false;
rsfd->currentSTRData->fp = pInfo->fp;
rsfd->currentSTRData->quicklyUnwound = pInfo->quickUnwind;
// Pass the appdomain that this thread was in when it was executing this frame to the Right Side.
rsfd->currentSTRData->currentAppDomainToken = (void*)pInfo->currentAppDomain;
REGDISPLAY* rd = &pInfo->registers;
DebuggerREGDISPLAY* drd = &(rsfd->currentSTRData->rd);
LPVOID FPAddress = GetRegdisplayFPAddress(rd);
// Set some common elements
drd->SP = rd->SP;
drd->PC = (SIZE_T)*(rd->pPC);
drd->FP = (FPAddress == NULL ? 0 : *((SIZE_T *)FPAddress));
//
// PUSHED_REG_ADDR gives us NULL if the register still lives in the thread's context, or it gives us the address
// of where the register was pushed for this frame.
//
#define PUSHED_REG_ADDR(_a) (((UINT_PTR)(_a) >= (UINT_PTR)rd->pContext) && ((UINT_PTR)(_a) <= ((UINT_PTR)rd->pContext + sizeof(CONTEXT)))) ? NULL : (_a)
// Frame pointer
drd->pFP = PUSHED_REG_ADDR(FPAddress);
#ifdef _X86_
drd->pEdi = PUSHED_REG_ADDR(rd->pEdi);
drd->Edi = (rd->pEdi == NULL ? 0 : *(rd->pEdi));
drd->pEsi = PUSHED_REG_ADDR(rd->pEsi);
drd->Esi = (rd->pEsi == NULL ? 0 : *(rd->pEsi));
drd->pEbx = PUSHED_REG_ADDR(rd->pEbx);
drd->Ebx = (rd->pEbx == NULL ? 0 : *(rd->pEbx));
drd->pEdx = PUSHED_REG_ADDR(rd->pEdx);
drd->Edx = (rd->pEdx == NULL ? 0 : *(rd->pEdx));
drd->pEcx = PUSHED_REG_ADDR(rd->pEcx);
drd->Ecx = (rd->pEcx == NULL ? 0 : *(rd->pEcx));
drd->pEax = PUSHED_REG_ADDR(rd->pEax);
drd->Eax = (rd->pEax == NULL ? 0 : *(rd->pEax));
// Please leave EBP, ESP, EIP at the front so I don't have to scroll
// left to see the most important registers. Thanks!
LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:Registers:"
"Ebp = %x Esp = %x Eip = %x Edi:%d "
"Esi = %x Ebx = %x Edx = %x Ecx = %x Eax = %x\n",
drd->FP, drd->SP, drd->PC, drd->Edi,
drd->Esi, drd->Ebx, drd->Edx, drd->Ecx, drd->Eax ) );
#elif defined(_PPC_) || defined (_SPARC_)
// All that's needed for now
#else
PORTABILITY_ASSERT("TraceAndSendStackCallback needs some munging for this platform.");
#endif
DebuggerIPCE_FuncData* currentFuncData = &rsfd->currentSTRData->v.funcData;
_ASSERTE(fd != NULL);
GetVAInfo(&(currentFuncData->fVarArgs),
&(currentFuncData->rpSig),
&(currentFuncData->cbSig),
&(currentFuncData->rpFirstArg),
fd,
rd,
pInfo->relOffset);
LOG((LF_CORDB, LL_INFO10000, "DT::TASSC: good frame for %s::%s\n",
fd->m_pszDebugClassName,
fd->m_pszDebugMethodName));
//
// Fill in information about the function that goes with this
// frame.
//
currentFuncData->funcRVA = g_pEEInterface->MethodDescGetRVA(fd);
_ASSERTE (t != NULL);
Module *pRuntimeModule = g_pEEInterface->MethodDescGetModule(fd);
AppDomain *pAppDomain = pInfo->currentAppDomain;
currentFuncData->funcDebuggerModuleToken = (void*) g_pDebugger->LookupModule(pRuntimeModule, pAppDomain);
if (currentFuncData->funcDebuggerModuleToken == NULL && rsfd->iWhich == IPC_TARGET_INPROC)
{
currentFuncData->funcDebuggerModuleToken = (void*)g_pDebugger->AddDebuggerModule(pRuntimeModule, pAppDomain);
LOG((LF_CORDB, LL_INFO100, "DT::TASSC: load module Mod:%#08x AD:%#08x isDynamic:%#x runtimeMod:%#08x\n",
currentFuncData->funcDebuggerModuleToken, pAppDomain, pRuntimeModule->IsReflection(), pRuntimeModule));
}
_ASSERTE(currentFuncData->funcDebuggerModuleToken != 0);
currentFuncData->funcDebuggerAssemblyToken =
(g_pEEInterface->MethodDescGetModule(fd))->GetClassLoader()->GetAssembly();
currentFuncData->funcMetadataToken = fd->GetMemberDef();
currentFuncData->classMetadataToken = fd->GetClass()->GetCl();
// Pass back the local var signature token.
COR_ILMETHOD *CorILM = g_pEEInterface->MethodDescGetILHeader(fd);
if (CorILM == NULL )
{
currentFuncData->localVarSigToken = mdSignatureNil;
currentFuncData->ilStartAddress = NULL;
currentFuncData->ilSize = 0;
rsfd->currentSTRData->v.ILIP = NULL;
currentFuncData->nativeStartAddressPtr = NULL;
currentFuncData->nativeSize = 0;
currentFuncData->nativenVersion = DebuggerJitInfo::DJI_VERSION_FIRST_VALID;
}
else
{
COR_ILMETHOD_DECODER ILHeader(CorILM);
if (ILHeader.GetLocalVarSigTok() != 0)
currentFuncData->localVarSigToken = ILHeader.GetLocalVarSigTok();
else
currentFuncData->localVarSigToken = mdSignatureNil;
//
//
currentFuncData->ilStartAddress = const_cast<BYTE*>(ILHeader.Code);
currentFuncData->ilSize = ILHeader.GetCodeSize();
currentFuncData->ilnVersion = g_pDebugger->GetVersionNumber(fd);
LOG((LF_CORDB,LL_INFO10000,"Sending il Ver:0x%x in stack trace!\n", currentFuncData->ilnVersion));
DebuggerJitInfo *jitInfo = g_pDebugger->GetJitInfo(fd, (const BYTE*)*pInfo->registers.pPC);
if (jitInfo == NULL)
{
//EnC: Couldn't find the code;
rsfd->currentSTRData->v.ILIP = NULL;
// Note: always send back the size of the method. This
// allows us to get the code, even when we haven't
// been tracking. (Handling of the GetCode message
// knows how to find the start address of the code, or
// how to respond if is been pitched.)
currentFuncData->nativeSize = g_pEEInterface->GetFunctionSize(fd);
currentFuncData->nativeStartAddressPtr = NULL;
currentFuncData->nativenVersion = DebuggerJitInfo::DJI_VERSION_FIRST_VALID;
currentFuncData->CodeVersionToken = NULL;
currentFuncData->ilToNativeMapAddr = NULL;
currentFuncData->ilToNativeMapSize = 0;
currentFuncData->nVersionMostRecentEnC = currentFuncData->ilnVersion;
}
else
{
LOG((LF_CORDB,LL_INFO10000,"DeTh::TASSC: Code: 0x%x Got DJI "
"0x%x, from 0x%x to 0x%x\n",(const BYTE*)drd->PC,jitInfo,
jitInfo->m_addrOfCode, jitInfo->m_addrOfCode +
jitInfo->m_sizeOfCode));
DWORD whichIrrelevant;
rsfd->currentSTRData->v.ILIP = const_cast<BYTE*>(ILHeader.Code)
+ jitInfo->MapNativeOffsetToIL((SIZE_T)pInfo->relOffset,
&rsfd->currentSTRData->v.mapping,
&whichIrrelevant);
// Pass back the pointers to the sequence point map so
// that the RIght Side can copy it out if needed.
_ASSERTE(jitInfo->m_sequenceMapSorted);
currentFuncData->ilToNativeMapAddr = jitInfo->m_sequenceMap;
currentFuncData->ilToNativeMapSize = jitInfo->m_sequenceMapCount;
if (!jitInfo->m_codePitched)
{ // It's there & life is groovy
currentFuncData->nativeStartAddressPtr = &(jitInfo->m_addrOfCode);
currentFuncData->nativeSize = g_pEEInterface->GetFunctionSize(fd);
currentFuncData->nativenVersion = jitInfo->m_nVersion;
currentFuncData->CodeVersionToken = (void *)jitInfo;
}
else
{
// It's been pitched
currentFuncData->nativeStartAddressPtr = NULL;
currentFuncData->nativeSize = 0;
}
LOG((LF_CORDB,LL_INFO10000,"Sending native Ver:0x%x Tok:0x%x in stack trace!\n",
currentFuncData->nativenVersion,currentFuncData->CodeVersionToken));
}
}
currentFuncData->nativeOffset = (SIZE_T)pInfo->relOffset;
//
// Bump our pointers to the next space for the next frame.
//
pEvent->StackTraceResultData.traceCount++;
rsfd->currentSTRData++;
rsfd->eventSize += sizeof(DebuggerIPCE_STRData);
}
if (pInfo->chainReason != 0)
{
//
// If we've filled this event, send it off to the Right Side
// before continuing the walk.
//
if ((rsfd->eventSize + sizeof(DebuggerIPCE_STRData)) >=
rsfd->eventMaxSize)
{
//
//
pEvent->StackTraceResultData.threadUserState =
g_pEEInterface->GetUserState(t);
if (rsfd->iWhich == IPC_TARGET_OUTOFPROC)
{
rsfd->rcThread->SendIPCEvent(rsfd->iWhich);
}
else
{
DebuggerIPCEvent *peT;
peT = rsfd->rcThread->GetIPCEventSendBufferContinuation(pEvent);
if (peT == NULL)
{
pEvent->hr = E_OUTOFMEMORY;
return SWA_ABORT;
}
CopyEventInfo(pEvent, peT);
pEvent = peT;
rsfd->pEvent = peT;
rsfd->eventSize = 0;
}
//
// Reset for the next set of frames.
//
pEvent->StackTraceResultData.traceCount = 0;
rsfd->currentSTRData = &(pEvent->StackTraceResultData.traceData);
rsfd->eventSize = (UINT_PTR)(rsfd->currentSTRData) -
(UINT_PTR)(pEvent);
}
//
// Send a chain boundary
//
rsfd->currentSTRData->isChain = true;
rsfd->currentSTRData->u.chainReason = pInfo->chainReason;
rsfd->currentSTRData->u.managed = pInfo->managed;
rsfd->currentSTRData->u.context = pInfo->context;
rsfd->currentSTRData->fp = pInfo->fp;
rsfd->currentSTRData->quicklyUnwound = pInfo->quickUnwind;
#ifdef _DEBUG
REGDISPLAY* rd = &rsfd->chainRegisters;
#endif // _DEBUG
#ifdef _X86_
LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:Registers: Edi:%d \
Esi = %x Ebx = %x Edx = %x Ecx = %x Eax = %x Ebp = %x\n", (rd->pEdi == NULL ? 0 : *(rd->pEdi)),
(rd->pEsi == NULL ? 0 : *(rd->pEsi)), (rd->pEbx == NULL ? 0 : *(rd->pEbx)),
(rd->pEdx == NULL ? 0 : *(rd->pEdx)), (rd->pEcx == NULL ? 0 : *(rd->pEcx)),
(rd->pEax == NULL ? 0 : *(rd->pEax)), (rd->pEbp == NULL ? 0 : *(rd->pEbp))) );
#endif
LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:PC: PC:%x SP:%x\n",
(SIZE_T)*(rd->pPC), rd->SP));
rsfd->needChainRegisters = true;
//
// Bump our pointers to the next space for the next frame.
//
pEvent->StackTraceResultData.traceCount++;
rsfd->currentSTRData++;
rsfd->eventSize += sizeof(DebuggerIPCE_STRData);
}
return SWA_CONTINUE;
}
