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)
{
}
