//Object or CLASS, or VALUETYPE public CorDebugValueObject(RuntimeValue rtv, CorDebugAppDomain appDomain) : base(rtv, appDomain) { if (!rtv.IsNull) { m_class = CorDebugValue.ClassFromRuntimeValue(rtv, appDomain); m_fIsEnum = m_class.IsEnum; m_fIsBoxed = rtv.IsBoxed; } }
private CorDebugValue GetResultValue() { if (m_resultValue == null) { m_resultValue = Process.ScratchPad.GetValue(m_iScratchPad, m_appDomain); } return(m_resultValue); }
private CorDebugValue[] EnsureValues(ref CorDebugValue[] values, uint cInfo, Engine.StackValueKind kind) { if (values == null) { values = CorDebugValue.CreateValues(this.Engine.GetStackFrameValueAll(m_chain.Thread.ID, this.DepthnanoCLR, cInfo, kind), this.Process); } return(values); }
public static CorDebugValue[] CreateValues(RuntimeValue[] rtv, CorDebugAppDomain appDomain) { CorDebugValue [] values = new CorDebugValue[rtv.Length]; for (int i = 0; i < rtv.Length; i++) { values[i] = CorDebugValue.CreateValue(rtv[i], appDomain); } return(values); }
int ICorDebugType.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue) { uint fd = nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(fieldDef, this.Assembly); this.Process.SetCurrentAppDomain(this.AppDomain); RuntimeValue rtv = this.Engine.GetStaticFieldValue(fd); ppValue = CorDebugValue.CreateValue(rtv, this.AppDomain); return(COM_HResults.S_OK); }
public static CorDebugValue CreateValue(RuntimeValue rtv, CorDebugAppDomain appDomain) { CorDebugValue val = null; bool fIsReference; if (rtv.IsBoxed) { val = new CorDebugValueBoxedObject(rtv, appDomain); fIsReference = true; } else if (rtv.IsPrimitive) { CorDebugClass c = ClassFromRuntimeValue(rtv, appDomain); if (c.IsEnum) { val = new CorDebugValueObject(rtv, appDomain); fIsReference = false; } else { val = new CorDebugValuePrimitive(rtv, appDomain); fIsReference = false; } } else if (rtv.IsArray) { val = new CorDebugValueArray(rtv, appDomain); fIsReference = true; } else if (rtv.CorElementType == CorElementType.ELEMENT_TYPE_STRING) { val = new CorDebugValueString(rtv, appDomain); fIsReference = true; } else { val = new CorDebugValueObject(rtv, appDomain); fIsReference = !rtv.IsValueType; } if (fIsReference) { val = new CorDebugValueReference(val, val._rtv, val._appDomain); } if (rtv.IsReference) //CorElementType.ELEMENT_TYPE_BYREF { val = new CorDebugValueReferenceByRef(val, val._rtv, val._appDomain); } return(val); }
public void ResumingExecution() { if (IsSuspended) { RefreshChain(); } else { _chain = null; _currentException = null; } }
int ICorDebugClass.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue) { //Cache, and invalidate when necessary??? uint fd = nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(fieldDef, Assembly); Process.SetCurrentAppDomain(AppDomain); RuntimeValue rtv = Engine.GetStaticFieldValue(fd); ppValue = CorDebugValue.CreateValue(rtv, AppDomain); return(COM_HResults.S_OK); }
int ICorDebugThread.GetObject(out ICorDebugValue ppObject) { Debug.Assert(!IsVirtualThread); RuntimeValue rv = Engine.GetThread(ID); if (rv != null) { ppObject = CorDebugValue.CreateValue(rv, AppDomain); } else { ppObject = null; } return(COM_HResults.S_OK); }
int ICorDebugEval.CallFunction(ICorDebugFunction pFunction, uint nArgs, ICorDebugValue[] ppArgs) { try { //CreateThread will cause a thread create event to occur. This is a virtual thread, so //we need to suspend processing of nanoCLR commands until we have created the thread ourselves //and the processing of a new virtual thread will be ignored. Process.SuspendCommands(true); //need to flush the breakpoints in case new breakpoints were waiting until process was resumed. Process.UpdateBreakpoints(); Debug.Assert(nArgs == ppArgs.Length); Debug.Assert(Process.IsExecutionPaused); CorDebugFunction function = (CorDebugFunction)pFunction; uint md = function.MethodDef_Index; if (function.IsVirtual && function.IsInstance) { Debug.Assert(nArgs > 0); md = this.Engine.GetVirtualMethod(function.MethodDef_Index, ((CorDebugValue)ppArgs[0]).RuntimeValue); } this.Process.SetCurrentAppDomain(this.AppDomain); //Send the selected thread ID to the device so calls that use Thread.CurrentThread work as the user expects. uint pid = this.Engine.CreateThread(md, GetScratchPadLocation(), m_threadReal.ID); if (pid == uint.MaxValue) { throw new ArgumentException("nanoCLR cannot call this function. Possible reasons include: ByRef arguments not supported"); } //If anything below fails, we need to clean up by killing the thread if (nArgs > 0) { List <RuntimeValue> stackFrameValues = this.Engine.GetStackFrameValueAll(pid, 0, function.NumArg, Engine.StackValueKind.Argument); for (int iArg = 0; iArg < nArgs; iArg++) { CorDebugValue valSrc = (CorDebugValue)ppArgs[iArg]; CorDebugValue valDst = CorDebugValue.CreateValue(stackFrameValues[iArg], m_appDomain); if (valDst.RuntimeValue.Assign(valSrc.RuntimeValue) == null) { throw new ArgumentException("nanoCLR cannot set argument " + iArg); } } } m_threadVirtual = new CorDebugThread(this.Process, pid, this); m_threadReal.AttachVirtualThread(m_threadVirtual); Debug.Assert(!m_fActive); m_fActive = true; //It is possible that a hard breakpoint is hit, the first line of the function //to evaluate. If that is the case, than breakpoints need to be drained so the //breakpoint event is fired, to avoid a race condition, where cpde resumes //execution to start the function eval before it gets the breakpoint event //This is primarily due to the difference in behaviour of the nanoCLR and the desktop. //In the desktop, the hard breakpoint will not get hit until execution is resumed. //The nanoCLR can hit the breakpoint during the Thread_Create call. Process.DrainBreakpointsAsync().Wait(); } finally { Process.SuspendCommands(false); } return(COM_HResults.S_OK); }
public CorDebugValueReferenceByRef(CorDebugValue val, RuntimeValue rtv, CorDebugAppDomain appDomain) : base(val, rtv, appDomain) { }
public CorDebugValueReference(CorDebugValue val, RuntimeValue rtv, CorDebugAppDomain appDomain) : base(rtv, appDomain) { m_value = val; }
int ICorDebugType.GetClass(out ICorDebugClass ppClass) { ppClass = CorDebugValue.ClassFromRuntimeValue(m_ValueArray.RuntimeValue, m_ValueArray.AppDomain); return(COM_HResults.S_OK); }
public void StoppedOnException() { _currentException = CorDebugValue.CreateValue(Engine.GetThreadException(ID), AppDomain); }
private CorDebugValue GetStackFrameValue(uint dwIndex, Engine.StackValueKind kind) { var stackFrameValue = Engine.GetStackFrameValue(_chain.Thread.ID, _depthnanoCLR, kind, dwIndex); return(CorDebugValue.CreateValue(stackFrameValue, AppDomain)); }
private void ResetScratchPadLocation() { m_iScratchPad = SCRATCH_PAD_INDEX_NOT_INITIALIZED; m_resultValue = null; }
protected CorDebugValue CreateValue(RuntimeValue rtv) { return(CorDebugValue.CreateValue(rtv, _appDomain)); }