public BasicBreakpoint( DebugControl control, BreakpointType type, int address )
: base( type, address )
{
Debug.Assert( control != null );
if( control == null )
throw new ArgumentNullException( "control" );
_control = control;
}
public bool Compare(Stream regStream, BreakpointType bpType, UInt32 bpAddress, USBGecko gecko)
{
if (regStream.Length != 0x120)
return false;
int spos = PRegister * 4;
UInt32 val = 0;
if (spos == 0x120) //Value of address is supposed to be checked
{
switch (bpType)
{
case BreakpointType.Read:
val = gecko.peek(bpAddress);
break;
case BreakpointType.ReadWrite:
case BreakpointType.Write:
gecko.Step();
val = gecko.peek(bpAddress);
break;
default:
return true;
}
}
else
{
regStream.Seek(spos, SeekOrigin.Begin);
val = GlobalFunctions.ReadStream(regStream);
}
switch (PCondition)
{
case BreakpointComparison.Equal:
return (val == PValue);
case BreakpointComparison.NotEqual:
return (val != PValue);
case BreakpointComparison.Greater:
return (val > PValue);
case BreakpointComparison.GreaterEqual:
return (val >= PValue);
case BreakpointComparison.Lower:
return (val < PValue);
case BreakpointComparison.LowerEqual:
return (val <= PValue);
}
return true;
}
private void OptimizeSize(decimal windowWidth)
{
BreakpointType actualBreakpoint = null;
for (int i = 0; i < _breakpoints.Length; i++)
{
if (windowWidth <= _breakpoints[i].Width && (windowWidth >= (i > 0 ? _breakpoints[i - 1].Width : 0)))
{
actualBreakpoint = _breakpoints[i];
}
}
SetGutterStyle(actualBreakpoint.Name);
if (OnBreakpoint.HasDelegate)
{
OnBreakpoint.InvokeAsync(actualBreakpoint);
}
StateHasChanged();
}
public PacketData RemoveBreakpoint(
[Argument(Separator = ',')] BreakpointType type,
[Argument(Separator = ',', Encoding = ArgumentAttribute.ArgumentEncoding.HexNumber)] ulong address,
[Argument(Separator = ';', Encoding = ArgumentAttribute.ArgumentEncoding.HexNumber)] uint kind)
{
switch (type)
{
case BreakpointType.MemoryBreakpoint:
foreach (var cpu in manager.ManagedCpus.Values)
{
cpu.RemoveHook(address, MemoryBreakpointHook);
}
break;
case BreakpointType.HardwareBreakpoint:
foreach (var cpu in manager.ManagedCpus.Values)
{
cpu.RemoveHook(address, HardwareBreakpointHook);
}
break;
case BreakpointType.AccessWatchpoint:
RemoveWatchpointsCoveringMemoryArea(address, kind, Access.ReadAndWrite, AccessWatchpointHook);
break;
case BreakpointType.ReadWatchpoint:
RemoveWatchpointsCoveringMemoryArea(address, kind, Access.Read, ReadWatchpointHook);
break;
case BreakpointType.WriteWatchpoint:
RemoveWatchpointsCoveringMemoryArea(address, kind, Access.Write, WriteWatchpointHook);
break;
default:
Logger.LogAs(this, LogLevel.Warning, "Unsupported breakpoint type: {0}, not removing.", type);
return(PacketData.ErrorReply());
}
return(PacketData.Success);
}
///////////////////////////////////////////////////////////////////////
#region Private Methods
private void Initialize()
{
enabled = new bool[] { DefaultEnabled, false };
loops = new int[] { 0, 0 };
active = new int[] { 0, 0 };
singleStep = new bool[] { false, false };
#if BREAKPOINTS
breakOnToken = new bool[] { false, false };
#endif
breakOnExecute = new bool[] { false, false };
breakOnCancel = new bool[] { false, false };
breakOnError = new bool[] { false, false };
breakOnReturn = new bool[] { false, false };
breakOnTest = new bool[] { false, false };
breakOnExit = new bool[] { false, false };
steps = new long[] { 0, 0 };
types = new BreakpointType[] {
DefaultTypes, BreakpointType.None
};
#if BREAKPOINTS
breakpoints = new BreakpointDictionary[] {
new BreakpointDictionary(), null
};
#endif
#if DEBUGGER_ARGUMENTS
executeArguments = new ArgumentList[] { null, null };
#endif
command = new string[] { null, null };
result = new Result[] { null, null };
queue = new QueueList <string, string>[] { null, null };
callbackArguments = new StringList[] { null, null };
}
public static void TryTrigger <T>(Emulator emu, BreakpointType type, T value)
{
if (Breakpoints.Count(t => { var v = (Breakpoint <T>)t; return(v.BpType.HasFlag(type) && (v.Value == null ? true : v.Value.Equals(value))); }) == 0)
{
return;
}
var bps = Breakpoints.Where(t => { var v = (Breakpoint <T>)t; return(v.BpType.HasFlag(type) && (v.Value == null ? true : v.Value.Equals(value))); });
foreach (var bp in bps)
{
if (bp.OneTimeOnly)
{
Breakpoints.Remove(bp);
}
if (bp.StopOnHit)
{
emu.Interrupt();
}
}
}
public bool TriggerBreakpoint(int aBreakAt,
BreakpointType aType,
Registers?aRegId = null)
{
if (!HasBreakpoint(aBreakAt, aType, aRegId))
{
return(false);
}
var shouldHalt = false;
var bpd =
GetBreakpoints(aBreakAt, aType, aRegId);
foreach (var bp in bpd)
{
if (bp?.Action != null && bp.Action.Invoke(aBreakAt))
{
shouldHalt = true;
}
}
return(shouldHalt);
}
///////////////////////////////////////////////////////////////////////
internal TraceInfo(
ITrace trace,
BreakpointType breakpointType,
ICallFrame frame,
IVariable variable,
string name,
string index,
VariableFlags flags,
object oldValue,
object newValue,
ElementDictionary oldValues,
ElementDictionary newValues,
StringList list,
bool cancel,
bool postProcess,
ReturnCode returnCode
)
{
Update(
trace, breakpointType, frame, variable, name, index, flags,
oldValue, newValue, oldValues, newValues, list, cancel,
postProcess, returnCode);
}
private void OptimizeSize(decimal windowWidth)
{
BreakpointType actualBreakpoint = _breakpoints[_breakpoints.Length - 1];
for (int i = 0; i < _breakpoints.Length; i++)
{
if (windowWidth <= (int)_breakpoints[i] && (windowWidth >= (i > 0 ? (int)_breakpoints[i - 1] : 0)))
{
actualBreakpoint = _breakpoints[i];
}
}
this._currentBreakPoint = actualBreakpoint;
SetGutterStyle(actualBreakpoint);
if (OnBreakpoint.HasDelegate)
{
OnBreakpoint.InvokeAsync(actualBreakpoint);
}
StateHasChanged();
}
public static string GetStopReason(this BreakpointType type)
{
switch (type)
{
case BreakpointType.AccessWatchpoint:
return("awatch");
case BreakpointType.WriteWatchpoint:
return("watch");
case BreakpointType.ReadWatchpoint:
return("rwatch");
case BreakpointType.HardwareBreakpoint:
return("hwbreak");
case BreakpointType.MemoryBreakpoint:
return("swbreak");
default:
throw new ArgumentException();
}
}
public bool Check(Stream regStream, BreakpointType bpType, UInt32 bpAddress, USBGecko gecko)
{
if (!Enabled)
{
return(true);
}
if (PConditions.Count == 0)
{
return(true);
}
if (regStream.Length != 0x120)
{
return(false);
}
List <UInt32> groups = new List <uint>();
// Fill it up with each groupNumber in the condition list
foreach (BreakpointCondition cond in PConditions)
{
if (!groups.Contains(cond.GroupNumber))
{
groups.Add(cond.GroupNumber);
}
}
// If any condition fails, remove it's group number from the group
foreach (BreakpointCondition cond in PConditions)
{
if (groups.Contains(cond.GroupNumber) && !cond.Compare(regStream, bpType, bpAddress, gecko))
{
groups.Remove(cond.GroupNumber);
}
}
// If there are any left, we succeeded!
return(groups.Count != 0);
}
///////////////////////////////////////////////////////////////////////
public ITraceInfo Update(
ITrace trace,
BreakpointType breakpointType,
ICallFrame frame,
IVariable variable,
string name,
string index,
VariableFlags flags,
object oldValue,
object newValue,
ElementDictionary oldValues,
ElementDictionary newValues,
StringList list,
bool cancel,
bool postProcess,
ReturnCode returnCode
)
{
this.trace = trace;
this.breakpointType = breakpointType;
this.frame = frame;
this.variable = variable;
this.name = name;
this.index = index;
this.flags = flags;
this.oldValue = oldValue;
this.newValue = newValue;
this.oldValues = oldValues;
this.newValues = newValues;
this.list = list;
this.cancel = cancel;
this.postProcess = postProcess;
this.returnCode = returnCode;
return(this);
}
private InteractiveLoopData(
bool debug,
IEnumerable <string> args,
ReturnCode code,
BreakpointType breakpointType,
string breakpointName,
IToken token,
ITraceInfo traceInfo,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
HeaderFlags headerFlags,
IClientData clientData,
ArgumentList arguments,
bool exit
)
{
this.kind = IdentifierKind.InteractiveLoopData;
this.id = AttributeOps.GetObjectId(this);
this.debug = debug;
this.args = args;
this.code = code;
this.breakpointType = breakpointType;
this.breakpointName = breakpointName;
this.token = token;
this.traceInfo = traceInfo;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.eventFlags = eventFlags;
this.expressionFlags = expressionFlags;
this.headerFlags = headerFlags;
this.clientData = clientData;
this.arguments = arguments;
this.exit = exit;
}
private Breakpoint( int id, BreakpointType type )
{
this.ID = id;
this.Type = type;
this.Name = null;
this.Mode = BreakpointMode.Break;
this.Enabled = true;
}
public BreakpointPropertiesDialog (BreakEvent be, BreakpointType breakpointType)
{
this.be = be;
LoadExceptionList ();
Initialize ();
SetInitialData ();
SetLayout ();
if (be == null) {
switch (breakpointType) {
case BreakpointType.Location:
stopOnLocation.Active = true;
entryLocationFile.SetFocus ();
break;
case BreakpointType.Function:
stopOnFunction.Active = true;
entryFunctionName.SetFocus ();
break;
case BreakpointType.Catchpoint:
stopOnException.Active = true;
entryExceptionType.SetFocus ();
break;
}
}
}
public Breakpoint(string name, BreakpointType type = BreakpointType.None)
{
Name = name;
Type = type;
}
/// <summary>
/// Sets a hardware breakpoint that suspends title execution when a particular section of memory is referenced.
/// </summary>
/// <param name="address">Address of the memory to watch.</param>
/// <param name="size">The size, in bytes, of the memory to be watched.
/// The only allowable values for this parameter are 1, 2, and 4.</param>
/// <param name="type">Type of access to watch for.</param>
public void SetBreakPoint(uint address, uint size, BreakpointType type)
{
SendCommand("break addr={0} size={1} {2}", address, type.ToString().Replace(",", ""));
}
/// <summary>
/// Initializes a new <see cref="Breakpoint"/> instance with the given parameters.
/// </summary>
/// <param name="id">A unique ID used to lookup the breakpoint.</param>
/// <param name="type">The breakpoint type.</param>
/// <param name="address">The address of the breakpoint.</param>
public Breakpoint(int id, BreakpointType type, uint address)
: this(id, type)
{
this.Address = address;
}
/// <summary>
/// Sets a breakpoint in an xbox title.
/// </summary>
/// <param name="address">Address where you would like to set a breakpoint.</param>
/// <param name="type">Type of access to watch for.</param>
/// <remarks>DmSetDataBreakpoint</remarks>
public void SetDataBreakPoint(uint address, BreakpointType type)
{
SetDataBreakPoint(address, 1, type);
}
public static PacketData StopReply(BreakpointType reason, long address)
{
return(new PacketData(string.Format("T05{0}:{1};", reason.GetStopReason(),
address == -1 ? string.Empty : string.Format("{0:X2}", address))));
}
public bool SetBreakpoint(UInt32 address, BreakpointType type, bool exact)
{
return(SetBreakpoint(address, type, exact, true));
}
public bool SetBreakpoint(UInt32 address, BreakpointType type, bool exact)
{
return SetBreakpoint(address, type, exact, true);
}
public static bool IsWatchpoint(this BreakpointType bt)
{
return(bt == BreakpointType.WriteWatchpoint || bt == BreakpointType.ReadWatchpoint || bt == BreakpointType.AccessWatchpoint);
}
public HaltArguments(HaltReason reason, long address = -1, BreakpointType? breakpointType = null)
{
Reason = reason;
Address = address;
BreakpointType = breakpointType;
}
public BreakpointEntry(BreakpointProcessor processor, BreakpointType type, int address)
{
Processor = processor;
Type = type;
Address = address;
}
///////////////////////////////////////////////////////////////////////
public ReturnCode FireTraces(
BreakpointType breakpointType,
Interpreter interpreter,
ITraceInfo traceInfo,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (traces != null)
{
//
// NOTE: Save the current variable flags.
//
VariableFlags savedFlags = flags;
//
// NOTE: Prevent endless trace recursion.
//
flags |= VariableFlags.NoTrace;
try
{
//
// NOTE: Process each trace (as long as they all continue
// to succeed).
//
foreach (ITrace trace in traces)
{
if ((trace != null) && !EntityOps.IsDisabled(trace))
{
//
// NOTE: If possible, set the Trace property of the
// TraceInfo to the one we are about to execute.
//
if (traceInfo != null)
{
traceInfo.Trace = trace;
}
//
// NOTE: Since variable traces can basically do anything
// they want, we wrap them in a try block to prevent
// exceptions from escaping.
//
interpreter.EnterTraceLevel();
try
{
code = trace.Execute(
breakpointType, interpreter, traceInfo, ref result);
}
catch (Exception e)
{
//
// NOTE: Translate exceptions to a failure return.
//
result = String.Format(
"caught exception while firing variable trace: {0}",
e);
code = ReturnCode.Error;
}
finally
{
interpreter.ExitTraceLevel();
}
//
// NOTE: Check for exception results specially because we
// treat "Break" different from other return codes.
//
if (code == ReturnCode.Break)
{
//
// NOTE: Success; however, skip processing further
// traces for this variable operation.
//
code = ReturnCode.Ok;
break;
}
else if (code != ReturnCode.Ok)
{
//
// NOTE: Some type of failure (or exception), stop
// processing for this variable operation.
//
break;
}
}
}
}
finally
{
//
// NOTE: Restore the saved variable flags.
//
flags = savedFlags;
}
}
return(code);
}
public Breakpoint(BreakpointType type, ushort address)
{
this.Type = type;
this.Address = address;
}
public static PacketData StopReply(BreakpointType reason, uint cpuId, ulong?address)
{
return(new PacketData(string.Format("T05{0}:{1};thread:{2:X2};", reason.GetStopReason(),
!address.HasValue ? string.Empty : string.Format("{0:X2}", address), cpuId)));
}
public void Add(uint address, BreakpointType type)
{
Add(new AtariBreakpoint(Callback, address, type));
}
/// <summary>
/// Sets a hardware breakpoint that suspends title execution when a particular section of memory is referenced.
/// </summary>
/// <param name="address">Address of the memory to watch.</param>
/// <param name="size">The size, in bytes, of the memory to be watched.
/// The only allowable values for this parameter are 1, 2, and 4.</param>
/// <param name="type">Type of access to watch for.</param>
/// <remarks>DmSetDataBreakpoint</remarks>
public void SetDataBreakPoint(uint address, uint size, BreakpointType type)
{
if (size != sizeof(byte) || size != sizeof(short) || size != sizeof(int))
throw new ArgumentOutOfRangeException("size", size.ToString());
bool clear = type == BreakpointType.None;
// xboxdbg.dll only uses one breakpoint type, so multiple types shouldn't be bitted together...
string type_str = type.ToString().Replace(",", "");
SendCommand("break {0}=0x{1} size={2} {3}", type_str, address.ToString("X8"), size,
clear ? "clear" : "");
}
public Breakpoint(BreakpointType type, ushort address)
{
this.Type = type;
this.Address = address;
}
public bool Check(Stream regStream, BreakpointType bpType, UInt32 bpAddress, TCPGecko gecko)
{
if (!Enabled)
return true;
if (PConditions.Count == 0)
return true;
if (regStream.Length != 0x120)
return false;
List<UInt32> groups = new List<uint>();
// Fill it up with each groupNumber in the condition list
foreach (BreakpointCondition cond in PConditions)
{
if (!groups.Contains(cond.GroupNumber))
groups.Add(cond.GroupNumber);
}
// If any condition fails, remove it's group number from the group
foreach (BreakpointCondition cond in PConditions)
{
if (groups.Contains(cond.GroupNumber) && !cond.Compare(regStream, bpType, bpAddress, gecko))
groups.Remove(cond.GroupNumber);
}
// If there are any left, we succeeded!
return (groups.Count != 0);
}
private static ReturnCode TraceCallback(
BreakpointType breakpointType, /* in */
Interpreter interpreter, /* in */
ITraceInfo traceInfo, /* in */
ref Result result /* out */
)
{
if (interpreter == null)
{
//
// NOTE: We require a valid interpreter context. Most custom
// variable trace methods will want to do this because it
// is a fairly standard safety check (HIGHLY RECOMMENDED).
//
result = "invalid interpreter";
return(ReturnCode.Error);
}
if (traceInfo == null)
{
//
// NOTE: This parameter should contain the information about
// the current variable access being processed. If it
// is null, we cannot continue (HIGHLY RECOMMENDED).
//
result = "invalid trace";
return(ReturnCode.Error);
}
//
// NOTE: This trace method intercepts and show all variable access
// for the interpreter. We could do practically anything
// inside this method, including monitoring and/or modifying
// the values to be fetched and/or set, changing the state of
// the interpreter, or aborting the operation altogether.
//
///////////////////////////////////////////////////////////////////
// ******************* BEGIN CUSTOM TRACE CODE ********************
///////////////////////////////////////////////////////////////////
//
// NOTE: This particular variable trace method requires a valid
// interpreter host; however, in practice, such a requirement
// would be very rare.
//
IHost host = interpreter.Host;
if (host == null)
{
result = "interpreter host not available";
return(ReturnCode.Error);
}
//
// NOTE: The try block here is optional; however, custom variable
// trace methods are "officially" discouraged from raising
// exceptions.
//
ReturnCode code = ReturnCode.Ok;
switch (traceInfo.BreakpointType)
{
case BreakpointType.BeforeVariableUnset:
{
try
{
//
// NOTE: Query the configured foreground and
// background colors used by the host
// to display variable trace information.
//
ConsoleColor foregroundColor = _ConsoleColor.None;
ConsoleColor backgroundColor = _ConsoleColor.None;
code = host.GetColors(null,
"TraceInfo", true, true, ref foregroundColor,
ref backgroundColor, ref result);
if (code == ReturnCode.Ok)
{
//
// NOTE: Clear the interpreter host and reset
// its output position as well.
//
host.Clear();
host.ResetPosition();
//
// NOTE: Write the variable trace information
// received by this method to the
// interpreter host.
//
host.WriteTraceInfo(
interpreter, traceInfo,
DetailFlags.EmptyContent, true,
foregroundColor, backgroundColor);
host.RestorePosition(false);
int left = 0;
int top = 0;
host.GetPosition(ref left, ref top);
left = 0; /* NOTE: Left aligned. */
top++; /* NOTE: On next line. */
host.WriteBox(null,
"Press any key to continue...", null,
false, false, ref left, ref top);
host.Pause();
}
}
catch (Exception e)
{
result = e;
code = ReturnCode.Error;
}
unsetTraces++;
break;
}
case BreakpointType.BeforeVariableGet:
{
getTraces++;
break;
}
case BreakpointType.BeforeVariableSet:
{
setTraces++;
break;
}
}
//
// NOTE: Finally, return one of the standard status codes that
// indicate success / failure of this variable access.
//
return(code);
///////////////////////////////////////////////////////////////////
// ******************** END CUSTOM TRACE CODE *********************
///////////////////////////////////////////////////////////////////
}
public static bool ShowBreakpointProperties (ref BreakEvent bp, BreakpointType breakpointType = BreakpointType.Location)
{
using (var dlg = new BreakpointPropertiesDialog (bp, breakpointType)) {
Xwt.Command response = dlg.Run ();
if (bp == null)
bp = dlg.GetBreakEvent ();
return response == Xwt.Command.Ok;
}
}
public static void AddBreakpoint <T>(BreakpointType type, T parameter, bool stopOnHit = true, bool oneTime = false)
{
Breakpoints.Add(new Breakpoint <T>(type, parameter, stopOnHit, oneTime));
}
private void OnBreakpoint(BreakpointType breakpoint)
{
_isCollapsed = breakpoint.IsIn(BreakpointType.Sm, BreakpointType.Xs);
}
public bool SetBreakpoint(UInt32 address, BreakpointType type, bool exact, bool wait)
{
try
{
bpType = type;
bpAddress = address;
bpWait = wait;
bpExact = exact;
PSkipCount = 0;
cancelled = false;
SetActualBP();
if (!bpWait)
return true;
Thread waitThread = new Thread(WaitForBreakpoint);
waitThread.Start();
return true;
}
catch (ETCPGeckoException e)
{
exceptionHandling.HandleException(e);
return false;
}
catch
{
return false;
}
}
public Breakpoint(uint address, int program, BreakpointType breakpointType)
{
Address = address;
Program = program;
BreakpointType = breakpointType;
}
public BreakpointEntry(BreakpointType type, ushort address)
{
Type = type;
Address = address;
}
public Breakpoint(BreakpointType type, int offset)
{
Type = type;
Offset = offset;
}
/// <summary>
/// Initializes a new <see cref="Breakpoint"/> instance with the given parameters.
/// </summary>
/// <param name="id">A unique ID used to lookup the breakpoint.</param>
/// <param name="type">The breakpoint type.</param>
/// <param name="address">The address of the breakpoint.</param>
public Breakpoint( int id, BreakpointType type, uint address )
: this(id, type)
{
this.Address = address;
}
private void OnBreakpoint(BreakpointType breakpoint)
{
Collapsed = breakpoint.IsIn(BreakpointType.Sm, BreakpointType.Xs, BreakpointType.Md);
SetStyle();
}
public static PacketData StopReply(BreakpointType reason, long address)
{
return new PacketData(string.Format("T05{0}:{1};", reason.GetStopReason(),
address == -1 ? string.Empty : string.Format("{0:X2}", address)));
}
