internal void StartDebugging()
{
if (_vm != null)
{
return;
}
_vm = VirtualMachineManager.Connect(new IPEndPoint(_ipAddress, 11000));
_vm.EnableEvents(EventType.AssemblyLoad,
EventType.ThreadStart,
EventType.ThreadDeath,
EventType.AssemblyUnload,
EventType.UserBreak,
EventType.Exception,
EventType.UserLog,
EventType.KeepAlive,
EventType.TypeLoad);
EventSet set = _vm.GetNextEventSet();
if (set.Events.OfType <VMStartEvent>().Any())
{
//TODO: review by techcap
_mainThread = new AD7Thread(_engine, new DebuggedThread(set.Events[0].Thread, _engine));
_engine.Callback.ThreadStarted(_mainThread);
Task.Factory.StartNew(ReceiveThread, TaskCreationOptions.LongRunning);
}
else
{
throw new Exception("Didnt get VMStart-Event!");
}
}
public AD7StackFrame(AD7Engine engine, AD7Thread thread, ThreadContext threadContext)
{
Debug.Assert(threadContext != null, "ThreadContext is null");
Engine = engine;
Thread = thread;
ThreadContext = threadContext;
_textPosition = threadContext.TextPosition;
_functionName = threadContext.Function;
if (threadContext.pc.HasValue)
{
_codeCxt = new AD7MemoryAddress(this.Engine, threadContext.pc.Value, _functionName);
}
if (_textPosition != null)
{
_documentCxt = new AD7DocumentContext(_textPosition, _codeCxt);
if (_codeCxt != null)
{
_codeCxt.SetDocumentContext(_documentCxt);
}
}
}
// Continue is called from the SDM when it wants execution to continue in the debugee
// but have stepping state remain. An example is when a tracepoint is executed,
// and the debugger does not want to actually enter break mode.
public int Continue(IDebugThread2 pThread)
{
// VS Code currently isn't providing a thread Id in certain cases. Work around this by handling null values.
AD7Thread thread = pThread as AD7Thread;
try
{
if (_pollThread.IsPollThread())
{
_debuggedProcess.Continue(thread?.GetDebuggedThread());
}
else
{
_pollThread.RunOperation(() => _debuggedProcess.Continue(thread?.GetDebuggedThread()));
}
}
catch (InvalidCoreDumpOperationException)
{
return(AD7_HRESULT.E_CRASHDUMP_UNSUPPORTED);
}
catch (Exception e)
{
_engineCallback.OnError(EngineUtils.GetExceptionDescription(e));
return(Constants.E_ABORT);
}
return(Constants.S_OK);
}
public int Step(IDebugThread2 pThread, enum_STEPKIND kind, enum_STEPUNIT unit)
{
AD7Thread thread = (AD7Thread)pThread;
try
{
if (null == thread || null == thread.GetDebuggedThread())
{
return(Constants.E_FAIL);
}
_debuggedProcess.WorkerThread.RunOperation(() => _debuggedProcess.Step(thread.GetDebuggedThread().Id, kind, unit));
}
catch (InvalidCoreDumpOperationException)
{
return(AD7_HRESULT.E_CRASHDUMP_UNSUPPORTED);
}
catch (Exception e)
{
_engineCallback.OnError(EngineUtils.GetExceptionDescription(e));
return(Constants.E_ABORT);
}
return(Constants.S_OK);
}
public void OnLoadComplete(DebuggedThread thread)
{
AD7Thread ad7Thread = (AD7Thread)thread.Client;
AD7LoadCompleteEvent eventObject = new AD7LoadCompleteEvent();
Send(eventObject, AD7LoadCompleteEvent.IID, ad7Thread);
}
public AD7StackFrame(AD7Engine engine, AD7Thread thread, ThreadContext threadContext)
{
Debug.Assert(threadContext != null, "ThreadContext is null");
Engine = engine;
Thread = thread;
ThreadContext = threadContext;
_textPosition = threadContext.TextPosition;
_functionName = threadContext.Function;
if (threadContext.pc.HasValue)
{
_codeCxt = new AD7MemoryAddress(this.Engine, threadContext.pc.Value, _functionName);
}
if (_textPosition != null)
{
_documentCxt = new AD7DocumentContext(_textPosition, _codeCxt);
if (_codeCxt != null)
{
_codeCxt.SetDocumentContext(_documentCxt);
}
}
}
// ExecuteOnThread is called when the SDM wants execution to continue and have
// stepping state cleared.
public int ExecuteOnThread(IDebugThread2 pThread)
{
AD7Thread thread = (AD7Thread)pThread;
_pollThread.RunOperation(() => _debuggedProcess.Execute(thread.GetDebuggedThread()));
return(Constants.S_OK);
}
// Exception events are sent when an exception occurs in the debuggee that the debugger was not expecting.
public void OnException(DebuggedThread thread, string name, string description, uint code)
{
AD7ExceptionEvent eventObject = new AD7ExceptionEvent(name, description, code);
AD7Thread ad7Thread = (AD7Thread)thread.Client;
Send(eventObject, AD7ExceptionEvent.IID, ad7Thread);
}
public int Step(IDebugThread2 pThread, enum_STEPKIND kind, enum_STEPUNIT unit)
{
AD7Thread thread = (AD7Thread)pThread;
_debuggedProcess.WorkerThread.RunOperation(() => _debuggedProcess.Step(thread.GetDebuggedThread().Id, kind, unit));
return(Constants.S_OK);
}
// Exception events are sent when an exception occurs in the debuggee that the debugger was not expecting.
public void OnException(DebuggedThread thread, string name, string description, uint code, Guid?exceptionCategory = null, ExceptionBreakpointState state = ExceptionBreakpointState.None)
{
AD7ExceptionEvent eventObject = new AD7ExceptionEvent(name, description, code, exceptionCategory, state);
AD7Thread ad7Thread = (AD7Thread)thread.Client;
Send(eventObject, AD7ExceptionEvent.IID, ad7Thread);
}
public void OnStepComplete(DebuggedThread thread)
{
// Step complete is sent when a step has finished
AD7StepCompleteEvent eventObject = new AD7StepCompleteEvent();
AD7Thread ad7Thread = (AD7Thread)thread.Client;
Send(eventObject, AD7StepCompleteEvent.IID, ad7Thread);
}
public DebuggedThread(ThreadMirror thread, AD7Engine engine)
{
Thread = thread;
Id = thread.TID;
Name = "";
TargetId = thread.TID;
AD7Thread ad7Thread = new AD7Thread(engine, this);
Client = ad7Thread;
}
// Continue is called from the SDM when it wants execution to continue in the debugee
// but have stepping state remain. An example is when a tracepoint is executed,
// and the debugger does not want to actually enter break mode.
public int Continue(IDebugThread2 pThread)
{
// VS Code currently isn't providing a thread Id in certain cases. Work around this by handling null values.
AD7Thread thread = pThread as AD7Thread;
_pollThread.RunOperation(() => _debuggedProcess.Continue(thread?.GetDebuggedThread()));
return(Constants.S_OK);
}
public DebuggedThread(ThreadMirror thread, AD7Engine engine)
{
Thread = thread;
Id = thread.TID;
Name = "";
TargetId = thread.TID;
AD7Thread ad7Thread = new AD7Thread(engine, this);
Client = ad7Thread;
}
public void OnAsyncBreakComplete(DebuggedThread thread)
{
// This will get called when the engine receives the breakpoint event that is created when the user
// hits the pause button in vs.
Debug.Assert(_engine.DebuggedProcess.WorkerThread.IsPollThread());
AD7Thread ad7Thread = (AD7Thread)thread.Client;
AD7AsyncBreakCompleteEvent eventObject = new AD7AsyncBreakCompleteEvent();
Send(eventObject, AD7AsyncBreakCompleteEvent.IID, ad7Thread);
}
// Continue is called from the SDM when it wants execution to continue in the debugee
// but have stepping state remain. An example is when a tracepoint is executed,
// and the debugger does not want to actually enter break mode.
public int Continue(IDebugThread2 pThread)
{
AD7Thread thread = (AD7Thread)pThread;
_pollThread.RunOperation(new Operation(delegate
{
_debuggedProcess.Continue(thread.GetDebuggedThread());
}));
return(Constants.S_OK);
}
public void OnThreadExit(DebuggedThread debuggedThread, uint exitCode)
{
Debug.Assert(_engine.DebuggedProcess.WorkerThread.IsPollThread());
AD7Thread ad7Thread = (AD7Thread)debuggedThread.Client;
Debug.Assert(ad7Thread != null);
AD7ThreadDestroyEvent eventObject = new AD7ThreadDestroyEvent(exitCode);
Send(eventObject, AD7ThreadDestroyEvent.IID, ad7Thread);
}
//This method gets the value/type info for the method parameters without creating an MI debugger varialbe for them. For use in the callstack window
//NOTE: eval is not called
public async Task <List <SimpleVariableInformation> > GetParameterInfoOnly(AD7Thread thread, ThreadContext ctx)
{
List <SimpleVariableInformation> parameters = new List <SimpleVariableInformation>();
ValueListValue localAndParameters = await MICommandFactory.StackListVariables(PrintValues.SimpleValues, thread.Id, ctx.Level);
foreach (var results in localAndParameters.Content.Where(r => r.TryFindString("arg") == "1"))
{
parameters.Add(new SimpleVariableInformation(results.FindString("name"), /*isParam*/ true, results.FindString("value"), results.FindString("type")));
}
return(parameters);
}
private VariableInformation(ThreadContext ctx, AD7Engine engine, AD7Thread thread)
{
_engine = engine;
_debuggedProcess = _engine.DebuggedProcess;
_ctx = ctx;
Client = thread;
IsParameter = false;
IsChild = false;
_attribsFetched = false;
Access = enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_NONE;
_fullname = null;
}
//internal void Resume()
//{
// _vm.Resume();
//}
/// <summary>
/// For Run
/// </summary>
/// <param name="thread"></param>
internal void Execute(AD7Thread thread)
{
DebugHelper.TraceEnteringMethod();
try
{
ResumeVM();
}
catch (Exception)
{
// TODO
throw;
}
}
internal void Step(AD7Thread thread, enum_STEPKIND sk, enum_STEPUNIT stepUnit)
{
DebugHelper.TraceEnteringMethod();
if (!_isStepping)
{
if (currentStepRequest == null)
{
currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror);
}
else
{
currentStepRequest.Disable();
}
_isStepping = true;
if (stepUnit == enum_STEPUNIT.STEP_LINE || stepUnit == enum_STEPUNIT.STEP_STATEMENT)
{
switch (sk)
{
case enum_STEPKIND.STEP_INTO:
currentStepRequest.Depth = StepDepth.Into;
break;
case enum_STEPKIND.STEP_OUT:
currentStepRequest.Depth = StepDepth.Out;
break;
case enum_STEPKIND.STEP_OVER:
currentStepRequest.Depth = StepDepth.Over;
break;
default:
return;
}
}
else if (stepUnit == enum_STEPUNIT.STEP_INSTRUCTION)
{
//TODO: by techcap
}
else
{
throw new NotImplementedException();
}
currentStepRequest.Size = StepSize.Line;
currentStepRequest.Enable();
}
ResumeVM();
}
public int Step(IDebugThread2 pThread, enum_STEPKIND kind, enum_STEPUNIT unit)
{
AD7Thread thread = (AD7Thread)pThread;
try
{
_debuggedProcess.WorkerThread.RunOperation(() => _debuggedProcess.Step(thread.GetDebuggedThread().Id, kind, unit));
}
catch (InvalidCoreDumpOperationException)
{
return(AD7_HRESULT.E_CRASHDUMP_UNSUPPORTED);
}
return(Constants.S_OK);
}
// ExecuteOnThread is called when the SDM wants execution to continue and have
// stepping state cleared.
public int ExecuteOnThread(IDebugThread2 pThread)
{
AD7Thread thread = (AD7Thread)pThread;
try
{
_pollThread.RunOperation(() => _debuggedProcess.Execute(thread?.GetDebuggedThread()));
}
catch (InvalidCoreDumpOperationException)
{
return(AD7_HRESULT.E_CRASHDUMP_UNSUPPORTED);
}
return(Constants.S_OK);
}
// EnumThreads is called by the debugger when it needs to enumerate the threads in the program.
public int EnumThreads(out IEnumDebugThreads2 ppEnum)
{
DebuggedThread[] threads = null;
DebuggedProcess.WorkerThread.RunOperation(async() => threads = await DebuggedProcess.ThreadCache.GetThreads());
AD7Thread[] threadObjects = new AD7Thread[threads.Length];
for (int i = 0; i < threads.Length; i++)
{
Debug.Assert(threads[i].Client != null);
threadObjects[i] = (AD7Thread)threads[i].Client;
}
ppEnum = new Microsoft.MIDebugEngine.AD7ThreadEnum(threadObjects);
return(Constants.S_OK);
}
//This method gets the locals and parameters and creates an MI debugger variable for each one so that we can manipulate them (and expand children, etc.)
//NOTE: Eval is called
internal async Task <List <VariableInformation> > GetLocalsAndParameters(AD7Thread thread, ThreadContext ctx)
{
List <VariableInformation> variables = new List <VariableInformation>();
ValueListValue localsAndParameters = await MICommandFactory.StackListVariables(PrintValues.NoValues, thread.Id, ctx.Level);
foreach (var localOrParamResult in localsAndParameters.Content)
{
string name = localOrParamResult.FindString("name");
bool isParam = localOrParamResult.TryFindString("arg") == "1";
SimpleVariableInformation simpleInfo = new SimpleVariableInformation(name, isParam);
VariableInformation vi = await simpleInfo.CreateMIDebuggerVariable(ctx, Engine, thread);
variables.Add(vi);
}
return(variables);
}
public AD7StackFrame(AD7Engine engine, AD7Thread thread, Mono.Debugger.Soft.StackFrame threadContext)
{
Debug.Assert(threadContext != null, "ThreadContext is null");
Engine = engine;
this.Thread = thread;
this.ThreadContext = threadContext;
_textPosition = RoslynHelper.GetStatementRange(ThreadContext.FileName, ThreadContext.LineNumber, ThreadContext.ColumnNumber);
_functionName = threadContext.Method.Name;
//if(threadContext.IsNativeTransition)
//{
//}
if (_textPosition != null)
{
docContext = new AD7DocumentContext(_textPosition);
}
this.LocalVariables = threadContext.GetVisibleVariables().Select(x => new MonoProperty(threadContext, x)).ToList();
}
//This method gets the value/type info for the method parameters of all frames without creating an mi debugger varialbe for them. For use in the callstack window
//NOTE: eval is not called
public async Task <List <ArgumentList> > GetParameterInfoOnly(AD7Thread thread, bool values, bool types, uint low, uint high)
{
var frames = await MICommandFactory.StackListArguments(values || types?PrintValues.SimpleValues : PrintValues.NoValues, thread.Id, low, high);
List <ArgumentList> parameters = new List <ArgumentList>();
foreach (var f in frames)
{
int level = f.FindInt("level");
ListValue argList = null;
f.TryFind <ListValue>("args", out argList);
List <SimpleVariableInformation> args = new List <SimpleVariableInformation>();
if (argList != null)
{
if (argList is ValueListValue) // a tuple for each arg
{
foreach (var arg in ((ValueListValue)argList).Content)
{
args.Add(new SimpleVariableInformation(arg.FindString("name"), /*isParam*/ true, arg.TryFindString("value"), arg.TryFindString("type")));
}
}
else
{
// simple arg name list
string[] names = ((ResultListValue)argList).FindAllStrings("name");
foreach (var n in names)
{
args.Add(new SimpleVariableInformation(n, /*isParam*/ true, null, null));
}
}
}
parameters.Add(new ArgumentList(level, args));
}
return(parameters);
}
public void OnBreakpoint(DebuggedThread thread, ReadOnlyCollection <object> clients)
{
IDebugBoundBreakpoint2[] boundBreakpoints = new IDebugBoundBreakpoint2[clients.Count];
int i = 0;
foreach (object objCurrentBreakpoint in clients)
{
boundBreakpoints[i] = (IDebugBoundBreakpoint2)objCurrentBreakpoint;
i++;
}
// An engine that supports more advanced breakpoint features such as hit counts, conditions and filters
// should notify each bound breakpoint that it has been hit and evaluate conditions here.
// The sample engine does not support these features.
AD7BoundBreakpointsEnum boundBreakpointsEnum = new AD7BoundBreakpointsEnum(boundBreakpoints);
AD7BreakpointEvent eventObject = new AD7BreakpointEvent(boundBreakpointsEnum);
AD7Thread ad7Thread = (AD7Thread)thread.Client;
Send(eventObject, AD7BreakpointEvent.IID, ad7Thread);
}
// EnumThreads is called by the debugger when it needs to enumerate the threads in the program.
public int EnumThreads(out IEnumDebugThreads2 ppEnum)
{
DebuggedThread[] threads = null;
DebuggedProcess.WorkerThread.RunOperation(async () => threads = await DebuggedProcess.ThreadCache.GetThreads());
AD7Thread[] threadObjects = new AD7Thread[threads.Length];
for (int i = 0; i < threads.Length; i++)
{
Debug.Assert(threads[i].Client != null);
threadObjects[i] = (AD7Thread)threads[i].Client;
}
ppEnum = new Microsoft.MIDebugEngine.AD7ThreadEnum(threadObjects);
return Constants.S_OK;
}
internal void StartDebugging()
{
if (_vm != null)
return;
_vm = VirtualMachineManager.Connect(new IPEndPoint(_ipAddress, 11000));
_vm.EnableEvents(EventType.AssemblyLoad,
EventType.ThreadStart,
EventType.ThreadDeath,
EventType.AssemblyUnload,
EventType.UserBreak,
EventType.Exception,
EventType.UserLog,
EventType.KeepAlive,
EventType.TypeLoad);
EventSet set = _vm.GetNextEventSet();
if (set.Events.OfType<VMStartEvent>().Any())
{
//TODO: review by techcap
_mainThread = new AD7Thread(_engine, new DebuggedThread(set.Events[0].Thread, _engine));
_engine.Callback.ThreadStarted(_mainThread);
Task.Factory.StartNew(ReceiveThread, TaskCreationOptions.LongRunning);
}
else
throw new Exception("Didnt get VMStart-Event!");
}
internal void Step(AD7Thread thread, enum_STEPKIND sk, enum_STEPUNIT stepUnit)
{
if (!isStepping)
{
if (currentStepRequest == null)
currentStepRequest = _vm.CreateStepRequest(thread.ThreadMirror);
else
{
currentStepRequest.Disable();
}
isStepping = true;
if (stepUnit == enum_STEPUNIT.STEP_LINE || stepUnit == enum_STEPUNIT.STEP_STATEMENT)
{
switch (sk)
{
case enum_STEPKIND.STEP_INTO:
currentStepRequest.Depth = StepDepth.Into;
break;
case enum_STEPKIND.STEP_OUT:
currentStepRequest.Depth = StepDepth.Out;
break;
case enum_STEPKIND.STEP_OVER:
currentStepRequest.Depth = StepDepth.Over;
break;
default:
return;
}
}
else if (stepUnit == enum_STEPUNIT.STEP_INSTRUCTION)
{
//TODO: by techcap
}
else
throw new NotImplementedException();
currentStepRequest.Size = StepSize.Line;
currentStepRequest.Enable();
}
_vm.Resume();
}
//internal void Resume()
//{
// _vm.Resume();
//}
/// <summary>
/// For Run
/// </summary>
/// <param name="debuggedMonoThread"></param>
internal void Execute(AD7Thread debuggedMonoThread)
{
_vm.Resume();
}
//This method gets the value/type info for the method parameters of all frames without creating an mi debugger variable for them. For use in the callstack window
//NOTE: eval is not called
public async Task<List<ArgumentList>> GetParameterInfoOnly(AD7Thread thread, bool values, bool types, uint low, uint high)
{
var frames = await MICommandFactory.StackListArguments(values || types ? PrintValues.SimpleValues : PrintValues.NoValues, thread.Id, low, high);
List<ArgumentList> parameters = new List<ArgumentList>();
foreach (var f in frames)
{
int level = f.FindInt("level");
ListValue argList = null;
f.TryFind<ListValue>("args", out argList);
List<SimpleVariableInformation> args = new List<SimpleVariableInformation>();
if (argList != null)
{
if (argList is ValueListValue) // a tuple for each arg
{
foreach (var arg in ((ValueListValue)argList).Content)
{
args.Add(new SimpleVariableInformation(arg.FindString("name"), /*isParam*/ true, arg.TryFindString("value"), arg.TryFindString("type")));
}
}
else
{
// simple arg name list
string[] names = ((ResultListValue)argList).FindAllStrings("name");
foreach (var n in names)
{
args.Add(new SimpleVariableInformation(n, /*isParam*/ true, null, null));
}
}
}
parameters.Add(new ArgumentList(level, args));
}
return parameters;
}
internal void BreakpointHit(AD7PendingBreakpoint breakpoint, AD7Thread thread)
{
var iid = new Guid(AD7BreakpointEvent.IID);
_eventCallback.Event(_engine, _engine.RemoteProcess, _engine, thread, new AD7BreakpointEvent(breakpoint), ref iid,
AD7StoppingEvent.Attributes);
}
//internal void Resume()
//{
// _vm.Resume();
//}
/// <summary>
/// For Run
/// </summary>
/// <param name="debuggedMonoThread"></param>
internal void Execute(AD7Thread debuggedMonoThread)
{
_vm.Resume();
}
//this constructor is used to create root nodes (local/params)
internal VariableInformation(string expr, ThreadContext ctx, AD7Engine engine, AD7Thread thread, bool isParameter = false)
: this(ctx, engine, thread)
{
// strip off formatting string
_strippedName = StripFormatSpecifier(expr, out _format);
Name = expr;
IsParameter = isParameter;
_parent = null;
VariableNodeType = NodeType.Root;
}
//This method gets the locals and parameters and creates an MI debugger variable for each one so that we can manipulate them (and expand children, etc.)
//NOTE: Eval is called
internal async Task<List<VariableInformation>> GetLocalsAndParameters(AD7Thread thread, ThreadContext ctx)
{
List<VariableInformation> variables = new List<VariableInformation>();
ValueListValue localsAndParameters = await MICommandFactory.StackListVariables(PrintValues.NoValues, thread.Id, ctx.Level);
foreach (var localOrParamResult in localsAndParameters.Content)
{
string name = localOrParamResult.FindString("name");
bool isParam = localOrParamResult.TryFindString("arg") == "1";
SimpleVariableInformation simpleInfo = new SimpleVariableInformation(name, isParam);
VariableInformation vi = await simpleInfo.CreateMIDebuggerVariable(ctx, Engine, thread);
variables.Add(vi);
}
return variables;
}
//This method gets the value/type info for the method parameters without creating an MI debugger variable for them. For use in the callstack window
//NOTE: eval is not called
public async Task<List<SimpleVariableInformation>> GetParameterInfoOnly(AD7Thread thread, ThreadContext ctx)
{
List<SimpleVariableInformation> parameters = new List<SimpleVariableInformation>();
ValueListValue localAndParameters = await MICommandFactory.StackListVariables(PrintValues.SimpleValues, thread.Id, ctx.Level);
foreach (var results in localAndParameters.Content.Where(r => r.TryFindString("arg") == "1"))
{
parameters.Add(new SimpleVariableInformation(results.FindString("name"), /*isParam*/ true, results.FindString("value"), results.FindString("type")));
}
return parameters;
}
private void HandleEventSet(Event ev)
{
var type = ev.EventType;
_engine.IsSuspended = true;
logger.Trace($"HandleEventSet: {ev}");
try
{
switch (type)
{
case EventType.AssemblyLoad:
HandleAssemblyLoad((AssemblyLoadEvent)ev);
break;
case EventType.UserBreak:
if (!HandleUserBreak((UserBreakEvent)ev))
{
return;
}
break;
case EventType.Breakpoint:
if (!HandleBreakPoint((BreakpointEvent)ev))
{
return;
}
break;
case EventType.Step:
HandleStep((StepEvent)ev);
return;
case EventType.TypeLoad:
var typeEvent = (TypeLoadEvent)ev;
RegisterType(typeEvent.Type);
TryBindBreakpoints();
break;
case EventType.UserLog:
UserLogEvent e = (UserLogEvent)ev;
HostOutputWindowEx.WriteLaunchError(e.Message);
break;
case EventType.VMDeath:
case EventType.VMDisconnect:
Disconnect();
return;
case EventType.VMStart:
case EventType.ThreadStart:
var domain = ev.Thread.Domain.FriendlyName;
var threadId = ev.Thread.ThreadId;
var newThread = new AD7Thread(_engine, ev.Thread);
if (_threads.TryAdd(threadId, newThread))
{
_engine.Callback.ThreadStarted(newThread);
}
else
{
logger.Error($"Thread {threadId} already added!");
}
break;
case EventType.ThreadDeath:
var oldThreadId = ev.Thread.ThreadId;
AD7Thread oldThread = null;
if (!_threads.TryRemove(oldThreadId, out oldThread))
{
_engine.Callback.ThreadDestroyed(oldThread, 0);
}
else
{
logger.Error($"Thread {oldThreadId} not found!");
}
break;
case EventType.Exception:
var exEvent = ev as ExceptionEvent;
var exceptionObjectMirror = exEvent.Exception;
// TODO Reading properties from complex exceptions throws an exception. Why?
var filter = MonoProperty.EnumOnlyFieldsFilter;
IEnumDebugPropertyInfo2 propInfo;
var monoProperty = new MonoProperty(exEvent.Thread.GetFrames().FirstOrDefault(), exceptionObjectMirror);
var propInfo1 = new DEBUG_PROPERTY_INFO[1];
monoProperty.GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ALL, 0, 10000, null, 0, propInfo1);
monoProperty.EnumChildren(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_ALL, 0, ref filter, enum_DBG_ATTRIB_FLAGS.DBG_ATTRIB_ACCESS_ALL, "", 10000, out propInfo);
var sbException = new StringBuilder();
sbException.AppendLine($"Excption thrown: {exceptionObjectMirror.Type.FullName}");
var propInfoCast = propInfo as AD7PropertyEnum;
foreach (var prop in propInfoCast.GetData())
{
if (prop.bstrName.StartsWith("_message") || prop.bstrName.StartsWith("_innerException"))
{
sbException.AppendLine($"{prop.bstrName} = {prop.bstrValue}");
}
}
logger.Error($"Exception thrown: {sbException.ToString()}");
HostOutputWindowEx.WriteLaunchError($"Exception thrown: {sbException.ToString()}");
break;
default:
logger.Trace(ev);
break;
}
}
catch (Exception ex)
{
logger.Error(ex, $"Exception thrown in {nameof(HandleEventSet)}({ev})");
}
try
{
if (type != EventType.VMStart)
{
logger.Trace($"HandleEventSet: ResumeVM ({ev})");
ResumeVM();
}
}
catch (VMNotSuspendedException)
{
if (type != EventType.VMStart && _vm.Version.AtLeast(2, 2))
{
throw;
}
}
catch (Exception ex)
{
logger.Error(ex);
}
}
internal void StepCompleted(AD7Thread thread)
{
var iid = new Guid(Microsoft.MIDebugEngine.AD7StepCompleteEvent.IID);
_eventCallback.Event(_engine, _engine.RemoteProcess, _engine, thread, new Microsoft.MIDebugEngine.AD7StepCompleteEvent(), ref iid,
AD7StoppingEvent.Attributes);
}
internal async Task <VariableInformation> CreateMIDebuggerVariable(ThreadContext ctx, AD7Engine engine, AD7Thread thread)
{
VariableInformation vi = new VariableInformation(Name, ctx, engine, thread, IsParameter);
await vi.Eval();
return(vi);
}
/// <summary>
/// On First run
/// </summary>
/// <param name="thread"></param>
internal void Continue(AD7Thread thread)
{
DebugHelper.TraceEnteringMethod();
//_vm.Resume();
}
