internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, string source = null) { Dictionary <int, string> markers = null; if (sequencePoints != null) { var actualPdbXml = PdbToXmlConverter.ToXml( pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()), peStream: new MemoryStream(EmittedAssemblyData.ToArray()), options: PdbToXmlOptions.ResolveTokens | PdbToXmlOptions.ThrowOnError | PdbToXmlOptions.ExcludeDocuments | PdbToXmlOptions.ExcludeCustomDebugInformation | PdbToXmlOptions.ExcludeScopes, methodName: sequencePoints); markers = ILValidation.GetSequencePointMarkers(actualPdbXml, source); } if (!realIL) { return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers)); } if (_lazyModuleSymbol == null) { var targetReference = LoadTestEmittedExecutableForSymbolValidation(EmittedAssemblyData, _compilation.Options.OutputKind, display: _compilation.AssemblyName); _lazyModuleSymbol = GetSymbolFromMetadata(targetReference, MetadataImportOptions.All); } return(_lazyModuleSymbol != null?_visualizeRealIL(_lazyModuleSymbol, methodData, markers) : null); }
internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null) { Dictionary <int, string> markers = null; if (sequencePoints != null) { var actualPdbXml = PdbToXmlConverter.ToXml( pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()), peStream: new MemoryStream(EmittedAssemblyData.ToArray()), options: PdbToXmlOptions.ResolveTokens | PdbToXmlOptions.ThrowOnError | PdbToXmlOptions.ExcludeDocuments | PdbToXmlOptions.ExcludeCustomDebugInformation | PdbToXmlOptions.ExcludeScopes, methodName: sequencePoints); markers = PdbValidation.GetMarkers(actualPdbXml); } if (!realIL) { return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers)); } if (_lazyModuleSymbol == null) { _lazyModuleSymbol = GetModuleSymbolForEmittedImage(EmittedAssemblyData, MetadataImportOptions.All); } return(_lazyModuleSymbol != null?_test.VisualizeRealIL(_lazyModuleSymbol, methodData, markers) : null); }
internal static void VerifyIL( this CompilationTestData.MethodData method, string expectedIL, [CallerLineNumber] int expectedValueSourceLine = 0, [CallerFilePath] string expectedValueSourcePath = null ) { const string moduleNamePlaceholder = "{#Module#}"; string actualIL = GetMethodIL(method); if (expectedIL.IndexOf(moduleNamePlaceholder) >= 0) { var module = method.Method.ContainingModule; var moduleName = Path.GetFileNameWithoutExtension(module.Name); expectedIL = expectedIL.Replace(moduleNamePlaceholder, moduleName); } AssertEx.AssertEqualToleratingWhitespaceDifferences( expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine ); }
private static void VerifyMethodData(CompilationTestData.MethodData methodData, string expectedType, string expectedIL) { methodData.VerifyIL(expectedIL); var method = (MethodSymbol)methodData.Method; VerifyTypeParameters(method); Assert.Equal(expectedType, method.ReturnType.ToTestDisplayString()); }
internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, string source = null) { Dictionary <int, string> markers = null; if (sequencePoints != null) { if (EmittedAssemblyPdb == null) { throw new InvalidOperationException($"{nameof(EmittedAssemblyPdb)} is not set"); } if (EmittedAssemblyData == null) { throw new InvalidOperationException($"{nameof(EmittedAssemblyData)} is not set"); } var actualPdbXml = PdbToXmlConverter.ToXml( pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()), peStream: new MemoryStream(EmittedAssemblyData.ToArray()), options: PdbToXmlOptions.ResolveTokens | PdbToXmlOptions.ThrowOnError | PdbToXmlOptions.ExcludeDocuments | PdbToXmlOptions.ExcludeCustomDebugInformation | PdbToXmlOptions.ExcludeScopes, methodName: sequencePoints); if (actualPdbXml.StartsWith("<error>")) { throw new Exception($"Failed to extract PDB information for method '{sequencePoints}'. PdbToXmlConverter returned:\r\n{actualPdbXml}"); } markers = ILValidation.GetSequencePointMarkers(actualPdbXml, source); } if (!realIL) { return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers)); } if (_lazyModuleSymbol == null) { var targetReference = LoadTestEmittedExecutableForSymbolValidation(EmittedAssemblyData, _compilation.Options.OutputKind, display: _compilation.AssemblyName); _lazyModuleSymbol = GetSymbolFromMetadata(targetReference, MetadataImportOptions.All); } if (_lazyModuleSymbol != null) { if (_visualizeRealIL == null) { throw new InvalidOperationException("IL visualization function is not set"); } return(_visualizeRealIL(_lazyModuleSymbol, methodData, markers, _testData.Module.GetMethodBody(methodData.Method).AreLocalsZeroed)); } return(null); }
internal static EditAndContinueMethodDebugInformation GetEncDebugInfo(this CompilationTestData.MethodData methodData) { // TODO: return(new EditAndContinueMethodDebugInformation( 0, Cci.MetadataWriter.GetLocalSlotDebugInfos(methodData.ILBuilder.LocalSlotManager.LocalsInOrder()), closures: ImmutableArray <ClosureDebugInfo> .Empty, lambdas: ImmutableArray <LambdaDebugInfo> .Empty)); }
internal static void VerifyIL( this CompilationTestData.MethodData method, string expectedIL, [CallerLineNumber] int expectedValueSourceLine = 0, [CallerFilePath] string expectedValueSourcePath = null) { string actualIL = GetMethodIL(method); AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine); }
private string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, bool useRefEmitter) { if (!realIL) { return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder)); } var module = this.GetModuleSymbolForEmittedImage(); return(module != null?test.VisualizeRealIL(module, methodData) : null); }
/// <summary> /// Returns a string representation of IL read from metadata. /// </summary> /// <remarks> /// Currently unsupported IL decoding: /// - multidimensional arrays /// - vararg calls /// - winmd /// - global methods /// </remarks> internal unsafe static string VisualizeRealIL(PEModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers) { var typeName = GetContainingTypeMetadataName(methodData.Method); // TODO (tomat): global methods (typeName == null) var type = peModule.ContainingAssembly.GetTypeByMetadataName(typeName); // TODO (tomat): overloaded methods var method = (PEMethodSymbol)type.GetMembers(methodData.Method.MetadataName).Single(); var bodyBlock = peModule.Module.GetMethodBodyOrThrow(method.Handle); Assert.NotNull(bodyBlock); var moduleDecoder = new MetadataDecoder(peModule); var peMethod = (PEMethodSymbol)moduleDecoder.GetSymbolForILToken(method.Handle); StringBuilder sb = new StringBuilder(); var ilBytes = bodyBlock.GetILContent(); var ehHandlerRegions = ILVisualizer.GetHandlerSpans(bodyBlock.ExceptionRegions); var methodDecoder = new MetadataDecoder(peModule, peMethod); ImmutableArray <ILVisualizer.LocalInfo> localDefinitions; if (!bodyBlock.LocalSignature.IsNil) { var signature = peModule.Module.MetadataReader.GetStandaloneSignature(bodyBlock.LocalSignature).Signature; var signatureReader = peModule.Module.GetMemoryReaderOrThrow(signature); var localInfos = methodDecoder.DecodeLocalSignatureOrThrow(ref signatureReader); localDefinitions = ToLocalDefinitions(localInfos, methodData.ILBuilder); } else { localDefinitions = ImmutableArray.Create <ILVisualizer.LocalInfo>(); } // TODO (tomat): the .maxstack in IL can't be less than 8, but many tests expect .maxstack < 8 int maxStack = (bodyBlock.MaxStack == 8 && methodData.ILBuilder.MaxStack < 8) ? methodData.ILBuilder.MaxStack : bodyBlock.MaxStack; var visualizer = new Visualizer(new MetadataDecoder(peModule, peMethod)); visualizer.DumpMethod(sb, maxStack, ilBytes, localDefinitions, ehHandlerRegions, markers); return(sb.ToString()); }
private string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints, bool useRefEmitter) { Dictionary <int, string> markers = null; if (sequencePoints != null) { var actualPdbXml = PdbToXmlConverter.ToXml( pdbStream: new MemoryStream(EmittedAssemblyPdb.ToArray()), peStream: new MemoryStream(EmittedAssemblyData.ToArray()), options: PdbToXmlOptions.ResolveTokens | PdbToXmlOptions.ThrowOnError, methodName: sequencePoints); markers = GetMarkers(actualPdbXml); } if (!realIL) { return(ILBuilderVisualizer.ILBuilderToString(methodData.ILBuilder, markers: markers)); } var module = this.GetModuleSymbolForEmittedImage(); return(module != null?_test.VisualizeRealIL(module, methodData, markers) : null); }
internal override string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers) { return(VisualizeRealIL((PEModuleSymbol)peModule, methodData, markers)); }
internal static Func <MethodDefinitionHandle, EditAndContinueMethodDebugInformation> EncDebugInfoProvider(this CompilationTestData.MethodData methodData) { return(_ => methodData.GetEncDebugInfo()); }
internal static string GetMethodIL(this CompilationTestData.MethodData method) { return(ILBuilderVisualizer.ILBuilderToString(method.ILBuilder)); }
internal override string VisualizeRealIL( IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers, bool areLocalsZeroed ) => throw new NotImplementedException();
internal static EditAndContinueMethodDebugInformation GetEncDebugInfo(this CompilationTestData.MethodData methodData) { return(Cci.CustomDebugInfoWriter.GetEncDebugInfoForLocals(methodData.ILBuilder.LocalSlotManager.LocalsInOrder())); }
internal static void VerifyIL(this CompilationTestData.MethodData method, string expectedIL) { string actualIL = GetMethodIL(method); AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL); }
internal abstract string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData);
internal static ImmutableArray <string> GetLocalNames(CompilationTestData.MethodData methodData) { var locals = methodData.ILBuilder.LocalSlotManager.LocalsInOrder(); return(locals.SelectAsArray(l => l.Name)); }
private static bool TryGetMethodData(ImmutableDictionary <string, CompilationTestData.MethodData> map, string qualifiedMethodName, out CompilationTestData.MethodData methodData) { if (map.TryGetValue(qualifiedMethodName, out methodData)) { return(true); } // caller may not have specified parameter list, so try to match parameterless method if (map.TryGetValue(qualifiedMethodName + "()", out methodData)) { return(true); } // now try to match single method with any parameter list var keys = map.Keys.Where(k => k.StartsWith(qualifiedMethodName + "(", StringComparison.Ordinal)); if (keys.Count() == 1) { methodData = map[keys.First()]; return(true); } else if (keys.Count() > 1) { throw new AmbiguousMatchException( "Could not determine best match for method named: " + qualifiedMethodName + Environment.NewLine + string.Join(Environment.NewLine, keys.Select(s => " " + s)) + Environment.NewLine); } else { return(false); } }
internal abstract string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData, IReadOnlyDictionary <int, string> markers);
internal static bool TryGetMethodData(this CompilationTestData data, string qualifiedMethodName, out CompilationTestData.MethodData methodData) { var map = data.GetMethodsByName(); return(TryGetMethodData(map, qualifiedMethodName, out methodData)); }
internal override string VisualizeRealIL(IModuleSymbol peModule, CompilationTestData.MethodData methodData) { return(VisualizeRealIL((PEModuleSymbol)peModule, methodData)); }
> EncDebugInfoProvider(this CompilationTestData.MethodData methodData) { return(_ => methodData.GetEncDebugInfo()); }