bool OnStep(StepEventRequest stepReq) { debuggerThread.VerifyAccess(); if (stepReq == null) return false; bool b = toStepper.TryGetValue(stepReq, out var info); Debug.Assert(b); if (!b) return false; toStepper.Remove(stepReq); stepReq.Disable(); return info.OnStep(new StepCompleteEventArgs(stepReq, false, false)); }
private void HandleStep(StepEvent stepEvent) { if (currentStepRequest != null) { currentStepRequest.Enabled = false; currentStepRequest = null; } _engine.Callback.StepCompleted(_mainThread); logger.Trace("Stepping: {0}:{1}", stepEvent.Method.Name, stepEvent.Location); isStepping = false; }
internal void CancelStepper(StepEventRequest stepReq) { debuggerThread.VerifyAccess(); if (stepReq != null) { try { using (TempBreak()) stepReq.Disable(); } catch { } } }
internal void Step(AD7Thread thread, enum_STEPKIND sk, enum_STEPUNIT stepUnit) { DebugHelper.TraceEnteringMethod(); if (!_isStepping) { if (currentStepRequest == null) { currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror); } else { currentStepRequest.Disable(); } _isStepping = true; if (stepUnit == enum_STEPUNIT.STEP_LINE || stepUnit == enum_STEPUNIT.STEP_STATEMENT) { switch (sk) { case enum_STEPKIND.STEP_INTO: currentStepRequest.Depth = StepDepth.Into; break; case enum_STEPKIND.STEP_OUT: currentStepRequest.Depth = StepDepth.Out; break; case enum_STEPKIND.STEP_OVER: currentStepRequest.Depth = StepDepth.Over; break; default: return; } } else if (stepUnit == enum_STEPUNIT.STEP_INSTRUCTION) { //TODO: by techcap } else { throw new NotImplementedException(); } currentStepRequest.Size = StepSize.Line; currentStepRequest.Enable(); } ResumeVM(); }
private void HandleStep(StepEvent stepEvent) { DebugHelper.TraceEnteringMethod(); if (currentStepRequest != null) { currentStepRequest.Enabled = false; currentStepRequest = null; } _engine.Callback.StepCompleted(GetThread(stepEvent)); logger.Trace("Stepping: {0}:{1}", stepEvent.Method.Name, stepEvent.Location); _isStepping = false; }
internal void CancelStepper(StepEventRequest stepReq) { debuggerThread.VerifyAccess(); if (stepReq != null) { try { using (TempBreak()) stepReq.Disable(); } catch { } if (toStepper.TryGetValue(stepReq, out var info)) { toStepper.Remove(stepReq); info.OnStep(new StepCompleteEventArgs(stepReq, false, true)); } } }
void SaveStepper(StepEventRequest newMonoStepper, object tag, bool callRunCore) { engine.VerifyMonoDebugThread(); if (newMonoStepper != null) { stepData = new StepData(tag, newMonoStepper); if (callRunCore) { engine.RunCore(); } } else { // This should rarely if ever happen so the string doesn't need to be localized RaiseStepComplete(thread, tag, "Could not step"); } }
protected override void OnNextLine() { ThreadPool.QueueUserWorkItem(delegate { Adaptor.CancelAsyncOperations(); // This call can block, so it has to run in background thread to avoid keeping the main session lock var req = vm.CreateStepRequest(current_thread); req.Depth = StepDepth.Over; req.Size = StepSize.Line; if (assemblyFilters != null && assemblyFilters.Count > 0) { req.AssemblyFilter = assemblyFilters; } req.Enabled = true; currentStepRequest = req; OnResumed(); vm.Resume(); DequeueEventsForFirstThread(); }); }
internal void Step(MonoThread thread, enum_STEPKIND sk) { if (isStepping) { return; } if (currentStepRequest == null) { currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror); } else { currentStepRequest.Disable(); } isStepping = true; switch (sk) { case enum_STEPKIND.STEP_INTO: currentStepRequest.Depth = StepDepth.Into; break; case enum_STEPKIND.STEP_OUT: currentStepRequest.Depth = StepDepth.Out; break; case enum_STEPKIND.STEP_OVER: currentStepRequest.Depth = StepDepth.Over; break; default: return; } currentStepRequest.Size = StepSize.Line; currentStepRequest.Enable(); _vm.Resume(); }
public StepCompleteEventArgs(StepEventRequest stepEventRequest, bool forciblyCanceled) { StepEventRequest = stepEventRequest; ForciblyCanceled = forciblyCanceled; }
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>(); foreach (var pair in types) { try { if (!pair.Value.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)) { continue; } } catch { } affectedTypes.Add(pair.Key); } foreach (string typename in affectedTypes) { types.Remove(typename); } foreach (var pair in source_to_type) { pair.Value.RemoveAll(delegate(TypeMirror mirror){ try { return(mirror.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)); } catch { } return(true); }); } 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); // } 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); } }
public StepData(object tag, StepEventRequest monoStepper) { Tag = tag; MonoStepper = monoStepper; }