Replace HeapNumber as doublebox with an explicit MutableHeapNumber.

src/ic.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 656 matching lines @@
 
 Handle<HeapType> IC::CurrentTypeOf(Handle<Object> object, Isolate* isolate) {
   return object->IsJSGlobalObject()
       ? HeapType::Constant(Handle<JSGlobalObject>::cast(object), isolate)
       : HeapType::OfCurrently(object, isolate);
 }
 
 
 Handle<Map> IC::TypeToMap(HeapType* type, Isolate* isolate) {
   if (type->Is(HeapType::Number()))
     return isolate->factory()->heap_number_map();

[Igor Sheludko, 2014/03/27 11:30:16]

I'm afraid we could loose the knowledge about mutability of the values.

   if (type->Is(HeapType::Boolean())) return isolate->factory()->oddball_map();
   if (type->IsConstant()) {
     return handle(Handle<JSGlobalObject>::cast(type->AsConstant())->map());
   }
   ASSERT(type->IsClass());
   return type->AsClass();
 }
 
 
 template <class T>
 typename T::TypeHandle IC::MapToType(Handle<Map> map,
                                      typename T::Region* region) {
   if (map->instance_type() == HEAP_NUMBER_TYPE) {

[Igor Sheludko, 2014/03/27 11:30:16]

What about supporting MUTABLE_HEAP_NUMBER_TYPE case here?

     return T::Number(region);
   } else if (map->instance_type() == ODDBALL_TYPE) {
     // The only oddballs that can be recorded in ICs are booleans.
     return T::Boolean(region);
   } else {
     return T::Class(map, region);
   }
 }
 
 
@@ skipping 1155 matching lines @@
   // Expand the properties array.
   FixedArray* old_storage = object->properties();
   int new_unused = transition->unused_property_fields();
   int new_size = old_storage->length() + new_unused + 1;
   Object* result;
   MaybeObject* maybe_result = old_storage->CopySize(new_size);
   if (!maybe_result->ToObject(&result)) return maybe_result;
 
   FixedArray* new_storage = FixedArray::cast(result);
 
-  Object* to_store = value;
-
   DescriptorArray* descriptors = transition->instance_descriptors();
   PropertyDetails details = descriptors->GetDetails(transition->LastAdded());
-  if (details.representation().IsDouble()) {
-    MaybeObject* maybe_storage =
-        isolate->heap()->AllocateHeapNumber(value->Number());
-    if (!maybe_storage->To(&to_store)) return maybe_storage;
-  }
+  Object* to_store;
+  MaybeObject* maybe_storage = value->AllocateNewStorageFor(
+      isolate->heap(), details.representation());
+  if (!maybe_storage->To(&to_store)) return maybe_storage;
 
   new_storage->set(old_storage->length(), to_store);
 
   // Set the new property value and do the map transition.
   object->set_properties(new_storage);
   object->set_map(transition);
 
   // Return the stored value.
   return value;
 }
@@ skipping 952 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal