public CorDebugManagedCallback(DnDebugger dbg)
{
this.dbg = dbg;
}
public ILCodeBreakpointConditionContext(DnDebugger debugger, DnILCodeBreakpoint bp)
: base(debugger)
{
this.ILCodeBreakpoint = bp;
}
void DnDebugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e)
{
if (debugState?.dbg != dbg)
{
return;
}
switch (e.Kind)
{
case DebugCallbackKind.Breakpoint:
case DebugCallbackKind.StepComplete:
case DebugCallbackKind.Break:
case DebugCallbackKind.Exception:
case DebugCallbackKind.EvalComplete:
case DebugCallbackKind.EvalException:
case DebugCallbackKind.CreateProcess:
case DebugCallbackKind.ExitProcess:
case DebugCallbackKind.CreateThread:
case DebugCallbackKind.LoadClass:
case DebugCallbackKind.UnloadClass:
case DebugCallbackKind.DebuggerError:
case DebugCallbackKind.LogSwitch:
case DebugCallbackKind.CreateAppDomain:
case DebugCallbackKind.ExitAppDomain:
case DebugCallbackKind.LoadAssembly:
case DebugCallbackKind.UnloadAssembly:
case DebugCallbackKind.ControlCTrap:
case DebugCallbackKind.NameChange:
case DebugCallbackKind.UpdateModuleSymbols:
case DebugCallbackKind.EditAndContinueRemap:
case DebugCallbackKind.BreakpointSetError:
case DebugCallbackKind.FunctionRemapOpportunity:
case DebugCallbackKind.CreateConnection:
case DebugCallbackKind.ChangeConnection:
case DebugCallbackKind.DestroyConnection:
case DebugCallbackKind.ExceptionUnwind:
case DebugCallbackKind.FunctionRemapComplete:
case DebugCallbackKind.CustomNotification:
break;
case DebugCallbackKind.ExitThread:
if (outputLoggerSettings.ShowThreadExitMessages)
{
var etArgs = (ExitThreadDebugCallbackEventArgs)e;
int threadExitCode;
if (!NativeMethods.GetExitCodeThread(etArgs.CorThread?.Handle ?? IntPtr.Zero, out threadExitCode))
{
threadExitCode = -1;
}
textPane.WriteLine(BoxedTextColor.DebugLogExitThread,
string.Format(dnSpy_Debugger_Resources.DebugLogExitThread,
etArgs.CorThread?.ThreadId ?? 0,
threadExitCode));
}
break;
case DebugCallbackKind.LoadModule:
if (outputLoggerSettings.ShowModuleLoadMessages)
{
var lmArgs = (LoadModuleDebugCallbackEventArgs)e;
var module = dbg.Modules.FirstOrDefault(a => a.CorModule == lmArgs.CorModule);
Debug.Assert(module != null);
textPane.WriteLine(BoxedTextColor.DebugLogLoadModule,
string.Format(dnSpy_Debugger_Resources.DebugLogLoadModule,
GetProcessName(module?.Process),
GetRuntimeVersion(dbg),
module?.AppDomain?.Name ?? "???",
module?.Name));
}
break;
case DebugCallbackKind.UnloadModule:
if (outputLoggerSettings.ShowModuleUnloadMessages)
{
var ulmArgs = (UnloadModuleDebugCallbackEventArgs)e;
var module = dbg.Modules.FirstOrDefault(a => a.CorModule == ulmArgs.CorModule);
Debug.Assert(module != null);
textPane.WriteLine(BoxedTextColor.DebugLogUnloadModule,
string.Format(dnSpy_Debugger_Resources.DebugLogUnloadModule,
GetProcessName(module?.Process),
GetRuntimeVersion(dbg),
module?.AppDomain?.Name ?? "???",
module?.Name));
}
break;
case DebugCallbackKind.LogMessage:
if (outputLoggerSettings.ShowProgramOutputMessages)
{
var lmsgArgs = (LogMessageDebugCallbackEventArgs)e;
var msg = FilterUserMessage(lmsgArgs.Message);
textPane.Write(BoxedTextColor.DebugLogProgramOutput, msg);
}
break;
case DebugCallbackKind.Exception2:
if (outputLoggerSettings.ShowExceptionMessages)
{
var ex2Args = (Exception2DebugCallbackEventArgs)e;
CorValue exValue;
DnModule exModule;
CorModule module;
string exMsg;
switch (ex2Args.EventType)
{
case CorDebugExceptionCallbackType.DEBUG_EXCEPTION_FIRST_CHANCE:
case CorDebugExceptionCallbackType.DEBUG_EXCEPTION_USER_FIRST_CHANCE:
break;
case CorDebugExceptionCallbackType.DEBUG_EXCEPTION_CATCH_HANDLER_FOUND:
exValue = ex2Args.CorThread?.CurrentException;
module = ex2Args.CorFrame?.Function?.Module;
exModule = dbg.Modules.FirstOrDefault(a => a.CorModule == module);
textPane.WriteLine(BoxedTextColor.DebugLogExceptionHandled,
string.Format(dnSpy_Debugger_Resources.DebugLogExceptionHandled,
exValue?.ExactType?.ToString() ?? "???",
GetModuleName(exModule)));
exMsg = FilterUserMessage(GetExceptionMessage(exValue));
textPane.WriteLine(BoxedTextColor.DebugLogExceptionHandled,
string.Format(dnSpy_Debugger_Resources.DebugLogAdditionalInformation, exMsg));
break;
case CorDebugExceptionCallbackType.DEBUG_EXCEPTION_UNHANDLED:
exValue = ex2Args.CorThread?.CurrentException;
module = ex2Args.CorFrame?.Function?.Module;
exModule = dbg.Modules.FirstOrDefault(a => a.CorModule == module);
textPane.WriteLine(BoxedTextColor.DebugLogExceptionUnhandled,
string.Format(dnSpy_Debugger_Resources.DebugLogExceptionUnhandled,
exValue?.ExactType?.ToString() ?? "???",
GetModuleName(exModule)));
exMsg = FilterUserMessage(GetExceptionMessage(exValue));
textPane.WriteLine(BoxedTextColor.DebugLogExceptionUnhandled,
string.Format(dnSpy_Debugger_Resources.DebugLogAdditionalInformation, exMsg));
break;
default:
Debug.Fail("Unknown exception event type: " + ex2Args.EventType);
break;
}
}
break;
case DebugCallbackKind.MDANotification:
if (outputLoggerSettings.ShowMDAMessages)
{
var mdaArgs = (MDANotificationDebugCallbackEventArgs)e;
var mda = mdaArgs.CorMDA;
var corProcess = mdaArgs.CorProcess ?? mdaArgs.CorThread?.Process;
var process = dbg.Processes.FirstOrDefault(a => a.CorProcess == corProcess);
textPane.WriteLine(BoxedTextColor.DebugLogMDA,
string.Format(dnSpy_Debugger_Resources.DebugLogMDA,
mda.Name ?? "???",
GetProcessFullPath(process)));
textPane.WriteLine(BoxedTextColor.DebugLogMDA,
string.Format(dnSpy_Debugger_Resources.DebugLogAdditionalInformation, mda.Description ?? "???"));
}
break;
}
}
public BreakProcessHelper(DnDebugger debugger, BreakProcessKind type)
{
this.debugger = debugger ?? throw new ArgumentNullException(nameof(debugger));
this.type = type;
AddStartupBreakpoint();
}
protected override void OnDebugProcess(DnDebugger dnDebugger) => runtimeInfo = new DbgEngineRuntimeInfo(PredefinedDbgRuntimeGuids.DotNetCore_Guid, PredefinedDbgRuntimeKindGuids.DotNet_Guid, "CoreCLR", new DotNetCoreRuntimeId(dnDebugger.OtherVersion), runtimeTags);
public NativeCodeBreakpointConditionContext(DnDebugger debugger, DnNativeCodeBreakpoint bp)
: base(debugger)
{
NativeCodeBreakpoint = bp;
}
protected BreakpointConditionContext(DnDebugger debugger) {
Debugger = debugger;
}
public ILCodeBreakpointConditionContext(DnDebugger debugger, DnILCodeBreakpoint bp, BreakpointDebugCallbackEventArgs e)
: base(debugger)
{
ILCodeBreakpoint = bp;
E = e;
}
void CallOnProcessStateChanged(DnDebugger dbg) => CallOnProcessStateChanged(dbg ?? debugger, DebuggerEventArgs.Empty);
void InstallDebuggerHooks(DnDebugger dbg) => dbg.OnNameChanged += DnDebugger_OnNameChanged;
void UninstallDebuggerHooks(DnDebugger dbg) => dbg.OnNameChanged -= DnDebugger_OnNameChanged;
protected override void OnDebugProcess(DnDebugger dnDebugger) => runtimeInfo = new DbgEngineRuntimeInfo(PredefinedDbgRuntimeGuids.DotNetFramework_Guid, PredefinedDbgRuntimeKindGuids.DotNet_Guid, "CLR " + dnDebugger.DebuggeeVersion, new DotNetFrameworkRuntimeId(dnDebugger.DebuggeeVersion), runtimeTags);
protected BreakpointConditionContext(DnDebugger debugger) => Debugger = debugger;
public ThreadPrinter(ITextColorWriter output, bool useHex, DnDebugger dbg)
{
this.output = output;
this.useHex = useHex;
this.dbg = dbg;
}
public AnyDebugEventBreakpointConditionContext(DnDebugger debugger, DnAnyDebugEventBreakpoint bp, DebugCallbackEventArgs e)
: base(debugger)
{
AnyDebugEventBreakpoint = bp;
EventArgs = e;
}
public static void Initialize(DnDebugger debugger) => new DisableSystemDebuggerDetection(debugger);
public StackFramesUpdatedEventArgs(DnDebugger debugger)
{
this.Debugger = debugger;
}
DisableSystemDebuggerDetection(DnDebugger debugger)
{
debugger.DebugCallbackEvent += DnDebugger_DebugCallbackEvent;
}
void DnDebugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e) {
string msg;
DbgModule module;
switch (e.Kind) {
case DebugCallbackKind.CreateProcess:
var cp = (CreateProcessDebugCallbackEventArgs)e;
hProcess_debuggee = Native.NativeMethods.OpenProcess(Native.NativeMethods.PROCESS_QUERY_LIMITED_INFORMATION, false, (uint)(cp.CorProcess?.ProcessId ?? -1));
SendMessage(new DbgMessageConnected((uint)cp.CorProcess.ProcessId, GetMessageFlags()));
e.AddPauseReason(DebuggerPauseReason.Other);
break;
case DebugCallbackKind.CreateAppDomain:
// CreateProcess is too early, we must do this when the AppDomain gets created
if (!clrDacInitd) {
clrDacInitd = true;
var p = dnDebugger.Processes.FirstOrDefault();
if (p != null)
clrDac = clrDacProvider.Create(p.ProcessId, dnDebugger.CLRPath, this);
}
break;
case DebugCallbackKind.Exception2:
var e2 = (Exception2DebugCallbackEventArgs)e;
DbgExceptionEventFlags exFlags;
if (e2.EventType == CorDebugExceptionCallbackType.DEBUG_EXCEPTION_FIRST_CHANCE)
exFlags = DbgExceptionEventFlags.FirstChance;
else if (e2.EventType == CorDebugExceptionCallbackType.DEBUG_EXCEPTION_UNHANDLED) {
exFlags = DbgExceptionEventFlags.SecondChance | DbgExceptionEventFlags.Unhandled;
isUnhandledException = true;
}
else
break;
// Ignore exceptions when evaluating except if it's an unhandled exception, those must always be reported
if (dbg.IsEvaluating && e2.EventType != CorDebugExceptionCallbackType.DEBUG_EXCEPTION_UNHANDLED)
break;
module = TryGetModule(e2.CorFrame, e2.CorThread);
var exObj = e2.CorThread?.CurrentException;
var reflectionAppDomain = module?.GetReflectionModule().AppDomain;
DbgDotNetValueImpl dnExObj = null;
try {
if (exObj != null && reflectionAppDomain != null)
dnExObj = CreateDotNetValue_CorDebug(exObj, reflectionAppDomain, tryCreateStrongHandle: false) as DbgDotNetValueImpl;
objectFactory.CreateException(new DbgExceptionId(PredefinedExceptionCategories.DotNet, TryGetExceptionName(dnExObj) ?? "???"), exFlags, TryGetExceptionMessage(dnExObj), TryGetThread(e2.CorThread), module, GetMessageFlags());
e.AddPauseReason(DebuggerPauseReason.Other);
}
finally {
dnExObj?.Dispose();
}
break;
case DebugCallbackKind.MDANotification:
if (dbg.IsEvaluating)
break;
var mdan = (MDANotificationDebugCallbackEventArgs)e;
objectFactory.CreateException(new DbgExceptionId(PredefinedExceptionCategories.MDA, mdan.CorMDA?.Name ?? "???"), DbgExceptionEventFlags.FirstChance, mdan.CorMDA?.Description, TryGetThread(mdan.CorThread), TryGetModule(null, mdan.CorThread), GetMessageFlags());
e.AddPauseReason(DebuggerPauseReason.Other);
break;
case DebugCallbackKind.LogMessage:
if (dbg.IsEvaluating)
break;
var lmsgArgs = (LogMessageDebugCallbackEventArgs)e;
msg = lmsgArgs.Message;
if (msg != null) {
e.AddPauseReason(DebuggerPauseReason.Other);
var thread = TryGetThread(lmsgArgs.CorThread);
SendMessage(new DbgMessageProgramMessage(msg, thread, GetMessageFlags()));
}
break;
case DebugCallbackKind.LoadClass:
var lcArgs = (LoadClassDebugCallbackEventArgs)e;
var cls = lcArgs.CorClass;
Debug.Assert(cls != null);
if (cls != null) {
var dnModule = dbg.TryGetModule(lcArgs.CorAppDomain, cls);
if (dnModule.IsDynamic) {
UpdateDynamicModuleIds(dnModule);
module = TryGetModule(dnModule.CorModule);
Debug.Assert(module != null);
if (module != null)
dbgModuleMemoryRefreshedNotifier.RaiseModulesRefreshed(new[] { module });
if (dnModule?.CorModuleDef != null && module != null) {
if (TryGetModuleData(module, out var data))
data.OnLoadClass();
ClassLoaded?.Invoke(this, new ClassLoadedEventArgs(module, cls.Token));
}
GetDynamicModuleHelper(dnModule).RaiseTypeLoaded(new DmdTypeLoadedEventArgs((int)cls.Token));
}
}
break;
case DebugCallbackKind.DebuggerError:
var deArgs = (DebuggerErrorDebugCallbackEventArgs)e;
if (deArgs.HError == CordbgErrors.CORDBG_E_UNCOMPATIBLE_PLATFORMS)
msg = GetIncompatiblePlatformErrorMessage();
else
msg = string.Format(dnSpy_Debugger_DotNet_CorDebug_Resources.Error_CLRDebuggerErrorOccurred, deArgs.HError, deArgs.ErrorCode);
SendMessage(new DbgMessageBreak(msg, GetMessageFlags(pause: true)));
break;
}
}
void UninstallDebuggerHooks(DnDebugger dbg)
{
dbg.OnModuleAdded -= DnDebugger_OnModuleAdded;
dbg.OnNameChanged -= DnDebugger_OnNameChanged;
}
public AnyDebugEventBreakpointConditionContext(DnDebugger debugger, DnAnyDebugEventBreakpoint bp, DebugCallbackEventArgs e)
: base(debugger) {
this.bp = bp;
this.e = e;
}
internal DnEval(DnDebugger debugger, IDebugMessageDispatcher debugMessageDispatcher)
{
this.debugger = debugger;
this.debugMessageDispatcher = debugMessageDispatcher;
this.suspendOtherThreads = true;
}
