Revert "Replace HeapNumber as doublebox with an explicit MutableHeapNumber."

src/arm64/macro-assembler-arm64.cc

 // Copyright 2013 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 "src/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
@@ skipping 3542 matching lines @@
 }
 
 
 // Allocates a heap number or jumps to the need_gc label if the young space
 // is full and a scavenge is needed.
 void MacroAssembler::AllocateHeapNumber(Register result,
                                         Label* gc_required,
                                         Register scratch1,
                                         Register scratch2,
                                         CPURegister value,
-                                        CPURegister heap_number_map,
-                                        MutableMode mode) {
+                                        CPURegister heap_number_map) {
   ASSERT(!value.IsValid() || value.Is64Bits());
   UseScratchRegisterScope temps(this);
 
   // Allocate an object in the heap for the heap number and tag it as a heap
   // object.
   Allocate(HeapNumber::kSize, result, scratch1, scratch2, gc_required,
            NO_ALLOCATION_FLAGS);
 
-  Heap::RootListIndex map_index = mode == MUTABLE
-      ? Heap::kMutableHeapNumberMapRootIndex
-      : Heap::kHeapNumberMapRootIndex;
-
   // Prepare the heap number map.
   if (!heap_number_map.IsValid()) {
     // If we have a valid value register, use the same type of register to store
     // the map so we can use STP to store both in one instruction.
     if (value.IsValid() && value.IsFPRegister()) {
       heap_number_map = temps.AcquireD();
     } else {
       heap_number_map = scratch1;
     }
-    LoadRoot(heap_number_map, map_index);
+    LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
   }
   if (emit_debug_code()) {
     Register map;
     if (heap_number_map.IsFPRegister()) {
       map = scratch1;
       Fmov(map, DoubleRegister(heap_number_map));
     } else {
       map = Register(heap_number_map);
     }
-    AssertRegisterIsRoot(map, map_index);
+    AssertRegisterIsRoot(map, Heap::kHeapNumberMapRootIndex);
   }
 
   // Store the heap number map and the value in the allocated object.
   if (value.IsSameSizeAndType(heap_number_map)) {
     STATIC_ASSERT(HeapObject::kMapOffset + kPointerSize ==
                   HeapNumber::kValueOffset);
     Stp(heap_number_map, value, MemOperand(result, HeapObject::kMapOffset));
   } else {
     Str(heap_number_map, MemOperand(result, HeapObject::kMapOffset));
     if (value.IsValid()) {
@@ skipping 1692 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64