Expose SIMD.Float32x4 type to Javascript.

test/cctest/test-heap.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 221 matching lines @@
 }
 
 
 TEST(SimdObjects) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   HandleScope sc(isolate);
 
-  Handle<Object> value = factory->NewFloat32x4(1, 2, 3, 4);
+  Handle<Object> handle = factory->NewFloat32x4(1, 2, 3, 4);

[rossberg, 2015/07/02 13:35:43]

Type this as Handle<Float32x4> and get rid of the separate declaration for
'value' and the cast it involves.

[bbudge, 2015/07/06 23:59:05]

Done.

+  CHECK(handle->IsFloat32x4());
+  CHECK(handle->BooleanValue());  // SIMD values map to true.
+

[rossberg, 2015/07/02 13:35:43]

Also check that the lanes have the values passed to the constructor.

[bbudge, 2015/07/06 23:59:05]

Done.

+  Float32x4* value = *Handle<Float32x4>::cast(handle);
   CHECK(value->IsFloat32x4());
-  CHECK(value->BooleanValue());  // SIMD values map to true.
+  CheckSimdLanes<Float32x4, float, 4>(value);
 
-  Float32x4* float32x4 = *Handle<Float32x4>::cast(value);
-  CheckSimdLanes<Float32x4, float, 4>(float32x4);
-
-  // Check ToString for SIMD values.
-  // TODO(bbudge): Switch to Check* style function to test ToString().
-  value = factory->NewFloat32x4(1, 2, 3, 4);
-  float32x4 = *Handle<Float32x4>::cast(value);
-  std::ostringstream os;
-  float32x4->Float32x4Print(os);
-  CHECK_EQ("1, 2, 3, 4", os.str());
-
-  // Check unusual lane values.
-  float32x4->set_lane(0, 0);
-  CHECK_EQ(0, float32x4->get_lane(0));
-  float32x4->set_lane(1, -0.0);
-  CHECK_EQ(-0.0, float32x4->get_lane(1));
+  // Check all lanes, and special lane values.
+  value->set_lane(0, 0);
+  CHECK_EQ(0, value->get_lane(0));
+  value->set_lane(1, -0.0);
+  CHECK_EQ(-0.0, value->get_lane(1));

[rossberg, 2015/07/02 13:35:43]

Does CHECK_EQ actually distinguish -0.0 from +0.0?

[bbudge, 2015/07/06 23:59:05]

Good point - probably not. I added a test for the sign bit.

   float quiet_NaN = std::numeric_limits<float>::quiet_NaN();
   float signaling_NaN = std::numeric_limits<float>::signaling_NaN();
-  float32x4->set_lane(2, quiet_NaN);
-  CHECK(std::isnan(float32x4->get_lane(2)));
-  float32x4->set_lane(3, signaling_NaN);
-  CHECK(std::isnan(float32x4->get_lane(3)));
+  value->set_lane(2, quiet_NaN);
+  CHECK(std::isnan(value->get_lane(2)));
+  value->set_lane(3, signaling_NaN);
+  CHECK(std::isnan(value->get_lane(3)));
+
+  // Check SIMD value to string conversions.
+  {
+    handle = factory->NewFloat32x4(1, 2, 3, 4);
+    value = *Handle<Float32x4>::cast(handle);
+    std::ostringstream os;
+    value->Float32x4Print(os);
+    CHECK_EQ("1, 2, 3, 4", os.str());
+  }
+  {
+    handle = factory->NewFloat32x4(0, -0.0, quiet_NaN, signaling_NaN);
+    value = *Handle<Float32x4>::cast(handle);
+    std::ostringstream os;
+    value->Float32x4Print(os);
+    CHECK_EQ("0, -0, nan, nan", os.str());
+  }
 }
 
 
 TEST(Tagging) {
   CcTest::InitializeVM();
   int request = 24;
   CHECK_EQ(request, static_cast<int>(OBJECT_POINTER_ALIGN(request)));
   CHECK(Smi::FromInt(42)->IsSmi());
   CHECK(Smi::FromInt(Smi::kMinValue)->IsSmi());
   CHECK(Smi::FromInt(Smi::kMaxValue)->IsSmi());
@@ skipping 5772 matching lines @@
          HeapObject::RawField(*array, FixedArray::kHeaderSize));
   SlotsBuffer::RemoveObjectSlots(CcTest::i_isolate()->heap(), buffer, *array);
   DCHECK(reinterpret_cast<void*>(buffer->Get(1)) ==
          HeapObject::RawField(heap->empty_fixed_array(),
                               FixedArrayBase::kLengthOffset));
   DCHECK(reinterpret_cast<void*>(buffer->Get(2)) ==
          HeapObject::RawField(heap->empty_fixed_array(),
                               FixedArrayBase::kLengthOffset));
   delete buffer;
 }