public void StoppedOnException() { var getThreadException = Engine.GetThreadExceptionAsync(ID); getThreadException.Wait(); _currentException = CorDebugValue.CreateValue(getThreadException.Result, this.AppDomain); }
//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); }
private CorDebugValue GetStackFrameValue(uint dwIndex, Engine.StackValueKind kind) { using (CancellationTokenSource cts = new CancellationTokenSource()) { var frameValue = this.Engine.GetStackFrameValueAsync(m_chain.Thread.ID, m_depthnanoCLR, kind, dwIndex, cts.Token); frameValue.Wait(); return(CorDebugValue.CreateValue(frameValue.Result, this.AppDomain)); } }
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.m_rtv, val.m_appDomain); } if (rtv.IsReference) //CorElementType.ELEMENT_TYPE_BYREF { val = new CorDebugValueReferenceByRef(val, val.m_rtv, val.m_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, this.Assembly); this.Process.SetCurrentAppDomain(this.AppDomain); var getField = this.Engine.GetStaticFieldValueAsync(fd); getField.Wait(); RuntimeValue rtv = getField.Result; ppValue = CorDebugValue.CreateValue(rtv, this.AppDomain); return(COM_HResults.S_OK); }
int ICorDebugThread.GetObject(out ICorDebugValue ppObject) { Debug.Assert(!IsVirtualThread); var getThread = Engine.GetThreadAsync(ID); getThread.Wait(); RuntimeValue rv = getThread.Result; if (rv != null) { ppObject = CorDebugValue.CreateValue(rv, this.AppDomain); } else { ppObject = null; } 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; }
protected CorDebugValue CreateValue(RuntimeValue rtv) { return(CorDebugValue.CreateValue(rtv, m_appDomain)); }
private void ResetScratchPadLocation() { m_iScratchPad = SCRATCH_PAD_INDEX_NOT_INITIALIZED; m_resultValue = null; }
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); var getMethod = this.Engine.GetVirtualMethodAsync(function.MethodDef_Index, ((CorDebugValue)ppArgs[0]).RuntimeValue); getMethod.Wait(); md = getMethod.Result; } this.Process.SetCurrentAppDomain(this.AppDomain); //Send the selected thread ID to the device so calls that use Thread.CurrentThread work as the user expects. var createThread = this.Engine.CreateThreadAsync(md, GetScratchPadLocation(), m_threadReal.ID); createThread.Wait(); uint pid = createThread.Result; 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) { RuntimeValue[] args = new RuntimeValue[0]; using (CancellationTokenSource cts = new CancellationTokenSource()) { var getStack = this.Engine.GetStackFrameValueAllAsync(pid, 0, function.NumArg, Engine.StackValueKind.Argument, cts.Token); getStack.Wait(); args = getStack.Result; } for (int iArg = 0; iArg < nArgs; iArg++) { CorDebugValue valSrc = (CorDebugValue)ppArgs[iArg]; CorDebugValue valDst = CorDebugValue.CreateValue(args[iArg], m_appDomain); var assignTask = valDst.RuntimeValue.AssignAsync(valSrc.RuntimeValue); assignTask.Wait(); if (assignTask.Result == 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 behavior 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.DrainBreakpoints(); } finally { Process.SuspendCommands(false); } return(COM_HResults.S_OK); }
int ICorDebugType.GetClass(out ICorDebugClass ppClass) { ppClass = CorDebugValue.ClassFromRuntimeValue(m_ValueArray.RuntimeValue, m_ValueArray.AppDomain); return(COM_HResults.S_OK); }