ExtendStorageStub added, it is aimed for extending objects backing store when it runs out of space.

src/code-stubs-hydrogen.cc

 // Copyright 2012 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"
 
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
 #include "src/lithium.h"
@@ skipping 45 matching lines @@
     return arguments_length_;
   }
   CompilationInfo* info() { return &info_; }
   HydrogenCodeStub* stub() { return info_.code_stub(); }
   HContext* context() { return context_; }
   Isolate* isolate() { return info_.isolate(); }
 
   HLoadNamedField* BuildLoadNamedField(HValue* object,
                                        FieldIndex index);
   void BuildStoreNamedField(HValue* object, HValue* value, FieldIndex index,
-                            Representation representation);
+                            Representation representation,
+                            bool transition_to_field);
 
   enum ArgumentClass {
     NONE,
     SINGLE,
     MULTIPLE
   };
 
   HValue* BuildArrayConstructor(ElementsKind kind,
                                 AllocationSiteOverrideMode override_mode,
                                 ArgumentClass argument_class);
@@ skipping 518 matching lines @@
   return Add<HLoadNamedField>(descriptors, static_cast<HValue*>(NULL),
                               value_access);
 }
 
 
 Handle<Code> LoadConstantStub::GenerateCode() { return DoGenerateCode(this); }
 
 
 void CodeStubGraphBuilderBase::BuildStoreNamedField(
     HValue* object, HValue* value, FieldIndex index,
-    Representation representation) {
+    Representation representation, bool transition_to_field) {
   DCHECK(!index.is_double() || representation.IsDouble());
   int offset = index.offset();
   HObjectAccess access =
       index.is_inobject()
           ? HObjectAccess::ForObservableJSObjectOffset(offset, representation)
           : HObjectAccess::ForBackingStoreOffset(offset, representation);
 
   if (representation.IsDouble()) {
-    // Load the heap number.
-    object = Add<HLoadNamedField>(
-        object, static_cast<HValue*>(NULL),
-        access.WithRepresentation(Representation::Tagged()));
-    // Store the double value into it.
-    access = HObjectAccess::ForHeapNumberValue();
+    HObjectAccess heap_number_access =
+        access.WithRepresentation(Representation::Tagged());
+    if (transition_to_field) {
+      // The store requires a mutable HeapNumber to be allocated.
+      NoObservableSideEffectsScope no_side_effects(this);
+      HInstruction* heap_number_size = Add<HConstant>(HeapNumber::kSize);
+
+      // TODO(hpayer): Allocation site pretenuring support.
+      HInstruction* heap_number =
+          Add<HAllocate>(heap_number_size, HType::HeapObject(), NOT_TENURED,
+                         MUTABLE_HEAP_NUMBER_TYPE);
+      AddStoreMapConstant(heap_number,
+                          isolate()->factory()->mutable_heap_number_map());
+      Add<HStoreNamedField>(heap_number, HObjectAccess::ForHeapNumberValue(),
+                            value);
+      // Store the new mutable heap number into the object.
+      access = heap_number_access;
+      value = heap_number;
+    } else {
+      // Load the heap number.
+      object = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
+                                    heap_number_access);
+      // Store the double value into it.
+      access = HObjectAccess::ForHeapNumberValue();
+    }
   } else if (representation.IsHeapObject()) {
     BuildCheckHeapObject(value);
   }
 
   Add<HStoreNamedField>(object, access, value, INITIALIZING_STORE);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<StoreFieldStub>::BuildCodeStub() {
   BuildStoreNamedField(GetParameter(0), GetParameter(2), casted_stub()->index(),
-                       casted_stub()->representation());
+                       casted_stub()->representation(), false);
   return GetParameter(2);
 }
 
 
 Handle<Code> StoreFieldStub::GenerateCode() { return DoGenerateCode(this); }
 
 
 template <>
+HValue* CodeStubGraphBuilder<ExtendStorageStub>::BuildCodeStub() {
+  HValue* object = GetParameter(ExtendStorageDescriptor::kReceiverIndex);
+  HValue* properties =
+      Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
+                           HObjectAccess::ForPropertiesPointer());
+  HValue* length = AddLoadFixedArrayLength(properties);
+  HValue* delta = Add<HConstant>(static_cast<int32_t>(JSObject::kFieldsAdded));
+  HValue* new_capacity = AddUncasted<HAdd>(length, delta);
+
+  // Grow properties array.
+  ElementsKind kind = FAST_ELEMENTS;
+  Add<HBoundsCheck>(new_capacity,
+                    Add<HConstant>((Page::kMaxRegularHeapObjectSize -
+                                    FixedArray::kHeaderSize) >>
+                                   ElementsKindToShiftSize(kind)));
+
+  // Reuse this code for properties backing store allocation.
+  HValue* new_properties = BuildAllocateAndInitializeArray(kind, new_capacity);
+
+  BuildCopyProperties(properties, new_properties, length, new_capacity);
+
+  // Store the new value into the "extended" object.
+  Add<HStoreNamedField>(object, HObjectAccess::ForPropertiesPointer(),
+                        new_properties);
+
+  BuildStoreNamedField(
+      object, GetParameter(ExtendStorageDescriptor::kValueIndex),
+      casted_stub()->index(), casted_stub()->representation(), true);
+
+  // And finally update the map after the new field is added.
+  Add<HStoreNamedField>(object, HObjectAccess::ForMap(),
+                        GetParameter(ExtendStorageDescriptor::kMapIndex));
+
+  return GetParameter(ExtendStorageDescriptor::kValueIndex);
+}
+
+
+Handle<Code> ExtendStorageStub::GenerateCode() { return DoGenerateCode(this); }
+
+
+template <>
 HValue* CodeStubGraphBuilder<StringLengthStub>::BuildCodeStub() {
   HValue* string = BuildLoadNamedField(GetParameter(0),
       FieldIndex::ForInObjectOffset(JSValue::kValueOffset));
   return BuildLoadNamedField(string,
       FieldIndex::ForInObjectOffset(String::kLengthOffset));
 }
 
 
 Handle<Code> StringLengthStub::GenerateCode() {
   return DoGenerateCode(this);
@@ skipping 1173 matching lines @@
 
   // Probe the stub cache.
   Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
       Code::ComputeHandlerFlags(Code::LOAD_IC));
   Add<HTailCallThroughMegamorphicCache>(receiver, name, flags);
 
   // We never continue.
   return graph()->GetConstant0();
 }
 } }  // namespace v8::internal