public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
using (var resultScope = JitCompileAndGetMethods(streams.AssemblyStream))
using (var dataTarget = DataTarget.AttachToProcess(Current.ProcessId, uint.MaxValue, AttachFlag.Passive)) {
var currentMethodAddressRef = new Reference <ulong>();
var runtime = dataTarget.ClrVersions.Single(v => v.Flavor == ClrFlavor).CreateRuntime();
var translator = new IntelTranslator {
SymbolResolver = (Instruction instruction, long addr, ref long offset) =>
ResolveSymbol(runtime, instruction, addr, currentMethodAddressRef.Value)
};
WriteJitInfo(runtime.ClrInfo, codeWriter);
WriteProfilerState(codeWriter);
codeWriter.WriteLine();
var architecture = MapArchitecture(runtime.ClrInfo.DacInfo.TargetArchitecture);
foreach (var result in resultScope.Results)
{
DisassembleAndWrite(result, runtime, architecture, translator, currentMethodAddressRef, codeWriter);
codeWriter.WriteLine();
}
}
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
var currentSetup = AppDomain.CurrentDomain.SetupInformation;
using (var dataTarget = DataTarget.AttachToProcess(CurrentProcess.Id, UInt32.MaxValue, AttachFlag.Passive))
using (var context = AppDomainContext.Create(new AppDomainSetup {
ApplicationBase = currentSetup.ApplicationBase,
PrivateBinPath = currentSetup.PrivateBinPath
})) {
context.LoadAssembly(LoadMethod.LoadFrom, Assembly.GetExecutingAssembly().GetAssemblyFile().FullName);
var results = RemoteFunc.Invoke(context.Domain, streams.AssemblyStream, Remote.GetCompiledMethods);
var currentMethodAddressRef = new Reference <ulong>();
var runtime = dataTarget.ClrVersions.Single().CreateRuntime();
var translator = new IntelTranslator {
SymbolResolver = (Instruction instruction, long addr, ref long offset) =>
ResolveSymbol(runtime, instruction, addr, currentMethodAddressRef.Value)
};
WriteJitInfo(runtime.ClrInfo, codeWriter);
var architecture = MapArchitecture(runtime.ClrInfo.DacInfo.TargetArchitecture);
foreach (var result in results)
{
DisassembleAndWrite(result, runtime, architecture, translator, currentMethodAddressRef, codeWriter);
codeWriter.WriteLine();
}
}
}
public static async Task <string> CompileAndExecuteAsync(string code, string languageName = LanguageNames.CSharp)
{
var session = await PrepareWorkSessionAsync(code, languageName);
var assemblyStream = new MemoryStream();
var symbolStream = new MemoryStream();
var diagnostics = new List <Diagnostic>();
var(compiled, hasSymbols) = await new Compiler().TryCompileToStreamAsync(
assemblyStream,
symbolStream,
session,
diagnostics,
CancellationToken.None
);
if (!compiled)
{
throw new Exception("Compilation failed:\n" + string.Join('\n', diagnostics));
}
assemblyStream.Position = 0;
symbolStream.Position = 0;
var streams = new CompilationStreamPair(assemblyStream, hasSymbols ? symbolStream : null);
var executor = CreateContainerExecutor();
return(await executor.ExecuteAsync(streams, session, CancellationToken.None));
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
using (var loadContext = new CustomAssemblyLoadContext(shouldShareAssembly: _ => true)) {
var assembly = loadContext.LoadFromStream(streams.AssemblyStream);
ValidateStaticConstructors(assembly);
using var runtimeLease = _runtimePool.GetOrCreate();
var runtime = runtimeLease.Object;
runtime.Flush();
var context = new JitWriteContext(codeWriter, runtime);
context.Translator = new IntelTranslator {
SymbolResolver = (Instruction instruction, long addr, ref long offset) =>
ResolveSymbol(runtime, instruction, addr, context.CurrentMethodAddress)
};
WriteJitInfo(runtime.ClrInfo, codeWriter);
WriteProfilerState(codeWriter);
var architecture = MapArchitecture(runtime.ClrInfo.DacInfo.TargetArchitecture);
foreach (var type in assembly.DefinedTypes)
{
if (type.IsNested)
{
continue; // it's easier to handle nested generic types recursively, so we suppress all nested for consistency
}
DisassembleAndWriteMembers(context, type);
}
}
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
using (var loadContext = new CustomAssemblyLoadContext(shouldShareAssembly: _ => true)) {
var assembly = loadContext.LoadFromStream(streams.AssemblyStream);
ValidateStaticConstructors(assembly);
using var runtimeLease = _runtimePool.GetOrCreate();
var runtime = runtimeLease.Object;
runtime.Flush();
var context = new JitWriteContext(codeWriter, runtime);
WriteJitInfo(runtime.ClrInfo, codeWriter);
WriteProfilerState(codeWriter);
foreach (var type in assembly.DefinedTypes)
{
if (type.IsNested)
{
continue; // it's easier to handle nested generic types recursively, so we suppress all nested for consistency
}
DisassembleAndWriteMembers(context, type);
}
}
}
public async Task <string> ExecuteAsync(CompilationStreamPair streams, IWorkSession session, CancellationToken cancellationToken)
{
var includePerformance = session.ShouldReportPerformance();
var rewriteStopwatch = includePerformance ? Stopwatch.StartNew() : null;
var readerParameters = new ReaderParameters {
ReadSymbols = streams.SymbolStream != null,
SymbolStream = streams.SymbolStream,
AssemblyResolver = _assemblyResolver,
SymbolReaderProvider = streams.SymbolStream != null ? _symbolReaderProvider : null
};
using var definition = AssemblyDefinition.ReadAssembly(streams.AssemblyStream, readerParameters);
foreach (var rewriter in _rewriters)
{
rewriter.Rewrite(definition, session);
}
using var rewrittenStream = _memoryStreamManager.GetStream();
definition.Write(rewrittenStream);
rewrittenStream.Seek(0, SeekOrigin.Begin);
rewriteStopwatch?.Stop();
var executeStopwatch = includePerformance ? Stopwatch.StartNew() : null;
var output = await _client.ExecuteAsync(session.GetSessionId(), rewrittenStream, includePerformance, cancellationToken);
if (rewriteStopwatch != null && executeStopwatch != null)
{
// TODO: Prettify
output += $"\n REWRITERS: {rewriteStopwatch.ElapsedMilliseconds,17}ms\n CONTAINER EXECUTOR: {executeStopwatch.ElapsedMilliseconds,8}ms";
}
return(output);
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
var readerParameters = new ReaderParameters {
AssemblyResolver = _assemblyResolver
};
using (var module = ModuleDefinition.ReadModule(streams.AssemblyStream, readerParameters)) {
var decompiler = new ICSharpCode.Decompiler.CSharp.CSharpDecompiler(module, DecompilerSettings);
var syntaxTree = decompiler.DecompileWholeModuleAsSingleFile();
new CSharpOutputVisitor(codeWriter, FormattingOptions).VisitSyntaxTree(syntaxTree);
}
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
using (var assemblyFile = new PEFile("", streams.AssemblyStream))
using (var debugInfo = streams.SymbolStream != null ? _debugInfoFactory(streams.SymbolStream) : null) {
var decompiler = new ICSharpCode.Decompiler.CSharp.CSharpDecompiler(assemblyFile, _assemblyResolver, DecompilerSettings)
{
DebugInfoProvider = debugInfo
};
var syntaxTree = decompiler.DecompileWholeModuleAsSingleFile();
new CSharpOutputVisitor(codeWriter, FormattingOptions).VisitSyntaxTree(syntaxTree);
}
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
using (var assemblyFile = new PEFile("", streams.AssemblyStream))
using (var debugInfo = streams.SymbolStream != null ? _debugInfoFactory(streams.SymbolStream) : null) {
var output = new PlainTextOutput(codeWriter)
{
IndentationString = " "
};
var disassembler = new ReflectionDisassembler(output, CancellationToken.None)
{
DebugInfo = debugInfo,
ShowSequencePoints = true
};
disassembler.WriteModuleContents(assemblyFile);
}
}
public ExecutionResult Execute(CompilationStreamPair streams, IWorkSession session)
{
var readerParameters = new ReaderParameters {
ReadSymbols = streams.SymbolStream != null,
SymbolStream = streams.SymbolStream,
AssemblyResolver = _assemblyResolver,
SymbolReaderProvider = streams.SymbolStream != null ? _symbolReaderProvider : null
};
using (streams)
using (var definition = AssemblyDefinition.ReadAssembly(streams.AssemblyStream, readerParameters)) {
foreach (var rewriter in _rewriters)
{
rewriter.Rewrite(definition, session);
}
PerformanceLog.Checkpoint("Executor.Rewrite.Flow.End");
AssemblyLog.Log("2.WithFlow", definition);
if (definition.EntryPoint == null)
{
Output.Reset();
Flow.Reset();
Output.WriteWarning("Could not find any code to run (either a Main method or any top level code).");
return(new ExecutionResult(Output.Stream, Flow.Steps));
}
var guardToken = AssemblyGuard.Rewrite(definition, _guardSettings);
using (var rewrittenStream = _memoryStreamManager.GetStream()) {
definition.Write(rewrittenStream);
AssemblyLog.Log("3.Unbreakable", definition);
rewrittenStream.Seek(0, SeekOrigin.Begin);
PerformanceLog.Checkpoint("Executor.Rewrite.Unbreakable.End");
using (var context = new CustomAssemblyLoadContext(shouldShareAssembly: ShouldShareAssembly)) {
var assembly = context.LoadFromStream(rewrittenStream);
PerformanceLog.Checkpoint("Executor.AssemblyLoad.End");
return(Execute(assembly, guardToken, session));
}
}
}
}
public ExecutionResult Execute(CompilationStreamPair streams, IWorkSession session)
{
var readerParameters = new ReaderParameters {
ReadSymbols = streams.SymbolStream != null,
SymbolStream = streams.SymbolStream,
AssemblyResolver = _assemblyResolver,
SymbolReaderProvider = streams.SymbolStream != null ? _symbolReaderProvider : null
};
using (streams)
using (var definition = AssemblyDefinition.ReadAssembly(streams.AssemblyStream, readerParameters)) {
AssemblyLog.Log("1.Initial", definition);
foreach (var rewriter in _rewriters)
{
rewriter.Rewrite(definition, session);
}
PerformanceLog.Checkpoint("Executor.Rewrite.Flow.End");
AssemblyLog.Log("2.WithFlow", definition);
if (definition.EntryPoint == null)
{
throw new ArgumentException("Failed to find an entry point (Main?) in assembly.", nameof(streams));
}
var guardToken = AssemblyGuard.Rewrite(definition, _guardSettings);
using (var rewrittenStream = _memoryStreamManager.GetStream()) {
definition.Write(rewrittenStream);
AssemblyLog.Log("3.Unbreakable", definition);
rewrittenStream.Seek(0, SeekOrigin.Begin);
PerformanceLog.Checkpoint("Executor.Rewrite.Unbreakable.End");
using (var context = new CustomAssemblyLoadContext(shouldShareAssembly: ShouldShareAssembly)) {
var assembly = context.LoadFromStream(rewrittenStream);
PerformanceLog.Checkpoint("Executor.AssemblyLoad.End");
return(Execute(assembly, guardToken, session));
}
}
}
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
using (var assemblyFile = new PEFile("", streams.AssemblyStream))
using (var debugInfo = streams.SymbolStream != null ? _debugInfoFactory(streams.SymbolStream) : null) {
//#if DEBUG
//assembly.Write(@"d:\Temp\assembly\" + System.DateTime.Now.Ticks + "-il.dll");
//#endif
var output = new SpaceIndentingPlainTextOutput(codeWriter);
var disassembler = new ReflectionDisassembler(output, CancellationToken.None)
{
DebugInfo = debugInfo,
ShowSequencePoints = true
};
disassembler.WriteModuleContents(assemblyFile);
}
}
public ExecutionResult Execute(CompilationStreamPair streams, IWorkSession session)
{
var readerParameters = new ReaderParameters {
ReadSymbols = streams.SymbolStream != null,
SymbolStream = streams.SymbolStream,
AssemblyResolver = _assemblyResolver,
SymbolReaderProvider = streams.SymbolStream != null ? _symbolReaderProvider : null
};
using (streams)
using (var assembly = AssemblyDefinition.ReadAssembly(streams.AssemblyStream, readerParameters)) {
/*
#if DEBUG
* assembly.Write(@"d:\Temp\assembly\" + DateTime.Now.Ticks + "-before-rewrite.dll");
#endif
*/
foreach (var rewriter in _rewriters)
{
rewriter.Rewrite(assembly, session);
}
if (assembly.EntryPoint == null)
{
throw new ArgumentException("Failed to find an entry point (Main?) in assembly.", nameof(streams));
}
var guardToken = AssemblyGuard.Rewrite(assembly, _guardSettings);
using (var rewrittenStream = _memoryStreamManager.GetStream()) {
assembly.Write(rewrittenStream);
/*
#if DEBUG
* assembly.Write(@"d:\Temp\assembly\" + DateTime.Now.Ticks + ".dll");
#endif
*/
rewrittenStream.Seek(0, SeekOrigin.Begin);
return(ExecuteInAppDomain(rewrittenStream, guardToken, session));
}
}
}
public ExecutionResult Execute(CompilationStreamPair streams, IWorkSession session)
{
var readerParameters = new ReaderParameters {
ReadSymbols = streams.SymbolStream != null,
SymbolStream = streams.SymbolStream,
AssemblyResolver = _assemblyResolver,
SymbolReaderProvider = streams.SymbolStream != null ? _symbolReaderProvider : null
};
using (streams)
using (var definition = AssemblyDefinition.ReadAssembly(streams.AssemblyStream, readerParameters)) {
AssemblyLog.Log("1.Initial", definition);
foreach (var rewriter in _rewriters)
{
rewriter.Rewrite(definition, session);
}
AssemblyLog.Log("2.WithFlow", definition);
if (definition.EntryPoint == null)
{
throw new ArgumentException("Failed to find an entry point (Main?) in assembly.", nameof(streams));
}
var guardToken = AssemblyGuard.Rewrite(definition, _guardSettings);
using (var rewrittenStream = _memoryStreamManager.GetStream()) {
definition.Write(rewrittenStream);
AssemblyLog.Log("3.Unbreakable", definition);
rewrittenStream.Seek(0, SeekOrigin.Begin);
var(result, exception) = ExecuteWithIsolation(rewrittenStream, guardToken, session);
if (ShouldMonitorException(exception))
{
_monitor.Exception(exception !, session);
}
return(result);
}
}
}
public void Decompile(CompilationStreamPair streams, TextWriter codeWriter)
{
Argument.NotNull(nameof(streams), streams);
Argument.NotNull(nameof(codeWriter), codeWriter);
var assembly = AssemblyDefinition.ReadAssembly(streams.AssemblyStream, new ReaderParameters {
ReadSymbols = streams.SymbolStream != null,
SymbolStream = streams.SymbolStream,
SymbolReaderProvider = streams.SymbolStream != null ? _symbolReaderProvider : null
});
//#if DEBUG
//assembly.Write(@"d:\Temp\assembly\" + System.DateTime.Now.Ticks + "-il.dll");
//#endif
var output = new SpaceIndentingPlainTextOutput(codeWriter);
var disassembler = new ReflectionDisassembler(output, CancellationToken.None)
{
ShowSequencePoints = true
};
disassembler.WriteModuleContents(assembly.MainModule);
}
public async Task <object?> ProcessAsync(IWorkSession session, IList <Diagnostic> diagnostics, CancellationToken cancellationToken)
{
PerformanceLog.Checkpoint("SlowUpdate.ProcessAsync.Start");
var targetName = GetAndEnsureTargetName(session);
if (targetName == TargetNames.Ast || targetName == TargetNames.Explain)
{
var astTarget = _astTargets[session.LanguageName];
var ast = await astTarget.GetAstAsync(session, cancellationToken).ConfigureAwait(false);
if (targetName == TargetNames.Explain)
{
return(await _explainer.ExplainAsync(ast, session, cancellationToken).ConfigureAwait(false));
}
return(ast);
}
if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
return(null);
}
if (targetName == LanguageNames.VisualBasic)
{
return(VisualBasicNotAvailable);
}
if (targetName != TargetNames.Run && targetName != TargetNames.Verify && !_decompilers.ContainsKey(targetName))
{
throw new NotSupportedException($"Target '{targetName}' is not (yet?) supported by this branch.");
}
MemoryStream?assemblyStream = null;
MemoryStream?symbolStream = null;
try {
assemblyStream = _memoryStreamManager.GetStream();
if (targetName == TargetNames.Run || targetName == TargetNames.IL)
{
symbolStream = _memoryStreamManager.GetStream();
}
var compiled = await _compiler.TryCompileToStreamAsync(assemblyStream, symbolStream, session, diagnostics, cancellationToken).ConfigureAwait(false);
if (!compiled.assembly)
{
assemblyStream.Dispose();
symbolStream?.Dispose();
return(null);
}
if (targetName == TargetNames.Verify)
{
assemblyStream.Dispose();
symbolStream?.Dispose();
return("✔️ Compilation completed.");
}
assemblyStream.Seek(0, SeekOrigin.Begin);
symbolStream?.Seek(0, SeekOrigin.Begin);
var streams = new CompilationStreamPair(assemblyStream, compiled.symbols ? symbolStream : null);
if (targetName == TargetNames.Run)
{
return(_executor.Execute(streams, session));
}
// it's fine not to Dispose() here -- MirrorSharp will dispose it after calling WriteResult()
return(streams);
}
catch {
assemblyStream?.Dispose();
symbolStream?.Dispose();
throw;
}
}
public async Task <object?> ProcessAsync(IWorkSession session, IList <Diagnostic> diagnostics, CancellationToken cancellationToken)
{
PerformanceLog.Checkpoint("SlowUpdate.ProcessAsync.Start");
var targetName = GetAndEnsureTargetName(session);
_topLevelProgramSupport.UpdateOutputKind(session, diagnostics);
if (targetName is TargetNames.Ast or TargetNames.Explain)
{
var astTarget = _astTargets[session.LanguageName];
var ast = await astTarget.GetAstAsync(session, cancellationToken).ConfigureAwait(false);
if (targetName == TargetNames.Explain)
{
return(await _explainer.ExplainAsync(ast, session, cancellationToken).ConfigureAwait(false));
}
return(ast);
}
if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
return(null);
}
if (targetName == LanguageNames.VisualBasic)
{
return(VisualBasicNotAvailable);
}
if (targetName is not(TargetNames.Run or TargetNames.Verify) && !_decompilers.ContainsKey(targetName))
{
throw new NotSupportedException($"Target '{targetName}' is not (yet?) supported by this branch.");
}
MemoryStream?assemblyStream = null;
MemoryStream?symbolStream = null;
try {
assemblyStream = _memoryStreamManager.GetStream();
if (targetName is TargetNames.Run or TargetNames.IL)
{
symbolStream = _memoryStreamManager.GetStream();
}
var compilationStopwatch = session.ShouldReportPerformance() ? Stopwatch.StartNew() : null;
var compiled = await _compiler.TryCompileToStreamAsync(assemblyStream, symbolStream, session, diagnostics, cancellationToken).ConfigureAwait(false);
compilationStopwatch?.Stop();
if (!compiled.assembly)
{
assemblyStream.Dispose();
symbolStream?.Dispose();
return(null);
}
if (targetName == TargetNames.Verify)
{
assemblyStream.Dispose();
symbolStream?.Dispose();
return("✔️ Compilation completed.");
}
assemblyStream.Seek(0, SeekOrigin.Begin);
symbolStream?.Seek(0, SeekOrigin.Begin);
AssemblyLog.Log("1.Compiled", assemblyStream, compiled.symbols ? symbolStream : null);
var streams = new CompilationStreamPair(assemblyStream, compiled.symbols ? symbolStream : null);
if (targetName == TargetNames.Run)
{
if (!session.HasContainerExperimentFailed())
{
try {
var output = await _containerExecutor.ExecuteAsync(streams, session, cancellationToken);
if (compilationStopwatch != null)
{
// TODO: Prettify
output += $"\n COMPILATION: {compilationStopwatch.ElapsedMilliseconds,15}ms";
}
streams.Dispose();
_monitor.Metric(ContainerExperimentMetrics.ContainerRunCount, 1);
return(output);
}
catch (Exception ex) {
_monitor.Metric(ContainerExperimentMetrics.ContainerFailureCount, 1);
_monitor.Exception(ex, session);
session.SetContainerExperimentException(ex);
assemblyStream.Seek(0, SeekOrigin.Begin);
symbolStream?.Seek(0, SeekOrigin.Begin);
}
}
_monitor.Metric(ContainerExperimentMetrics.LegacyRunCount, 1);
return(_executor.Execute(streams, session));
}
// it's fine not to Dispose() here -- MirrorSharp will dispose it after calling WriteResult()
return(streams);
}
catch {
assemblyStream?.Dispose();
symbolStream?.Dispose();
throw;
}
}