/// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            var stackTypeForOperand1 = ctx.Operand1.StackType;
            var stackTypeForOperand2 = ctx.Operand2.StackType;

            if (ctx.Operand1.Type is ValueTypeSigType)
            {
                var op1Type = compiler.Method.Module.GetType ((ctx.Operand1.Type as ValueTypeSigType).Token);
                if (op1Type.BaseType.FullName == "System.Enum")
                    stackTypeForOperand1 = this.FromSigType (op1Type.Fields[0].SignatureType.Type);
            }

            if (ctx.Operand2.Type is ValueTypeSigType)
            {
                var op2Type = compiler.Method.Module.GetType ((ctx.Operand2.Type as ValueTypeSigType).Token);
                if (op2Type.BaseType.FullName == "System.Enum")
                    stackTypeForOperand2 = this.FromSigType (op2Type.Fields[0].SignatureType.Type);
            }

            var result = _opTable[(int)stackTypeForOperand1][(int)stackTypeForOperand2];

            if (result == StackTypeCode.Unknown)
                throw new InvalidOperationException (@"Invalid stack result of instruction: " + result.ToString () + " (" + ctx.Operand1.ToString () + ")");

            ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result));
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            StackTypeCode result = StackTypeCode.Unknown;
            switch (opcode)
            {
                case OpCode.Add_ovf_un:
                    result = _addovfunTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType];
                    break;

                case OpCode.Sub_ovf_un:
                    result = _subovfunTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType];
                    break;

                default:
                    result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType];
                    break;
            }

            if (StackTypeCode.Unknown == result)
                throw new InvalidOperationException(@"Invalid operand types passed to " + opcode);

            ctx.Result = compiler.CreateVirtualRegister(Operand.SigTypeFromStackType(result));
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            // Simple result is the same type as the unary argument
            ctx.Result = compiler.CreateTemporary(ctx.Operand1.Type);
        }

        /// <summary>
        /// Validates the specified instruction.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            ctx.Result = ctx.Operand1;
            ctx.Result2 = ctx.Operand1;
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            // Validate the typecode & determine the resulting stack type
            SigType resultType;

            switch (_opcode) {
                case OpCode.Conv_u: goto case OpCode.Conv_i;
                case OpCode.Conv_i:
                    resultType = compiler.Architecture.NativeType;
                    break;

                case OpCode.Conv_i1:
                    resultType = new SigType(CilElementType.I1);
                    break;

                case OpCode.Conv_i2:
                    resultType = new SigType(CilElementType.I2);
                    break;

                case OpCode.Conv_i4:
                    resultType = new SigType(CilElementType.I4);
                    break;

                case OpCode.Conv_i8:
                    resultType = new SigType(CilElementType.I8);
                    break;

                case OpCode.Conv_r4:
                    resultType = new SigType(CilElementType.R4);
                    break;

                case OpCode.Conv_r8:
                    resultType = new SigType(CilElementType.R8);
                    break;

                case OpCode.Conv_u1:
                    resultType = new SigType(CilElementType.U1);
                    break;

                case OpCode.Conv_u2:
                    resultType = new SigType(CilElementType.U2);
                    break;

                case OpCode.Conv_u4:
                    resultType = new SigType(CilElementType.U4);
                    break;

                case OpCode.Conv_u8:
                    resultType = new SigType(CilElementType.U8);
                    break;

                default:
                    throw new NotSupportedException(@"Overflow checking conversions not supported.");
            }

            ctx.Result = compiler.CreateTemporary(resultType);
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            Mosa.Runtime.Metadata.Signatures.ArraySigType a = ctx.Operand1.Type as Mosa.Runtime.Metadata.Signatures.ArraySigType;
            if (null == a || 1 != a.Rank)
                throw new InvalidProgramException(@"Operand to ldlen is not a vector.");
            ctx.Result = compiler.CreateTemporary(new SigType(CilElementType.I));
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            SZArraySigType arrayType = ctx.Operand1.Type as SZArraySigType;
            if (arrayType == null)
                throw new InvalidProgramException(@"Operand to ldlen is not a vector.");

            ctx.Result = compiler.CreateTemporary(BuiltInSigType.IntPtr);
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            StackTypeCode result = _opTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType];
            if (result == StackTypeCode.Unknown)
                throw new InvalidOperationException(@"Invalid stack result of instruction.");

            ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result));
        }

 public static void Run(IMethodCompiler methodCompiler, IPipelineStage stage)
 {
     Run(
         methodCompiler.InternalTrace,
         stage,
         methodCompiler.Method,
         methodCompiler.InstructionSet,
         methodCompiler.BasicBlocks
     );
 }

        /// <summary>
        /// Setups the specified compiler.
        /// </summary>
        /// <param name="compiler">The compiler.</param>
        public void Setup(IMethodCompiler compiler)
        {
            if (compiler == null)
                throw new ArgumentNullException ("compiler");

            MethodCompiler = compiler;
            InstructionSet = compiler.InstructionSet;
            BasicBlocks = compiler.BasicBlocks;
            Architecture = compiler.Architecture;
        }

        /// <summary>
        /// Setup stage specific processing on the compiler context.
        /// </summary>
        /// <param name="methodCompiler">The compiler context to perform processing in.</param>
        void IMethodCompilerStage.Setup(IMethodCompiler methodCompiler)
        {
            base.Setup(methodCompiler);

            IStackLayoutProvider stackLayoutProvider = methodCompiler.Pipeline.FindFirst<IStackLayoutProvider>();

            stackSize = (stackLayoutProvider == null) ? 0 : stackLayoutProvider.LocalsSize;

            Debug.Assert((stackSize % 4) == 0, @"Stack size of method can't be divided by 4!!");
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            StackTypeCode result = _operandTable[(int)ctx.Operand1.StackType][(int)ctx.Operand2.StackType];
            Debug.Assert(StackTypeCode.Unknown != result, @"Can't shift with the given stack operands.");
            if (StackTypeCode.Unknown == result)
                throw new InvalidOperationException(@"Invalid stack state for pairing (" + ctx.Operand1.StackType + ", " + ctx.Operand2.StackType + ")");

            ctx.Result = compiler.CreateTemporary(Operand.SigTypeFromStackType(result));
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            // Validate the operand
            StackTypeCode result = _opTable[(int)ctx.Operand1.StackType];
            if (StackTypeCode.Unknown == result)
                throw new InvalidOperationException(@"Invalid operand to Not instruction.");

            ctx.Result = compiler.CreateTemporary(ctx.Operand1.Type);
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            // Validate the operand
            StackTypeCode result = _typeCodes[(int)ctx.Operand1.StackType];
            if (StackTypeCode.Unknown == result)
                throw new InvalidOperationException(@"Invalid operand to Neg instruction [" + result + "]");

            ctx.Result = compiler.CreateVirtualRegister(ctx.Operand1.Type);
        }

        private static int ComputeTypeSize(TokenTypes token, IMethodCompiler compiler)
        {
            IMetadataProvider metadata = compiler.Assembly.Metadata;
            Metadata.Tables.TypeDefRow typeDefinition;
            Metadata.Tables.TypeDefRow followingTypeDefinition;
            metadata.Read(token, out typeDefinition);
            metadata.Read(token + 1, out followingTypeDefinition);

            int result = 0;
            TokenTypes fieldList = typeDefinition.FieldList;
            while (fieldList != followingTypeDefinition.FieldList)
                result += FieldSize(fieldList++, compiler);

            return result;
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            // Make sure the base is a typed reference
            throw new NotImplementedException();
            /*
                if (!Object.ReferenceEquals(_operands[0].Type, MetadataTypeReference.FromName(compiler.Assembly.Metadata, @"System", @"TypedReference")))
                {
                    Debug.Assert(false);
                    throw new InvalidProgramException(@"Invalid stack object.");
                }

                // Push the loaded value
                _results[0] = CreateResultOperand(_typeRef);
             */
        }

        private static int FieldSize(TokenTypes field, IMethodCompiler compiler)
        {
            Metadata.Tables.FieldRow fieldRow;
            compiler.Assembly.Metadata.Read(field, out fieldRow);
            FieldSignature signature = Signature.FromMemberRefSignatureToken(compiler.Assembly.Metadata, fieldRow.SignatureBlobIdx) as FieldSignature;

            // If the field is another struct, we have to dig down and compute its size too.
            if (signature.Type.Type == CilElementType.ValueType)
            {
                TokenTypes valueTypeSig = ValueTokenTypeFromSignature(compiler.Assembly.Metadata, fieldRow.SignatureBlobIdx);
                return ComputeTypeSize(valueTypeSig, compiler);
            }

            int size, alignment;
            compiler.Architecture.GetTypeRequirements(signature.Type, out size, out alignment);
            return size;
        }

        /// <summary>
        /// Initializes a new instance of <see cref="BaseCodeEmitter"/>.
        /// </summary>
        /// <param name="compiler">The compiler.</param>
        /// <param name="codeStream">The stream the machine code is written to.</param>
        /// <param name="linker">The linker used to resolve external addresses.</param>
        void ICodeEmitter.Initialize(IMethodCompiler compiler, Stream codeStream, IAssemblyLinker linker)
        {
            Debug.Assert(null != compiler, @"MachineCodeEmitter needs a method compiler.");
            if (compiler == null)
                throw new ArgumentNullException(@"compiler");
            Debug.Assert(null != codeStream, @"MachineCodeEmitter needs a code stream.");
            if (codeStream == null)
                throw new ArgumentNullException(@"codeStream");
            Debug.Assert(null != linker, @"MachineCodeEmitter needs a linker.");
            if (linker == null)
                throw new ArgumentNullException(@"linker");

            this.compiler = compiler;
            this.codeStream = codeStream;
            this.codeStreamBasePosition = codeStream.Position;
            this.linker = linker;
        }

        /// <summary>
        /// Sets the invoke target.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        /// <param name="method">The method.</param>
        private static void SetInvokeTarget(Context ctx, IMethodCompiler compiler, RuntimeMethod method)
        {
            if (method == null)
                throw new ArgumentNullException(@"method");

            // Signature of the call target
            // Number of parameters required for the call

            ctx.InvokeTarget = method;

            // Retrieve the target signature
            MethodSignature signature = ctx.InvokeTarget.Signature;

            // Fix the parameter list
            byte paramCount = (byte)signature.Parameters.Length;
            if (signature.HasThis && !signature.HasExplicitThis)
                paramCount++;

            // Setup operands for parameters and the return value
            if (signature.ReturnType.Type != CilElementType.Void)
            {
                ctx.ResultCount = 1;
                ctx.Result = compiler.CreateTemporary(signature.ReturnType);
            }
            else
                ctx.ResultCount = 0;

            ctx.OperandCount = paramCount;
        }

        /// <summary>
        /// Validates the instruction operands and creates a matching variable for the result.
        /// </summary>
        /// <param name="ctx">The context.</param>
        /// <param name="compiler">The compiler.</param>
        public override void Validate(Context ctx, IMethodCompiler compiler)
        {
            base.Validate(ctx, compiler);

            int paramCount = ctx.InvokeTarget.Signature.Parameters.Length;

            if (ctx.InvokeTarget.Signature.HasThis && !ctx.InvokeTarget.Signature.HasExplicitThis)
                paramCount++;

            // Validate the operands...
            Debug.Assert(ctx.OperandCount == paramCount, @"Operand count doesn't match parameter count.");

            //for (int i = 0; i < ctx.OperandCount; i++)
            //{
            /* FIXME: Check implicit conversions
            // if (ops[i] != null) {
                Debug.Assert(_operands[i].Type == _parameterTypes[i]);
                if (_operands[i].Type != _parameterTypes[i])
                {
                    // FIXME: Determine if we can do an implicit conversion
                    throw new ExecutionEngineException(@"Invalid operand types.");
                }
            */
            //}
        }