/// <summary>
        /// Matches the specified other.
        /// </summary>
        /// <param name="other">The other signature type.</param>
        /// <returns>True, if the signature type matches.</returns>
        public override bool Matches(SigType other)
        {
            RefSigType refOther = other as RefSigType;

            // FIXME: Do we need to consider custom mods here?
            return (refOther != null && refOther.elementType.Matches(this.ElementType) == true);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="GenericInstSigType"/> class.
 /// </summary>
 /// <param name="baseType">Type of the base.</param>
 /// <param name="genericArguments">The generic args.</param>
 public GenericInstSigType(TypeSigType baseType, SigType[] genericArguments)
     : base(CilElementType.GenericInst)
 {
     this.baseType = baseType;
     this.genericArguments = genericArguments;
     this.containsGenericParameters = CheckContainsOpenGenericParameters();
 }

        private IInstruction GetMoveInstruction(SigType sigType)
        {
            IInstruction moveInstruction;
            if (this.RequiresSseOperation(sigType) == false)
            {
                if (MustSignExtendOnLoad(sigType.Type) == true)
                {
                    moveInstruction = Instruction.MovsxInstruction;
                }
                else if (MustZeroExtendOnLoad(sigType.Type) == true)
                {
                    moveInstruction = Instruction.MovzxInstruction;
                }
                else
                {
                    moveInstruction = Instruction.MovInstruction;
                }
            }
            else if (sigType.Type == CilElementType.R8)
            {
                moveInstruction = Instruction.MovsdInstruction;
            }
            else
            {
                moveInstruction = Instruction.MovssInstruction;
            }

            return moveInstruction;
        }

        /// <summary>
        /// Retrieves a constant operand to represent the null-value.
        /// </summary>
        /// <returns>A new instance of <see cref="ConstantOperand"/>, that represents the null value.</returns>
        public static ConstantOperand GetNull()
        {
            if (_sObject == null)
                _sObject = BuiltInSigType.Object;

            return new ConstantOperand(_sObject, null);
        }

        /// <summary>
        /// Indicates whether the current object is equal to another object of the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        public override bool Equals(SigType other)
        {
            RefSigType rst = other as RefSigType;
            if (null == rst)
                return false;

            return (base.Equals(other) && this.elementType.Matches(rst.elementType) == true);
        }

        /// <summary>
        /// Allocates the virtual register.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public Operand AllocateVirtualRegister(SigType type)
        {
            Operand virtualRegister = Operand.CreateVirtualRegister(type, virtualRegisters.Count + 1);

            virtualRegisters.Add(virtualRegister);

            return virtualRegister;
        }

        /// <summary>
        /// Initializes a new <see cref="RegisterOperand"/>.
        /// </summary>
        /// <param name="type">The signature type of the value the register holds.</param>
        /// <param name="register">The machine specific register used.</param>
        public RegisterOperand(SigType type, Register register)
            : base(type)
        {
            if (register == null)
                throw new ArgumentNullException(@"register");

            this.register = register;
        }

        /// <summary>
        /// Indicates whether the current object is equal to another object of the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        public override bool Equals(SigType other)
        {
            ClassSigType cst = other as ClassSigType;
            if (null == cst)
                return false;

            return (base.Equals(other) == true && this.Token == cst.Token);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MemberOperand"/> class.
        /// </summary>
        /// <param name="member">The member to reference.</param>
        /// <param name="type">The type of data held in the operand.</param>
        /// <param name="offset">The offset from the base register or absolute address to retrieve.</param>
        public MemberOperand(RuntimeMember member, SigType type, IntPtr offset)
            : base(null, type, offset)
        {
            if (member == null)
                throw new ArgumentNullException(@"member");

            this.member = member;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RefSigType"/> class.
        /// </summary>
        /// <param name="type">The referenced type.</param>
        public RefSigType(SigType type)
            : base(CilElementType.ByRef)
        {
            if (null == type)
                throw new ArgumentNullException(@"type");

            ElementType = type;
        }

        /// <summary>
        /// Indicates whether the current object is equal to another object of the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        public override bool Equals(SigType other)
        {
            SZArraySigType szast = other as SZArraySigType;
            if (szast == null)
                return false;

            return (base.Equals(other) == true && _elementType.Equals(szast._elementType) && CustomMod.Equals(_customMods, szast._customMods));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LocalVariableSignature"/> class.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="token">The token.</param>
        /// <param name="genericArguments">The generic arguments.</param>
        public LocalVariableSignature(LocalVariableSignature signature, SigType[] genericArguments)
            : base(signature.Token)
        {
            locals = new VariableSignature[signature.locals.Length];

            for (int i = 0; i < signature.locals.Length; i++)
                locals[i] = new VariableSignature(signature.locals[i], genericArguments);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PtrSigType"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="customMods">The custom mods.</param>
        public PtrSigType(SigType type, CustomMod[] customMods)
            : base(CilElementType.Ptr)
        {
            if (type == null)
                throw new ArgumentNullException(@"type");

            this.customMods = customMods;
            this.elementType = type;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LdobjInstruction"/> class.
        /// </summary>
        /// <param name="opcode">The opcode.</param>
        public LdobjInstruction(OpCode opcode)
            : base(opcode, 1)
        {
            switch (opcode)
            {
                case OpCode.Ldind_i1:
                    typeRef = BuiltInSigType.SByte;
                    break;

                case OpCode.Ldind_i2:
                    typeRef = BuiltInSigType.Int16;
                    break;

                case OpCode.Ldind_i4:
                    typeRef = BuiltInSigType.Int32;
                    break;

                case OpCode.Ldind_i8:
                    typeRef = BuiltInSigType.Int64;
                    break;

                case OpCode.Ldind_u1:
                    typeRef = BuiltInSigType.Byte;
                    break;

                case OpCode.Ldind_u2:
                    typeRef = BuiltInSigType.UInt16;
                    break;

                case OpCode.Ldind_u4:
                    typeRef = BuiltInSigType.UInt32;
                    break;

                case OpCode.Ldind_i:
                    typeRef = BuiltInSigType.IntPtr;
                    break;

                case OpCode.Ldind_r4:
                    typeRef = BuiltInSigType.Single;
                    break;

                case OpCode.Ldind_r8:
                    typeRef = BuiltInSigType.Double;
                    break;

                case OpCode.Ldind_ref: // FIXME: Really object?
                    typeRef = BuiltInSigType.Object;
                    break;

                case OpCode.Ldobj: // FIXME
                    typeRef = null; // BuiltInSigType.Object;
                    break;

                default:
                    throw new NotImplementedException();
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PtrSigType"/> class.
        /// </summary>
        /// <param name="type">The type.</param>
        public PtrSigType(SigType type)
            : base(CilElementType.Ptr)
        {
            if (null == type)
                throw new ArgumentNullException(@"type");

            this.customMods = null;
            this.elementType = type;
        }

        /// <summary>
        /// Allocates the virtual register.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public VirtualRegisterOperand AllocateVirtualRegister(SigType type)
        {
            int index = virtualRegisters.Count + 1;

            VirtualRegisterOperand virtualRegister = new VirtualRegisterOperand(type, index);

            virtualRegisters.Add(virtualRegister);

            return virtualRegister;
        }

        private Operand InsertLoadBeforeInstruction(Context context, string symbolName, SigType type)
        {
            Context before = context.InsertBefore();
            Operand result = methodCompiler.CreateVirtualRegister(type);
            Operand op = Operand.CreateSymbol(type, symbolName);

            before.SetInstruction(CILInstruction.Get(OpCode.Ldc_i4), result, op);

            return result;
        }

        private Operand InsertLoadBeforeInstruction(Context context, string symbolName, SigType type)
        {
            Context before = context.InsertBefore();
            Operand result = this.methodCompiler.CreateTemporary(type);
            Operand op = new SymbolOperand(type, symbolName);

            before.SetInstruction(Instruction.Get(OpCode.Ldc_i4), result, op);

            return result;
        }

 public static Operand CreateResultOperand(IInstructionDecoder decoder, StackTypeCode operandType, SigType operandSigType)
 {
     if (operandType == StackTypeCode.O || operandType == StackTypeCode.Ptr || operandType == StackTypeCode.F)
     {
         return decoder.Compiler.CreateVirtualRegister(operandSigType);
     }
     else
     {
         return decoder.Compiler.CreateVirtualRegister(Operand.SigTypeFromStackType(operandType));
     }
 }

		public static SigType[] Resolve(SigType[] sigTypes, SigType[] genericArguments)
		{
			SigType[] newSigTypes = new SigType[sigTypes.Length];

			for (int i = 0; i < sigTypes.Length; i++)
			{
				newSigTypes[i] = Resolve(sigTypes[i], genericArguments);
			}

			return newSigTypes;
		}