/// <summary>
        /// Emits the specified platform instruction.
        /// </summary>
        /// <param name="node">The context.</param>
        /// <param name="emitter">The emitter.</param>
        internal override void EmitLegacy(InstructionNode node, X86CodeEmitter emitter)
        {
            Debug.Assert(node.Result == node.Operand1);
            LegacyOpCode opCode = ComputeOpCode(node.Result, node.Operand1, node.Operand2);

            emitter.Emit(opCode, node.Result, node.Operand2);
        }
示例#2
0
        /// <summary>
        /// Emits the specified platform instruction.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="emitter">The emitter.</param>
        internal override void EmitLegacy(InstructionNode node, X86CodeEmitter emitter)
        {
            LegacyOpCode opCode = ComputeOpCode(node.Result, node.Operand1, null);

            if (node.Result.Register is ControlRegister)
            {
                emitter.Emit(opCode, node.Result, node.Operand1);
            }
            else
            {
                emitter.Emit(opCode, node.Operand1, node.Result);
            }
        }
示例#3
0
        private static readonly LegacyOpCode CMOVG  = new LegacyOpCode(new byte[] { 0x0F, 0x4F });          // GreaterThan (ZF = 0 and SF = OF)

        #endregion Data Members

        #region Methods

        /// <summary>
        /// Emits the specified platform instruction.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="emitter">The emitter.</param>
        /// <exception cref="System.NotSupportedException"></exception>
        internal override void EmitLegacy(InstructionNode node, X86CodeEmitter emitter)
        {
            LegacyOpCode opcode = null;

            switch (node.ConditionCode)
            {
            case ConditionCode.Equal: opcode = CMOVO; break;

            case ConditionCode.NotEqual: opcode = CMOVNE; break;

            case ConditionCode.Zero: opcode = CMOVZ; break;

            case ConditionCode.NotZero: opcode = CMOVNZ; break;

            case ConditionCode.GreaterOrEqual: opcode = CMOVGE; break;

            case ConditionCode.GreaterThan: opcode = CMOVG; break;

            case ConditionCode.LessOrEqual: opcode = CMOVLE; break;

            case ConditionCode.LessThan: opcode = CMOVL; break;

            case ConditionCode.UnsignedGreaterOrEqual: opcode = CMOVNB; break;

            case ConditionCode.UnsignedGreaterThan: opcode = CMOVA; break;

            case ConditionCode.UnsignedLessOrEqual: opcode = CMOVBE; break;

            case ConditionCode.UnsignedLessThan: opcode = CMOVB; break;

            case ConditionCode.Signed: opcode = CMOVS; break;

            case ConditionCode.NotSigned: opcode = CMOVNS; break;

            case ConditionCode.Carry: opcode = CMOVC; break;

            case ConditionCode.NoCarry: opcode = CMOVNC; break;

            case ConditionCode.Overflow: opcode = CMOVO; break;

            case ConditionCode.NoOverflow: opcode = CMOVNO; break;

            case ConditionCode.Parity: opcode = CMOVP; break;

            case ConditionCode.NoParity: opcode = CMOVNP; break;

            default: throw new NotSupportedException();
            }

            emitter.Emit(opcode, node.Result, node.Operand1);
        }
示例#4
0
        /// <summary>
        /// Emits the specified platform instruction.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="emitter">The emitter.</param>
        internal override void EmitLegacy(InstructionNode node, X86CodeEmitter emitter)
        {
            LegacyOpCode opCode = ComputeOpCode(node.Result, null, null);

            emitter.Emit(opCode, node.Result);
        }
示例#5
0
        /// <summary>
        /// Emits the specified platform instruction.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="emitter">The emitter.</param>
        internal override void EmitLegacy(InstructionNode node, X86CodeEmitter emitter)
        {
            LegacyOpCode opCode = ComputeOpCode(null, node.Operand1, node.Operand2);

            emitter.Emit(opCode, node.Operand1, node.Operand2);
        }