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 ICorDebugClass.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue) { //Cache, and invalidate when necessary??? uint fd = TinyCLR_TypeSystem.ClassMemberIndexFromCLRToken(fieldDef, this.Assembly); this.Process.SetCurrentAppDomain(this.AppDomain); RuntimeValue rtv = this.Engine.GetStaticFieldValue(fd); ppValue = CorDebugValue.CreateValue(rtv, this.AppDomain); return(Utility.COM_HResults.S_OK); }
int ICorDebugThread.GetObject(out ICorDebugValue ppObject) { Debug.Assert(!IsVirtualThread); RuntimeValue rv = Engine.GetThread(m_id); if (rv != null) { ppObject = CorDebugValue.CreateValue(rv, this.AppDomain); } else { ppObject = null; } return(Utility.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 tinyclr 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("TinyCLR 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 = 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(args[iArg], m_appDomain); if (valDst.RuntimeValue.Assign(valSrc.RuntimeValue) == null) { throw new ArgumentException("TinyCLR 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 TinyCLR and the desktop. //In the desktop, the hard breakpoint will not get hit until execution is resumed. //The TinyCLR can hit the breakpoint during the Thread_Create call. Process.DrainBreakpoints(); } finally { Process.SuspendCommands(false); } return(Utility.COM_HResults.S_OK); }
public void StoppedOnException() { m_currentException = CorDebugValue.CreateValue(Engine.GetThreadException(m_id), this.AppDomain); }
protected CorDebugValue CreateValue(RuntimeValue rtv) { return(CorDebugValue.CreateValue(rtv, m_appDomain)); }
private CorDebugValue GetStackFrameValue(uint dwIndex, Engine.StackValueKind kind) { return(CorDebugValue.CreateValue(this.Engine.GetStackFrameValue(m_chain.Thread.ID, m_depthTinyCLR, kind, dwIndex), this.AppDomain)); }