internal async Task BindAsync()
{
if (IsHardwareBreakpoint)
{
// Flush pending deletes so the debugger knows how many hardware breakpoint registers are still occupied
await _bpManager.DeleteBreakpointsPendingDeletion();
}
if (CanBind())
{
PendingBreakpoint.BindResult bindResult;
// Bind all breakpoints that match this source and line number.
if (_documentName != null)
{
bindResult = await PendingBreakpoint.Bind(_documentName, _startPosition[0].dwLine + 1, _startPosition[0].dwColumn, _engine.DebuggedProcess, _condition, _enabled, _checksums, this);
}
else if (_functionName != null)
{
bindResult = await PendingBreakpoint.Bind(_functionName, _engine.DebuggedProcess, _condition, _enabled, this);
}
else if (_codeAddress != 0)
{
bindResult = await PendingBreakpoint.Bind(_codeAddress, _engine.DebuggedProcess, _condition, _enabled, this);
}
else
{
bindResult = await PendingBreakpoint.Bind(_address, _size, _engine.DebuggedProcess, _condition, this);
}
lock (_boundBreakpoints)
{
if (bindResult.PendingBreakpoint != null)
{
_bp = bindResult.PendingBreakpoint; // an MI breakpoint object exists: TODO: lock?
}
if (bindResult.BoundBreakpoints == null || bindResult.BoundBreakpoints.Count == 0)
{
this.SetError(new AD7ErrorBreakpoint(this, bindResult.ErrorMessage), true);
}
else
{
Debug.Assert(_bp != null);
foreach (BoundBreakpoint bp in bindResult.BoundBreakpoints)
{
AddBoundBreakpoint(bp);
}
}
}
}
}
private async Task HandleBreakModeEvent(ResultEventArgs results)
{
string reason = results.Results.TryFindString("reason");
int tid;
if (!results.Results.Contains("thread-id"))
{
Results res = await MICommandFactory.ThreadInfo();
tid = res.FindInt("id");
}
else
{
tid = results.Results.FindInt("thread-id");
}
ThreadCache.MarkDirty();
MICommandFactory.DefineCurrentThread(tid);
DebuggedThread thread = await ThreadCache.GetThread(tid);
await ThreadCache.StackFrames(thread); // prepopulate the break thread in the thread cache
ThreadContext cxt = await ThreadCache.GetThreadContext(thread);
ThreadCache.SendThreadEvents(this, null); // make sure that new threads have been pushed to the UI
//always delete breakpoints pending deletion on break mode
//the flag tells us if we hit an existing breakpoint pending deletion that we need to continue
await _breakpointManager.DeleteBreakpointsPendingDeletion();
//delete varialbes that have been GC'd
List <string> variablesToDelete = new List <string>();
lock (VariablesToDelete)
{
foreach (var variable in VariablesToDelete)
{
variablesToDelete.Add(variable);
}
VariablesToDelete.Clear();
}
foreach (var variable in variablesToDelete)
{
try
{
await MICommandFactory.VarDelete(variable);
}
catch (MIException)
{
//not much to do really, we're leaking MI debugger variables.
Debug.Fail("Failed to delete variable: " + variable + ". This is leaking memory in the MI Debugger.");
}
}
if (String.IsNullOrWhiteSpace(reason) && !_bEntrypointHit)
{
// CLRDBG TODO: Try to verify this code path
_bEntrypointHit = true;
CmdContinueAsync();
FireDeviceAppLauncherResume();
}
else if (reason == "breakpoint-hit")
{
string bkptno = results.Results.FindString("bkptno");
ulong addr = cxt.pc ?? 0;
AD7BoundBreakpoint bkpt = null;
bool fContinue;
TupleValue frame = results.Results.TryFind <TupleValue>("frame");
bkpt = _breakpointManager.FindHitBreakpoint(bkptno, addr, frame, out fContinue); // use breakpoint number to resolve breakpoint
if (bkpt != null)
{
List <object> bplist = new List <object>();
bplist.Add(bkpt);
_callback.OnBreakpoint(thread, bplist.AsReadOnly());
}
else if (!_bEntrypointHit)
{
_bEntrypointHit = true;
_callback.OnEntryPoint(thread);
}
else
{
if (fContinue)
{
//we hit a bp pending deletion
//post the CmdContinueAsync operation so it does not happen until we have deleted all the pending deletes
CmdContinueAsync();
}
else
{
// not one of our breakpoints, so stop with a message
_callback.OnException(thread, "Unknown breakpoint", "", 0);
}
}
}
else if (reason == "end-stepping-range" || reason == "function-finished")
{
_callback.OnStepComplete(thread);
}
else if (reason == "signal-received")
{
string name = results.Results.TryFindString("signal-name");
if ((name == "SIG32") || (name == "SIG33"))
{
// we are going to ignore these (Sigma) signals for now
CmdContinueAsync();
}
else if (MICommandFactory.IsAsyncBreakSignal(results.Results))
{
_callback.OnAsyncBreakComplete(thread);
}
else
{
uint code = 0;
string sigName = results.Results.TryFindString("signal-name");
code = results.Results.Contains("signal") ? results.Results.FindUint("signal") : 0;
if (String.IsNullOrEmpty(sigName) && code != 0 && EngineUtils.SignalMap.Instance.ContainsValue(code))
{
sigName = EngineUtils.SignalMap.Instance.First((p) => p.Value == code).Key;
}
else if (!String.IsNullOrEmpty(sigName) && code == 0 && EngineUtils.SignalMap.Instance.ContainsKey(sigName))
{
code = EngineUtils.SignalMap.Instance[sigName];
}
_callback.OnException(thread, sigName, results.Results.TryFindString("signal-meaning"), code);
}
}
else if (reason == "exception-received")
{
string exception = results.Results.FindString("exception");
_callback.OnException(thread, "Exception", exception, 0);
}
else
{
Debug.Fail("Unknown stopping reason");
_callback.OnException(thread, "Unknown", "Unknown stopping event", 0);
}
}
