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 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 abstract void InsertBreakpoint(BreakpointHandle breakpoint,
TargetAddress address, int 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 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 ();
}
}
