Added pretenuring support for fast literal allocation in old data space.

src/hydrogen.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 9928 matching lines @@
 
 
 HInstruction* HOptimizedGraphBuilder::BuildFastLiteral(
     HValue* context,
     Handle<JSObject> boilerplate_object,
     Handle<JSObject> original_boilerplate_object,
     int data_size,
     int pointer_size,
     AllocationSiteMode mode) {
   Zone* zone = this->zone();
-  int total_size = data_size + pointer_size;
-
   NoObservableSideEffectsScope no_effects(this);
 
-  HAllocate::Flags flags = HAllocate::CAN_ALLOCATE_IN_NEW_SPACE;
-  // TODO(hpayer): add support for old data space
-  if (isolate()->heap()->ShouldGloballyPretenure() &&
-      data_size == 0) {
-    flags = static_cast<HAllocate::Flags>(
-        flags | HAllocate::CAN_ALLOCATE_IN_OLD_POINTER_SPACE);
+  HInstruction* target = NULL;
+  HInstruction* data_target = NULL;
+
+  HAllocate::Flags flags = HAllocate::DefaultFlags();
+
+  if (isolate()->heap()->ShouldGloballyPretenure()) {
+    if (data_size != 0) {
+      HAllocate::Flags data_flags =
+          static_cast<HAllocate::Flags>(HAllocate::DefaultFlags() |
+              HAllocate::CAN_ALLOCATE_IN_OLD_DATA_SPACE);
+      HValue* size_in_bytes = AddInstruction(new(zone) HConstant(data_size));
+      data_target = AddInstruction(new(zone) HAllocate(
+          context, size_in_bytes, HType::JSObject(), data_flags));
+      Handle<Map> free_space_map = isolate()->factory()->free_space_map();
+      AddStoreMapConstant(data_target, free_space_map);
+      HObjectAccess access =
+          HObjectAccess::ForJSObjectOffset(FreeSpace::kSizeOffset);
+      AddStore(data_target, access, size_in_bytes);
+    }
+    if (pointer_size != 0) {
+      flags = static_cast<HAllocate::Flags>(
+          flags | HAllocate::CAN_ALLOCATE_IN_OLD_POINTER_SPACE);
+      HValue* size_in_bytes = AddInstruction(new(zone) HConstant(pointer_size));
+      target = AddInstruction(new(zone) HAllocate(context,
+          size_in_bytes, HType::JSObject(), flags));
+    }
+  } else {
+    HValue* size_in_bytes =
+        AddInstruction(new(zone) HConstant(data_size + pointer_size));
+    target = AddInstruction(new(zone) HAllocate(context, size_in_bytes,
+        HType::JSObject(), flags));
   }
 
-  HValue* size_in_bytes = AddInstruction(new(zone) HConstant(total_size));
-  HInstruction* result =
-      AddInstruction(new(zone) HAllocate(context,
-                                         size_in_bytes,
-                                         HType::JSObject(),
-                                         flags));
   int offset = 0;
-  BuildEmitDeepCopy(boilerplate_object, original_boilerplate_object, result,
-                    &offset, mode);
-  return result;
+  int data_offset = 0;
+  BuildEmitDeepCopy(boilerplate_object, original_boilerplate_object, target,
+                    &offset, data_target, &data_offset, mode);
+  return target;
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitDeepCopy(
     Handle<JSObject> boilerplate_object,
     Handle<JSObject> original_boilerplate_object,
     HInstruction* target,
     int* offset,
+    HInstruction* data_target,
+    int* data_offset,
     AllocationSiteMode mode) {
   Zone* zone = this->zone();
 
   Handle<FixedArrayBase> elements(boilerplate_object->elements());
   Handle<FixedArrayBase> original_elements(
       original_boilerplate_object->elements());
   ElementsKind kind = boilerplate_object->map()->elements_kind();
 
-  // Increase the offset so that subsequent objects end up right after
-  // this object and its backing store.
   int object_offset = *offset;
   int object_size = boilerplate_object->map()->instance_size();
   int elements_size = (elements->length() > 0 &&
       elements->map() != isolate()->heap()->fixed_cow_array_map()) ?
           elements->Size() : 0;
-  int elements_offset = *offset + object_size;
+  int elements_offset = 0;
 
-  *offset += object_size + elements_size;
+  if (data_target != NULL && boilerplate_object->HasFastDoubleElements()) {
+    elements_offset = *data_offset;
+    *data_offset += elements_size;
+  } else {
+    // Place elements right after this object.
+    elements_offset = *offset + object_size;
+    *offset += elements_size;
+  }
+  // Increase the offset so that subsequent objects end up right after this
+  // object (and it's elements if they are allocated in the same space).
+  *offset += object_size;
 
   // Copy object elements if non-COW.
   HValue* object_elements = BuildEmitObjectHeader(boilerplate_object, target,
-      object_offset, elements_offset, elements_size);
+      data_target, object_offset, elements_offset, elements_size);
   if (object_elements != NULL) {
     BuildEmitElements(elements, original_elements, kind, object_elements,
-        target, offset);
+        target, offset, data_target, data_offset);
   }
 
   // Copy in-object properties.
   HValue* object_properties =
       AddInstruction(new(zone) HInnerAllocatedObject(target, object_offset));
   BuildEmitInObjectProperties(boilerplate_object, original_boilerplate_object,
-      object_properties, target, offset);
+      object_properties, target, offset, data_target, data_offset);
 
   // Create allocation site info.
   if (mode == TRACK_ALLOCATION_SITE &&
       boilerplate_object->map()->CanTrackAllocationSite()) {
     elements_offset += AllocationSiteInfo::kSize;
     *offset += AllocationSiteInfo::kSize;
     HInstruction* original_boilerplate = AddInstruction(new(zone) HConstant(
         original_boilerplate_object));
     BuildCreateAllocationSiteInfo(target, JSArray::kSize, original_boilerplate);
   }
 }
 
 
 HValue* HOptimizedGraphBuilder::BuildEmitObjectHeader(
     Handle<JSObject> boilerplate_object,
     HInstruction* target,
+    HInstruction* data_target,
     int object_offset,
     int elements_offset,
     int elements_size) {
   ASSERT(boilerplate_object->properties()->length() == 0);
   Zone* zone = this->zone();
   HValue* result = NULL;
 
   HValue* object_header =
       AddInstruction(new(zone) HInnerAllocatedObject(target, object_offset));
   Handle<Map> boilerplate_object_map(boilerplate_object->map());
   AddStoreMapConstant(object_header, boilerplate_object_map);
 
   HInstruction* elements;
   if (elements_size == 0) {
     Handle<Object> elements_field =
         Handle<Object>(boilerplate_object->elements(), isolate());
     elements = AddInstruction(new(zone) HConstant(elements_field));
   } else {
-    elements = AddInstruction(new(zone) HInnerAllocatedObject(
-        target, elements_offset));
+    if (data_target != NULL && boilerplate_object->HasFastDoubleElements()) {
+      elements = AddInstruction(new(zone) HInnerAllocatedObject(
+          data_target, elements_offset));
+    } else {
+      elements = AddInstruction(new(zone) HInnerAllocatedObject(
+          target, elements_offset));
+    }
     result = elements;
   }
   AddStore(object_header, HObjectAccess::ForElementsPointer(), elements);
 
   Handle<Object> properties_field =
       Handle<Object>(boilerplate_object->properties(), isolate());
   ASSERT(*properties_field == isolate()->heap()->empty_fixed_array());
   HInstruction* properties = AddInstruction(new(zone) HConstant(
       properties_field));
   HObjectAccess access = HObjectAccess::ForPropertiesPointer();
@@ skipping 16 matching lines @@
 
   return result;
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitInObjectProperties(
     Handle<JSObject> boilerplate_object,
     Handle<JSObject> original_boilerplate_object,
     HValue* object_properties,
     HInstruction* target,
-    int* offset) {
+    int* offset,
+    HInstruction* data_target,
+    int* data_offset) {
   Zone* zone = this->zone();
   Handle<DescriptorArray> descriptors(
       boilerplate_object->map()->instance_descriptors());
   int limit = boilerplate_object->map()->NumberOfOwnDescriptors();
 
   int copied_fields = 0;
   for (int i = 0; i < limit; i++) {
     PropertyDetails details = descriptors->GetDetails(i);
     if (details.type() != FIELD) continue;
     copied_fields++;
@@ skipping 13 matching lines @@
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
       Handle<JSObject> original_value_object = Handle<JSObject>::cast(
           Handle<Object>(original_boilerplate_object->InObjectPropertyAt(index),
               isolate()));
       HInstruction* value_instruction =
           AddInstruction(new(zone) HInnerAllocatedObject(target, *offset));
 
       AddStore(object_properties, access, value_instruction);
 
       BuildEmitDeepCopy(value_object, original_value_object, target,
-          offset, DONT_TRACK_ALLOCATION_SITE);
+          offset, data_target, data_offset, DONT_TRACK_ALLOCATION_SITE);
     } else {
       Representation representation = details.representation();
       HInstruction* value_instruction =
           AddInstruction(new(zone) HConstant(value));
 
       if (representation.IsDouble()) {
         // Allocate a HeapNumber box and store the value into it.
-        HInstruction* double_box =
-            AddInstruction(new(zone) HInnerAllocatedObject(target, *offset));
+        HInstruction* double_box;
+        if (data_target != NULL) {
+          double_box = AddInstruction(new(zone) HInnerAllocatedObject(
+              data_target, *data_offset));
+          *data_offset += HeapNumber::kSize;
+        } else {
+          double_box = AddInstruction(new(zone) HInnerAllocatedObject(
+              target, *offset));
+          *offset += HeapNumber::kSize;
+        }
         AddStoreMapConstant(double_box,
             isolate()->factory()->heap_number_map());
         AddStore(double_box, HObjectAccess::ForHeapNumberValue(),
             value_instruction, Representation::Double());
         value_instruction = double_box;
-        *offset += HeapNumber::kSize;
       }
 
       AddStore(object_properties, access, value_instruction);
     }
   }
 
   int inobject_properties = boilerplate_object->map()->inobject_properties();
   HInstruction* value_instruction = AddInstruction(new(zone)
       HConstant(isolate()->factory()->one_pointer_filler_map()));
   for (int i = copied_fields; i < inobject_properties; i++) {
     ASSERT(boilerplate_object->IsJSObject());
     int property_offset = boilerplate_object->GetInObjectPropertyOffset(i);
     HObjectAccess access = HObjectAccess::ForJSObjectOffset(property_offset);
     AddStore(object_properties, access, value_instruction);
   }
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitElements(
     Handle<FixedArrayBase> elements,
     Handle<FixedArrayBase> original_elements,
     ElementsKind kind,
     HValue* object_elements,
     HInstruction* target,
-    int* offset) {
+    int* offset,
+    HInstruction* data_target,
+    int* data_offset) {
   Zone* zone = this->zone();
 
   int elements_length = elements->length();
   HValue* object_elements_length =
       AddInstruction(new(zone) HConstant(elements_length));
 
   BuildInitializeElementsHeader(object_elements, kind, object_elements_length);
 
   // Copy elements backing store content.
   if (elements->IsFixedDoubleArray()) {
     BuildEmitFixedDoubleArray(elements, kind, object_elements);
   } else if (elements->IsFixedArray()) {
     BuildEmitFixedArray(elements, original_elements, kind, object_elements,
-        target, offset);
+        target, offset, data_target, data_offset);
   } else {
     UNREACHABLE();
   }
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitFixedDoubleArray(
     Handle<FixedArrayBase> elements,
     ElementsKind kind,
     HValue* object_elements) {
@@ skipping 12 matching lines @@
   }
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitFixedArray(
     Handle<FixedArrayBase> elements,
     Handle<FixedArrayBase> original_elements,
     ElementsKind kind,
     HValue* object_elements,
     HInstruction* target,
-    int* offset) {
+    int* offset,
+    HInstruction* data_target,
+    int* data_offset) {
   Zone* zone = this->zone();
   HInstruction* boilerplate_elements =
       AddInstruction(new(zone) HConstant(elements));
   int elements_length = elements->length();
   Handle<FixedArray> fast_elements = Handle<FixedArray>::cast(elements);
   Handle<FixedArray> original_fast_elements =
       Handle<FixedArray>::cast(original_elements);
   for (int i = 0; i < elements_length; i++) {
     Handle<Object> value(fast_elements->get(i), isolate());
     HValue* key_constant = AddInstruction(new(zone) HConstant(i));
     if (value->IsJSObject()) {
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
       Handle<JSObject> original_value_object = Handle<JSObject>::cast(
           Handle<Object>(original_fast_elements->get(i), isolate()));
       HInstruction* value_instruction =
           AddInstruction(new(zone) HInnerAllocatedObject(target, *offset));
       AddInstruction(new(zone) HStoreKeyed(
           object_elements, key_constant, value_instruction, kind));
       BuildEmitDeepCopy(value_object, original_value_object, target,
-          offset, DONT_TRACK_ALLOCATION_SITE);
+          offset, data_target, data_offset, DONT_TRACK_ALLOCATION_SITE);
     } else {
       HInstruction* value_instruction =
           AddInstruction(new(zone) HLoadKeyed(
               boilerplate_elements, key_constant, NULL, kind,
               ALLOW_RETURN_HOLE));
       AddInstruction(new(zone) HStoreKeyed(
           object_elements, key_constant, value_instruction, kind));
     }
   }
 }
@@ skipping 1349 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal