public Instruction(Mnemonic mnemonic, Operand? operand, byte opcode, int length)
 {
     this.Mnemonic = mnemonic;
     this.Operand = operand;
     this.Opcode = opcode;
     this.Length = length;
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="destination"></param>
        /// <param name="source"></param>
        /// <param name="third"></param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            if (source.Type.Type == CilElementType.R4)
                return R4;

            return R8;
        }

        /// <summary>
        /// Builds up an expression to divide the left operand by the right operand.
        /// </summary>
        /// <param name="left">The left operand.</param>
        /// <param name="right">The right operand.</param>
        /// <returns>The operand that consists of the expression to divide the left operand by the right operand.</returns>
        public override Operand Calculate(Operand left, Operand right)
        {
            Logger.Info("Dividing operands (left = '{0}', right = '{1}').", left.OperandType.FullName, right.OperandType.FullName);

            Operand result = null;

            var operands = new OperandPair(left, right);
            if (operands.Are(typeof(decimal)))
            {
                result = new Operand(Expression.Divide(left.Expression, right.Expression), typeof(decimal));
            }
            else
            {
                Warn("'{0}' doesn't support to divide '{1}' and '{2}'.", GetType().FullName, left.OperandType.FullName, right.OperandType.FullName);

                var l = Expression.Call(null, typeof(Convert).GetMethod("ToString", new Type[] { typeof(object) }), Expression.Convert(left.Expression, typeof(object)));
                var r = Expression.Call(null, typeof(Convert).GetMethod("ToString", new Type[] { typeof(object) }), Expression.Convert(right.Expression, typeof(object)));
                var method = typeof(string).GetMethod("Concat", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(string) }, null);
                result = new Operand(Expression.Call(null, method, l, Expression.Constant(Symbol), r), typeof(string));
            }

            Logger.Info("Divided operands (result = '{0}').", result.OperandType.FullName);

            return result;
        }

        /// <summary>
        /// Computes the opcode.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        /// <param name="third">The third operand.</param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            if ((destination is MemoryOperand) && (source is RegisterOperand))
            {
                if (IsByte(destination) || IsByte(source))
                    return M_R_8;
                if (IsChar(destination) || IsChar(source))
                    return M_R_16;
                return M_R;
            }

            if ((destination is RegisterOperand) && (source is MemoryOperand))
            {
                if (IsByte(source) || IsByte(destination))
                    return R_M_8;
                if (IsChar(source) || IsShort(source))
                    return R_M_16;
                return R_M;
            }

            if ((destination is RegisterOperand) && (source is RegisterOperand)) return R_R;
            if ((destination is MemoryOperand) && (source is ConstantOperand)) return M_C;
            if ((destination is RegisterOperand) && (source is ConstantOperand))
            {
                if (IsByte(source) || IsByte(destination))
                    return R_C_8;
                if (IsChar(source) || IsShort(source))
                    return R_C_16;
                return R_C;
            }

            throw new ArgumentException(String.Format(@"x86.CmpInstruction: No opcode for operand types {0} and {1}.", destination, source));
        }

 /// <summary>
 /// Computes the opcode.
 /// </summary>
 /// <param name="destination">The destination operand.</param>
 /// <param name="source">The source operand.</param>
 /// <param name="third">The third operand.</param>
 /// <returns></returns>
 protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
 {
     if ((destination is RegisterOperand) && (source is LabelOperand)) return opcode;
     if ((destination is RegisterOperand) && (source is RegisterOperand)) return opcode;
     if ((destination is RegisterOperand) && (source is MemoryOperand)) return opcode;
     throw new ArgumentException(@"No opcode for operand type.");
 }

        /// <summary>
        /// Allows quick internal call replacements
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="methodCompiler">The method compiler.</param>
        /// <param name="internalMethod">The internal method to replace with.</param>
        /// <param name="internalClass">The internal class that has the internal method.</param>
        protected void Internal(Context context, BaseMethodCompiler methodCompiler, string internalMethod, string internalClass = "Internal")
        {
            if (context == null || methodCompiler == null || internalMethod == null || internalClass == null)
                throw new ArgumentNullException();

            var type = methodCompiler.TypeSystem.GetTypeByName("Mosa.Runtime", internalClass);
            Debug.Assert(type != null, "Cannot find Mosa.Runtime." + internalClass);

            var method = type.FindMethodByName(internalMethod);
            Debug.Assert(method != null, "Cannot find " + internalMethod + " in " + type.Name);

            Operand callTargetOperand = Operand.CreateSymbolFromMethod(methodCompiler.TypeSystem, method);

            var operands = new Operand[context.OperandCount];

            for (int i = 0; i < context.OperandCount; i++)
                operands[i] = context.GetOperand(i);

            Operand result = context.Result;

            context.SetInstruction(IRInstruction.Call, result, callTargetOperand);

            for (int i = 0; i < operands.Length; i++)
            {
                context.SetOperand(1 + i, operands[i]);
            }

            context.OperandCount = (byte)(1 + operands.Length);
            context.InvokeMethod = method;
        }

        /// <summary>
        /// Computes the opcode.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        /// <param name="third">The third operand.</param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            //if (source.Type.Type == CilElementType.R4) return DIVSS;
            return opcode;

            //return DIVSD;
        }

        /// <summary>
        /// Computes the opcode.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        /// <param name="third">The third operand.</param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            if ((destination is MemoryOperand) && (source is RegisterOperand))
            {
                if (IsByte (destination) || IsByte (source))
                    return M_R_8;
                if (IsChar (destination) || IsChar (source))
                    return M_R_16;
                return M_R;
            }

            if ((destination is RegisterOperand) && (source is MemoryOperand))
            {
                if (IsByte (source) || IsByte (destination))
                    return R_M_8;
                if (IsChar (source) || IsShort (source))
                    return R_M_16;
                return R_M;
            }

            if ((destination is RegisterOperand) && (source is RegisterOperand))
                return R_R;
            if ((destination is MemoryOperand) && (source is ConstantOperand))
                return M_C;
            if ((destination is RegisterOperand) && (source is ConstantOperand))
            {
                if (IsByte (source) || IsByte (destination))
                    return R_C_8;
                if (IsChar (source) || IsShort (source))
                    return R_C_16;
                return R_C;
            }
            throw new ArgumentException ("No opcode for operand type.");
        }

 public ConversationWrapper(Conversion conv, Operand op, Type @from, Type to)
 {
     _conv = conv;
     _op = op;
     _to = to;
     _from = @from;
 }

 //FUNCTIONS
 void Awake()
 {
     base.initialize(); //this calls initialization stuff inside the Symbol class
     operand = transform.parent.GetComponent<Operand>(); //refernce to parent Operand
     Debug.Log("Operand: " + operand);
     _padding = 0;
 }

 public SafeCast(Operand op, Type t)
 {
     _op = op;
     _t = t;
     if (t.IsValueType)
         _conditional = _op.Is(_t).Conditional(_op.Cast(_t), new DefaultValue(_t));
 }

        /// <summary>
        /// This function emits a constant variable into the read-only data section.
        /// </summary>
        /// <param name="operand">The operand.</param>
        /// <returns>
        /// An operand, which represents the reference to the read-only constant.
        /// </returns>
        protected Operand EmitFloatingPointConstant(Operand operand)
        {
            if (!operand.IsConstant || !operand.IsR)
                return operand;

            int size, alignment;
            Architecture.GetTypeRequirements(TypeLayout, operand.Type, out size, out alignment);

            string name = String.Format("C_{0}", Guid.NewGuid());

            using (Stream stream = MethodCompiler.Linker.Allocate(name, SectionKind.ROData, size, alignment))
            {
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    if (operand.IsR4)
                    {
                        writer.Write(operand.ConstantSingleFloatingPoint);
                    }
                    else if (operand.IsR8)
                    {
                        writer.Write(operand.ConstantDoubleFloatingPoint);
                    }
                }
            }

            return Operand.CreateLabel(operand.Type, name);
        }

 public AssemblerInstruction(int line, Opcode opcode, Operand left, Operand right)
 {
     Line = line;
     Opcode = opcode;
     Left = left;
     Right = right;
 }

        /// <summary>
        /// Computes the opcode.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        /// <param name="third">The third operand.</param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            if (destination is RegisterOperand)
                if ((destination as RegisterOperand).Register is ControlRegister) return CR_R;
                else if ((destination as RegisterOperand).Register is SegmentRegister)
                    throw new ArgumentException(@"TODO: No opcode for move to segment register");

            if (source is RegisterOperand)
                if ((source as RegisterOperand).Register is ControlRegister) return R_CR;
                else if ((source as RegisterOperand).Register is SegmentRegister)
                    throw new ArgumentException(@"TODO: No opcode for move from segment register");

            if ((destination is RegisterOperand) && (source is ConstantOperand)) return R_C;
            if ((destination is MemoryOperand) && (source is ConstantOperand)) return M_C;
            if ((destination is RegisterOperand) && (source is LabelOperand)) return R_C;
            if ((destination is MemoryOperand) && (source is LabelOperand)) return M_C;

            if ((destination is RegisterOperand) && (source is RegisterOperand)) {
                if (IsByte(source) || IsByte(destination)) return R_R_U8;
                if (IsChar(source) || IsChar(destination) || IsShort(source) || IsShort(destination)) return R_R_16;
                return R_R;
            }
            if ((destination is RegisterOperand) && (source is MemoryOperand)) {
                if (IsByte(destination)) return R_M_U8;
                if (IsChar(destination) || IsShort(destination)) return R_M_16;
                return R_M;
            }
            if ((destination is MemoryOperand) && (source is RegisterOperand)) {
                if (IsByte(destination)) return M_R_U8;
                if (IsChar(destination) || IsShort(destination)) return M_R_16;
                return M_R;
            }

            throw new ArgumentException(@"No opcode for operand type. [" + destination.GetType() + ", " + source.GetType() + ")");
        }

 /// <summary>
 /// Determines whether the specified operand is 32 bits.
 /// </summary>
 /// <param name="operand">The operand.</param>
 /// <returns></returns>
 protected static bool Is32Bit(Operand operand)
 {
     return (operand.Type.Type == CilElementType.U4)
         || (operand.Type.Type == CilElementType.I4)
         || IsPointer(operand)
         || IsObject(operand);
 }

        void IIntrinsicSupport.EmitInstruction(InstructionCode code, Operand operand0, Operand operand1)
        {
            Contract.Requires(operand0 != null);
            Contract.Requires(operand1 != null);

            throw new NotImplementedException();
        }

        /// <summary>
        /// Computes the opcode.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        /// <param name="third">The third operand.</param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            if (destination == null || destination is RegisterOperand || destination is MemoryOperand)
                return DIV;

            throw new ArgumentException ("No opcode for operand type.");
        }

 public Instruction(Mnemonic mnemonic, Operand[] operands, byte[] opcode, int length)
 {
     this.Mnemonic = mnemonic;
     this.Operands = operands;
     this.Opcode = opcode;
     this.Length = length;
 }

        /// <summary>
        /// Computes the opcode.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        /// <param name="third">The third operand.</param>
        /// <returns></returns>
        protected override OpCode ComputeOpCode(Operand destination, Operand source, Operand third)
        {
            if (!(destination is RegisterOperand))
                throw new ArgumentException(@"Destination must be RegisterOperand.", @"destination");
            if (source is ConstantOperand)
                throw new ArgumentException(@"Source must not be ConstantOperand.", @"source");

            switch (source.Type.Type) {
                case CilElementType.U1: goto case CilElementType.I1;
                case CilElementType.I1: {
                        if ((destination is RegisterOperand) && (source is RegisterOperand)) return R_X8;
                        if ((destination is RegisterOperand) && (source is MemoryOperand)) return R_X8;
                    }
                    break;
                case CilElementType.Char: goto case CilElementType.U2;
                case CilElementType.U2: goto case CilElementType.I2;
                case CilElementType.I2:
                    if ((destination is RegisterOperand) && (source is RegisterOperand)) return R_X16;
                    if ((destination is RegisterOperand) && (source is MemoryOperand)) return R_X16;
                    break;
                case CilElementType.Boolean: goto case CilElementType.I1;
                default:

                    break;
            }

            throw new ArgumentException(@"No opcode for operand type. [" + destination.GetType() + ", " + source.GetType() + ")");
        }

        private void HandleMemoryToMemoryOperation(Context ctx, Operand register, bool useStack)
        {
            Operand destination = ctx.Result;
            Operand source = ctx.Operand1;

            Debug.Assert (destination is MemoryOperand && source is MemoryOperand);

            if (register == null)
                register = new RegisterOperand (destination.Type, GeneralPurposeRegister.EDX);

            ctx.Operand1 = register;

            Context before = ctx.InsertBefore ();

            if (useStack)
            {
                before.SetInstruction (CPUx86.Instruction.PushInstruction, null, register);
                before.AppendInstruction (CPUx86.Instruction.MovInstruction, register, source);
            }

            else
                before.SetInstruction (CPUx86.Instruction.MovInstruction, register, source);

            if (useStack)
                ctx.AppendInstruction (CPUx86.Instruction.PopInstruction, register);
        }