示例#1
0
        public void VisualizeMethodBody(MethodBodyBlock body, MethodHandle methodHandle, bool emitHeader = true)
        {
            StringBuilder builder = new StringBuilder();

            // TODO: Inspect EncLog to find a containing type and display qualified name.
            var method = GetMethod(methodHandle);

            if (emitHeader)
            {
                builder.AppendFormat("Method {0} (0x{1:X8})", Literal(method.Name), MetadataTokens.GetToken(methodHandle));
                builder.AppendLine();
            }

            // TODO: decode signature
            if (!body.LocalSignature.IsNil)
            {
                var localSignature = GetLocalSignature(body.LocalSignature);
                builder.AppendFormat("  Locals: {0}", Literal(localSignature));
                builder.AppendLine();
            }

            ILVisualizerAsTokens.Instance.DumpMethod(
                builder,
                body.MaxStack,
                body.GetILBytes(),
                ImmutableArray.Create <ILVisualizer.LocalInfo>(),     // TODO
                ImmutableArray.Create <ILVisualizer.HandlerSpan>());  // TOOD: ILVisualizer.GetHandlerSpans(body.ExceptionRegions)

            builder.AppendLine();

            writer.Write(builder.ToString());
        }
示例#2
0
        static private void ProcessMethod(ILGenerator generator, MethodEx methodEx, MethodBase method, MetaDataMapper mapper)
        {
            if (method.IsAbstract)
            {
                return;
            }
            MethodBodyBlock body = null;

            if (methodEx == null)
            {
                throw new ExportException();
            }

            body = CreateBody(methodEx);
            if (body == null)
            {
                throw new ExportException();
            }

            MetaDataResolver.Map(body, mapper);
            bool verified = CFGVerifier.Check(body);

            if (!verified)
            {
                throw new ExportException();
            }

            Emitter.Emit(generator, body);
        }
示例#3
0
 private static unsafe MethodBodyBlock ReadMethodBody(byte[] body)
 {
     fixed(byte *bodyPtr = &body[0])
     {
         return(MethodBodyBlock.Create(new BlobReader(bodyPtr, body.Length)));
     }
 }
        public void PinnedAndUnpinnedLocals()
        {
            using (FileStream stream = File.OpenRead(AssemblyPathHelper.GetAssemblyLocation(typeof(PinnedAndUnpinnedLocalsToDecode).GetTypeInfo().Assembly)))
                using (var peReader = new PEReader(stream))
                {
                    MetadataReader reader   = peReader.GetMetadataReader();
                    var            provider = new DisassemblingTypeProvider();

                    TypeDefinitionHandle typeDefHandle = TestMetadataResolver.FindTestType(reader, typeof(PinnedAndUnpinnedLocalsToDecode));
                    TypeDefinition       typeDef       = reader.GetTypeDefinition(typeDefHandle);
                    MethodDefinition     methodDef     = reader.GetMethodDefinition(typeDef.GetMethods().First());

                    Assert.Equal("DoSomething", reader.GetString(methodDef.Name));

                    MethodBodyBlock     body           = peReader.GetMethodBody(methodDef.RelativeVirtualAddress);
                    StandaloneSignature localSignature = reader.GetStandaloneSignature(body.LocalSignature);

                    ImmutableArray <string> localTypes = localSignature.DecodeLocalSignature(provider, genericContext: null);

                    // Compiler can generate temporaries or re-order so just check the ones we expect are there.
                    // (They could get optimized away too. If that happens in practice, change this test to use hard-coded signatures.)
                    Assert.Contains("uint8[] pinned", localTypes);
                    Assert.Contains("uint8[]", localTypes);
                }
        }
示例#5
0
 public static IEnumerable <_ExceptionRegionInfo> GetExceptionRegionInfos(this MethodBodyBlock aThis, Module aModule)
 {
     foreach (var x in aThis.ExceptionRegions)
     {
         yield return(new _ExceptionRegionInfo(aModule, x));
     }
 }
        bool ScanMethodBody(ITypeDefinition analyzedEntity, IMethod method, MethodBodyBlock methodBody)
        {
            bool found          = false;
            var  blob           = methodBody.GetILReader();
            var  module         = (MetadataModule)method.ParentModule;
            var  genericContext = new Decompiler.TypeSystem.GenericContext();            // type parameters don't matter for this analyzer

            while (!found && blob.RemainingBytes > 0)
            {
                var opCode = blob.DecodeOpCode();
                if (!CanBeReference(opCode))
                {
                    blob.SkipOperand(opCode);
                    continue;
                }
                EntityHandle methodHandle = MetadataTokenHelpers.EntityHandleOrNil(blob.ReadInt32());
                if (!methodHandle.Kind.IsMemberKind())
                {
                    continue;
                }
                var ctor = module.ResolveMethod(methodHandle, genericContext);
                if (ctor == null || !ctor.IsConstructor)
                {
                    continue;
                }

                if (ctor.DeclaringTypeDefinition?.MetadataToken == analyzedEntity.MetadataToken &&
                    ctor.ParentModule.PEFile == analyzedEntity.ParentModule.PEFile)
                {
                    return(true);
                }
            }

            return(false);
        }
示例#7
0
    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);
                    }
                }
            }
        }
    }
示例#8
0
        public static Value InterpretMethod(MethodBodyHolder holder,
                                            MethodBodyBlock body, ParameterValues paramVals, out Exception exc,
                                            string indent)
        {
            exc = null;

            GraphProcessor graphProcessor = new GraphProcessor();
            IntVisitor     visitor        = new IntVisitor(graphProcessor, holder, indent);

            visitor.state = new State(body.Variables.Count);

            int paramCount = 0;

            foreach (Variable var in body.Variables.ParameterMapper)
            {
                visitor.state.Pool[var] = paramVals[paramCount++];
            }

            visitor.AddTask(body);
            graphProcessor.Process();

            Value result = null;

            if (visitor.unhandledException != null)
            {
                exc = visitor.unhandledException;
            }
            else if (body.ReturnType != typeof(void))
            {
                result = visitor.state.Stack.Pop().FromStack(body.ReturnType);
            }

            return(result);
        }
示例#9
0
            public void Callback(Node node)
            {
                if (node is ITypedNode)
                {
                    ITypedNode theNode = node as ITypedNode;
                    theNode.Type = mapper.Map(theNode.Type);
                }
                if (node is ManageField)
                {
                    ManageField theNode = node as ManageField;
                    theNode.Field = mapper.Map(theNode.Field);
                }
                if (node is MethodBodyBlock)
                {
                    MethodBodyBlock body = node as MethodBodyBlock;
                    foreach (Variable var in body.Variables)
                    {
                        var.Type = mapper.Map(var.Type);
                    }
                    body.ReturnType = mapper.Map(body.ReturnType);
                }
                if (node is CallMethod)
                {
                    CallMethod     call = node as CallMethod;
                    ResidualMethod id   = Specialization.GetResidualMethod(call);
                    if (id != null)
                    {
                        MethodBodyBlock mbb = mapper.Holder[id];
                        node.Options["HasPseudoParameter"] = mapper.HasPseudoParameter(mbb);
                        call.MethodWithParams = new MethodInfoExtention(mapper.Map(mbb), call.IsVirtCall, mapper.Map(GetParamTypes(mbb, id.IsConstructor)));
                    }
                    else
                    {
                        call.MethodWithParams = mapper.Map(call.MethodWithParams);
                    }
                }
                if (node is NewObject)
                {
                    NewObject      newObj = node as NewObject;
                    ResidualMethod id     = Specialization.GetResidualMethod(node);
                    if (id != null)
                    {
                        MethodBodyBlock mbb = mapper.Holder[id];
                        newObj.CtorWithParams = new MethodInfoExtention(mapper.Map(mbb), false, mapper.Map(GetParamTypes(mbb, id.IsConstructor)));
                        node.Options["HasPseudoParameter"] = mapper.HasPseudoParameter(mbb);
                    }
                    else
                    {
                        newObj.CtorWithParams = mapper.Map(newObj.CtorWithParams);
                    }
                }
                if (node is CreateDelegate)
                {
                    CreateDelegate crDel = node as CreateDelegate;
                    //Andrew TODO: Map this node...
                }

                // Graph should be verified AFTER the metadata is resolved
            }
示例#10
0
        public static void ForEach(MethodBodyBlock method, ForEachCallback handler)
        {
            GraphProcessor graphProcessor = new GraphProcessor();
            Visitor        visitor        = new ForEachVisitor(graphProcessor, handler);

            visitor.AddTask(method, null);
            graphProcessor.Process();
        }
示例#11
0
        private EcmaMethodIL(EcmaMethod method, int rva, bool clearInitLocals)
        {
            _method     = method;
            _module     = method.Module;
            _methodBody = _module.PEReader.GetMethodBody(rva);

            _clearInitLocals = clearInitLocals;
        }
示例#12
0
 internal BlockBuilder(MethodBodyBlock body,
                       Dictionary <ExceptionRegion, ILVariable> variableByExceptionHandler)
 {
     Debug.Assert(body != null);
     Debug.Assert(variableByExceptionHandler != null);
     this.body = body;
     this.variableByExceptionHandler = variableByExceptionHandler;
 }
示例#13
0
        public static int GetCodeSize(this MethodBodyBlock body)
        {
            if (body == null)
            {
                throw new ArgumentNullException(nameof(body));
            }

            return(body.GetILReader().Length);
        }
示例#14
0
文件: Spec.cs 项目: PlumpMath/cilpe-1
 internal SpecializingVisitor(GraphProcessor graphProcessor, ResidualAssemblyHolder holder, MethodBodyBlock mbbUp, SpecState state, VariablesHashtable varsHash) : base(graphProcessor)
 {
     this.holder      = holder;
     this.mbbUp       = mbbUp;
     this.state       = state;
     this.varsHash    = varsHash;
     this.upDownNodes = new Hashtable();
     this.exitData    = new ArrayList();
 }
示例#15
0
        public TypeMethodHandle ReadMethod(BaseJIT jit, MethodDefinitionHandle methodHandle)
        {
            MethodDefinition methodDefinition = this.metadata.GetMethodDefinition(methodHandle);
            TypeDefinition   typeDefinition   = this.metadata.GetTypeDefinition(methodDefinition.GetDeclaringType());

            TypeHandle      typeHandle = this.typeLoader.LoadType(this.metadata, typeDefinition);
            MethodBodyBlock methodBody = this.peReader.GetMethodBody(methodDefinition.RelativeVirtualAddress);

            return(typeHandle.LoadMethod(jit, this, this.metadata, methodHandle, methodBody));
        }
示例#16
0
        bool ScanMethodBody(IField analyzedField, IMethod method, MethodBodyBlock methodBody)
        {
            if (methodBody == null)
            {
                return(false);
            }

            var mainModule     = (MetadataModule)method.ParentModule;
            var blob           = methodBody.GetILReader();
            var genericContext = new Decompiler.TypeSystem.GenericContext();             // type parameters don't matter for this analyzer

            while (blob.RemainingBytes > 0)
            {
                ILOpCode opCode;
                try
                {
                    opCode = blob.DecodeOpCode();
                    if (!CanBeReference(opCode))
                    {
                        blob.SkipOperand(opCode);
                        continue;
                    }
                }
                catch (BadImageFormatException)
                {
                    return(false);
                }
                EntityHandle fieldHandle = MetadataTokenHelpers.EntityHandleOrNil(blob.ReadInt32());
                if (!fieldHandle.Kind.IsMemberKind())
                {
                    continue;
                }
                IField field;
                try
                {
                    field = mainModule.ResolveEntity(fieldHandle, genericContext) as IField;
                }
                catch (BadImageFormatException)
                {
                    continue;
                }
                if (field == null)
                {
                    continue;
                }

                if (field.MetadataToken == analyzedField.MetadataToken &&
                    field.ParentModule.PEFile == analyzedField.ParentModule.PEFile)
                {
                    return(true);
                }
            }

            return(false);
        }
示例#17
0
        void DisassembleLocalsBlock(MethodDefinitionHandle method, MethodBodyBlock body)
        {
            if (body.LocalSignature.IsNil)
            {
                return;
            }
            output.Write(".locals");
            WriteMetadataToken(body.LocalSignature, spaceBefore: true);
            if (body.LocalVariablesInitialized)
            {
                output.Write(" init");
            }
            var blob      = metadata.GetStandaloneSignature(body.LocalSignature);
            var signature = ImmutableArray <Action <ILNameSyntax> > .Empty;

            try
            {
                if (blob.GetKind() == StandaloneSignatureKind.LocalVariables)
                {
                    signature = blob.DecodeLocalSignature(signatureDecoder, genericContext);
                }
                else
                {
                    output.Write(" /* wrong signature kind */");
                }
            }
            catch (BadImageFormatException ex)
            {
                output.Write($" /* {ex.Message} */");
            }
            output.Write(' ');
            output.WriteLine("(");
            output.Indent();
            int index = 0;

            foreach (var v in signature)
            {
                output.WriteLocalReference("[" + index + "]", "loc_" + index, isDefinition: true);
                output.Write(' ');
                v(ILNameSyntax.TypeName);
                if (DebugInfo != null && DebugInfo.TryGetName(method, index, out var name))
                {
                    output.Write(" " + DisassemblerHelpers.Escape(name));
                }
                if (index + 1 < signature.Length)
                {
                    output.Write(',');
                }
                output.WriteLine();
                index++;
            }
            output.Unindent();
            output.WriteLine(")");
        }
示例#18
0
            protected internal override void VisitMethodBodyBlock(MethodBodyBlock node, object data)
            {
                StackTypes stack = data as StackTypes;

                if (stack.Count != 0)
                {
                    throw new VerifierException();
                }

                AddTask(node.Next, stack);
            }
示例#19
0
        public BasicBlocksGraph(MethodBodyBlock methodBodyBlock)
        {
            mbb = methodBodyBlock;
            mbb.RemoveOption(BasicBlock.BASIC_BLOCK_OPTION);
            GraphProcessor     processor = new GraphProcessor();
            BasicBlocksBuilder builder   = new BasicBlocksBuilder(processor);

            entry = builder.createBasicBlock();
            builder.AddTask(methodBodyBlock, entry);
            processor.Process();
            blockList = builder.BlockList;
        }
示例#20
0
        protected override void VisitMethodBodyBlock(MethodBodyBlock node, object data)
        {
            foreach (Variable var in node.Variables)
            {
                if (!state.Pool.ContainsVar(var))
                {
                    state.Pool[var] = new Location(var.Type);
                }
            }

            AddTask(node.Next);
        }
示例#21
0
        internal AnnotatedMethod AnnotateMethod(AnnotatedMethod method)
        {
            int count = 0;

            foreach (AnnotatedMethod key in this.getMethods())
            {
                if (method.SourceMethod == key.SourceMethod)
                {
                    count++;
                    if (AnnotatedMethod.EqualMethods(method, key))
                    {
                        return(key);
                    }
                }
            }

            if (count > AnnotatedAssemblyHolder.NUMBER_FOR_MERGE)
            {
                AnnotatedMethod keyMethod         = null;
                int             keyMethodCreators = 0;

                foreach (AnnotatedMethod key in this.getMethods())
                {
                    if (method.SourceMethod == key.SourceMethod)
                    {
                        int keyCreators = AnnotatedMethod.PseudoMergeMethods(method, key).Count;
                        if (keyMethod == null || keyMethodCreators > keyCreators)
                        {
                            keyMethod         = key;
                            keyMethodCreators = keyCreators;
                        }
                    }
                }

                if (keyMethod != null && (keyMethodCreators == 0 || count > AnnotatedAssemblyHolder.NUMBER_FOR_LIFT))
                {
                    Creators crtrs = AnnotatedMethod.MergeMethods(method, keyMethod);
                    if (!crtrs.IsEmpty)
                    {
                        throw new AnnotatingVisitor.LiftException(crtrs);
                    }

                    return(keyMethod);
                }
            }

            MethodBodyBlock mbbUp = Annotation.AnnotateMethod(this, method);

            this.addMethodBody(method, mbbUp);
            return(method);
        }
示例#22
0
        public static unsafe string GetMethodIL(this ImmutableArray <byte> ilArray)
        {
            var result = new StringBuilder();

            fixed(byte *ilPtr = ilArray.ToArray())
            {
                int offset = 0;

                while (true)
                {
                    // skip padding:
                    while (offset < ilArray.Length && ilArray[offset] == 0)
                    {
                        offset++;
                    }

                    if (offset == ilArray.Length)
                    {
                        break;
                    }

                    var reader   = new BlobReader(ilPtr + offset, ilArray.Length - offset);
                    var methodIL = MethodBodyBlock.Create(reader);

                    if (methodIL == null)
                    {
                        result.AppendFormat(
                            "<invalid byte 0x{0:X2} at offset {1}>",
                            ilArray[offset],
                            offset
                            );
                        offset++;
                    }
                    else
                    {
                        ILVisualizer.Default.DumpMethod(
                            result,
                            methodIL.MaxStack,
                            methodIL.GetILContent(),
                            ImmutableArray.Create <ILVisualizer.LocalInfo>(),
                            ImmutableArray.Create <ILVisualizer.HandlerSpan>()
                            );

                        offset += methodIL.Size;
                    }
                }
            }

            return(result.ToString());
        }
示例#23
0
        public static Type[] GetParamTypes(MethodBodyBlock mbb, bool doRemoveThis)
        {
            ArrayList paramTypesList = new ArrayList();
            int       i0             = doRemoveThis ? 1 : 0;
            int       I = mbb.Variables.ParameterMapper.Count;

            for (int i = i0; i < I; i++)
            {
                Variable var = mbb.Variables.ParameterMapper[i];
                paramTypesList.Add(var.Type);
            }
            Type[] paramTypes = new Type[paramTypesList.Count];
            paramTypesList.CopyTo(paramTypes);
            return(paramTypes);
        }
示例#24
0
        internal static CilLocal[] DecodeLocalSignature(MethodBodyBlock methodBody, MetadataReader metadataReader, CilTypeProvider provider)
        {
            if (methodBody.LocalSignature.IsNil)
            {
                return(new CilLocal[0]);
            }
            ImmutableArray <CilType> localTypes = SignatureDecoder.DecodeLocalSignature(methodBody.LocalSignature, provider);

            CilLocal[] locals = new CilLocal[localTypes.Length];
            for (int i = 0; i < localTypes.Length; i++)
            {
                string name = "V_" + i;
                locals[i] = new CilLocal(name, localTypes[i].ToString());
            }
            return(locals);
        }
示例#25
0
        public static unsafe MethodBodyBlock GetMethodBodyBlock(this ImmutableArray <byte> ilArray)
        {
            fixed(byte *ilPtr = ilArray.AsSpan())
            {
                int offset = 0;

                // skip padding:
                while (offset < ilArray.Length && ilArray[offset] == 0)
                {
                    offset++;
                }

                var reader = new BlobReader(ilPtr + offset, ilArray.Length - offset);

                return(MethodBodyBlock.Create(reader));
            }
        }
示例#26
0
        public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
        {
            if (relocsOnly)
            {
                return(new ObjectData(
                           data: Array.Empty <byte>(),
                           relocs: Array.Empty <Relocation>(),
                           alignment: 1,
                           definedSymbols: new ISymbolDefinitionNode[] { this }));
            }

            var rva    = _method.MetadataReader.GetMethodDefinition(_method.Handle).RelativeVirtualAddress;
            var reader = _method.Module.PEReader.GetSectionData(rva).GetReader();
            int size   = MethodBodyBlock.Create(reader).Size;

            return(new ObjectData(reader.ReadBytes(size), Array.Empty <Relocation>(), 4, new ISymbolDefinitionNode[] { this }));
        }
示例#27
0
        // See: https://github.com/dotnet/corert/blob/635cf21aca11265ded9d78d216424bd609c052f5/src/Common/src/TypeSystem/Ecma/EcmaSignatureParser.cs#L242
        public static int GetLocalsCount(this MetadataReader reader, MethodBodyBlock method)
        {
            if (method.LocalSignature.IsNil)
            {
                return(0);
            }

            var entryPointSignature = reader.GetStandaloneSignature(method.LocalSignature);
            var signatureBlobReader = reader.GetBlobReader(entryPointSignature.Signature);

            if (signatureBlobReader.ReadSignatureHeader().Kind != SignatureKind.LocalVariables)
            {
                throw new BadImageFormatException();
            }

            return(signatureBlobReader.ReadCompressedInteger());
        }
示例#28
0
        public static bool Check(MethodBodyBlock method)
        {
            //TODO: Will check parents consistency, if give up to do it automatically
            RemoveStackTypes(method);
            GraphProcessor  graphProcessor  = new GraphProcessor();
            VerifierVisitor verifierVisitor = new VerifierVisitor(graphProcessor);

            verifierVisitor.AddTask(method, new StackTypes());
            try
            {
                graphProcessor.Process();
            }
            catch (VerifierException)
            {
                RemoveStackTypes(method);
                return(false);
            }
            return(true);
        }
        //<SnippetPrintMethods>
        static void PrintMethods(PEReader reader, MetadataReader mr, TypeDefinition tdef)
        {
            MethodDefinitionHandleCollection methods = tdef.GetMethods();

            foreach (MethodDefinitionHandle mdefh in methods)
            {
                MethodDefinition mdef  = mr.GetMethodDefinition(mdefh);
                string           mname = mr.GetString(mdef.Name);
                Console.WriteLine($"Method: {mname}");

                // Get the relative address of the method body in the executable
                int rva = mdef.RelativeVirtualAddress;

                if (rva == 0)
                {
                    Console.WriteLine("Method body not found");
                    Console.WriteLine();
                    continue;
                }

                // Get method body information
                MethodBodyBlock mb = reader.GetMethodBody(rva);
                Console.WriteLine($"  Maximum stack size: {mb.MaxStack}");
                Console.WriteLine($"  Local variables initialized: {mb.LocalVariablesInitialized}");

                byte[] il = mb.GetILBytes();
                Console.WriteLine($"  Method body size: {il.Length}");
                Console.WriteLine($"  Exception regions: {mb.ExceptionRegions.Length}");
                Console.WriteLine();

                foreach (var region in mb.ExceptionRegions)
                {
                    Console.WriteLine(region.Kind.ToString());
                    Console.WriteLine($"  Try block offset: {region.TryOffset}");
                    Console.WriteLine($"  Try block length: {region.TryLength}");
                    Console.WriteLine($"  Handler offset: {region.HandlerOffset}");
                    Console.WriteLine($"  Handler length: {region.HandlerLength}");
                    Console.WriteLine();
                }
            }
        }
示例#30
0
        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>");
            }
        }
示例#31
0
 internal static CilLocal[] DecodeLocalSignature(MethodBodyBlock methodBody, MetadataReader metadataReader, CilTypeProvider provider)
 {
     if (methodBody.LocalSignature.IsNil)
     {
         return new CilLocal[0];
     }
     ImmutableArray<CilType> localTypes = SignatureDecoder.DecodeLocalSignature(methodBody.LocalSignature, provider);
     CilLocal[] locals = new CilLocal[localTypes.Length];
     for (int i = 0; i < localTypes.Length; i++)
     {
         string name = "V_" + i;
         locals[i] = new CilLocal(name, localTypes[i].ToString());
     }
     return locals;
 }