public override void Deactivate (Thread target) { if (handle != null) { handle.Remove (target); handle = null; } }
public override void Deactivate(Thread target) { if (handle != null) { handle.Remove (target); handle = null; } }
internal override BreakpointHandle Resolve(Thread target, StackFrame frame) { if (handle != null) { return(handle); } if (frame.Thread.Process.IsManaged) { MonoLanguageBackend mono = frame.Thread.Process.MonoLanguage; MonoFunctionType main = mono.MainMethod; if (main == null) { return(null); } handle = main.GetBreakpointHandle(this, -1, -1); } else { OperatingSystemBackend os = frame.Thread.Process.OperatingSystem; TargetAddress main = os.LookupSymbol("main"); if (main.IsNull) { return(null); } handle = new AddressBreakpointHandle(this, main); } return(handle); }
internal override BreakpointHandle Resolve (Thread target, StackFrame frame) { if (handle != null) return handle; handle = location.ResolveBreakpoint (session, this); return handle; }
// <summary> // Remove breakpoint @index. @index is the breakpoint number which has // been returned by InsertBreakpoint(). // </summary> internal void RemoveBreakpoint(BreakpointHandle handle) { check_disposed(); if (servant != null) { servant.RemoveBreakpoint(handle); } }
internal override BreakpointHandle Resolve(Thread target, StackFrame frame) { if (handle != null) return handle; SourceLocation location = Session.ParseLocation ( target, frame, LocationType, Name); if (location == null) throw new TargetException (TargetError.LocationInvalid); handle = location.ResolveBreakpoint (Session, this); return handle; }
internal override BreakpointHandle Resolve(Thread target, StackFrame frame) { if (handle != null) { return(handle); } SourceLocation location = Session.ParseLocation( target, frame, LocationType, Name); if (location == null) { throw new TargetException(TargetError.LocationInvalid); } handle = location.ResolveBreakpoint(Session, this); return(handle); }
// <summary> // Remove breakpoint @index. @index is the breakpoint number which has // been returned by InsertBreakpoint(). // </summary> internal void RemoveBreakpoint(BreakpointHandle handle) { check_disposed (); if (servant != null) servant.RemoveBreakpoint (handle); }
internal override void InsertBreakpoint(BreakpointHandle handle, TargetAddress address, int domain) { throw new InvalidOperationException (); }
public BreakpointEntry(BreakpointHandle handle, int domain) { this.Handle = handle; this.Domain = domain; }
// <summary> // Insert a breakpoint at address @address. // // Returns a number which may be passed to RemoveBreakpoint() to remove // the breakpoint. // </summary> internal void InsertBreakpoint(BreakpointHandle handle, TargetAddress address, int domain) { check_alive (); servant.InsertBreakpoint (handle, address, domain); }
internal override BreakpointHandle Resolve(Thread target, StackFrame frame) { if (handle != null) return handle; if (frame.Thread.Process.IsManaged) { MonoLanguageBackend mono = frame.Thread.Process.MonoLanguage; MonoFunctionType main = mono.MainMethod; if (main == null) return null; handle = main.GetBreakpointHandle (this, -1, -1); } else { OperatingSystemBackend os = frame.Thread.Process.OperatingSystem; TargetAddress main = os.LookupSymbol ("main"); if (main.IsNull) return null; handle = new AddressBreakpointHandle (this, main); } return handle; }
// <summary> // Insert a breakpoint at address @address. // // Returns a number which may be passed to RemoveBreakpoint() to remove // the breakpoint. // </summary> internal void InsertBreakpoint(BreakpointHandle handle, TargetAddress address, int domain) { check_alive(); servant.InsertBreakpoint(handle, address, domain); }
internal abstract void RemoveBreakpoint(BreakpointHandle handle);
internal override void RemoveBreakpoint(BreakpointHandle handle) { throw new InvalidOperationException (); }
internal abstract void InsertBreakpoint(BreakpointHandle breakpoint, TargetAddress address, int domain);
public int InsertBreakpoint(Inferior inferior, BreakpointHandle handle, TargetAddress address, int domain) { Lock (); try { int index; bool is_enabled; BreakpointHandle old = LookupBreakpoint ( address, out index, out is_enabled); if (old != null) throw new TargetException ( TargetError.AlreadyHaveBreakpoint, "Already have breakpoint {0} at address {1}.", old.Breakpoint.Index, address); int dr_index = -1; switch (handle.Breakpoint.Type) { case EventType.Breakpoint: index = inferior.InsertBreakpoint (address); break; case EventType.WatchRead: index = inferior.InsertHardwareWatchPoint ( address, Inferior.HardwareBreakpointType.READ, out dr_index); break; case EventType.WatchWrite: index = inferior.InsertHardwareWatchPoint ( address, Inferior.HardwareBreakpointType.WRITE, out dr_index); break; default: throw new InternalError (); } index_hash.Add (index, new BreakpointEntry (handle, domain)); return index; } finally { Unlock (); } }
internal override void RemoveBreakpoint(BreakpointHandle handle) { breakpoint_manager.RemoveBreakpoint (this, handle); }
internal override void InsertBreakpoint(BreakpointHandle handle, TargetAddress address, int domain) { breakpoint_manager.InsertBreakpoint (this, handle, address, domain); }
internal override BreakpointHandle Resolve(Thread target, StackFrame frame) { if (handle != null) return handle; handle = location.ResolveBreakpoint (session, this); return handle; }
internal override void OnTargetExited () { if (location != null) location.OnTargetExited (); handle = null; }
internal override void OnTargetExited() { handle = null; }
internal override void InsertBreakpoint(BreakpointHandle handle, TargetAddress address, int domain) { SendCommand (delegate { process.BreakpointManager.InsertBreakpoint ( inferior, handle, address, domain); return null; }); }
internal PendingBreakpointQueue GetPendingBreakpoints(SingleSteppingEngine sse, Module module) { var pending_removals = new List <FunctionBreakpointHandle> (); var pending_inserts = new List <FunctionBreakpointHandle> (); lock (this) { if (!reached_main) { foreach (Event e in events.Values) { Breakpoint bpt = e as Breakpoint; if (bpt == null) { continue; } pending_bpts.Add(bpt, BreakpointHandle.Action.Insert); } reached_main = true; } foreach (var entry in pending_bpts.ToArray()) { var breakpoint = entry.Key; var action = entry.Value; if (((action == BreakpointHandle.Action.Remove) && !breakpoint.IsActivated) || ((action == BreakpointHandle.Action.Insert) && breakpoint.IsActivated)) { pending_bpts.Remove(breakpoint); continue; } if ((action == BreakpointHandle.Action.Insert) && breakpoint.IsUserModule && (module != null) && (module.ModuleGroup.Name != "user")) { continue; } } if (pending_bpts.Count == 0) { return(null); } Language language; if (sse.Process.IsManaged) { language = sse.Process.MonoLanguage; } else { language = sse.Process.NativeLanguage; } StackFrame main_frame = new StackFrame( sse.Client, FrameType.Special, TargetAddress.Null, TargetAddress.Null, TargetAddress.Null, null, language, new Symbol("<main>", TargetAddress.Null, 0)); foreach (var entry in pending_bpts.ToArray()) { var breakpoint = entry.Key; var action = entry.Value; try { BreakpointHandle handle = breakpoint.Resolve(sse.Client, main_frame); if (handle == null) { continue; } FunctionBreakpointHandle fh = handle as FunctionBreakpointHandle; if (fh == null) { if (action == BreakpointHandle.Action.Insert) { handle.Insert(sse.Inferior); } else { handle.Remove(sse.Inferior); } pending_bpts.Remove(breakpoint); continue; } pending_bpts.Remove(breakpoint); if (action == BreakpointHandle.Action.Insert) { pending_inserts.Add(fh); } else { pending_removals.Add(fh); } } catch (TargetException ex) { if (ex.Type == TargetError.LocationInvalid) { breakpoint.OnResolveFailed(); } else { Console.WriteLine("EX: {0} {1} {2}", breakpoint, action, ex); breakpoint.OnBreakpointError( "Cannot insert breakpoint {0}: {1}", breakpoint.Index, ex.Message); } } catch (Exception ex) { Console.WriteLine("EX: {0} {1} {2}", breakpoint, action, ex); breakpoint.OnBreakpointError( "Cannot insert breakpoint {0}: {1}", breakpoint.Index, ex.Message); } } } var pending = new PendingBreakpointQueue(); foreach (var pending_removal in pending_inserts) { pending.Add(pending_removal, BreakpointHandle.Action.Insert); } foreach (var pending_removal in pending_removals) { pending.Add(pending_removal, BreakpointHandle.Action.Remove); } return(pending); }
internal override void RemoveBreakpoint(BreakpointHandle handle) { SendCommand (delegate { process.BreakpointManager.RemoveBreakpoint (inferior, handle); return null; }); }
internal override void OnTargetExited() { if (location != null) location.OnTargetExited (); handle = null; }
public void RemoveBreakpoint(Inferior inferior, BreakpointHandle handle) { Lock (); try { int[] indices = new int [index_hash.Count]; index_hash.Keys.CopyTo (indices, 0); for (int i = 0; i < indices.Length; i++) { BreakpointEntry entry = (BreakpointEntry) index_hash [indices [i]]; if (entry.Handle != handle) continue; inferior.RemoveBreakpoint (indices [i]); index_hash.Remove (indices [i]); } } finally { Unlock (); } }