コード例 #1
0
        public void StoppedOnException()
        {
            var getThreadException = Engine.GetThreadExceptionAsync(ID);

            getThreadException.Wait();

            _currentException = CorDebugValue.CreateValue(getThreadException.Result, this.AppDomain);
        }
コード例 #2
0
 //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;
     }
 }
コード例 #3
0
        private CorDebugValue GetResultValue()
        {
            if (m_resultValue == null)
            {
                m_resultValue = Process.ScratchPad.GetValue(m_iScratchPad, m_appDomain);
            }

            return(m_resultValue);
        }
コード例 #4
0
        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);
        }
コード例 #5
0
        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);
        }
コード例 #6
0
        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));
            }
        }
コード例 #7
0
        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);
        }
コード例 #8
0
 public void ResumingExecution()
 {
     if (IsSuspended)
     {
         RefreshChain();
     }
     else
     {
         _chain            = null;
         _currentException = null;
     }
 }
コード例 #9
0
        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);
        }
コード例 #10
0
        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);
        }
コード例 #11
0
 public CorDebugValueReferenceByRef(CorDebugValue val, RuntimeValue rtv, CorDebugAppDomain appDomain) : base(val, rtv, appDomain)
 {
 }
コード例 #12
0
 public CorDebugValueReference(CorDebugValue val, RuntimeValue rtv, CorDebugAppDomain appDomain)
     : base(rtv, appDomain)
 {
     m_value = val;
 }
コード例 #13
0
 protected CorDebugValue CreateValue(RuntimeValue rtv)
 {
     return(CorDebugValue.CreateValue(rtv, m_appDomain));
 }
コード例 #14
0
 private void ResetScratchPadLocation()
 {
     m_iScratchPad = SCRATCH_PAD_INDEX_NOT_INITIALIZED;
     m_resultValue = null;
 }
コード例 #15
0
        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);
        }
コード例 #16
0
 int ICorDebugType.GetClass(out ICorDebugClass ppClass)
 {
     ppClass = CorDebugValue.ClassFromRuntimeValue(m_ValueArray.RuntimeValue, m_ValueArray.AppDomain);
     return(COM_HResults.S_OK);
 }