public Action <ILNameSyntax> GetGenericTypeParameter(MetadataGenericContext genericContext, int index) { return(syntax => { output.Write("!"); WriteTypeParameter(genericContext.GetGenericTypeParameterHandleOrNull(index), index, syntax); }); }
/// <summary> /// </summary> /// <param name="method"> /// </param> /// <param name="genericTypeSpecializations"> /// </param> /// <param name="genericMethodSpecializations"> /// </param> /// <param name="structTypes"> /// </param> /// <param name="stackCall"> /// </param> public static void DiscoverRequiredTypesAndMethodsInMethodBody( this IMethod method, ISet <IType> genericTypeSpecializations, ISet <IMethod> genericMethodSpecializations, ISet <IType> structTypes, ISet <IType> arrayTypes, Queue <IMethod> stackCall) { if (Il2Converter.VerboseOutput) { Debug.WriteLine("Scanning method for types: {0}", method); } // read method body to extract all types var reader = new IlReader(); reader.UsedStructTypes = structTypes; reader.UsedArrayTypes = arrayTypes; reader.UsedGenericSpecialiazedTypes = genericTypeSpecializations; reader.UsedGenericSpecialiazedMethods = genericMethodSpecializations; var genericContext = MetadataGenericContext.DiscoverFrom(method, false); // true foreach (var op in reader.OpCodes(method, genericContext, stackCall)) { } }
public ILStructure(PEFile module, MethodDefinitionHandle handle, MetadataGenericContext genericContext, ILStructureType type, int startOffset, int endOffset, ExceptionRegion handler = default) { Debug.Assert(startOffset < endOffset); this.Module = module; this.MethodHandle = handle; this.GenericContext = genericContext; this.Type = type; this.StartOffset = startOffset; this.EndOffset = endOffset; this.ExceptionHandler = handler; }
public ILStructure(PEFile module, MethodDefinitionHandle handle, MetadataGenericContext genericContext, ILStructureType type, int startOffset, int endOffset, int loopEntryPoint) { Debug.Assert(startOffset < endOffset); this.Module = module; this.MethodHandle = handle; this.GenericContext = genericContext; this.Type = type; this.StartOffset = startOffset; this.EndOffset = endOffset; this.LoopEntryPointOffset = loopEntryPoint; }
private static IEnumerable <IType> GetAllRequiredTypesForMethod( IMethod method, ReadingTypesContext readingTypesContext) { DicoverGenericSpecializedTypesAndAdditionalTypes( method.ReturnType, readingTypesContext); foreach (var param in method.GetParameters()) { DicoverGenericSpecializedTypesAndAdditionalTypes( param.ParameterType, readingTypesContext); } if (method.DeclaringType.IsInterface) { yield break; } var methodWithCustomBodyOrDefault = MethodBodyBank.GetMethodWithCustomBodyOrDefault(method, _codeWriter); var methodBody = methodWithCustomBodyOrDefault.GetMethodBody(MetadataGenericContext.DiscoverFrom(method)); if (methodBody != null) { foreach (var localVar in methodBody.LocalVariables) { DicoverGenericSpecializedTypesAndAdditionalTypes( localVar.LocalType, readingTypesContext); if (localVar.LocalType.IsStructureType() && !localVar.LocalType.IsPointer && !localVar.LocalType.IsByRef) { yield return(localVar.LocalType); } } var usedStructTypes = new NamespaceContainer <IType>(); methodWithCustomBodyOrDefault.DiscoverRequiredTypesAndMethodsInMethodBody( readingTypesContext.GenericTypeSpecializations, readingTypesContext.GenericMethodSpecializations, usedStructTypes, readingTypesContext.AdditionalTypesToProcess, new Queue <IMethod>()); foreach (var usedStructType in usedStructTypes) { yield return(usedStructType); } } }
/// <summary> /// </summary> /// <param name="method"> /// </param> /// <param name="structTypes"> /// </param> /// <param name="calledMethods"> /// </param> /// <param name="readStaticFields"> /// </param> public static void DiscoverMethod(this IMethod method, ISet <IType> structTypes, ISet <IMethod> calledMethods, ISet <IField> readStaticFields) { // read method body to extract all types var reader = new IlReader(); reader.UsedTypes = structTypes; reader.CalledMethods = calledMethods; reader.UsedStaticFieldsToRead = readStaticFields; var genericContext = MetadataGenericContext.DiscoverFrom(method); foreach (var op in reader.OpCodes(method, genericContext, new Queue <IMethod>())) { } }
private static void DiscoverAllGenericMethodsOfInterfacesForMethod(IEnumerable <IType> allTypes, ISet <IMethod> genericMethodSpecializations, IGrouping <IType, IMethod> specializedTypeMethods) { var types = allTypes.Where(t => t.GetAllInterfaces().Contains(specializedTypeMethods.Key)).ToList(); foreach (var specializedTypeMethod in specializedTypeMethods) { var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance; foreach (var genericMethodOfInterface in types.SelectMany(t => t.GetMethods(flags).Where(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(specializedTypeMethod)))) { genericMethodSpecializations.Add( genericMethodOfInterface.ToSpecialization(MetadataGenericContext.CreateMap(genericMethodOfInterface, specializedTypeMethod))); } } }
internal void WriteExceptionHandlers(PEFile module, MethodDefinitionHandle handle, MethodBodyBlock body) { this.module = module; metadata = module.Metadata; genericContext = new MetadataGenericContext(handle, module); signatureDecoder = new DisassemblerSignatureTypeProvider(module, output); var handlers = body.ExceptionRegions; if (!handlers.IsEmpty) { output.WriteLine(); foreach (var eh in handlers) { eh.WriteTo(module, genericContext, output); output.WriteLine(); } } }
/// <summary> /// </summary> /// <param name="allTypes"> /// </param> /// <param name="genericMethodSpecializations"> /// </param> private static void DiscoverAllGenericVirtualMethods( IEnumerable <IType> allTypes, ReadingTypesContext readingTypesContext) { var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations; // find all override of generic methods var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance; var overrideSpecializedMethods = new List <IMethod>(); foreach ( var overrideGenericMethod in allTypes.SelectMany( t => t.GetMethods(flags).Where(m => m.IsOverride && m.IsGenericMethodDefinition))) { var method = overrideGenericMethod; var methodDefinition = overrideGenericMethod; overrideSpecializedMethods.AddRange( from methodSpecialization in genericMethodSpecializations.Where(m => m.IsVirtual || m.IsOverride || m.IsAbstract) where method.DeclaringType.IsDerivedFrom(methodSpecialization.DeclaringType) && method.IsMatchingOverride(methodSpecialization) select methodDefinition.ToSpecialization( MetadataGenericContext.CreateCustomMap(null, methodSpecialization, methodDefinition))); } // append to discovered foreach (var overrideSpecializedMethod in overrideSpecializedMethods) { genericMethodSpecializations.Add(overrideSpecializedMethod); // rediscover generic methods again overrideSpecializedMethod.DiscoverRequiredTypesAndMethodsInMethodBody( readingTypesContext.GenericTypeSpecializations, readingTypesContext.GenericMethodSpecializations, null, readingTypesContext.AdditionalTypesToProcess, new Queue <IMethod>()); } }
/// <summary> /// </summary> /// <param name="method"> /// </param> /// <param name="genericTypeSpecializations"> /// </param> /// <param name="genericMethodSpecializations"> /// </param> /// <param name="requiredTypes"> /// </param> /// <param name="stackCall"> /// </param> public static void DiscoverRequiredTypesAndMethodsInMethodBody( this IMethod method, ISet <IType> genericTypeSpecializations, ISet <IMethod> genericMethodSpecializations, ISet <IType> requiredTypes, Queue <IMethod> stackCall) { // read method body to extract all types var reader = new IlReader(); reader.UsedStructTypes = requiredTypes; reader.UsedGenericSpecialiazedTypes = genericTypeSpecializations; reader.UsedGenericSpecialiazedMethods = genericMethodSpecializations; var genericContext = MetadataGenericContext.DiscoverFrom(method, false); // true foreach (var op in reader.OpCodes(method, genericContext, stackCall)) { } }
private static void DiscoverAllGenericMethodsOfInterfacesForMethod( IEnumerable <IType> allTypes, IGrouping <IType, IMethod> specializedTypeMethods, ReadingTypesContext readingTypesContext) { var types = allTypes.Where(t => t.GetAllInterfaces().Contains(specializedTypeMethods.Key)).ToList(); foreach (var interfaceMethodSpecialization in specializedTypeMethods) { var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance; foreach (var classMethodDefinition in types.SelectMany( t => t.GetMethods(flags) .Where(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(interfaceMethodSpecialization)))) { // find interface var @interfaceDefinition = classMethodDefinition.DeclaringType.GetInterfaces() .First(i => i.TypeEquals(interfaceMethodSpecialization.DeclaringType)); var @interfaceMethodDefinition = @interfaceDefinition.GetMethods(flags) .First(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(interfaceMethodSpecialization)); var classMethodSpecialization = classMethodDefinition.ToSpecialization( MetadataGenericContext.CreateCustomMap(@interfaceMethodDefinition, interfaceMethodSpecialization, classMethodDefinition)); readingTypesContext.GenericMethodSpecializations.Add(classMethodSpecialization); // rediscover generic methods again classMethodSpecialization.DiscoverRequiredTypesAndMethodsInMethodBody( readingTypesContext.GenericTypeSpecializations, readingTypesContext.GenericMethodSpecializations, null, readingTypesContext.AdditionalTypesToProcess, new Queue <IMethod>()); } } }
/// <summary> /// </summary> /// <param name="allTypes"> /// </param> /// <param name="genericMethodSpecializations"> /// </param> private static void DiscoverAllGenericVirtualMethods(IEnumerable <IType> allTypes, ISet <IMethod> genericMethodSpecializations) { // find all override of generic methods var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance; var overrideSpecializedMethods = new List <IMethod>(); foreach (var overrideGenericMethod in allTypes.SelectMany(t => t.GetMethods(flags).Where(m => m.IsOverride && m.IsGenericMethodDefinition))) { var method = overrideGenericMethod; var genericMethod = overrideGenericMethod; overrideSpecializedMethods.AddRange( from specializationMethod in genericMethodSpecializations.Where(m => m.IsVirtual || m.IsOverride || m.IsAbstract) where method.DeclaringType.IsDerivedFrom(specializationMethod.DeclaringType) && method.IsMatchingOverride(specializationMethod) select genericMethod.ToSpecialization(MetadataGenericContext.CreateMap(genericMethod, specializationMethod))); } // append to discovered foreach (var overrideSpecializedMethod in overrideSpecializedMethods) { genericMethodSpecializations.Add(overrideSpecializedMethod); } }
/// <summary> /// </summary> /// <param name="type"> /// </param> /// <param name="genericTypeSpecializations"> /// </param> /// <param name="genericMethodSpecializations"> /// </param> /// <returns> /// </returns> private static IEnumerable <IType> GetAllRequiredITypesForIType( IType type, ISet <IType> genericTypeSpecializations, ISet <IMethod> genericMethodSpecializations) { Debug.Assert(type != null); if (type.BaseType != null) { DicoverGenericSpecializedIType(type.BaseType, genericTypeSpecializations, genericMethodSpecializations); yield return(type.BaseType); } var interfaces = type.GetInterfaces(); if (interfaces != null) { foreach (var @interface in interfaces) { DicoverGenericSpecializedIType(@interface, genericTypeSpecializations, genericMethodSpecializations); yield return(@interface); } } var fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); if (fields != null) { foreach (var field in fields) { DicoverGenericSpecializedIType(field.FieldType, genericTypeSpecializations, genericMethodSpecializations); if (field.FieldType.IsStructureType() && !field.FieldType.IsPointer) { yield return(field.FieldType); } } } var methods = type.GetMethods( BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); if (methods != null) { foreach (var method in methods) { DicoverGenericSpecializedIType(method.ReturnType, genericTypeSpecializations, genericMethodSpecializations); foreach (var param in method.GetParameters()) { DicoverGenericSpecializedIType(param.ParameterType, genericTypeSpecializations, genericMethodSpecializations); } var methodBody = method.GetMethodBody(MetadataGenericContext.DiscoverFrom(method)); if (methodBody != null) { foreach (var localVar in methodBody.LocalVariables) { DicoverGenericSpecializedIType(localVar.LocalType, genericTypeSpecializations, genericMethodSpecializations); if (localVar.LocalType.IsStructureType() && !localVar.LocalType.IsPointer) { yield return(localVar.LocalType); } } var usedStructTypes = new HashSet <IType>(); method.DiscoverRequiredTypesAndMethodsInMethodBody( genericTypeSpecializations, genericMethodSpecializations, usedStructTypes, new Queue <IMethod>()); foreach (var usedStructType in usedStructTypes) { yield return(usedStructType); } } } } }
/// <summary> /// </summary> /// <param name="ilReader"> /// </param> /// <param name="codeWriter"> /// </param> /// <param name="type"> /// </param> /// <param name="genericDefinition"> /// </param> /// <param name="genericMethodSpecializatons"> /// </param> /// <param name="mode"> /// </param> /// <param name="processGenericMethodsOnly"> /// </param> private static void ConvertIType( IlReader ilReader, ICodeWriter codeWriter, IType type, IType genericDefinition, IEnumerable <IMethod> genericMethodSpecializatons, ConvertingMode mode, bool processGenericMethodsOnly = false) { Debug.WriteLine("Converting {0}, Mode: {1}", type, mode); var typeSpecialization = type.IsGenericType && !type.IsGenericTypeDefinition ? type : null; var genericContext = new MetadataGenericContext(); genericContext.TypeDefinition = genericDefinition; genericContext.TypeSpecialization = typeSpecialization; genericContext.MethodDefinition = null; genericContext.MethodSpecialization = null; if (mode == ConvertingMode.Declaration) { if (!codeWriter.IsProcessed(type)) { WriteTypeDefinition(codeWriter, type, genericContext); } codeWriter.WritePostDeclarations(type); codeWriter.WriteBeforeConstructors(); } if (mode == ConvertingMode.Definition) { codeWriter.DisableWrite(true); if (!processGenericMethodsOnly) { // pre process step to get all used undefined structures foreach (var ctor in IlReader.Constructors(type)) { IConstructor genericCtor = null; if (type.IsGenericType && !type.IsInterface && !type.IsDelegate) { // find the same constructor in generic class Debug.Assert(genericDefinition != null); genericCtor = IlReader.Constructors(genericDefinition).First(gm => ctor.IsMatchingGeneric(gm)); } genericContext.MethodDefinition = genericCtor; genericContext.MethodSpecialization = null; codeWriter.WriteConstructorStart(ctor, genericContext); foreach (var ilCode in ilReader.OpCodes(genericCtor ?? ctor, genericContext)) { codeWriter.Write(ilCode); } codeWriter.WriteConstructorEnd(ctor, genericContext); } } codeWriter.DisableWrite(false); // Actual Write codeWriter.WriteRequiredTypesForBody(); codeWriter.WriteStoredText(); } if (mode == ConvertingMode.Declaration) { codeWriter.WriteAfterConstructors(); codeWriter.WriteBeforeMethods(); } if (mode == ConvertingMode.Definition) { codeWriter.DisableWrite(true); // pre process step to get all used undefined structures foreach (var method in IlReader.MethodsOriginal(type).Select(m => MethodBodyBank.GetMethodBodyOrDefault(m, codeWriter))) { IMethod genericMethod = null; if (type.IsGenericType && !type.IsInterface && !type.IsDelegate) { // find the same method in generic class genericMethod = IlReader.MethodsOriginal(genericDefinition).First(gm => method.IsMatchingGeneric(gm.ToSpecialization(genericContext))); } if (!method.IsGenericMethodDefinition && !processGenericMethodsOnly) { genericContext.MethodDefinition = genericMethod; genericContext.MethodSpecialization = genericMethod != null ? method : null; codeWriter.WriteMethodStart(method, genericContext); foreach (var ilCode in ilReader.OpCodes(genericMethod ?? method, genericContext)) { codeWriter.Write(ilCode); } codeWriter.WriteMethodEnd(method, genericContext); } else { // write all specializations of a method if (genericMethodSpecializatons != null) { foreach (var methodSpec in genericMethodSpecializatons) { if (!methodSpec.IsMatchingGeneric(method)) { continue; } genericContext.MethodDefinition = method; genericContext.MethodSpecialization = methodSpec; codeWriter.WriteMethodStart(methodSpec, genericContext); foreach (var ilCode in ilReader.OpCodes(genericMethod ?? method, genericContext)) { codeWriter.Write(ilCode); } codeWriter.WriteMethodEnd(methodSpec, genericContext); } } } } codeWriter.DisableWrite(false); // Actual Write codeWriter.WriteRequiredTypesForBody(); codeWriter.WriteStoredText(); } if (mode == ConvertingMode.Declaration) { codeWriter.WriteAfterMethods(); codeWriter.WriteTypeEnd(type); } }
/// <summary> /// </summary> /// <param name="ilReader"> /// </param> /// <param name="codeWriter"> /// </param> /// <param name="type"> /// </param> /// <param name="typeDefinition"> /// </param> /// <param name="genericMethodSpecializatons"> /// </param> /// <param name="mode"> /// </param> /// <param name="processGenericMethodsOnly"> /// </param> private static void ConvertIType( IlReader ilReader, ICodeWriter codeWriter, IType type, IEnumerable <IMethod> genericMethodSpecializatons, ConvertingMode mode, bool processGenericMethodsOnly = false) { if (VerboseOutput) { Trace.WriteLine(string.Format("Converting {0}, Mode: {1}", type, mode)); } var typeDefinition = type.IsGenericType ? type.GetTypeDefinition() : null; var typeSpecialization = type.IsGenericType && !type.IsGenericTypeDefinition ? type : null; var genericTypeContext = typeDefinition != null || typeSpecialization != null ? MetadataGenericContext.Create(typeDefinition, typeSpecialization) : null; if (mode == ConvertingMode.Declaration) { if (!codeWriter.IsProcessed(type)) { WriteTypeDefinition(codeWriter, type, genericTypeContext); } codeWriter.WritePostDeclarationsAndInternalDefinitions(type); codeWriter.WriteBeforeConstructors(); } if (mode == ConvertingMode.Definition) { codeWriter.DisableWrite(true); if (!processGenericMethodsOnly) { // pre process step to get all used undefined structures foreach (var ctor in IlReader.Constructors(type, codeWriter)) { codeWriter.WriteConstructorStart(ctor, genericTypeContext); foreach (var ilCode in ilReader.OpCodes(type.IsGenericType ? ctor.GetMethodDefinition() : ctor, genericTypeContext)) { codeWriter.Write(ilCode); } codeWriter.WriteConstructorEnd(ctor, genericTypeContext); } } codeWriter.DisableWrite(false); // Actual Write codeWriter.WriteRequiredTypesForBody(); codeWriter.WriteStoredText(); } if (mode == ConvertingMode.Declaration) { codeWriter.WriteAfterConstructors(); codeWriter.WriteBeforeMethods(); } if (mode == ConvertingMode.Definition) { codeWriter.DisableWrite(true); // pre process step to get all used undefined structures foreach ( var method in IlReader.Methods(type, codeWriter, true).Select(m => MethodBodyBank.GetMethodWithCustomBodyOrDefault(m, codeWriter))) { if (!method.IsGenericMethodDefinition && !processGenericMethodsOnly) { var genericMethodContext = method.IsGenericMethod ? MetadataGenericContext.Create(typeDefinition, typeSpecialization, method.GetMethodDefinition(), method) : genericTypeContext; codeWriter.WriteMethodStart(method, genericMethodContext); foreach (var ilCode in ilReader.OpCodes(type.IsGenericType ? method.GetMethodDefinition() : method, genericMethodContext)) { codeWriter.Write(ilCode); } codeWriter.WriteMethodEnd(method, genericMethodContext); } if (method.IsGenericMethodDefinition || method.IsGenericMethod) { // write all specializations of a method if (genericMethodSpecializatons != null) { var methodDefinition = method.GetMethodDefinition(); foreach ( var methodSpec in genericMethodSpecializatons.Where( methodSpec => methodSpec.IsMatchingGeneric(methodDefinition) && (!methodSpec.Equals(method) || processGenericMethodsOnly))) { var genericMethodContext = MetadataGenericContext.Create(typeDefinition, typeSpecialization, method, methodSpec); codeWriter.WriteMethodStart(methodSpec, genericMethodContext); foreach (var ilCode in ilReader.OpCodes(methodDefinition ?? method, genericMethodContext)) { codeWriter.Write(ilCode); } codeWriter.WriteMethodEnd(methodSpec, genericMethodContext); } } } } codeWriter.DisableWrite(false); // Actual Write codeWriter.WriteRequiredTypesForBody(); codeWriter.WriteStoredText(); } if (mode == ConvertingMode.Declaration) { codeWriter.WriteAfterMethods(); codeWriter.WriteTypeEnd(type); } }
public ILStructure(PEFile module, MethodDefinitionHandle handle, MetadataGenericContext genericContext, MethodBodyBlock body) : this(module, handle, genericContext, ILStructureType.Root, 0, body.GetILReader().Length) { // Build the tree of exception structures: for (int i = 0; i < body.ExceptionRegions.Length; i++) { ExceptionRegion eh = body.ExceptionRegions[i]; if (!body.ExceptionRegions.Take(i).Any(oldEh => oldEh.TryOffset == eh.TryOffset && oldEh.TryLength == eh.TryLength)) { AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Try, eh.TryOffset, eh.TryOffset + eh.TryLength, eh)); } if (eh.Kind == ExceptionRegionKind.Filter) { AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Filter, eh.FilterOffset, eh.HandlerOffset, eh)); } AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Handler, eh.HandlerOffset, eh.HandlerOffset + eh.HandlerLength, eh)); } // Very simple loop detection: look for backward branches (var allBranches, var isAfterUnconditionalBranch) = FindAllBranches(body.GetILReader()); // We go through the branches in reverse so that we find the biggest possible loop boundary first (think loops with "continue;") for (int i = allBranches.Count - 1; i >= 0; i--) { int loopEnd = allBranches[i].Source.End; int loopStart = allBranches[i].Target; if (loopStart < loopEnd) { // We found a backward branch. This is a potential loop. // Check that is has only one entry point: int entryPoint = -1; // entry point is first instruction in loop if prev inst isn't an unconditional branch if (loopStart > 0 && !isAfterUnconditionalBranch[loopStart]) { entryPoint = allBranches[i].Target; } bool multipleEntryPoints = false; foreach (var branch in allBranches) { if (branch.Source.Start < loopStart || branch.Source.Start >= loopEnd) { if (loopStart <= branch.Target && branch.Target < loopEnd) { // jump from outside the loop into the loop if (entryPoint < 0) { entryPoint = branch.Target; } else if (branch.Target != entryPoint) { multipleEntryPoints = true; } } } } if (!multipleEntryPoints) { AddNestedStructure(new ILStructure(module, handle, genericContext, ILStructureType.Loop, loopStart, loopEnd, entryPoint)); } } } SortChildren(); }
public virtual void Disassemble(PEFile module, MethodDefinitionHandle handle) { this.module = module ?? throw new ArgumentNullException(nameof(module)); metadata = module.Metadata; genericContext = new MetadataGenericContext(handle, module); signatureDecoder = new DisassemblerSignatureTypeProvider(module, output); var methodDefinition = metadata.GetMethodDefinition(handle); // start writing IL code output.WriteLine("// Method begins at RVA 0x{0:x4}", methodDefinition.RelativeVirtualAddress); if (methodDefinition.RelativeVirtualAddress == 0) { output.WriteLine("// Header size: {0}", 0); output.WriteLine("// Code size: {0} (0x{0:x})", 0); output.WriteLine(".maxstack {0}", 0); output.WriteLine(); return; } MethodBodyBlock body; BlobReader bodyBlockReader; try { body = module.Reader.GetMethodBody(methodDefinition.RelativeVirtualAddress); bodyBlockReader = module.Reader.GetSectionData(methodDefinition.RelativeVirtualAddress).GetReader(); } catch (BadImageFormatException ex) { output.WriteLine("// {0}", ex.Message); return; } var blob = body.GetILReader(); int headerSize = ILParser.GetHeaderSize(bodyBlockReader); output.WriteLine("// Header size: {0}", headerSize); output.WriteLine("// Code size: {0} (0x{0:x})", blob.Length); output.WriteLine(".maxstack {0}", body.MaxStack); var entrypointHandle = MetadataTokens.MethodDefinitionHandle(module.Reader.PEHeaders.CorHeader.EntryPointTokenOrRelativeVirtualAddress); if (handle == entrypointHandle) { output.WriteLine(".entrypoint"); } DisassembleLocalsBlock(handle, body); output.WriteLine(); sequencePoints = DebugInfo?.GetSequencePoints(handle) ?? EmptyList <DebugInfo.SequencePoint> .Instance; nextSequencePointIndex = 0; if (DetectControlStructure && blob.Length > 0) { blob.Reset(); HashSet <int> branchTargets = GetBranchTargets(blob); blob.Reset(); WriteStructureBody(new ILStructure(module, handle, genericContext, body), branchTargets, ref blob, methodDefinition.RelativeVirtualAddress + headerSize); } else { while (blob.RemainingBytes > 0) { cancellationToken.ThrowIfCancellationRequested(); WriteInstruction(output, metadata, handle, ref blob, methodDefinition.RelativeVirtualAddress); } WriteExceptionHandlers(module, handle, body); } sequencePoints = null; }
public Action <ILNameSyntax> GetTypeFromSpecification(MetadataReader reader, MetadataGenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) { return(reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext)); }
public static void WriteTo(this SRM.ExceptionRegion exceptionHandler, Metadata.PEFile module, MetadataGenericContext context, ITextOutput writer) { writer.Write(".try "); WriteOffsetReference(writer, exceptionHandler.TryOffset); writer.Write('-'); WriteOffsetReference(writer, exceptionHandler.TryOffset + exceptionHandler.TryLength); writer.Write(' '); writer.Write(exceptionHandler.Kind.ToString().ToLowerInvariant()); if (exceptionHandler.FilterOffset != -1) { writer.Write(' '); WriteOffsetReference(writer, exceptionHandler.FilterOffset); writer.Write(" handler "); } if (!exceptionHandler.CatchType.IsNil) { writer.Write(' '); exceptionHandler.CatchType.WriteTo(module, writer, context); } writer.Write(' '); WriteOffsetReference(writer, exceptionHandler.HandlerOffset); writer.Write('-'); WriteOffsetReference(writer, exceptionHandler.HandlerOffset + exceptionHandler.HandlerLength); }