private unsafe void VisualizeGenerations(List <GenerationData> generations)
{
var mdReaders = generations.Select(g => g.MetadataReader).ToArray();
var visualizer = new MetadataVisualizer(mdReaders, _writer);
for (int generationIndex = 0; generationIndex < generations.Count; generationIndex++)
{
if (_arguments.SkipGenerations.Contains(generationIndex))
{
continue;
}
var generation = generations[generationIndex];
var mdReader = generation.MetadataReader;
visualizer.VisualizeHeaders();
_writer.WriteLine(">>>");
_writer.WriteLine(string.Format(">>> Generation {0}:", generationIndex));
_writer.WriteLine(">>>");
_writer.WriteLine();
if (_arguments.DisplayMetadata)
{
visualizer.Visualize(generationIndex);
}
if (_arguments.DisplayIL)
{
VisualizeGenerationIL(visualizer, generationIndex, generation, mdReader);
}
VisualizeMemberRefs(mdReader);
}
}
internal static void VerifyIL(
this ImmutableArray <byte> assembly,
string qualifiedName,
string expectedIL,
[CallerLineNumber] int expectedValueSourceLine = 0,
[CallerFilePath] string expectedValueSourcePath = null)
{
var parts = qualifiedName.Split('.');
if (parts.Length != 2)
{
throw new NotImplementedException();
}
using (var module = new PEModule(new PEReader(assembly), metadataOpt: IntPtr.Zero, metadataSizeOpt: 0))
{
var reader = module.MetadataReader;
var typeDef = reader.GetTypeDef(parts[0]);
var methodName = parts[1];
var methodHandle = reader.GetMethodDefHandle(typeDef, methodName);
var methodBody = module.GetMethodBodyOrThrow(methodHandle);
var pooled = PooledStringBuilder.GetInstance();
var builder = pooled.Builder;
var writer = new StringWriter(pooled.Builder);
var visualizer = new MetadataVisualizer(reader, writer);
visualizer.VisualizeMethodBody(methodBody, methodHandle, emitHeader: false);
var actualIL = pooled.ToStringAndFree();
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine);
}
}
static void Main(string[] args)
{
if (args.Length == 0 || new[] { "/?", "-?", "-h", "--help" }.Any(x => string.Equals(args[0], x, StringComparison.OrdinalIgnoreCase)))
{
PrintUsage();
return;
}
foreach (var fileName in args)
{
Console.WriteLine(fileName);
Console.WriteLine(new string('*', 80));
try
{
using (var stream = File.OpenRead(fileName))
using (var peFile = new PEReader(stream))
{
var metadataReader = peFile.GetMetadataReader();
var visualizer = new MetadataVisualizer(metadataReader, Console.Out);
visualizer.Visualize();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
private static unsafe void VisualizeGenerationIL(MetadataVisualizer visualizer, int generationIndex, GenerationData generation, MetadataReader mdReader)
{
if (generation.PEReaderOpt != null)
{
foreach (var methodHandle in mdReader.MethodDefinitions)
{
var method = mdReader.GetMethodDefinition(methodHandle);
var rva = method.RelativeVirtualAddress;
if (rva != 0)
{
var body = generation.PEReaderOpt.GetMethodBody(rva);
visualizer.VisualizeMethodBody(body, methodHandle);
}
}
}
else if (generation.DeltaILOpt != null)
{
fixed(byte *deltaILPtr = generation.DeltaILOpt)
{
foreach (var generationHandle in mdReader.MethodDefinitions)
{
var method = mdReader.GetMethodDefinition(generationHandle);
var rva = method.RelativeVirtualAddress;
if (rva != 0)
{
var body = MethodBodyBlock.Create(new BlobReader(deltaILPtr + rva, generation.DeltaILOpt.Length - rva));
visualizer.VisualizeMethodBody(body, generationHandle, generationIndex);
}
}
}
}
}
static void Main(string[] args)
{
if (args.Length == 0 || new[] {"/?", "-?", "-h", "--help"}.Any(x => string.Equals(args[0], x, StringComparison.OrdinalIgnoreCase)))
{
PrintUsage();
return;
}
foreach (var fileName in args)
{
Console.WriteLine(fileName);
Console.WriteLine(new string('*', 80));
try
{
using (var stream = File.OpenRead(fileName))
using (var peFile = new PEReader(stream))
{
var metadataReader = peFile.GetMetadataReader();
var visualizer = new MetadataVisualizer(metadataReader, Console.Out);
visualizer.Visualize();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
public void MethodToMethodWithClosure()
{
var source0 =
@"delegate object D();
class C
{
static object F(object o)
{
return o;
}
}";
var source1 =
@"delegate object D();
class C
{
static object F(object o)
{
return ((D)(() => o))();
}
}";
var compilation0 = CreateCompilationWithMscorlib(source0, options: TestOptions.DebugDll);
var compilation1 = compilation0.WithSource(source1);
var bytes0 = compilation0.EmitToArray();
var generation0 = EmitBaseline.CreateInitialBaseline(ModuleMetadata.CreateFromImage(bytes0), EmptyLocalsProvider);
var diff1 = compilation1.EmitDifference(
generation0,
ImmutableArray.Create(new SemanticEdit(SemanticEditKind.Update, compilation0.GetMember <MethodSymbol>("C.F"), compilation1.GetMember <MethodSymbol>("C.F"))));
using (var md1 = diff1.GetMetadata())
{
var reader1 = md1.Reader;
var w = new StringWriter();
var v = new MetadataVisualizer(new[] { generation0.MetadataReader, reader1 }, w);
v.VisualizeAllGenerations();
var s = w.ToString();
// Field 'o'
// Methods: 'F', '.ctor', '<F>b__1'
// Type: display class
CheckEncLogDefinitions(reader1,
Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
Row(3, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
Row(4, TableIndex.TypeDef, EditAndContinueOperation.Default),
Row(4, TableIndex.TypeDef, EditAndContinueOperation.AddField),
Row(1, TableIndex.Field, EditAndContinueOperation.Default),
Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
Row(4, TableIndex.TypeDef, EditAndContinueOperation.AddMethod),
Row(7, TableIndex.MethodDef, EditAndContinueOperation.Default),
Row(4, TableIndex.TypeDef, EditAndContinueOperation.AddMethod),
Row(8, TableIndex.MethodDef, EditAndContinueOperation.Default),
Row(4, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
Row(1, TableIndex.NestedClass, EditAndContinueOperation.Default));
}
}
unsafe protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
{
var md = (MetadataDelta)objectProvider.GetObject();
var writer = new StringWriter();
fixed (byte* ptr = md.Bytes)
{
var reader = new MetadataReader(ptr, md.Bytes.Length, MetadataReaderOptions.ApplyWindowsRuntimeProjections);
var visualizer = new MetadataVisualizer(reader, writer);
visualizer.Visualize();
}
var viewer = new TextViewer(writer.ToString(), "Metadata");
viewer.ShowDialog();
}
private static unsafe string GetMetadataText(MetadataDelta metadataDelta)
{
var writer = new StringWriter();
fixed (byte* ptr = metadataDelta.Bytes)
{
var reader = new MetadataReader(ptr, metadataDelta.Bytes.Length, MetadataReaderOptions.ApplyWindowsRuntimeProjections);
var visualizer = new MetadataVisualizer(reader, writer);
visualizer.Visualize();
}
return writer.ToString();
}
private static unsafe string GetMetadataText(MetadataDelta metadataDelta)
{
var writer = new StringWriter();
fixed(byte *ptr = metadataDelta.Bytes)
{
var reader = new MetadataReader(ptr, metadataDelta.Bytes.Length, MetadataReaderOptions.ApplyWindowsRuntimeProjections);
var visualizer = new MetadataVisualizer(reader, writer);
visualizer.Visualize();
}
return(writer.ToString());
}
internal static void VerifyIL(
this byte[] assembly,
int methodToken,
string qualifiedName,
string expectedIL,
[CallerLineNumber] int expectedValueSourceLine = 0,
[CallerFilePath] string expectedValueSourcePath = null)
{
var parts = qualifiedName.Split('.');
if (parts.Length != 2)
{
throw new NotImplementedException();
}
using (var metadata = ModuleMetadata.CreateFromImage(assembly))
{
var module = metadata.Module;
var reader = module.MetadataReader;
var methodHandle = (MethodDefinitionHandle)MetadataTokens.Handle(methodToken);
var methodDef = reader.GetMethodDefinition(methodHandle);
var typeDef = reader.GetTypeDefinition(methodDef.GetDeclaringType());
Assert.True(reader.StringComparer.Equals(typeDef.Name, parts[0]));
Assert.True(reader.StringComparer.Equals(methodDef.Name, parts[1]));
var methodBody = module.GetMethodBodyOrThrow(methodHandle);
var pooled = PooledStringBuilder.GetInstance();
var builder = pooled.Builder;
if (!methodBody.LocalSignature.IsNil)
{
var visualizer = new MetadataVisualizer(reader, new StringWriter(), MetadataVisualizerOptions.NoHeapReferences);
var signature = reader.GetStandaloneSignature(methodBody.LocalSignature);
builder.AppendFormat("Locals: {0}", visualizer.StandaloneSignature(signature.Signature));
builder.AppendLine();
}
ILVisualizer.Default.DumpMethod(
builder,
methodBody.MaxStack,
methodBody.GetILContent(),
ImmutableArray.Create <ILVisualizer.LocalInfo>(),
ImmutableArray.Create <ILVisualizer.HandlerSpan>());
var actualIL = pooled.ToStringAndFree();
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine);
}
}
unsafe protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
{
var md = (MetadataDelta)objectProvider.GetObject();
var writer = new StringWriter();
fixed(byte *ptr = md.Bytes)
{
var reader = new MetadataReader(ptr, md.Bytes.Length, MetadataReaderOptions.ApplyWindowsRuntimeProjections);
var visualizer = new MetadataVisualizer(reader, writer);
visualizer.Visualize();
}
var viewer = new TextViewer(writer.ToString(), "Metadata");
viewer.ShowDialog();
}
private static void VerifyPortablePdb(Stream pdbStream, string expectedMetadata, string message)
{
using (var provider = MetadataReaderProvider.FromPortablePdbStream(pdbStream, MetadataStreamOptions.LeaveOpen))
{
var mdReader = provider.GetMetadataReader();
var writer = new StringWriter();
var mdv = new MetadataVisualizer(mdReader, writer, MetadataVisualizerOptions.NoHeapReferences);
mdv.WriteDocument();
mdv.WriteMethodDebugInformation();
mdv.WriteLocalScope();
mdv.WriteLocalVariable();
mdv.WriteLocalConstant();
mdv.WriteImportScope();
mdv.WriteCustomDebugInformation();
AssertEx.AssertLinesEqual(expectedMetadata, writer.ToString(), message);
}
}
private void VisualizeGenerations(List <GenerationData> generations)
{
var mdReaders = generations.Select(g => g.MetadataReader).ToArray();
var visualizer = new MetadataVisualizer(mdReaders, _writer);
for (int generationIndex = 0; generationIndex < generations.Count; generationIndex++)
{
if (_arguments.SkipGenerations.Contains(generationIndex))
{
continue;
}
var generation = generations[generationIndex];
var mdReader = generation.MetadataReader;
if (generation.PEReaderOpt != null)
{
VisualizeDebugDirectory(generation.PEReaderOpt, _writer);
}
visualizer.VisualizeHeaders();
if (generations.Count > 1)
{
_writer.WriteLine(">>>");
_writer.WriteLine($">>> Generation {generationIndex}:");
_writer.WriteLine(">>>");
_writer.WriteLine();
}
if (_arguments.DisplayMetadata)
{
visualizer.Visualize(generationIndex);
}
if (_arguments.DisplayIL)
{
VisualizeGenerationIL(visualizer, generationIndex, generation, mdReader);
}
VisualizeMemberRefs(mdReader);
}
}
private static unsafe void VisualizeGenerationIL(MetadataVisualizer visualizer, int generationIndex, GenerationData generation, MetadataReader mdReader)
{
try
{
if (generation.PEReaderOpt != null)
{
foreach (var methodHandle in mdReader.MethodDefinitions)
{
visualizer.VisualizeMethodBody(methodHandle, rva => generation.PEReaderOpt.GetMethodBody(rva));
}
}
else if (generation.ILDeltaOpt != null)
{
fixed(byte *deltaILPtr = generation.ILDeltaOpt)
{
foreach (var generationHandle in mdReader.MethodDefinitions)
{
var method = mdReader.GetMethodDefinition(generationHandle);
var rva = method.RelativeVirtualAddress;
if (rva != 0)
{
var body = MethodBodyBlock.Create(new BlobReader(deltaILPtr + rva, generation.ILDeltaOpt.Length - rva));
visualizer.VisualizeMethodBody(body, generationHandle, generationIndex);
}
}
}
}
else
{
visualizer.WriteLine("<IL not available>");
}
}
catch (BadImageFormatException)
{
visualizer.WriteLine("<bad metadata>");
}
}
private static DataContext Create()
{
PeReader = new PEReader(File.OpenRead(@"some.dll"));
Reader = PeReader.GetMetadataReader();
var visualizer = new MetadataVisualizer(Reader);
return(DataContext.Default.AddTables(
new SchemaTableSymbol(TableDefinition.Create("Assemblies", visualizer.GetAssemblies())),
new SchemaTableSymbol(TableDefinition.Create("AssemblyRefs", visualizer.GetAssemblyRefs())),
new SchemaTableSymbol(TableDefinition.Create("Blobs", visualizer.GetBlobs())),
new SchemaTableSymbol(TableDefinition.Create("Constants", visualizer.GetConstants())),
new SchemaTableSymbol(TableDefinition.Create("CustomAttributes", visualizer.GetCustomAttributes())),
new SchemaTableSymbol(TableDefinition.Create("DeclSecurity", visualizer.GetDeclSecurity())),
new SchemaTableSymbol(TableDefinition.Create("EncLogs", visualizer.GetEnCLogs())),
new SchemaTableSymbol(TableDefinition.Create("Events", visualizer.GetEvents())),
new SchemaTableSymbol(TableDefinition.Create("Fields", visualizer.GetFields())),
new SchemaTableSymbol(TableDefinition.Create("Files", visualizer.GetFiles())),
new SchemaTableSymbol(TableDefinition.Create("GenericParamConstraints", visualizer.GetGenericParamConstraints())),
new SchemaTableSymbol(TableDefinition.Create("GenericParams", visualizer.GetGenericParams())),
new SchemaTableSymbol(TableDefinition.Create("Guids", visualizer.GetGuids())),
new SchemaTableSymbol(TableDefinition.Create("ManifestResources", visualizer.GetManifestResources())),
new SchemaTableSymbol(TableDefinition.Create("MemberRefs", visualizer.GetMemberRefs())),
new SchemaTableSymbol(TableDefinition.Create("MethodImpls", visualizer.GetMethodImpls())),
new SchemaTableSymbol(TableDefinition.Create("Methods", visualizer.GetMethods())),
new SchemaTableSymbol(TableDefinition.Create("MethodSpecs", visualizer.GetMethodSpecs())),
new SchemaTableSymbol(TableDefinition.Create("Modules", visualizer.GetModule())),
new SchemaTableSymbol(TableDefinition.Create("ModuleRefs", visualizer.GetModuleRefs())),
new SchemaTableSymbol(TableDefinition.Create("Params", visualizer.GetParams())),
new SchemaTableSymbol(TableDefinition.Create("Properties", visualizer.GetProperties())),
new SchemaTableSymbol(TableDefinition.Create("StandAloneSigs", visualizer.GetStandAloneSigs())),
new SchemaTableSymbol(TableDefinition.Create("Strings", visualizer.GetStrings())),
new SchemaTableSymbol(TableDefinition.Create("TypeDefs", visualizer.GetTypeDefs())),
new SchemaTableSymbol(TableDefinition.Create("TypeRefs", visualizer.GetTypeRef())),
new SchemaTableSymbol(TableDefinition.Create("TypeSpecs", visualizer.GetTypeSpecs())),
new SchemaTableSymbol(TableDefinition.Create("UserStrings", visualizer.GetUserStrings()))
));
}
internal static void VerifyIL(
this byte[] assembly,
int methodToken,
string qualifiedName,
string expectedIL,
[CallerLineNumber] int expectedValueSourceLine = 0,
[CallerFilePath] string expectedValueSourcePath = null)
{
var parts = qualifiedName.Split('.');
if (parts.Length != 2)
{
throw new NotImplementedException();
}
using (var metadata = ModuleMetadata.CreateFromImage(assembly))
{
var module = metadata.Module;
var reader = module.MetadataReader;
var methodHandle = (MethodDefinitionHandle)MetadataTokens.Handle(methodToken);
var methodDef = reader.GetMethodDefinition(methodHandle);
var typeDef = reader.GetTypeDefinition(methodDef.GetDeclaringType());
Assert.True(reader.StringComparer.Equals(typeDef.Name, parts[0]));
Assert.True(reader.StringComparer.Equals(methodDef.Name, parts[1]));
var methodBody = module.GetMethodBodyOrThrow(methodHandle);
var pooled = PooledStringBuilder.GetInstance();
var builder = pooled.Builder;
var writer = new StringWriter(pooled.Builder);
var visualizer = new MetadataVisualizer(reader, writer);
visualizer.VisualizeMethodBody(methodBody, methodHandle, emitHeader: false);
var actualIL = pooled.ToStringAndFree();
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine);
}
}
public SignatureVisualizer(MetadataVisualizer visualizer)
{
_visualizer = visualizer;
}
public void ImportScopeEquality()
{
var sources = new[] { @"
extern alias A;
using System;
using C = System;
namespace N.M
{
using System.Collections;
class C1 { void F() {} }
}
namespace N.M
{
using System.Collections;
class C2 { void F() {} }
}
", @"
extern alias A;
using System;
using C = System;
namespace N.M
{
using System.Collections;
class C3 { void F() {} }
}
namespace N.M
{
using System.Collections.Generic;
class C4 { void F() {} }
}
", @"
extern alias A;
using System;
using D = System;
namespace N.M
{
using System.Collections;
class C5 { void F() {} }
}
", @"
extern alias A;
using System;
class C6 { void F() {} }
" };
var c = CreateCompilationWithMscorlib(sources, new[] { SystemCoreRef.WithAliases(ImmutableArray.Create("A")) });
var pdbStream = new MemoryStream();
c.EmitToArray(EmitOptions.Default.WithDebugInformationFormat(DebugInformationFormat.PortablePdb), pdbStream: pdbStream);
var pdbImage = pdbStream.ToImmutable();
using (var metadata = new PinnedMetadata(pdbImage))
{
var mdReader = metadata.Reader;
var writer = new StringWriter();
var mdVisualizer = new MetadataVisualizer(mdReader, writer);
mdVisualizer.WriteImportScope();
AssertEx.AssertEqualToleratingWhitespaceDifferences(@"
ImportScope (index: 0x35, size: 36):
=============================================================================================
Parent Imports
=============================================================================================
1: nil (ImportScope) 'A' (#1) = 0x23000002 (AssemblyRef)
2: 0x35000001 (ImportScope) Extern Alias 'A' (#1), 'System' (#7)
3: 0x35000001 (ImportScope) Extern Alias 'A' (#1), 'System' (#7), 'C' (#1d) = 'System' (#7)
4: 0x35000003 (ImportScope) nil
5: 0x35000004 (ImportScope) 'System.Collections' (#27)
6: 0x35000004 (ImportScope) 'System.Collections.Generic' (#4b)
7: 0x35000001 (ImportScope) Extern Alias 'A' (#1), 'System' (#7), 'D' (#69) = 'System' (#7)
8: 0x35000007 (ImportScope) nil
9: 0x35000008 (ImportScope) 'System.Collections' (#27)
", writer.ToString());
}
}
