C# Method.TryGetBody方法代码示例

        /// <summary>
        /// Returns a method call for a PUT. This should be of certain characteristics,
        /// It should contain only one method call as generated by us
        /// </summary>
        /// <param name="putmethod"></param>
        /// <returns></returns>
        public static bool TryRetrieveMethodCall(Method putmethod, out Method assocmethod)
        {
            SafeDebug.AssumeNotNull(putmethod, "putmethod");
            assocmethod = null;

            MethodBodyEx mbodyex;
            bool bresult = putmethod.TryGetBody(out mbodyex);
            SafeDebug.Assert(bresult, "Failed to get the body");

            int offset = 0;
            Instruction instruction;

            List<Method> allCalledMethods = new List<Method>();
            while (mbodyex.TryGetInstruction(offset, out instruction))
            {
                SafeDebug.AssumeNotNull(instruction, "instruction");
                OpCode opCode = instruction.OpCode;

                if (opCode == OpCodes.Call || opCode == OpCodes.Callvirt)
                {
                    SafeDebug.Assume(opCode.OperandType == OperandType.InlineMethod,
                        "opCode.OperandType == OperandType.InlineMethod");
                    allCalledMethods.Add(instruction.Method);
                }

                offset = instruction.NextOffset;
            }

            if (allCalledMethods.Count != 1)
                return false;

            assocmethod = allCalledMethods[0];
            return true;
        }

        /// <summary>
        /// Computes method effects statically. All written fields of a method.
        /// Can be imprecise and conservative
        /// </summary>
        /// <param name="declaringType"></param>
        /// <param name="method"></param>
        /// <param name="effects"></param>
        /// <returns></returns>
        public static bool TryComputeMethodEffects(IPexComponent host, TypeEx declaringType, Method method,
            SafeSet<Method> visitedMethods, out MethodEffects effects)
        {
            SafeDebug.AssumeNotNull(declaringType, "declaringType");
            SafeDebug.AssumeNotNull(method, "method");

            try
            {
                if (visitedMethods == null)
                    visitedMethods = new SafeSet<Method>();

                if (visitedMethods.Contains(method))
                {
                    effects = null;
                    return false;
                }

                visitedMethods.Add(method);

                //Check whether this has been computed before
                var psd = host.GetService<IPexMeStaticDatabase>() as PexMeStaticDatabase;
                if (psd.MethodEffectsDic.TryGetValue(method.GlobalIndex, out effects))
                    return true;

                var res = new SafeSet<string>();
                var directSetFields = new SafeSet<string>();
                var directCalledMethods = new SafeSet<Method>();
                var returnFields = new SafeSet<Field>();
                var modificationTypeDic = new SafeDictionary<string, FieldModificationType>();
                var parameters = method.Parameters;

                MethodBodyEx body;
                if (!method.TryGetBody(out body) || !body.HasInstructions)
                {
                    effects = null;
                    return false;
                }

                int callDepth = 0;
                int offset = 0;
                Instruction instruction;
                OpCode prevOpcode = OpCodes.Nop;

                //Stack for load instructions
                Field lastAccessedArrayField = null;
                Field lastAccessedField = null;

                while (body.TryGetInstruction(offset, out instruction))
                {
                    SafeDebug.AssumeNotNull(instruction, "instruction");
                    OpCode opCode = instruction.OpCode;
                    if (LdcOpCodes.Contains(opCode))
                    {
                        //topIsConstant = true;
                    }
                    else if (ConvOpCodes.Contains(opCode))
                    {
                        // do not change topIsConstant
                    }
                    else
                    {
                        if (opCode == OpCodes.Stfld)
                        {
                            SafeDebug.Assume(opCode.OperandType == OperandType.InlineField, "opCode.OperandType == OperandType.InlineField");
                            Field field = instruction.Field;
                            AddFieldToMethodEffects(host, declaringType, res, directSetFields, modificationTypeDic, prevOpcode, field, field.Type);
                        }
                        else if (opCode == OpCodes.Ldfld || opCode == OpCodes.Ldflda)
                        {
                            SafeDebug.Assume(opCode.OperandType == OperandType.InlineField, "opCode.OperandType == OperandType.InlineField");
                            Field accessedField = instruction.Field;

                            if (accessedField.Type.Spec == TypeSpec.SzArray)
                            {
                                lastAccessedArrayField = accessedField;
                            }
                            else
                                lastAccessedField = accessedField;
                        }
                        else if (StElemOpCodes.Contains(opCode))
                        {
                            if (lastAccessedArrayField != null)
                            {
                                //Indicates that there is n array type modified
                                AddFieldToMethodEffects(host, declaringType, res, directSetFields, modificationTypeDic, prevOpcode, lastAccessedArrayField, lastAccessedArrayField.Type);
                                lastAccessedArrayField = null;
                            }
                        }
                        else if (opCode == OpCodes.Call || opCode == OpCodes.Callvirt)
                        {
                            SafeDebug.Assume(opCode.OperandType == OperandType.InlineMethod, "opCode.OperandType == OperandType.InlineMethod");
                            Method methodinner = instruction.Method;
//.........这里部分代码省略.........

        /// <summary>
        /// Populates all vertices
        /// </summary>
        /// <param name="method"></param>
        private void PopulateVertices(Method method)
        {
            MethodBodyEx body;
            if (!method.TryGetBody(out body) || !body.HasInstructions)
            {
                return;
            }

            int offset = 0;
            Instruction instruction;
            while (body.TryGetInstruction(offset, out instruction))
            {
                SafeDebug.AssumeNotNull(instruction, "instruction");
                OpCode opCode = instruction.OpCode;

                InstructionVertex iv = this.AddVertex(instruction);
                this.vertices[offset] = iv;
                offset = instruction.NextOffset;
            }
        }

        /// <summary>
        /// Adds edges to the graph
        /// </summary>
        /// <param name="method"></param>
        private void PopulateEdges(Method method)
        {
            MethodBodyEx body;
            if (!method.TryGetBody(out body) || !body.HasInstructions)
            {
                return;
            }

            int offset = 0;
            Instruction instruction;
            InstructionVertex cv = null;

            //make the graph
            while (body.TryGetInstruction(offset, out instruction))
            {
                SafeDebug.AssumeNotNull(instruction, "instruction");
                OpCode opCode = instruction.OpCode;

                InstructionVertex iv = this.vertices[offset];
                if (cv != null)
                {
                    this.AddEdge(cv, iv);
                }

                if (MethodOrFieldAnalyzer.BranchOpCodes.Contains(opCode))
                {
                    InstructionVertex alternatev = this.vertices[instruction.BrTargetOffset];
                    this.AddEdge(iv, alternatev);
                    cv = iv;
                }
                else if (opCode == OpCodes.Switch)
                {
                    foreach (var switchoff in instruction.SwitchOffsets)
                    {
                        InstructionVertex alternatev = this.vertices[switchoff];
                        this.AddEdge(iv, alternatev);
                    }
                    cv = iv;
                }
                else if (opCode == OpCodes.Br || opCode == OpCodes.Br_S)
                {
                    InstructionVertex alternatev = this.vertices[instruction.BrTargetOffset];
                    this.AddEdge(iv, alternatev);
                    cv = null;
                }
                else if (opCode == OpCodes.Break)
                {
                    InstructionVertex alternatev = this.vertices[instruction.BrTargetOffset];
                    this.AddEdge(iv, alternatev);
                    cv = null;
                }
                else if (opCode == OpCodes.Ret || opCode == OpCodes.Throw)
                {
                    cv = null;
                }
                else
                {
                    cv = iv;
                }
                offset = instruction.NextOffset;
            }
        }

        /// <summary>
        /// Checks whether all blocks within the method are covered
        /// </summary>
        /// <param name="methoddef"></param>
        /// <returns></returns>
        public bool AreAllOffsetsCoveredInMethod(Method method)
        {
            var methoddef = method.Definition;
            MethodDefinitionBodyInstrumentationInfo info;
            if (!methoddef.TryGetBodyInstrumentationInfo(out info))
                return false;

            CoverageDomain domain;
            int[] hits;
            if (!this.coverageBuilderMaxAggregator.TryGetMethodHits(methoddef, out domain, out hits))
                return false;

            MethodBodyEx body;
            if (!method.TryGetBody(out body) || !body.HasInstructions)
                return false;

            int offset = 0;
            Instruction instruction;
            while (body.TryGetInstruction(offset, out instruction))
            {
                //For a branching instruction, check whether both sides are covered
                if (MethodOrFieldAnalyzer.BranchOpCodes.Contains(instruction.OpCode))
                {
                    if (NumTimesOffsetCovered(offset, info, hits) <= 1)
                        return false;
                }
                offset = instruction.NextOffset;
            }
            return true;
        }