Replace HeapNumber as doublebox with an explicit MutableHeapNumber.

src/objects-inl.h

 // 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 159 matching lines @@
 }
 
 
 bool Object::NonFailureIsHeapObject() {
   ASSERT(!this->IsFailure());
   return (reinterpret_cast<intptr_t>(this) & kSmiTagMask) != 0;
 }
 
 
 TYPE_CHECKER(HeapNumber, HEAP_NUMBER_TYPE)
+TYPE_CHECKER(MutableHeapNumber, MUTABLE_HEAP_NUMBER_TYPE)
 TYPE_CHECKER(Symbol, SYMBOL_TYPE)
 
 
 bool Object::IsString() {
   return Object::IsHeapObject()
     && HeapObject::cast(this)->map()->instance_type() < FIRST_NONSTRING_TYPE;
 }
 
 
 bool Object::IsName() {
@@ skipping 85 matching lines @@
          IsFixedTypedArrayBase();
 }
 
 
 MaybeObject* Object::AllocateNewStorageFor(Heap* heap,
                                            Representation representation) {
   if (representation.IsSmi() && IsUninitialized()) {
     return Smi::FromInt(0);
   }
   if (!representation.IsDouble()) return this;
+  double value;
   if (IsUninitialized()) {
-    return heap->AllocateHeapNumber(0);
+    value = 0;
+  } else if (IsMutableHeapNumber()) {

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

If you extend IsNumber() to return true for mutable heap numbers then you will
not need this special case as Number() will handle this case automagically.

+    value = HeapNumber::cast(this)->value();
+  } else {
+    value = Number();
   }
-  return heap->AllocateHeapNumber(Number());
+  return heap->AllocateMutableHeapNumber(value);
 }
 
 
+MaybeObject* Object::WrapForRead(Heap* heap,
+                                 Representation representation) {
+  ASSERT(!IsUninitialized());
+  if (!representation.IsDouble()) {
+    ASSERT(FitsRepresentation(representation));
+    return this;
+  }
+  return heap->AllocateHeapNumber(HeapNumber::cast(this)->value());

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

Same here: use Number().

+}
+
+
 StringShape::StringShape(String* str)
   : type_(str->map()->instance_type()) {
   set_valid();
   ASSERT((type_ & kIsNotStringMask) == kStringTag);
 }
 
 
 StringShape::StringShape(Map* map)
   : type_(map->instance_type()) {
   set_valid();
@@ skipping 286 matching lines @@
   }
 
   Vector<const char> string_;
   uint32_t hash_field_;
   int chars_;  // Caches the number of characters when computing the hash code.
   uint32_t seed_;
 };
 
 
 bool Object::IsNumber() {
   return IsSmi() || IsHeapNumber();

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

|| IsMutableHeapNumber() ?

 }
 
 
 TYPE_CHECKER(ByteArray, BYTE_ARRAY_TYPE)
 TYPE_CHECKER(FreeSpace, FREE_SPACE_TYPE)
 
 
 bool Object::IsFiller() {
   if (!Object::IsHeapObject()) return false;
   InstanceType instance_type = HeapObject::cast(this)->map()->instance_type();
@@ skipping 1328 matching lines @@
   // properties are at the end of the object. Therefore there is no need
   // to adjust the index here.
   int offset = GetHeaderSize() + (kPointerSize * index);
   WRITE_FIELD(this, offset, value);
 }
 
 
 MaybeObject* JSObject::FastPropertyAt(Representation representation,
                                       int index) {
   Object* raw_value = RawFastPropertyAt(index);
-  return raw_value->AllocateNewStorageFor(GetHeap(), representation);
+  return raw_value->WrapForRead(GetHeap(), representation);

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

Shouldn't we also repack mutable heap number to immutable in LoadIC?

 }
 
 
 // Access fast-case object properties at index. The use of these routines
 // is needed to correctly distinguish between properties stored in-object and
 // properties stored in the properties array.
 Object* JSObject::RawFastPropertyAt(int index) {
   // Adjust for the number of properties stored in the object.
   index -= map()->inobject_properties();
   if (index < 0) {
@@ skipping 887 matching lines @@
 CAST_ACCESSOR(ConsString)
 CAST_ACCESSOR(ExternalString)
 CAST_ACCESSOR(ExternalAsciiString)
 CAST_ACCESSOR(ExternalTwoByteString)
 CAST_ACCESSOR(Symbol)
 CAST_ACCESSOR(Name)
 CAST_ACCESSOR(JSReceiver)
 CAST_ACCESSOR(JSObject)
 CAST_ACCESSOR(Smi)
 CAST_ACCESSOR(HeapObject)
-CAST_ACCESSOR(HeapNumber)
 CAST_ACCESSOR(Oddball)
 CAST_ACCESSOR(Cell)
 CAST_ACCESSOR(PropertyCell)
 CAST_ACCESSOR(SharedFunctionInfo)
 CAST_ACCESSOR(Map)
 CAST_ACCESSOR(JSFunction)
 CAST_ACCESSOR(GlobalObject)
 CAST_ACCESSOR(JSGlobalProxy)
 CAST_ACCESSOR(JSGlobalObject)
 CAST_ACCESSOR(JSBuiltinsObject)
@@ skipping 2800 matching lines @@
 ACCESSORS(JSValue, value, Object, kValueOffset)
 
 
 JSValue* JSValue::cast(Object* obj) {
   ASSERT(obj->IsJSValue());
   ASSERT(HeapObject::cast(obj)->Size() == JSValue::kSize);
   return reinterpret_cast<JSValue*>(obj);
 }
 
 
+HeapNumber* HeapNumber::cast(Object* object) {
+  SLOW_ASSERT(object->IsHeapNumber() || object->IsMutableHeapNumber());
+  return reinterpret_cast<HeapNumber*>(object);
+}
+
+
 ACCESSORS(JSDate, value, Object, kValueOffset)
 ACCESSORS(JSDate, cache_stamp, Object, kCacheStampOffset)
 ACCESSORS(JSDate, year, Object, kYearOffset)
 ACCESSORS(JSDate, month, Object, kMonthOffset)
 ACCESSORS(JSDate, day, Object, kDayOffset)
 ACCESSORS(JSDate, weekday, Object, kWeekdayOffset)
 ACCESSORS(JSDate, hour, Object, kHourOffset)
 ACCESSORS(JSDate, min, Object, kMinOffset)
 ACCESSORS(JSDate, sec, Object, kSecOffset)
 
@@ skipping 1103 matching lines @@
 #undef READ_UINT32_FIELD
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_