public void Attach(MDbgProcess process)
{
process.PostDebugEvent +=
(sender, e) =>
{
log.Log(e.CallbackType.ToString());
if (e.CallbackType == ManagedCallbackType.OnException2)
{
var ce = (CorException2EventArgs)e.CallbackArgs;
if (ce.EventType == CorDebugExceptionCallbackType.DEBUG_EXCEPTION_FIRST_CHANCE)
{
var thread = process.Threads.Lookup(ce.Thread);
foreach (var frame in thread.Frames)
{
if (!frame.IsManaged || frame.Function.FullName.StartsWith("System."))
{
break;
}
log.Log("{0}({1})", frame.Function.FullName, string.Join(", ", frame.Function.GetArguments(frame).Select(
arg => string.Format("{0} = {1}", arg.Name, arg.GetStringValue(false)))));
}
}
}
};
}
public void AnalyseExecutionPosition()
{
if (!shell.Debugger.Processes.HaveActive)
{
ReportDebugTermination();
return; // don't try to display current location
}
else
{
if (lastActiveprocess == null)
{
shell.Debugger.Processes.Active.PostDebugEvent += OnPostDebugEvent;
lastActiveprocessId = shell.Debugger.Processes.Active.CorProcess.Id;
MessageQueue.AddNotification(NppCategory.Process + lastActiveprocessId + ":STARTED");
lastActiveprocess = shell.Debugger.Processes.Active;
}
try
{
ReportCurrentState();
ReportWatch();
}
catch
{
}
}
}
// O2.Debugger.Mdbg.OriginalMdbgCode.mdbg.mdbgCommandsCustomizedForO2
// , O2Thread.FuncVoid<string> o2Callback)
public static bool AttachCmd(string arguments, O2Thread.FuncVoidT1 <string> o2Callback)
{
try
{
var ap = new ArgParser(arguments);
if (ap.Count > 1)
{
DI.log.error("in AttachCmd: Wrong # of arguments.");
return(false);
}
if (!ap.Exists(0))
{
DI.log.error("in AttachCmd: Please choose some process to attach");
MdbgCommands.ProcessEnumCmd("");
return(false);
}
int pid = ap.AsInt(0);
if (Process.GetCurrentProcess().Id == pid)
{
DI.log.error("in AttachCmd: Cannot attach to myself!");
return(false);
}
MDbgProcess p = CommandBase.Debugger.Attach(pid);
p.Go().WaitOne();
return(true);
}
catch (Exception ex)
{
DI.log.ex(ex, "in AttachCmd");
return(false);
}
}
// Return class as a string.
/// <summary>
/// Creates a string representation of CorType.
/// </summary>
/// <param name="proc">A debugged process.</param>
/// <param name="ct">A CorType object representing a type in the debugged process.</param>
/// <returns>String representaion of the passed in type.</returns>
public static string PrintCorType(MDbgProcess proc, CorType ct)
{
var sb = new StringBuilder();
PrintCorType(sb, proc, ct);
return(sb.ToString());
}
/// <summary>
/// Creates a new instance of the MDbgValue Object.
/// This constructor is public so that applications can use this class to print values (CorValue).
/// CorValue's can be returned for example by funceval(CorEval.Result).
/// </summary>
/// <param name="process">The Process that will own the Value.</param>
/// <param name="value">The CorValue that this MDbgValue will start with.</param>
public MDbgValue(MDbgProcess process, CorDebug.CorValue value)
{
// value can be null, but we should always know what process we are
// looking at.
Debug.Assert(process != null);
Initialize(process, null, value);
}
public void StartProcess()
{
Debugger.Options.StopOnLogMessage = false;
if (options.PID != 0)
{
string clrVersion = string.IsNullOrEmpty(options.CLRVersion) ? MdbgVersionPolicy.GetDefaultAttachVersion(options.PID) : options.CLRVersion;
Process = Debugger.Attach(options.PID, null, clrVersion);
WriteLine("Attached to " + options.PID);
Process.Go().WaitOne();
}
else if (!string.IsNullOrEmpty(options.Executable))
{
var clrVersion = MdbgVersionPolicy.GetDefaultLaunchVersion(options.Executable);
Process = Debugger.Processes.CreateLocalProcess(new CorDebugger(clrVersion));
if (Process == null)
{
throw new Exception("Could not create debugging interface for runtime version " + clrVersion);
}
Process.DebugMode = DebugModeFlag.Debug;
Process.CreateProcess(options.Executable, configuration.arguments != null ? configuration.arguments : "");
Process.Go().WaitOne();
}
else
{
WriteLine(options.GetUsage());
return;
}
Console.CancelKeyPress += OnAbort;
}
} // refresh
void EvalWatch(MDbgProcess proc)
{
Console.WriteLine("-------------------");
try
{
//public class Test { public int MyProp { get; set; } }
//...
//var t = new Test();
//t.MyProp = 9;
string expression = "t.MyProp";
expression = "printer";
//expression = "d";
MDbgValue value = proc.ResolveVariable(expression, proc.Threads.Active.CurrentFrame);
if (value != null)
{
//Console.WriteLine(expression + ": " + value.InvokeToString());
//Console.WriteLine(expression + ": " + value.InvokeMethod("Test").InvokeToString());
Console.WriteLine(expression + ": " + value.InvokeMethod("Ping"));
//Console.WriteLine(expression + ": " + value.InvokeMethod("Who").InvokeToString());
//Console.WriteLine(expression + ": " + value.InvokeMethod("Who1").InvokeToString());
//Console.WriteLine(expression + ": " + value.GetStringValue(false));
}
Console.WriteLine("#################");
}
catch
{
//expressionValue = "<items/>";
Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
Console.WriteLine("-------------------");
}
private static void Main(string[] args)
{
MDbgProcess proc = null;
try
{
int processId = Int32.Parse(args[0]);
MDbgEngine debugger = new MDbgEngine();
proc = debugger.Attach(processId);
InitializeMdbg(debugger, proc);
DumpThreads(proc);
}
catch
{
PrintUsage();
}
finally
{
if (proc != null)
{
// We always want to detach from target.
proc.Detach().WaitOne();
}
}
}
/// <summary>
/// Creates a default 'source level step' on process with current active frame and active thread.
/// </summary>
/// <param name="process">non-null process </param>
/// <param name="type">type of step (in, out, over)</param>
/// <param name="singleStepInstructions">false to step source level, true to step single instructions</param>
/// <returns></returns>
public static StepperDescriptor CreateSourceLevelStep(MDbgProcess process, StepperType type, bool singleStepInstructions)
{
StepperDescriptor s = new StepperDescriptor(process);
s.StepperType = type;
//
// Handle Step-out case.
//
if (type == StepperType.Out)
{
return(s);
}
//
// Handle step-over / step-in case
//
bool stepInto = (type == StepperType.In);
// Cache current
s.Thread = process.Threads.Active.CorThread;
s.Frame = s.Thread.ActiveFrame;
CorDebugMappingResult mappingResult;
uint ip;
if (!singleStepInstructions)
{
// For source-level stepping, skip some interceptors. These are random, and cause
// random differences in stepping across different runtimes; and user generally don't care
// about interceptors.
// It's actually a debatable policy about which interceptors to skip and stop on.
s.InterceptMask = CorDebugIntercept.INTERCEPT_ALL &
~(CorDebugIntercept.INTERCEPT_SECURITY | CorDebugIntercept.INTERCEPT_CLASS_INIT);
}
s.Frame.GetIP(out ip, out mappingResult);
if (singleStepInstructions ||
(mappingResult != CorDebugMappingResult.MAPPING_EXACT &&
mappingResult != CorDebugMappingResult.MAPPING_APPROXIMATE))
{
// Leave step ranges null
}
else
{
// Getting the step ranges is what really makes this a source-level step.
MDbgFunction f = process.Modules.LookupFunction(s.Frame.Function);
COR_DEBUG_STEP_RANGE[] sr = f.GetStepRangesFromIP((int)ip);
if (sr != null)
{
s.SetStepRanges(sr, true);
}
else
{
// Leave step ranges null.
}
}
return(s);
}
public void Attach(MDbgProcess process)
{
//foreach (MDbgModule module in process.Modules)
// module.
//process.SymbolPath =
}
private static void DumpThreads(MDbgProcess proc)
{
foreach (MDbgThread thread in (IEnumerable)proc.Threads)
{
DumpThread(thread);
}
}
private void WriteMdbgPrompt(bool processStopped)
{
string s;
if (processStopped)
{
MDbgProcess p = null;
if (m_shell.Debugger.Processes.HaveActive)
{
p = m_shell.Debugger.Processes.Active;
if (p.Threads.HaveActive)
{
s = "[p#:" + p.Number + ", t#:" + p.Threads.Active.Number + "] ";
}
else
{
s = "[p#:" + p.Number + ", t#:no active thread] ";
}
}
else
{
s = "";
}
}
else
{
s = "[process running] ";
}
Console.Write(s + TEXT_PROMPT_STRING);
}
string GetCurrentSourcePosition()
{
if (!shell.Debugger.Processes.HaveActive)
{
return(null);
}
MDbgProcess process = shell.Debugger.Processes.Active;
if (process.IsRunning)
{
return(null);
}
if (!process.Threads.Active.HaveCurrentFrame)
{
return(null); //No frame for current thread #" + thread.Number);
}
if (!process.Threads.Active.CurrentFrame.IsInfoOnly)
{
return(FormatSourcePosition(process.Threads.Active.CurrentFrame));
}
else
{
return(null);
}
}
internal MDbgModule(MDbgProcess process, CorModule managedModule, int number)
{
Debug.Assert(process != null && managedModule != null);
m_process = process;
m_module = managedModule;
m_functions = new MDbgFunctionMgr(this);
m_number = number;
}
internal MDbgAppDomain(MDbgProcess process, CorDebug.CorAppDomain appDomain, int number)
{
Debug.Assert(process != null);
Debug.Assert(appDomain != null);
m_process = process;
m_appDomain = appDomain;
m_number = number;
}
/// <summary>
/// Creates an empty stepper.
/// </summary>
/// <param name="process">non-null process that this is stepping</param>
public StepperDescriptor(MDbgProcess process)
{
if (process == null)
{
throw new ArgumentNullException("process");
}
m_process = process;
}
public static CorValue CreateCorValue(this MDbgProcess process, string value)
{
CorEval eval = process.Threads.Active.CorThread.CreateEval();
eval.NewString(value);
process.Go().WaitOne();
return((process.StopReason as EvalCompleteStopReason).Eval.Result);
}
private void Cleanup()
{
MDbgProcess active = Debugger.Processes.Active;
active.Breakpoints.DeleteAll();
active.CorProcess.Stop(0);
active.Detach();
}
//////////////////////////////////////////////////////////////////////////////////
//
// Controlling Commands
//
//////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// creates a new debugged process.
/// </summary>
/// <param name="commandLine">The command to run.</param>
/// <param name="commandArguments">The arguments for the command.</param>
/// <param name="debugMode">The debug mode to run with.</param>
/// <param name="deeVersion">The version of debugging interfaces that should be used for
/// debuging of the started program. If this value is null, the default (latest) version
/// of interface is used.
/// </param>
/// <returns>The resulting MDbgProcess.</returns>
public MDbgProcess CreateProcess(string commandLine, string commandArguments,
DebugModeFlag debugMode, string deeVersion)
{
MDbgProcess p = m_processMgr.CreateLocalProcess(deeVersion);
p.DebugMode = debugMode;
p.CreateProcess(commandLine, commandArguments);
return(p);
}
/// <summary>
/// Attach to a process with the given Process ID
/// Only debug the specified CLR version; all others are ignored.
/// </summary>
/// <param name="processId">The Process ID to attach to.</param>
/// <param name="attachContinuationEvent">A OS event handle which must be set to unblock the debuggee
/// when first continuing from attach</param>
/// <param name="version">The version string for the CLR instance to debug.</param>
/// <returns>The resulting MDbgProcess.</returns>
public MDbgProcess Attach(int processId,
Microsoft.Samples.Debugging.Native.SafeWin32Handle attachContinuationEvent,
string version)
{
Debug.Assert(version != null);
MDbgProcess p = m_processMgr.CreateLocalProcess(new CorDebugger(version));
p.Attach(processId, attachContinuationEvent);
return(p);
}
/// <summary>
/// Acts on debugger callback based on the contained stop option policies matching
/// the callback type.
/// </summary>
/// <param name="currentProcess">Current MDbgProcess.</param>
/// <param name="args">Debugger callback arguments.</param>
public void ActOnCallback(MDbgProcess currentProcess, CustomPostCallbackEventArgs args)
{
if (m_stopOptions[(int)args.CallbackType] != null)
{
foreach (MDbgStopOptionPolicy sop in m_stopOptions[(int)args.CallbackType])
{
sop.ActOnCallback(currentProcess, args);
}
}
}
void ReportDebugTermination()
{
if (lastActiveprocess != null)
{
MessageQueue.AddNotification(NppCategory.Process + lastActiveprocessId + ":STOPPED");
MessageQueue.AddCommand(NppCommand.Exit); //to close all communication channels
lastActiveprocess = null;
lastActiveprocessId = 0;
}
}
/// <summary>
/// Acts on the debugger callback, based on the stop option policy settings and the
/// type of exception thrown.
/// </summary>
/// <param name="currentProcess">Current MDbgProcess.</param>
/// <param name="args">Callback arguments.</param>
public override void ActOnCallback(MDbgProcess currentProcess, CustomPostCallbackEventArgs args)
{
var ea = args.CallbackArgs as CorException2EventArgs;
var ua = args.CallbackArgs as CorExceptionUnwind2EventArgs;
bool bException2 = (ea != null);
if (m_exceptionEnhancedOn ||
(bException2 && (ea.EventType == CorDebugExceptionCallbackType.DEBUG_EXCEPTION_FIRST_CHANCE)))
{
MDbgThread currentThread = null;
currentThread =
currentProcess.Threads.GetThreadFromThreadId((args.CallbackArgs as CorThreadEventArgs).Thread.Id);
string exceptionType = currentThread.CurrentException.TypeName;
switch (DetermineBehavior(exceptionType))
{
case DebuggerBehavior.Stop:
if (bException2)
{
args.Controller.Stop(ea.Thread, new ExceptionThrownStopReason(ea.AppDomain,
ea.Thread, ea.Frame, ea.Offset,
ea.EventType, ea.Flags,
m_exceptionEnhancedOn));
}
else
{
args.Controller.Stop(ua.Thread, new ExceptionUnwindStopReason(ua.AppDomain,
ua.Thread, ua.EventType,
ua.Flags));
}
break;
case DebuggerBehavior.Log:
CommandBase.WriteOutput("Exception thrown: " + currentThread.CurrentException.TypeName +
" at function " + currentThread.CurrentFrame.Function.FullName +
" in source file " + currentThread.CurrentSourcePosition.Path +
":" + currentThread.CurrentSourcePosition.Line);
if (m_exceptionEnhancedOn)
{
if (bException2)
{
CommandBase.WriteOutput("Event type: " + ea.EventType);
}
else
{
CommandBase.WriteOutput("Event type: " + ua.EventType);
}
}
CommandBase.WriteOutput("");
break;
}
}
}
private static void InitializeMdbg(MDbgEngine debugger, MDbgProcess proc)
{
bool stopOnNewThread = debugger.Options.StopOnNewThread;
debugger.Options.StopOnNewThread = false;
proc.Go().WaitOne();
debugger.Options.StopOnNewThread = true;
while (proc.CorProcess.HasQueuedCallbacks(null))
{
proc.Go().WaitOne();
}
debugger.Options.StopOnNewThread = stopOnNewThread;
}
public Mdbg()
{
process = engine.Processes.CreateLocalProcess();
string cmd = ServiceHost.Discovery.NetRuntimeSDK;
if (cmd == null)
{
return;
}
reader = new Thread(new ThreadStart(ReaderLoop));
reader.Name = "Cordbg reader";
reader.Start();
}
// Helper to append generic args from tyenum in pretty format.
// This will add a string like '<int, Foo<string>>'
internal static void AddGenericArgs(StringBuilder sb, MDbgProcess proc, IEnumerable tyenum)
{
int i = 0;
foreach (CorType t1 in tyenum)
{
sb.Append((i == 0) ? '<' : ',');
PrintCorType(sb, proc, t1);
i++;
}
if (i > 0)
{
sb.Append('>');
}
}
private static void SetBreakPoint(MDbgProcess process)
{
if (process.Breakpoints.Count == 0)
{
try
{
var module = process.Modules.Lookup(Assembly.GetExecutingAssembly().Location);
var document = module.SymReader.GetDocuments().Single(d => Path.GetFileName(d.URL) == "Program.Debugee.cs");
var breakpoint = process.Breakpoints.CreateBreakpoint(document.URL, 77);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
}
/// <summary>
/// Acts on the current callback, based on the current debugger behavior for this stop
/// option policy.
/// </summary>
/// <param name="currentProcess">Current MDbgProcess.</param>
/// <param name="args">Callback arguments.</param>
public override void ActOnCallback(MDbgProcess currentProcess, CustomPostCallbackEventArgs args)
{
var eventArgs = args.CallbackArgs as CorEventArgs;
switch (m_behavior)
{
case DebuggerBehavior.Stop:
args.Controller.Stop(eventArgs.Thread,
MDbgUtil.CreateStopReasonFromEventArgs(eventArgs, currentProcess));
break;
case DebuggerBehavior.Log:
CommandBase.WriteOutput(eventArgs + "\n");
break;
}
}
// Helper to append generic args from tyenum in pretty format.
// This will add a string like '<int, Foo<string>>'
internal static void AddGenericArgs(StringBuilder sb, MDbgProcess proc, IEnumerable tyenum)
{
int i = 0;
foreach (CorType t1 in tyenum)
{
sb.Append((i == 0) ? '<' : ',');
InternalUtil.PrintCorType(sb, proc, t1);
i++;
}
if (i > 0)
{
sb.Append('>');
//System.Collections.Generic.List`1 //zos; CSScript.Npp related changes
sb.Replace("`" + i, "");
}
}
//////////////////////////////////////////////////////////////////////////////////
//
// Controlling Commands
//
//////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// creates a new debugged process.
/// </summary>
/// <param name="commandLine">The command to run.</param>
/// <param name="commandArguments">The arguments for the command.</param>
/// <param name="debugMode">The debug mode to run with.</param>
/// <param name="deeVersion">The version of debugging interfaces that should be used for
/// debugging of the started program. If this value is null, the default (latest) version
/// of interface is used.
/// </param>
/// <returns>The resulting MDbgProcess.</returns>
public MDbgProcess CreateProcess(string commandLine, string commandArguments,
DebugModeFlag debugMode, string deeVersion)
{
CorDebugger debugger;
if (deeVersion == null)
{
debugger = new CorDebugger(CorDebugger.GetDefaultDebuggerVersion());
}
else
{
debugger = new CorDebugger(deeVersion);
}
MDbgProcess p = m_processMgr.CreateLocalProcess(debugger);
p.DebugMode = debugMode;
p.CreateProcess(commandLine, commandArguments);
return(p);
}