[Turbofan] Modify ARM vswp assembler test to use integers.

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 2901 matching lines @@
 
 TEST(vswp) {
   if (!CpuFeatures::IsSupported(NEON)) return;
 
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   Assembler assm(isolate, NULL, 0);
 
   typedef struct {
-    double result0;
-    double result1;
-    double result2;
-    double result3;
-    double result4;
-    double result5;
-    double result6;
-    double result7;
+    uint64_t result0;
+    uint64_t result1;
+    uint64_t result2;
+    uint64_t result3;
+    uint64_t result4;
+    uint64_t result5;
+    uint64_t result6;
+    uint64_t result7;
   } T;
   T t;
 
-  __ vmov(d0, 1.0);
-  __ vmov(d1, -1.0);
+  __ stm(db_w, sp, r4.bit() | r5.bit() | r6.bit() | lr.bit());
+
+  __ mov(r4, Operand(0));
+  __ mov(r5, Operand(0x3FF00000));
+  __ mov(r6, Operand(0xBFF00000));

[jbramley, 2016/11/30 10:41:08]

`double_to_rawbits` could make this cleaner:

uint64_t one = double_to_rawbits(1.0);
__ mov(r5, Operand(one >> 32));
__ mov(r6, Operand(one & 0xffffffff));

[bbudge, 2016/11/30 11:34:14]

I used bit_cast<uint64_t> since double_to_rawbits is only an arm64 function.

+  __ vmov(d0, r4, r5);  // d0 = 1.0
+  __ vmov(d1, r4, r6);  // d1 = -1.0
   __ vswp(d0, d1);
   __ vstr(d0, r0, offsetof(T, result0));
   __ vstr(d1, r0, offsetof(T, result1));
 
   if (CpuFeatures::IsSupported(VFP32DREGS)) {
-    __ vmov(d30, 1.0);
-    __ vmov(d31, -1.0);
+    __ vmov(d30, r4, r5);  // d30 = 1.0
+    __ vmov(d31, r4, r6);  // d31 = -1.0
     __ vswp(d30, d31);
     __ vstr(d30, r0, offsetof(T, result2));
     __ vstr(d31, r0, offsetof(T, result3));
   }
 
   // q-register swap.
-  __ vmov(d8, 1.0);
-  __ vmov(d9, 2.0);
-  __ vmov(d10, 3.0);
-  __ vmov(d11, 4.0);
+  __ vmov(d8, r4, r5);
+  __ vmov(d9, r4, r5);  // q4 = [1.0, 1.0]
+  __ vmov(d10, r4, r6);
+  __ vmov(d11, r4, r6);  // q5 = [-1.0, -1.0]
   __ vswp(q4, q5);
   __ vstr(d8, r0, offsetof(T, result4));
   __ vstr(d9, r0, offsetof(T, result5));
   __ vstr(d10, r0, offsetof(T, result6));
   __ vstr(d11, r0, offsetof(T, result7));
 
+  __ ldm(ia_w, sp, r4.bit() | r5.bit() | r6.bit() | pc.bit());
   __ bx(lr);
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F3 f = FUNCTION_CAST<F3>(code->entry());
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
-  CHECK_EQ(-1.0, t.result0);
-  CHECK_EQ(1.0, t.result1);
+  CHECK_EQ(0xBFF0000000000000u, t.result0);

[jbramley, 2016/11/30 10:41:08]

Nearby tests use lower-case hexadecimal. This should probably be consistent.

Also, instead of 'u', it'd be better to use UINT64_C(...), like in the
unaligned_stores test above.

[bbudge, 2016/11/30 11:34:14]

Or we can use the 'one' and 'minus_one' constants we define above. Done.

+  CHECK_EQ(0x3FF0000000000000u, t.result1);
   if (CpuFeatures::IsSupported(VFP32DREGS)) {
-    CHECK_EQ(-1.0, t.result2);
-    CHECK_EQ(1.0, t.result3);
+    CHECK_EQ(0xBFF0000000000000u, t.result2);
+    CHECK_EQ(0x3FF0000000000000u, t.result3);
   }
-  CHECK_EQ(3.0, t.result4);
-  CHECK_EQ(4.0, t.result5);
-  CHECK_EQ(1.0, t.result6);
-  CHECK_EQ(2.0, t.result7);
+  CHECK_EQ(0xBFF0000000000000u, t.result4);
+  CHECK_EQ(0xBFF0000000000000u, t.result5);
+  CHECK_EQ(0x3FF0000000000000u, t.result6);
+  CHECK_EQ(0x3FF0000000000000u, t.result7);
 }
 
 TEST(regress4292_b) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   Assembler assm(isolate, NULL, 0);
   Label end;
   __ mov(r0, Operand(isolate->factory()->infinity_value()));
@@ skipping 40 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 __