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);
}