// 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; }
private void EvalExceptionEventHandler(Object sender, CorEvalEventArgs e) { OriginalMDbgMessages.WriteLine("ManagedCallback::EvalException"); if (InternalHandleRawMode(ManagedCallbackType.OnEvalException, e)) return; // custom eval handling if (customEvals != null && customEvals.Contains(e.Eval)) { using (var psc = new MDbgProcessStopController(this, e, false)) { var handler = (customEvals[e.Eval] as CustomEvalEventHandler); customEvals.Remove(e.Eval); handler(this, new CustomEvalEventArgs(psc, e, CustomEvalEventArgs.EvalCallbackType.EvalException)); } return; // this was custom eval, no additional action necessary. } e.Continue = false; InternalSignalRuntimeIsStopped(e.Thread, new EvalExceptionStopReason(e.Eval)); }
private void StepCompleteEventHandler(Object sender, CorStepCompleteEventArgs e) { OriginalMDbgMessages.WriteLine("ManagedCallback::StepComplete"); if (InternalHandleRawMode(ManagedCallbackType.OnStepComplete, e)) return; // custom stepper handling if (customSteppers != null && customSteppers.Contains(e.Stepper)) { using (var psc = new MDbgProcessStopController(this, e, false)) { var handler = (customSteppers[e.Stepper] as CustomStepperEventHandler); customSteppers.Remove(e.Stepper); handler(this, new CustomStepCompleteEventArgs(psc, e)); } return; // this was custom stepper, no additional action necessary. } // we need to deliver step complete for cordbg skin, so that we can print // enhanced diagnostics. if (HandleCustomPostCallback(ManagedCallbackType.OnStepComplete, e)) return; // we will stop only if this callback is from our own stepper. if (e.Stepper == m_activeStepper) { m_activeStepper = null; e.Continue = false; InternalSignalRuntimeIsStopped(e.Thread, new StepCompleteStopReason(e.Stepper, e.StepReason)); } }
////////////////////////////////////////////////////////////////////////////////// // // Callbacks implementation // ////////////////////////////////////////////////////////////////////////////////// private void BreakpointEventHandler(Object sender, CorBreakpointEventArgs e) { /* if (DI.o2MDbg.AutoContinueOnBreakPointEvent) { O2MDbgUtils.setCurrentLocationFromActiveThread(); return; // DC (if this is set means some other breakpoint handler has already processed this and set the e.Continue flag to true }*/ OriginalMDbgMessages.WriteLine("ManagedCallback::Breakpoint"); if (InternalHandleRawMode(ManagedCallbackType.OnBreakpoint, e)) return; // custom breakpoint handling. All normal MDbg shell breakpoints (including our user breakpoint) // register their own handlers here, so this is the very common case. if (customBreakpoints != null && customBreakpoints.Contains(e.Breakpoint)) { using (var psc = new MDbgProcessStopController(this, e, false)) { var handler = (customBreakpoints[e.Breakpoint] as CustomBreakpointEventHandler); // Invoke custom callback handler. This may stop the shell. handler(this, new CustomBreakpointEventArgs(psc, e)); } return; // this was custom breakpoint, no additional action necessary. } // We have an unknown breakpoint that no handler was registered for. This should be a very // uncommon case and indicate some bug in MDbg or an extension. e.Continue = false; InternalSignalRuntimeIsStopped(e.Thread, "Unexpected raw breakpoint hit"); }
private void EvalCompleteEventHandler(Object sender, CorEvalEventArgs e) { Trace.WriteLine("ManagedCallback::EvalComplete"); BeginManagedDebugEvent(); try { if (InternalHandleRawMode(ManagedCallbackType.OnEvalComplete, e)) return; // custom eval handling if (customEvals != null && customEvals.Contains(e.Eval)) { using (MDbgProcessStopController psc = new MDbgProcessStopController(this, e, false)) { CustomEvalEventHandler handler = (customEvals[e.Eval] as CustomEvalEventHandler); customEvals.Remove(e.Eval); handler(this, new CustomEvalEventArgs(psc, e, CustomEvalEventArgs.EvalCallbackType.EvalComplete)); } return; // this was custom eval, no additional action necessary. } e.Continue = false; InternalSignalRuntimeIsStopped(e.Thread, new EvalCompleteStopReason(e.Eval)); } finally { EndManagedDebugEvent(e); } }
private void BreakpointEventHandler(Object sender, CorBreakpointEventArgs e) { Trace.WriteLine("ManagedCallback::Breakpoint"); BeginManagedDebugEvent(); try { if (InternalHandleRawMode(ManagedCallbackType.OnBreakpoint, e)) return; bool fHandled = false; // custom breakpoint handling. All normal MDbg shell breakpoints (including our user breakpoint) // register their own handlers here, so this is the very common case. if (customBreakpoints != null && customBreakpoints.Contains(e.Breakpoint)) { using (MDbgProcessStopController psc = new MDbgProcessStopController(this, e, false)) { CustomBreakpointEventHandler handler = (customBreakpoints[e.Breakpoint] as CustomBreakpointEventHandler); // Invoke custom callback handler. This may stop the shell. handler(this, new CustomBreakpointEventArgs(psc, e)); } fHandled = true; } if (HandleCustomPostCallback(ManagedCallbackType.OnBreakpoint, e)) { return; } if (fHandled) { return; // this was custom breakpoint, no additional action necessary. } // We have an unknown breakpoint that no handler was registered for. This should be a very // uncommon case and indicate some bug in MDbg or an extension. e.Continue = false; InternalSignalRuntimeIsStopped(e.Thread, "Unexpected raw breakpoint hit"); } finally { EndManagedDebugEvent(e); } }