diff --git a/src/coreclr/debug/daccess/dacdbiimpl.h b/src/coreclr/debug/daccess/dacdbiimpl.h index 97763ae7047756..3af49ef2c2a8ff 100644 --- a/src/coreclr/debug/daccess/dacdbiimpl.h +++ b/src/coreclr/debug/daccess/dacdbiimpl.h @@ -730,10 +730,6 @@ class DacDbiInterfaceImpl : // DacDbi API: Get the context for a particular thread of the target process HRESULT STDMETHODCALLTYPE GetContext(VMPTR_Thread vmThread, DT_CONTEXT * pContextBuffer); - // This is a simple helper function to convert a CONTEXT to a DebuggerREGDISPLAY. We need to do this - // inside DDI because the RS has no notion of REGDISPLAY. - HRESULT STDMETHODCALLTYPE ConvertContextToDebuggerRegDisplay(const DT_CONTEXT * pInContext, DebuggerREGDISPLAY * pOutDRD, BOOL fActive); - // Check if the given method is a DiagnosticHidden or an LCG method. HRESULT STDMETHODCALLTYPE IsDiagnosticsHiddenOrLCGMethod(VMPTR_MethodDesc vmMethodDesc, OUT DynamicMethodType * pRetVal); diff --git a/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp b/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp index cf294274ac514a..3ef32a23964011 100644 --- a/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp +++ b/src/coreclr/debug/daccess/dacdbiimplstackwalk.cpp @@ -727,30 +727,6 @@ HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsLeafFrame(VMPTR_Thread vmThread return hr; } -// This is a simple helper function to convert a CONTEXT to a DebuggerREGDISPLAY. We need to do this -// inside DDI because the RS has no notion of REGDISPLAY. -HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::ConvertContextToDebuggerRegDisplay(const DT_CONTEXT * pInContext, DebuggerREGDISPLAY * pOutDRD, BOOL fActive) -{ - DD_ENTER_MAY_THROW; - - HRESULT hr = S_OK; - EX_TRY - { - - // This is a bit cumbersome. First we need to convert the CONTEXT into a REGDISPLAY. Then we need - // to convert the REGDISPLAY to a DebuggerREGDISPLAY. - T_CONTEXT tmpContext = { }; - CopyMemory(&tmpContext, pInContext, sizeof(*pInContext)); - - REGDISPLAY rd; - FillRegDisplay(&rd, &tmpContext); - - SetDebuggerREGDISPLAYFromREGDISPLAY(pOutDRD, &rd); - } - EX_CATCH_HRESULT(hr); - return hr; -} - //--------------------------------------------------------------------------------------- // // Fill in the structure with information about the current frame at which the stackwalker is stopped. @@ -809,9 +785,6 @@ void DacDbiInterfaceImpl::InitFrameData(StackFrameIterator * pIter, pFrameData->eType = Debugger_STRData::cMethodFrame; - _ASSERTE(pFrameData->rd != NULL); - SetDebuggerREGDISPLAYFromREGDISPLAY(pFrameData->rd, pCF->GetRegisterSet()); - _ASSERTE(pFrameData->ctx != NULL); GetStackWalkCurrentContext(pIter, pFrameData->ctx); diff --git a/src/coreclr/debug/di/amd64/cordbregisterset.cpp b/src/coreclr/debug/di/amd64/cordbregisterset.cpp index 75c0a914633c44..22e4521dbc12c6 100644 --- a/src/coreclr/debug/di/amd64/cordbregisterset.cpp +++ b/src/coreclr/debug/di/amd64/cordbregisterset.cpp @@ -133,39 +133,39 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, switch( i ) { case REGISTER_INSTRUCTION_POINTER: - regBuffer[iRegister++] = m_rd->PC; break; + regBuffer[iRegister++] = m_context.Rip; break; case REGISTER_STACK_POINTER: - regBuffer[iRegister++] = m_rd->SP; break; + regBuffer[iRegister++] = m_context.Rsp; break; case REGISTER_AMD64_RBP: - regBuffer[iRegister++] = m_rd->Rbp; break; + regBuffer[iRegister++] = m_context.Rbp; break; case REGISTER_AMD64_RAX: - regBuffer[iRegister++] = m_rd->Rax; break; + regBuffer[iRegister++] = m_context.Rax; break; case REGISTER_AMD64_RBX: - regBuffer[iRegister++] = m_rd->Rbx; break; + regBuffer[iRegister++] = m_context.Rbx; break; case REGISTER_AMD64_RCX: - regBuffer[iRegister++] = m_rd->Rcx; break; + regBuffer[iRegister++] = m_context.Rcx; break; case REGISTER_AMD64_RDX: - regBuffer[iRegister++] = m_rd->Rdx; break; + regBuffer[iRegister++] = m_context.Rdx; break; case REGISTER_AMD64_RSI: - regBuffer[iRegister++] = m_rd->Rsi; break; + regBuffer[iRegister++] = m_context.Rsi; break; case REGISTER_AMD64_RDI: - regBuffer[iRegister++] = m_rd->Rdi; break; + regBuffer[iRegister++] = m_context.Rdi; break; case REGISTER_AMD64_R8: - regBuffer[iRegister++] = m_rd->R8; break; + regBuffer[iRegister++] = m_context.R8; break; case REGISTER_AMD64_R9: - regBuffer[iRegister++] = m_rd->R9; break; + regBuffer[iRegister++] = m_context.R9; break; case REGISTER_AMD64_R10: - regBuffer[iRegister++] = m_rd->R10; break; + regBuffer[iRegister++] = m_context.R10; break; case REGISTER_AMD64_R11: - regBuffer[iRegister++] = m_rd->R11; break; + regBuffer[iRegister++] = m_context.R11; break; case REGISTER_AMD64_R12: - regBuffer[iRegister++] = m_rd->R12; break; + regBuffer[iRegister++] = m_context.R12; break; case REGISTER_AMD64_R13: - regBuffer[iRegister++] = m_rd->R13; break; + regBuffer[iRegister++] = m_context.R13; break; case REGISTER_AMD64_R14: - regBuffer[iRegister++] = m_rd->R14; break; + regBuffer[iRegister++] = m_context.R14; break; case REGISTER_AMD64_R15: - regBuffer[iRegister++] = m_rd->R15; break; + regBuffer[iRegister++] = m_context.R15; break; case REGISTER_AMD64_XMM0: case REGISTER_AMD64_XMM1: @@ -215,39 +215,3 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], // Defer to adapter for v1.0 interface return GetRegistersAdapter(maskCount, mask, regCount, regBuffer); } - - -// This is just a convenience function to convert a regdisplay into a Context. -// Since a context has more info than a regdisplay, the conversion isn't perfect -// and the context can't be fully accurate. -void CordbRegisterSet::InternalCopyRDToContext(DT_CONTEXT *pInputContext) -{ - INTERNAL_SYNC_API_ENTRY(GetProcess()); - _ASSERTE(pInputContext); - - if((pInputContext->ContextFlags & DT_CONTEXT_INTEGER)==DT_CONTEXT_INTEGER) - { - pInputContext->Rax = m_rd->Rax; - pInputContext->Rbx = m_rd->Rbx; - pInputContext->Rcx = m_rd->Rcx; - pInputContext->Rdx = m_rd->Rdx; - pInputContext->Rbp = m_rd->Rbp; - pInputContext->Rsi = m_rd->Rsi; - pInputContext->Rdi = m_rd->Rdi; - pInputContext->R8 = m_rd->R8; - pInputContext->R9 = m_rd->R9; - pInputContext->R10 = m_rd->R10; - pInputContext->R11 = m_rd->R11; - pInputContext->R12 = m_rd->R12; - pInputContext->R13 = m_rd->R13; - pInputContext->R14 = m_rd->R14; - pInputContext->R15 = m_rd->R15; - } - - - if((pInputContext->ContextFlags & DT_CONTEXT_CONTROL)==DT_CONTEXT_CONTROL) - { - pInputContext->Rip = m_rd->PC; - pInputContext->Rsp = m_rd->SP; - } -} diff --git a/src/coreclr/debug/di/arm/cordbregisterset.cpp b/src/coreclr/debug/di/arm/cordbregisterset.cpp index 507c6020d6358c..781947a6e45e82 100644 --- a/src/coreclr/debug/di/arm/cordbregisterset.cpp +++ b/src/coreclr/debug/di/arm/cordbregisterset.cpp @@ -54,37 +54,37 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, CORDB_REG switch (i) { case REGISTER_INSTRUCTION_POINTER: - regBuffer[iRegister++] = m_rd->PC; break; + regBuffer[iRegister++] = m_context.Pc; break; case REGISTER_STACK_POINTER: - regBuffer[iRegister++] = m_rd->SP; break; + regBuffer[iRegister++] = m_context.Sp; break; case REGISTER_ARM_R0: - regBuffer[iRegister++] = m_rd->R0; break; + regBuffer[iRegister++] = m_context.R0; break; case REGISTER_ARM_R1: - regBuffer[iRegister++] = m_rd->R1; break; + regBuffer[iRegister++] = m_context.R1; break; case REGISTER_ARM_R2: - regBuffer[iRegister++] = m_rd->R2; break; + regBuffer[iRegister++] = m_context.R2; break; case REGISTER_ARM_R3: - regBuffer[iRegister++] = m_rd->R3; break; + regBuffer[iRegister++] = m_context.R3; break; case REGISTER_ARM_R4: - regBuffer[iRegister++] = m_rd->R4; break; + regBuffer[iRegister++] = m_context.R4; break; case REGISTER_ARM_R5: - regBuffer[iRegister++] = m_rd->R5; break; + regBuffer[iRegister++] = m_context.R5; break; case REGISTER_ARM_R6: - regBuffer[iRegister++] = m_rd->R6; break; + regBuffer[iRegister++] = m_context.R6; break; case REGISTER_ARM_R7: - regBuffer[iRegister++] = m_rd->R7; break; + regBuffer[iRegister++] = m_context.R7; break; case REGISTER_ARM_R8: - regBuffer[iRegister++] = m_rd->R8; break; + regBuffer[iRegister++] = m_context.R8; break; case REGISTER_ARM_R9: - regBuffer[iRegister++] = m_rd->R9; break; + regBuffer[iRegister++] = m_context.R9; break; case REGISTER_ARM_R10: - regBuffer[iRegister++] = m_rd->R10; break; + regBuffer[iRegister++] = m_context.R10; break; case REGISTER_ARM_R11: - regBuffer[iRegister++] = m_rd->R11; break; + regBuffer[iRegister++] = m_context.R11; break; case REGISTER_ARM_R12: - regBuffer[iRegister++] = m_rd->R12; break; + regBuffer[iRegister++] = m_context.R12; break; case REGISTER_ARM_LR: - regBuffer[iRegister++] = m_rd->LR; break; + regBuffer[iRegister++] = m_context.Lr; break; } } } @@ -115,35 +115,3 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], // Defer to adapter for v1.0 interface return GetRegistersAdapter(maskCount, mask, regCount, regBuffer); } - -// This is just a convenience function to convert a regdisplay into a Context. -// Since a context has more info than a regdisplay, the conversion isn't perfect -// and the context can't be fully accurate. -void CordbRegisterSet::InternalCopyRDToContext(DT_CONTEXT * pInputContext) -{ - INTERNAL_SYNC_API_ENTRY(GetProcess()); - _ASSERTE(pInputContext); - - if ((pInputContext->ContextFlags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - pInputContext->R0 = m_rd->R0; - pInputContext->R1 = m_rd->R1; - pInputContext->R2 = m_rd->R2; - pInputContext->R3 = m_rd->R3; - pInputContext->R4 = m_rd->R4; - pInputContext->R5 = m_rd->R5; - pInputContext->R6 = m_rd->R6; - pInputContext->R7 = m_rd->R7; - pInputContext->R8 = m_rd->R8; - pInputContext->R9 = m_rd->R9; - pInputContext->R10 = m_rd->R10; - pInputContext->R11 = m_rd->R11; - } - - if ((pInputContext->ContextFlags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pInputContext->Sp = m_rd->SP; - pInputContext->Lr = m_rd->LR; - pInputContext->Pc = m_rd->PC; - } -} diff --git a/src/coreclr/debug/di/arm64/cordbregisterset.cpp b/src/coreclr/debug/di/arm64/cordbregisterset.cpp index 1d470e39c420a7..ca11ec8020aabc 100644 --- a/src/coreclr/debug/di/arm64/cordbregisterset.cpp +++ b/src/coreclr/debug/di/arm64/cordbregisterset.cpp @@ -103,7 +103,7 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, if ((i >= REGISTER_ARM64_X0) && (i <= REGISTER_ARM64_X28)) { - regBuffer[iRegister++] = m_rd->X[i - REGISTER_ARM64_X0]; + regBuffer[iRegister++] = m_context.X[i - REGISTER_ARM64_X0]; continue; } @@ -133,13 +133,13 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, switch (i) { case REGISTER_ARM64_PC: - regBuffer[iRegister++] = m_rd->PC; break; + regBuffer[iRegister++] = m_context.Pc; break; case REGISTER_ARM64_SP: - regBuffer[iRegister++] = m_rd->SP; break; + regBuffer[iRegister++] = m_context.Sp; break; case REGISTER_ARM64_FP: - regBuffer[iRegister++] = m_rd->FP; break; + regBuffer[iRegister++] = m_context.Fp; break; case REGISTER_ARM64_LR: - regBuffer[iRegister++] = m_rd->LR; break; + regBuffer[iRegister++] = m_context.Lr; break; default: _ASSERTE(false); break; } @@ -193,7 +193,7 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], if ((i >= REGISTER_ARM64_X0) && (i <= REGISTER_ARM64_X28)) { - regBuffer[iRegister++] = m_rd->X[i - REGISTER_ARM64_X0]; + regBuffer[iRegister++] = m_context.X[i - REGISTER_ARM64_X0]; continue; } @@ -223,13 +223,13 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], switch (i) { case REGISTER_ARM64_PC: - regBuffer[iRegister++] = m_rd->PC; break; + regBuffer[iRegister++] = m_context.Pc; break; case REGISTER_ARM64_SP: - regBuffer[iRegister++] = m_rd->SP; break; + regBuffer[iRegister++] = m_context.Sp; break; case REGISTER_ARM64_FP: - regBuffer[iRegister++] = m_rd->FP; break; + regBuffer[iRegister++] = m_context.Fp; break; case REGISTER_ARM64_LR: - regBuffer[iRegister++] = m_rd->LR; break; + regBuffer[iRegister++] = m_context.Lr; break; default: _ASSERTE(false); break; } @@ -239,28 +239,3 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], return S_OK; } - - -// This is just a convenience function to convert a regdisplay into a Context. -// Since a context has more info than a regdisplay, the conversion isn't perfect -// and the context can't be fully accurate. -void CordbRegisterSet::InternalCopyRDToContext(DT_CONTEXT *pInputContext) -{ INTERNAL_SYNC_API_ENTRY(GetProcess()); - _ASSERTE(pInputContext); - - if ((pInputContext->ContextFlags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - for (int i = 0 ; i < 29 ; ++i) - { - pInputContext->X[i] = m_rd->X[i]; - } - } - - if ((pInputContext->ContextFlags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pInputContext->Sp = m_rd->SP; - pInputContext->Lr = m_rd->LR; - pInputContext->Pc = m_rd->PC; - pInputContext->Fp = m_rd->FP; - } -} diff --git a/src/coreclr/debug/di/i386/cordbregisterset.cpp b/src/coreclr/debug/di/i386/cordbregisterset.cpp index a1254f0b608707..1bf9056912536d 100644 --- a/src/coreclr/debug/di/i386/cordbregisterset.cpp +++ b/src/coreclr/debug/di/i386/cordbregisterset.cpp @@ -104,23 +104,23 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, switch( i ) { case REGISTER_INSTRUCTION_POINTER: - regBuffer[iRegister++] = m_rd->PC; break; + regBuffer[iRegister++] = m_context.Eip; break; case REGISTER_STACK_POINTER: - regBuffer[iRegister++] = m_rd->SP; break; + regBuffer[iRegister++] = m_context.Esp; break; case REGISTER_FRAME_POINTER: - regBuffer[iRegister++] = m_rd->FP; break; + regBuffer[iRegister++] = m_context.Ebp; break; case REGISTER_X86_EAX: - regBuffer[iRegister++] = m_rd->Eax; break; + regBuffer[iRegister++] = m_context.Eax; break; case REGISTER_X86_EBX: - regBuffer[iRegister++] = m_rd->Ebx; break; + regBuffer[iRegister++] = m_context.Ebx; break; case REGISTER_X86_ECX: - regBuffer[iRegister++] = m_rd->Ecx; break; + regBuffer[iRegister++] = m_context.Ecx; break; case REGISTER_X86_EDX: - regBuffer[iRegister++] = m_rd->Edx; break; + regBuffer[iRegister++] = m_context.Edx; break; case REGISTER_X86_ESI: - regBuffer[iRegister++] = m_rd->Esi; break; + regBuffer[iRegister++] = m_context.Esi; break; case REGISTER_X86_EDI: - regBuffer[iRegister++] = m_rd->Edi; break; + regBuffer[iRegister++] = m_context.Edi; break; //for floats, copy the bits, not the integer part of //the value, into the register @@ -189,33 +189,3 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], // Defer to adapter for v1.0 interface return GetRegistersAdapter(maskCount, mask, regCount, regBuffer); } - - -// This is just a convenience function to convert a regdisplay into a Context. -// Since a context has more info than a regdisplay, the conversion isn't perfect -// and the context can't be fully accurate. -void CordbRegisterSet::InternalCopyRDToContext(DT_CONTEXT * pInputContext) -{ - INTERNAL_SYNC_API_ENTRY(GetProcess()); - _ASSERTE(pInputContext); - - //now update the registers based on the current frame - if((pInputContext->ContextFlags & DT_CONTEXT_INTEGER)==DT_CONTEXT_INTEGER) - { - pInputContext->Eax = m_rd->Eax; - pInputContext->Ebx = m_rd->Ebx; - pInputContext->Ecx = m_rd->Ecx; - pInputContext->Edx = m_rd->Edx; - pInputContext->Esi = m_rd->Esi; - pInputContext->Edi = m_rd->Edi; - } - - - if((pInputContext->ContextFlags & DT_CONTEXT_CONTROL)==DT_CONTEXT_CONTROL) - { - pInputContext->Eip = m_rd->PC; - pInputContext->Esp = m_rd->SP; - pInputContext->Ebp = m_rd->FP; - } -} - diff --git a/src/coreclr/debug/di/loongarch64/cordbregisterset.cpp b/src/coreclr/debug/di/loongarch64/cordbregisterset.cpp index 8cce3050c7a9ba..faec1079c1b059 100644 --- a/src/coreclr/debug/di/loongarch64/cordbregisterset.cpp +++ b/src/coreclr/debug/di/loongarch64/cordbregisterset.cpp @@ -83,6 +83,105 @@ HRESULT CordbRegisterSet::GetRegistersAvailable(ULONG64* pAvailable) return S_OK; } +// Reads the value of a single register (identified by a CorDebugRegister index) into *pValue. +// Shared by both GetRegisters overloads to avoid duplicating the per-register mapping. +static HRESULT GetRegisterValue(CordbThread * pThread, const DT_CONTEXT * pContext, int regIndex, CORDB_REGISTER * pValue) +{ + if ((regIndex >= REGISTER_LOONGARCH64_F0) && (regIndex <= REGISTER_LOONGARCH64_F31)) + { + if (!pThread->m_fFloatStateValid) + { + HRESULT hr = S_OK; + EX_TRY + { + pThread->LoadFloatState(); + } + EX_CATCH_HRESULT(hr); + + if ( !SUCCEEDED(hr) ) + { + return hr; + } + LOG( ( LF_CORDB, LL_INFO1000, "CRS::GR: Loaded float state\n" ) ); + } + + *pValue = *(CORDB_REGISTER*)&(pThread->m_floatValues[(regIndex - REGISTER_LOONGARCH64_F0)]); + return S_OK; + } + + switch (regIndex) + { + case REGISTER_LOONGARCH64_A0: + *pValue = pContext->A0; break; + case REGISTER_LOONGARCH64_A1: + *pValue = pContext->A1; break; + case REGISTER_LOONGARCH64_A2: + *pValue = pContext->A2; break; + case REGISTER_LOONGARCH64_A3: + *pValue = pContext->A3; break; + case REGISTER_LOONGARCH64_A4: + *pValue = pContext->A4; break; + case REGISTER_LOONGARCH64_A5: + *pValue = pContext->A5; break; + case REGISTER_LOONGARCH64_A6: + *pValue = pContext->A6; break; + case REGISTER_LOONGARCH64_A7: + *pValue = pContext->A7; break; + case REGISTER_LOONGARCH64_S0: + *pValue = pContext->S0; break; + case REGISTER_LOONGARCH64_S1: + *pValue = pContext->S1; break; + case REGISTER_LOONGARCH64_S2: + *pValue = pContext->S2; break; + case REGISTER_LOONGARCH64_S3: + *pValue = pContext->S3; break; + case REGISTER_LOONGARCH64_S4: + *pValue = pContext->S4; break; + case REGISTER_LOONGARCH64_S5: + *pValue = pContext->S5; break; + case REGISTER_LOONGARCH64_S6: + *pValue = pContext->S6; break; + case REGISTER_LOONGARCH64_S7: + *pValue = pContext->S7; break; + case REGISTER_LOONGARCH64_S8: + *pValue = pContext->S8; break; + case REGISTER_LOONGARCH64_T0: + *pValue = pContext->T0; break; + case REGISTER_LOONGARCH64_T1: + *pValue = pContext->T1; break; + case REGISTER_LOONGARCH64_T2: + *pValue = pContext->T2; break; + case REGISTER_LOONGARCH64_T3: + *pValue = pContext->T3; break; + case REGISTER_LOONGARCH64_T4: + *pValue = pContext->T4; break; + case REGISTER_LOONGARCH64_T5: + *pValue = pContext->T5; break; + case REGISTER_LOONGARCH64_T6: + *pValue = pContext->T6; break; + case REGISTER_LOONGARCH64_T7: + *pValue = pContext->T7; break; + case REGISTER_LOONGARCH64_T8: + *pValue = pContext->T8; break; + case REGISTER_LOONGARCH64_X0: + *pValue = pContext->X0; break; + case REGISTER_LOONGARCH64_PC: + *pValue = pContext->Pc; break; + case REGISTER_LOONGARCH64_SP: + *pValue = pContext->Sp; break; + case REGISTER_LOONGARCH64_FP: + *pValue = pContext->Fp; break; + case REGISTER_LOONGARCH64_RA: + *pValue = pContext->Ra; break; + case REGISTER_LOONGARCH64_TP: + *pValue = pContext->Tp; break; + default: + _ASSERTE(false); break; + } + + return S_OK; +} + HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, CORDB_REGISTER regBuffer[]) { @@ -102,56 +201,12 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, { _ASSERTE (iRegister < regCount); - if ((i >= REGISTER_LOONGARCH64_A0) && (i <= REGISTER_LOONGARCH64_X0)) - { - regBuffer[iRegister++] = *(ULONG64*)((char*)(&m_rd->A0) + ((i - REGISTER_LOONGARCH64_A0) << 3)); - continue; - } - - if ((i >= REGISTER_LOONGARCH64_S0) && (i <= REGISTER_LOONGARCH64_S8)) - { - regBuffer[iRegister++] = *(ULONG64*)((char*)(&m_rd->S0) + ((i - REGISTER_LOONGARCH64_S0) << 3)); - continue; - } - - if ((i >= REGISTER_LOONGARCH64_F0) && (i <= REGISTER_LOONGARCH64_F31)) - { - if (!m_thread->m_fFloatStateValid) - { - HRESULT hr = S_OK; - EX_TRY - { - m_thread->LoadFloatState(); - } - EX_CATCH_HRESULT(hr); - - if ( !SUCCEEDED(hr) ) - { - return hr; - } - LOG( ( LF_CORDB, LL_INFO1000, "CRS::GR: Loaded float state\n" ) ); - } - - regBuffer[iRegister++] = *(CORDB_REGISTER*) - &(m_thread->m_floatValues[(i - REGISTER_LOONGARCH64_F0)]); - continue; - } - - switch (i) + HRESULT hr = GetRegisterValue(m_thread, &m_context, i, ®Buffer[iRegister]); + if (FAILED(hr)) { - case REGISTER_LOONGARCH64_PC: - regBuffer[iRegister++] = m_rd->PC; break; - case REGISTER_LOONGARCH64_SP: - regBuffer[iRegister++] = m_rd->SP; break; - case REGISTER_LOONGARCH64_FP: - regBuffer[iRegister++] = m_rd->FP; break; - case REGISTER_LOONGARCH64_RA: - regBuffer[iRegister++] = m_rd->RA; break; - case REGISTER_LOONGARCH64_TP: - regBuffer[iRegister++] = m_rd->TP; break; - default: - _ASSERTE(false); break; + return hr; } + iRegister++; } } @@ -200,95 +255,15 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], int i = m * 8 + bit; - if ((i >= REGISTER_LOONGARCH64_A0) && (i <= REGISTER_LOONGARCH64_X0)) - { - regBuffer[iRegister++] = *(ULONG64*)((char*)(&m_rd->A0) + ((i - REGISTER_LOONGARCH64_A0) << 3)); - continue; - } - - if ((i >= REGISTER_LOONGARCH64_S0) && (i <= REGISTER_LOONGARCH64_S8)) + HRESULT hr = GetRegisterValue(m_thread, &m_context, i, ®Buffer[iRegister]); + if (FAILED(hr)) { - regBuffer[iRegister++] = *(ULONG64*)((char*)(&m_rd->S0) + ((i - REGISTER_LOONGARCH64_S0) << 3)); - continue; - } - - - if ((i >= REGISTER_LOONGARCH64_F0) && (i <= REGISTER_LOONGARCH64_F31)) - { - if (!m_thread->m_fFloatStateValid) - { - HRESULT hr = S_OK; - EX_TRY - { - m_thread->LoadFloatState(); - } - EX_CATCH_HRESULT(hr); - - if ( !SUCCEEDED(hr) ) - { - return hr; - } - LOG( ( LF_CORDB, LL_INFO1000, "CRS::GR: Loaded float state\n" ) ); - } - - regBuffer[iRegister++] = *(CORDB_REGISTER*) - &(m_thread->m_floatValues[(i - REGISTER_LOONGARCH64_F0)]); - continue; - } - - switch (i) - { - case REGISTER_LOONGARCH64_PC: - regBuffer[iRegister++] = m_rd->PC; break; - case REGISTER_LOONGARCH64_SP: - regBuffer[iRegister++] = m_rd->SP; break; - case REGISTER_LOONGARCH64_FP: - regBuffer[iRegister++] = m_rd->FP; break; - case REGISTER_LOONGARCH64_RA: - regBuffer[iRegister++] = m_rd->RA; break; - case REGISTER_LOONGARCH64_TP: - regBuffer[iRegister++] = m_rd->TP; break; - default: - _ASSERTE(false); break; + return hr; } + iRegister++; } } } return S_OK; } - - -// This is just a convenience function to convert a regdisplay into a Context. -// Since a context has more info than a regdisplay, the conversion isn't perfect -// and the context can't be fully accurate. -void CordbRegisterSet::InternalCopyRDToContext(DT_CONTEXT *pInputContext) -{ INTERNAL_SYNC_API_ENTRY(GetProcess()); - _ASSERTE(pInputContext); - - if ((pInputContext->ContextFlags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - ULONG64* pDest = &pInputContext->A0; - ULONG64* pSrc = &m_rd->A0; - for (int i = REGISTER_LOONGARCH64_A0; i < REGISTER_LOONGARCH64_X0; ++i) - { - *pDest++ = *pSrc++; - } - - pDest = &pInputContext->S0; - pSrc = &m_rd->S0; - for (int i = REGISTER_LOONGARCH64_S0; i <= REGISTER_LOONGARCH64_S8; ++i) - { - *pDest++ = *pSrc++; - } - - pInputContext->Ra = m_rd->RA; - } - - if ((pInputContext->ContextFlags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pInputContext->Sp = m_rd->SP; - pInputContext->Pc = m_rd->PC; - pInputContext->Fp = m_rd->FP; - } -} diff --git a/src/coreclr/debug/di/riscv64/cordbregisterset.cpp b/src/coreclr/debug/di/riscv64/cordbregisterset.cpp index 7a80fd91dee26f..abda3421346d98 100644 --- a/src/coreclr/debug/di/riscv64/cordbregisterset.cpp +++ b/src/coreclr/debug/di/riscv64/cordbregisterset.cpp @@ -105,12 +105,3 @@ HRESULT CordbRegisterSet::GetRegisters(ULONG32 maskCount, BYTE mask[], _ASSERTE(!"RISCV64:NYI"); return S_OK; } - - -// This is just a convenience function to convert a regdisplay into a Context. -// Since a context has more info than a regdisplay, the conversion isn't perfect -// and the context can't be fully accurate. -void CordbRegisterSet::InternalCopyRDToContext(DT_CONTEXT *pInputContext) -{ - _ASSERTE(!"RISCV64:NYI"); -} diff --git a/src/coreclr/debug/di/rspriv.h b/src/coreclr/debug/di/rspriv.h index 84c9b8ce1ced51..a345389ae49c1b 100644 --- a/src/coreclr/debug/di/rspriv.h +++ b/src/coreclr/debug/di/rspriv.h @@ -6847,7 +6847,6 @@ class CordbNativeFrame : public CordbFrame, public ICorDebugNativeFrame, public FramePointer fp, CordbNativeCode * pNativeCode, SIZE_T ip, - DebuggerREGDISPLAY * pDRD, TADDR addrAmbientESP, CordbAppDomain * pCurrentAppDomain, CordbMiscFrame * pMisc = NULL, @@ -7025,8 +7024,6 @@ class CordbNativeFrame : public CordbFrame, public ICorDebugNativeFrame, public //----------------------------------------------------------- public: - // the register set - DebuggerREGDISPLAY m_rd; // each CordbNativeFrame corresponds to exactly one CordbJITILFrame and one CordbNativeCode RSSmartPtr m_JITILFrame; @@ -7040,8 +7037,6 @@ class CordbNativeFrame : public CordbFrame, public ICorDebugNativeFrame, public // (most likely in a frameless method) TADDR m_taAmbientESP; - // @dbgtodo inspection - When we DACize the various Cordb*Value classes, we should consider getting rid of the - // DebuggerREGDISPLAY and just use the CONTEXT. A lot of simplification can be done here. DT_CONTEXT m_context; }; @@ -7064,11 +7059,10 @@ class CordbNativeFrame : public CordbFrame, public ICorDebugNativeFrame, public class CordbRegisterSet : public CordbBase, public ICorDebugRegisterSet, public ICorDebugRegisterSet2 { public: - CordbRegisterSet(DebuggerREGDISPLAY * pRegDisplay, - CordbThread * pThread, + CordbRegisterSet(CordbThread * pThread, + DT_CONTEXT * pContext, bool fActive, - bool fQuickUnwind, - bool fTakeOwnershipOfDRD = false); + bool fQuickUnwind); ~CordbRegisterSet(); @@ -7164,23 +7158,15 @@ class CordbRegisterSet : public CordbBase, public ICorDebugRegisterSet, public I } protected: - // Platform specific helper for GetThreadContext. - void InternalCopyRDToContext(DT_CONTEXT * pContext); // Adapters to impl v2.0 interfaces on top of v1.0 interfaces. HRESULT GetRegistersAvailableAdapter(ULONG32 regCount, BYTE pAvailable[]); HRESULT GetRegistersAdapter(ULONG32 maskCount, BYTE mask[], ULONG32 regCount, CORDB_REGISTER regBuffer[]); - - // This CordbRegisterSet is responsible to free this memory if m_fTakeOwnershipOfDRD is true. Otherwise, - // this memory is freed by the CordbNativeFrame or CordbThread which creates this CordbRegisterSet. - DebuggerREGDISPLAY *m_rd; + DT_CONTEXT m_context; CordbThread *m_thread; bool m_active; // true if we're the leafmost register set. bool m_quickUnwind; - - // true if the CordbRegisterSet owns the DebuggerREGDISPLAY pointer and needs to free the memory - bool m_fTakeOwnershipOfDRD; } ; diff --git a/src/coreclr/debug/di/rsregsetcommon.cpp b/src/coreclr/debug/di/rsregsetcommon.cpp index ac8e3d97507a41..c5f7e85ee3cca4 100644 --- a/src/coreclr/debug/di/rsregsetcommon.cpp +++ b/src/coreclr/debug/di/rsregsetcommon.cpp @@ -18,22 +18,19 @@ CordbRegisterSet::CordbRegisterSet( - DebuggerREGDISPLAY * pRegDisplay, CordbThread * pThread, + DT_CONTEXT * pContext, bool fActive, - bool fQuickUnwind, - bool fTakeOwnershipOfDRD /*= false*/) + bool fQuickUnwind) : CordbBase(pThread->GetProcess(), 0, enumCordbRegisterSet) { - _ASSERTE( pRegDisplay != NULL ); + _ASSERTE( pContext != NULL ); _ASSERTE( pThread != NULL ); - m_rd = pRegDisplay; m_thread = pThread; + m_context = *pContext; m_active = fActive; m_quickUnwind = fQuickUnwind; - m_fTakeOwnershipOfDRD = fTakeOwnershipOfDRD; - // Add to our parent thread's neuter list. HRESULT hr = S_OK; @@ -48,12 +45,6 @@ CordbRegisterSet::CordbRegisterSet( void CordbRegisterSet::Neuter() { m_thread = NULL; - if (m_fTakeOwnershipOfDRD) - { - delete m_rd; - } - m_rd = NULL; - CordbBase::Neuter(); } @@ -153,11 +144,7 @@ HRESULT CordbRegisterSet::GetThreadContext(ULONG32 contextSize, BYTE context[]) memmove( pInputContext, pLeafContext, sizeof( DT_CONTEXT) ); } } - - - // Now update the registers based on the current frame. - // This is a very platform specific action. - InternalCopyRDToContext(pInputContext); + CORDbgCopyThreadContext(pInputContext, &m_context); } EX_CATCH_HRESULT(hr); return hr; diff --git a/src/coreclr/debug/di/rsstackwalk.cpp b/src/coreclr/debug/di/rsstackwalk.cpp index 1540ae24ae5ddf..672d83b133122e 100644 --- a/src/coreclr/debug/di/rsstackwalk.cpp +++ b/src/coreclr/debug/di/rsstackwalk.cpp @@ -578,16 +578,12 @@ HRESULT CordbStackWalk::GetFrameWorker(ICorDebugFrame ** ppFrame) Debugger_STRData frameData; ZeroMemory(&frameData, sizeof(frameData)); - // Allocate the DT_CONTEXT and DebuggerREGDISPLAY buffers on the dbi stack and - // hand their addresses to the DAC via Debugger_STRData. The DAC writes the - // populated context/regdisplay through these pointers. See the comment on - // Debugger_STRData in dbgipcevents.h for the protocol. + // Allocate the DT_CONTEXT buffer on the dbi stack and + // hand the address to the DAC via Debugger_STRData. The DAC writes the + // populated context through this pointer. DT_CONTEXT frameCtx; - DebuggerREGDISPLAY frameRd; ZeroMemory(&frameCtx, sizeof(frameCtx)); - ZeroMemory(&frameRd, sizeof(frameRd)); frameData.ctx = &frameCtx; - frameData.rd = &frameRd; IDacDbiInterface::FrameType ft = IDacDbiInterface::kInvalid; @@ -693,7 +689,6 @@ HRESULT CordbStackWalk::GetFrameWorker(ICorDebugFrame ** ppFrame) frameData.fp, pNativeCode, (SIZE_T)pJITFuncData->nativeOffset, - &frameRd, (TADDR)frameData.v.taAmbientESP, pCurrentAppDomain, &miscFrame, diff --git a/src/coreclr/debug/di/rsthread.cpp b/src/coreclr/debug/di/rsthread.cpp index 4c1de068775829..ad5f3f596ac0d7 100644 --- a/src/coreclr/debug/di/rsthread.cpp +++ b/src/coreclr/debug/di/rsthread.cpp @@ -328,21 +328,11 @@ void CordbThread::CreateCordbRegisterSet(DT_CONTEXT * pContext, IfFailThrow(EnsureThreadIsAlive()); - // The CordbRegisterSet is responsible for freeing this memory. - NewHolder pDRD(new DebuggerREGDISPLAY()); - - // convert the CONTEXT to a DebuggerREGDISPLAY - IDacDbiInterface * pDAC = GetProcess()->GetDAC(); - IfFailThrow(pDAC->ConvertContextToDebuggerRegDisplay(pContext, pDRD, fLeaf)); - // create the CordbRegisterSet - RSInitHolder pRS(new CordbRegisterSet(pDRD, - this, + RSInitHolder pRS(new CordbRegisterSet(this, + pContext, (fLeaf == TRUE), - (reason == CHAIN_ENTER_MANAGED), - true)); - pDRD.SuppressRelease(); - + (reason == CHAIN_ENTER_MANAGED))); pRS.TransferOwnershipExternal(ppRegSet); } @@ -1160,20 +1150,11 @@ HRESULT CordbThread::GetRegisterSet(ICorDebugRegisterSet ** ppRegisters) hr = pSW->GetContext(CONTEXT_FULL, sizeof(ctx), NULL, reinterpret_cast(&ctx)); IfFailThrow(hr); - // the CordbRegisterSet is responsible for freeing this memory - NewHolder pDRD(new DebuggerREGDISPLAY()); - - // convert the CONTEXT to a DebuggerREGDISPLAY - IDacDbiInterface * pDAC = GetProcess()->GetDAC(); - IfFailThrow(pDAC->ConvertContextToDebuggerRegDisplay(&ctx, pDRD, true)); - // create the CordbRegisterSet - RSInitHolder pRS(new CordbRegisterSet(pDRD, - this, + RSInitHolder pRS(new CordbRegisterSet(this, + &ctx, true, // active - false, // !fQuickUnwind - true)); // own DRD memory - pDRD.SuppressRelease(); + false)); pRS.TransferOwnershipExternal(ppRegisters); } @@ -3923,7 +3904,7 @@ HRESULT CordbUnmanagedThread::SetupGenericHijack(DWORD eventCode, const EXCEPTIO HRESULT CordbUnmanagedThread::FixupFromGenericHijack() { LOG((LF_CORDB, LL_INFO1000, "CUT::FFGH: fixing up from generic hijack. Eip=0x%p, Esp=0x%p\n", - CORDbgGetIP(GetHijackCtx()), CORDbgGetSP(GetHijackCtx()))); + CORDbgGetIP(GetHijackCtx()), CORDB_ADDRESS_TO_PTR(CORDbgGetSP(GetHijackCtx())))); // We're no longer hijacked _ASSERTE(IsGenericHijacked()); @@ -4437,23 +4418,6 @@ HRESULT RemoveRemotePatch(CordbProcess * pProcess, const void * pRemoteAddress, } #endif // FEATURE_INTEROP_DEBUGGING -//--------------------------------------------------------------------------------------- -// -// Simple helper to return the SP value stored in a DebuggerREGDISPLAY. -// -// Arguments: -// pDRD - the DebuggerREGDISPLAY in question -// -// Return Value: -// the SP value -// - -inline CORDB_ADDRESS GetSPFromDebuggerREGDISPLAY(DebuggerREGDISPLAY* pDRD) -{ - return pDRD->SP; -} - - /* ------------------------------------------------------------------------- * * Frame class * ------------------------------------------------------------------------- */ @@ -5334,7 +5298,7 @@ BOOL CordbInternalFrame::IsCloserToLeafWorker(ICorDebugFrame * pFrameToCompare) // Compare the address of the "this" internal frame to the SP of the stack frame. // We can't compare frame pointers because the frame pointer means different things on // different platforms. - CORDB_ADDRESS stackFrameSP = GetSPFromDebuggerREGDISPLAY(&(pCNativeFrame->m_rd)); + CORDB_ADDRESS stackFrameSP = CORDbgGetSP(pCNativeFrame->GetContext()); return (thisFrameAddr < stackFrameSP); } @@ -5347,7 +5311,7 @@ BOOL CordbInternalFrame::IsCloserToLeafWorker(ICorDebugFrame * pFrameToCompare) static_cast(pRUFrame.GetValue()); DT_CONTEXT * pResumeContext = const_cast(pCRUFrame->GetContext()); - CORDB_ADDRESS stackFrameSP = PTR_TO_CORDB_ADDRESS(CORDbgGetSP(pResumeContext)); + CORDB_ADDRESS stackFrameSP = CORDbgGetSP(pResumeContext); return (thisFrameAddr < stackFrameSP); } @@ -5480,13 +5444,11 @@ CordbNativeFrame::CordbNativeFrame(CordbThread * pThread, FramePointer fp, CordbNativeCode * pNativeCode, SIZE_T ip, - DebuggerREGDISPLAY * pDRD, TADDR taAmbientESP, CordbAppDomain * pCurrentAppDomain, CordbMiscFrame * pMisc /*= NULL*/, DT_CONTEXT * pContext /*= NULL*/) : CordbFrame(pThread, fp, ip, pCurrentAppDomain), - m_rd(*pDRD), m_JITILFrame(NULL), m_nativeCode(pNativeCode), // implicit InternalAddRef m_taAmbientESP(taAmbientESP) @@ -5808,7 +5770,7 @@ HRESULT CordbNativeFrame::GetStackRange(CORDB_ADDRESS *pStart, if (pStart) { // From register set. - *pStart = GetSPFromDebuggerREGDISPLAY(&m_rd); + *pStart = CORDbgGetSP(&m_context); } if (pEnd) @@ -5848,8 +5810,8 @@ HRESULT CordbNativeFrame::GetRegisterSet(ICorDebugRegisterSet **ppRegisters) EX_TRY { // allocate a new CordbRegisterSet object - RSInitHolder pRegisterSet(new CordbRegisterSet(&m_rd, - m_pThread, + RSInitHolder pRegisterSet(new CordbRegisterSet(m_pThread, + &m_context, IsLeafFrame(), false)); @@ -5998,159 +5960,159 @@ UINT_PTR * CordbNativeFrame::GetAddressOfRegister(CorDebugRegister regNum) const switch (regNum) { case REGISTER_STACK_POINTER: - ret = (UINT_PTR*)GetSPAddress(&m_rd); + ret = (UINT_PTR*)GetSPAddress(&m_context); break; #if !defined(TARGET_AMD64) && !defined(TARGET_ARM) // @ARMTODO case REGISTER_FRAME_POINTER: - ret = (UINT_PTR*)GetFPAddress(&m_rd); + ret = (UINT_PTR*)GetFPAddress(&m_context); break; #endif #if defined(TARGET_X86) case REGISTER_X86_EAX: - ret = (UINT_PTR*)&m_rd.Eax; + ret = (UINT_PTR*)&m_context.Eax; break; case REGISTER_X86_ECX: - ret = (UINT_PTR*)&m_rd.Ecx; + ret = (UINT_PTR*)&m_context.Ecx; break; case REGISTER_X86_EDX: - ret = (UINT_PTR*)&m_rd.Edx; + ret = (UINT_PTR*)&m_context.Edx; break; case REGISTER_X86_EBX: - ret = (UINT_PTR*)&m_rd.Ebx; + ret = (UINT_PTR*)&m_context.Ebx; break; case REGISTER_X86_ESI: - ret = (UINT_PTR*)&m_rd.Esi; + ret = (UINT_PTR*)&m_context.Esi; break; case REGISTER_X86_EDI: - ret = (UINT_PTR*)&m_rd.Edi; + ret = (UINT_PTR*)&m_context.Edi; break; #elif defined(TARGET_AMD64) case REGISTER_AMD64_RBP: - ret = (UINT_PTR*)&m_rd.Rbp; + ret = (UINT_PTR*)&m_context.Rbp; break; case REGISTER_AMD64_RAX: - ret = (UINT_PTR*)&m_rd.Rax; + ret = (UINT_PTR*)&m_context.Rax; break; case REGISTER_AMD64_RCX: - ret = (UINT_PTR*)&m_rd.Rcx; + ret = (UINT_PTR*)&m_context.Rcx; break; case REGISTER_AMD64_RDX: - ret = (UINT_PTR*)&m_rd.Rdx; + ret = (UINT_PTR*)&m_context.Rdx; break; case REGISTER_AMD64_RBX: - ret = (UINT_PTR*)&m_rd.Rbx; + ret = (UINT_PTR*)&m_context.Rbx; break; case REGISTER_AMD64_RSI: - ret = (UINT_PTR*)&m_rd.Rsi; + ret = (UINT_PTR*)&m_context.Rsi; break; case REGISTER_AMD64_RDI: - ret = (UINT_PTR*)&m_rd.Rdi; + ret = (UINT_PTR*)&m_context.Rdi; break; case REGISTER_AMD64_R8: - ret = (UINT_PTR*)&m_rd.R8; + ret = (UINT_PTR*)&m_context.R8; break; case REGISTER_AMD64_R9: - ret = (UINT_PTR*)&m_rd.R9; + ret = (UINT_PTR*)&m_context.R9; break; case REGISTER_AMD64_R10: - ret = (UINT_PTR*)&m_rd.R10; + ret = (UINT_PTR*)&m_context.R10; break; case REGISTER_AMD64_R11: - ret = (UINT_PTR*)&m_rd.R11; + ret = (UINT_PTR*)&m_context.R11; break; case REGISTER_AMD64_R12: - ret = (UINT_PTR*)&m_rd.R12; + ret = (UINT_PTR*)&m_context.R12; break; case REGISTER_AMD64_R13: - ret = (UINT_PTR*)&m_rd.R13; + ret = (UINT_PTR*)&m_context.R13; break; case REGISTER_AMD64_R14: - ret = (UINT_PTR*)&m_rd.R14; + ret = (UINT_PTR*)&m_context.R14; break; case REGISTER_AMD64_R15: - ret = (UINT_PTR*)&m_rd.R15; + ret = (UINT_PTR*)&m_context.R15; break; #elif defined(TARGET_ARM) case REGISTER_ARM_R0: - ret = (UINT_PTR*)&m_rd.R0; + ret = (UINT_PTR*)&m_context.R0; break; case REGISTER_ARM_R1: - ret = (UINT_PTR*)&m_rd.R1; + ret = (UINT_PTR*)&m_context.R1; break; case REGISTER_ARM_R2: - ret = (UINT_PTR*)&m_rd.R2; + ret = (UINT_PTR*)&m_context.R2; break; case REGISTER_ARM_R3: - ret = (UINT_PTR*)&m_rd.R3; + ret = (UINT_PTR*)&m_context.R3; break; case REGISTER_ARM_R4: - ret = (UINT_PTR*)&m_rd.R4; + ret = (UINT_PTR*)&m_context.R4; break; case REGISTER_ARM_R5: - ret = (UINT_PTR*)&m_rd.R5; + ret = (UINT_PTR*)&m_context.R5; break; case REGISTER_ARM_R6: - ret = (UINT_PTR*)&m_rd.R6; + ret = (UINT_PTR*)&m_context.R6; break; case REGISTER_ARM_R7: - ret = (UINT_PTR*)&m_rd.R7; + ret = (UINT_PTR*)&m_context.R7; break; case REGISTER_ARM_R8: - ret = (UINT_PTR*)&m_rd.R8; + ret = (UINT_PTR*)&m_context.R8; break; case REGISTER_ARM_R9: - ret = (UINT_PTR*)&m_rd.R9; + ret = (UINT_PTR*)&m_context.R9; break; case REGISTER_ARM_R10: - ret = (UINT_PTR*)&m_rd.R10; + ret = (UINT_PTR*)&m_context.R10; break; case REGISTER_ARM_R11: - ret = (UINT_PTR*)&m_rd.R11; + ret = (UINT_PTR*)&m_context.R11; break; case REGISTER_ARM_R12: - ret = (UINT_PTR*)&m_rd.R12; + ret = (UINT_PTR*)&m_context.R12; break; case REGISTER_ARM_LR: - ret = (UINT_PTR*)&m_rd.LR; + ret = (UINT_PTR*)&m_context.Lr; break; case REGISTER_ARM_PC: - ret = (UINT_PTR*)&m_rd.PC; + ret = (UINT_PTR*)&m_context.Pc; break; #elif defined(TARGET_ARM64) case REGISTER_ARM64_X0: @@ -6182,255 +6144,255 @@ UINT_PTR * CordbNativeFrame::GetAddressOfRegister(CorDebugRegister regNum) const case REGISTER_ARM64_X26: case REGISTER_ARM64_X27: case REGISTER_ARM64_X28: - ret = (UINT_PTR*)&m_rd.X[regNum - REGISTER_ARM64_X0]; + ret = (UINT_PTR*)&m_context.X[regNum - REGISTER_ARM64_X0]; break; case REGISTER_ARM64_LR: - ret = (UINT_PTR*)&m_rd.LR; + ret = (UINT_PTR*)&m_context.Lr; break; case REGISTER_ARM64_PC: - ret = (UINT_PTR*)&m_rd.PC; + ret = (UINT_PTR*)&m_context.Pc; break; #elif defined(TARGET_RISCV64) case REGISTER_RISCV64_PC: - ret = (UINT_PTR*)&m_rd.PC; + ret = (UINT_PTR*)&m_context.Pc; break; case REGISTER_RISCV64_RA: - ret = (UINT_PTR*)&m_rd.RA; + ret = (UINT_PTR*)&m_context.Ra; break; case REGISTER_RISCV64_GP: - ret = (UINT_PTR*)&m_rd.GP; + ret = (UINT_PTR*)&m_context.Gp; break; case REGISTER_RISCV64_TP: - ret = (UINT_PTR*)&m_rd.TP; + ret = (UINT_PTR*)&m_context.Tp; break; case REGISTER_RISCV64_T0: - ret = (UINT_PTR*)&m_rd.T0; + ret = (UINT_PTR*)&m_context.T0; break; case REGISTER_RISCV64_T1: - ret = (UINT_PTR*)&m_rd.T1; + ret = (UINT_PTR*)&m_context.T1; break; case REGISTER_RISCV64_T2: - ret = (UINT_PTR*)&m_rd.T2; + ret = (UINT_PTR*)&m_context.T2; break; case REGISTER_RISCV64_S1: - ret = (UINT_PTR*)&m_rd.S1; + ret = (UINT_PTR*)&m_context.S1; break; case REGISTER_RISCV64_A0: - ret = (UINT_PTR*)&m_rd.A0; + ret = (UINT_PTR*)&m_context.A0; break; case REGISTER_RISCV64_A1: - ret = (UINT_PTR*)&m_rd.A1; + ret = (UINT_PTR*)&m_context.A1; break; case REGISTER_RISCV64_A2: - ret = (UINT_PTR*)&m_rd.A2; + ret = (UINT_PTR*)&m_context.A2; break; case REGISTER_RISCV64_A3: - ret = (UINT_PTR*)&m_rd.A3; + ret = (UINT_PTR*)&m_context.A3; break; case REGISTER_RISCV64_A4: - ret = (UINT_PTR*)&m_rd.A4; + ret = (UINT_PTR*)&m_context.A4; break; case REGISTER_RISCV64_A5: - ret = (UINT_PTR*)&m_rd.A5; + ret = (UINT_PTR*)&m_context.A5; break; case REGISTER_RISCV64_A6: - ret = (UINT_PTR*)&m_rd.A6; + ret = (UINT_PTR*)&m_context.A6; break; case REGISTER_RISCV64_A7: - ret = (UINT_PTR*)&m_rd.A7; + ret = (UINT_PTR*)&m_context.A7; break; case REGISTER_RISCV64_S2: - ret = (UINT_PTR*)&m_rd.S2; + ret = (UINT_PTR*)&m_context.S2; break; case REGISTER_RISCV64_S3: - ret = (UINT_PTR*)&m_rd.S3; + ret = (UINT_PTR*)&m_context.S3; break; case REGISTER_RISCV64_S4: - ret = (UINT_PTR*)&m_rd.S4; + ret = (UINT_PTR*)&m_context.S4; break; case REGISTER_RISCV64_S5: - ret = (UINT_PTR*)&m_rd.S5; + ret = (UINT_PTR*)&m_context.S5; break; case REGISTER_RISCV64_S6: - ret = (UINT_PTR*)&m_rd.S6; + ret = (UINT_PTR*)&m_context.S6; break; case REGISTER_RISCV64_S7: - ret = (UINT_PTR*)&m_rd.S7; + ret = (UINT_PTR*)&m_context.S7; break; case REGISTER_RISCV64_S8: - ret = (UINT_PTR*)&m_rd.S8; + ret = (UINT_PTR*)&m_context.S8; break; case REGISTER_RISCV64_S9: - ret = (UINT_PTR*)&m_rd.S9; + ret = (UINT_PTR*)&m_context.S9; break; case REGISTER_RISCV64_S10: - ret = (UINT_PTR*)&m_rd.S10; + ret = (UINT_PTR*)&m_context.S10; break; case REGISTER_RISCV64_S11: - ret = (UINT_PTR*)&m_rd.S11; + ret = (UINT_PTR*)&m_context.S11; break; case REGISTER_RISCV64_T3: - ret = (UINT_PTR*)&m_rd.T3; + ret = (UINT_PTR*)&m_context.T3; break; case REGISTER_RISCV64_T4: - ret = (UINT_PTR*)&m_rd.T4; + ret = (UINT_PTR*)&m_context.T4; break; case REGISTER_RISCV64_T5: - ret = (UINT_PTR*)&m_rd.T5; + ret = (UINT_PTR*)&m_context.T5; break; case REGISTER_RISCV64_T6: - ret = (UINT_PTR*)&m_rd.T6; + ret = (UINT_PTR*)&m_context.T6; break; #elif defined(TARGET_LOONGARCH64) case REGISTER_LOONGARCH64_PC: - ret = (UINT_PTR*)&m_rd.PC; + ret = (UINT_PTR*)&m_context.Pc; break; case REGISTER_LOONGARCH64_RA: - ret = (UINT_PTR*)&m_rd.RA; + ret = (UINT_PTR*)&m_context.Ra; break; case REGISTER_LOONGARCH64_TP: - ret = (UINT_PTR*)&m_rd.TP; + ret = (UINT_PTR*)&m_context.Tp; break; case REGISTER_LOONGARCH64_A0: - ret = (UINT_PTR*)&m_rd.A0; + ret = (UINT_PTR*)&m_context.A0; break; case REGISTER_LOONGARCH64_A1: - ret = (UINT_PTR*)&m_rd.A1; + ret = (UINT_PTR*)&m_context.A1; break; case REGISTER_LOONGARCH64_A2: - ret = (UINT_PTR*)&m_rd.A2; + ret = (UINT_PTR*)&m_context.A2; break; case REGISTER_LOONGARCH64_A3: - ret = (UINT_PTR*)&m_rd.A3; + ret = (UINT_PTR*)&m_context.A3; break; case REGISTER_LOONGARCH64_A4: - ret = (UINT_PTR*)&m_rd.A4; + ret = (UINT_PTR*)&m_context.A4; break; case REGISTER_LOONGARCH64_A5: - ret = (UINT_PTR*)&m_rd.A5; + ret = (UINT_PTR*)&m_context.A5; break; case REGISTER_LOONGARCH64_A6: - ret = (UINT_PTR*)&m_rd.A6; + ret = (UINT_PTR*)&m_context.A6; break; case REGISTER_LOONGARCH64_A7: - ret = (UINT_PTR*)&m_rd.A7; + ret = (UINT_PTR*)&m_context.A7; break; case REGISTER_LOONGARCH64_T0: - ret = (UINT_PTR*)&m_rd.T0; + ret = (UINT_PTR*)&m_context.T0; break; case REGISTER_LOONGARCH64_T1: - ret = (UINT_PTR*)&m_rd.T1; + ret = (UINT_PTR*)&m_context.T1; break; case REGISTER_LOONGARCH64_T2: - ret = (UINT_PTR*)&m_rd.T2; + ret = (UINT_PTR*)&m_context.T2; break; case REGISTER_LOONGARCH64_T3: - ret = (UINT_PTR*)&m_rd.T3; + ret = (UINT_PTR*)&m_context.T3; break; case REGISTER_LOONGARCH64_T4: - ret = (UINT_PTR*)&m_rd.T4; + ret = (UINT_PTR*)&m_context.T4; break; case REGISTER_LOONGARCH64_T5: - ret = (UINT_PTR*)&m_rd.T5; + ret = (UINT_PTR*)&m_context.T5; break; case REGISTER_LOONGARCH64_T6: - ret = (UINT_PTR*)&m_rd.T6; + ret = (UINT_PTR*)&m_context.T6; break; case REGISTER_LOONGARCH64_T7: - ret = (UINT_PTR*)&m_rd.T7; + ret = (UINT_PTR*)&m_context.T7; break; case REGISTER_LOONGARCH64_T8: - ret = (UINT_PTR*)&m_rd.T8; + ret = (UINT_PTR*)&m_context.T8; break; case REGISTER_LOONGARCH64_X0: - ret = (UINT_PTR*)&m_rd.X0; + ret = (UINT_PTR*)&m_context.X0; break; case REGISTER_LOONGARCH64_S0: - ret = (UINT_PTR*)&m_rd.S0; + ret = (UINT_PTR*)&m_context.S0; break; case REGISTER_LOONGARCH64_S1: - ret = (UINT_PTR*)&m_rd.S1; + ret = (UINT_PTR*)&m_context.S1; break; case REGISTER_LOONGARCH64_S2: - ret = (UINT_PTR*)&m_rd.S2; + ret = (UINT_PTR*)&m_context.S2; break; case REGISTER_LOONGARCH64_S3: - ret = (UINT_PTR*)&m_rd.S3; + ret = (UINT_PTR*)&m_context.S3; break; case REGISTER_LOONGARCH64_S4: - ret = (UINT_PTR*)&m_rd.S4; + ret = (UINT_PTR*)&m_context.S4; break; case REGISTER_LOONGARCH64_S5: - ret = (UINT_PTR*)&m_rd.S5; + ret = (UINT_PTR*)&m_context.S5; break; case REGISTER_LOONGARCH64_S6: - ret = (UINT_PTR*)&m_rd.S6; + ret = (UINT_PTR*)&m_context.S6; break; case REGISTER_LOONGARCH64_S7: - ret = (UINT_PTR*)&m_rd.S7; + ret = (UINT_PTR*)&m_context.S7; break; case REGISTER_LOONGARCH64_S8: - ret = (UINT_PTR*)&m_rd.S8; + ret = (UINT_PTR*)&m_context.S8; break; #endif @@ -6447,9 +6409,7 @@ UINT_PTR * CordbNativeFrame::GetAddressOfRegister(CorDebugRegister regNum) const // CORDB_ADDRESS CordbNativeFrame::GetLeftSideAddressOfRegister(CorDebugRegister regNum) const { -#if !defined(USE_REMOTE_REGISTER_ADDRESS) // Use marker values as the register address. This is to implement the funceval breaking change. - // if (IsLeafFrame()) { return kLeafFrameRegAddr; @@ -6458,111 +6418,6 @@ CORDB_ADDRESS CordbNativeFrame::GetLeftSideAddressOfRegister(CorDebugRegister re { return kNonLeafFrameRegAddr; } - -#else // USE_REMOTE_REGISTER_ADDRESS - void* ret = 0; - - switch (regNum) - { - -#if !defined(TARGET_AMD64) - case REGISTER_FRAME_POINTER: - ret = m_rd.pFP; - break; -#endif - -#if defined(TARGET_X86) - case REGISTER_X86_EAX: - ret = m_rd.pEax; - break; - - case REGISTER_X86_ECX: - ret = m_rd.pEcx; - break; - - case REGISTER_X86_EDX: - ret = m_rd.pEdx; - break; - - case REGISTER_X86_EBX: - ret = m_rd.pEbx; - break; - - case REGISTER_X86_ESI: - ret = m_rd.pEsi; - break; - - case REGISTER_X86_EDI: - ret = m_rd.pEdi; - break; - -#elif defined(TARGET_AMD64) - case REGISTER_AMD64_RBP: - ret = m_rd.pRbp; - break; - - case REGISTER_AMD64_RAX: - ret = m_rd.pRax; - break; - - case REGISTER_AMD64_RCX: - ret = m_rd.pRcx; - break; - - case REGISTER_AMD64_RDX: - ret = m_rd.pRdx; - break; - - case REGISTER_AMD64_RBX: - ret = m_rd.pRbx; - break; - - case REGISTER_AMD64_RSI: - ret = m_rd.pRsi; - break; - - case REGISTER_AMD64_RDI: - ret = m_rd.pRdi; - break; - - case REGISTER_AMD64_R8: - ret = m_rd.pR8; - break; - - case REGISTER_AMD64_R9: - ret = m_rd.pR9; - break; - - case REGISTER_AMD64_R10: - ret = m_rd.pR10; - break; - - case REGISTER_AMD64_R11: - ret = m_rd.pR11; - break; - - case REGISTER_AMD64_R12: - ret = m_rd.pR12; - break; - - case REGISTER_AMD64_R13: - ret = m_rd.pR13; - break; - - case REGISTER_AMD64_R14: - ret = m_rd.pR14; - break; - - case REGISTER_AMD64_R15: - ret = m_rd.pR15; - break; -#endif - default: - _ASSERT(!"Invalid register number!"); - } - - return PTR_TO_CORDB_ADDRESS(ret); -#endif // !USE_REMOTE_REGISTER_ADDRESS } diff --git a/src/coreclr/debug/di/shimstackwalk.cpp b/src/coreclr/debug/di/shimstackwalk.cpp index 6dd04eba5d4eb3..c580bb0c7842ce 100644 --- a/src/coreclr/debug/di/shimstackwalk.cpp +++ b/src/coreclr/debug/di/shimstackwalk.cpp @@ -956,7 +956,7 @@ void ShimStackWalk::GetCalleeForFrame(ICorDebugFrame * pFrame, ICorDebugFrame ** FramePointer ShimStackWalk::GetFramePointerForChain(DT_CONTEXT * pContext) { - return FramePointer::MakeFramePointer(CORDbgGetSP(pContext)); + return FramePointer::MakeFramePointer(CORDB_ADDRESS_TO_PTR(CORDbgGetSP(pContext))); } FramePointer ShimStackWalk::GetFramePointerForChain(ICorDebugInternalFrame2 * pInternalFrame2) @@ -1118,7 +1118,7 @@ void ShimStackWalk::AppendChain(ChainInfo * pChainInfo, StackWalkInfo * pStackWa { // We need to send an extra enter-managed chain. _ASSERTE(pChainInfo->m_fLeafNativeContextIsValid); - BYTE * sp = reinterpret_cast(CORDbgGetSP(&(pChainInfo->m_leafNativeContext))); + BYTE * sp = reinterpret_cast(CORDB_ADDRESS_TO_PTR(CORDbgGetSP(&(pChainInfo->m_leafNativeContext)))); #if !defined(TARGET_ARM) && !defined(TARGET_ARM64) // Dev11 324806: on ARM we use the caller's SP for a frame's ending delimiter so we cannot // subtract 4 bytes from the chain's ending delimiter else the frame might never be in range. @@ -1229,7 +1229,7 @@ BOOL ShimStackWalk::CheckInternalFrame(ICorDebugFrame * pNextStackFrame, IfFailThrow(hr); // Get the SP from the CONTEXT. This is the caller SP. - CORDB_ADDRESS sp = PTR_TO_CORDB_ADDRESS(CORDbgGetSP(&ctx)); + CORDB_ADDRESS sp = CORDbgGetSP(&ctx); // get the frame address CORDB_ADDRESS frameAddr = 0; @@ -1677,7 +1677,7 @@ HRESULT ShimChain::GetStackRange(CORDB_ADDRESS * pStart, CORDB_ADDRESS * pEnd) // The leafmost end is represented by the register set. if (pStart) { - *pStart = PTR_TO_CORDB_ADDRESS(CORDbgGetSP(&m_context)); + *pStart = CORDbgGetSP(&m_context); } // Return the rootmost end of the stack range. It is represented by the frame pointer of the chain. diff --git a/src/coreclr/debug/ee/CMakeLists.txt b/src/coreclr/debug/ee/CMakeLists.txt index 2c1191d64a7da7..ea6b9be52ab3b7 100644 --- a/src/coreclr/debug/ee/CMakeLists.txt +++ b/src/coreclr/debug/ee/CMakeLists.txt @@ -56,7 +56,7 @@ if(FEATURE_INTERPRETER) endif(FEATURE_INTERPRETER) if (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) - list(APPEND CORDBEE_SOURCES_WKS ${ARCH_SOURCES_DIR}/debuggerregdisplayhelper.cpp) + list(APPEND CORDBEE_SOURCES_WKS ${ARCH_SOURCES_DIR}/regdisplayhelper.cpp) endif () convert_to_absolute_path(CORDBEE_SOURCES_DAC ${CORDBEE_SOURCES_DAC}) diff --git a/src/coreclr/debug/ee/amd64/debuggerregdisplayhelper.cpp b/src/coreclr/debug/ee/amd64/regdisplayhelper.cpp similarity index 82% rename from src/coreclr/debug/ee/amd64/debuggerregdisplayhelper.cpp rename to src/coreclr/debug/ee/amd64/regdisplayhelper.cpp index 4ca44c44411777..b0e31e16099bca 100644 --- a/src/coreclr/debug/ee/amd64/debuggerregdisplayhelper.cpp +++ b/src/coreclr/debug/ee/amd64/regdisplayhelper.cpp @@ -1,11 +1,9 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. /* ------------------------------------------------------------------------- * - * DebuggerRegDisplayHelper.cpp -- implementation of the platform-dependent -// - - * methods for transferring information between - * REGDISPLAY and DebuggerREGDISPLAY + * RegDisplayHelper.cpp -- implementation of the platform-dependent + * methods for transferring information between + * REGDISPLAYs * ------------------------------------------------------------------------- */ #include "stdafx.h" diff --git a/src/coreclr/debug/ee/debugger.h b/src/coreclr/debug/ee/debugger.h index 20823514e529e8..7b995d878f4909 100644 --- a/src/coreclr/debug/ee/debugger.h +++ b/src/coreclr/debug/ee/debugger.h @@ -364,32 +364,7 @@ inline bool ThisMaybeHelperThread() { return true; } #endif - -// These are methods for transferring information between a REGDISPLAY and -// a DebuggerREGDISPLAY. extern void CopyREGDISPLAY(REGDISPLAY* pDst, REGDISPLAY* pSrc); -extern void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD); - -// -// 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. -// -// This macro is used in CopyREGDISPLAY() and SetDebuggerREGDISPLAYFromREGDISPLAY(). We really should make -// DebuggerREGDISPLAY to be a class with these two methods, but unfortunately, the RS has no notion of REGDISPLAY. -inline LPVOID PushedRegAddr(REGDISPLAY* pRD, LPVOID pAddr) -{ - LIMITED_METHOD_CONTRACT; - - if ( ((UINT_PTR)(pAddr) >= (UINT_PTR)pRD->pCurrentContextPointers) && - ((UINT_PTR)(pAddr) <= ((UINT_PTR)pRD->pCurrentContextPointers + sizeof(T_KNONVOLATILE_CONTEXT_POINTERS))) ) - - return NULL; - - // (Microsoft 2/9/07 - putting this in an else clause confuses gcc for some reason, so I've moved - // it to here) - return pAddr; -} - bool HandleIPCEventWrapper(Debugger* pDebugger, DebuggerIPCEvent *e); HRESULT ValidateObject(Object *objPtr); diff --git a/src/coreclr/debug/ee/i386/debuggerregdisplayhelper.cpp b/src/coreclr/debug/ee/i386/regdisplayhelper.cpp similarity index 81% rename from src/coreclr/debug/ee/i386/debuggerregdisplayhelper.cpp rename to src/coreclr/debug/ee/i386/regdisplayhelper.cpp index 17923a7a8281cd..d8e571ae139e2d 100644 --- a/src/coreclr/debug/ee/i386/debuggerregdisplayhelper.cpp +++ b/src/coreclr/debug/ee/i386/regdisplayhelper.cpp @@ -1,11 +1,9 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. /* ------------------------------------------------------------------------- * - * DebuggerRegDisplayHelper.cpp -- implementation of the platform-dependent -// - - * methods for transferring information between - * REGDISPLAY and DebuggerREGDISPLAY + * RegDisplayHelper.cpp -- implementation of the platform-dependent + * methods for transferring information between + * REGDISPLAYs * ------------------------------------------------------------------------- */ #include "stdafx.h" diff --git a/src/coreclr/debug/inc/amd64/primitives.h b/src/coreclr/debug/inc/amd64/primitives.h index 678badee1136a9..7980e11dcb9695 100644 --- a/src/coreclr/debug/inc/amd64/primitives.h +++ b/src/coreclr/debug/inc/amd64/primitives.h @@ -116,7 +116,7 @@ inline void CORDbgSetIP(DT_CONTEXT* context, LPVOID rip) context->Rip = (DWORD64) rip; } -inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) +inline CORDB_ADDRESS CORDbgGetSP(const DT_CONTEXT * context) { CONTRACTL { @@ -127,7 +127,7 @@ inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) } CONTRACTL_END; - return (LPVOID)context->Rsp; + return (CORDB_ADDRESS)context->Rsp; } inline void CORDbgSetSP(DT_CONTEXT *context, LPVOID rsp) { diff --git a/src/coreclr/debug/inc/arm/primitives.h b/src/coreclr/debug/inc/arm/primitives.h index bb585412a26e02..431d223fc73b39 100644 --- a/src/coreclr/debug/inc/arm/primitives.h +++ b/src/coreclr/debug/inc/arm/primitives.h @@ -92,10 +92,10 @@ inline void CORDbgSetIP(DT_CONTEXT *context, LPVOID eip) { context->Pc = (UINT32)(size_t)eip; } -inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) { +inline CORDB_ADDRESS CORDbgGetSP(const DT_CONTEXT * context) { LIMITED_METHOD_CONTRACT; - return (LPVOID)(size_t)(context->Sp); + return (CORDB_ADDRESS)(context->Sp); } inline void CORDbgSetSP(DT_CONTEXT *context, LPVOID esp) { diff --git a/src/coreclr/debug/inc/arm64/primitives.h b/src/coreclr/debug/inc/arm64/primitives.h index cf4023e7ab2ca9..cb7553be3c075e 100644 --- a/src/coreclr/debug/inc/arm64/primitives.h +++ b/src/coreclr/debug/inc/arm64/primitives.h @@ -103,10 +103,10 @@ inline void CORDbgSetIP(DT_CONTEXT *context, LPVOID eip) { context->Pc = (DWORD64)eip; } -inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) { +inline CORDB_ADDRESS CORDbgGetSP(const DT_CONTEXT * context) { LIMITED_METHOD_CONTRACT; - return (LPVOID)(size_t)(context->Sp); + return (CORDB_ADDRESS)(context->Sp); } inline void CORDbgSetSP(DT_CONTEXT *context, LPVOID esp) { diff --git a/src/coreclr/debug/inc/common.h b/src/coreclr/debug/inc/common.h index 1398021576b9e3..5e4000839846f8 100644 --- a/src/coreclr/debug/inc/common.h +++ b/src/coreclr/debug/inc/common.h @@ -58,11 +58,8 @@ void InitEventForDebuggerNotification(DEBUG_EVENT * pDebugEvent, // CORDbgCopyThreadContext() does an intelligent copy from pSrc to pDst, // respecting the ContextFlags of both contexts. // -struct DebuggerREGDISPLAY; extern void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc); -extern void CORDbgSetDebuggerREGDISPLAYFromContext(DebuggerREGDISPLAY *pDRD, - DT_CONTEXT* pContext); //--------------------------------------------------------------------------------------- // diff --git a/src/coreclr/debug/inc/dacdbiinterface.h b/src/coreclr/debug/inc/dacdbiinterface.h index 79a6b12d3bc825..5f181aa14a2158 100644 --- a/src/coreclr/debug/inc/dacdbiinterface.h +++ b/src/coreclr/debug/inc/dacdbiinterface.h @@ -1281,21 +1281,6 @@ IDacDbiInterface : public IUnknown // Note: returns an appropriate failure HRESULT on error virtual HRESULT STDMETHODCALLTYPE GetContext(VMPTR_Thread vmThread, DT_CONTEXT * pContextBuffer) = 0; - // - // This is a simple helper function to convert a CONTEXT to a DebuggerREGDISPLAY. We need to do this - // inside DDI because the RS has no notion of REGDISPLAY. - // - // Arguments: - // pInContext - the CONTEXT to be converted - // pOutDRD - the converted DebuggerREGDISPLAY - // fActive - Indicate whether the CONTEXT is active or not. An active CONTEXT means that the - // IP is the next instruction to be executed, not the return address of a function call. - // The opposite of an active CONTEXT is an unwind CONTEXT, which is obtained from - // unwinding. - // - - virtual HRESULT STDMETHODCALLTYPE ConvertContextToDebuggerRegDisplay(const DT_CONTEXT * pInContext, DebuggerREGDISPLAY * pOutDRD, BOOL fActive) = 0; - typedef enum { kNone, diff --git a/src/coreclr/debug/inc/dacdbistructures.h b/src/coreclr/debug/inc/dacdbistructures.h index e9eb4df5736178..f6cbf3c7bbc720 100644 --- a/src/coreclr/debug/inc/dacdbistructures.h +++ b/src/coreclr/debug/inc/dacdbistructures.h @@ -539,9 +539,7 @@ struct MSLAYOUT Debugger_JITFuncData struct MSLAYOUT Debugger_STRData { FramePointer fp; - // @dbgtodo stackwalker/shim- Ideally we should be able to get rid of the DebuggerREGDISPLAY and just use the CONTEXT. DT_CONTEXT * ctx; - DebuggerREGDISPLAY * rd; VMPTR_AppDomain vmCurrentAppDomainToken; diff --git a/src/coreclr/debug/inc/dbgipcevents.h b/src/coreclr/debug/inc/dbgipcevents.h index b3190ddb5c98e9..bcc6d65c104ff4 100644 --- a/src/coreclr/debug/inc/dbgipcevents.h +++ b/src/coreclr/debug/inc/dbgipcevents.h @@ -960,214 +960,50 @@ struct MSLAYOUT IPCENames // We use a class/struct so that the function can rema // // NOTE: CPU-specific values below! -// -// DebuggerREGDISPLAY is very similar to the EE REGDISPLAY structure. It holds -// register values that can be saved over calls for each frame in a stack -// trace. -// // DebuggerIPCE_FloatCount is the number of doubles in the processor's // floating point stack. -// -// Note: We used to just pass the values of the registers for each frame to the Right Side, but I had to add in the -// address of each register, too, to support using enregistered variables on non-leaf frames as args to a func eval. Its -// very, very possible that we would rework the entire code base to just use the register's address instead of passing -// both, but its way, way too late in V1 to undertake that, so I'm just using these addresses to suppport our one func -// eval case. Clearly, this needs to be cleaned up post V1. -// -// -- Fri Feb 09 11:21:24 2001 -// -struct MSLAYOUT DebuggerREGDISPLAY -{ #if defined(TARGET_X86) - #define DebuggerIPCE_FloatCount 8 - - SIZE_T Edi; - void *pEdi; - SIZE_T Esi; - void *pEsi; - SIZE_T Ebx; - void *pEbx; - SIZE_T Edx; - void *pEdx; - SIZE_T Ecx; - void *pEcx; - SIZE_T Eax; - void *pEax; - SIZE_T FP; - void *pFP; - SIZE_T SP; - SIZE_T PC; - +#define DebuggerIPCE_FloatCount 8 #elif defined(TARGET_AMD64) - #define DebuggerIPCE_FloatCount 16 - - SIZE_T Rax; - void *pRax; - SIZE_T Rcx; - void *pRcx; - SIZE_T Rdx; - void *pRdx; - SIZE_T Rbx; - void *pRbx; - SIZE_T Rbp; - void *pRbp; - SIZE_T Rsi; - void *pRsi; - SIZE_T Rdi; - void *pRdi; - - SIZE_T R8; - void *pR8; - SIZE_T R9; - void *pR9; - SIZE_T R10; - void *pR10; - SIZE_T R11; - void *pR11; - SIZE_T R12; - void *pR12; - SIZE_T R13; - void *pR13; - SIZE_T R14; - void *pR14; - SIZE_T R15; - void *pR15; - - SIZE_T SP; - SIZE_T PC; +#define DebuggerIPCE_FloatCount 16 #elif defined(TARGET_ARM) - #define DebuggerIPCE_FloatCount 32 - - SIZE_T R0; - void *pR0; - SIZE_T R1; - void *pR1; - SIZE_T R2; - void *pR2; - SIZE_T R3; - void *pR3; - SIZE_T R4; - void *pR4; - SIZE_T R5; - void *pR5; - SIZE_T R6; - void *pR6; - SIZE_T R7; - void *pR7; - SIZE_T R8; - void *pR8; - SIZE_T R9; - void *pR9; - SIZE_T R10; - void *pR10; - SIZE_T R11; - void *pR11; - SIZE_T R12; - void *pR12; - SIZE_T SP; - void *pSP; - SIZE_T LR; - void *pLR; - SIZE_T PC; - void *pPC; +#define DebuggerIPCE_FloatCount 32 #elif defined(TARGET_ARM64) - #define DebuggerIPCE_FloatCount 32 - - SIZE_T X[29]; - SIZE_T FP; - SIZE_T LR; - SIZE_T SP; - SIZE_T PC; +#define DebuggerIPCE_FloatCount 32 #elif defined(TARGET_LOONGARCH64) - #define DebuggerIPCE_FloatCount 32 - SIZE_T RA; - SIZE_T TP; - SIZE_T SP; - SIZE_T A0; - SIZE_T A1; - SIZE_T A2; - SIZE_T A3; - SIZE_T A4; - SIZE_T A5; - SIZE_T A6; - SIZE_T A7; - SIZE_T T0; - SIZE_T T1; - SIZE_T T2; - SIZE_T T3; - SIZE_T T4; - SIZE_T T5; - SIZE_T T6; - SIZE_T T7; - SIZE_T T8; - SIZE_T X0; - SIZE_T FP; - SIZE_T S0; - SIZE_T S1; - SIZE_T S2; - SIZE_T S3; - SIZE_T S4; - SIZE_T S5; - SIZE_T S6; - SIZE_T S7; - SIZE_T S8; - SIZE_T PC; +#define DebuggerIPCE_FloatCount 32 #elif defined(TARGET_RISCV64) - #define DebuggerIPCE_FloatCount 32 - SIZE_T RA; - SIZE_T SP; - SIZE_T GP; - SIZE_T TP; - SIZE_T T0; - SIZE_T T1; - SIZE_T T2; - SIZE_T FP; - SIZE_T S1; - SIZE_T A0; - SIZE_T A1; - SIZE_T A2; - SIZE_T A3; - SIZE_T A4; - SIZE_T A5; - SIZE_T A6; - SIZE_T A7; - SIZE_T S2; - SIZE_T S3; - SIZE_T S4; - SIZE_T S5; - SIZE_T S6; - SIZE_T S7; - SIZE_T S8; - SIZE_T S9; - SIZE_T S10; - SIZE_T S11; - SIZE_T T3; - SIZE_T T4; - SIZE_T T5; - SIZE_T T6; - SIZE_T PC; +#define DebuggerIPCE_FloatCount 32 #else - #define DebuggerIPCE_FloatCount 1 - - SIZE_T PC; - SIZE_T FP; - SIZE_T SP; - void *pFP; +#define DebuggerIPCE_FloatCount 1 #endif -}; -inline LPVOID GetSPAddress(const DebuggerREGDISPLAY * display) +inline LPVOID GetSPAddress(const DT_CONTEXT * context) { - return (LPVOID)&display->SP; +#if defined(TARGET_X86) + return (LPVOID)&context->Esp; +#elif defined(TARGET_AMD64) + return (LPVOID)&context->Rsp; +#elif defined(TARGET_WASM) + return (LPVOID)&context->InterpreterSP; +#else + return (LPVOID)&context->Sp; +#endif } #if !defined(TARGET_AMD64) && !defined(TARGET_ARM) -inline LPVOID GetFPAddress(const DebuggerREGDISPLAY * display) +inline LPVOID GetFPAddress(const DT_CONTEXT * context) { - return (LPVOID)&display->FP; +#if defined(TARGET_X86) + return (LPVOID)&context->Ebp; +#elif defined(TARGET_WASM) + return (LPVOID)&context->InterpreterFP; +#else + return (LPVOID)&context->Fp; +#endif } -#endif // !TARGET_AMD64 +#endif // !TARGET_AMD64 && !TARGET_ARM class MSLAYOUT FramePointer diff --git a/src/coreclr/debug/inc/i386/primitives.h b/src/coreclr/debug/inc/i386/primitives.h index d0c55986ea96e1..aa7d35a73a9bfa 100644 --- a/src/coreclr/debug/inc/i386/primitives.h +++ b/src/coreclr/debug/inc/i386/primitives.h @@ -84,10 +84,10 @@ inline void CORDbgSetIP(DT_CONTEXT *context, LPVOID eip) { context->Eip = (UINT32)(size_t)eip; } -inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) { +inline CORDB_ADDRESS CORDbgGetSP(const DT_CONTEXT * context) { LIMITED_METHOD_CONTRACT; - return (LPVOID)(size_t)(context->Esp); + return (CORDB_ADDRESS)(context->Esp); } inline void CORDbgSetSP(DT_CONTEXT *context, LPVOID esp) { diff --git a/src/coreclr/debug/inc/loongarch64/primitives.h b/src/coreclr/debug/inc/loongarch64/primitives.h index f6309552e5ebf3..e66743adfd084a 100644 --- a/src/coreclr/debug/inc/loongarch64/primitives.h +++ b/src/coreclr/debug/inc/loongarch64/primitives.h @@ -89,10 +89,10 @@ inline void CORDbgSetIP(DT_CONTEXT *context, LPVOID ip) { context->Pc = (DWORD64)ip; } -inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) { +inline CORDB_ADDRESS CORDbgGetSP(const DT_CONTEXT * context) { LIMITED_METHOD_CONTRACT; - return (LPVOID)(size_t)(context->Sp); + return (CORDB_ADDRESS)(context->Sp); } inline void CORDbgSetSP(DT_CONTEXT *context, LPVOID esp) { diff --git a/src/coreclr/debug/inc/riscv64/primitives.h b/src/coreclr/debug/inc/riscv64/primitives.h index ed4f15d6018a63..821a324281dcaf 100644 --- a/src/coreclr/debug/inc/riscv64/primitives.h +++ b/src/coreclr/debug/inc/riscv64/primitives.h @@ -90,10 +90,10 @@ inline void CORDbgSetIP(DT_CONTEXT *context, LPVOID ip) { context->Pc = (DWORD64)ip; } -inline LPVOID CORDbgGetSP(const DT_CONTEXT * context) { +inline CORDB_ADDRESS CORDbgGetSP(const DT_CONTEXT * context) { LIMITED_METHOD_CONTRACT; - return (LPVOID)(size_t)(context->Sp); + return (CORDB_ADDRESS)(context->Sp); } inline void CORDbgSetSP(DT_CONTEXT *context, LPVOID esp) { diff --git a/src/coreclr/debug/shared/amd64/primitives.cpp b/src/coreclr/debug/shared/amd64/primitives.cpp index 1e06e9b6b5fa60..ff23ab99b1003d 100644 --- a/src/coreclr/debug/shared/amd64/primitives.cpp +++ b/src/coreclr/debug/shared/amd64/primitives.cpp @@ -77,101 +77,3 @@ void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc) CONTEXT_DEBUG_REGISTERS); } } - -void CORDbgSetDebuggerREGDISPLAYFromContext(DebuggerREGDISPLAY* pDRD, - DT_CONTEXT* pContext) -{ - DWORD flags = pContext->ContextFlags; - if ((flags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pDRD->PC = (SIZE_T)CORDbgGetIP(pContext); - pDRD->SP = (SIZE_T)CORDbgGetSP(pContext); - } - - if ((flags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - pDRD->Rax = pContext->Rax; - pDRD->Rcx = pContext->Rcx; - pDRD->Rdx = pContext->Rdx; - pDRD->Rbx = pContext->Rbx; - pDRD->Rbp = pContext->Rbp; - pDRD->Rsi = pContext->Rsi; - pDRD->Rdi = pContext->Rdi; - pDRD->R8 = pContext->R8; - pDRD->R9 = pContext->R9; - pDRD->R10 = pContext->R10; - pDRD->R11 = pContext->R11; - pDRD->R12 = pContext->R12; - pDRD->R13 = pContext->R13; - pDRD->R14 = pContext->R14; - pDRD->R15 = pContext->R15; - } -} - -#if defined(ALLOW_VMPTR_ACCESS) || !defined(RIGHT_SIDE_COMPILE) -void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD) -{ - SUPPORTS_DAC_HOST_ONLY; - // CORDbgSetDebuggerREGDISPLAYFromContext() checks the context flags. In cases where we don't have a filter - // context from the thread, we initialize a CONTEXT on the stack and use that to do our stack walking. We never - // initialize the context flags in such cases. Since this function is called from the stackwalker, we can - // guarantee that the integer, control, and floating point sections are valid. So we set the flags here and - // restore them afterwards. - DWORD contextFlags = pRD->pCurrentContext->ContextFlags; - pRD->pCurrentContext->ContextFlags = CONTEXT_FULL; - // This doesn't set the pointers, only the values - CORDbgSetDebuggerREGDISPLAYFromContext(pDRD, reinterpret_cast(pRD->pCurrentContext)); // MACTODO: KLUDGE UNDO Microsoft - pRD->pCurrentContext->ContextFlags = contextFlags; - - // These pointers are always valid so we don't need to test them using PushedRegAddr -#if defined(USE_REMOTE_REGISTER_ADDRESS) - pDRD->pRax = pRD->pCurrentContextPointers->Integer.Register.Rax; - pDRD->pRcx = pRD->pCurrentContextPointers->Integer.Register.Rcx; - pDRD->pRdx = pRD->pCurrentContextPointers->Integer.Register.Rdx; - pDRD->pRbx = pRD->pCurrentContextPointers->Integer.Register.Rbx; - pDRD->pRbp = pRD->pCurrentContextPointers->Integer.Register.Rbp; - pDRD->pRsi = pRD->pCurrentContextPointers->Integer.Register.Rsi; - pDRD->pRdi = pRD->pCurrentContextPointers->Integer.Register.Rdi; - pDRD->pR8 = pRD->pCurrentContextPointers->Integer.Register.R8; - pDRD->pR9 = pRD->pCurrentContextPointers->Integer.Register.R9; - pDRD->pR10 = pRD->pCurrentContextPointers->Integer.Register.R10; - pDRD->pR11 = pRD->pCurrentContextPointers->Integer.Register.R11; - pDRD->pR12 = pRD->pCurrentContextPointers->Integer.Register.R12; - pDRD->pR13 = pRD->pCurrentContextPointers->Integer.Register.R13; - pDRD->pR14 = pRD->pCurrentContextPointers->Integer.Register.R14; - pDRD->pR15 = pRD->pCurrentContextPointers->Integer.Register.R15; -#else // !USE_REMOTE_REGISTER_ADDRESS - pDRD->pRax = NULL; - pDRD->pRcx = NULL; - pDRD->pRdx = NULL; - pDRD->pRbx = NULL; - pDRD->pRbp = NULL; - pDRD->pRsi = NULL; - pDRD->pRdi = NULL; - pDRD->pR8 = NULL; - pDRD->pR9 = NULL; - pDRD->pR10 = NULL; - pDRD->pR11 = NULL; - pDRD->pR12 = NULL; - pDRD->pR13 = NULL; - pDRD->pR14 = NULL; - pDRD->pR15 = NULL; -#endif // USE_REMOTE_REGISTER_ADDRESS - - pDRD->PC = pRD->ControlPC; - pDRD->SP = pRD->SP; - - // Please leave RSP, RIP at the front so I don't have to scroll - // left to see the most important registers. Thanks! - LOG( (LF_CORDB, LL_INFO1000, "SDRFR:Registers:" - "Rsp = %p Rip = %p Rbp = %p Rdi = %p " - "Rsi = %p Rbx = %p Rdx = %p Rcx = %p Rax = %p" - "R8 = %p R9 = %p R10 = %p R11 = %p" - "R12 = %p R13 = %p R14 = %p R15 = %p\n", - pDRD->SP, pDRD->PC, pDRD->Rbp, pDRD->Rdi, - pDRD->Rsi, pDRD->Rbx, pDRD->Rdx, pDRD->Rcx, pDRD->Rax, - pDRD->R8, pDRD->R9, pDRD->R10, pDRD->R11, pDRD->R12, - pDRD->R13, pDRD->R14, pDRD->R15) ); - -} -#endif // ALLOW_VMPTR_ACCESS || !RIGHT_SIDE_COMPILE diff --git a/src/coreclr/debug/shared/arm/primitives.cpp b/src/coreclr/debug/shared/arm/primitives.cpp index 522bc574e14140..4cdf1e82af643d 100644 --- a/src/coreclr/debug/shared/arm/primitives.cpp +++ b/src/coreclr/debug/shared/arm/primitives.cpp @@ -41,59 +41,3 @@ void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc) CopyContextChunk(&(pDst->Bvr[0]), &(pSrc->Bvr[0]), &(pDst->Wcr[DT_ARM_MAX_WATCHPOINTS]), DT_CONTEXT_DEBUG_REGISTERS); } - - -// Update the regdisplay from a given context. -void CORDbgSetDebuggerREGDISPLAYFromContext(DebuggerREGDISPLAY *pDRD, - DT_CONTEXT* pContext) -{ - // We must pay attention to the context flags so that we only use valid portions - // of the context. - DWORD flags = pContext->ContextFlags; - if ((flags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pDRD->PC = (SIZE_T)CORDbgGetIP(pContext); - pDRD->SP = (SIZE_T)CORDbgGetSP(pContext); - pDRD->LR = (SIZE_T)pContext->Lr; - } - - if ((flags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - pDRD->R0 = (SIZE_T)pContext->R0; - pDRD->R1 = (SIZE_T)pContext->R1; - pDRD->R2 = (SIZE_T)pContext->R2; - pDRD->R3 = (SIZE_T)pContext->R3; - pDRD->R4 = (SIZE_T)pContext->R4; - pDRD->R5 = (SIZE_T)pContext->R5; - pDRD->R6 = (SIZE_T)pContext->R6; - pDRD->R7 = (SIZE_T)pContext->R7; - pDRD->R8 = (SIZE_T)pContext->R8; - pDRD->R9 = (SIZE_T)pContext->R9; - pDRD->R10 = (SIZE_T)pContext->R10; - pDRD->R11 = (SIZE_T)pContext->R11; - pDRD->R12 = (SIZE_T)pContext->R12; - } -} - -#if defined(ALLOW_VMPTR_ACCESS) || !defined(RIGHT_SIDE_COMPILE) -void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD) -{ - SUPPORTS_DAC_HOST_ONLY; - // CORDbgSetDebuggerREGDISPLAYFromContext() checks the context flags. In cases where we don't have a filter - // context from the thread, we initialize a CONTEXT on the stack and use that to do our stack walking. We never - // initialize the context flags in such cases. Since this function is called from the stackwalker, we can - // guarantee that the integer, control, and floating point sections are valid. So we set the flags here and - // restore them afterwards. - DWORD contextFlags = pRD->pCurrentContext->ContextFlags; - pRD->pCurrentContext->ContextFlags = CONTEXT_FULL; - CORDbgSetDebuggerREGDISPLAYFromContext(pDRD, reinterpret_cast(pRD->pCurrentContext)); - pRD->pCurrentContext->ContextFlags = contextFlags; - - pDRD->SP = pRD->SP; - pDRD->PC = (SIZE_T)*(pRD->pPC); - - LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:Registers:" - "SP = %x PC = %x", - pDRD->SP, pDRD->PC) ); -} -#endif // ALLOW_VMPTR_ACCESS || !RIGHT_SIDE_COMPILE diff --git a/src/coreclr/debug/shared/arm64/primitives.cpp b/src/coreclr/debug/shared/arm64/primitives.cpp index 9bbf0308319bd4..a381891b02d83d 100644 --- a/src/coreclr/debug/shared/arm64/primitives.cpp +++ b/src/coreclr/debug/shared/arm64/primitives.cpp @@ -45,38 +45,3 @@ void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc) CopyContextChunk(&(pDst->Bcr[0]), &(pSrc->Bcr[0]), &(pDst->Wvr[ARM64_MAX_WATCHPOINTS]), DT_CONTEXT_DEBUG_REGISTERS); } - -#if defined(ALLOW_VMPTR_ACCESS) || !defined(RIGHT_SIDE_COMPILE) -void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD) -{ - SUPPORTS_DAC_HOST_ONLY; - - DT_CONTEXT* pContext = reinterpret_cast(pRD->pCurrentContext); - - // We must pay attention to the context flags so that we only use valid portions - // of the context. - DWORD flags = pContext->ContextFlags; - if ((flags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pDRD->FP = (SIZE_T)CORDbgGetFP(pContext); - pDRD->LR = (SIZE_T)pContext->Lr; - pDRD->PC = (SIZE_T)pContext->Pc; - } - - if ((flags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - for(int i = 0 ; i < 29 ; i++) - { - pDRD->X[i] = (SIZE_T)pContext->X[i]; - } - } - - pDRD->SP = pRD->SP; - - LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:Registers:" - "SP = %x", - pDRD->SP) ); -} -#endif // ALLOW_VMPTR_ACCESS || !RIGHT_SIDE_COMPILE - - diff --git a/src/coreclr/debug/shared/i386/primitives.cpp b/src/coreclr/debug/shared/i386/primitives.cpp index 19f0c5d63c4828..96a5a8f9aea90f 100644 --- a/src/coreclr/debug/shared/i386/primitives.cpp +++ b/src/coreclr/debug/shared/i386/primitives.cpp @@ -53,74 +53,3 @@ void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc) &(pDst->ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION]), DT_CONTEXT_EXTENDED_REGISTERS); } - - -// Update the regdisplay from a given context. -void CORDbgSetDebuggerREGDISPLAYFromContext(DebuggerREGDISPLAY *pDRD, - DT_CONTEXT* pContext) -{ - // We must pay attention to the context flags so that we only use valid portions - // of the context. - DWORD flags = pContext->ContextFlags; - if ((flags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pDRD->PC = (SIZE_T)CORDbgGetIP(pContext); - pDRD->SP = (SIZE_T)CORDbgGetSP(pContext); - pDRD->FP = (SIZE_T)CORDbgGetFP(pContext); - } - - if ((flags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - pDRD->Eax = pContext->Eax; - pDRD->Ebx = pContext->Ebx; - pDRD->Ecx = pContext->Ecx; - pDRD->Edx = pContext->Edx; - pDRD->Esi = pContext->Esi; - pDRD->Edi = pContext->Edi; - } -} - -#if defined(ALLOW_VMPTR_ACCESS) || !defined(RIGHT_SIDE_COMPILE) -void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD) -{ - SUPPORTS_DAC_HOST_ONLY; - // Frame pointer - LPVOID FPAddress = GetRegdisplayFPAddress(pRD); - pDRD->FP = (FPAddress == NULL ? 0 : *((SIZE_T *)FPAddress)); - pDRD->Edi = (pRD->GetEdiLocation() == NULL ? 0 : *pRD->GetEdiLocation()); - pDRD->Esi = (pRD->GetEsiLocation() == NULL ? 0 : *pRD->GetEsiLocation()); - pDRD->Ebx = (pRD->GetEbxLocation() == NULL ? 0 : *pRD->GetEbxLocation()); - pDRD->Edx = (pRD->GetEdxLocation() == NULL ? 0 : *pRD->GetEdxLocation()); - pDRD->Ecx = (pRD->GetEcxLocation() == NULL ? 0 : *pRD->GetEcxLocation()); - pDRD->Eax = (pRD->GetEaxLocation() == NULL ? 0 : *pRD->GetEaxLocation()); - -#if defined(USE_REMOTE_REGISTER_ADDRESS) - pDRD->pFP = PushedRegAddr(pRD, FPAddress); - pDRD->pEdi = PushedRegAddr(pRD, pRD->pEdi); - pDRD->pEsi = PushedRegAddr(pRD, pRD->pEsi); - pDRD->pEbx = PushedRegAddr(pRD, pRD->pEbx); - pDRD->pEdx = PushedRegAddr(pRD, pRD->pEdx); - pDRD->pEcx = PushedRegAddr(pRD, pRD->pEcx); - pDRD->pEax = PushedRegAddr(pRD, pRD->pEax); -#else // !USE_REMOTE_REGISTER_ADDRESS - pDRD->pFP = NULL; - pDRD->pEdi = NULL; - pDRD->pEsi = NULL; - pDRD->pEbx = NULL; - pDRD->pEdx = NULL; - pDRD->pEcx = NULL; - pDRD->pEax = NULL; -#endif // !USE_REMOTE_REGISTER_ADDRESS - - pDRD->SP = pRD->SP; - pDRD->PC = pRD->ControlPC; - - // 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", - pDRD->FP, pDRD->SP, pDRD->PC, pDRD->Edi, - pDRD->Esi, pDRD->Ebx, pDRD->Edx, pDRD->Ecx, pDRD->Eax ) ); -} -#endif // ALLOW_VMPTR_ACCESS || !RIGHT_SIDE_COMPILE diff --git a/src/coreclr/debug/shared/loongarch64/primitives.cpp b/src/coreclr/debug/shared/loongarch64/primitives.cpp index eefe4284be28e8..11801fea05c106 100644 --- a/src/coreclr/debug/shared/loongarch64/primitives.cpp +++ b/src/coreclr/debug/shared/loongarch64/primitives.cpp @@ -64,34 +64,3 @@ void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc) pDst->Fcc = pSrc->Fcc; } } - -#if defined(ALLOW_VMPTR_ACCESS) || !defined(RIGHT_SIDE_COMPILE) -void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD) -{ - SUPPORTS_DAC_HOST_ONLY; - - DT_CONTEXT* pContext = reinterpret_cast(pRD->pCurrentContext); - - // We must pay attention to the context flags so that we only use valid portions - // of the context. - DWORD flags = pContext->ContextFlags; - if ((flags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pDRD->FP = (SIZE_T)CORDbgGetFP(pContext); - pDRD->PC = (SIZE_T)pContext->Pc; - pDRD->RA = (SIZE_T)pContext->Ra; - } - - if ((flags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - memcpy(&pDRD->A0, &pContext->A0, sizeof(pDRD->A0)*(21 - 4 + 1)); - memcpy(&pDRD->S0, &pContext->S0, sizeof(pDRD->S0)* 9); - } - - pDRD->SP = pRD->SP; - - LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:Registers:" - "SP = %x", - pDRD->SP) ); -} -#endif // ALLOW_VMPTR_ACCESS || !RIGHT_SIDE_COMPILE diff --git a/src/coreclr/debug/shared/riscv64/primitives.cpp b/src/coreclr/debug/shared/riscv64/primitives.cpp index b351da17cf802a..cf306684ada4cd 100644 --- a/src/coreclr/debug/shared/riscv64/primitives.cpp +++ b/src/coreclr/debug/shared/riscv64/primitives.cpp @@ -65,34 +65,3 @@ void CORDbgCopyThreadContext(DT_CONTEXT* pDst, const DT_CONTEXT* pSrc) pDst->Fcsr = pSrc->Fcsr; } } - -#if defined(ALLOW_VMPTR_ACCESS) || !defined(RIGHT_SIDE_COMPILE) -void SetDebuggerREGDISPLAYFromREGDISPLAY(DebuggerREGDISPLAY* pDRD, REGDISPLAY* pRD) -{ - SUPPORTS_DAC_HOST_ONLY; - - DT_CONTEXT* pContext = reinterpret_cast(pRD->pCurrentContext); - - // We must pay attention to the context flags so that we only use valid portions - // of the context. - DWORD flags = pContext->ContextFlags; - if ((flags & DT_CONTEXT_CONTROL) == DT_CONTEXT_CONTROL) - { - pDRD->FP = (SIZE_T)CORDbgGetFP(pContext); - pDRD->PC = (SIZE_T)pContext->Pc; - pDRD->RA = (SIZE_T)pContext->Ra; - } - - if ((flags & DT_CONTEXT_INTEGER) == DT_CONTEXT_INTEGER) - { - memcpy(&pDRD->GP, &pContext->Gp, sizeof(pDRD->GP) * 5); - memcpy(&pDRD->S1, &pContext->S1, sizeof(pDRD->S1) * 23); - } - - pDRD->SP = pRD->SP; - - LOG( (LF_CORDB, LL_INFO1000, "DT::TASSC:Registers:" - "SP = %x", - pDRD->SP) ); -} -#endif // ALLOW_VMPTR_ACCESS || !RIGHT_SIDE_COMPILE diff --git a/src/coreclr/inc/dacdbi.idl b/src/coreclr/inc/dacdbi.idl index a31addfea95f37..ef6b92dcf8f9c0 100644 --- a/src/coreclr/inc/dacdbi.idl +++ b/src/coreclr/inc/dacdbi.idl @@ -19,7 +19,6 @@ struct DacThreadAllocInfo; struct NativeVarData; struct SequencePoints; struct Debugger_STRData; -struct DebuggerREGDISPLAY; struct NativeCodeFunctionData; struct FieldData; struct DebuggerIPCE_ExpandedTypeData; @@ -283,7 +282,6 @@ interface IDacDbiInterface : IUnknown HRESULT GetFramePointer([in] StackWalkHandle pSFIHandle, [out] FramePointer * pRetVal); HRESULT IsLeafFrame([in] VMPTR_Thread vmThread, [in] const DT_CONTEXT * pContext, [out] BOOL * pResult); HRESULT GetContext([in] VMPTR_Thread vmThread, [out] DT_CONTEXT * pContextBuffer); - HRESULT ConvertContextToDebuggerRegDisplay([in] const DT_CONTEXT * pInContext, [out] struct DebuggerREGDISPLAY * pOutDRD, [in] BOOL fActive); // Method HRESULT IsDiagnosticsHiddenOrLCGMethod([in] VMPTR_MethodDesc vmMethodDesc, [out] DynamicMethodType * pRetVal); diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs index 31a7d8af888863..5a8eb889c958a9 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs @@ -1399,7 +1399,7 @@ public int EnumerateInternalFrames(ulong vmThread, delegate* unmanaged LegacyFallbackHelper.CanFallback() && _legacy is not null ? _legacy.ConvertContextToDebuggerRegDisplay(pInContext, pOutDRD, fActive) : HResults.E_NOTIMPL; - public int IsDiagnosticsHiddenOrLCGMethod(ulong vmMethodDesc, int* pRetVal) { *pRetVal = (int)DynamicMethodType.kNone; diff --git a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/IDacDbiInterface.cs b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/IDacDbiInterface.cs index b3ef19f16e3679..1408ca04b28898 100644 --- a/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/IDacDbiInterface.cs +++ b/src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/IDacDbiInterface.cs @@ -220,10 +220,10 @@ public struct DebuggerIPCE_STRData_StubFrame // the DI during a stack walk. Mirrors the native Debugger_STRData struct // defined in src/coreclr/debug/inc/dbgipcevents.h. // -// `ctx` and `rd` are pointers into dbi-allocated memory. -// The DAC writes the populated context/regdisplay through these pointers rather -// than storing them inline. Code paths that do not produce a context/regdisplay -// (e.g. EnumerateInternalFrames for cStubFrame entries) leave them as 0. +// `ctx` is a pointer into dbi-allocated memory. +// The DAC writes the populated context through this pointer rather +// than storing it inline. Code paths that do not produce a context +// (e.g. EnumerateInternalFrames for cStubFrame entries) leave it as 0. [StructLayout(LayoutKind.Explicit)] public struct Debugger_STRData { @@ -236,11 +236,10 @@ public enum EType [FieldOffset(0)] public ulong fp; // FramePointer [FieldOffset(8)] public ulong ctx; // DT_CONTEXT* - [FieldOffset(16)] public ulong rd; // DebuggerREGDISPLAY* - [FieldOffset(24)] public ulong vmCurrentAppDomainToken; // VMPTR_AppDomain - [FieldOffset(32)] public EType eType; - [FieldOffset(40)] public DebuggerIPCE_STRData_MethodFrame v; - [FieldOffset(40)] public DebuggerIPCE_STRData_StubFrame stubFrame; + [FieldOffset(16)] public ulong vmCurrentAppDomainToken; // VMPTR_AppDomain + [FieldOffset(24)] public EType eType; + [FieldOffset(32)] public DebuggerIPCE_STRData_MethodFrame v; + [FieldOffset(32)] public DebuggerIPCE_STRData_StubFrame stubFrame; } #pragma warning restore CS0649 @@ -534,9 +533,6 @@ public unsafe partial interface IDacDbiInterface [PreserveSig] int GetContext(ulong vmThread, byte* pContextBuffer); - [PreserveSig] - int ConvertContextToDebuggerRegDisplay(nint pInContext, nint pOutDRD, Interop.BOOL fActive); - [PreserveSig] int IsDiagnosticsHiddenOrLCGMethod(ulong vmMethodDesc, int* pRetVal);