Esempio n. 1
0
        public static void Rev(ArmEmitterContext context)
        {
            Operand m = GetAluM(context);

            Operand res = context.ByteSwap(m);

            EmitAluStore(context, res);
        }
        public static void Vrev(ArmEmitterContext context)
        {
            OpCode32Simd op = (OpCode32Simd)context.CurrOp;

            EmitVectorUnaryOpZx32(context, (op1) =>
            {
                switch (op.Opc)
                {
                case 0:
                    switch (op.Size)     // Swap bytes.
                    {
                    default:
                        return(op1);

                    case 1:
                        return(InstEmitAluHelper.EmitReverseBytes16_32Op(context, op1));

                    case 2:
                    case 3:
                        return(context.ByteSwap(op1));
                    }

                case 1:
                    switch (op.Size)
                    {
                    default:
                        return(op1);

                    case 2:
                        return(context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op1, Const(0xffff0000)), Const(16)),
                                                 context.ShiftLeft(context.BitwiseAnd(op1, Const(0x0000ffff)), Const(16))));

                    case 3:
                        return(context.BitwiseOr(
                                   context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op1, Const(0xffff000000000000ul)), Const(48)),
                                                     context.ShiftLeft(context.BitwiseAnd(op1, Const(0x000000000000fffful)), Const(48))),
                                   context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op1, Const(0x0000ffff00000000ul)), Const(16)),
                                                     context.ShiftLeft(context.BitwiseAnd(op1, Const(0x00000000ffff0000ul)), Const(16)))));
                    }

                case 2:
                    // Swap upper and lower halves.
                    return(context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op1, Const(0xffffffff00000000ul)), Const(32)),
                                             context.ShiftLeft(context.BitwiseAnd(op1, Const(0x00000000fffffffful)), Const(32))));
                }

                return(op1);
            });
        }
Esempio n. 3
0
        public static void Rev32(ArmEmitterContext context)
        {
            OpCodeAlu op = (OpCodeAlu)context.CurrOp;

            Operand n = GetIntOrZR(context, op.Rn);

            if (op.RegisterSize == RegisterSize.Int32)
            {
                SetAluDOrZR(context, context.ByteSwap(n));
            }
            else
            {
                Operand d = context.Call(new _U64_U64(SoftFallback.ReverseBytes32_64), n);

                SetAluDOrZR(context, d);
            }
        }
Esempio n. 4
0
        public static void Rev32(ArmEmitterContext context)
        {
            OpCodeAlu op = (OpCodeAlu)context.CurrOp;

            Operand n = GetIntOrZR(context, op.Rn);
            Operand d;

            if (op.RegisterSize == RegisterSize.Int32)
            {
                d = context.ByteSwap(n);
            }
            else
            {
                d = EmitReverseBytes32_64Op(context, n);
            }

            SetAluDOrZR(context, d);
        }
Esempio n. 5
0
        public static void Rev64(ArmEmitterContext context)
        {
            OpCodeAlu op = (OpCodeAlu)context.CurrOp;

            SetAluDOrZR(context, context.ByteSwap(GetIntOrZR(context, op.Rn)));
        }