// ICorDebugEnum
public static IEnumerable<ICorDebugFrame> GetEnumerator(this ICorDebugFrameEnum corEnum)
{
corEnum.Reset();
while (true) {
ICorDebugFrame[] corFrames = new ICorDebugFrame[EnumerateBufferSize];
uint fetched = corEnum.Next(EnumerateBufferSize, corFrames);
if (fetched == 0)
yield break;
for(int i = 0; i < fetched; i++)
yield return corFrames[i];
}
}
internal RuntimeFrame(RuntimeThread thread, ICorDebugFrame comFrame)
{
_thread = thread;
_comFrame = comFrame;
if (!IsExternal)
{
ICorDebugFunction comFunction;
comFrame.GetFunction(out comFunction);
ICorDebugModule comModule;
comFunction.GetModule(out comModule);
var module = Session.FindModule(x => x.ComModule == comModule);
_function = module.GetFunction(comFunction);
}
}
public void Exception([In, MarshalAs(UnmanagedType.Interface)] ICorDebugAppDomain pAppDomain, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pThread, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugFrame pFrame, [In] uint nOffset, [In] CorDebugExceptionCallbackType dwEventType, [In] uint dwFlags)
{
throw new NotImplementedException();
}
//
// IEnumerator interface
//
public bool MoveNext()
{
ICorDebugFrame[] a = new ICorDebugFrame[1];
uint c = 0;
int r = m_enum.Next((uint)a.Length, a, out c);
if (r == 0 && c == 1) // S_OK && we got 1 new element
m_frame = new CorFrame(a[0]);
else
m_frame = null;
return m_frame != null;
}
public void Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
pAppDomain.Continue(0);
}
public static ICorDebugValue GetStaticFieldValue(this ICorDebugType instance, uint fieldDef, ICorDebugFrame pFrame)
{
ICorDebugValue ppValue;
instance.__GetStaticFieldValue(fieldDef, pFrame, out ppValue);
return ppValue;
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType exceptionType, uint dwFlags)
{
EnterCallback(PausedReason.Exception, "Exception2 (type=" + exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Whatch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
process.SelectedThread.CurrentExceptionType = (ExceptionType)exceptionType;
if (ExceptionType.DEBUG_EXCEPTION_UNHANDLED != (ExceptionType)exceptionType)
{
// Handled exception
if (process.PauseOnHandledException)
{
ExitCallback_Paused();
}
else
{
ExitCallback_Continue();
}
}
else
{
// Unhandled exception
ExitCallback_Paused();
}
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType _exceptionType, uint dwFlags)
{
EnterCallback(PausedReason.Exception, "Exception2 (type=" + _exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Watch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
ExceptionType exceptionType = (ExceptionType)_exceptionType;
bool pauseOnHandled = !process.Evaluating && process.Options != null && process.Options.PauseOnHandledExceptions;
if (exceptionType == ExceptionType.Unhandled || (pauseOnHandled && exceptionType == ExceptionType.CatchHandlerFound)) {
// sanity check: we can only handle one exception after another
// TODO : create Exception queue if CLR throws multiple exceptions
Debug.Assert(process.SelectedThread.CurrentException == null);
process.SelectedThread.CurrentException = new Exception(new Value(process.AppDomains[pAppDomain], process.SelectedThread.CorThread.GetCurrentException()).GetPermanentReference());
process.SelectedThread.CurrentException_DebuggeeState = process.DebuggeeState;
process.SelectedThread.CurrentExceptionType = exceptionType;
process.SelectedThread.CurrentExceptionIsUnhandled = exceptionType == ExceptionType.Unhandled;
pauseOnNextExit = true;
}
ExitCallback();
}
int ICorDebugInternalFrame.GetCallee(out ICorDebugFrame ppFrame)
{
return(ICorDebugFrame.GetCallee(out ppFrame));
}
public static ICorDebugFrame Next(this ICorDebugFrameEnum corEnum)
{
ICorDebugFrame[] corFrames = new ICorDebugFrame[] { null };
uint framesFetched = corEnum.Next(1, corFrames);
return corFrames[0];
}
int ICorDebugThread2.InterceptCurrentException( ICorDebugFrame pFrame )
{
CorDebugFrame frame = (CorDebugFrame)pFrame;
this.Engine.UnwindThread(this.ID, frame.DepthTinyCLR);
return Utility.COM_HResults.S_OK;
}
int ICorDebugThread.GetActiveFrame(out ICorDebugFrame ppFrame)
{
Debug.Assert(!IsVirtualThread);
((ICorDebugChain)this.GetLastCorDebugThread().Chain).GetActiveFrame(out ppFrame);
return Utility.COM_HResults.S_OK;
}
internal RuntimeFrame(RuntimeFunction function, RuntimeThread thread, ICorDebugFrame comFrame)
{
_thread = thread;
_function = function;
_comFrame = comFrame;
}
int ICorDebugInternalFrame.GetCode(out ICorDebugCode ppCode)
{
return(ICorDebugFrame.GetCode(out ppCode));
}
public void Exception(
ICorDebugAppDomain pAppDomain,
ICorDebugThread pThread,
ICorDebugFrame pFrame,
uint nOffset,
CorDebugExceptionCallbackType dwEventType,
uint dwFlags)
{
m_listner.PostExceptionNotification(
new CorThread(pThread),
new CorFunctionFrame(pFrame),
dwEventType,
dwFlags);
controller.Continue(0);
}
int ICorDebugInternalFrame.GetFunctionToken(out uint pToken)
{
return(ICorDebugFrame.GetFunctionToken(out pToken));
}
public virtual void Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
pAppDomain.Continue(0);
}
internal CorFrame(ICorDebugFrame frame)
: base(frame)
{
m_frame = frame;
}
int ICorDebugFrame.GetCallee (out ICorDebugFrame ppFrame)
{
ppFrame = (ICorDebugFrame)m_chain.GetFrameFromDepthCLR (this.m_depthCLR + 1);
return Utility.COM_HResults.S_OK;
}
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 ICorDebugILFrame.GetCaller( out ICorDebugFrame ppFrame )
{
return ((ICorDebugFrame)this).GetCaller( out ppFrame );
}
internal CorFrame(ICorDebugFrame coframe, CorDebuggerOptions options)
: base(coframe, options)
{
this.coframe = coframe;
}
int ICorDebugNativeFrame.GetCallee(out ICorDebugFrame ppFrame)
{
return ((ICorDebugFrame)this).GetCallee(out ppFrame);
}
public static uint Next(this ICorDebugFrameEnum instance, uint celt, ICorDebugFrame[] frames)
{
uint pceltFetched;
instance.__Next(celt, frames, out pceltFetched);
return pceltFetched;
}
int ICorDebugInternalFrame.GetCallee( out ICorDebugFrame ppFrame )
{
return this.ICorDebugFrame.GetCallee( out ppFrame );
}
public virtual void Exception(
ICorDebugAppDomain appDomain,
ICorDebugThread thread,
ICorDebugFrame frame,
int offset,
CorDebugExceptionCallbackType eventType,
int flags)
{
this.DefaultHandler(appDomain);
}
int ICorDebugType.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
{
ppValue = null;
return(COM_HResults.E_NOTIMPL);
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType _exceptionType, uint dwFlags)
{
EnterCallback("Exception2 (type=" + _exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Watch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
ExceptionType exceptionType = (ExceptionType)_exceptionType;
bool pauseOnHandled = !process.Evaluating && process.Options != null && process.Options.PauseOnHandledExceptions;
Thread thread = process.GetThread(pThread);
if (exceptionType == ExceptionType.Unhandled || (pauseOnHandled && exceptionType == ExceptionType.CatchHandlerFound && BreakOnException(thread))) {
// Multiple exceptions can happen at the same time on multiple threads
// (I have managed to create a test application to trigger it)
thread.CurrentExceptionType = exceptionType;
RequestPause(thread).ExceptionsThrown.Add(thread);
}
ExitCallback();
}
int ICorDebugChain. GetActiveFrame( out ICorDebugFrame ppFrame )
{
ppFrame = this.ActiveFrame;
return Utility.COM_HResults.S_OK;
}
int ICorDebugInternalFrame.GetChain(out ICorDebugChain ppChain)
{
return(ICorDebugFrame.GetChain(out ppChain));
}
int ICorDebugFrame.GetCallee(out ICorDebugFrame ppFrame)
{
ppFrame = (ICorDebugFrame)m_chain.GetFrameFromDepthCLR(this.m_depthCLR + 1);
return(Utility.COM_HResults.S_OK);
}
int ICorDebugInternalFrame.GetFunction(out ICorDebugFunction ppFunction)
{
return(ICorDebugFrame.GetFunction(out ppFunction));
}
int ICorDebugInternalFrame.GetCaller(out ICorDebugFrame ppFrame)
{
return(this.ICorDebugFrame.GetCaller(out ppFrame));
}
int ICorDebugInternalFrame.GetStackRange(out ulong pStart, out ulong pEnd)
{
return(ICorDebugFrame.GetStackRange(out pStart, out pEnd));
}
public static ICorDebugValue GetStaticFieldValue(this ICorDebugClass instance, uint fieldDef, ICorDebugFrame pFrame)
{
ICorDebugValue ppValue;
instance.__GetStaticFieldValue(fieldDef, pFrame, out ppValue);
ProcessOutParameter(ppValue);
return ppValue;
}
int ICorDebugInternalFrame.CreateStepper(out ICorDebugStepper ppStepper)
{
return(ICorDebugFrame.CreateStepper(out ppStepper));
}
public void Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
throw new NotImplementedException();
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType _exceptionType, uint dwFlags)
{
EnterCallback("Exception2 (type=" + _exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Watch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
ExceptionType exceptionType = (ExceptionType)_exceptionType;
bool pauseOnHandled = !process.Evaluating && process.Options != null && process.Options.PauseOnHandledExceptions;
Thread thread = process.GetThread(pThread);
if (exceptionType == ExceptionType.Unhandled || (pauseOnHandled && exceptionType == ExceptionType.CatchHandlerFound && BreakOnException(thread)))
{
// Multiple exceptions can happen at the same time on multiple threads
// (I have managed to create a test application to trigger it)
thread.CurrentExceptionType = exceptionType;
RequestPause(thread).ExceptionsThrown.Add(thread);
}
ExitCallback();
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType exceptionType, uint dwFlags)
{
ManagedCallback managedCallback = GetProcessCallbackInterface("Exception2", pAppDomain);
if (managedCallback != null) {
managedCallback.Exception2(pAppDomain, pThread, pFrame, nOffset, exceptionType, dwFlags);
}
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType exceptionType, uint dwFlags)
{
ManagedCallback managedCallback = GetProcessCallbackInterface("Exception2", pAppDomain);
if (managedCallback != null)
{
managedCallback.Exception2(pAppDomain, pThread, pFrame, nOffset, exceptionType, dwFlags);
}
}
public CorFunctionFrame(ICorDebugFrame frm)
{
frame = frm;
}
public Exception2DebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, CorDebugExceptionFlags dwFlags)
: base(pAppDomain)
{
AppDomain = pAppDomain;
Thread = pThread;
Frame = pFrame;
Offset = nOffset;
EventType = dwEventType;
Flags = dwFlags;
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType _exceptionType, uint dwFlags)
{
EnterCallback(PausedReason.Exception, "Exception2 (type=" + _exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Watch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
ExceptionType exceptionType = (ExceptionType)_exceptionType;
bool pauseOnHandled = !process.Evaluating && process.Options != null && process.Options.PauseOnHandledExceptions;
if (exceptionType == ExceptionType.Unhandled || (pauseOnHandled && exceptionType == ExceptionType.CatchHandlerFound))
{
// sanity check: we can only handle one exception after another
// TODO : create Exception queue if CLR throws multiple exceptions
Debug.Assert(process.SelectedThread.CurrentException == null);
process.SelectedThread.CurrentException = new Exception(new Value(process.AppDomains[pAppDomain], process.SelectedThread.CorThread.GetCurrentException()).GetPermanentReference());
process.SelectedThread.CurrentException_DebuggeeState = process.DebuggeeState;
process.SelectedThread.CurrentExceptionType = exceptionType;
process.SelectedThread.CurrentExceptionIsUnhandled = exceptionType == ExceptionType.Unhandled;
pauseOnNextExit = true;
}
ExitCallback();
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType exceptionType, uint dwFlags)
{
EnterCallback(PausedReason.Exception, "Exception2 (type=" + exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Watch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
if ((ExceptionType)exceptionType == ExceptionType.Unhandled || process.PauseOnHandledException)
{
process.SelectedThread.CurrentException = new Exception(new Value(process.AppDomains[pAppDomain], process.SelectedThread.CorThread.GetCurrentException()).GetPermanentReference());
process.SelectedThread.CurrentException_DebuggeeState = process.DebuggeeState;
process.SelectedThread.CurrentExceptionType = (ExceptionType)exceptionType;
process.SelectedThread.CurrentExceptionIsUnhandled = (ExceptionType)exceptionType == ExceptionType.Unhandled;
pauseOnNextExit = true;
}
ExitCallback();
}
void ICorDebugManagedCallback2.Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
var ev = new CorEventArgs(new CorAppDomain(pAppDomain, p_options));
GetOwner(ev.Controller).DispatchEvent(ev);
FinishEvent(ev);
}
public void Exception2(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType exceptionType, uint dwFlags)
{
EnterCallback(PausedReason.Exception, "Exception2 (type=" + exceptionType.ToString() + ")", pThread);
// This callback is also called from Exception(...)!!!! (the .NET 1.1 version)
// Watch out for the zeros and null!
// Exception -> Exception2(pAppDomain, pThread, null, 0, exceptionType, 0);
if ((ExceptionType)exceptionType == ExceptionType.Unhandled || process.PauseOnHandledException) {
process.SelectedThread.CurrentException = new Exception(new Value(process.AppDomains[pAppDomain], process.SelectedThread.CorThread.GetCurrentException()).GetPermanentReference());
process.SelectedThread.CurrentException_DebuggeeState = process.DebuggeeState;
process.SelectedThread.CurrentExceptionType = (ExceptionType)exceptionType;
process.SelectedThread.CurrentExceptionIsUnhandled = (ExceptionType)exceptionType == ExceptionType.Unhandled;
pauseOnNextExit = true;
}
ExitCallback();
}
int ICorDebugChain.GetActiveFrame(out ICorDebugFrame ppFrame)
{
ppFrame = this.ActiveFrame;
return(Utility.COM_HResults.S_OK);
}
public static void InterceptCurrentException(this ICorDebugThread2 instance, ICorDebugFrame pFrame)
{
instance.__InterceptCurrentException(pFrame);
}
public void Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
var domain = GetProcessWrapper(pAppDomain).GetAppDomain(pAppDomain);
var thread = domain.GetThread(pThread);
var frame = thread.CurrentFrame;
string exceptionType = string.Empty;
switch (dwEventType)
{
case CorDebugExceptionCallbackType.CatchHandlerFound: exceptionType = "Catch handler"; break;
case CorDebugExceptionCallbackType.FirstChance: exceptionType = "First chance"; break;
case CorDebugExceptionCallbackType.Unhandled: exceptionType = "Unhandled"; break;
case CorDebugExceptionCallbackType.UserFirstChance: exceptionType = "User first chance"; break;
}
Log("{0} exception occured in {1}, thread {2}, at offset {3}", exceptionType, domain.Name, thread.Id, nOffset);
var eventArgs = new DebuggeeExceptionEventArgs(domain, thread, nOffset, dwEventType);
domain.DispatchExceptionOccurredEvent(eventArgs);
FinalizeEvent(eventArgs);
}
public Exception2DebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, CorDebugExceptionFlags dwFlags)
: base(pAppDomain) {
this.AppDomain = pAppDomain;
this.Thread = pThread;
this.Frame = pFrame;
this.Offset = nOffset;
this.EventType = dwEventType;
this.Flags = dwFlags;
}
int ICorDebugType.GetStaticFieldValue (uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
{
ppValue = null;
return Utility.COM_HResults.E_NOTIMPL;
}
public void ExceptionCatcher(ICorDebugAppDomain appDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
ExceptionCatcherNotification(new CorDebugAppDomain(appDomain), new CorThread(pThread), new CorFunctionFrame(pFrame), dwEventType,nOffset);
}
int ICorDebugFrame.GetCallee(out ICorDebugFrame ppFrame)
{
ppFrame = (ICorDebugFrame)_chain.GetFrameFromDepthCLR(_depthCLR + 1);
return(COM_HResults.S_OK);
}
public void Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
try
{
_EnterCallback();
_CallbackNotImplemented();
_CallbackEvent("Exception");
}
catch (Exception e)
{
_CallbackException(e);
}
}
int ICorDebugILFrame.GetCaller(out ICorDebugFrame ppFrame)
{
return(((ICorDebugFrame)this).GetCaller(out ppFrame));
}
internal CorFrame(ICorDebugFrame frame)
: base(frame)
{
m_frame = frame;
}
int ICorDebugNativeFrame.GetCallee(out ICorDebugFrame ppFrame)
{
return(((ICorDebugFrame)this).GetCallee(out ppFrame));
}
void ICorDebugManagedCallback2.Exception(ICorDebugAppDomain ad, ICorDebugThread thread,
ICorDebugFrame frame, uint offset,
CorDebugExceptionCallbackType eventType, uint flags)
{
HandleEvent(ManagedCallbackType.OnException2,
new CorException2EventArgs(ad == null ? null : new CorAppDomain(ad),
thread == null ? null : new CorThread(thread),
frame == null ? null : new CorFrame(frame),
(int)offset,
eventType,
(int)flags,
ManagedCallbackType.OnException2));
}
public void Exception(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFrame pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags)
{
Console.WriteLine("Exception");
pAppDomain.Continue(0);
}
