DbgEngineValueNode[] GetChildrenCore(DbgEvaluationInfo evalInfo, ulong index, int count, DbgValueNodeEvaluationOptions options)
{
DbgEngineValueNode[]? res = null;
DbgDotNetValueNode[]? dnNodes = null;
try {
dnNodes = dnValueNode.GetChildren(evalInfo, index, count, options);
res = new DbgEngineValueNode[dnNodes.Length];
for (int i = 0; i < res.Length; i++)
{
evalInfo.CancellationToken.ThrowIfCancellationRequested();
res[i] = owner.Create(dnNodes[i]);
}
}
catch (Exception ex) {
if (!(res is null))
{
evalInfo.Runtime.Process.DbgManager.Close(res.Where(a => !(a is null)));
}
if (!(dnNodes is null))
{
evalInfo.Runtime.Process.DbgManager.Close(dnNodes);
}
if (!ExceptionUtils.IsInternalDebuggerError(ex))
{
throw;
}
res = new DbgEngineValueNode[count];
for (int i = 0; i < res.Length; i++)
{
res[i] = owner.CreateError(evalInfo, DbgDotNetEngineValueNodeFactoryExtensions.errorName, PredefinedEvaluationErrorMessages.InternalDebuggerError, "<expression>", false);
}
return(res);
}
return(res);
}
DbgEngineValueNode[] GetChildrenCore(DbgEvaluationContext context, DbgStackFrame frame, ulong index, int count, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken)
{
DbgEngineValueNode[] res = null;
DbgDotNetValueNode[] dnNodes = null;
try {
dnNodes = dnValueNode.GetChildren(context, frame, index, count, options, cancellationToken);
res = new DbgEngineValueNode[dnNodes.Length];
for (int i = 0; i < res.Length; i++)
{
cancellationToken.ThrowIfCancellationRequested();
res[i] = owner.Create(dnNodes[i]);
}
}
catch (Exception ex) {
if (res != null)
{
context.Runtime.Process.DbgManager.Close(res.Where(a => a != null));
}
if (dnNodes != null)
{
context.Runtime.Process.DbgManager.Close(dnNodes);
}
if (!ExceptionUtils.IsInternalDebuggerError(ex))
{
throw;
}
res = new DbgEngineValueNode[count];
for (int i = 0; i < res.Length; i++)
{
res[i] = owner.CreateError(context, frame, DbgDotNetEngineValueNodeFactoryExtensions.errorName, PredefinedEvaluationErrorMessages.InternalDebuggerError, "<expression>", false, cancellationToken);
}
return(res);
}
return(res);
}
DbgEngineValueNodeAssignmentResult AssignCore(DbgEvaluationContext context, DbgStackFrame frame, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken)
{
try {
var ee = context.Language.ExpressionEvaluator;
var res = ee.Assign(context, frame, Expression, expression, options, cancellationToken);
return(new DbgEngineValueNodeAssignmentResult(res.Flags, res.Error));
}
catch (Exception ex) when(ExceptionUtils.IsInternalDebuggerError(ex))
{
return(new DbgEngineValueNodeAssignmentResult(DbgEEAssignmentResultFlags.None, PredefinedEvaluationErrorMessages.InternalDebuggerError));
}
}
DbgEngineValueNodeAssignmentResult AssignCore(DbgEvaluationInfo evalInfo, string expression, DbgEvaluationOptions options)
{
try {
var ee = evalInfo.Context.Language.ExpressionEvaluator;
var res = ee.Assign(evalInfo, Expression, expression, options);
return(new DbgEngineValueNodeAssignmentResult(res.Flags, res.Error));
}
catch (Exception ex) when(ExceptionUtils.IsInternalDebuggerError(ex))
{
return(new DbgEngineValueNodeAssignmentResult(DbgEEAssignmentResultFlags.None, PredefinedEvaluationErrorMessages.InternalDebuggerError));
}
}
DbgEngineLocalsValueNodeInfo[] GetNodesCore(DbgEvaluationContext context, DbgStackFrame frame, DbgValueNodeEvaluationOptions options, DbgLocalsValueNodeEvaluationOptions localsOptions, CancellationToken cancellationToken)
{
DbgEngineLocalsValueNodeInfo[] valueNodes = null;
try {
var refsResult = dbgModuleReferenceProvider.GetModuleReferences(context.Runtime, frame);
if (refsResult.ErrorMessage != null)
{
return(Array.Empty <DbgEngineLocalsValueNodeInfo>());
}
var languageDebugInfo = context.TryGetLanguageDebugInfo();
if (languageDebugInfo == null)
{
return(Array.Empty <DbgEngineLocalsValueNodeInfo>());
}
var methodDebugInfo = languageDebugInfo.MethodDebugInfo;
var module = frame.Module ?? throw new InvalidOperationException();
// Since we attach this to the module, the module doesn't have to be part of Key
var state = StateWithKey <GetNodesState> .GetOrCreate(module, this);
var localsOptionsKey = localsOptions & ~(DbgLocalsValueNodeEvaluationOptions.ShowCompilerGeneratedVariables | DbgLocalsValueNodeEvaluationOptions.ShowDecompilerGeneratedVariables);
var key = new GetNodesState.Key(methodDebugInfo.DecompilerOptionsVersion,
methodDebugInfo.Method.MDToken.ToInt32(), languageDebugInfo.MethodVersion,
refsResult.ModuleReferences, MethodDebugScopeUtils.GetScope(methodDebugInfo.Scope, languageDebugInfo.ILOffset),
options, localsOptionsKey);
var evalOptions = DbgEvaluationOptions.None;
if ((options & DbgValueNodeEvaluationOptions.NoFuncEval) != 0)
{
evalOptions |= DbgEvaluationOptions.NoFuncEval;
}
ValueInfo[] valueInfos;
byte[] assemblyBytes;
int compilerGeneratedCount;
int decompilerGeneratedCount;
if (key.Equals(state.CachedKey))
{
valueInfos = state.CachedValueInfos;
assemblyBytes = state.CachedAssemblyBytes;
decompilerGeneratedCount = state.CachedDecompilerGeneratedCount;
compilerGeneratedCount = state.CachedCompilerGeneratedCount;
}
else
{
var compilationResult = expressionCompiler.CompileGetLocals(context, frame, refsResult.ModuleReferences, evalOptions, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
if (compilationResult.IsError)
{
return new[] { CreateInternalErrorNode(context, frame, compilationResult.ErrorMessage, cancellationToken) }
}
;
decompilerGeneratedCount = GetDecompilerGeneratedVariablesCount(methodDebugInfo.Scope, languageDebugInfo.ILOffset);
valueInfos = new ValueInfo[compilationResult.CompiledExpressions.Length + decompilerGeneratedCount];
int valueInfosIndex = 0;
compilerGeneratedCount = 0;
for (int i = 0; i < compilationResult.CompiledExpressions.Length; i++, valueInfosIndex++)
{
if ((compilationResult.CompiledExpressions[i].ResultFlags & DbgDotNetCompiledExpressionResultFlags.CompilerGenerated) != 0)
{
compilerGeneratedCount++;
}
valueInfos[valueInfosIndex] = new CompiledExpressionValueInfo(compilationResult.CompiledExpressions, i);
}
if (decompilerGeneratedCount > 0)
{
var scope = methodDebugInfo.Scope;
for (;;)
{
foreach (var local in scope.Locals)
{
if (local.IsDecompilerGenerated)
{
valueInfos[valueInfosIndex] = new DecompilerGeneratedVariableValueInfo(local.Name);
valueInfosIndex++;
}
}
bool found = false;
foreach (var childScope in scope.Scopes)
{
if (childScope.Span.Start <= languageDebugInfo.ILOffset && languageDebugInfo.ILOffset < childScope.Span.End)
{
found = true;
scope = childScope;
break;
}
}
if (!found)
{
break;
}
}
}
if (valueInfos.Length != valueInfosIndex)
{
throw new InvalidOperationException();
}
assemblyBytes = compilationResult.Assembly;
state.CachedKey = key;
state.CachedValueInfos = valueInfos;
state.CachedAssemblyBytes = assemblyBytes;
state.CachedILInterpreterState = null;
state.CachedDecompilerGeneratedCount = decompilerGeneratedCount;
state.CachedCompilerGeneratedCount = compilerGeneratedCount;
}
int count = valueInfos.Length;
if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowCompilerGeneratedVariables) == 0)
{
count -= compilerGeneratedCount;
}
if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowDecompilerGeneratedVariables) == 0)
{
count -= decompilerGeneratedCount;
}
valueNodes = count == 0 ? Array.Empty <DbgEngineLocalsValueNodeInfo>() : new DbgEngineLocalsValueNodeInfo[count];
var valueCreator = new DbgDotNetValueCreator(valueNodeFactory, dnILInterpreter, context, frame, options, evalOptions, assemblyBytes, cancellationToken);
int w = 0;
for (int i = 0; i < valueInfos.Length; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var valueInfo = valueInfos[i];
DbgEngineLocalsValueNodeInfo valueNodeInfo;
switch (valueInfo.Kind)
{
case ValueInfoKind.CompiledExpression:
var compExpr = (CompiledExpressionValueInfo)valueInfo;
if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowCompilerGeneratedVariables) == 0 && compExpr.IsCompilerGenerated)
{
continue;
}
valueNodeInfo = new DbgEngineLocalsValueNodeInfo(
compExpr.IsParameter ? DbgLocalsValueNodeKind.Parameter : DbgLocalsValueNodeKind.Local,
valueCreator.CreateValueNode(ref state.CachedILInterpreterState, ref compExpr.CompiledExpressionResult));
break;
case ValueInfoKind.DecompilerGeneratedVariable:
if ((localsOptions & DbgLocalsValueNodeEvaluationOptions.ShowDecompilerGeneratedVariables) == 0)
{
continue;
}
var decGen = (DecompilerGeneratedVariableValueInfo)valueInfo;
valueNodeInfo = new DbgEngineLocalsValueNodeInfo(DbgLocalsValueNodeKind.Local,
valueNodeFactory.CreateError(context, frame,
new DbgDotNetText(new DbgDotNetTextPart(BoxedTextColor.Local, decGen.Name)),
dnSpy_Debugger_DotNet_Resources.DecompilerGeneratedVariablesCanNotBeEvaluated,
decGen.Name, false, cancellationToken));
break;
default:
throw new InvalidOperationException();
}
valueNodes[w++] = valueNodeInfo;
}
if (w != valueNodes.Length)
{
throw new InvalidOperationException();
}
return(valueNodes);
}
catch (Exception ex) {
if (valueNodes != null)
{
frame.Process.DbgManager.Close(valueNodes.Select(a => a.ValueNode).Where(a => a != null));
}
if (!ExceptionUtils.IsInternalDebuggerError(ex))
{
throw;
}
return(new[] { CreateInternalErrorNode(context, frame, PredefinedEvaluationErrorMessages.InternalDebuggerError, cancellationToken) });
}
}