//TODO: If decompiler settings change, we need to invalidate the cached data in DbgEvaluationContext, see decompiler.Settings.VersionChanged DbgLanguageDebugInfo?GetOrCreateDebugInfo(DbgEvaluationContext context, RuntimeState state, IDbgDotNetCodeLocation location, CancellationToken cancellationToken) { DbgLanguageDebugInfoKey key; if (location.DbgModule is DbgModule dbgModule) { key = new DbgLanguageDebugInfoKey(dbgModule, location.Token); } else { key = new DbgLanguageDebugInfoKey(location.Module, location.Token); } var debugInfos = state.DebugInfos; lock (state.LockObj) { if (debugInfos.Count > 0 && debugInfos[0].debugInfo.MethodDebugInfo.DebugInfoVersion != decompiler.Settings.Version) { debugInfos.Clear(); } for (int i = debugInfos.Count - 1; i >= 0; i--) { var info = debugInfos[i]; if (info.key.Equals(key)) { if (i != debugInfos.Count - 1) { debugInfos.RemoveAt(i); debugInfos.Add(info); } return(info.debugInfo); } } } var debugInfo = CreateDebugInfo(context, location, cancellationToken); if (debugInfo is null) { return(null); } lock (state.LockObj) { if (debugInfos.Count == RuntimeState.MAX_CACHED_DEBUG_INFOS) { debugInfos.RemoveAt(0); } debugInfos.Add((key, debugInfo)); } return(debugInfo); }
public void Clear(DbgDotNetValue returnValue) { context = null; frame = null; cancellationToken = default; foreach (var v in valuesToDispose) { if (v != returnValue) { v.Dispose(); } } valuesToDispose.Clear(); }
public override void Initialize(DbgEvaluationContext context, DbgStackFrame frame, DmdMethodBody realMethodBody, VariablesProvider argumentsProvider, VariablesProvider localsProvider, bool canFuncEval, CancellationToken cancellationToken) { Debug.Assert(this.context == null); if (this.context != null) { throw new InvalidOperationException(); } this.context = context; this.frame = frame; this.cancellationToken = cancellationToken; this.canFuncEval = canFuncEval; this.argumentsProvider = argumentsProvider ?? DefaultArgumentsProvider; interpreterLocalsProvider.Initialize(realMethodBody, localsProvider ?? DefaultLocalsProvider); Debug.Assert(valuesToDispose.Count == 0); }
protected void GetTypeCompilationState <T>(DbgEvaluationContext context, DbgStackFrame frame, DbgModuleReference[] references, out T state, out ImmutableArray <MetadataBlock> metadataBlocks) where T : EvalContextState, new() { state = GetEvalContextState <T>(frame); if (state.LastModuleReferences == references && !state.LastMetadataBlocks.IsDefault) { metadataBlocks = state.LastMetadataBlocks; } else { metadataBlocks = CreateMetadataBlock(references); state.LastModuleReferences = references; state.LastMetadataBlocks = metadataBlocks; } }
public override DbgValueNode[] Create(DbgEvaluationContext context, DbgStackFrame frame, DbgObjectId[] objectIds, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (!(context is DbgEvaluationContextImpl)) { throw new ArgumentException(); } if (context.Language != Language) { throw new ArgumentException(); } if (context.Runtime.RuntimeKindGuid != runtimeKindGuid) { throw new ArgumentException(); } if (frame == null) { throw new ArgumentNullException(nameof(frame)); } if (frame.Runtime.RuntimeKindGuid != runtimeKindGuid) { throw new ArgumentException(); } if (objectIds == null) { throw new ArgumentNullException(nameof(objectIds)); } if (objectIds.Length == 0) { return(Array.Empty <DbgValueNode>()); } var runtime = objectIds[0].Runtime; if (runtime.RuntimeKindGuid != runtimeKindGuid) { throw new ArgumentException(); } var engineObjectIds = new DbgEngineObjectId[objectIds.Length]; for (int i = 0; i < objectIds.Length; i++) { engineObjectIds[i] = ((DbgObjectIdImpl)objectIds[i]).EngineObjectId; } return(CreateResult(runtime, engineValueNodeFactory.Create(context, frame, engineObjectIds, options, cancellationToken), engineObjectIds.Length)); }
public override DbgDotNetValueNode[] GetChildren(DbgEvaluationContext context, DbgStackFrame frame, ulong index, int count, DbgValueNodeEvaluationOptions options, CancellationToken cancellationToken) { var res = new DbgDotNetValueNode[count]; try { for (int i = 0, j = (int)index; i < count; i++, j++) { res[i] = new TypeVariableValueNode(valueNodeFactory, typeVariableInfos[j]); } } catch { context.Process.DbgManager.Close(res.Where(a => a != null)); throw; } return(res); }
string StoreIndirect_MonoDebug(DbgEvaluationContext context, DbgStackFrame frame, object value, CancellationToken cancellationToken) { engine.VerifyMonoDebugThread(); cancellationToken.ThrowIfCancellationRequested(); if (!Type.IsByRef) { return(PredefinedEvaluationErrorMessages.InternalDebuggerError); } var res = engine.CreateMonoValue_MonoDebug(context, frame, value, Type.GetElementType(), cancellationToken); if (res.ErrorMessage != null) { return(res.ErrorMessage); } return(valueLocation.Store(res.Value)); }
public override void Format(DbgEvaluationContext context, DbgStackFrame frame, IDbgValueNodeFormatParameters options, CultureInfo cultureInfo, CancellationToken cancellationToken) { var dispatcher = context.Runtime.GetDotNetRuntime().Dispatcher; if (dispatcher.CheckAccess()) { FormatCore(context, frame, options, cultureInfo, cancellationToken); } else { Format2(dispatcher, context, frame, options, cultureInfo, cancellationToken); } void Format2(DbgDotNetDispatcher dispatcher2, DbgEvaluationContext context2, DbgStackFrame frame2, IDbgValueNodeFormatParameters options2, CultureInfo cultureInfo2, CancellationToken cancellationToken2) => dispatcher2.InvokeRethrow(() => FormatCore(context2, frame2, options2, cultureInfo2, cancellationToken2)); }
public override void Clear(DbgDotNetValue returnValue) { context = null; frame = null; cancellationToken = default; canFuncEval = false; foreach (var v in valuesToDispose) { if (v != returnValue && argumentsProvider.CanDispose(v) && localsProvider.CanDispose(v)) v.Dispose(); } valuesToDispose.Clear(); argumentsProvider.Clear(); localsProvider.Clear(); argumentsProvider = null; localsProvider = null; reflectionAppDomain = null; }
public override DbgValueNodeInfo[] GetNodes(DbgEvaluationContext context, DbgLanguage language, DbgStackFrame frame, DbgEvaluationOptions evalOptions, DbgValueNodeEvaluationOptions nodeEvalOptions) { if (expressions.Count == 0) { return(Array.Empty <DbgValueNodeInfo>()); } var infos = new DbgExpressionEvaluationInfo[expressions.Count]; Debug.Assert((evalOptions & DbgEvaluationOptions.NoSideEffects) == 0); for (int i = 0; i < infos.Length; i++) { var info = expressions[i]; // Root nodes in watch window can always func-eval var realEvalOptions = evalOptions & ~DbgEvaluationOptions.NoFuncEval; var realNodeEvalOptions = nodeEvalOptions & ~DbgValueNodeEvaluationOptions.NoFuncEval; if (info.ForceEval) { realEvalOptions = evalOptions & ~DbgEvaluationOptions.NoSideEffects; } else { realEvalOptions = evalOptions | DbgEvaluationOptions.NoSideEffects; } Debug.Assert(((realEvalOptions & DbgEvaluationOptions.NoFuncEval) != 0) == ((realNodeEvalOptions & DbgValueNodeEvaluationOptions.NoFuncEval) != 0)); info.ForceEval = false; infos[i] = new DbgExpressionEvaluationInfo(info.Expression, realNodeEvalOptions, realEvalOptions); } var compRes = language.ValueNodeFactory.Create(context, frame, infos); Debug.Assert(compRes.Length == infos.Length); var res = new DbgValueNodeInfo[compRes.Length]; for (int i = 0; i < res.Length; i++) { var info = compRes[i]; if (info.ValueNode.Expression != expressions[i].Expression) { throw new InvalidOperationException(); } res[i] = new DbgValueNodeInfo(info.ValueNode, expressions[i].Id, info.CausesSideEffects); } return(res); }
internal DbgDotNetValueResult Box_CorDebug(DbgEvaluationContext context, DbgThread thread, CorAppDomain appDomain, CorValue value, DmdType type, CancellationToken cancellationToken) { debuggerThread.VerifyAccess(); cancellationToken.ThrowIfCancellationRequested(); var tmp = CheckFuncEval(context); if (tmp != null) { return(tmp.Value); } var dnThread = GetThread(thread); var createdValues = new List <CorValue>(); CorValue boxedValue = null; try { using (var dnEval = dnDebugger.CreateEval(cancellationToken, suspendOtherThreads: (context.Options & DbgEvaluationContextOptions.RunAllThreads) == 0)) { dnEval.SetThread(dnThread); dnEval.SetTimeout(context.FuncEvalTimeout); dnEval.EvalEvent += (s, e) => DnEval_EvalEvent(dnEval, context); boxedValue = BoxIfNeeded(dnEval, appDomain, createdValues, value, type.AppDomain.System_Object, type); if (boxedValue == null) { return(new DbgDotNetValueResult(CordbgErrorHelper.GetErrorMessage(-1))); } return(new DbgDotNetValueResult(CreateDotNetValue_CorDebug(boxedValue, type.AppDomain, tryCreateStrongHandle: true), valueIsException: false)); } } catch (TimeoutException) { return(new DbgDotNetValueResult(PredefinedEvaluationErrorMessages.FuncEvalTimedOut)); } catch (Exception ex) when(ExceptionUtils.IsInternalDebuggerError(ex)) { return(new DbgDotNetValueResult(CordbgErrorHelper.InternalError)); } finally { foreach (var v in createdValues) { if (boxedValue != v) { dnDebugger.DisposeHandle(v); } } } }
string StoreIndirect_CorDebug(DbgEvaluationContext context, DbgStackFrame frame, object value, CancellationToken cancellationToken) { engine.VerifyCorDebugThread(); cancellationToken.ThrowIfCancellationRequested(); if (!ILDbgEngineStackFrame.TryGetEngineStackFrame(frame, out var ilFrame)) { return(CordbgErrorHelper.InternalError); } if (!Type.IsByRef) { return(CordbgErrorHelper.InternalError); } Func <CreateCorValueResult> createTargetValue = () => { var objValue = TryGetCorValue(); if (objValue == null) { return(new CreateCorValueResult(null, -1)); } Debug.Assert(objValue.ElementType == CorElementType.ByRef); if (objValue.ElementType == CorElementType.ByRef) { var derefencedValue = objValue.DereferencedValue; if (derefencedValue == null) { return(new CreateCorValueResult(null, -1)); } if (!derefencedValue.IsReference) { if (derefencedValue.IsGeneric) { return(new CreateCorValueResult(derefencedValue, 0, canDispose: true)); } engine.DisposeHandle_CorDebug(derefencedValue); return(new CreateCorValueResult(null, -1)); } return(new CreateCorValueResult(derefencedValue, 0, canDispose: true)); } else { return(new CreateCorValueResult(null, -1)); } }; return(engine.StoreValue_CorDebug(context, frame.Thread, ilFrame, createTargetValue, Type.GetElementType(), value, cancellationToken)); }
protected override string InitializeCore(DbgEvaluationContext context, DbgStackFrame frame, CancellationToken cancellationToken) { if ((evalOptions & DbgValueNodeEvaluationOptions.NoFuncEval) != 0) { return(PredefinedEvaluationErrorMessages.FuncEvalDisabled); } var proxyCtor = EnumerableDebugViewHelper.GetEnumerableDebugViewConstructor(enumerableType); if ((object)proxyCtor == null) { var loadState = enumerableType.AppDomain.GetOrCreateData <ForceLoadAssemblyState>(); if (Interlocked.Exchange(ref loadState.Counter, 1) == 0) { var loader = new ReflectionAssemblyLoader(context, frame, enumerableType.AppDomain, cancellationToken); if (loader.TryLoadAssembly(GetRequiredAssemblyFullName(context.Runtime))) { proxyCtor = EnumerableDebugViewHelper.GetEnumerableDebugViewConstructor(enumerableType); } } if ((object)proxyCtor == null) { var asmFilename = GetRequiredAssemblyFilename(context.Runtime); var asm = enumerableType.AppDomain.GetAssembly(Path.GetFileNameWithoutExtension(asmFilename)); if (asm == null) { return(string.Format(dnSpy_Roslyn_Shared_Resources.SystemCoreDllNotLoaded, asmFilename)); } return(string.Format(dnSpy_Roslyn_Shared_Resources.TypeDoesNotExistInAssembly, EnumerableDebugViewHelper.GetDebugViewTypeDisplayName(enumerableType), asmFilename)); } } var runtime = context.Runtime.GetDotNetRuntime(); var proxyTypeResult = runtime.CreateInstance(context, frame, proxyCtor, new[] { instanceValue }, DbgDotNetInvokeOptions.None, cancellationToken); if (proxyTypeResult.HasError) { return(proxyTypeResult.ErrorMessage); } resultsViewProxyExpression = valueNodeProviderFactory.GetNewObjectExpression(proxyCtor, valueExpression); getResultsViewValue = proxyTypeResult.Value; valueNodeProviderFactory.GetMemberCollections(getResultsViewValue.Type, evalOptions, out membersCollection, out _); return(null); }
// This method calls ICorDebugEval2.NewParameterizedArray() which doesn't support creating SZ arrays // with any element type. See the caller of this method (CreateSZArrayCore) for more info. internal DbgDotNetValueResult CreateSZArray_CorDebug(DbgEvaluationContext context, DbgThread thread, CorAppDomain appDomain, DmdType elementType, int length, CancellationToken cancellationToken) { debuggerThread.VerifyAccess(); cancellationToken.ThrowIfCancellationRequested(); var tmp = CheckFuncEval(context); if (tmp != null) { return(tmp.Value); } var dnThread = GetThread(thread); try { using (var dnEval = dnDebugger.CreateEval(cancellationToken, suspendOtherThreads: (context.Options & DbgEvaluationContextOptions.RunAllThreads) == 0)) { dnEval.SetThread(dnThread); dnEval.SetTimeout(context.FuncEvalTimeout); dnEval.EvalEvent += (s, e) => DnEval_EvalEvent(dnEval, context); var corType = GetType(appDomain, elementType); var res = dnEval.CreateSZArray(corType, length, out int hr); if (res == null) { return(new DbgDotNetValueResult(CordbgErrorHelper.GetErrorMessage(hr))); } Debug.Assert(!res.Value.WasException, "Shouldn't throw " + nameof(ArgumentOutOfRangeException)); if (res.Value.WasCustomNotification) { return(new DbgDotNetValueResult(CordbgErrorHelper.FuncEvalRequiresAllThreadsToRun)); } if (res.Value.WasCancelled) { return(new DbgDotNetValueResult(PredefinedEvaluationErrorMessages.FuncEvalTimedOut)); } return(new DbgDotNetValueResult(CreateDotNetValue_CorDebug(res.Value.ResultOrException, elementType.AppDomain, tryCreateStrongHandle: true), valueIsException: res.Value.WasException)); } } catch (TimeoutException) { return(new DbgDotNetValueResult(PredefinedEvaluationErrorMessages.FuncEvalTimedOut)); } catch (Exception ex) when(ExceptionUtils.IsInternalDebuggerError(ex)) { return(new DbgDotNetValueResult(CordbgErrorHelper.InternalError)); } }
public override DbgDotNetCompilationResult CompileGetLocals(DbgEvaluationContext context, DbgStackFrame frame, DbgModuleReference[] references, DbgEvaluationOptions options, CancellationToken cancellationToken) { GetCompilationState <VisualBasicEvalContextState>(context, frame, references, out var langDebugInfo, out var method, out var methodToken, out var localVarSigTok, out var state, out var metadataBlocks, out var methodVersion); var getMethodDebugInfo = CreateGetMethodDebugInfo(state, langDebugInfo); var evalCtx = EvaluationContext.CreateMethodContext(state.MetadataContext, metadataBlocks, null, getMethodDebugInfo, method.Module.Mvid ?? Guid.Empty, methodToken, methodVersion, langDebugInfo.ILOffset, localVarSigTok); state.MetadataContext = new VisualBasicMetadataContext(metadataBlocks, evalCtx); var asmBytes = evalCtx.CompileGetLocals(false, ImmutableArray <Alias> .Empty, out var localsInfo, out var typeName, out var errorMessage); var res = CreateCompilationResult(state, asmBytes, typeName, localsInfo, errorMessage); if (!res.IsError) { return(res); } return(CompileGetLocals(state, method)); }
public void Clear(DbgDotNetValue returnValue) { context = null; frame = null; cancellationToken = default; foreach (var v in valuesToDispose) { if (v != returnValue && argumentsProvider.CanDispose(v) && localsProvider.CanDispose(v)) { v.Dispose(); } } valuesToDispose.Clear(); argumentsProvider.Clear(); localsProvider.Clear(); argumentsProvider = null; localsProvider = null; }
public override DbgValueNodeAssignmentResult Assign(DbgEvaluationContext context, DbgStackFrame frame, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (!(context is DbgEvaluationContextImpl)) { throw new ArgumentException(); } if (context.Language != Language) { throw new ArgumentException(); } if (context.Runtime != Runtime) { throw new ArgumentException(); } if (frame == null) { throw new ArgumentNullException(nameof(frame)); } if (!(frame is DbgStackFrameImpl)) { throw new ArgumentException(); } if (frame.Runtime != Runtime) { throw new ArgumentException(); } if (expression == null) { throw new ArgumentNullException(nameof(expression)); } if (IsReadOnly) { throw new InvalidOperationException(); } if (engineValueNode.ErrorMessage != null) { throw new NotSupportedException(); } return(CreateResult(engineValueNode.Assign(context, frame, expression, options, cancellationToken))); }
public override void Format(DbgEvaluationContext context, DbgStackFrame frame, ITextColorWriter output, DbgValue value, DbgValueFormatterOptions options, CultureInfo cultureInfo, CancellationToken cancellationToken) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (!(context is DbgEvaluationContextImpl)) { throw new ArgumentException(); } if (context.Language != Language) { throw new ArgumentException(); } if (context.Runtime.RuntimeKindGuid != runtimeKindGuid) { throw new ArgumentException(); } if (frame == null) { throw new ArgumentNullException(nameof(frame)); } if (frame.Runtime.RuntimeKindGuid != runtimeKindGuid) { throw new ArgumentException(); } if (output == null) { throw new ArgumentNullException(nameof(output)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } if (!(value is DbgValueImpl valueImpl)) { throw new ArgumentException(); } if (value.Runtime.RuntimeKindGuid != runtimeKindGuid) { throw new ArgumentException(); } engineValueFormatter.Format(context, frame, output, valueImpl.EngineValue, options, cultureInfo, cancellationToken); }
public override DbgValueNodeInfo[] GetNodes(DbgEvaluationContext context, DbgLanguage language, DbgStackFrame frame, DbgEvaluationOptions evalOptions, DbgValueNodeEvaluationOptions nodeEvalOptions) { var returnValues = language.ReturnValuesProvider.GetNodes(context, frame, nodeEvalOptions); var variables = language.AutosProvider.GetNodes(context, frame, nodeEvalOptions); var res = new DbgValueNodeInfo[returnValues.Length + variables.Length]; int ri = 0; for (int i = 0; i < returnValues.Length; i++, ri++) { res[ri] = new DbgValueNodeInfo(returnValues[i], GetNextReturnValueId(), causesSideEffects: false); } for (int i = 0; i < variables.Length; i++, ri++) { res[ri] = new DbgValueNodeInfo(variables[i], causesSideEffects: false); } return(res); }
DbgLanguageDebugInfo?CreateDebugInfo(DbgEvaluationContext context, IDbgDotNetCodeLocation location, CancellationToken cancellationToken) { var result = dbgMethodDebugInfoProvider.GetMethodDebugInfo(context.Runtime, decompiler, location, cancellationToken); if (result.DebugInfo is null) { return(null); } var runtime = context.Runtime.GetDotNetRuntime(); if (location.DbgModule is null || !runtime.TryGetMethodToken(location.DbgModule, (int)location.Token, out int methodToken, out int localVarSigTok)) { methodToken = (int)location.Token; localVarSigTok = (int)((result.StateMachineDebugInfo ?? result.DebugInfo)?.Method.Body?.LocalVarSigTok ?? 0); } return(new DbgLanguageDebugInfo(result.DebugInfo, methodToken, localVarSigTok, result.MethodVersion, location.Offset)); }
public override void InitializeContext(DbgEvaluationContext context, DbgCodeLocation location, CancellationToken cancellationToken) { Debug.Assert(context.Runtime.GetDotNetRuntime() != null); IDebuggerDisplayAttributeEvaluatorUtils.Initialize(context, debuggerDisplayAttributeEvaluator); // Needed by DebuggerRuntimeImpl (calls expressionCompiler.TryGetAliasInfo()) context.GetOrCreateData(() => expressionCompiler); if ((context.Options & DbgEvaluationContextOptions.NoMethodBody) == 0 && location is IDbgDotNetCodeLocation loc) { var state = StateWithKey <RuntimeState> .GetOrCreate(context.Runtime, decompiler); var debugInfo = GetOrCreateDebugInfo(context, state, loc, cancellationToken); if (debugInfo != null) { DbgLanguageDebugInfoExtensions.SetLanguageDebugInfo(context, debugInfo); } } }
public sealed override void Format(DbgEvaluationContext context, DbgStackFrame frame, IDbgValueNodeFormatParameters options, CultureInfo cultureInfo) { if (options.NameOutput != null) { FormatName(context, frame, options.NameOutput, cultureInfo); } if (options.ValueOutput != null) { FormatValue(context, frame, options.ValueOutput, options.ValueFormatterOptions, cultureInfo); } if (options.ExpectedTypeOutput != null) { WriteTo(options.ExpectedTypeOutput, CachedExpectedType); } if (options.ActualTypeOutput != null) { WriteTo(options.ActualTypeOutput, CachedActualType); } }
public override DbgDotNetCompilationResult CompileExpression(DbgEvaluationContext context, DbgStackFrame frame, DbgModuleReference[] references, DbgDotNetAlias[] aliases, string expression, DbgEvaluationOptions options, CancellationToken cancellationToken) { GetCompilationState <CSharpEvalContextState>(context, frame, references, out var langDebugInfo, out var method, out var localVarSigTok, out var state, out var metadataBlocks, out var methodVersion); var getMethodDebugInfo = CreateGetMethodDebugInfo(state, langDebugInfo); var evalCtx = EvaluationContext.CreateMethodContext(state.MetadataContext, metadataBlocks, getMethodDebugInfo, method.Module.Mvid ?? Guid.Empty, method.MDToken.ToInt32(), methodVersion, langDebugInfo.ILOffset, localVarSigTok); state.MetadataContext = new CSharpMetadataContext(metadataBlocks, evalCtx); var compilationFlags = DkmEvaluationFlags.None; if ((options & DbgEvaluationOptions.Expression) != 0) { compilationFlags |= DkmEvaluationFlags.TreatAsExpression; } var compileResult = evalCtx.CompileExpression(expression, compilationFlags, CreateAliases(aliases), out var resultProperties, out var errorMessage); return(CreateCompilationResult(expression, compileResult, resultProperties, errorMessage, GetExpressionText(expression))); }
DbgDotNetValue Box_CorDebug(DbgEvaluationContext context, DbgStackFrame frame, CancellationToken cancellationToken) { engine.VerifyCorDebugThread(); cancellationToken.ThrowIfCancellationRequested(); var corValue = TryGetCorValue(); if (corValue == null) { return(null); } if (!ILDbgEngineStackFrame.TryGetEngineStackFrame(frame, out var ilFrame)) { return(null); } // Even if it's boxed, box the unboxed value. This code path should only be called if // the compiler thinks it's an unboxed value, so we must make a new boxed value. if (corValue.IsReference) { corValue = corValue.DereferencedValue; if (corValue == null) { return(null); } } if (corValue.IsBox) { corValue = corValue.BoxedValue; if (corValue == null) { return(null); } } var res = engine.Box_CorDebug(context, frame.Thread, ilFrame.GetCorAppDomain(), corValue, Type, cancellationToken); if (res.IsNormalResult) { return(res.Value); } res.Value?.Dispose(); return(null); }
DbgEngineEEAssignmentResult AssignCore(DbgEvaluationContext context, DbgStackFrame frame, string expression, string valueExpression, DbgEvaluationOptions options, CancellationToken cancellationToken) { var resultFlags = DbgEEAssignmentResultFlags.None; try { var refsResult = dbgModuleReferenceProvider.GetModuleReferences(context.Runtime, frame); if (refsResult.ErrorMessage != null) { return(new DbgEngineEEAssignmentResult(resultFlags, refsResult.ErrorMessage)); } var aliases = GetAliases(context, frame, cancellationToken); var compRes = expressionCompiler.CompileAssignment(context, frame, refsResult.ModuleReferences, aliases, expression, valueExpression, options, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); if (compRes.IsError) { return(new DbgEngineEEAssignmentResult(resultFlags | DbgEEAssignmentResultFlags.CompilerError, compRes.ErrorMessage)); } var state = dnILInterpreter.CreateState(compRes.Assembly); ref var exprInfo = ref compRes.CompiledExpressions[0]; if (exprInfo.ErrorMessage != null) { return(new DbgEngineEEAssignmentResult(resultFlags | DbgEEAssignmentResultFlags.CompilerError, exprInfo.ErrorMessage)); } resultFlags |= DbgEEAssignmentResultFlags.ExecutedCode; var res = dnILInterpreter.Execute(context, frame, state, exprInfo.TypeName, exprInfo.MethodName, options, out _, cancellationToken); if (res.HasError) { return(new DbgEngineEEAssignmentResult(resultFlags, res.ErrorMessage)); } if (res.ValueIsException) { res.Value.Dispose(); var error = string.Format(dnSpy_Debugger_DotNet_Resources.Method_X_ThrewAnExceptionOfType_Y, expression, res.Value.Type.FullName); return(new DbgEngineEEAssignmentResult(resultFlags, error)); } res.Value?.Dispose(); return(new DbgEngineEEAssignmentResult()); }
internal DbgDotNetValueResult?CheckFuncEval(DbgEvaluationContext context) { debuggerThread.VerifyAccess(); if (!IsPaused) { return(DbgDotNetValueResult.CreateError(PredefinedEvaluationErrorMessages.CanFuncEvalOnlyWhenPaused)); } if (isUnhandledException) { return(DbgDotNetValueResult.CreateError(PredefinedEvaluationErrorMessages.CantFuncEvalWhenUnhandledExceptionHasOccurred)); } if (context.ContinueContext.HasData <EvalTimedOut>()) { return(DbgDotNetValueResult.CreateError(PredefinedEvaluationErrorMessages.FuncEvalTimedOutNowDisabled)); } if (IsEvaluating) { return(DbgDotNetValueResult.CreateError(PredefinedEvaluationErrorMessages.CantFuncEval)); } return(null); }
public override void InitializeContext(DbgEvaluationContext context, DbgCodeLocation location, CancellationToken cancellationToken) { Debug.Assert(context.Runtime.GetDotNetRuntime() != null); var loc = location as IDbgDotNetCodeLocation; if (loc == null) { // Could be a special frame, eg. managed to native frame return; } var state = StateWithKey <RuntimeState> .GetOrCreate(context.Runtime, decompiler); var debugInfo = GetOrCreateDebugInfo(state, loc, cancellationToken); if (debugInfo == null) { return; } DbgLanguageDebugInfoExtensions.SetLanguageDebugInfo(context, debugInfo); }
protected void GetCompilationState <T>(DbgEvaluationContext context, DbgStackFrame frame, DbgModuleReference[] references, out DbgLanguageDebugInfo langDebugInfo, out MethodDef method, out int localVarSigTok, out T state, out ImmutableArray <MetadataBlock> metadataBlocks, out int methodVersion) where T : EvalContextState, new() { langDebugInfo = context.GetLanguageDebugInfo(); method = langDebugInfo.MethodDebugInfo.Method; localVarSigTok = (int)(method.Body?.LocalVarSigTok ?? 0); state = GetEvalContextState <T>(frame); if (state.LastModuleReferences == references && !state.LastMetadataBlocks.IsDefault) { metadataBlocks = state.LastMetadataBlocks; } else { metadataBlocks = CreateMetadataBlock(references); state.LastModuleReferences = references; state.LastMetadataBlocks = metadataBlocks; } methodVersion = langDebugInfo.MethodVersion; }
DbgLanguageDebugInfo CreateDebugInfo(DbgEvaluationContext context, IDbgDotNetCodeLocation location, CancellationToken cancellationToken) { var result = dbgMethodDebugInfoProvider.GetMethodDebugInfo(context.Runtime, decompiler, location, cancellationToken); if (result.DebugInfoOrNull == null) { return(null); } var runtime = context.Runtime.GetDotNetRuntime(); if (location.DbgModule == null || !runtime.TryGetMethodToken(location.DbgModule, (int)location.Token, out int methodToken, out int localVarSigTok)) { methodToken = (int)location.Token; localVarSigTok = (int)result.LocalVarSigTok; } // We don't support EnC so the version is always 1 const int methodVersion = 1; return(new DbgLanguageDebugInfo(result.DebugInfoOrNull, methodToken, localVarSigTok, methodVersion, location.Offset)); }
protected override string InitializeCore(DbgEvaluationContext context, DbgStackFrame frame, CancellationToken cancellationToken) { if ((evalOptions & DbgValueNodeEvaluationOptions.NoFuncEval) != 0) { return(PredefinedEvaluationErrorMessages.FuncEvalDisabled); } var proxyCtor = EnumerableDebugViewHelper.GetEnumerableDebugViewConstructor(enumerableType); if ((object)proxyCtor == null) { var loadState = enumerableType.AppDomain.GetOrCreateData <ForceLoadAssemblyState>(); if (Interlocked.Increment(ref loadState.Counter) == 1) { var loader = new ReflectionAssemblyLoader(context, frame, enumerableType.AppDomain, cancellationToken); if (loader.TryLoadAssembly(GetRequiredAssemblyFullName(context.Runtime))) { proxyCtor = EnumerableDebugViewHelper.GetEnumerableDebugViewConstructor(enumerableType); } } if ((object)proxyCtor == null) { return(string.Format(dnSpy_Roslyn_Shared_Resources.SystemCoreDllNotLoaded, GetRequiredAssemblyFileName(context.Runtime))); } } var runtime = context.Runtime.GetDotNetRuntime(); var proxyTypeResult = runtime.CreateInstance(context, frame, proxyCtor, new[] { instanceValue }, cancellationToken); if (proxyTypeResult.HasError) { return(proxyTypeResult.ErrorMessage); } getResultsViewValue = proxyTypeResult.Value; valueNodeProviderFactory.GetMemberCollections(getResultsViewValue.Type, evalOptions, out membersCollection, out _); return(null); }