/*private void CorProcess_OnStepComplete(object sender, CorStepCompleteEventArgs e)
{
// if (iCount++ % 100 == 0 && logOnBreakpoint)
DI.log.info("[{0}] CorProcess_OnStepComplete {1}", iStepCount++, getActiveFrameFunctionName(e));
e.Continue = handleDebugFlowAction();
}
private void CorProcess_OnBreakpointSetError(object sender, CorBreakpointEventArgs e)
{
if (logOnBreakpoint)
DI.log.info("CorProcess_OnBreakpointSetError {0}", getActiveFrameFunctionName(e));
e.Continue = true;
}
private void CorProcess_OnBreakpoint(object sender, CorBreakpointEventArgs e)
{
DI.log.info("in CorProcess_OnBreakpoint");
/*( if (handleBreakpoints)
{
if (logOnBreakpoint)
log.info("Breakpoint on {0}", getActiveFrameFunctionName(e));
e.Continue = handleDebugFlowAction();
}* /
e.Continue = true;
}
private bool handleDebugFlowAction()
{
switch (onBreakPointAction)
{
case OnBreakPointAction.StepOut:
o2MDbgOLD.mdbgProcess.StepOut();
break;
case OnBreakPointAction.StepInto:
o2MDbgOLD.mdbgProcess.StepInto(false);
break;
case OnBreakPointAction.StepOver:
o2MDbgOLD.mdbgProcess.StepOver(false);
break;
case OnBreakPointAction.Stop:
return false;
case OnBreakPointAction.Continue:
return true;
}
return true;
}
*/
public static string getActiveFrameFunctionName(CorEventArgs e)
{
try
{
if (e.Thread.ActiveFrame == null)
return "e.Thread.ActiveFrame == null";
//var corFunctionBreakpoint = (CorFunctionBreakpoint)e.Breakpoint;
var corMetadataImport = new CorMetadataImport(e.Thread.ActiveFrame.Function.Class.Module);
MethodInfo methodInfo = corMetadataImport.GetMethodInfo(e.Thread.ActiveFrame.Function.Token);
return (methodInfo.DeclaringType.FullName ?? "(null)") + " :: " + (methodInfo.Name ?? "(null)");
}
catch (Exception ex)
{
DI.log.ex(ex, "getActiveFrameFunctionName");
return "";
}
}
// returns true if the CustomPostCallback requested stop.
private bool HandleCustomPostCallback(ManagedCallbackType callbackType, CorEventArgs callbackArgs)
{
bool stopRequested = false;
bool needAsyncStopCall = false;
if (!needAsyncStopCall)
{
Threads.RefreshStack();
}
using (var psc = new MDbgProcessStopController(this, callbackArgs, needAsyncStopCall))
{
if (PostDebugEvent != null)
{
PostDebugEvent(this, new CustomPostCallbackEventArgs(psc, callbackType, callbackArgs));
stopRequested = psc.CustomStopRequested;
}
} // end using
return stopRequested;
}
public MDbgProcessStopController(MDbgProcess process, CorEventArgs eventArgs, bool needAsyncStopCall)
{
Debug.Assert(process != null);
Debug.Assert(eventArgs != null);
this.process = process;
this.eventArgs = eventArgs;
this.needAsyncStopCall = needAsyncStopCall;
}
internal RawModeStopReason(ManagedCallbackType callbackType, CorEventArgs callbackArgs)
{
Debug.Assert(callbackArgs != null);
m_callbackType = callbackType;
m_callbackArgs = callbackArgs;
}
private bool InternalHandleRawMode(ManagedCallbackType callbackType, CorEventArgs callbackArgs)
{
lock (this)
{
switch (RawModeType)
{
case RawMode.None:
return false;
case RawMode.AlwaysStop:
callbackArgs.Continue = false;
m_stopReason = new RawModeStopReason(callbackType, callbackArgs);
++m_stopCount;
Debug.Assert(m_stopCount == 1, "StopCount=" + m_stopCount);
// we should be stopped just by this event
m_stopCounter = g_stopCounter++;
m_stopEvent.Set();
return true;
case RawMode.NeverStop:
return true;
default:
Debug.Assert(false);
return false;
}
}
}
protected override void HandleEvent(ManagedCallbackType eventId, CorEventArgs args)
{
m_outer.InternalFireEvent(eventId, args);
}
/**
* Helper for invoking events. Checks to make sure that handlers
* are hooked up to a handler before the handler is invoked.
*
* We want to allow maximum flexibility by our callers. As such,
* we don't require that they call <code>e.Controller.Continue</code>,
* nor do we require that this class call it. <b>Someone</b> needs
* to call it, however.
*
* Consequently, if an exception is thrown and the process is stopped,
* the process is continued automatically.
*/
private void InternalFireEvent(ManagedCallbackType callbackType, CorEventArgs e)
{
CorProcess owner;
CorController c = e.Controller;
Debug.Assert(c != null);
if (c is CorProcess)
owner = (CorProcess) c;
else
{
Debug.Assert(c is CorAppDomain);
owner = (c as CorAppDomain).Process;
}
Debug.Assert(owner != null);
try
{
owner.DispatchEvent(callbackType, e);
}
finally
{
if (e.Continue)
{
e.Controller.Continue(false);
}
}
}
protected abstract void HandleEvent(ManagedCallbackType eventId, CorEventArgs args);
// when process is first created wait till callbacks are enabled.
internal void DispatchEvent(ManagedCallbackType callback, CorEventArgs e)
{
try
{
if (m_callbackAttachedEvent != null)
m_callbackAttachedEvent.WaitOne(); // waits till callbacks are enabled
Debug.Assert((int) callback >= 0 && (int) callback < m_callbacksArray.Length);
Delegate d = m_callbacksArray[(int) callback];
if (d != null)
d.DynamicInvoke(new Object[] {this, e});
}
catch (Exception ex)
{
var e2 = new CorExceptionInCallbackEventArgs(e.Controller, ex);
OriginalMDbgMessages.WriteLine("Exception in callback: " + ex);
// DC Debug.Assert(false,"Exception in callback: "+ex.ToString());
try
{
// we need to dispatch the exceptin in callback error, but we cannot
// use DispatchEvent since throwing exception in ExceptionInCallback
// would lead to infinite recursion.
Debug.Assert(m_callbackAttachedEvent == null);
Delegate d = m_callbacksArray[(int) ManagedCallbackType.OnExceptionInCallback];
if (d != null)
d.DynamicInvoke(new Object[] {this, e2});
}
catch (Exception ex2)
{
OriginalMDbgMessages.WriteLine("Exception in Exception notification callback: " + ex2);
// DC Debug.Assert(false,"Exception in Exception notification callback: "+ex2.ToString());
// ignore it -- there is nothing we can do.
}
e.Continue = e2.Continue;
}
}
/// <summary>
/// Given a CorEventArgs object, returns a corresponding StopReason.
/// </summary>
/// <param name="args">Callback Arguments.</param>
/// <param name="currentProcess">Current MDbgProcess.</param>
/// <returns>A stop reason corresponsing to the given callback arguments. This
/// function currently creates StopReason objects for CorEventArgs with the following
/// callback types: OnCreateThread, OnExceptionUnwind2, OnModuleLoad, OnMDANotification.
/// For all other callback types, this function returns args.ToString().</returns>
public static Object CreateStopReasonFromEventArgs(CorEventArgs args, MDbgProcess currentProcess)
{
if (args.CallbackType == ManagedCallbackType.OnCreateThread)
{
return new ThreadCreatedStopReason(currentProcess.Threads.GetThreadFromThreadId(args.Thread.Id));
}
if (args.CallbackType == ManagedCallbackType.OnExceptionUnwind2)
{
var ea = args as CorExceptionUnwind2EventArgs;
return new ExceptionUnwindStopReason(ea.AppDomain, ea.Thread, ea.EventType, ea.Flags);
}
if (args.CallbackType == ManagedCallbackType.OnModuleLoad)
{
var ea = args as CorModuleEventArgs;
return new ModuleLoadedStopReason(currentProcess.Modules.Lookup(ea.Module));
}
if (args.CallbackType == ManagedCallbackType.OnMDANotification)
{
var ea = args as CorMDAEventArgs;
return new MDANotificationStopReason(ea.MDA);
}
return args.ToString();
}
