public BacktraceWrapper (MD.StackFrame[] frames, TargetObject exception): base (Server.Instance.MdbObjectValueAdaptor) { this.frames = frames; this.exception = exception; Connect (); }
public virtual void InitializeBreakpoint (MDB.SourceBreakpoint bp) { }
public override void AbortThread (MDB.Thread thread, MDB.RuntimeInvokeResult result) { result.Abort (); }
public MdbDissassemblyBuffer (MD.Thread thread, MD.TargetAddress addr): base (addr.Address) { this.thread = thread; this.baseAddr = addr; }
ThreadInfo CreateThreadInfo (MD.Thread t) { string loc; if (t.CurrentFrame != null && t.CurrentFrame.SourceLocation != null) { loc = t.CurrentFrame.ToString (); } else loc = "<Unknown>"; return new ThreadInfo (t.Process.ID, t.ID, t.Name, loc); }
public override void InitializeBreakpoint (MDB.SourceBreakpoint bp) { // bp.IsUserModule = true; }
private void OnProcessExecdEvent (MD.Debugger debugger, MD.Process process) { WriteDebuggerOutput (string.Format ("Process {0} execd.\n", process.ID)); }
public virtual void ActivateEvent (MDB.Event ev) { }
private void OnTargetEvent (MD.Thread thread, MD.TargetEventArgs args) { try { if (!running) { LogEvent (args); return; } bool notifyToClient = args.IsStopped || args.Type == MD.TargetEventType.UnhandledException || args.Type == MD.TargetEventType.Exception || args.Type == MD.TargetEventType.TargetInterrupted; LogEvent (args); bool isStop = args.Type != MD.TargetEventType.FrameChanged && args.Type != MD.TargetEventType.TargetExited && args.Type != MD.TargetEventType.TargetRunning; if (isStop) { lock (debugger) { if (stoppedWorkQueue.Count > 0) { // Execute queued work in another thread with a small delay // since it is not safe to execute it here System.Threading.ThreadPool.QueueUserWorkItem (delegate { System.Threading.Thread.Sleep (50); bool resume = false; lock (debugger) { foreach (ST.WaitCallback cb in stoppedWorkQueue) { cb (null); } stoppedWorkQueue.Clear (); } if (resume) guiManager.Continue (process.MainThread); else if (notifyToClient) NotifyTargetEvent (thread, args); }); return; } } } if (notifyToClient) NotifyTargetEvent (thread, args); } catch (Exception e) { Console.WriteLine ("*** DS.OnTargetEvent1, exception : {0}", e.ToString ()); } }
void NotifyTargetEvent (MD.Thread thread, MD.TargetEventArgs args) { if (args.Frame != null) activeThread = args.Frame.Thread; try { if (args.Type == MD.TargetEventType.TargetStopped && ((int)args.Data) != 0) { DispatchEvent (delegate { controller.OnDebuggerOutput (false, string.Format ("Thread {0:x} received signal {1}.\n", args.Frame.Thread.ID, args.Data)); }); } DL.TargetEventType type; switch (args.Type) { case MD.TargetEventType.Exception: type = DL.TargetEventType.ExceptionThrown; break; case MD.TargetEventType.TargetHitBreakpoint: type = DL.TargetEventType.TargetHitBreakpoint; break; case MD.TargetEventType.TargetInterrupted: type = DL.TargetEventType.TargetInterrupted; break; case MD.TargetEventType.TargetSignaled: type = DL.TargetEventType.TargetSignaled; break; case MD.TargetEventType.TargetStopped: type = DL.TargetEventType.TargetStopped; break; case MD.TargetEventType.UnhandledException: type = DL.TargetEventType.UnhandledException; break; default: return; } OnCleanFrameData (); DL.TargetEventArgs targetArgs = new DL.TargetEventArgs (type); if (args.Type != MD.TargetEventType.TargetExited) { ML.TargetObject exception = null; if (args.Type == MD.TargetEventType.UnhandledException || args.Type == MD.TargetEventType.Exception) exception = args.Frame.ExceptionObject; targetArgs.Backtrace = CreateBacktrace (thread, exception); targetArgs.Thread = CreateThreadInfo (activeThread); } running = false; DispatchEvent (delegate { controller.OnTargetEvent (targetArgs); }); } catch (Exception e) { Console.WriteLine ("*** DS.OnTargetEvent2, exception : {0}", e.ToString ()); } }
void LogEvent (MD.TargetEventArgs args) { Console.WriteLine ("Server OnTargetEvent: {0} stopped:{1} data:{2} queue:{3} thread:{4} running:{5}", args.Type, args.IsStopped, args.Data, stoppedWorkQueue.Count, args.Frame != null ? args.Frame.Thread : null, running); }
private void OnInitialized (MD.Debugger debugger, Process process) { Console.WriteLine (">> OnInitialized"); this.process = process; this.debugger = debugger; mdbAdaptor.Process = process; guiManager = process.StartGUIManager (); //FIXME: conditionally add event handlers process.TargetOutputEvent += OnTargetOutput; debugger.ProcessCreatedEvent += OnProcessCreatedEvent; debugger.ProcessExecdEvent += OnProcessExecdEvent; debugger.ProcessExitedEvent += OnProcessExitedEvent; debugger.ThreadCreatedEvent += OnThreadCreatedEvent; debugger.ThreadExitedEvent += OnThreadExitedEvent; debugger.TargetExitedEvent += OnTargetExitedEvent; guiManager.TargetEvent += OnTargetEvent; // Not supported //guiManager.BreakpointHitHandler = BreakEventCheck; activeThread = process.MainThread; running = true; Console.WriteLine ("<< OnInitialized"); }
DL.Backtrace CreateBacktrace (MD.Thread thread, ML.TargetObject exception) { List<MD.StackFrame> frames = new List<MD.StackFrame> (); DateTime t = DateTime.Now; if (!thread.CurrentFrame.Language.IsManaged) { MD.Backtrace bt = thread.GetBacktrace (MD.Backtrace.Mode.Native, max_frames); if (bt != null) { Console.WriteLine ("GetBacktrace native time: {0} ms n:{1}", (DateTime.Now - t).TotalMilliseconds, bt.Count); frames.AddRange (bt.Frames); } } else { t = DateTime.Now; MD.Backtrace backtrace = thread.GetBacktrace (MD.Backtrace.Mode.Managed, max_frames); if (backtrace != null) { Console.WriteLine ("GetBacktrace managed time: {0} ms n:{1}", (DateTime.Now - t).TotalMilliseconds, backtrace.Count); frames.AddRange (backtrace.Frames); } } if (frames.Count > 0) { BacktraceWrapper wrapper = new BacktraceWrapper (frames.ToArray (), exception); return new DL.Backtrace (wrapper); } else if (thread.CurrentBacktrace != null) { BacktraceWrapper wrapper = new BacktraceWrapper (thread.CurrentBacktrace.Frames, exception); return new DL.Backtrace (wrapper); } return null; }
public abstract void AbortThread (MDB.Thread thread, MDB.RuntimeInvokeResult result);
private void OnThreadExitedEvent (MD.Debugger debugger, MD.Thread thread) { WriteDebuggerOutput (string.Format ("Thread {0} exited.\n", thread.ID)); }
public virtual void EnableEvent (MDB.Event ev, bool enable) { }
private void OnTargetExitedEvent (MD.Debugger debugger) { exited = true; DispatchEvent (delegate { controller.OnDebuggerOutput (false, "Target exited.\n"); DL.TargetEventArgs args = new DL.TargetEventArgs (DL.TargetEventType.TargetExited); controller.OnTargetEvent (args); }); }
public virtual void RemoveEvent (MDB.Event ev) { }
bool BreakEventCheck (MD.TargetEventArgs args) { MD.StackFrame frame = args.Frame; if (!(args.Data is int)) return true; int eventHandle = (int) args.Data; DL.BreakEvent be; if (!events.TryGetValue (eventHandle, out be)) return true; // Check hit count if (be.HitCount > 0) { be.HitCount--; DispatchEvent (delegate { NotifyBreakEventUpdate (eventHandle, be.HitCount, null); }); return false; } MdbEvaluationContext ctx = new MdbEvaluationContext (frame.Thread, frame, null, SessionOptions.EvaluationOptions); DL.Breakpoint bp = be as DL.Breakpoint; if (bp != null && !string.IsNullOrEmpty (bp.ConditionExpression)) { ML.TargetObject val = EvaluateExp (ctx, bp.ConditionExpression); if (val == null) return false; if (bp.BreakIfConditionChanges) { string current = evaluator.TargetObjectToExpression (ctx, val).Value; string last; bool found = lastConditionValue.TryGetValue (eventHandle, out last); lastConditionValue [eventHandle] = current; if (!found || last == current) return false; } else { ML.TargetFundamentalObject fob = val as ML.TargetFundamentalObject; if (fob == null) return false; object ob = fob.GetObject (frame.Thread); if (!(ob is bool) || !(bool)ob) return false; } } switch (be.HitAction) { case HitAction.Break: return true; case HitAction.CustomAction: return controller.OnCustomBreakpointAction (be.CustomActionId, eventHandle); case HitAction.PrintExpression: if (string.IsNullOrEmpty (be.TraceExpression) || frame == null) return false; ML.TargetObject val = EvaluateExp (ctx, be.TraceExpression); if (val != null) { string str = evaluator.TargetObjectToString (ctx, val); DispatchEvent (delegate { NotifyBreakEventUpdate (eventHandle, -1, str); }); } return false; } return false; }