C# Instruction.IsStoreLocal方法代码示例

        internal static bool AreEquivalent(Instruction source, Instruction target)
        {
            if (source.OpCode.Code != target.OpCode.Code)
                return false;

            if (source.OpCode.Code == Code.Ldstr)
                return true;

            //Check the types in ldarg stuff.  Sometimes this scheme
            //could lead us to false positives.  We need an analysis
            //which depends on the context.
            if (source.IsLoadArgument ()) {
                // case where 'ldarg this' is used (p.GetSequence () would be 0)
                if (!Current.HasParameters && !Target.HasParameters)
                    return true;
                return AreEquivalent (source.GetParameter (Current), target.GetParameter (Target));
            }

            // The same for ldloc / stloc
            if (source.IsLoadLocal () || source.IsStoreLocal ())
                return AreEquivalent (source.GetVariable (Current), target.GetVariable (Target));

            //WARNING: Dirty Evil Hack: this should be in the
            //Pattern class
            if (source.OpCode.Code == Code.Ret && source.Previous != null &&
                (source.Previous.OpCode.StackBehaviourPush == StackBehaviour.Pushi ||
                source.Previous.OpCode.Code == Code.Ldnull ||
                source.Previous.OpCode.StackBehaviourPush == StackBehaviour.Push1))
                return false;

            //if (source.Operand != target.Operand)
            if (source.Operand != null && target.Operand != null) {
                // we're sure that target.Operand is of the same type as source.Operand (same OpCode is used)
                Instruction si = (source.Operand as Instruction);
                if (si != null)
                    return (si.Offset == ((Instruction) target.Operand).Offset);
                IMetadataTokenProvider sm = (source.Operand as IMetadataTokenProvider);
                if (sm != null)
                    return sm.Equals (target.Operand as IMetadataTokenProvider);
                if (source.Operand == target.Operand)
                    return true;
                // last chance: we do call ToString
                if (source.Operand.ToString () != target.Operand.ToString ())
                    return false;
            }

            return true;
        }

		static bool OriginsMatch (MethodDefinition method, Instruction lhs, Instruction rhs)
		{
			bool match = false;

			object operand1 = lhs.GetOperand (method);
			object operand2 = rhs.GetOperand (method);

			if (lhs.OpCode.Code == rhs.OpCode.Code) {
				if (lhs.IsLoadArgument ())
					match = operand1.Equals (operand2);

				else if (lhs.IsLoadElement ())
					match = LoadElementMatch (method, lhs, rhs);

				else if (lhs.IsLoadIndirect ())
					match = LoadIndirectMatch (method, lhs, rhs);

				else if (lhs.IsLoadLocal ())
					match = LocalsMatch (operand1, operand2);

			} else if (lhs.IsStoreLocal () && rhs.IsLoadLocal ())
				match = LocalsMatch (operand1, operand2);

			else if (lhs.IsLoadLocal () && rhs.IsStoreLocal ())
				match = LocalsMatch (operand1, operand2);

			return match;
		}

		// true == handled
		// false == unhandled
		bool CheckIfStored (Instruction afterLdstr)
		{
			switch (afterLdstr.OpCode.Code) {
			case Code.Stfld: // store into field
			case Code.Stsfld:
				CheckIdentifier ((afterLdstr.Operand as FieldReference).Name);
				break;
			default:
				if (afterLdstr.IsStoreLocal ())
					CheckIdentifier (afterLdstr.GetVariable (method_body.Method).Name);
				else
					return false;
				break;
			}

			return true; // handled
		}

		static string CheckDoubleAssignement (MethodDefinition method, Instruction ins, Instruction next)
		{
			// for a static field the pattern is
			// DUP, STSFLD, STSFLD
			if (ins.OpCode.Code == Code.Stsfld) {
				if (next.OpCode.Code != Code.Stsfld)
					return String.Empty;

				// check that we're assigning the same field twice
				FieldDefinition fd1 = ins.GetField ();
				FieldDefinition fd2 = next.GetField ();
				if (fd1.MetadataToken.RID != fd2.MetadataToken.RID)
					return String.Empty;

				return String.Format ("Static field '{0}'.", fd1.Name);
			} else if (ins.IsStoreLocal ()) {
				// for a local variable the pattern is
				// DUP, STLOC, STLOC
				VariableDefinition vd2 = next.GetVariable (method);
				// check that we're assigning the same variable twice
				if (vd2 != null) {
					VariableDefinition vd1 = ins.GetVariable (method);
					if (vd1.Index != vd2.Index)
						return String.Empty;

					return String.Format ("Local variable '{0}'.", vd1.Name);
				} else if (next.OpCode.Code == Code.Stfld) {
					// instance fields are a bit more complex...
					return CheckDoubleAssignementOnInstanceFields (method, ins, next);
				}
			}
			return String.Empty;
		}

        private void Apply(Instruction instruction, Stack<Value> stack, ICollection<Value> values, IList<Value> locals)
        {
            // TODO: this method is a mess and needs to be refactored!!

            var pushCount = instruction.GetPushCount();
            var popCount = instruction.GetPopCount(_method);
            if (popCount == Int32.MaxValue)
                popCount = stack.Count;

            var isCall = instruction.OpCode.FlowControl == FlowControl.Call;
            var callParams = isCall ? (instruction.Operand as MethodReference).Parameters : NoParams;

            // List of all popped values
            var poppedValues = new List<Value>();

            var inputArguments = new List<Value>();
            for (var i = 0; i < popCount; i++)
            {
                // Instruction is a consumer
                var value = stack.Pop();
                poppedValues.Add(value);
                // If we popped a value for an out parameter, we're not a consumer!
                // Note that the first pop returns the last argument.
                if (isCall && i < callParams.Count && callParams[callParams.Count - i - 1].IsOut)
                {
                    inputArguments.Insert(0, null); // empty slot
                    continue;
                }
                value.Consumer = instruction;
                inputArguments.Insert(0, value); //TODO: not 'this'!?!?
            }
            int storeIndex;
            if (instruction.IsStoreLocal(out storeIndex))
            {
                Debug.Assert(popCount == 1);
                locals[storeIndex] = poppedValues[0];
            }
            for (var i = 0; i < pushCount; i++)
            {
                Value newValue;
                // Instruction is a producer
                int loadIndex;
                if (instruction.IsLoadLocal(out loadIndex))
                {
                    Debug.Assert(pushCount == 1);
                    newValue = new Value(instruction);
                    values.Add(newValue);
                    // The local value can be null if we're passing loading a reference
                    // destined for an out parameter. Note that we can get a non-null
                    // value as well, so we have to sort things out when we handle the
                    // call to the method with the out parameter.
                    var localValue = locals[loadIndex];
                    if (localValue != null)
                    {
                        newValue.AddParents(new[] { localValue });
                    }
                }
                else
                {
                    newValue = new Value(instruction);
                    values.Add(newValue);
                    newValue.AddParents(inputArguments.Where(a => a != null));
                }
                stack.Push(newValue);
            }
            if (isCall)
            {
                var argValues = new Value[callParams.Count];
                for (var i = 0; i < argValues.Length; i++)
                {
                    argValues[i] = poppedValues[argValues.Length - i - 1];
                }
                for (var i = 0; i < callParams.Count; i++)
                {
                    // First of poppedValues is last argument
                    var inputArgument = poppedValues[callParams.Count - i - 1];
                    if (!callParams[i].IsRef() && !callParams[i].IsOut)
                        continue;

                    var newValue = new Value(instruction);
                    var storeAtIndex = (inputArgument.Producer.Operand as VariableDefinition).Index;

                    // Add all input values (including any refs) as parents!
                    for (var j = 0; j < callParams.Count; j++)
                    {
                        if (callParams[j].IsOut)
                            continue;
                        newValue.AddParents(new[] { argValues[j] });
                    }

                    // Don't push onto the stack, but save the value and store
                    // it in the locals array.
                    values.Add(newValue);
                    locals[storeAtIndex] = newValue;
                }
            }
        }

		static Instruction LocalTraceBack (IMethodSignature method, Instruction ins)
		{
			ins = ins.TraceBack (method);
			while (ins != null) {
				if (ins.IsLoadLocal () || ins.IsStoreLocal ())
					return ins;
				ins = ins.TraceBack (method);
			}
			return null;
		}