Replace HeapNumber as doublebox with an explicit MutableHeapNumber.

src/heap.cc

Index: src/heap.cc
diff --git a/src/heap.cc b/src/heap.cc
index 6374433bbd9e407fe6ebd11a8318b4c8ed5d905d..9c374f1c5841c618677135c4859a70aa6d32bee7 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -2856,6 +2856,8 @@ bool Heap::CreateInitialMaps() {
 
     ALLOCATE_VARSIZE_MAP(FIXED_ARRAY_TYPE, scope_info)
     ALLOCATE_MAP(HEAP_NUMBER_TYPE, HeapNumber::kSize, heap_number)
+    ALLOCATE_MAP(
+        MUTABLE_HEAP_NUMBER_TYPE, HeapNumber::kSize, mutable_heap_number)
     ALLOCATE_MAP(SYMBOL_TYPE, Symbol::kSize, symbol)
     ALLOCATE_MAP(FOREIGN_TYPE, Foreign::kSize, foreign)
 
@@ -2966,7 +2968,9 @@ bool Heap::CreateInitialMaps() {
 }
 
 
-MaybeObject* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
+MaybeObject* Heap::AllocateHeapNumber(double value,
+                                      MutableMode mode,
+                                      PretenureFlag pretenure) {
   // Statically ensure that it is safe to allocate heap numbers in paged
   // spaces.
   int size = HeapNumber::kSize;
@@ -2979,7 +2983,8 @@ MaybeObject* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
-  HeapObject::cast(result)->set_map_no_write_barrier(heap_number_map());
+  Map* map = mode == MUTABLE ? mutable_heap_number_map() : heap_number_map();
+  HeapObject::cast(result)->set_map_no_write_barrier(map);
   HeapNumber::cast(result)->set_value(value);
   return result;
 }
@@ -3128,18 +3133,20 @@ bool Heap::CreateInitialObjects() {
   Object* obj;
 
   // The -0 value must be set before NumberFromDouble works.
-  { MaybeObject* maybe_obj = AllocateHeapNumber(-0.0, TENURED);
+  { MaybeObject* maybe_obj = AllocateHeapNumber(-0.0, IMMUTABLE, TENURED);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_minus_zero_value(HeapNumber::cast(obj));
   ASSERT(std::signbit(minus_zero_value()->Number()) != 0);
 
-  { MaybeObject* maybe_obj = AllocateHeapNumber(OS::nan_value(), TENURED);
+  { MaybeObject* maybe_obj = AllocateHeapNumber(
+        OS::nan_value(), IMMUTABLE, TENURED);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_nan_value(HeapNumber::cast(obj));
 
-  { MaybeObject* maybe_obj = AllocateHeapNumber(V8_INFINITY, TENURED);
+  { MaybeObject* maybe_obj = AllocateHeapNumber(
+        V8_INFINITY, IMMUTABLE, TENURED);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_infinity_value(HeapNumber::cast(obj));
@@ -3821,7 +3828,7 @@ MaybeObject* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {
   // done after conversion to int. Doing this by comparing bit
   // patterns is faster than using fpclassify() et al.
   if (IsMinusZero(value)) {
-    return AllocateHeapNumber(-0.0, pretenure);
+    return AllocateHeapNumber(-0.0, IMMUTABLE, pretenure);
   }
 
   int int_value = FastD2I(value);
@@ -3830,7 +3837,7 @@ MaybeObject* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {
   }
 
   // Materialize the value in the heap.
-  return AllocateHeapNumber(value, pretenure);
+  return AllocateHeapNumber(value, IMMUTABLE, pretenure);
 }