public CorDebugFunctionBreakpoint (CorDebugFunction function, uint ilCLR) : base(function.AppDomain) { m_function = function; m_il = new Pdbx.IL(); m_il.CLR = ilCLR; m_il.TinyCLR = function.GetILTinyCLRFromILCLR(ilCLR); m_breakpointDef.m_IP = m_il.TinyCLR; m_breakpointDef.m_md = m_function.MethodDef_Index; this.Active = true; }
public CorDebugFunctionBreakpoint(CorDebugFunction function, uint ilCLR) : base(function.AppDomain) { m_function = function; m_il = new Pdbx.IL(); m_il.CLR = ilCLR; m_il.TinyCLR = function.GetILTinyCLRFromILCLR(ilCLR); m_breakpointDef.m_IP = m_il.TinyCLR; m_breakpointDef.m_md = m_function.MethodDef_Index; this.Active = true; }
public static CorDebugFunction CorDebugFunctionFromMethodIndex(uint methodIndex, CorDebugAppDomain appDomain) { CorDebugFunction function = null; CorDebugAssembly assembly = appDomain.AssemblyFromIdx(TinyCLR_TypeSystem.IdxAssemblyFromIndex(methodIndex)); if (assembly != null) { uint tk = TinyCLR_TypeSystem.TinyCLRTokenFromMethodIndex(methodIndex); function = assembly.GetFunctionFromTokenTinyCLR(tk); } return(function); }
private CorDebugFunction GetFunctionFromToken(uint tk, Hashtable ht) { CorDebugFunction function = null; Pdbx.Method method = ht [tk] as Pdbx.Method; if (method != null) { CorDebugClass c = new CorDebugClass(this, method.Class); function = new CorDebugFunction(c, method); } Debug.Assert(function != null); return(function); }
int ICorDebugEval.NewObject(ICorDebugFunction pConstructor, uint nArgs, ICorDebugValue[] ppArgs) { Debug.Assert(nArgs == ppArgs.Length); CorDebugFunction f = (CorDebugFunction)pConstructor; CorDebugClass c = f.Class; this.Process.SetCurrentAppDomain(this.AppDomain); Engine.AllocateObject(GetScratchPadLocation(), c.TypeDef_Index); ICorDebugValue[] args = new ICorDebugValue[nArgs + 1]; args[0] = GetResultValue(); ppArgs.CopyTo(args, 1); ((ICorDebugEval)this).CallFunction(pConstructor, (uint)args.Length, args); return(Utility.COM_HResults.S_OK); }
public CorDebugCode (CorDebugFunction function) { m_function = function; }
public CorDebugCode(CorDebugFunction function) { m_function = function; }
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 CorDebugValue RuntimeInvoke (CorDebugFunction function, CorDebugType[] typeArgs, CorDebugValue thisObj, CorDebugValue[] arguments) { return Session.RuntimeInvoke (this, function, typeArgs, thisObj, arguments); }
private CorDebugFunction GetFunctionFromToken( uint tk, Hashtable ht ) { CorDebugFunction function = null; Pdbx.Method method = ht[tk] as Pdbx.Method; if(method != null) { CorDebugClass c = new CorDebugClass( this, method.Class ); function = new CorDebugFunction( c, method ); } Debug.Assert( function != null ); return function; }
public CorDebugValue RuntimeInvoke (CorEvaluationContext corEvaluationContext, CorDebugFunction function, CorDebugType[] typeArgs, CorDebugValue thisObj, CorDebugValue[] arguments) { return null; }
int ICorDebugManagedCallback.EditAndContinueRemap (CorDebugAppDomain pAppDomain, CorDebugThread pThread, CorDebugFunction pFunction, int fAccurate) { return 0; }