private void HandleEvent(Event e)
{
if (_mainThread == null)
_mainThread = e.Thread;
switch (e.EventType)
{
case EventType.VMStart:
OnVMStart((VMStartEvent) e);
return;
case EventType.AssemblyLoad:
OnAssemblyLoad((AssemblyLoadEvent)e);
break;
case EventType.AssemblyUnload:
OnAssemblyUnload((AssemblyUnloadEvent)e);
break;
case EventType.AppDomainCreate:
OnAppDomainCreate((AppDomainCreateEvent)e);
break;
case EventType.AppDomainUnload:
OnAppDomainUnload((AppDomainUnloadEvent)e);
break;
case EventType.TypeLoad:
OnTypeLoad((TypeLoadEvent)e);
break;
case EventType.MethodEntry:
OnMethodEntry((MethodEntryEvent)e);
return;
case EventType.Step:
OnStep((StepEvent)e);
return;
case EventType.VMDisconnect:
case EventType.VMDeath:
Trace(e.EventType.ToString());
_vmSuspended = true;
Dispose();
return;
}
SafeResume();
}
void QueueBreakEventSet (Event[] eventSet)
{
#if DEBUG_EVENT_QUEUEING
Console.WriteLine ("qq eventset({0}): {1}", eventSet.Length, eventSet[0]);
#endif
var events = new List<Event> (eventSet);
lock (queuedEventSets) {
queuedEventSets.AddLast (events);
}
}
public bool CheckAssemblyLoad( Event evt )
{
var al = evt as AssemblyLoadEvent;
if ( al != null ) {
MarkAssembly( al.Assembly );
return true;
}
return false;
}
void HandleBreakEventSet (Event[] es, bool dequeuing)
{
if (dequeuing && exited)
return;
OnHandleBreakEventSet (es);
bool resume = true;
ObjectMirror exception = null;
TargetEventType etype = TargetEventType.TargetStopped;
BreakEvent breakEvent = null;
if (es[0] is ExceptionEvent) {
var bad = es.FirstOrDefault (ee => !(ee is ExceptionEvent));
if (bad != null)
throw new Exception ("Catchpoint eventset had unexpected event type " + bad.GetType ());
var ev = (ExceptionEvent)es[0];
if (ev.Request == unhandledExceptionRequest)
etype = TargetEventType.UnhandledException;
else
etype = TargetEventType.ExceptionThrown;
exception = ev.Exception;
if (ev.Request != unhandledExceptionRequest || exception.Type.FullName != "System.Threading.ThreadAbortException")
resume = false;
}
else {
//always need to evaluate all breakpoints, some might be tracepoints or conditional bps with counters
foreach (Event e in es) {
BreakpointEvent be = e as BreakpointEvent;
if (be != null) {
if (!HandleBreakpoint (e.Thread, be.Request)) {
etype = TargetEventType.TargetHitBreakpoint;
BreakInfo binfo;
if (breakpoints.TryGetValue (be.Request, out binfo))
breakEvent = binfo.BreakEvent;
resume = false;
}
} else if (e is StepEvent) {
etype = TargetEventType.TargetStopped;
resume = false;
} else {
throw new Exception ("Break eventset had unexpected event type " + e.GetType ());
}
}
}
if (resume) {
//all breakpoints were conditional and evaluated as false
vm.Resume ();
DequeueEventsForFirstThread ();
} else {
if (currentStepRequest != null) {
currentStepRequest.Enabled = false;
currentStepRequest = null;
}
current_thread = recent_thread = es[0].Thread;
TargetEventArgs args = new TargetEventArgs (etype);
args.Process = OnGetProcesses () [0];
args.Thread = GetThread (args.Process, current_thread);
args.Backtrace = GetThreadBacktrace (current_thread);
args.BreakEvent = breakEvent;
if (exception != null)
activeExceptionsByThread [current_thread.ThreadId] = exception;
OnTargetEvent (args);
}
}
protected virtual void OnHandleBreakEventSet (Event[] events)
{
}
void HandleBreakEventSet (Event[] es, bool dequeuing)
{
if (dequeuing && exited)
return;
bool resume = true;
bool steppedOut = false;
bool steppedInto = false;
bool redoCurrentStep = false;
ObjectMirror exception = null;
TargetEventType etype = TargetEventType.TargetStopped;
BreakEvent breakEvent = null;
if (es[0] is ExceptionEvent) {
var bad = es.FirstOrDefault (ee => ee.EventType != EventType.Exception);
if (bad != null)
throw new Exception ("Catchpoint eventset had unexpected event type " + bad.GetType ());
var ev = (ExceptionEvent)es[0];
if (ev.Request == unhandledExceptionRequest)
etype = TargetEventType.UnhandledException;
else
etype = TargetEventType.ExceptionThrown;
exception = ev.Exception;
if (ev.Request != unhandledExceptionRequest || exception.Type.FullName != "System.Threading.ThreadAbortException")
resume = false;
}
else {
//always need to evaluate all breakpoints, some might be tracepoints or conditional bps with counters
foreach (Event e in es) {
if (e.EventType == EventType.Breakpoint) {
var be = e as BreakpointEvent;
BreakInfo binfo;
if (!HandleBreakpoint (e.Thread, be.Request)) {
etype = TargetEventType.TargetHitBreakpoint;
autoStepInto = false;
resume = false;
}
if (breakpoints.TryGetValue (be.Request, out binfo)) {
if (currentStepRequest != null &&
binfo.Location.ILOffset == currentAddress &&
e.Thread.Id == currentStepRequest.Thread.Id)
redoCurrentStep = true;
breakEvent = binfo.BreakEvent;
}
} else if (e.EventType == EventType.Step) {
var stepRequest = e.Request as StepEventRequest;
steppedInto = IsStepIntoRequest (stepRequest);
steppedOut = IsStepOutRequest (stepRequest);
etype = TargetEventType.TargetStopped;
resume = false;
} else if (e.EventType == EventType.UserBreak) {
etype = TargetEventType.TargetStopped;
autoStepInto = false;
resume = false;
} else {
throw new Exception ("Break eventset had unexpected event type " + e.GetType ());
}
}
}
if (redoCurrentStep) {
StepDepth depth = currentStepRequest.Depth;
StepSize size = currentStepRequest.Size;
current_thread = recent_thread = es[0].Thread;
currentStepRequest.Enabled = false;
currentStepRequest = null;
Step (depth, size);
} else if (resume) {
//all breakpoints were conditional and evaluated as false
vm.Resume ();
DequeueEventsForFirstThread ();
} else {
if (currentStepRequest != null) {
currentStepRequest.Enabled = false;
currentStepRequest = null;
}
current_thread = recent_thread = es[0].Thread;
if (exception != null)
activeExceptionsByThread [current_thread.ThreadId] = exception;
var backtrace = GetThreadBacktrace (current_thread);
bool stepOut = false;
if (backtrace.FrameCount > 0) {
var frame = backtrace.GetFrame (0) as SoftDebuggerStackFrame;
currentAddress = frame != null ? frame.Address : -1;
if (steppedInto && Options.StepOverPropertiesAndOperators)
stepOut = frame != null && IsPropertyOrOperatorMethod (frame.StackFrame.Method);
}
if (stepOut) {
// We will want to call StepInto once StepOut returns...
autoStepInto = true;
Step (StepDepth.Out, StepSize.Min);
} else if (steppedOut && autoStepInto) {
autoStepInto = false;
Step (StepDepth.Into, StepSize.Min);
} else {
var args = new TargetEventArgs (etype);
args.Process = OnGetProcesses () [0];
args.Thread = GetThread (args.Process, current_thread);
args.Backtrace = backtrace;
args.BreakEvent = breakEvent;
OnTargetEvent (args);
}
}
}
internal EventSet (VirtualMachine vm, SuspendPolicy suspend_policy, Event[] events) {
this.vm = vm;
this.suspend_policy = suspend_policy;
this.events = events;
}
private bool HandleEvent(MDS.Event e, MDS.SuspendPolicy policy)
{
//LogProvider.Log ("Received Event: " + e.GetType ());
bool exit = false;
lock (vm)
{
exit = exited;
}
if (exit)
{
return(false);
}
bool ret = running;
//if (VMSuspended != null && policy != MDS.SuspendPolicy.None)
//{
// switch (e.EventType)
// {
// case MDS.EventType.VMStart:
// case MDS.EventType.VMDeath:
// case MDS.EventType.VMDisconnect:
// case MDS.EventType.AppDomainCreate:
// case MDS.EventType.AppDomainUnload:
// case MDS.EventType.ThreadStart:
// case MDS.EventType.ThreadDeath:
// case MDS.EventType.AssemblyLoad:
// case MDS.EventType.AssemblyUnload:
// case MDS.EventType.TypeLoad:
// break;
// default:
// LogProvider.Log (e.EventType.ToString ());
// OnVMSuspended (new Event (e, State.Suspend));
// break;
// }
//}
switch (e.EventType)
{
case MDS.EventType.VMStart:
if (VMStateChanged != null)
{
VMStateChanged(new Event(e, State.Start));
}
break;
case MDS.EventType.VMDeath:
if (VMStateChanged != null)
{
VMStateChanged(new Event(e, State.Stop));
}
ret = false;
break;
case MDS.EventType.VMDisconnect:
if (VMStateChanged != null)
{
VMStateChanged(new Event(e, State.Disconnect));
}
ret = false;
break;
case MDS.EventType.AppDomainCreate:
if (AppDomainLoaded != null)
{
AppDomainLoaded(new Event(e));
}
appdomains.Add(((MDS.AppDomainCreateEvent)e).Domain);
break;
case MDS.EventType.AppDomainUnload:
if (AppDomainUnloaded != null)
{
AppDomainUnloaded(new Event(e));
}
if (appdomains.Contains(((MDS.AppDomainUnloadEvent)e).Domain))
{
appdomains.Remove(((MDS.AppDomainUnloadEvent)e).Domain);
}
break;
case MDS.EventType.ThreadStart:
if (ThreadStarted != null)
{
ThreadStarted(new Event(e));
}
break;
case MDS.EventType.ThreadDeath:
if (ThreadStopped != null)
{
ThreadStopped(new Event(e));
}
break;
case MDS.EventType.AssemblyLoad:
if (AssemblyLoaded != null)
{
var ev = new AssemblyEvent(e);
AssemblyLoaded(ev);
if (!ev.Cancel && !filteredAssemblies.Contains(((MDS.AssemblyLoadEvent)e).Assembly.Id))
{
var tr = vm.CreateTypeLoadRequest();
tr.AssemblyFilter = new MDS.AssemblyMirror [] { ((MDS.AssemblyLoadEvent)e).Assembly };
tr.Enable();
filteredAssemblies.Add(((MDS.AssemblyLoadEvent)e).Assembly.Id);
}
}
break;
case MDS.EventType.AssemblyUnload:
if (AssemblyUnloaded != null)
{
AssemblyUnloaded(new AssemblyEvent(e));
}
break;
case MDS.EventType.TypeLoad:
if (TypeLoaded != null)
{
TypeLoaded(new TypeEvent(e));
}
break;
case MDS.EventType.Breakpoint:
if (BreakpointHit != null)
{
BreakpointHit(new BreakpointEvent(e));
}
break;
case MDS.EventType.Step:
if (Stepped != null)
{
Stepped(new Event(e));
}
break;
case MDS.EventType.MethodEntry:
LogProvider.Log(((MDS.MethodEntryEvent)e).Method.FullName);
break;
default:
LogProvider.Log("Unknown event: " + e.GetType());
break;
}
if (policy != MDS.SuspendPolicy.None)
{
Resume();
}
return(ret);
}
public AssemblyEvent(MDS.Event ev)
: base(ev)
{
}
public BreakpointEvent(MDS.Event ev)
: base(ev)
{
}
private bool HandleEventSet(Event ev)
{
if (ev.EventType == EventType.Breakpoint)
{
HandleBreakPoint((BreakpointEvent) ev);
return currentStepRequest != null && currentStepRequest.Enabled;
}
if (ev.EventType == EventType.Step)
{
HandleStep((StepEvent) ev);
return false;
}
switch (ev.EventType)
{
case EventType.TypeLoad:
var typeEvent = (TypeLoadEvent) ev;
RegisterType(typeEvent.Type);
if (TryBindBreakpoints() != 0)
return false;
break;
case EventType.VMDeath:
case EventType.VMDisconnect:
Disconnect();
return false;
default:
logger.Trace(ev);
break;
}
return true;
}
public bool CheckBreakPointRequest (Event evt)
{
var bpe = evt as BreakpointEvent;
if (bpe != null) {
BreakPoint bp = null;
if (rbps.TryGetValue (bpe.Request as BreakpointEventRequest, out bp)) {
CodeRecord rec = bp.Record;
lock ( DataStore )
{
rec.Hit (bp.Location.LineNumber);
if ( bp.Location.LineNumber == bp.Record.GetFirstLine() ) {
rec.CallCount++;
}
}
}
}
return bpe != null;
}
public bool CheckMethodEntryRequest (Event evt)
{
var met = evt as MethodEntryEvent;
if (met != null) {
CodeRecord rec = null;
Log( "call {0}", met.Method.FullName );
if (records.TryGetValue (met.Method.FullName, out rec)) {
rec.CallCount++;
//if (rec.Lines.Count > 0)
// rec.Hit (rec.Lines [0]);
}
}
return met != null;
}
public bool CheckMethodRequests (Event evt)
{
return CheckMethodEntryRequest (evt);
}
private void OnVMGotSuspended(Event e)
{
_vmSuspended = true;
if (VMGotSuspended != null)
VMGotSuspended(e);
}
void HandleEvent (Event e)
{
switch (e.EventType) {
case EventType.AssemblyLoad: {
var ae = (AssemblyLoadEvent) e;
string location = ae.Assembly.Location;
// If we miss the unload, we can reload an assembly we've already seen
if (assemblyLocations.ContainsValue (location)) {
RependBreakpoints (location);
}
assemblyLocations[ae.Assembly] = location;
bool isExternal = !UpdateAssemblyFilters (ae.Assembly) && userAssemblyNames != null;
string flagExt = isExternal? " [External]" : "";
OnDebuggerOutput (false, string.Format ("Loaded assembly: {0}{1} ({2})\n", location, flagExt, ae.Assembly.GetHashCode ()));
break;
}
case EventType.AssemblyUnload: {
var aue = (AssemblyUnloadEvent) e;
string location;
if (!assemblyLocations.TryGetValue (aue.Assembly, out location))
break;
assemblyLocations.Remove (aue.Assembly);
RependBreakpoints (location);
OnDebuggerOutput (false, string.Format ("Unloaded assembly: {0}\n", location));
break;
}
case EventType.VMStart: {
OnStarted (new ThreadInfo (0, GetId (e.Thread), e.Thread.Name, null));
//HACK: 2.6.1 VM doesn't emit type load event, so work around it
var t = vm.RootDomain.Corlib.GetType ("System.Exception", false, false);
if (t != null)
ResolveBreakpoints (t);
break;
}
case EventType.TypeLoad: {
var t = ((TypeLoadEvent)e).Type;
ResolveBreakpoints (t);
break;
}
case EventType.ThreadStart: {
var ts = (ThreadStartEvent) e;
OnDebuggerOutput (false, string.Format ("Thread started: {0}\n", ts.Thread.Name));
OnTargetEvent (new TargetEventArgs (TargetEventType.ThreadStarted) {
Thread = new ThreadInfo (0, GetId (ts.Thread), ts.Thread.Name, null),
});
break;
}
case EventType.ThreadDeath: {
var ts = (ThreadDeathEvent) e;
OnDebuggerOutput (false, string.Format ("Thread finished: {0}\n", ts.Thread.Name));
OnTargetEvent (new TargetEventArgs (TargetEventType.ThreadStopped) {
Thread = new ThreadInfo (0, GetId (ts.Thread), ts.Thread.Name, null),
});
break;
}
case EventType.UserLog: {
var ul = (UserLogEvent) e;
OnDebuggerOutput (false, string.Format ("[{0}:{1}] {2}\n", ul.Level, ul.Category, ul.Message));
break;
}
default:
Console.WriteLine ("Unknown debugger event type {0}", e.GetType ());
break;
}
}
public Event(MDS.Event ev, State state = State.None) : base(ev)
{
State = state;
}
private HandlerAction DoProcessEvent(Event e)
{
HandlerAction action = HandlerAction.Resume;
try
{
Func<Event, HandlerAction> handler;
if (m_handlers.TryGetValue(e.GetType(), out handler))
action = handler(e);
else
action = DoUnknownEvent(e);
}
catch (Exception ex)
{
if (Debugger.IsShuttingDown(ex))
{
Log.WriteLine(TraceLevel.Error, "Debugger", "VMDisconnectedException while trying to process {0}", e);
DoTransition(State.Disconnected);
}
else
{
Log.WriteLine(TraceLevel.Error, "Debugger", "{0}", ex);
NSString title = NSString.Create("Error processing {0}.", ex);
NSString message = NSString.Create(ex.Message);
NSApplication.sharedApplication().BeginInvoke(() => Functions.NSRunAlertPanel(title, message));
}
}
return action;
}
void HandleEvent (Event e)
{
switch (e.EventType) {
case EventType.AssemblyLoad: {
var ae = (AssemblyLoadEvent) e;
bool isExternal = !UpdateAssemblyFilters (ae.Assembly) && userAssemblyNames != null;
string flagExt = isExternal? " [External]" : "";
OnDebuggerOutput (false, string.Format ("Loaded assembly: {0}{1}\n", ae.Assembly.Location, flagExt));
break;
}
case EventType.AssemblyUnload: {
var aue = (AssemblyUnloadEvent) e;
// Mark affected breakpoints as pending again
var affectedBreakpoints = new List<KeyValuePair<EventRequest, BreakInfo>> (
breakpoints.Where (x=> (x.Value.Location.Method.DeclaringType.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)))
);
foreach (KeyValuePair<EventRequest,BreakInfo> breakpoint in affectedBreakpoints) {
string file = PathToFileName (breakpoint.Value.Location.SourceFile);
int line = breakpoint.Value.Location.LineNumber;
OnDebuggerOutput (false, string.Format ("Re-pending breakpoint at {0}:{1}\n", file, line));
breakpoints.Remove (breakpoint.Key);
pending_bes.Add (breakpoint.Value);
}
// Remove affected types from the loaded types list
var affectedTypes = new List<string> (
from pair in types
where pair.Value.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)
select pair.Key
);
foreach (string typename in affectedTypes) {
types.Remove (typename);
}
foreach (var pair in source_to_type) {
pair.Value.RemoveAll (delegate (TypeMirror mirror){
return mirror.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase);
});
}
OnDebuggerOutput (false, string.Format ("Unloaded assembly: {0}\n", aue.Assembly.Location));
break;
}
case EventType.VMStart: {
OnStarted (new ThreadInfo (0, GetId (e.Thread), e.Thread.Name, null));
//HACK: 2.6.1 VM doesn't emit type load event, so work around it
var t = vm.RootDomain.Corlib.GetType ("System.Exception", false, false);
if (t != null)
ResolveBreakpoints (t);
break;
}
case EventType.TypeLoad: {
var t = ((TypeLoadEvent)e).Type;
string typeName = t.FullName;
if (types.ContainsKey (typeName)) {
/* This can happen since we manually add entries to 'types' */
/*
if (typeName != "System.Exception" && typeName != "<Module>")
LoggingService.LogError ("Type '" + typeName + "' loaded more than once", null);
*/
} else {
ResolveBreakpoints (t);
}
break;
}
case EventType.ThreadStart: {
var ts = (ThreadStartEvent) e;
OnDebuggerOutput (false, string.Format ("Thread started: {0}\n", ts.Thread.Name));
OnTargetEvent (new TargetEventArgs (TargetEventType.ThreadStarted) {
Thread = new ThreadInfo (0, GetId (ts.Thread), ts.Thread.Name, null),
});
break;
}
case EventType.ThreadDeath: {
var ts = (ThreadDeathEvent) e;
OnDebuggerOutput (false, string.Format ("Thread finished: {0}\n", ts.Thread.Name));
OnTargetEvent (new TargetEventArgs (TargetEventType.ThreadStopped) {
Thread = new ThreadInfo (0, GetId (ts.Thread), ts.Thread.Name, null),
});
break;
}
case EventType.UserLog: {
var ul = (UserLogEvent) e;
OnDebuggerOutput (false, string.Format ("[{0}:{1}] {2}\n", ul.Level, ul.Category, ul.Message));
break;
}
default:
Console.WriteLine ("Unknown debugger event type {0}", e.GetType ());
break;
}
}
private HandlerAction DoUnknownEvent(Event e)
{
Log.WriteLine(TraceLevel.Info, "Debugger", "Unknown: {0}", e);
return HandlerAction.Resume;
}
private void HandleEventSet(Event ev)
{
var type = ev.EventType;
switch (type)
{
case EventType.Breakpoint:
if (!HandleBreakPoint((BreakpointEvent)ev))
return;
break;
case EventType.Step:
HandleStep((StepEvent)ev);
return;
case EventType.TypeLoad:
var typeEvent = (TypeLoadEvent)ev;
RegisterType(typeEvent.Type);
TryBindBreakpoints();
break;
case EventType.UserLog:
UserLogEvent e = (UserLogEvent)ev;
HostOutputWindowEx.WriteLaunchError(e.Message);
break;
case EventType.VMDeath:
case EventType.VMDisconnect:
Disconnect();
return;
default:
logger.Trace(ev);
break;
}
try
{
_vm.Resume();
}
catch (VMNotSuspendedException)
{
if (type != EventType.VMStart && _vm.Version.AtLeast(2, 2))
throw;
}
}
void HandleEvent (Event e)
{
bool isBreakEvent = e is BreakpointEvent || e is ExceptionEvent || e is StepEvent;
if (isBreakEvent && current_thread != null && e.Thread.Id != current_thread.Id) {
QueueEvent (e);
} else {
HandleEvent (e, false);
}
}
void HandleEvent (Event e)
{
OnHandleEvent (e);
if (e is AssemblyLoadEvent) {
AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
bool isExternal = !UpdateAssemblyFilters (ae.Assembly) && userAssemblyNames != null;
string flagExt = isExternal? " [External]" : "";
OnDebuggerOutput (false, string.Format ("Loaded assembly: {0}{1}\n", ae.Assembly.Location, flagExt));
}
else if (e is AssemblyUnloadEvent) {
AssemblyUnloadEvent aue = (AssemblyUnloadEvent)e;
// Mark affected breakpoints as pending again
List<KeyValuePair<EventRequest,BreakInfo>> affectedBreakpoints = new List<KeyValuePair<EventRequest, BreakInfo>> (
breakpoints.Where (x=> (x.Value.Location.Method.DeclaringType.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)))
);
foreach (KeyValuePair<EventRequest,BreakInfo> breakpoint in affectedBreakpoints) {
string file = PathToFileName (breakpoint.Value.Location.SourceFile);
int line = breakpoint.Value.Location.LineNumber;
OnDebuggerOutput (false, string.Format ("Re-pending breakpoint at {0}:{1}\n", file, line));
breakpoints.Remove (breakpoint.Key);
pending_bes.Add (breakpoint.Value.BreakEvent);
}
// Remove affected types from the loaded types list
List<string> affectedTypes = new List<string> (
from pair in types
where pair.Value.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)
select pair.Key
);
foreach (string typename in affectedTypes) {
types.Remove (typename);
}
foreach (var pair in source_to_type) {
pair.Value.RemoveAll (delegate (TypeMirror mirror){
return mirror.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase);
});
}
OnDebuggerOutput (false, string.Format ("Unloaded assembly: {0}\n", aue.Assembly.Location));
}
else if (e is VMStartEvent) {
//HACK: 2.6.1 VM doesn't emit type load event, so work around it
var t = vm.RootDomain.Corlib.GetType ("System.Exception", false, false);
if (t != null)
ResolveBreakpoints (t);
OnVMStartEvent ((VMStartEvent) e);
}
else if (e is TypeLoadEvent) {
var t = ((TypeLoadEvent)e).Type;
string typeName = t.FullName;
if (types.ContainsKey (typeName)) {
if (typeName != "System.Exception")
LoggingService.LogError ("Type '" + typeName + "' loaded more than once", null);
} else {
ResolveBreakpoints (t);
}
}
else if (e is ThreadStartEvent) {
ThreadStartEvent ts = (ThreadStartEvent)e;
OnDebuggerOutput (false, string.Format ("Thread started: {0}\n", ts.Thread.Name));
TargetEventArgs args = new TargetEventArgs (TargetEventType.ThreadStarted);
args.Thread = new ThreadInfo (0, GetId (ts.Thread), ts.Thread.Name, null);
OnTargetEvent (args);
}
else if (e is ThreadDeathEvent) {
ThreadDeathEvent ts = (ThreadDeathEvent)e;
OnDebuggerOutput (false, string.Format ("Thread finished: {0}\n", ts.Thread.Name));
TargetEventArgs args = new TargetEventArgs (TargetEventType.ThreadStarted);
args.Thread = new ThreadInfo (0, GetId (ts.Thread), ts.Thread.Name, null);
OnTargetEvent (args);
}
}
void HandleEvent (Event e, bool dequeuing)
{
if (dequeuing && exited)
return;
bool resume = true;
ObjectMirror exception = null;
TargetEventType etype = TargetEventType.TargetStopped;
#if DEBUG_EVENT_QUEUEING
if (!(e is TypeLoadEvent))
Console.WriteLine ("pp event: " + e);
#endif
OnHandleEvent (e);
if (e is AssemblyLoadEvent) {
AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
bool isExternal = !UpdateAssemblyFilters (ae.Assembly) && userAssemblyNames != null;
string flagExt = isExternal? " [External]" : "";
OnDebuggerOutput (false, string.Format ("Loaded assembly: {0}{1}\n", ae.Assembly.Location, flagExt));
}
if (e is AssemblyUnloadEvent) {
AssemblyUnloadEvent aue = (AssemblyUnloadEvent)e;
// Mark affected breakpoints as pending again
List<KeyValuePair<EventRequest,BreakInfo>> affectedBreakpoints = new List<KeyValuePair<EventRequest, BreakInfo>> (
breakpoints.Where (x=> (x.Value.Location.Method.DeclaringType.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)))
);
foreach (KeyValuePair<EventRequest,BreakInfo> breakpoint in affectedBreakpoints) {
OnDebuggerOutput (false, string.Format ("Re-pending breakpoint at {0}:{1}\n",
Path.GetFileName (breakpoint.Value.Location.SourceFile),
breakpoint.Value.Location.LineNumber));
breakpoints.Remove (breakpoint.Key);
pending_bes.Add (breakpoint.Value.BreakEvent);
}
// Remove affected types from the loaded types list
List<string> affectedTypes = new List<string> (
from pair in types
where pair.Value.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)
select pair.Key
);
foreach (string typename in affectedTypes) {
types.Remove (typename);
}
foreach (var pair in source_to_type) {
pair.Value.RemoveAll (delegate (TypeMirror mirror){
return mirror.Assembly.Location.Equals (aue.Assembly.Location, StringComparison.OrdinalIgnoreCase);
});
}
OnDebuggerOutput (false, string.Format ("Unloaded assembly: {0}\n", aue.Assembly.Location));
}
if (e is VMStartEvent) {
//HACK: 2.6.1 VM doesn't emit type load event, so work around it
var t = vm.RootDomain.Corlib.GetType ("System.Exception", false, false);
if (t != null)
ResolveBreakpoints (t);
OnVMStartEvent ((VMStartEvent) e);
}
if (e is TypeLoadEvent) {
var t = ((TypeLoadEvent)e).Type;
string typeName = t.FullName;
if (types.ContainsKey (typeName)) {
if (typeName != "System.Exception")
LoggingService.LogError ("Type '" + typeName + "' loaded more than once", null);
} else {
ResolveBreakpoints (t);
}
}
if (e is BreakpointEvent) {
BreakpointEvent be = (BreakpointEvent)e;
if (!HandleBreakpoint (e.Thread, be.Request)) {
etype = TargetEventType.TargetHitBreakpoint;
resume = false;
}
}
if (e is ExceptionEvent) {
etype = TargetEventType.ExceptionThrown;
var ev = (ExceptionEvent)e;
exception = ev.Exception;
if (ev.Request != unhandledExceptionRequest || exception.Type.FullName != "System.Threading.ThreadAbortException")
resume = false;
}
if (e is StepEvent) {
etype = TargetEventType.TargetStopped;
resume = false;
}
if (e is ThreadStartEvent) {
ThreadStartEvent ts = (ThreadStartEvent)e;
OnDebuggerOutput (false, string.Format ("Thread started: {0}\n", ts.Thread.Name));
}
if (resume)
vm.Resume ();
else {
if (currentStepRequest != null) {
currentStepRequest.Enabled = false;
currentStepRequest = null;
}
current_thread = recent_thread = e.Thread;
TargetEventArgs args = new TargetEventArgs (etype);
args.Process = OnGetProcesses () [0];
args.Thread = GetThread (args.Process, current_thread);
args.Backtrace = GetThreadBacktrace (current_thread);
if (exception != null)
activeExceptionsByThread [current_thread.Id] = exception;
OnTargetEvent (args);
}
}
protected virtual void OnHandleEvent (Event e)
{
}
void QueueEvent (Event ev)
{
#if DEBUG_EVENT_QUEUEING
Console.WriteLine ("qq event: " + ev);
#endif
lock (queuedEvents) {
queuedEvents.AddLast (ev);
}
}
public TypeEvent(MDS.Event ev)
: base(ev)
{
}
public bool CheckTypeLoad (Event evt)
{
var tl = evt as TypeLoadEvent;
if (tl != null) {
Log("TypeLoadEvent {0}", tl.Type.FullName);
foreach (var rx in typeMatchers) {
if (rx.IsMatch (tl.Type.FullName)) {
MarkType( tl.Type );
}
}
}
return tl != null;
}
