private void m_debuggerClient_BreakpointEvent(object sender, BreakpointEventArgs e)
{
if (ExceptionEvent != null)
{
BreakpointEvent(sender, new BreakpointEventArgs(e.BreakpointEvent));
}
}
protected virtual void OnBreakpointHit(object sender, BreakpointEventArgs e)
{
if (BreakpointHit != null)
{
BreakpointHit(this, new BreakpointEventArgs(e.Breakpoint));
}
}
} // end _ShouldOutput()
public int Breakpoint(WDebugBreakpoint Bp)
{
try
{
var bi = new DbgBreakpointInfo(m_debugger, Bp);
if (bi.IsOneShot)
{
// If we /hit/ a breakpoint, and it was "one-shot", then it's
// going to get deleted out from under us. Prevent AVs later by
// marking it invalid now.
bi.MarkInvalid();
}
var eventArgs = new BreakpointEventArgs(m_debugger, bi);
int retVal = _RaiseEvent(m_debugger.BreakpointHit, eventArgs);
if (_ShouldOutput(retVal, eventArgs))
{
// Special case for "gu"/"step out" breakpoints: we're going to
// pretend they don't exist.
if (DbgBreakpointInfo.StepOutBreakpointId != bi.Id)
{
_PsPipe.WriteObject(eventArgs);
}
}
return(retVal);
}
catch (Exception e)
{
Util.FailFast("Unexpected exception during event callback.", e);
return(0);
}
} // end Breakpoint()
protected virtual void OnBreakpointStateChanged(object sender, BreakpointEventArgs e)
{
if (BreakpointStateChanged != null)
{
BreakpointStateChanged(this, new BreakpointEventArgs(e.Breakpoint));
}
}
private void BreakpointService_Added(object sender, BreakpointEventArgs e)
{
var bpLine = GetLineByAddress(e.Address) as DisassemblyInstructionLineViewModel;
if (bpLine != null)
{
bpLine.HasBreakpoint = true;
}
}
private void HandleBp(object sender, BreakpointEventArgs args)
{
uint bpId = args.Breakpoint.Id;
if (bpId == this.getVersionBp.Id)
{
this.getVersionRetBp.Offset = this.ctrl.ReturnOffset;
this.getVersionRetBp.Options = BreakpointOptions.Enabled;
}
else if (bpId == this.getVersionExBp.Id)
{
ulong[] ptrs = new ulong[1];
this.data.ReadPointersVirtual(1, this.regs.StackOffset + 4, ptrs);
this.osVerOffset = ptrs[0];
this.getVersionExRetBp.Offset = this.ctrl.ReturnOffset;
this.getVersionExRetBp.Options = BreakpointOptions.Enabled;
}
else if (bpId == this.getVersionRetBp.Id)
{
this.getVersionRetBp.Options &= ~BreakpointOptions.Enabled;
this.regs.SetValue(this.eaxIndex, this.versionNumber);
Console.Out.WriteLine("HEALER: GetVersion returns {0}", this.versionNumber.ToString("x"));
}
else if (bpId == this.getVersionExRetBp.Id)
{
this.getVersionExRetBp.Options &= ~BreakpointOptions.Enabled;
int sizeOfOsVer = Marshal.SizeOf(this.osVer);
byte[] rawOsVer = new byte[sizeOfOsVer];
GCHandle gchOsVer = GCHandle.Alloc(this.osVer, GCHandleType.Pinned);
try
{
Marshal.Copy((IntPtr)gchOsVer, rawOsVer, 0, sizeOfOsVer);
this.data.WriteVirtual(this.osVerOffset, rawOsVer);
}
finally
{
gchOsVer.Free();
}
Console.Out.WriteLine("HEALER: GetVersionEx returns {0}", this.versionNumber.ToString("x"));
}
else
{
return;
}
args.EventStatus = DebugStatus.Go;
}
private void OnBreakpoint(object sender, BreakpointEventArgs e)
{
var result = MessageBox.Show($"Pause execution at 0x{e.PC:X4}?", "Breakpoint hit",
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result == MessageBoxResult.Yes)
{
FocusHexBox?.Invoke(_console.Cpu.PC);
_cancel = true;
}
}
internal void HandleBreakpointEvent(BreakpointEventArgs e)
{
var context = e.Thread.GetThreadContext();
var eip = (Register <uint>)context.GetRegisterByName("eip");
eip.Value--;
context.Flush();
RestoreOriginalCode();
OnBreakpointHit(e);
}
private void OnChange(object sender, BreakpointEventArgs e)
{
switch (e.EventType)
{
case BreakpointEventType.Add:
var lvi = new ListViewItem()
{
Text = $"${e.Address:X4}", Tag = e.Address
};
lvi.SubItems.Add(new ListViewItem.ListViewSubItem()
{
Text = "Yes"
});
BreakpointsListView.Items.Add(lvi);
break;
case BreakpointEventType.Remove:
{
var item = BreakpointsListView.Items.Cast <ListViewItem>().FirstOrDefault(x => (int)x.Tag == e.Address);
if (item != null)
{
BreakpointsListView.Items.Remove(item);
}
}
break;
case BreakpointEventType.Clear:
BreakpointsListView.Items.Clear();
break;
case BreakpointEventType.Enable:
{
var item = BreakpointsListView.Items.Cast <ListViewItem>().FirstOrDefault(x => (int)x.Tag == e.Address);
if (item != null)
{
item.SubItems[1].Text = "Yes";
}
}
break;
case BreakpointEventType.Disable:
{
var item = BreakpointsListView.Items.Cast <ListViewItem>().FirstOrDefault(x => (int)x.Tag == e.Address);
if (item != null)
{
item.SubItems[1].Text = "No";
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public bool HandlePageGuardViolationEvent(DEBUG_EVENT debugEvent, out DebuggerAction nextAction)
{
// Memory breakpoints are implemented using page guards. We need to check if the page guard
// violation originated from a breakpoint or not, and pause or continue execution when appropriate.
const int ExceptionInformationReadWrite = 0;
const int ExceptionInformationAddress = 1;
var info = debugEvent.InterpretDebugInfoAs <EXCEPTION_DEBUG_INFO>();
var process = _session.GetProcessById((int)debugEvent.dwProcessId);
var thread = process.GetThreadById((int)debugEvent.dwThreadId);
if (info.ExceptionRecord.NumberParameters >= 2)
{
bool isWrite = info.ExceptionRecord.ExceptionInformation[ExceptionInformationReadWrite] == 1;
IntPtr address = (IntPtr)info.ExceptionRecord.ExceptionInformation[ExceptionInformationAddress];
var pageGuard = process.GetContainingPageGuard(address);
if (pageGuard != null)
{
// Restore page guard after continuing.
_pageGuardsToRestore.Add(pageGuard);
if (pageGuard.Breakpoints.TryGetValue(address, out var breakpoint) &&
(breakpoint.BreakOnRead == !isWrite || breakpoint.BreakOnWrite == isWrite))
{
// Violation originated from a breakpoint.
var eventArgs = new BreakpointEventArgs(thread, breakpoint)
{
NextAction = DebuggerAction.Stop
};
breakpoint.HandleBreakpointEvent(eventArgs);
OnBreakpointHit(eventArgs);
nextAction = eventArgs.NextAction;
}
else
{
// Violation did not originate from a breakpoint.
_isRestoringFromGuard = true;
PrepareContextForSingleStep(thread);
nextAction = DebuggerAction.Continue;
}
return(true);
}
}
nextAction = DebuggerAction.ContinueWithException;
return(false);
}
private void OnBreakpointBindSucceeded(object sender, BreakpointEventArgs e)
{
IDebugPendingBreakpoint2 pendingBreakpoint;
var boundBreakpoint = _breakpointManager.GetBreakpoint(e.Breakpoint);
((IDebugBoundBreakpoint2)boundBreakpoint).GetPendingBreakpoint(out pendingBreakpoint);
Send(
new AD7BreakpointBoundEvent((AD7PendingBreakpoint)pendingBreakpoint, boundBreakpoint),
AD7BreakpointBoundEvent.IID,
null
);
}
private void SessionOnBreakpointHit(object sender, BreakpointEventArgs args)
{
string breakpointType = null;
if (args.Breakpoint is ISoftwareBreakpoint)
{
breakpointType = "Software";
}
else if (args.Breakpoint is IMemoryBreakpoint)
{
breakpointType = "Memory";
}
_logger.WriteLine(LoggerMessageType.Breakpoint, "{0} breakpoint at address {1:X8} hit.",
breakpointType,
args.Breakpoint.Address.ToInt64());
}
private void OnBreakpointBindSucceeded(object sender, BreakpointEventArgs e)
{
IDebugPendingBreakpoint2 pendingBreakpoint;
AD7BoundBreakpoint boundBreakpoint = _breakpointManager.GetBreakpoint(e.Breakpoint);
((IDebugBoundBreakpoint2)boundBreakpoint).GetPendingBreakpoint(out pendingBreakpoint);
Send(
new AD7BreakpointBoundEvent((AD7PendingBreakpoint)pendingBreakpoint, boundBreakpoint),
AD7BreakpointBoundEvent.IID,
null
);
EventHandler <AD7EngineEventArgs> breakpointHit = EngineBreakpointHit;
if (breakpointHit != null)
{
breakpointHit(this, new AD7EngineEventArgs(this));
}
}
public void RaiseBreakpointEventViaDebuggerClient()
{
// Arrange
var connectionMock = new Mock <IDebuggerConnection>();
var messageEventArgs = new MessageEventArgs(Resources.NodeBreakpointResponse);
var client = new DebuggerClient(connectionMock.Object);
object sender = null;
BreakpointEventArgs args = null;
// Act
client.BreakpointEvent += (s, a) => {
sender = s;
args = a;
};
connectionMock.Raise(f => f.OutputMessage += null, messageEventArgs);
// Assert
Assert.AreEqual(client, sender);
Assert.IsNotNull(args);
Assert.IsNotNull(args.BreakpointEvent);
}
void OnBreakpointUpdated(object s, BreakpointEventArgs args)
{
TreeIter it;
if (!store.GetIterFirst(out it))
{
return;
}
do
{
Breakpoint bp = (Breakpoint)store.GetValue(it, (int)Columns.Breakpoint);
if (bp == args.Breakpoint)
{
string traceVal = bp.HitAction == HitAction.PrintExpression ? bp.LastTraceValue : "";
string hitCount = bp.HitCount > 0 ? bp.HitCount.ToString() : "";
store.SetValue(it, (int)Columns.HitCount, hitCount);
store.SetValue(it, (int)Columns.LastTrace, traceVal);
break;
}
}while (store.IterNext(ref it));
}
public bool HandleBreakpointEvent(DEBUG_EVENT debugEvent, out DebuggerAction nextAction)
{
// If signalled by an int3, the exception was thrown after the execution of int3.
// Find corresponding breakpoint and restore the instruction pointer so that it seems
// it has paused execution before the int3.
var process = _session.GetProcessById((int)debugEvent.dwProcessId);
var thread = process.GetThreadById((int)debugEvent.dwThreadId);
uint eip = (uint)thread.GetThreadContext().GetRegisterByName("eip").Value - 1;
var breakpoint = process.GetSoftwareBreakpointByAddress((IntPtr)eip);
// Check if breakpoint originated from a step-over action.
if (breakpoint == null && _stepOverBreakpoint?.Address == (IntPtr)eip)
{
_stepOverBreakpoint.HandleBreakpointEvent(new BreakpointEventArgs(thread, _stepOverBreakpoint));
_stepOverBreakpoint = null;
nextAction = FinalizeStep(thread);
return(true);
}
if (breakpoint != null)
{
_breakpointsToRestore.Add(breakpoint);
var eventArgs = new BreakpointEventArgs(thread, breakpoint)
{
NextAction = DebuggerAction.Stop
};
breakpoint.HandleBreakpointEvent(eventArgs);
OnBreakpointHit(eventArgs);
nextAction = eventArgs.NextAction;
return(true);
}
nextAction = DebuggerAction.ContinueWithException;
return(false);
}
// Token: 0x06000117 RID: 279 RVA: 0x000052C0 File Offset: 0x000034C0
private void OnBreakpointStatusChanged(object sender, BreakpointEventArgs args)
{
Breakpoint breakpoint = args.Breakpoint;
PendingBreakpoint pendingBreakpoint;
if (this.TryGetPendingBreakpoint(args.Breakpoint, out pendingBreakpoint))
{
BreakEventStatus status = args.Breakpoint.GetStatus(this.session);
AD7BoundBreakpoint bound;
if (status == BreakEventStatus.Bound)
{
if (!BreakpointsAdapter.TryGetBoundBreakpoint(breakpoint, pendingBreakpoint, out bound))
{
bound = new AD7BoundBreakpoint(pendingBreakpoint, args.Breakpoint, this.process);
pendingBreakpoint.OnBreakpointBound(bound);
return;
}
}
else if (BreakpointsAdapter.TryGetBoundBreakpoint(breakpoint, pendingBreakpoint, out bound))
{
pendingBreakpoint.OnBreakpointUnbound(bound);
}
}
}
void OnBreakpointUpdated(object s, BreakpointEventArgs args)
{
Runtime.RunInMainThread(() => {
TreeIter it;
if (!store.GetIterFirst(out it))
{
return;
}
do
{
var bp = (BreakEvent)store.GetValue(it, (int)Columns.Breakpoint);
if (bp == args.Breakpoint)
{
string hitCount = bp.HitCountMode != HitCountMode.None ? bp.CurrentHitCount.ToString() : "";
string traceVal = (bp.HitAction & HitAction.PrintExpression) != HitAction.None ? bp.LastTraceValue : "";
store.SetValue(it, (int)Columns.HitCount, hitCount);
store.SetValue(it, (int)Columns.LastTrace, traceVal);
break;
}
} while (store.IterNext(ref it));
});
}
protected virtual void OnBreakpointHit(BreakpointEventArgs e)
{
BreakpointHit?.Invoke(this, e);
}
public void Breakpoint(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugBreakpoint pBreakpoint)
{
Log("Breakpoint hit.");
var domain = GetProcessWrapper(pAppDomain).GetAppDomain(pAppDomain);
var thread = domain.GetThread(pThread);
var breakpoint = domain.GetBreakpoint(pBreakpoint);
var eventArgs = new BreakpointEventArgs(domain, thread, breakpoint);
domain.DispatchBreakpointEvent(eventArgs);
FinalizeEvent(eventArgs);
}
private void BreakpointManager_Added(object sender, BreakpointEventArgs e)
{
WabbitcodeBreakpointManager.AddBreakpoint(new FilePath(FileName), e.Breakpoint.LineNumber);
}
private void DebuggerControlBreakpointToggled( object sender, BreakpointEventArgs e )
{
_codeCache.Invalidate( e.Breakpoint.Address );
}
private void OnBreakpointBindSucceeded(object sender, BreakpointEventArgs e)
{
IDebugPendingBreakpoint2 pendingBreakpoint;
var boundBreakpoint = _breakpointManager.GetBreakpoint(e.Breakpoint);
((IDebugBoundBreakpoint2)boundBreakpoint).GetPendingBreakpoint(out pendingBreakpoint);
Send(
new AD7BreakpointBoundEvent((AD7PendingBreakpoint)pendingBreakpoint, boundBreakpoint),
AD7BreakpointBoundEvent.IID,
null
);
}
private void _debuggee_PreBreakpoint(object sender, BreakpointEventArgs e)
{
BreakIfHandled(DebugTrigger.Breakpoint, e);
}
private void OnBreakpointBindFailed(object sender, BreakpointEventArgs e)
{
}
static DebugStatus HandleBp(object sender, BreakpointEventArgs e)
{
Console.WriteLine("Breakpoint hit");
return(DebugStatus.Go);
}
private void debuggerClient_BreakpointEvent(object sender, BreakpointEventArgs e)
{
//TODO: Change this to notify only the connection associatd with the script engine. (or that group?!)
Clients.All.breakpointHit(e.BreakpointEvent);
}
internal void HandleBreakpointEvent(BreakpointEventArgs e)
{
OnBreakpointHit(e);
}
private void Debugger_BreakpointHit(object sender, BreakpointEventArgs eventArgs)
{
m_bea = eventArgs;
}
private void _debuggee_Breakpoint(object sender, BreakpointEventArgs e)
{
HandleIfBroken(DebugTrigger.Breakpoint, e);
e.Status = DebugStatus.Go;
}
internal void DispatchBreakpointEvent(BreakpointEventArgs e)
{
OnPaused(e);
OnBreakpointHit(e);
}
protected virtual void OnBreakpointHit(BreakpointEventArgs e)
{
if (BreakpointHit != null)
BreakpointHit(this, e);
}
private void OnBreakpointBindFailed(object sender, BreakpointEventArgs e)
{
}
private void OnBreakpointBindSucceeded(object sender, BreakpointEventArgs e)
{
IDebugPendingBreakpoint2 pendingBreakpoint;
var boundBreakpoint = _breakpointManager.GetBreakpoint(e.Breakpoint);
((IDebugBoundBreakpoint2)boundBreakpoint).GetPendingBreakpoint(out pendingBreakpoint);
Send(
new AD7BreakpointBoundEvent((AD7PendingBreakpoint)pendingBreakpoint, boundBreakpoint),
AD7BreakpointBoundEvent.IID,
null
);
var breakpointHit = EngineBreakpointHit;
if (breakpointHit != null) {
breakpointHit(this, new AD7EngineEventArgs(this));
}
}
private void DebuggerControlBreakpointToggled(object sender, BreakpointEventArgs e)
{
_codeCache.Invalidate(e.Breakpoint.Address);
}
private void TargetObject_BreakpointHit(object sender, BreakpointEventArgs e)
{
OnBreakpointHit(e);
}