public CorDebugFunctionBreakpoint(CorDebugFunction function, uint ilCLR) : base(function.AppDomain) { m_function = function; m_il = new Pdbx.IL(); m_il.CLR = ilCLR; m_il.nanoCLR = function.GetILnanoCLRFromILCLR(ilCLR); m_breakpointDef.m_IP = m_il.nanoCLR; m_breakpointDef.m_md = m_function.MethodDef_Index; Active = true; }
public static CorDebugFunction CorDebugFunctionFromMethodIndex(uint methodIndex, CorDebugAppDomain appDomain) { CorDebugFunction function = null; CorDebugAssembly assembly = appDomain.AssemblyFromIdx(nanoCLR_TypeSystem.IdxAssemblyFromIndex(methodIndex)); if (assembly != null) { uint tk = nanoCLR_TypeSystem.nanoCLRTokenFromMethodIndex(methodIndex); function = assembly.GetFunctionFromTokennanoCLR(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(COM_HResults.S_OK); }
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 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); }