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