public ExceptionWindow(DebuggerService debuggerService, Thread thread, TargetEventArgs args) { this.debuggerService = debuggerService; Glade.XML gxml = new Glade.XML("gui.glade", "exceptionWindow", null); gxml.Autoconnect(this); image.Pixbuf = Pixmaps.Exception.GetPixbuf(); if (args.Type == TargetEventType.UnhandledException) { buttonContinue.Visible = false; } labelExceptionCaught.Text = (args.Type == TargetEventType.Exception ? "Exception" : "Unandled exception") + " has been caugth:"; StringBuilder sb = new StringBuilder(); StackFrame[] callstack; try { callstack = thread.GetBacktrace().Frames; } catch { return; } foreach(StackFrame frame in callstack) { sb.Append(frame.ToString() + Environment.NewLine); } textviewCallstack.Buffer.Text = sb.ToString(); }
protected override void OnTargetEvent(Mono.Debugger.Thread thread, TargetEventArgs args) { switch (args.Type) { case TargetEventType.TargetStopped: { eventData newEvent = new eventData(); newEvent.eventType = "TargetStopped"; newEvent.arg1 = thread.ID; newEvent.arg3 = ""; newEvent.arg2 = (int)args.Data; eventList.Add(newEvent); break; } case TargetEventType.TargetRunning: { eventData newEvent = new eventData(); newEvent.eventType = "TargetRunning"; newEvent.arg1 = thread.ID; newEvent.arg2 = 0; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.TargetInterrupted: { eventData newEvent = new eventData(); newEvent.eventType = "TargetInterrupted"; newEvent.arg1 = thread.ID; newEvent.arg2 = 0; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.FrameChanged: { eventData newEvent = new eventData(); newEvent.eventType = "FrameChanged"; newEvent.arg1 = thread.ID; newEvent.arg2 = 0; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.TargetHitBreakpoint: { eventData newEvent = new eventData(); newEvent.eventType = "TargetHitBreakpoint"; newEvent.arg1 = thread.ID; newEvent.arg2 = (int)args.Data; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.TargetSignaled: { eventData newEvent = new eventData(); newEvent.eventType = "TargetSignaled"; newEvent.arg1 = thread.ID; newEvent.arg2 = (int)args.Data; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.TargetExited: { eventData newEvent = new eventData(); newEvent.eventType = "TargetExited"; newEvent.arg1 = thread.ID; newEvent.arg2 = (int)args.Data; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.Exception: { eventData newEvent = new eventData(); newEvent.eventType = "Exception"; newEvent.arg1 = thread.ID; newEvent.arg2 = 0; newEvent.arg3 = ""; eventList.Add(newEvent); break; } case TargetEventType.UnhandledException: { eventData newEvent = new eventData(); newEvent.eventType = "UnhandledException"; newEvent.arg1 = thread.ID; newEvent.arg2 = 0; newEvent.arg3 = ""; eventList.Add(newEvent); break; } } base.OnTargetEvent(thread, args); }
public void Main() { Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", "X.Main(string[])"); AssertExecute("continue"); Thread blocking = AssertThreadCreated(); AssertHitBreakpoint(thread, "thread start1", "X.StartThreads()"); AssertExecute("continue"); Thread sleeping = AssertThreadCreated(); AssertHitBreakpoint(thread, "thread start2", "X.StartThreads()"); AssertExecute("continue"); Thread executing = AssertThreadCreated(); AssertTargetOutput("True"); AssertHitBreakpoint(thread, "thread start3", "X.StartThreads()"); AssertExecute("bg"); int bpt_executing = (int)AssertExecute("break -gui -global " + GetLine("executing")); AssertHitBreakpoint(executing, bpt_executing, "X.ExecutingThread()", GetLine("executing")); Interpreter.CurrentThread = executing; AssertExecute("set loop = false"); AssertPrint(executing, "loop", "(bool) false"); AssertExecute("bg"); int status = 0; while (status != 63) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ThreadExited) { if (e.Data == blocking) { status |= 1; continue; } else if (e.Data == executing) { status |= 2; continue; } else if (e.Data == sleeping) { status |= 4; continue; } } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if (args.Type == TargetEventType.TargetExited) { if (e_thread == blocking) { status |= 8; continue; } else if (e_thread == executing) { status |= 16; continue; } else if (e_thread == sleeping) { status |= 32; continue; } } } Assert.Fail("Received unexpected event {0}.", e); } AssertTargetOutput("Blocking Done"); AssertTargetExited(process); }
private void event_TargetThreadStarted(object sender, TargetEventArgs e) { MonoThread thread = _debugEngine.ThreadManager.AddThread(e.Thread); _debugEngine.Callback.OnThreadCreate(thread); }
protected void TargetEvent(Thread target, StackFrame frame, TargetEventArgs args) { switch (args.Type) { case TargetEventType.TargetStopped: { if ((int)args.Data != 0) { interpreter.Print("{0} received signal {1} at {2}.", target.Name, (int)args.Data, frame); } else if (!interpreter.IsInteractive) { break; } else { interpreter.Print("{0} stopped at {1}.", target.Name, frame); } if (interpreter.IsScript) { break; } AssemblerLine insn; try { insn = target.DisassembleInstruction( frame.Method, frame.TargetAddress); } catch { insn = null; } interpreter.Style.TargetStopped(interpreter, frame, insn); break; } case TargetEventType.TargetHitBreakpoint: { if (!interpreter.IsInteractive) { break; } interpreter.Print("{0} hit breakpoint {1} at {2}.", target.Name, (int)args.Data, frame); if (interpreter.IsScript) { break; } AssemblerLine insn; try { insn = target.DisassembleInstruction( frame.Method, frame.TargetAddress); } catch { insn = null; } interpreter.Style.TargetStopped(interpreter, frame, insn); break; } case TargetEventType.Exception: case TargetEventType.UnhandledException: { interpreter.Print("{0} caught {2}exception at {1}.", target.Name, frame, args.Type == TargetEventType.Exception ? "" : "unhandled "); if (interpreter.IsScript) { break; } AssemblerLine insn; try { insn = target.DisassembleInstruction( frame.Method, frame.TargetAddress); } catch { insn = null; } interpreter.Style.UnhandledException(interpreter, frame, insn); break; } } }
private void OnValueChange(object sender, TargetEventArgs e) { ElementController.SetValueFromRenderer(Slider.ValueProperty, Control.NumberValue); }
private void _select_Change(object sender, TargetEventArgs e) { Element.SetValueFromRenderer(Picker.SelectedIndexProperty, Element.ItemsSource.IndexOf(_select.Value)); }
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); } }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { args = null; Report.Debug (DebugFlags.SSE, "{0} activate breakpoints: {1}", sse, completed); while (!completed) { if (do_execute ()) return EventResult.Running; Report.Debug (DebugFlags.SSE, "{0} activate breakpoints done - continue", sse); return EventResult.ResumeOperation; } Report.Debug (DebugFlags.SSE, "{0} activate breakpoints completed", sse); return EventResult.AskParent; }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} abort runtime invoke - callback completed: {1:x}", sse, data1); args = null; inferior.Continue (); return EventResult.Running; }
protected abstract EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args);
public virtual EventResult ProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { if (cevent.Type == Inferior.ChildEventType.CHILD_INTERRUPTED) { args = null; if (ResumeOperation ()) return EventResult.Running; } if ((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument != 0)) { sse.frame_changed (inferior.CurrentFrame, null); args = new TargetEventArgs (TargetEventType.TargetStopped, (int) cevent.Argument, sse.current_frame); return EventResult.Completed; } EventResult result; if (child != null) { Report.Debug (DebugFlags.EventLoop, "{0} child event: {1} {2}", sse, this, cevent); result = child.ProcessEvent (cevent, out args); Report.Debug (DebugFlags.EventLoop, "{0} child event done: {1} {2} {3} {4}", sse, this, cevent, result, args); if (result == EventResult.ParentResumed) { child = null; return EventResult.Running; } if ((result != EventResult.AskParent) && (result != EventResult.ResumeOperation)) return result; Operation old_child = child; child = null; if ((result == EventResult.ResumeOperation) && ResumeOperation ()) { args = null; return EventResult.Running; } Report.Debug (DebugFlags.EventLoop, "{0} resending event {1} from {2} to {3}", sse, cevent, old_child, this); } result = DoProcessEvent (cevent, out args); return result; }
private void SetInterval_Click(object sender, TargetEventArgs e) => OnInterval?.Invoke();
private void _session_TargetExited(object sender, TargetEventArgs e) { OnEndSession(); }
private void _session_TargetReady(object sender, TargetEventArgs e) { TargetReady?.Invoke(this, e); }
public override CommandResult Return(ReturnMode mode) { return (CommandResult) SendCommand (delegate { if (!engine_stopped) { Report.Debug (DebugFlags.Wait, "{0} not stopped", this); throw new TargetException (TargetError.NotStopped); } if (current_frame == null) throw new TargetException (TargetError.NoStack); process.UpdateSymbolTable (inferior); if (!process.IsManagedApplication) { if (mode == ReturnMode.Managed) mode = ReturnMode.Native; else if (mode == ReturnMode.Invocation) throw new TargetException (TargetError.InvalidReturn, "Not a managed application."); } CommandResult result = new ThreadCommandResult (thread); Backtrace bt = new Backtrace (current_frame); if (mode == ReturnMode.Invocation) { var cframe = inferior.GetCallbackFrame (current_frame.StackPointer, false); if (cframe == null) throw new TargetException (TargetError.NoInvocation); if (MonoDebuggerInfo.HasAbortRuntimeInvoke) { OperationRuntimeInvoke rti = rti_stack.Peek (); if (rti.ID != cframe.ID) throw new TargetException (TargetError.NoInvocation); return StartOperation (new OperationAbortRuntimeInvoke (this, result)); } bt.GetBacktrace (this, inferior, Backtrace.Mode.Native, cframe.StackPointer, -1); for (int i = 0; i < bt.Count; i++) { if ((bt.Frames [i].Type == FrameType.Normal) && bt.Frames [i].IsManaged) continue; else if ((bt.Frames [i].Type == FrameType.RuntimeInvoke) && (i + 1 == bt.Count)) break; throw new TargetException (TargetError.InvalidReturn, "Cannot abort an invocation which contains non-managed frames."); } } else { bt.GetBacktrace (this, inferior, Backtrace.Mode.Native, TargetAddress.Null, 2); } if (bt.Count < 2) throw new TargetException (TargetError.NoStack); StackFrame parent_frame = bt.Frames [1]; if (parent_frame == null) return null; Report.Debug (DebugFlags.SSE, "{0} return: {1} {2} {3}", this, mode, current_frame.Type, parent_frame.Type); if (mode == ReturnMode.Native) { if ((current_frame.Type == FrameType.Signal) || (parent_frame.Type == FrameType.Signal) || (current_frame.Type == FrameType.Callback) || (parent_frame.Type == FrameType.Callback)) throw new TargetException (TargetError.InvalidReturn, "Cannot return from a signal handler or mdb-internal callback."); if ((current_frame.Type != FrameType.Normal) || (parent_frame.Type != FrameType.Normal)) throw new TargetException (TargetError.InvalidReturn); } else if (mode == ReturnMode.Managed) { bool ok = true; if (current_frame.Type == FrameType.Normal) { if (!current_frame.IsManaged) ok = false; } else { if (current_frame.Type == FrameType.RuntimeInvoke) throw new TargetException (TargetError.InvalidReturn, "Cannot return from an invocation."); ok = false; } if (parent_frame.Type == FrameType.Normal) { if (!parent_frame.IsManaged) ok = false; } else { if (parent_frame.Type == FrameType.RuntimeInvoke) throw new TargetException (TargetError.InvalidReturn, "Cannot return from an invocation."); ok = false; } if (!ok) throw new TargetException (TargetError.InvalidReturn, "Cannot return from a non-managed frame."); } if (mode == ReturnMode.Native) { inferior.SetRegisters (parent_frame.Registers); frame_changed (inferior.CurrentFrame, null); TargetEventArgs args = new TargetEventArgs ( TargetEventType.TargetStopped, 0, current_frame); process.Debugger.OnTargetEvent (thread, args); return null; } return StartOperation (new OperationReturn (this, bt, mode, result)); }); }
public void Main() { Interpreter.Options.File = Path.Combine(BuildDirectory, "testnativenoforkexec"); Interpreter.Options.InferiorArgs = new string [] { Path.Combine(BuildDirectory, "testnativechild") }; Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("disable " + bpt_child); AssertExecute("continue"); bool thread_created = false; bool execd = false; bool stopped = false; Thread execd_child = null; while (!execd || !thread_created || !stopped) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExecd) { execd = true; continue; } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetStopped)) { AssertFrame(execd_child, "main", LineChild); stopped = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertExecute("continue"); bool exited_event = false; bool process_exited = false; bool thread_exited = false; bool exited = false; while (!exited || !exited_event || !thread_exited || !process_exited) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == execd_child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.ProcessExited) { process_exited = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetExited)) { exited_event = true; continue; } } else if (e.Type == DebuggerEventType.TargetExited) { exited = true; continue; } Assert.Fail("Received unexpected event {0}", e); } AssertTargetOutput("Hello World!"); AssertNoTargetOutput(); }
protected abstract EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args);
protected void HandleEvent(object sender, EventReceivedEventArgs obj) { Task.Run(() => { switch (obj.EventType) { case "initialized": //OnStarted(); break; case "stopped": TargetEventArgs args; var body = (StoppedEvent)obj.Body; switch (body.Reason) { case StoppedEvent.ReasonValue.Breakpoint: var stackFrame = (VsCodeStackFrame)this.GetThreadBacktrace(body.ThreadId ?? -1).GetFrame(0); args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint); var bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => b.FileName == stackFrame.SourceLocation.FileName && b.Line == stackFrame.SourceLocation.Line); if (bp == null) { bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => Path.GetFileName(b.FileName) == Path.GetFileName(stackFrame.SourceLocation.FileName) && b.Line == stackFrame.SourceLocation.Line); } if (bp == null) { //None of breakpoints is matching, this is probably Debugger.Break(); args = new TargetEventArgs(TargetEventType.TargetStopped); } else { args.BreakEvent = bp; if (breakpoints.TryGetValue(bp, out var binfo)) { if ((bp.HitAction & HitAction.PrintExpression) != HitAction.None) { string exp = EvaluateTrace(stackFrame.frameId, bp.TraceExpression); binfo.UpdateLastTraceValue(exp); OnContinue(); return; } } } break; case StoppedEvent.ReasonValue.Step: case StoppedEvent.ReasonValue.Pause: args = new TargetEventArgs(TargetEventType.TargetStopped); break; case StoppedEvent.ReasonValue.Exception: stackFrame = null; var backtrace = GetThreadBacktrace(body.ThreadId ?? -1); if (Options.ProjectAssembliesOnly) { // We can't evaluate expressions in external code frames, the debugger will hang for (int i = 0; i < backtrace.FrameCount; i++) { var frame = stackFrame = (VsCodeStackFrame)backtrace.GetFrame(i); if (!frame.IsExternalCode) { stackFrame = frame; break; } } if (stackFrame == null) { OnContinue(); return; } } else { // It's OK to evaluate expressions in external code stackFrame = (VsCodeStackFrame)backtrace.GetFrame(0); } var response = protocolClient.SendRequestSync(new ExceptionInfoRequest(body.ThreadId ?? -1)); if (response.BreakMode.Equals(ExceptionBreakMode.UserUnhandled) || response.BreakMode.Equals(ExceptionBreakMode.Unhandled)) { args = new TargetEventArgs(TargetEventType.UnhandledException); } else { if (!breakpoints.Select(b => b.Key).OfType <Catchpoint> ().Any(c => ShouldStopOnExceptionCatchpoint(c, stackFrame.frameId))) { OnContinue(); return; } args = new TargetEventArgs(TargetEventType.ExceptionThrown); } break; default: throw new NotImplementedException(body.Reason.ToString()); } currentThreadId = body.ThreadId ?? -1; //TODO: what happens if thread is not specified? args.Process = GetProcesses() [0]; args.Thread = args.Process.GetThreads().Single(t => t.Id == currentThreadId); args.Backtrace = args.Thread.Backtrace; OnTargetEvent(args); break; case "terminated": OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited)); break; case "exited": OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited) { ExitCode = ((ExitedEvent)obj.Body).ExitCode }); break; case "process": var processEvent = (ProcessEvent)obj.Body; processInfo.Add(new ProcessInfo(processEvent.SystemProcessId ?? 1, processEvent.Name)); OnStarted(); break; case "output": var outputBody = (OutputEvent)obj.Body; switch (outputBody.Category) { case OutputEvent.CategoryValue.Stdout: OnTargetOutput(false, outputBody.Output); break; case OutputEvent.CategoryValue.Console: OnDebuggerOutput(false, outputBody.Output); break; case OutputEvent.CategoryValue.Stderr: OnTargetOutput(true, outputBody.Output); break; } break; case "module": var moduleEvent = (ModuleEvent)obj.Body; if (moduleEvent.Reason == ModuleEvent.ReasonValue.New) { OnAssemblyLoaded(moduleEvent.Module.Path); } break; } }).Ignore(); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.EventLoop, "{0} received event {1} at {2} while waiting for " + "callback {4}:{3}", sse, cevent, inferior.CurrentFrame, ID, this); args = null; if ((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument == 0)) { sse.do_continue (); return EventResult.Running; } else if ((cevent.Type != Inferior.ChildEventType.CHILD_CALLBACK) && (cevent.Type != Inferior.ChildEventType.RUNTIME_INVOKE_DONE)) { Report.Debug (DebugFlags.SSE, "{0} aborting callback {1} ({2}) at {3}: {4}", sse, this, ID, inferior.CurrentFrame, cevent); AbortOperation (); return EventResult.Completed; } if (ID != cevent.Argument) { Report.Debug (DebugFlags.SSE, "{0} aborting callback {1} ({2}) at {3}: {4}", sse, this, ID, inferior.CurrentFrame, cevent); AbortOperation (); return EventResult.Completed; } try { return CallbackCompleted (cevent.Data1, cevent.Data2, out args); } catch (Exception ex) { Report.Debug (DebugFlags.SSE, "{0} got exception while handling event {1}: {2}", sse, cevent, ex); RestoreStack (); return EventResult.CompletedCallback; } }
private void OnTargetExited(object sender, TargetEventArgs Args) { AttachToEngineCommand.Instance.OnDetach(); }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { if (inferior.TargetAddressSize == 4) data1 &= 0xffffffffL; Report.Debug (DebugFlags.SSE, "{0} call method done: {1:x} {2:x} {3}", sse, data1, data2, Result); RestoreStack (); Result.Result = new TargetAddress (inferior.AddressDomain, data1); args = null; return EventResult.CompletedCallback; }
protected void HandleEvent(object sender, EventReceivedEventArgs obj) { Task.Run(() => { switch (obj.EventType) { case "initialized": //OnStarted(); break; case "stopped": TargetEventArgs args; var body = (StoppedEvent)obj.Body; switch (body.Reason) { case StoppedEvent.ReasonValue.Breakpoint: var stackFrame = this.GetThreadBacktrace(body.ThreadId ?? -1).GetFrame(0); args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint); var bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => b.FileName == stackFrame.SourceLocation.FileName && b.Line == stackFrame.SourceLocation.Line); if (bp == null) { //None of breakpoints is matching, this is probably Debugger.Break(); args = new TargetEventArgs(TargetEventType.TargetStopped); } else { args.BreakEvent = bp; } break; case StoppedEvent.ReasonValue.Step: case StoppedEvent.ReasonValue.Pause: args = new TargetEventArgs(TargetEventType.TargetStopped); break; case StoppedEvent.ReasonValue.Exception: args = new TargetEventArgs(TargetEventType.ExceptionThrown); break; default: throw new NotImplementedException(body.Reason.ToString()); } currentThreadId = body.ThreadId ?? -1; //TODO: what happens if thread is not specified? args.Process = GetProcesses() [0]; args.Thread = args.Process.GetThreads().Single(t => t.Id == currentThreadId); args.Backtrace = args.Thread.Backtrace; OnTargetEvent(args); break; case "terminated": OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited)); break; case "exited": OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited) { ExitCode = ((ExitedEvent)obj.Body).ExitCode }); break; case "output": var outputBody = (OutputEvent)obj.Body; switch (outputBody.Category) { case OutputEvent.CategoryValue.Stdout: OnTargetOutput(false, outputBody.Output); break; case OutputEvent.CategoryValue.Console: OnDebuggerOutput(false, outputBody.Output); break; case OutputEvent.CategoryValue.Stderr: OnTargetOutput(true, outputBody.Output); break; } break; } }); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { if (!interrupted_syscall) return base.DoProcessEvent (cevent, out args); Report.Debug (DebugFlags.EventLoop, "{0} received event {1} at {2} while waiting for " + "callback {4}:{3}", sse, cevent, inferior.CurrentFrame, ID, this); args = null; if ((cevent.Type != Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument != 0)) { Report.Debug (DebugFlags.SSE, "{0} aborting callback {1} ({2}) at {3}: {4}", sse, this, ID, inferior.CurrentFrame, cevent); AbortOperation (); return EventResult.Completed; } DoExecute (); return EventResult.Running; }
private void event_TargetUnhandledException(object sender, TargetEventArgs e) { ExceptionInfo exception = e.Backtrace.GetFrame(0).GetException(); _debugEngine.Callback.OnExceptionThrown(exception, _debugEngine.ThreadManager[e.Thread]); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} processing OperationException at {1}: {2} {3} {4}", sse, inferior.CurrentFrame, ip, exc, unhandled); if (unhandled) { sse.frame_changed (inferior.CurrentFrame, null); sse.current_frame.SetExceptionObject (exc_object); args = new TargetEventArgs ( TargetEventType.UnhandledException, exc_object, sse.current_frame); return EventResult.SuspendOperation; } else { sse.frame_changed (inferior.CurrentFrame, null); sse.current_frame.SetExceptionObject (exc_object); args = new TargetEventArgs ( TargetEventType.Exception, exc_object, sse.current_frame); return EventResult.SuspendOperation; } }
private void event_TargetHitBreakpoint(object sender, TargetEventArgs e) { MonoPendingBreakpoint pendingBreakpoint = _debugEngine.BreakpointManager.FindBreakpoint(e.BreakEvent); _debugEngine.Callback.OnBreakpointHit(pendingBreakpoint, _debugEngine.ThreadManager[e.Thread]); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} executed instruction at {1}: {2}\n{3}", sse, inferior.CurrentFrame, cevent, TargetBinaryReader.HexDump (Instruction)); args = null; if (pushed_code_buffer) { pushed_code_buffer = false; inferior.ExecuteInstruction (Instruction, UpdateIP); return EventResult.Running; } return EventResult.ResumeOperation; }
protected void HandleEvent(object sender, EventReceivedEventArgs obj) { Task.Run(() => { switch (obj.EventType) { case "initialized": //OnStarted(); break; case "stopped": TargetEventArgs args; var body = (StoppedEvent)obj.Body; switch (body.Reason) { case StoppedEvent.ReasonValue.Breakpoint: var stackFrame = (VsCodeStackFrame)this.GetThreadBacktrace(body.ThreadId ?? -1).GetFrame(0); args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint); var bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => b.FileName == stackFrame.SourceLocation.FileName && b.Line == stackFrame.SourceLocation.Line); if (bp == null) { bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => Path.GetFileName(b.FileName) == Path.GetFileName(stackFrame.SourceLocation.FileName) && b.Line == stackFrame.SourceLocation.Line); } if (bp == null) { //None of breakpoints is matching, this is probably Debugger.Break(); args = new TargetEventArgs(TargetEventType.TargetStopped); } else { args.BreakEvent = bp; if (breakpoints.TryGetValue(bp, out var binfo)) { if ((bp.HitAction & HitAction.PrintExpression) != HitAction.None) { string exp = EvaluateTrace(stackFrame.frameId, bp.TraceExpression); binfo.UpdateLastTraceValue(exp); OnContinue(); return; } } } break; case StoppedEvent.ReasonValue.Step: case StoppedEvent.ReasonValue.Pause: args = new TargetEventArgs(TargetEventType.TargetStopped); break; case StoppedEvent.ReasonValue.Exception: args = new TargetEventArgs(TargetEventType.ExceptionThrown); break; default: throw new NotImplementedException(body.Reason.ToString()); } currentThreadId = body.ThreadId ?? -1; //TODO: what happens if thread is not specified? args.Process = GetProcesses() [0]; args.Thread = args.Process.GetThreads().Single(t => t.Id == currentThreadId); args.Backtrace = args.Thread.Backtrace; OnTargetEvent(args); break; case "terminated": OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited)); break; case "exited": OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited) { ExitCode = ((ExitedEvent)obj.Body).ExitCode }); break; case "process": var processEvent = (ProcessEvent)obj.Body; processInfo.Add(new ProcessInfo(processEvent.SystemProcessId ?? 1, processEvent.Name)); OnStarted(); break; case "output": var outputBody = (OutputEvent)obj.Body; switch (outputBody.Category) { case OutputEvent.CategoryValue.Stdout: OnTargetOutput(false, outputBody.Output); break; case OutputEvent.CategoryValue.Console: OnDebuggerOutput(false, outputBody.Output); break; case OutputEvent.CategoryValue.Stderr: OnTargetOutput(true, outputBody.Output); break; } break; case "module": var moduleEvent = (ModuleEvent)obj.Body; if (moduleEvent.Reason == ModuleEvent.ReasonValue.New) { OnAssemblyLoaded(moduleEvent.Module.Path); } break; } }); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} init after fork ({1})", sse, DebuggerWaitHandle.CurrentThread); sse.Process.BreakpointManager.InitializeAfterFork (inferior); args = null; return EventResult.AskParent; }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} stepped over breakpoint {1} at {2}: {3} {4}", sse, Index, inferior.CurrentFrame, cevent, until); if ((cevent.Type == Inferior.ChildEventType.CHILD_HIT_BREAKPOINT) && (cevent.Argument != Index)) { args = null; return EventResult.Completed; } if (!until.IsNull) { sse.do_continue (until); args = null; until = TargetAddress.Null; return EventResult.Running; } args = null; return EventResult.ResumeOperation; }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} init code buffer: {1:x} {2:x} {3}", sse, data1, data2, Result); TargetAddress buffer = new TargetAddress (inferior.AddressDomain, data1); sse.process.MonoManager.InitCodeBuffer (inferior, buffer); RestoreStack (); args = null; return EventResult.AskParent; }
public void ManagedChild() { Interpreter.Options.File = Path.Combine(BuildDirectory, "testnativenoforkexec"); Interpreter.Options.InferiorArgs = new string [] { MonoExecutable, Path.Combine(BuildDirectory, "TestChild.exe") }; Config.ThreadingModel = ThreadingModel.Global; AssertExecute("disable " + bpt_child); AssertExecute("enable " + bpt_managed_child); Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("continue -wait"); bool thread_created = false; bool reached_main = false; bool execd = false; Thread execd_child = null; while (!execd || !thread_created || !reached_main) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExecd) { execd = true; continue; } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetStopped)) { AssertFrame(execd_child, "X.Main()", LineManagedMain); reached_main = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertExecute("continue"); AssertHitBreakpoint(execd_child, bpt_managed_child, "X.Main()", LineManagedBpt); AssertExecute("continue"); AssertTargetOutput("Hello World"); AssertTargetExited(thread.Process); }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { TargetAddress info = new TargetAddress (inferior.AddressDomain, data1); Report.Debug (DebugFlags.SSE, "{0} insert breakpoint done: {1}", sse, info); sse.Process.MonoLanguage.RegisterMethodLoadHandler (inferior, info, Handle.Index, Handle.MethodLoaded); Handle.Breakpoint.OnBreakpointBound (); args = null; return EventResult.AskParent; }
void OnBreakpoint(object sender, CorBreakpointEventArgs e) { lock (debugLock) { if (evaluating) { e.Continue = true; return; } } BreakEventInfo binfo; if (breakpoints.TryGetValue(e.Breakpoint, out binfo)) { e.Continue = true; Breakpoint bp = (Breakpoint)binfo.BreakEvent; if (bp.HitCount > 1) { // Just update the count and continue binfo.UpdateHitCount(bp.HitCount - 1); return; } if (!string.IsNullOrEmpty(bp.ConditionExpression)) { string res = EvaluateExpression(e.Thread, bp.ConditionExpression); if (bp.BreakIfConditionChanges) { if (res == bp.LastConditionValue) { return; } bp.LastConditionValue = res; } else { if (res != null && res.ToLower() == "false") { return; } } } switch (bp.HitAction) { case HitAction.CustomAction: // If custom action returns true, execution must continue if (binfo.RunCustomBreakpointAction(bp.CustomActionId)) { return; } break; case HitAction.PrintExpression: { string exp = EvaluateTrace(e.Thread, bp.TraceExpression); binfo.UpdateLastTraceValue(exp); return; } } } OnStopped(); e.Continue = false; // If a breakpoint is hit while stepping, cancel the stepping operation if (stepper != null && stepper.IsActive()) { stepper.Deactivate(); } SetActiveThread(e.Thread); TargetEventArgs args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint); args.Process = GetProcess(process); args.Thread = GetThread(e.Thread); args.Backtrace = new Backtrace(new CorBacktrace(e.Thread, this)); OnTargetEvent(args); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} managed callback process event: {1} {2} {3}", sse, cevent, thread_lock, current_callback); current_callback.Result.Completed (); args = null; if (do_execute ()) return EventResult.Running; if ((thread_lock != null) && (thread_lock.StopEvent != null)) { sse.ThreadManager.AddPendingEvent (sse, thread_lock.StopEvent); return EventResult.ParentResumed; } args = null; return EventResult.ResumeOperation; }
public void Main() { Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("disable " + bpt_child); AssertExecute("disable " + bpt_waitpid); AssertExecute("next -wait"); Thread child = AssertProcessCreated(); bool exited = false; bool child_exited = false; bool thread_exited = false; bool stopped = false; while (!exited || !child_exited || !thread_exited || !stopped) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExited) { if ((Process)e.Data == child.Process) { child_exited = true; continue; } } else if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetStopped)) { stopped = true; continue; } else if ((e_thread == child) && (args.Type == TargetEventType.TargetExited)) { exited = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "main", LineMain + 1); AssertPrint(thread, "pid", String.Format("(pid_t) {0}", child.PID)); AssertExecute("next -wait"); AssertStopped(thread, "main", LineWaitpid); AssertExecute("next -wait"); AssertStopped(thread, "main", LineWaitpid + 1); AssertExecute("continue -wait"); AssertTargetExited(thread.Process); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { if ((cevent.Type == Inferior.ChildEventType.CHILD_NOTIFICATION) && ((NotificationType) cevent.Argument == NotificationType.Trampoline)) { TargetAddress info = new TargetAddress ( inferior.AddressDomain, cevent.Data1); TargetReader reader = new TargetReader (inferior.ReadMemory (info, 3 * inferior.TargetAddressSize)); TargetAddress trampoline = reader.ReadAddress (); TargetAddress method = reader.ReadAddress (); TargetAddress code = reader.ReadAddress (); if ((trampoline.IsNull) || (trampoline != CallSite.Address + CallSite.InstructionSize)) { args = null; sse.do_continue (); return EventResult.Running; } args = null; compiled = true; TrampolineCompiled (method, code); return EventResult.Running; } else if ((cevent.Type == Inferior.ChildEventType.CHILD_NOTIFICATION) && ((NotificationType) cevent.Argument == NotificationType.OldTrampoline)) { TargetAddress method = new TargetAddress ( inferior.AddressDomain, cevent.Data1); TargetAddress code = new TargetAddress ( inferior.AddressDomain, cevent.Data2); args = null; compiled = true; TrampolineCompiled (method, code); return EventResult.Running; } args = null; if (!compiled) { sse.disable_extended_notification (NotificationType.Trampoline); return EventResult.Completed; } else return EventResult.ResumeOperation; }
protected override void OnTargetEvent(Thread thread, TargetEventArgs args) { base.OnTargetEvent(thread, args); if (args.Type == TargetEventType.Exception || args.Type == TargetEventType.UnhandledException) { new ExceptionWindow(debuggerService, thread, args).Show(); } }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} native trampoline event: {1}", sse, cevent); args = null; Inferior.StackFrame frame = inferior.GetCurrentFrame (); if (done) return EventResult.Completed; if (!entered_trampoline) { stack_pointer = frame.StackPointer; sse.do_step_native (); entered_trampoline = true; return EventResult.Running; } if (frame.StackPointer <= stack_pointer) { sse.do_next (); return EventResult.Running; } done = true; Instruction instruction = sse.Architecture.ReadInstruction ( inferior, frame.Address); if ((instruction == null) || !instruction.HasInstructionSize) { sse.do_step_native (); return EventResult.Running; } if (instruction.InstructionType != Instruction.Type.Jump) { sse.do_step_native (); return EventResult.Running; } return EventResult.Completed; }
public void NativeChild() { Interpreter.Options.File = Path.Combine(BuildDirectory, "TestExec.exe"); Interpreter.Options.InferiorArgs = new string [] { Path.Combine(BuildDirectory, "testnativechild") }; AssertExecute("disable " + bpt_child); Interpreter.DebuggerConfiguration.ThreadingModel = ThreadingModel.Single; Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "X.Main(string[])", line_main); AssertExecute("continue -wait"); Thread child = AssertProcessCreated(); Thread execd_child = null; bool exited = false; bool execd = false; bool stopped = false; bool thread_created = false; bool thread_exited = false; bool child_exited = false; while (!stopped || !thread_created || !exited || !execd || !child_exited || !thread_exited) { DebuggerEvent e = AssertEvent(); Report.Debug(DebugFlags.NUnit, "EXEC EVENT: {0}", e); if (e.Type == DebuggerEventType.ProcessExited) { if ((Process)e.Data == child.Process) { child_exited = true; continue; } } else if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == execd_child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.ProcessExecd) { if ((Process)e.Data == child.Process) { execd = true; continue; } } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_main)) { stopped = true; continue; } else if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetExited)) { exited = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "X.Main(string[])", line_main_3); AssertPrint(thread, "process.ExitCode", "(int) 0"); AssertTargetOutput("Hello World!"); AssertExecute("continue"); AssertTargetExited(thread.Process); }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { args = null; return EventResult.AskParent; }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { args = null; StackFrame parent_frame = Backtrace.Frames [++level]; inferior.SetRegisters (parent_frame.Registers); Inferior.CallbackFrame cframe = inferior.GetCallbackFrame (parent_frame.StackPointer, true); Report.Debug (DebugFlags.SSE, "{0} return: {1} {2}\n{3}", sse, level, cframe, parent_frame); if (cframe != null) { Report.Debug (DebugFlags.SSE, "{0} return aborting rti: {1}", sse, cframe); aborted_rti = sse.AbortRuntimeInvoke (cframe.ID); return EventResult.Completed; } if (level == Backtrace.Count) { Report.Debug (DebugFlags.SSE, "{0} completed return", sse); return EventResult.Completed; } DoExecute (); return EventResult.Running; }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { Completed (data1, data2); args = null; return EventResult.CompletedCallback; }
public static void ChangeRadioButtonState(string radioButtonGroupName, RadioButton sender, TargetEventArgs targetEventArgs) { SetRadioButtonState(radioButtonGroupName, sender, true); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} stopped at {1} during outer runtime-invoke: {2}", sse, inferior.CurrentFrame, cevent); args = null; if ((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument == 0)) { if (Debug && (inferior.CurrentFrame == helper.InvokeMethod)) { if (NestedBreakStates) return EventResult.SuspendOperation; else return EventResult.Completed; } goto resume_target; } else if (cevent.Type == Inferior.ChildEventType.CHILD_HIT_BREAKPOINT) { if (NestedBreakStates) return EventResult.SuspendOperation; if (Debug) return EventResult.Completed; goto resume_target; } Report.Debug (DebugFlags.SSE, "{0} stopped abnormally at {1} during outer runtime-invoke: {2}", sse, inferior.CurrentFrame, cevent); return EventResult.Completed; resume_target: Report.Debug (DebugFlags.SSE, "{0} resuming target during runtime-invoke", sse); sse.do_continue (); return EventResult.Running; }
protected override void OnDetach() { TargetEventArgs args = new TargetEventArgs(TargetEventType.TargetExited); OnTargetEvent(args); }
protected override EventResult CallbackCompleted(long data1, long data2, out TargetEventArgs args) { if (RTI.AbortRequested) { CompletedRTI (); RTI.Result.InvocationAborted = true; RestoreStack (); args = null; return EventResult.CompletedCallback; } switch (stage) { case Stage.Uninitialized: { TargetAddress klass = new TargetAddress (inferior.AddressDomain, data1); Report.Debug (DebugFlags.SSE, "{0} rti resolved class: {1}", sse, klass); class_info = language.ReadClassInfo (inferior, klass); ((IMonoStructType) RTI.Function.DeclaringType).ClassInfo = class_info; ((IMonoStructType) RTI.Function.DeclaringType).ResolveClass (inferior, false); stage = Stage.ResolvedClass; do_execute (); args = null; return EventResult.Running; } case Stage.BoxingInstance: { TargetAddress boxed = new TargetAddress (inferior.AddressDomain, data1); Report.Debug (DebugFlags.SSE, "{0} rti boxed object: {1}", sse, boxed); TargetLocation new_loc = new AbsoluteTargetLocation (boxed); TargetClassType parent_type = instance.Type.GetParentType (inferior); instance = (TargetClassObject) parent_type.GetObject (inferior, new_loc); stage = Stage.HasMethodAddress; do_execute (); args = null; return EventResult.Running; } case Stage.GettingVirtualMethod: { method = new TargetAddress (inferior.AddressDomain, data1); Report.Debug (DebugFlags.SSE, "{0} rti got virtual method: {1}", sse, method); TargetAddress klass = inferior.ReadAddress (method + 8); TargetType class_type = language.ReadMonoClass (inferior, klass); if (class_type == null) { RTI.Result.ExceptionMessage = String.Format ( "Unable to get virtual method `{0}'.", RTI.Function.FullName); RTI.Result.InvocationCompleted = true; RestoreStack (); args = null; return EventResult.CompletedCallback; } if (!class_type.IsByRef) { TargetLocation new_loc = instance.Location.GetLocationAtOffset ( 2 * inferior.TargetMemoryInfo.TargetAddressSize); instance = (TargetClassObject) class_type.GetObject ( inferior, new_loc); } Report.Debug (DebugFlags.SSE, "{0} rti got virtual method #1: {1} {2}", sse, class_type, instance); stage = Stage.HasVirtualMethod; do_execute (); args = null; return EventResult.Running; } case Stage.CompilingMethod: { invoke = new TargetAddress (inferior.AddressDomain, data1); Report.Debug (DebugFlags.SSE, "{0} rti compiled method: {1}", sse, invoke); stage = Stage.CompiledMethod; do_execute (); args = null; return EventResult.Running; } case Stage.InvokedMethod: { RTI.Completed (data1, data2); RestoreStack (); args = null; return EventResult.CompletedCallback; } default: throw new InternalError (); } }
public abstract void TargetEvent(Thread thread, TargetEventArgs args);
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { if ((cevent.Type == Inferior.ChildEventType.CHILD_HIT_BREAKPOINT) || ((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument == 0))) { if (inferior.CurrentFrame == invoke) { Report.Debug (DebugFlags.SSE, "{0} stopped at invoke method {1} / {2}", sse, invoke, stage); inferior.MarkRuntimeInvokeFrame (); RTI.SetupCallback (ID); args = null; return EventResult.AskParent; } Report.Debug (DebugFlags.SSE, "{0} stopped at {1} during runtime-invoke: {2}", sse, inferior.CurrentFrame, cevent); } return base.DoProcessEvent (cevent, out args); }
private void event_TargetReady(object sender, TargetEventArgs e) { _debugEngine.ThreadManager.AddThread(e.Thread); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { Report.Debug (DebugFlags.SSE, "{0} start: {1} {2} {3} {4}", sse, cevent, sse.Process.IsAttached, inferior.CurrentFrame, inferior.EntryPoint); args = null; if ((cevent.Type != Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Type != Inferior.ChildEventType.CHILD_CALLBACK)) return EventResult.Completed; if (sse.Architecture.IsSyscallInstruction (inferior, inferior.CurrentFrame)) { Report.Debug (DebugFlags.SSE, "{0} start stopped on syscall instruction {1}", sse, inferior.CurrentFrame); inferior.Step (); return EventResult.Running; } sse.Process.OperatingSystem.UpdateSharedLibraries (inferior); sse.Process.InitializeThreads (inferior, !sse.Process.IsAttached); if (sse.Process.IsAttached) return EventResult.Completed; if (!sse.Process.IsManaged) { if (sse.InitializeBreakpoints ()) return EventResult.Running; } Report.Debug (DebugFlags.SSE, "{0} start #1: {1} {2}", sse, cevent, Result); sse.PushOperation (new OperationStep (sse, StepMode.Run, Result)); return EventResult.Running; }
private void event_TargetThreadStopped(object sender, TargetEventArgs e) { MonoThread thread = _debugEngine.ThreadManager.Remove(e.Thread.Id); _debugEngine.Callback.OnThreadDestroy(thread); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { string frame_text = ""; Inferior.StackFrame iframe = inferior.GetCurrentFrame (true); if (iframe != null) frame_text = " at " + iframe.Address.ToString (); Report.Debug (DebugFlags.EventLoop, "{0} received {1}{2} in {3}", sse, cevent, frame_text, this); if ((StepMode == StepMode.Run) && ((cevent.Type == Inferior.ChildEventType.CHILD_HIT_BREAKPOINT) || (cevent.Type == Inferior.ChildEventType.CHILD_CALLBACK) || (cevent.Type == Inferior.ChildEventType.RUNTIME_INVOKE_DONE))) { args = null; return EventResult.Completed; } return base.DoProcessEvent (cevent, out args); }
private void event_TargetExited(object sender, TargetEventArgs e) { _debugEngine.Callback.OnProgramDestroyed(_debugEngine, (uint?)e.ExitCode ?? 0); }
protected override EventResult DoProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { args = null; bool completed; if (cevent.Type == Inferior.ChildEventType.CHILD_INTERRUPTED) completed = !ResumeOperation (); else completed = DoProcessEvent (); return completed ? EventResult.Completed : EventResult.Running; }
void OnClick(object sender, TargetEventArgs e) { Element.OnSearchButtonPressed(); }
public override EventResult ProcessEvent(Inferior.ChildEvent cevent, out TargetEventArgs args) { if (((cevent.Type == Inferior.ChildEventType.CHILD_STOPPED) && (cevent.Argument == 0)) || ((cevent.Type != Inferior.ChildEventType.CHILD_CALLBACK) && (cevent.Type != Inferior.ChildEventType.RUNTIME_INVOKE_DONE))) { if (!ReleaseThreadLock (cevent)) { args = null; return EventResult.Running; } } return base.ProcessEvent (cevent, out args); }
public void Breakpoint() { Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("enable " + bpt_waitpid); AssertExecute("enable " + bpt_local_waitpid); AssertExecute("enable " + bpt_child); AssertExecute("continue -bg"); Thread child = AssertProcessCreated(); bool child_stopped = false; bool reached_waitpid = false; while (!child_stopped || !reached_waitpid) { DebuggerEvent e = AssertEvent(); if (e.Type != DebuggerEventType.TargetEvent) { Assert.Fail("Received unexpected event {0}", e); } Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_waitpid)) { reached_waitpid = true; continue; } else if ((e_thread == child) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_child)) { child_stopped = true; continue; } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "main", LineWaitpid); AssertFrame(child, "main", LineChild); AssertPrint(thread, "pid", String.Format("(pid_t) {0}", child.PID)); AssertPrint(child, "pid", "(pid_t) 0"); AssertExecute("background -thread " + child.ID); AssertExecute("continue -wait -thread " + thread.ID); Thread execd_child = null; bool exited = false; bool child_execd = false; bool child_exited = false; bool thread_created = false; bool thread_exited = false; bool stopped = false; while (!exited || !stopped || !child_execd || !thread_created || !child_exited || !thread_exited) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExited) { if ((Process)e.Data == child.Process) { exited = true; continue; } } else if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == execd_child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.ProcessExecd) { if ((Process)e.Data == child.Process) { child_execd = true; continue; } } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_local_waitpid)) { stopped = true; continue; } else if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetExited)) { child_exited = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "main", LineWaitpid + 1); AssertTargetOutput("Hello World!"); AssertExecute("continue"); AssertTargetExited(thread.Process); }
public override void OnSelected(object sender, TargetEventArgs e) { }