Access double fields in C++ as uint64_t fields to preserve signaling bit of a NaN.

test/cctest/test-unboxed-doubles.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/compilation-cache.h"
@@ skipping 908 matching lines @@
   Handle<LayoutDescriptor> layout_descriptor =
       LayoutDescriptor::New(map, descriptors, kPropsCount);
   map->InitializeDescriptors(*descriptors, *layout_descriptor);
 
   Handle<JSObject> object = factory->NewJSObjectFromMap(map, TENURED);
 
   Address fake_address = reinterpret_cast<Address>(~kHeapObjectTagMask);
   HeapObject* fake_object = HeapObject::FromAddress(fake_address);
   CHECK(fake_object->IsHeapObject());
 
-  double boom_value = bit_cast<double>(fake_object);
+  uint64_t boom_value = bit_cast<uint64_t>(fake_object);
   for (int i = 0; i < kPropsCount; i++) {
     FieldIndex index = FieldIndex::ForDescriptor(*map, i);
     CHECK(map->IsUnboxedDoubleField(index));
-    object->RawFastDoublePropertyAtPut(index, boom_value);
+    object->RawFastDoublePropertyAsBitsAtPut(index, boom_value);
   }
   CHECK(object->HasFastProperties());
   CHECK(!object->map()->HasFastPointerLayout());
 
   Handle<Map> normalized_map =
       Map::Normalize(map, KEEP_INOBJECT_PROPERTIES, "testing");
   JSObject::MigrateToMap(object, normalized_map);
   CHECK(!object->HasFastProperties());
   CHECK(object->map()->HasFastPointerLayout());
 
@@ skipping 461 matching lines @@
     for (int i = 0; i < n; i++) {
       obj->FastPropertyAtPut(index, *obj_value);
     }
   }
 
   // Migrate |obj| to |new_map| which should shift fields and put the
   // |boom_value| to the slot that was earlier recorded by write barrier.
   JSObject::MigrateToMap(obj, new_map);
 
   Address fake_object = reinterpret_cast<Address>(*obj_value) + kPointerSize;
-  double boom_value = bit_cast<double>(fake_object);
+  uint64_t boom_value = bit_cast<uint64_t>(fake_object);
 
   FieldIndex double_field_index =
       FieldIndex::ForDescriptor(*new_map, double_descriptor);
   CHECK(obj->IsUnboxedDoubleField(double_field_index));
-  obj->RawFastDoublePropertyAtPut(double_field_index, boom_value);
+  obj->RawFastDoublePropertyAsBitsAtPut(double_field_index, boom_value);
 
   // Trigger GC to evacuate all candidates.
   CcTest::CollectGarbage(NEW_SPACE);
 
   if (check_tagged_value) {
     FieldIndex tagged_field_index =
         FieldIndex::ForDescriptor(*new_map, tagged_descriptor);
     CHECK_EQ(*obj_value, obj->RawFastPropertyAt(tagged_field_index));
   }
-  CHECK_EQ(boom_value, obj->RawFastDoublePropertyAt(double_field_index));
+  CHECK_EQ(boom_value, obj->RawFastDoublePropertyAsBitsAt(double_field_index));
 }
 
 
 static void TestIncrementalWriteBarrier(Handle<Map> map, Handle<Map> new_map,
                                         int tagged_descriptor,
                                         int double_descriptor,
                                         bool check_tagged_value = true) {
   if (FLAG_never_compact || !FLAG_incremental_marking) return;
   FLAG_manual_evacuation_candidates_selection = true;
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 43 matching lines @@
   {
     FieldIndex index = FieldIndex::ForDescriptor(*map, tagged_descriptor);
     obj->FastPropertyAtPut(index, *obj_value);
   }
 
   // Migrate |obj| to |new_map| which should shift fields and put the
   // |boom_value| to the slot that was earlier recorded by incremental write
   // barrier.
   JSObject::MigrateToMap(obj, new_map);
 
-  double boom_value = bit_cast<double>(UINT64_C(0xbaad0176a37c28e1));
+  uint64_t boom_value = UINT64_C(0xbaad0176a37c28e1);
 
   FieldIndex double_field_index =
       FieldIndex::ForDescriptor(*new_map, double_descriptor);
   CHECK(obj->IsUnboxedDoubleField(double_field_index));
-  obj->RawFastDoublePropertyAtPut(double_field_index, boom_value);
+  obj->RawFastDoublePropertyAsBitsAtPut(double_field_index, boom_value);
 
   // Trigger GC to evacuate all candidates.
   CcTest::CollectGarbage(OLD_SPACE);
 
   // Ensure that the values are still there and correct.
   CHECK(!MarkCompactCollector::IsOnEvacuationCandidate(*obj_value));
 
   if (check_tagged_value) {
     FieldIndex tagged_field_index =
         FieldIndex::ForDescriptor(*new_map, tagged_descriptor);
     CHECK_EQ(*obj_value, obj->RawFastPropertyAt(tagged_field_index));
   }
-  CHECK_EQ(boom_value, obj->RawFastDoublePropertyAt(double_field_index));
+  CHECK_EQ(boom_value, obj->RawFastDoublePropertyAsBitsAt(double_field_index));
 }
 
 enum OldToWriteBarrierKind {
   OLD_TO_OLD_WRITE_BARRIER,
   OLD_TO_NEW_WRITE_BARRIER
 };
 static void TestWriteBarrierObjectShiftFieldsRight(
     OldToWriteBarrierKind write_barrier_kind) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 39 matching lines @@
 
 // TODO(ishell): add respective tests for property kind reconfiguring from
 // accessor field to double, once accessor fields are supported by
 // Map::ReconfigureProperty().
 
 
 // TODO(ishell): add respective tests for fast property removal case once
 // Map::ReconfigureProperty() supports that.
 
 #endif