diff options
Diffstat (limited to 'src/vm/encee.cpp')
| -rw-r--r-- | src/vm/encee.cpp | 1753 |
1 files changed, 1753 insertions, 0 deletions
diff --git a/src/vm/encee.cpp b/src/vm/encee.cpp new file mode 100644 index 0000000000..ca4e7fe553 --- /dev/null +++ b/src/vm/encee.cpp @@ -0,0 +1,1753 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// =========================================================================== +// File: EnC.CPP +// + +// +// Handles EditAndContinue support in the EE +// =========================================================================== + + +#include "common.h" +#include "dbginterface.h" +#include "dllimport.h" +#include "eeconfig.h" +#include "excep.h" +#include "stackwalk.h" + +#ifdef EnC_SUPPORTED + +// can't get this on the helper thread at runtime in ResolveField, so make it static and get when add a field. +#ifdef _DEBUG +static int g_BreakOnEnCResolveField = -1; +#endif + +#ifndef DACCESS_COMPILE + + +// Module initialization occurs in two phases: the constructor phase and the Initialize phase. +// +// The constructor phase initializes just enough so that Destruct() can be safely called. +// It cannot throw or fail. +// +EditAndContinueModule::EditAndContinueModule(Assembly *pAssembly, mdToken moduleRef, PEFile *file) + : Module(pAssembly, moduleRef, file) +{ + CONTRACTL + { + NOTHROW; + GC_TRIGGERS; + FORBID_FAULT; + } + CONTRACTL_END + + LOG((LF_ENC,LL_INFO100,"EACM::ctor 0x%x\n", this)); + + m_applyChangesCount = CorDB_DEFAULT_ENC_FUNCTION_VERSION; +} + +// Module initialization occurs in two phases: the constructor phase and the Initialize phase. +// +// The Initialize() phase completes the initialization after the constructor has run. +// It can throw exceptions but whether it throws or succeeds, it must leave the Module +// in a state where Destruct() can be safely called. +// +/*virtual*/ +void EditAndContinueModule::Initialize(AllocMemTracker *pamTracker) +{ + CONTRACTL + { + THROWS; + GC_TRIGGERS; + INJECT_FAULT(COMPlusThrowOM();); + } + CONTRACTL_END + + LOG((LF_ENC,LL_INFO100,"EACM::Initialize 0x%x\n", this)); + Module::Initialize(pamTracker); +} + +// Called when the module is being destroyed (eg. AD unload time) +void EditAndContinueModule::Destruct() +{ + LIMITED_METHOD_CONTRACT; + LOG((LF_ENC,LL_EVERYTHING,"EACM::Destruct 0x%x\n", this)); + + // Call the superclass's Destruct method... + Module::Destruct(); +} + +//--------------------------------------------------------------------------------------- +// +// ApplyEditAndContinue - updates this module for an EnC +// +// Arguments: +// cbDeltaMD - number of bytes pointed to by pDeltaMD +// pDeltaMD - pointer to buffer holding the delta metadata +// cbDeltaIL - number of bytes pointed to by pDeltaIL +// pDeltaIL - pointer to buffer holding the delta IL +// +// Return Value: +// S_OK on success. +// if the edit fails for any reason, at any point in this function, +// we are toasted, so return out and IDE will end debug session. +// + +HRESULT EditAndContinueModule::ApplyEditAndContinue( + DWORD cbDeltaMD, + BYTE *pDeltaMD, + DWORD cbDeltaIL, + BYTE *pDeltaIL) +{ + CONTRACTL + { + THROWS; + GC_NOTRIGGER; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + // Update the module's EnC version number + ++m_applyChangesCount; + + LOG((LF_ENC, LL_INFO100, "EACM::AEAC:\n")); + +#ifdef _DEBUG + // Debugging hook to optionally break when this method is called + static BOOL shouldBreak = -1; + if (shouldBreak == -1) + shouldBreak = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_EncApplyChanges); + if (shouldBreak > 0) { + _ASSERTE(!"EncApplyChanges"); + } + + // Debugging hook to dump out all edits to dmeta and dil files + static BOOL dumpChanges = -1; + + if (dumpChanges == -1) + + dumpChanges = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_EncDumpApplyChanges); + + if (dumpChanges> 0) { + SString fn; + int ec; + fn.Printf(W("ApplyChanges.%d.dmeta"), m_applyChangesCount); + FILE *fp; + ec = _wfopen_s(&fp, fn.GetUnicode(), W("wb")); + _ASSERTE(SUCCEEDED(ec)); + fwrite(pDeltaMD, 1, cbDeltaMD, fp); + fclose(fp); + fn.Printf(W("ApplyChanges.%d.dil"), m_applyChangesCount); + ec = _wfopen_s(&fp, fn.GetUnicode(), W("wb")); + _ASSERTE(SUCCEEDED(ec)); + fwrite(pDeltaIL, 1, cbDeltaIL, fp); + fclose(fp); + } +#endif + + HRESULT hr = S_OK; + HENUMInternal enumENC; + + CONTRACT_VIOLATION(GCViolation); // SafeComHolder goes to preemptive mode, which will trigger a GC + SafeComHolder<IMDInternalImportENC> pIMDInternalImportENC; + SafeComHolder<IMetaDataEmit> pEmitter; + + // Apply the changes. Note that ApplyEditAndContinue() requires read/write metadata. If the metadata is + // not already RW, then ApplyEditAndContinue() will perform the conversion, invalidate the current + // metadata importer, and return us a new one. We can't let that happen. Other parts of the system are + // already using the current metadata importer, some possibly in preemptive GC mode at this very moment. + // Instead, we ensure that the metadata is RW by calling ConvertMDInternalToReadWrite(), which will make + // a new importer if necessary and ensure that new accesses to the metadata use that while still managing + // the lifetime of the old importer. Therefore, we can be sure that ApplyEditAndContinue() won't need to + // make a new importer. + + // Ensure the metadata is RW. + EX_TRY + { + // ConvertMetadataToRWForEnC should only ever be called on EnC capable files. + _ASSERTE(IsEditAndContinueCapable()); // this also checks that the file is EnC capable + GetFile()->ConvertMetadataToRWForEnC(); + } + EX_CATCH_HRESULT(hr); + + IfFailGo(hr); + + // Grab the current importer. + IMDInternalImport *pMDImport = GetMDImport(); + IMDInternalImport *pNewMDImport; + + // Apply the EnC delta to this module's metadata. + IfFailGo(pMDImport->ApplyEditAndContinue(pDeltaMD, cbDeltaMD, &pNewMDImport)); + + // The importer should not have changed! We assert that, and back-stop in a retail build just to be sure. + if (pNewMDImport != pMDImport) + { + _ASSERTE( !"ApplyEditAndContinue should not have needed to create a new metadata importer!" ); + IfFailGo(CORDBG_E_ENC_INTERNAL_ERROR); + } + + // get the delta interface + IfFailGo(pMDImport->QueryInterface(IID_IMDInternalImportENC, (void **)&pIMDInternalImportENC)); + + // get an emitter interface + IfFailGo(GetMetaDataPublicInterfaceFromInternal(pMDImport, IID_IMetaDataEmit, (void **)&pEmitter)); + + // Copy the deltaIL into our RVAable IL memory + BYTE *pLocalILMemory = new BYTE[cbDeltaIL]; + memcpy(pLocalILMemory, pDeltaIL, cbDeltaIL); + + // Enumerate all of the EnC delta tokens + memset(&enumENC, 0, sizeof(HENUMInternal)); + IfFailGo(pIMDInternalImportENC->EnumDeltaTokensInit(&enumENC)); + + mdToken token; + FieldDesc * pField = NULL; + while (pIMDInternalImportENC->EnumNext(&enumENC, &token)) + { + STRESS_LOG3(LF_ENC, LL_INFO100, "EACM::AEAC: updated token 0x%x; type 0x%x; rid 0x%x\n", token, TypeFromToken(token), RidFromToken(token)); + + switch (TypeFromToken(token)) + { + case mdtMethodDef: + + // MethodDef token - update/add a method + LOG((LF_ENC, LL_INFO10000, "EACM::AEAC: Found method 0x%x\n", token)); + + ULONG dwMethodRVA; + DWORD dwMethodFlags; + IfFailGo(pMDImport->GetMethodImplProps(token, &dwMethodRVA, &dwMethodFlags)); + + if (dwMethodRVA >= cbDeltaIL) + { + LOG((LF_ENC, LL_INFO10000, "EACM::AEAC: failure RVA of %d with cbDeltaIl %d\n", dwMethodRVA, cbDeltaIL)); + IfFailGo(E_INVALIDARG); + } + + SetDynamicIL(token, (TADDR)(pLocalILMemory + dwMethodRVA), FALSE); + + // use module to resolve to method + MethodDesc *pMethod; + pMethod = LookupMethodDef(token); + if (pMethod) + { + // Method exists already - update it + IfFailGo(UpdateMethod(pMethod)); + } + else + { + // This is a new method token - create a new method + IfFailGo(AddMethod(token)); + } + + break; + + case mdtFieldDef: + + // FieldDef token - add a new field + LOG((LF_ENC, LL_INFO10000, "EACM::AEAC: Found field 0x%x\n", token)); + + pField = LookupFieldDef(token); + if (pField) + { + // Field already exists - just ignore for now + continue; + } + + // Field is new - add it + IfFailGo(AddField(token)); + break; + + case mdtTypeRef: + EnsureTypeRefCanBeStored(token); + break; + + case mdtAssemblyRef: + EnsureAssemblyRefCanBeStored(token); + break; + } + } + +ErrExit: + if (pIMDInternalImportENC) + pIMDInternalImportENC->EnumClose(&enumENC); + + return hr; +} + +//--------------------------------------------------------------------------------------- +// +// UpdateMethod - called when a method has been updated by EnC. +// +// The module's metadata has already been updated. Here we notify the +// debugger of the update, and swap the new IL in as the current +// version of the method. +// +// Arguments: +// pMethod - the method being updated +// +// Return Value: +// S_OK on success. +// if the edit fails for any reason, at any point in this function, +// we are toasted, so return out and IDE will end debug session. +// +// Assumptions: +// The CLR must be suspended for debugging. +// +HRESULT EditAndContinueModule::UpdateMethod(MethodDesc *pMethod) +{ + CONTRACTL + { + THROWS; + GC_NOTRIGGER; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + // Notify the debugger of the update + HRESULT hr = g_pDebugInterface->UpdateFunction(pMethod, m_applyChangesCount); + if (FAILED(hr)) + { + return hr; + } + + // Notify the JIT that we've got new IL for this method + // This will ensure that all new calls to the method will go to the new version. + // The runtime does this by never backpatching the methodtable slots in EnC-enabled modules. + LOG((LF_ENC, LL_INFO100000, "EACM::UM: Updating function %s to version %d\n", pMethod->m_pszDebugMethodName, m_applyChangesCount)); + + // Reset any flags relevant to the old code + // + // Note that this only works since we've very carefullly made sure that _all_ references + // to the Method's code must be to the call/jmp blob immediately in front of the + // MethodDesc itself. See MethodDesc::IsEnCMethod() + // + pMethod->Reset(); + + return S_OK; +} + +//--------------------------------------------------------------------------------------- +// +// AddMethod - called when a new method is added by EnC. +// +// The module's metadata has already been updated. Here we notify the +// debugger of the update, and create and add a new MethodDesc to the class. +// +// Arguments: +// token - methodDef token for the method being added +// +// Return Value: +// S_OK on success. +// if the edit fails for any reason, at any point in this function, +// we are toasted, so return out and IDE will end debug session. +// +// Assumptions: +// The CLR must be suspended for debugging. +// +HRESULT EditAndContinueModule::AddMethod(mdMethodDef token) +{ + CONTRACTL + { + THROWS; + GC_NOTRIGGER; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + mdTypeDef parentTypeDef; + HRESULT hr = GetMDImport()->GetParentToken(token, &parentTypeDef); + if (FAILED(hr)) + { + LOG((LF_ENC, LL_INFO100, "**Error** EnCModule::AM can't find parent token for method token %p\n", token)); + return E_FAIL; + } + + // see if the class is loaded yet. + MethodTable * pParentType = LookupTypeDef(parentTypeDef).AsMethodTable(); + if (pParentType == NULL) + { + // Class isn't loaded yet, don't have to modify any existing EE data structures beyond the metadata. + // Just notify debugger and return. + LOG((LF_ENC, LL_INFO100, "EnCModule::AM class %p not loaded, our work is done\n", parentTypeDef)); + hr = g_pDebugInterface->UpdateNotYetLoadedFunction(token, this, m_applyChangesCount); + return hr; + } + + // Add the method to the runtime's Class data structures + LOG((LF_ENC, LL_INFO100000, "EACM::AM: Adding function %p\n", token)); + MethodDesc *pMethod = NULL; + hr = EEClass::AddMethod(pParentType, token, 0, &pMethod); + + if (FAILED(hr)) + { + _ASSERTE(!"Failed to add function"); + LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AM: Failed to add function %p with hr 0x%x\n", token)); + return hr; + } + + // Tell the debugger about the new method so it get's the version number properly + hr = g_pDebugInterface->AddFunction(pMethod, m_applyChangesCount); + if (FAILED(hr)) + { + _ASSERTE(!"Failed to add function"); + LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add method %p to debugger with hr 0x%x\n", token)); + } + + return hr; +} + +//--------------------------------------------------------------------------------------- +// +// AddField - called when a new field is added by EnC. +// +// The module's metadata has already been updated. Here we notify the +// debugger of the update, +// +// Arguments: +// token - fieldDef for the field being added +// +// Return Value: +// S_OK on success. +// if the edit fails for any reason, at any point in this function, +// we are toasted, so return out and IDE will end debug session. +// +// Assumptions: +// The CLR must be suspended for debugging. +// +HRESULT EditAndContinueModule::AddField(mdFieldDef token) +{ + CONTRACTL + { + THROWS; + GC_NOTRIGGER; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + mdTypeDef parentTypeDef; + HRESULT hr = GetMDImport()->GetParentToken(token, &parentTypeDef); + + if (FAILED(hr)) + { + LOG((LF_ENC, LL_INFO100, "**Error** EnCModule::AF can't find parent token for field token %p\n", token)); + return E_FAIL; + } + + // see if the class is loaded yet. If not we don't need to do anything. When this class is + // loaded (with the updated metadata), it will have this field like any other normal field. + // If the class hasn't been loaded, than the debugger shouldn't know anything about it + // so there shouldn't be any harm in not notifying it of the update. For completeness, + // we may want to consider changing this to notify the debugger here as well. + MethodTable * pParentType = LookupTypeDef(parentTypeDef).AsMethodTable(); + if (pParentType == NULL) + { + LOG((LF_ENC, LL_INFO100, "EnCModule::AF class %p not loaded, our work is done\n", parentTypeDef)); + return S_OK; + } + + // Create a new EnCFieldDesc for the field and add it to the class + LOG((LF_ENC, LL_INFO100000, "EACM::AM: Adding field %p\n", token)); + EnCFieldDesc *pField; + hr = EEClass::AddField(pParentType, token, &pField); + + if (FAILED(hr)) + { + LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add field %p to EE with hr 0x%x\n", token)); + return hr; + } + + // Tell the debugger about the new field + hr = g_pDebugInterface->AddField(pField, m_applyChangesCount); + if (FAILED(hr)) + { + LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add field %p to debugger with hr 0x%x\n", token)); + } + +#ifdef _DEBUG + if (g_BreakOnEnCResolveField == -1) + { + g_BreakOnEnCResolveField = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_EnCResolveField); + } +#endif + + return hr; +} + +//--------------------------------------------------------------------------------------- +// +// JitUpdatedFunction - Jit the new version of a function for EnC. +// +// Arguments: +// pMD - the MethodDesc for the method we want to JIT +// pOrigContext - context of thread pointing into original version of the function +// +// Return value: +// Return the address of the newly jitted code or NULL on failure. +// +PCODE EditAndContinueModule::JitUpdatedFunction( MethodDesc *pMD, + CONTEXT *pOrigContext) +{ + CONTRACTL + { + NOTHROW; + GC_TRIGGERS; + MODE_ANY; + } + CONTRACTL_END; + + LOG((LF_ENC, LL_INFO100, "EnCModule::JitUpdatedFunction for %s\n", + pMD->m_pszDebugMethodName)); + + PCODE jittedCode = NULL; + + GCX_COOP(); + +#ifdef _DEBUG + BOOL shouldBreak = CLRConfig::GetConfigValue( + CLRConfig::INTERNAL_EncJitUpdatedFunction); + if (shouldBreak > 0) { + _ASSERTE(!"EncJitUpdatedFunction"); + } +#endif + + // Setup a frame so that has context for the exception + // so that gc can crawl the stack and do the right thing. + _ASSERTE(pOrigContext); + Thread *pCurThread = GetThread(); + _ASSERTE(pCurThread); + FrameWithCookie<ResumableFrame> resFrame(pOrigContext); + resFrame.Push(pCurThread); + + CONTEXT *pCtxTemp = NULL; + // We need to zero out the filter context so a multi-threaded GC doesn't result + // in somebody else tracing this thread & concluding that we're in JITted code. + // We need to remove the filter context so that if we're in preemptive GC + // mode, we'll either have the filter context, or the ResumableFrame, + // but not both, set. + // Since we're in cooperative mode here, we can swap the two non-atomically here. + pCtxTemp = pCurThread->GetFilterContext(); + _ASSERTE(pCtxTemp != NULL); // currently called from within a filter context, protects us during GC-toggle. + pCurThread->SetFilterContext(NULL); + + // get the code address (may jit the fcn if not already jitted) + EX_TRY { + if (!pMD->IsPointingToNativeCode()) + { + GCX_PREEMP(); + pMD->DoPrestub(NULL); + LOG((LF_ENC, LL_INFO100, "EnCModule::ResumeInUpdatedFunction JIT successful\n")); + } + else + { + LOG((LF_ENC, LL_INFO100, "EnCModule::ResumeInUpdatedFunction function already JITed\n")); + } + jittedCode = pMD->GetNativeCode(); + } EX_CATCH { +#ifdef _DEBUG + { + // This is debug-only code to print out the error string, but SString can throw. + // This function is no-throw, and we can't put an EX_TRY inside an EX_CATCH block, so + // we just have the violation. + CONTRACT_VIOLATION(ThrowsViolation); + + StackSString exceptionMessage; + SString errorMessage; + GetExceptionMessage(GET_THROWABLE(), exceptionMessage); + errorMessage.AppendASCII("**Error: Probable rude edit.**\n\n" + "EnCModule::JITUpdatedFunction JIT failed with the following exception:\n\n"); + errorMessage.Append(exceptionMessage); + StackScratchBuffer buffer; + DbgAssertDialog(__FILE__, __LINE__, errorMessage.GetANSI(buffer)); + LOG((LF_ENC, LL_INFO100, errorMessage.GetANSI(buffer))); + } +#endif + } EX_END_CATCH(SwallowAllExceptions) + + resFrame.Pop(pCurThread); + + // Restore the filter context here (see comment above) + pCurThread->SetFilterContext(pCtxTemp); + + return jittedCode; +} + + +//----------------------------------------------------------------------------- +// Called by EnC to resume the code in a new version of the function. +// This will: +// 1) jit the new function +// 2) set the IP to newILOffset within that new function +// 3) adjust local variables (particularly enregistered vars) to the new func. +// It will not return. +// +// Params: +// pMD - method desc for method being updated. This is not enc-version aware. +// oldDebuggerFuncHandle - Debugger DJI to uniquely identify old function. +// This is enc-version aware. +// newILOffset - the IL offset to resume execution at within the new function. +// pOrigContext - context of thread pointing into original version of the function. +// +// This function must be called on the thread that's executing the old function. +// This function does not return. Instead, it will remap this thread directly +// to be executing the new function. +//----------------------------------------------------------------------------- +HRESULT EditAndContinueModule::ResumeInUpdatedFunction( + MethodDesc *pMD, + void *oldDebuggerFuncHandle, + SIZE_T newILOffset, + CONTEXT *pOrigContext) +{ + LOG((LF_ENC, LL_INFO100, "EnCModule::ResumeInUpdatedFunction for %s at IL offset 0x%x, ", + pMD->m_pszDebugMethodName, newILOffset)); + +#ifdef _DEBUG + BOOL shouldBreak = CLRConfig::GetConfigValue( + CLRConfig::INTERNAL_EncResumeInUpdatedFunction); + if (shouldBreak > 0) { + _ASSERTE(!"EncResumeInUpdatedFunction"); + } +#endif + + HRESULT hr = E_FAIL; + + // JIT-compile the updated version of the method + PCODE jittedCode = JitUpdatedFunction(pMD, pOrigContext); + if ( jittedCode == NULL ) + return CORDBG_E_ENC_JIT_CANT_UPDATE; + + GCX_COOP(); + + // This will create a new frame and copy old vars to it + // need pointer to old & new code, old & new info + + EECodeInfo oldCodeInfo(GetIP(pOrigContext)); + _ASSERTE(oldCodeInfo.GetMethodDesc() == pMD); + + // Get the new native offset & IP from the new IL offset + LOG((LF_ENC, LL_INFO10000, "EACM::RIUF: About to map IL forwards!\n")); + SIZE_T newNativeOffset = 0; + g_pDebugInterface->MapILInfoToCurrentNative(pMD, + newILOffset, + jittedCode, + &newNativeOffset); + + EECodeInfo newCodeInfo(jittedCode + newNativeOffset); + _ASSERTE(newCodeInfo.GetMethodDesc() == pMD); + + _ASSERTE(newCodeInfo.GetRelOffset() == newNativeOffset); + + _ASSERTE(oldCodeInfo.GetCodeManager() == newCodeInfo.GetCodeManager()); + + DWORD oldFrameSize = oldCodeInfo.GetFixedStackSize(); + DWORD newFrameSize = newCodeInfo.GetFixedStackSize(); + + // FixContextAndResume() will replace the old stack frame of the function with the new + // one and will initialize that new frame to null. Anything on the stack where that new + // frame sits will be wiped out. This could include anything on the stack right up to or beyond our + // current stack from in ResumeInUpdatedFunction. In order to prevent our current frame from being + // trashed we determine the maximum amount that the stack could grow by and allocate this as a buffer using + // alloca. Then we call FixContextAndResume which can safely rely on the stack because none of it's frames + // state or anything lower can be reached by the new frame. + + if( newFrameSize > oldFrameSize) + { + DWORD frameIncrement = newFrameSize - oldFrameSize; + (void)alloca(frameIncrement); + } + + // Ask the EECodeManager to actually fill in the context and stack for the new frame so that + // values of locals etc. are preserved. + LOG((LF_ENC, LL_INFO100, "EnCModule::ResumeInUpdatedFunction calling FixContextAndResume oldNativeOffset: 0x%x, newNativeOffset: 0x%x," + "oldFrameSize: 0x%x, newFrameSize: 0x%x\n", + oldCodeInfo.GetRelOffset(), newCodeInfo.GetRelOffset(), oldFrameSize, newFrameSize)); + + FixContextAndResume(pMD, + oldDebuggerFuncHandle, + pOrigContext, + &oldCodeInfo, + &newCodeInfo); + + // At this point we shouldn't have failed, so this is genuinely erroneous. + LOG((LF_ENC, LL_ERROR, "**Error** EnCModule::ResumeInUpdatedFunction returned from ResumeAtJit")); + _ASSERTE(!"Should not return from FixContextAndResume()"); + + hr = E_FAIL; + + // If we fail for any reason we have already potentially trashed with new locals and we have also unwound any + // Win32 handlers on the stack so cannot ever return from this function. + EEPOLICY_HANDLE_FATAL_ERROR(CORDBG_E_ENC_INTERNAL_ERROR); +} + +//--------------------------------------------------------------------------------------- +// +// FixContextAndResume - Modify the thread context for EnC remap and resume execution +// +// Arguments: +// pMD - MethodDesc for the method being remapped +// oldDebuggerFuncHandle - Debugger DJI to uniquely identify old function. +// pContext - the thread's original CONTEXT when the remap opportunity was hit +// pOldCodeInfo - collection of various information about the current frame state +// pNewCodeInfo - information about how we want the frame state to be after the remap +// +// Return Value: +// Doesn't return +// +// Notes: +// WARNING: This method cannot access any stack-data below its frame on the stack +// (i.e. anything allocated in a caller frame), so all stack-based arguments must +// EXPLICITLY be copied by value and this method cannot be inlined. We may need to expand +// the stack frame to accomodate the new method, and so extra buffer space must have +// been allocated on the stack. Note that passing a struct by value (via C++) is not +// enough to ensure its data is really copied (on x64, large structs may internally be +// passed by reference). Thus we explicitly make copies of structs passed in, at the +// beginning. +// + +NOINLINE void EditAndContinueModule::FixContextAndResume( + MethodDesc *pMD, + void *oldDebuggerFuncHandle, + T_CONTEXT *pContext, + EECodeInfo *pOldCodeInfo, + EECodeInfo *pNewCodeInfo) +{ + STATIC_CONTRACT_MODE_COOPERATIVE; + STATIC_CONTRACT_GC_TRIGGERS; // Sends IPC event + STATIC_CONTRACT_THROWS; + + // Create local copies of all structs passed as arguments to prevent them from being overwritten + CONTEXT context; + memcpy(&context, pContext, sizeof(CONTEXT)); + pContext = &context; + +#if defined(_TARGET_AMD64_) + // Since we made a copy of the incoming CONTEXT in context, clear any new flags we + // don't understand (like XSAVE), since we'll eventually be passing a CONTEXT based + // on this copy to RtlRestoreContext, and this copy doesn't have the extra info + // required by the XSAVE or other flags. + // + // FUTURE: No reason to ifdef this for amd64-only, except to make this late fix as + // surgical as possible. Would be nice to enable this on x86 early in the next cycle. + pContext->ContextFlags &= CONTEXT_ALL; +#endif // defined(_TARGET_AMD64_) + + EECodeInfo oldCodeInfo; + memcpy(&oldCodeInfo, pOldCodeInfo, sizeof(EECodeInfo)); + pOldCodeInfo = &oldCodeInfo; + + EECodeInfo newCodeInfo; + memcpy(&newCodeInfo, pNewCodeInfo, sizeof(EECodeInfo)); + pNewCodeInfo = &newCodeInfo; + + const ICorDebugInfo::NativeVarInfo *pOldVarInfo = NULL; + const ICorDebugInfo::NativeVarInfo *pNewVarInfo = NULL; + SIZE_T oldVarInfoCount = 0; + SIZE_T newVarInfoCount = 0; + + // Get the var info which the codemanager will use for updating + // enregistered variables correctly, or variables whose lifetimes differ + // at the update point + g_pDebugInterface->GetVarInfo(pMD, oldDebuggerFuncHandle, &oldVarInfoCount, &pOldVarInfo); + g_pDebugInterface->GetVarInfo(pMD, NULL, &newVarInfoCount, &pNewVarInfo); + +#ifdef _TARGET_X86_ + // save the frame pointer as FixContextForEnC might step on it. + LPVOID oldSP = dac_cast<PTR_VOID>(GetSP(pContext)); + + // need to pop the SEH records before write over the stack in FixContextForEnC + PopSEHRecords(oldSP); +#endif + + // Ask the EECodeManager to actually fill in the context and stack for the new frame so that + // values of locals etc. are preserved. + HRESULT hr = pNewCodeInfo->GetCodeManager()->FixContextForEnC( + pContext, + pOldCodeInfo, + pOldVarInfo, oldVarInfoCount, + pNewCodeInfo, + pNewVarInfo, newVarInfoCount); + + // If FixContextForEnC succeeded, the stack is potentially trashed with any new locals and we have also unwound + // any Win32 handlers on the stack so cannot ever return from this function. If FixContextForEnC failed, can't + // assume that the stack is still intact so apply the proper policy for a fatal EE error to bring us down + // "gracefully" (it's all relative). + if (FAILED(hr)) + { + LOG((LF_ENC, LL_INFO100, "**Error** EnCModule::ResumeInUpdatedFunction for FixContextForEnC failed\n")); + EEPOLICY_HANDLE_FATAL_ERROR(hr); + } + + // Set the new IP + // Note that all we're really doing here is setting the IP register. We unfortunately don't + // share any code with the implementation of debugger SetIP, despite the similarities. + LOG((LF_ENC, LL_INFO100, "EnCModule::ResumeInUpdatedFunction: Resume at EIP=0x%x\n", pNewCodeInfo->GetCodeAddress())); + + Thread *pCurThread = GetThread(); + _ASSERTE(pCurThread); + + pCurThread->SetFilterContext(pContext); + SetIP(pContext, pNewCodeInfo->GetCodeAddress()); + + // Notify the debugger that we're about to resume execution in the new version of the method + HRESULT hrIgnore = g_pDebugInterface->RemapComplete(pMD, pNewCodeInfo->GetCodeAddress(), pNewCodeInfo->GetRelOffset()); + + // Now jump into the new version of the method. Note that we can't just setup the filter context + // and return because we are potentially writing new vars onto the stack. + pCurThread->SetFilterContext( NULL ); + +#if defined(_TARGET_X86_) + ResumeAtJit(pContext, oldSP); +#else + RtlRestoreContext(pContext, NULL); +#endif + + // At this point we shouldn't have failed, so this is genuinely erroneous. + LOG((LF_ENC, LL_ERROR, "**Error** EnCModule::ResumeInUpdatedFunction returned from ResumeAtJit")); + _ASSERTE(!"Should not return from ResumeAtJit()"); +} +#endif // #ifndef DACCESS_COMPILE + +//--------------------------------------------------------------------------------------- +// ResolveField - get a pointer to the value of a field that was added by EnC +// +// Arguments: +// thisPointer - For instance fields, a pointer to the object instance of interest. +// For static fields this is unused and should be NULL. +// pFD - FieldDesc describing the field we're interested in +// fAllocateNew - If storage doesn't yet exist for this field and fAllocateNew is true +// then we will attempt to allocate the storage (throwing an exception +// if it fails). Otherwise, if fAllocateNew is false, then we will just +// return NULL when the storage is not yet available. +// +// Return Value: +// If storage doesn't yet exist for this field we return NULL, otherwise, we return a pointer +// to the contents of the field on success. +//--------------------------------------------------------------------------------------- +PTR_CBYTE EditAndContinueModule::ResolveField(OBJECTREF thisPointer, + EnCFieldDesc * pFD) +{ + CONTRACTL + { + GC_NOTRIGGER; + NOTHROW; + SUPPORTS_DAC; + } + CONTRACTL_END; + +#ifdef _DEBUG + if (g_BreakOnEnCResolveField == 1) + { + _ASSERTE( !"EditAndContinueModule::ResolveField"); + } +#endif + + // If it's static, we stash in the EnCFieldDesc + if (pFD->IsStatic()) + { + _ASSERTE( thisPointer == NULL ); + EnCAddedStaticField *pAddedStatic = pFD->GetStaticFieldData(); + if (!pAddedStatic) + { + return NULL; + } + + _ASSERTE( pAddedStatic->m_pFieldDesc == pFD ); + return PTR_CBYTE(pAddedStatic->GetFieldData()); + } + + // not static so get it out of the syncblock + SyncBlock * pBlock = NULL; + + // Get the SyncBlock, failing if not available + pBlock = thisPointer->PassiveGetSyncBlock(); + if( pBlock == NULL ) + { + return NULL; + } + + EnCSyncBlockInfo * pEnCInfo = NULL; + + // Attempt to get the EnC information from the sync block + pEnCInfo = pBlock->GetEnCInfo(); + + if (!pEnCInfo) + { + // No EnC info on this object yet, fail since we don't want to allocate it + return NULL; + } + + // Lookup the actual field value from the EnCSyncBlockInfo + return pEnCInfo->ResolveField(thisPointer, pFD); +} // EditAndContinueModule::ResolveField + +#ifndef DACCESS_COMPILE +//--------------------------------------------------------------------------------------- +// ResolveOrAllocateField - get a pointer to the value of a field that was added by EnC, +// allocating storage for it if necessary +// +// Arguments: +// thisPointer - For instance fields, a pointer to the object instance of interest. +// For static fields this is unused and should be NULL. +// pFD - FieldDesc describing the field we're interested in +// Return Value: +// Returns a pointer to the contents of the field on success. This should only fail due +// to out-of-memory and will therefore throw an OOM exception. +//--------------------------------------------------------------------------------------- +PTR_CBYTE EditAndContinueModule::ResolveOrAllocateField(OBJECTREF thisPointer, + EnCFieldDesc * pFD) +{ + CONTRACTL + { + GC_TRIGGERS; + THROWS; + } + CONTRACTL_END; + + // first try getting a pre-existing field + PTR_CBYTE fieldAddr = ResolveField(thisPointer, pFD); + if (fieldAddr != NULL) + { + return fieldAddr; + } + + // we didn't find the field already allocated + if (pFD->IsStatic()) + { + _ASSERTE(thisPointer == NULL); + EnCAddedStaticField * pAddedStatic = pFD->GetOrAllocateStaticFieldData(); + _ASSERTE(pAddedStatic->m_pFieldDesc == pFD); + return PTR_CBYTE(pAddedStatic->GetFieldData()); + } + + // not static so get it out of the syncblock + SyncBlock* pBlock = NULL; + + // Get the SyncBlock, creating it if necessary + pBlock = thisPointer->GetSyncBlock(); + + EnCSyncBlockInfo * pEnCInfo = NULL; + + // Attempt to get the EnC information from the sync block + pEnCInfo = pBlock->GetEnCInfo(); + + if (!pEnCInfo) + { + // Attach new EnC field info to this object. + pEnCInfo = new EnCSyncBlockInfo; + if (!pEnCInfo) + { + COMPlusThrowOM(); + } + pBlock->SetEnCInfo(pEnCInfo); + } + + // Lookup the actual field value from the EnCSyncBlockInfo + return pEnCInfo->ResolveOrAllocateField(thisPointer, pFD); +} // EditAndContinueModule::ResolveOrAllocateField + +#endif // !DACCESS_COMPILE + +//----------------------------------------------------------------------------- +// Get or optionally create an EnCEEClassData object for the specified +// EEClass in this module. +// +// Arguments: +// pClass - the EEClass of interest +// getOnly - if false (the default), we'll create a new entry of none exists yet +// +// Note: If called in a DAC build, GetOnly must be TRUE +// +PTR_EnCEEClassData EditAndContinueModule::GetEnCEEClassData(MethodTable * pMT, BOOL getOnly /*=FALSE*/ ) +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + SUPPORTS_DAC; + } CONTRACTL_END; + +#ifdef DACCESS_COMPILE + _ASSERTE(getOnly == TRUE); +#endif // DACCESS_COMPILE + + DPTR(PTR_EnCEEClassData) ppData = m_ClassList.Table(); + DPTR(PTR_EnCEEClassData) ppLast = ppData + m_ClassList.Count(); + + // Look for an existing entry for the specified class + while (ppData < ppLast) + { + PREFIX_ASSUME(ppLast != NULL); + if ((*ppData)->GetMethodTable() == pMT) + return *ppData; + ++ppData; + } + + // No match found. Return now if we don't want to create a new entry + if (getOnly) + { + return NULL; + } + +#ifndef DACCESS_COMPILE + // Create a new entry and add it to the end our our table + EnCEEClassData *pNewData = (EnCEEClassData*)(void*)pMT->GetLoaderAllocator()->GetLowFrequencyHeap()->AllocMem_NoThrow(S_SIZE_T(sizeof(EnCEEClassData))); + pNewData->Init(pMT); + ppData = m_ClassList.Append(); + if (!ppData) + return NULL; + *ppData = pNewData; + return pNewData; +#else + DacNotImpl(); + return NULL; +#endif +} + +// Computes the address of this field within the object "o" +void *EnCFieldDesc::GetAddress( void *o) +{ +#ifndef DACCESS_COMPILE + CONTRACTL { + THROWS; + GC_TRIGGERS; + } CONTRACTL_END; + + // can't throw through FieldDesc::GetInstanceField if FORBIDGC_LOADER_USE_ENABLED + _ASSERTE(! FORBIDGC_LOADER_USE_ENABLED()); + + EditAndContinueModule *pModule = (EditAndContinueModule*)GetModule(); + _ASSERTE(pModule->IsEditAndContinueEnabled()); + + // EnC added fields aren't just at some static offset in the object like normal fields + // are. Get the EditAndContinueModule to compute the address for us. + return (void *)pModule->ResolveOrAllocateField(ObjectToOBJECTREF((Object *)o), this); +#else + DacNotImpl(); + return NULL; +#endif +} + +#ifndef DACCESS_COMPILE + +// Do simple field initialization +// We do this when the process is suspended for debugging (in a GC_NOTRIGGER). +// Full initialization will be done in Fixup when the process is running. +void EnCFieldDesc::Init(mdFieldDef token, BOOL fIsStatic) +{ + CONTRACTL + { + THROWS; + GC_NOTRIGGER; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + // Clear out the FieldDesc incase someone attempts to use any of the fields + memset( this, 0, sizeof(EnCFieldDesc) ); + + // Initialize our members + m_pStaticFieldData = NULL; + m_bNeedsFixup = TRUE; + + // Initialize the bare minimum of FieldDesc necessary for now + if (fIsStatic) + FieldDesc::m_isStatic = TRUE; + + SetMemberDef(token); + + SetEnCNew(); +} + +// Allocate a new EnCAddedField instance and hook it up to hold the value for an instance +// field which was added by EnC to the specified object. This effectively adds a reference from +// the object to the new field value so that the field's lifetime is managed properly. +// +// Arguments: +// pFD - description of the field being added +// thisPointer - object instance to attach the new field to +// +EnCAddedField *EnCAddedField::Allocate(OBJECTREF thisPointer, EnCFieldDesc *pFD) +{ + CONTRACTL + { + THROWS; + GC_TRIGGERS; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + LOG((LF_ENC, LL_INFO1000, "\tEnCAF:Allocate for this %p, FD %p\n", thisPointer, pFD->GetMemberDef())); + + // Create a new EnCAddedField instance + EnCAddedField *pEntry = new EnCAddedField; + pEntry->m_pFieldDesc = pFD; + + _ASSERTE(!pFD->GetApproxEnclosingMethodTable()->IsDomainNeutral()); + AppDomain *pDomain = (AppDomain*) pFD->GetApproxEnclosingMethodTable()->GetDomain(); + + // We need to associate the contents of the new field with the object it is attached to + // in a way that mimics the lifetime behavior of a normal field reference. Specifically, + // when the object is collected, the field should also be collected (assuming there are no + // other references), but references to the field shouldn't keep the object alive. + // To acheive this, we have introduced the concept of a "dependent handle" which provides + // the appropriate semantics. The dependent handle has a weak reference to a "primary object" + // (the object getting a new field in this case), and a strong reference to a secondary object. + // When the primary object is collected, the reference to the secondary object is released. + // See the definition of code:HNDTYPE_DEPENDENT and code:Ref_ScanDependentHandles for more details. + // + // We create a helper object and store it as the secondary object in the dependant handle + // so that its liveliness can be maintained along with the primary object. + // The helper then contains an object reference to the real field value that we are adding. + // The reason for doing this is that we cannot hand out the handle address for + // the OBJECTREF address so we need to hand out something else that is hooked up to the handle. + + GCPROTECT_BEGIN(thisPointer); + MethodTable *pHelperMT = MscorlibBinder::GetClass(CLASS__ENC_HELPER); + pEntry->m_FieldData = pDomain->CreateDependentHandle(thisPointer, AllocateObject(pHelperMT)); + GCPROTECT_END(); + + LOG((LF_ENC, LL_INFO1000, "\tEnCAF:Allocate created dependent handle %p\n",pEntry->m_FieldData)); + + // The EnC helper object stores a reference to the actual field value. For fields which are + // reference types, this is simply a normal object reference so we don't need to do anything + // special here. + + if (pFD->GetFieldType() != ELEMENT_TYPE_CLASS) + { + // The field is a value type so we need to create storage on the heap to hold a boxed + // copy of the value and have the helper's objectref point there. + + OBJECTREF obj = NULL; + if (pFD->IsByValue()) + { + // Create a boxed version of the value class. This allows the standard GC algorithm + // to take care of internal pointers into the value class. + obj = AllocateObject(pFD->GetFieldTypeHandleThrowing().GetMethodTable()); + } + else + { + // In the case of primitive types, we use a reference to a 1-element array on the heap. + // I'm not sure why we bother treating primitives specially, it seems like we should be able + // to just box any value type including primitives. + obj = AllocatePrimitiveArray(ELEMENT_TYPE_I1, GetSizeForCorElementType(pFD->GetFieldType())); + } + GCPROTECT_BEGIN (obj); + + // Get a FieldDesc for the object reference field in the EnC helper object (warning: triggers) + FieldDesc *pHelperField = MscorlibBinder::GetField(FIELD__ENC_HELPER__OBJECT_REFERENCE); + + // store the empty boxed object into the helper object + OBJECTREF pHelperObj = GetDependentHandleSecondary(pEntry->m_FieldData); + OBJECTREF *pHelperRef = (OBJECTREF *)pHelperField->GetAddress( pHelperObj->GetAddress() ); + SetObjectReference( pHelperRef, obj, pDomain ); + + GCPROTECT_END (); + } + + return pEntry; +} +#endif // !DACCESS_COMPILE + +//--------------------------------------------------------------------------------------- +// EnCSyncBlockInfo::GetEnCFieldAddrFromHelperFieldDesc +// Gets the address of an EnC field accounting for its type: valuetype, class or primitive +// Arguments: +// input: pHelperFieldDesc - FieldDesc for the enc helper object +// pHelper - EnC helper (points to list of added fields) +// pFD - fieldDesc describing the field of interest +// Return value: the address of the EnC added field +//--------------------------------------------------------------------------------------- +PTR_CBYTE EnCSyncBlockInfo::GetEnCFieldAddrFromHelperFieldDesc(FieldDesc * pHelperFieldDesc, + OBJECTREF pHelper, + EnCFieldDesc * pFD) +{ + WRAPPER_NO_CONTRACT; + SUPPORTS_DAC; + + _ASSERTE(pHelperFieldDesc != NULL); + _ASSERTE(pHelper != NULL); + + // Get the address of the reference inside the helper object which points to + // the field contents + PTR_OBJECTREF pOR = dac_cast<PTR_OBJECTREF>(pHelperFieldDesc->GetAddress(pHelper->GetAddress())); + _ASSERTE(pOR != NULL); + + PTR_CBYTE retAddr = NULL; + + // Compute the address to the actual field contents based on the field type + // See the description above Allocate for details + if (pFD->IsByValue()) + { + // field value is a value type, we store it boxed so get the pointer to the first field + retAddr = dac_cast<PTR_CBYTE>((*pOR)->UnBox()); + } + else if (pFD->GetFieldType() == ELEMENT_TYPE_CLASS) + { + // field value is a reference type, we store the objref directly + retAddr = dac_cast<PTR_CBYTE>(pOR); + } + else + { + // field value is a primitive, we store it inside a 1-element array + OBJECTREF objRef = *pOR; + I1ARRAYREF primitiveArray = dac_cast<I1ARRAYREF>(objRef); + retAddr = dac_cast<PTR_CBYTE>(primitiveArray->GetDirectPointerToNonObjectElements()); + } + + LOG((LF_ENC, LL_INFO1000, "\tEnCSBI:RF address of %s type member is %p\n", + (pFD->IsByValue() ? "ByValue" : pFD->GetFieldType() == ELEMENT_TYPE_CLASS ? "Class" : "Other"), retAddr)); + + return retAddr; +} // EnCSyncBlockInfo::GetEnCFieldAddrFromHelperFieldDesc + +//--------------------------------------------------------------------------------------- +// EnCSyncBlockInfo::ResolveField +// Get the address of the data referenced by an instance field that was added with EnC +// Arguments: +// thisPointer - the object instance whose field to access +// pFD - fieldDesc describing the field of interest +// Return value: Returns a pointer to the data referenced by an EnC added instance field +//--------------------------------------------------------------------------------------- +PTR_CBYTE EnCSyncBlockInfo::ResolveField(OBJECTREF thisPointer, EnCFieldDesc *pFD) +{ + CONTRACTL + { + GC_NOTRIGGER; + NOTHROW; + SUPPORTS_DAC; + } + CONTRACTL_END; + + // We should only be passed FieldDescs for instance fields + _ASSERTE(!pFD->IsStatic()); + + PTR_EnCAddedField pEntry = NULL; + + LOG((LF_ENC, LL_INFO1000, "EnCSBI:RF for this %p, FD %p\n", thisPointer, pFD->GetMemberDef())); + + // This list is not synchronized--it hasn't proved a problem, but we could conceivably see race conditions + // arise here. + // Look for an entry for the requested field in our linked list + pEntry = m_pList; + while (pEntry && pEntry->m_pFieldDesc != pFD) + { + pEntry = pEntry->m_pNext; + } + + if (!pEntry) + { + // No existing entry - we have to return NULL + return NULL; + } + + // we found a matching entry in the list of EnCAddedFields + // Get the EnC helper object (see the detailed description in Allocate above) + OBJECTREF pHelper = GetDependentHandleSecondary(pEntry->m_FieldData); + _ASSERTE(pHelper != NULL); + + FieldDesc *pHelperFieldDesc = NULL; + + // We _HAVE_ to call GetExistingField b/c (a) we can't throw exceptions, and + // (b) we _DON'T_ want to run class init code, either. + pHelperFieldDesc = MscorlibBinder::GetExistingField(FIELD__ENC_HELPER__OBJECT_REFERENCE); + if (pHelperFieldDesc == NULL) + { + return NULL; + } + else + { + return GetEnCFieldAddrFromHelperFieldDesc(pHelperFieldDesc, pHelper, pFD); + } +} // EnCSyncBlockInfo::ResolveField + +#ifndef DACCESS_COMPILE +//--------------------------------------------------------------------------------------- +// EnCSyncBlockInfo::ResolveOrAllocateField +// get the address of an EnC added field, allocating it if it doesn't yet exist +// Arguments: +// thisPointer - the object instance whose field to access +// pFD - fieldDesc describing the field of interest +// Return value: Returns a pointer to the data referenced by an instance field that was added with EnC +//--------------------------------------------------------------------------------------- +PTR_CBYTE EnCSyncBlockInfo::ResolveOrAllocateField(OBJECTREF thisPointer, EnCFieldDesc *pFD) +{ + CONTRACTL + { + GC_TRIGGERS; + WRAPPER(THROWS); + } + CONTRACTL_END; + + // We should only be passed FieldDescs for instance fields + _ASSERTE( !pFD->IsStatic() ); + + // first try to get the address of a pre-existing field (storage has already been allocated) + PTR_CBYTE retAddr = ResolveField(thisPointer, pFD); + + if (retAddr != NULL) + { + return retAddr; + } + + // if the field doesn't yet have available storage, we'll have to allocate it. + PTR_EnCAddedField pEntry = NULL; + + LOG((LF_ENC, LL_INFO1000, "EnCSBI:RF for this %p, FD %p\n", thisPointer, pFD->GetMemberDef())); + + // This list is not synchronized--it hasn't proved a problem, but we could conceivably see race conditions + // arise here. + // Because we may have additions to the head of m_pList at any time, we have to keep searching this + // until we either find a match or succeed in allocating a new entry and adding it to the list + do + { + // Look for an entry for the requested field in our linked list (maybe it was just added) + pEntry = m_pList; + while (pEntry && pEntry->m_pFieldDesc != pFD) + { + pEntry = pEntry->m_pNext; + } + + if (pEntry) + { + // match found + break; + } + + // Allocate an entry and tie it to the object instance + pEntry = EnCAddedField::Allocate(thisPointer, pFD); + + // put at front of list so the list is in order of most recently added + pEntry->m_pNext = m_pList; + if (FastInterlockCompareExchangePointer(&m_pList, pEntry, pEntry->m_pNext) == pEntry->m_pNext) + break; + + // There was a race and another thread modified the list here, so we need to try again + // We should do this so rarely, and EnC perf is of relatively little + // consequence, we should just be taking a lock here to simplify this code. + // @todo - We leak a GC handle here. Allocate() above alloced a GC handle in m_FieldData. + // There's no dtor for pEntry to free it. + delete pEntry; + } while (TRUE); + + // we found a matching entry in the list of EnCAddedFields + // Get the EnC helper object (see the detailed description in Allocate above) + OBJECTREF pHelper = GetDependentHandleSecondary(pEntry->m_FieldData); + _ASSERTE(pHelper != NULL); + + FieldDesc * pHelperField = NULL; + GCPROTECT_BEGIN (pHelper); + pHelperField = MscorlibBinder::GetField(FIELD__ENC_HELPER__OBJECT_REFERENCE); + GCPROTECT_END (); + + return GetEnCFieldAddrFromHelperFieldDesc(pHelperField, pHelper, pFD); +} // EnCSyncBlockInfo::ResolveOrAllocateField + +// Free all the resources associated with the fields added to this object instance +// This is invoked after the object instance has been collected, and the SyncBlock is +// being reclaimed. +// +// Note, this is not threadsafe, and so should only be called when we know no-one else +// maybe using this SyncBlockInfo. +void EnCSyncBlockInfo::Cleanup() +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + SO_TOLERANT; + MODE_ANY; + } + CONTRACTL_END; + // Walk our linked list of all the fields that were added + EnCAddedField *pEntry = m_pList; + while (pEntry) + { + // Clean up the handle we created in EnCAddedField::Allocate + DestroyDependentHandle(*(OBJECTHANDLE*)&pEntry->m_FieldData); + + // Delete this list entry and move onto the next + EnCAddedField *next = pEntry->m_pNext; + delete pEntry; + pEntry = next; + } + + // Finally, delete the sync block info itself + delete this; +} + +// Allocate space to hold the value for the new static field +EnCAddedStaticField *EnCAddedStaticField::Allocate(EnCFieldDesc *pFD) +{ + CONTRACTL + { + THROWS; + GC_TRIGGERS; + } + CONTRACTL_END; + + _ASSERTE(!pFD->GetEnclosingMethodTable()->IsDomainNeutral()); + AppDomain *pDomain = (AppDomain*) pFD->GetApproxEnclosingMethodTable()->GetDomain(); + + // Compute the size of the fieldData entry + size_t fieldSize; + if (pFD->IsByValue() || pFD->GetFieldType() == ELEMENT_TYPE_CLASS) { + // We store references to reference types or boxed value types + fieldSize = sizeof(OBJECTREF*); + } else { + // We store primitives inline + fieldSize = GetSizeForCorElementType(pFD->GetFieldType()); + } + + // allocate an instance with space for the field data + EnCAddedStaticField *pEntry = (EnCAddedStaticField *) + (void*)pDomain->GetHighFrequencyHeap()->AllocMem(S_SIZE_T(offsetof(EnCAddedStaticField, m_FieldData)) + S_SIZE_T(fieldSize)); + pEntry->m_pFieldDesc = pFD; + + // Create a static objectref to point to the field contents, except for primitives + // which will use the memory available in-line at m_FieldData for storage. + // We use static object refs for static fields as these fields won't go away + // unless the module is unloaded, and they can easily be found by GC. + if (pFD->IsByValue()) + { + // create a boxed version of the value class. This allows the standard GC + // algorithm to take care of internal pointers in the value class. + OBJECTREF **pOR = (OBJECTREF**)&pEntry->m_FieldData; + *pOR = pDomain->AllocateStaticFieldObjRefPtrs(1); + OBJECTREF obj = AllocateObject(pFD->GetFieldTypeHandleThrowing().GetMethodTable()); + SetObjectReference( *pOR, obj, pDomain ); + } + else if (pFD->GetFieldType() == ELEMENT_TYPE_CLASS) + { + // references to reference-types are stored directly in the field data + OBJECTREF **pOR = (OBJECTREF**)&pEntry->m_FieldData; + *pOR = pDomain->AllocateStaticFieldObjRefPtrs(1); + } + + return pEntry; +} +#endif // !DACCESS_COMPILE +// GetFieldData - return the ADDRESS where the field data is located +PTR_CBYTE EnCAddedStaticField::GetFieldData() +{ + LIMITED_METHOD_CONTRACT; + SUPPORTS_DAC; + + if ( (m_pFieldDesc->IsByValue()) || (m_pFieldDesc->GetFieldType() == ELEMENT_TYPE_CLASS) ) + { + // It's indirect via an ObjRef at m_FieldData. This is a TADDR, so we need to make a PTR_CBYTE from + // the ObjRef + return *(PTR_CBYTE *)&m_FieldData; + } + else + { + // An elementry type. It's stored directly in m_FieldData. In this case, we need to get the target + // address of the m_FieldData data member and marshal it via the DAC. + return dac_cast<PTR_CBYTE>(PTR_HOST_MEMBER_TADDR(EnCAddedStaticField, this, m_FieldData)); + } +} + +// Gets a pointer to the field's contents (assuming this is a static field) +// We'll return NULL if we don't yet have a pointer to the data. +// Arguments: none +// Return value: address of the static field data if available or NULL otherwise +EnCAddedStaticField * EnCFieldDesc::GetStaticFieldData() +{ + CONTRACTL + { + GC_NOTRIGGER; + NOTHROW; + SUPPORTS_DAC; + } + CONTRACTL_END; + + _ASSERTE(IsStatic()); + + return m_pStaticFieldData; +} + +#ifndef DACCESS_COMPILE +// Gets a pointer to the field's contents (assuming this is a static field) +// Arguments: none +// Return value: address of the field data. If we don't yet have a pointer to the data, +// this will allocate space to store it. +// May throw OOM. +EnCAddedStaticField * EnCFieldDesc::GetOrAllocateStaticFieldData() +{ + CONTRACTL + { + GC_TRIGGERS; + THROWS; + } + CONTRACTL_END; + + _ASSERTE(IsStatic()); + + // If necessary and requested, allocate space for the static field data + if (!m_pStaticFieldData) + { + m_pStaticFieldData = EnCAddedStaticField::Allocate(this); + } + + return m_pStaticFieldData; +} +#endif // !DACCESS_COMPILE + +#ifndef DACCESS_COMPILE +// Adds the provided new field to the appropriate linked list and updates the appropriate count +void EnCEEClassData::AddField(EnCAddedFieldElement *pAddedField) +{ + LIMITED_METHOD_CONTRACT; + // Determine the appropriate field list and update the field counter + EnCFieldDesc *pFD = &pAddedField->m_fieldDesc; + EnCAddedFieldElement **pList; + if (pFD->IsStatic()) + { + ++m_dwNumAddedStaticFields; + pList = &m_pAddedStaticFields; + } + else + { + ++m_dwNumAddedInstanceFields; + pList = &m_pAddedInstanceFields; + } + + // If the list is empty, just add this field as the only entry + if (*pList == NULL) + { + *pList = pAddedField; + return; + } + + // Otherwise, add this field to the end of the field list + EnCAddedFieldElement *pCur = *pList; + while (pCur->m_next != NULL) + { + pCur = pCur->m_next; + } + pCur->m_next = pAddedField; +} + +#endif // #ifndef DACCESS_COMPILE + +#ifdef DACCESS_COMPILE + +void +EnCEEClassData::EnumMemoryRegions(CLRDataEnumMemoryFlags flags) +{ + SUPPORTS_DAC; + DAC_ENUM_DTHIS(); + + if (m_pMT.IsValid()) + { + m_pMT->EnumMemoryRegions(flags); + } + + PTR_EnCAddedFieldElement elt = m_pAddedInstanceFields; + while (elt.IsValid()) + { + elt.EnumMem(); + elt = elt->m_next; + } + elt = m_pAddedStaticFields; + while (elt.IsValid()) + { + elt.EnumMem(); + elt = elt->m_next; + } +} + +void +EditAndContinueModule::EnumMemoryRegions(CLRDataEnumMemoryFlags flags, + bool enumThis) +{ + SUPPORTS_DAC; + + if (enumThis) + { + DAC_ENUM_VTHIS(); + } + + Module::EnumMemoryRegions(flags, false); + + m_ClassList.EnumMemoryRegions(); + + DPTR(PTR_EnCEEClassData) classData = m_ClassList.Table(); + DPTR(PTR_EnCEEClassData) classLast = classData + m_ClassList.Count(); + + while (classData.IsValid() && classData < classLast) + { + if ((*classData).IsValid()) + { + (*classData)->EnumMemoryRegions(flags); + } + + classData++; + } +} + +#endif // #ifdef DACCESS_COMPILE + + +// Create a field iterator which includes EnC fields in addition to the fields from an +// underlying ApproxFieldDescIterator. +// +// Arguments: +// pMT - MethodTable indicating the type of interest +// iteratorType - one of the ApproxFieldDescIterator::IteratorType values specifying which fields +// are of interest. +// fixupEnC - if true, then any partially-initialized EnC FieldDescs will be fixed up to be complete +// initialized FieldDescs as they are returned by Next(). This may load types and do +// other things to trigger a GC. +// +EncApproxFieldDescIterator::EncApproxFieldDescIterator(MethodTable *pMT, int iteratorType, BOOL fixupEnC) : + m_nonEnCIter( pMT, iteratorType ) +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + SUPPORTS_DAC; + } + CONTRACTL_END + + m_fixupEnC = fixupEnC; + +#ifndef DACCESS_COMPILE + // can't fixup for EnC on the debugger thread + _ASSERTE((g_pDebugInterface->GetRCThreadId() != GetCurrentThreadId()) || fixupEnC == FALSE); +#endif + + m_pCurrListElem = NULL; + m_encClassData = NULL; + m_encFieldsReturned = 0; + + // If this is an EnC module, then grab a pointer to the EnC data + if( pMT->GetModule()->IsEditAndContinueEnabled() ) + { + PTR_EditAndContinueModule encMod = PTR_EditAndContinueModule(pMT->GetModule()); + m_encClassData = encMod->GetEnCEEClassData( pMT, TRUE); + } +} + +// Iterates through all fields, returns NULL when done. +PTR_FieldDesc EncApproxFieldDescIterator::Next() +{ + CONTRACTL + { + NOTHROW; + if (m_fixupEnC) {GC_TRIGGERS;} else {GC_NOTRIGGER;} + FORBID_FAULT; + SUPPORTS_DAC; + } + CONTRACTL_END + + // If we still have non-EnC fields to look at, return one of them + if( m_nonEnCIter.CountRemaining() > 0 ) + { + _ASSERTE( m_encFieldsReturned == 0 ); + return m_nonEnCIter.Next(); + } + + // Get the next EnC field Desc if any + PTR_EnCFieldDesc pFD = NextEnC(); + if( pFD == NULL ) + { + // No more fields + return NULL; + } + +#ifndef DACCESS_COMPILE + // Fixup the fieldDesc if requested and necessary + if ( m_fixupEnC && (pFD->NeedsFixup()) ) + { + // if we get an OOM during fixup, the field will just not get fixed up + EX_TRY + { + FAULT_NOT_FATAL(); + pFD->Fixup(pFD->GetMemberDef()); + } + EX_CATCH + { + } + EX_END_CATCH(SwallowAllExceptions) + } + + // Either it's been fixed up so we can use it, or we're the Debugger RC thread, we can't fix it up, + // but it's ok since our logic will check & make sure we don't try and use it. If haven't asked to + // have the field fixed up, should never be trying to get at non-fixed up field in + // this list. Can't simply fixup the field always because loading triggers GC and many + // code paths can't tolerate that. + _ASSERTE( !(pFD->NeedsFixup()) || + ( g_pDebugInterface->GetRCThreadId() == GetCurrentThreadId() ) ); +#endif + + return dac_cast<PTR_FieldDesc>(pFD); +} + +// Iterate through EnC added fields. +// Returns NULL when done. +PTR_EnCFieldDesc EncApproxFieldDescIterator::NextEnC() +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + FORBID_FAULT; + SUPPORTS_DAC; + } + CONTRACTL_END + + // If this module doesn't have any EnC data then there aren't any EnC fields + if( m_encClassData == NULL ) + { + return NULL; + } + + BOOL doInst = ( GetIteratorType() & (int)ApproxFieldDescIterator::INSTANCE_FIELDS); + BOOL doStatic = ( GetIteratorType() & (int)ApproxFieldDescIterator::STATIC_FIELDS); + + int cNumAddedInst = doInst ? m_encClassData->GetAddedInstanceFields() : 0; + int cNumAddedStatics = doStatic ? m_encClassData->GetAddedStaticFields() : 0; + + // If we haven't returned anything yet + if ( m_encFieldsReturned == 0 ) + { + _ASSERTE(m_pCurrListElem == NULL); + + // We're at the start of the instance list. + if ( doInst ) + { + m_pCurrListElem = m_encClassData->m_pAddedInstanceFields; + } + } + + // If we've finished the instance fields (or never wanted to do any) + if ( m_encFieldsReturned == cNumAddedInst) + { + // We should be at the end of the instance list if doInst is true + _ASSERTE(m_pCurrListElem == NULL); + + // We're at the start of the statics list. + if ( doStatic ) + { + m_pCurrListElem = m_encClassData->m_pAddedStaticFields; + } + } + + // If we don't have any elements to return, then we're done + if (m_pCurrListElem == NULL) + { + // Verify that we returned the number we expected to + _ASSERTE( m_encFieldsReturned == cNumAddedInst + cNumAddedStatics ); + return NULL; + } + + // Advance the list pointer and return the element + m_encFieldsReturned++; + PTR_EnCFieldDesc fd = PTR_EnCFieldDesc(PTR_HOST_MEMBER_TADDR(EnCAddedFieldElement, m_pCurrListElem, m_fieldDesc)); + m_pCurrListElem = m_pCurrListElem->m_next; + return fd; +} + +#endif // EnC_SUPPORTED |