[ARM] Improve VFP register moves.

test/cctest/test-assembler-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1280 matching lines @@
     uint32_t vqmovn_s8[2], vqmovn_u16[2], vqmovn_s32[2];
     int32_t vcvt_s32_f32[4];
     uint32_t vcvt_u32_f32[4];
     float vcvt_f32_s32[4], vcvt_f32_u32[4];
     uint32_t vdup8[4], vdup16[4], vdup32[4];
     float vabsf[4], vnegf[4];
     uint32_t vabs_s8[4], vabs_s16[4], vabs_s32[4];
     uint32_t vneg_s8[4], vneg_s16[4], vneg_s32[4];
     uint32_t veor[4], vand[4], vorr[4];
     float vdupf[4], vaddf[4], vpaddf[2], vsubf[4], vmulf[4];
+    uint32_t vdupf_16[2], vdupf_8[4];
     uint32_t vmin_s8[4], vmin_u16[4], vmin_s32[4];
     uint32_t vmax_s8[4], vmax_u16[4], vmax_s32[4];
     uint32_t vpadd_i8[2], vpadd_i16[2], vpadd_i32[2];
     uint32_t vpmin_s8[2], vpmin_u16[2], vpmin_s32[2];
     uint32_t vpmax_s8[2], vpmax_u16[2], vpmax_s32[2];
     uint32_t vadd8[4], vadd16[4], vadd32[4];
     uint32_t vqadd_s8[4], vqadd_u16[4], vqadd_s32[4];
     uint32_t vsub8[4], vsub16[4], vsub32[4];
     uint32_t vqsub_u8[4], vqsub_s16[4], vqsub_u32[4];
     uint32_t vmul8[4], vmul16[4], vmul32[4];
     uint32_t vshl8[4], vshl16[4], vshl32[5];
     uint32_t vshr_s8[4], vshr_u16[4], vshr_s32[5];
+    uint32_t vsli_64[2], vsri_64[2], vsli_32[2], vsri_32[2];
     uint32_t vceq[4], vceqf[4], vcgef[4], vcgtf[4];
     uint32_t vcge_s8[4], vcge_u16[4], vcge_s32[4];
     uint32_t vcgt_s8[4], vcgt_u16[4], vcgt_s32[4];
     float vrecpe[4], vrecps[4], vrsqrte[4], vrsqrts[4];
     float vminf[4], vmaxf[4];
     uint32_t vtst[4], vbsl[4];
     uint32_t vext[4];
     uint32_t vzip8a[4], vzip8b[4], vzip16a[4], vzip16b[4], vzip32a[4],
         vzip32b[4];
     uint32_t vzipd8a[2], vzipd8b[2], vzipd16a[2], vzipd16b[2];
@@ skipping 110 matching lines @@
     __ mov(r4, Operand(kMaxUInt32));
     __ mov(r5, Operand(kMinInt + 1));
     __ vmov(d1, r4, r5);  // q0 = [kMinInt, kMaxInt, kMaxUInt32, kMinInt + 1]
     __ vcvt_f32_s32(q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vcvt_f32_s32))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     __ vcvt_f32_u32(q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vcvt_f32_u32))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
 
-    // vdup (integer).
+    // vdup (from register).
     __ mov(r4, Operand(0xa));
     __ vdup(Neon8, q0, r4);
     __ vdup(Neon16, q1, r4);
     __ vdup(Neon32, q2, r4);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vdup8))));
     __ vst1(Neon8, NeonListOperand(q0), NeonMemOperand(r4));
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vdup16))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vdup32))));
     __ vst1(Neon8, NeonListOperand(q2), NeonMemOperand(r4));
 
-    // vdup (float).
+    // vdup (from scalar).
     __ vmov(s0, -1.0);
-    __ vdup(q0, s0);
+    __ vdup(Neon32, q1, d0, 0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vdupf))));
-    __ vst1(Neon8, NeonListOperand(q0), NeonMemOperand(r4));
+    __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
+    __ vdup(Neon16, d2, d0, 1);
+    __ vstr(d2, r0, offsetof(T, vdupf_16));
+    __ vdup(Neon8, q1, d0, 3);
+    __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vdupf_8))));
+    __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
 
     // vabs (float).
     __ vmov(s0, -1.0);
     __ vmov(s1, -0.0);
     __ vmov(s2, 0.0);
     __ vmov(s3, 1.0);
     __ vabs(q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vabsf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vneg (float).
@@ skipping 48 matching lines @@
     __ mov(r4, Operand(0xaa));
     __ vdup(Neon16, q0, r4);
     __ mov(r4, Operand(0x55));
     __ vdup(Neon16, q1, r4);
     __ vorr(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vorr))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
 
     // vmin (float).
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vmov(s4, 1.0);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q1, d2, 0);
     __ vmin(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vminf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vmax (float).
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vmov(s4, 1.0);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q1, d2, 0);
     __ vmax(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vmaxf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vadd (float).
     __ vmov(s4, 1.0);
-    __ vdup(q0, s4);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q0, d2, 0);
+    __ vdup(Neon32, q1, d2, 0);
     __ vadd(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vaddf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vpadd (float).
     __ vmov(s0, 1.0);
     __ vmov(s1, 2.0);
     __ vmov(s2, 3.0);
     __ vmov(s3, 4.0);
     __ vpadd(d2, d0, d1);
     __ vstr(d2, r0, offsetof(T, vpaddf));
     // vsub (float).
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vmov(s4, 1.0);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q1, d2, 0);
     __ vsub(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vsubf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vmul (float).
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q0, d2, 0);
+    __ vdup(Neon32, q1, d2, 0);
     __ vmul(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vmulf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vrecpe.
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vrecpe(q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vrecpe))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vrecps.
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vmov(s4, 1.5);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q1, d2, 0);
     __ vrecps(q1, q0, q1);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vrecps))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vrsqrte.
     __ vmov(s4, 4.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vrsqrte(q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vrsqrte))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vrsqrts.
     __ vmov(s4, 2.0);
-    __ vdup(q0, s4);
+    __ vdup(Neon32, q0, d2, 0);
     __ vmov(s4, 2.5);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q1, d2, 0);
     __ vrsqrts(q1, q0, q1);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vrsqrts))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vceq (float).
     __ vmov(s4, 1.0);
-    __ vdup(q0, s4);
-    __ vdup(q1, s4);
+    __ vdup(Neon32, q0, d2, 0);
+    __ vdup(Neon32, q1, d2, 0);
     __ vceq(q1, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vceqf))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     // vcge (float).
     __ vmov(s0, 1.0);
     __ vmov(s1, -1.0);
     __ vmov(s2, -0.0);
     __ vmov(s3, 0.0);
-    __ vdup(q1, s3);
+    __ vdup(Neon32, q1, d1, 1);
     __ vcge(q2, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vcgef))));
     __ vst1(Neon8, NeonListOperand(q2), NeonMemOperand(r4));
     __ vcgt(q2, q1, q0);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vcgtf))));
     __ vst1(Neon8, NeonListOperand(q2), NeonMemOperand(r4));
 
     // vmin/vmax integer.
     __ mov(r4, Operand(0x03));
     __ vdup(Neon16, q0, r4);
@@ skipping 185 matching lines @@
     __ vshr(NeonS8, q1, q0, 1);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vshr_s8))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     __ vshr(NeonU16, q1, q0, 9);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vshr_u16))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
     __ vshr(NeonS32, q1, q0, 17);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vshr_s32))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
 
+    // vsli, vsri.
+    __ mov(r4, Operand(0xffffffff));
+    __ mov(r5, Operand(0x1));
+    __ vmov(d0, r4, r5);
+    __ vmov(d1, r5, r5);
+    __ vsli(Neon64, d1, d0, 32);
+    __ vstr(d1, r0, offsetof(T, vsli_64));
+    __ vmov(d0, r5, r4);
+    __ vmov(d1, r5, r5);
+    __ vsri(Neon64, d1, d0, 32);
+    __ vstr(d1, r0, offsetof(T, vsri_64));
+    __ vmov(d0, r4, r5);
+    __ vmov(d1, r5, r5);
+    __ vsli(Neon32, d1, d0, 16);
+    __ vstr(d1, r0, offsetof(T, vsli_32));
+    __ vmov(d0, r5, r4);
+    __ vmov(d1, r5, r5);
+    __ vsri(Neon32, d1, d0, 16);
+    __ vstr(d1, r0, offsetof(T, vsri_32));
+
     // vceq.
     __ mov(r4, Operand(0x03));
     __ vdup(Neon8, q0, r4);
     __ vdup(Neon16, q1, r4);
     __ vceq(Neon8, q1, q0, q1);
     __ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vceq))));
     __ vst1(Neon8, NeonListOperand(q1), NeonMemOperand(r4));
 
     // vcge/vcgt (integer).
     __ mov(r4, Operand(0x03));
@@ skipping 273 matching lines @@
     CHECK_EQ(0xFFFFFFFFu, t.vmov_from_scalar_s16);
     CHECK_EQ(0xFFFFu, t.vmov_from_scalar_u16);
     CHECK_EQ(0xFFFFFFFFu, t.vmov_from_scalar_32);
 
     CHECK_EQ_32X4(vmov, 0x03020100u, 0x07060504u, 0x0b0a0908u, 0x0f0e0d0cu);
     CHECK_EQ_32X4(vmvn, 0xfcfdfeffu, 0xf8f9fafbu, 0xf4f5f6f7u, 0xf0f1f2f3u);
 
     CHECK_EQ_SPLAT(vdup8, 0x0a0a0a0au);
     CHECK_EQ_SPLAT(vdup16, 0x000a000au);
     CHECK_EQ_SPLAT(vdup32, 0x0000000au);
-    CHECK_EQ_SPLAT(vdupf, -1.0);
+    CHECK_EQ_SPLAT(vdupf, -1.0);  // bit pattern is 0xbf800000.
+    CHECK_EQ_32X2(vdupf_16, 0xbf80bf80u, 0xbf80bf80u);
+    CHECK_EQ_SPLAT(vdupf_8, 0xbfbfbfbfu);
 
     // src: [-1, -1, 1, 1]
     CHECK_EQ_32X4(vcvt_s32_f32, -1, -1, 1, 1);
     CHECK_EQ_32X4(vcvt_u32_f32, 0u, 0u, 1u, 1u);
     // src: [kMinInt, kMaxInt, kMaxUInt32, kMinInt + 1]
     CHECK_EQ_32X4(vcvt_f32_s32, INT32_TO_FLOAT(kMinInt),
                   INT32_TO_FLOAT(kMaxInt), INT32_TO_FLOAT(kMaxUInt32),
                   INT32_TO_FLOAT(kMinInt + 1));
     CHECK_EQ_32X4(vcvt_f32_u32, UINT32_TO_FLOAT(kMinInt),
                   UINT32_TO_FLOAT(kMaxInt), UINT32_TO_FLOAT(kMaxUInt32),
@@ skipping 61 matching lines @@
     CHECK_EQ_SPLAT(vsub32, 0xfffffffeu);
     CHECK_EQ_SPLAT(vmul8, 0x04040404u);
     CHECK_EQ_SPLAT(vmul16, 0x00040004u);
     CHECK_EQ_SPLAT(vmul32, 0x00000004u);
     CHECK_EQ_SPLAT(vshl8, 0xaaaaaaaau);
     CHECK_EQ_SPLAT(vshl16, 0xaa00aa00u);
     CHECK_EQ_SPLAT(vshl32, 0xaaaa0000u);
     CHECK_EQ_SPLAT(vshr_s8, 0xc0c0c0c0u);
     CHECK_EQ_SPLAT(vshr_u16, 0x00400040u);
     CHECK_EQ_SPLAT(vshr_s32, 0xffffc040u);
+    CHECK_EQ_32X2(vsli_64, 0x01u, 0xffffffffu);
+    CHECK_EQ_32X2(vsri_64, 0xffffffffu, 0x01u);
+    CHECK_EQ_32X2(vsli_32, 0xffff0001u, 0x00010001u);
+    CHECK_EQ_32X2(vsri_32, 0x00000000u, 0x0000ffffu);
     CHECK_EQ_SPLAT(vceq, 0x00ff00ffu);
     // [0, 3, 0, 3, ...] >= [3, 3, 3, 3, ...]
     CHECK_EQ_SPLAT(vcge_s8, 0x00ff00ffu);
     CHECK_EQ_SPLAT(vcgt_s8, 0u);
     // [0x00ff, 0x00ff, ...] >= [0xffff, 0xffff, ...]
     CHECK_EQ_SPLAT(vcge_u16, 0u);
     CHECK_EQ_SPLAT(vcgt_u16, 0u);
     // [0x000000ff, 0x000000ff, ...] >= [0xffffffff, 0xffffffff, ...]
     CHECK_EQ_SPLAT(vcge_s32, 0xffffffffu);
     CHECK_EQ_SPLAT(vcgt_s32, 0xffffffffu);
@@ skipping 1631 matching lines @@
     __ vswp(d30, d31);
     __ vstr(d30, r0, offsetof(T, vswp_d30));
     __ vstr(d31, r0, offsetof(T, vswp_d31));
   }
 
   // q-register swap.
   const uint32_t test_1 = 0x01234567;
   const uint32_t test_2 = 0x89abcdef;
   __ mov(r4, Operand(test_1));
   __ mov(r5, Operand(test_2));
-  // TODO(bbudge) replace with vdup when implemented.
-  __ vmov(d8, r4, r4);
-  __ vmov(d9, r4, r4);  // q4 = [1.0, 1.0]
-  __ vmov(d10, r5, r5);
-  __ vmov(d11, r5, r5);  // q5 = [-1.0, -1.0]
+  __ vdup(Neon32, q4, r4);
+  __ vdup(Neon32, q5, r5);
   __ vswp(q4, q5);
   __ add(r6, r0, Operand(static_cast<int32_t>(offsetof(T, vswp_q4))));
   __ vst1(Neon8, NeonListOperand(q4), NeonMemOperand(r6));
   __ add(r6, r0, Operand(static_cast<int32_t>(offsetof(T, vswp_q5))));
   __ vst1(Neon8, NeonListOperand(q5), NeonMemOperand(r6));
 
   __ ldm(ia_w, sp, r4.bit() | r5.bit() | r6.bit() | r7.bit() | pc.bit());
   __ bx(lr);
 
   CodeDesc desc;
@@ skipping 74 matching lines @@
   HandleScope scope(isolate);
 
   Assembler assm(isolate, NULL, 0);
   __ mov(r0, Operand(isolate->factory()->infinity_value()));
   __ BlockConstPoolFor(1019);
   for (int i = 0; i < 1019; ++i) __ nop();
   __ vldr(d0, MemOperand(r0, 0));
 }
 
 #undef __