Allocation Info Tracking, continued.

src/builtins.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 185 matching lines @@
   Handle<JSFunction> function = args.at<JSFunction>(1);
   Handle<Object> type_info = args.at<Object>(2);
 
   JSArray* array = NULL;
   bool holey = false;
   if (caller_args->length() == 1 && (*caller_args)[0]->IsSmi()) {
     int value = Smi::cast((*caller_args)[0])->value();
     holey = (value > 0 && value < JSObject::kInitialMaxFastElementArray);
   }
 
-  // Allocate the initial map if absent.
-  if (!function->has_initial_map()) {
-    Object* initial_map;
-    { MaybeObject* maybe_initial_map =
-          isolate->heap()->AllocateInitialMap(*function);
-      if (!maybe_initial_map->ToObject(&initial_map)) return maybe_initial_map;
-    }
-    function->set_initial_map(Map::cast(initial_map));
-    Map::cast(initial_map)->set_constructor(*function);
-  }
-
+  ASSERT(function->has_initial_map());
   ElementsKind kind = function->initial_map()->elements_kind();
   if (holey) {
     kind = GetHoleyElementsKind(kind);
   }
 
   MaybeObject* maybe_array;
   if (*type_info != isolate->heap()->undefined_value()) {
-    ASSERT(type_info->IsJSGlobalPropertyCell());
     JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(*type_info);
     if (cell->value()->IsSmi()) {
       Smi* smi = Smi::cast(cell->value());
       ElementsKind to_kind = static_cast<ElementsKind>(smi->value());
-      if (holey) {
+      if (holey && !IsFastHoleyElementsKind(to_kind)) {
         to_kind = GetHoleyElementsKind(to_kind);
+        // Update the allocation site info to reflect the advice alteration.
+        cell->set_value(Smi::FromInt(to_kind));
       }
 
-      if (IsMoreGeneralElementsKindTransition(kind, to_kind)) {
-        maybe_array = isolate->heap()->AllocateEmptyJSArray(to_kind);
+      AllocationSiteMode mode = AllocationSiteInfo::GetMode(to_kind);
+      if (mode == TRACK_ALLOCATION_SITE) {
+        maybe_array = isolate->heap()->AllocateEmptyJSArrayWithAllocationSite(
+            kind, type_info);
       } else {
-        AllocationSiteMode mode = AllocationSiteInfo::GetMode(kind);
-        maybe_array = isolate->heap()->AllocateEmptyJSArray(kind,
-                                                            mode,
-                                                            &type_info);
+        maybe_array = isolate->heap()->AllocateEmptyJSArray(kind);
       }
       if (!maybe_array->To(&array)) return maybe_array;
     }
   }
 
   if (array == NULL) {
     maybe_array = isolate->heap()->AllocateEmptyJSArray(kind);
     if (!maybe_array->To(&array)) return maybe_array;
   }
 
   maybe_array = ArrayConstructInitializeElements(array, caller_args);
   if (maybe_array->IsFailure()) return maybe_array;
   return array;
 }
 
 
 static MaybeObject* ArrayCodeGenericCommon(Arguments* args,
                                            Isolate* isolate,
                                            JSFunction* constructor) {
   ASSERT(args->length() >= 1);
   Heap* heap = isolate->heap();
   isolate->counters()->array_function_runtime()->Increment();
 
   JSArray* array;
   if (CalledAsConstructor(isolate)) {
     array = JSArray::cast((*args)[0]);
     // Initialize elements and length in case later allocations fail so that the
     // array object is initialized in a valid state.
-    array->set_length(Smi::FromInt(0));
-    array->set_elements(heap->empty_fixed_array());
-    AllocationSiteInfo* info = AllocationSiteInfo::FindForJSObject(array);
-    ElementsKind to_kind = array->GetElementsKind();
-    if (info != NULL && info->GetElementsKindPayload(&to_kind)) {
-      if (IsMoreGeneralElementsKindTransition(array->GetElementsKind(),
-                                              to_kind)) {
-        // We have advice that we should change the elements kind
-        if (FLAG_trace_track_allocation_sites) {
-          PrintF("AllocationSiteInfo: pre-transitioning array %p(%s->%s)\n",
-                 reinterpret_cast<void*>(array),
-                 ElementsKindToString(array->GetElementsKind()),
-                 ElementsKindToString(to_kind));
+    MaybeObject* maybe_array = array->Initialize(0);
+    if (maybe_array->IsFailure()) return maybe_array;
+
+    if (FLAG_optimize_constructed_arrays) {
+      AllocationSiteInfo* info = AllocationSiteInfo::FindForJSObject(array);
+      ElementsKind to_kind = array->GetElementsKind();
+      if (info != NULL && info->GetElementsKindPayload(&to_kind)) {
+        if (IsMoreGeneralElementsKindTransition(array->GetElementsKind(),
+                                                to_kind)) {
+          // We have advice that we should change the elements kind
+          if (FLAG_trace_track_allocation_sites) {
+            PrintF("AllocationSiteInfo: pre-transitioning array %p(%s->%s)\n",
+                   reinterpret_cast<void*>(array),
+                   ElementsKindToString(array->GetElementsKind()),
+                   ElementsKindToString(to_kind));
+          }
+
+          maybe_array = array->TransitionElementsKind(to_kind);
+          if (maybe_array->IsFailure()) return maybe_array;
         }
-
-        MaybeObject* maybe_array =
-            array->TransitionElementsKind(to_kind);
-        if (maybe_array->IsFailure()) return maybe_array;
       }
     }
 
     if (!FLAG_smi_only_arrays) {
       Context* native_context = isolate->context()->native_context();
       if (array->GetElementsKind() == GetInitialFastElementsKind() &&
           !native_context->js_array_maps()->IsUndefined()) {
         FixedArray* map_array =
             FixedArray::cast(native_context->js_array_maps());
         array->set_map(Map::cast(map_array->
                                  get(TERMINAL_FAST_ELEMENTS_KIND)));
       }
     }
   } else {
     // Allocate the JS Array
-    // TODO(mvstanton): There is no allocation info advice for this case.
-    //                  How to address?
     MaybeObject* maybe_obj = heap->AllocateJSObject(constructor);
     if (!maybe_obj->To(&array)) return maybe_obj;
   }
 
   Arguments adjusted_arguments(args->length() - 1, args->arguments() - 1);
   ASSERT(adjusted_arguments.length() < 1 ||
          adjusted_arguments[0] == (*args)[1]);
-  { MaybeObject* maybe_obj = ArrayConstructInitializeElements(array,
-        &adjusted_arguments);
-    if (!maybe_obj->To(&array)) return maybe_obj;
-  }
-
-  return array;
+  return ArrayConstructInitializeElements(array, &adjusted_arguments);
 }
 
 
 BUILTIN(InternalArrayCodeGeneric) {
   return ArrayCodeGenericCommon(
       &args,
       isolate,
       isolate->context()->native_context()->internal_array_function());
 }
 
@@ skipping 850 matching lines @@
   // boxing doubles may cause incremental marking.
   ArrayStorageAllocationMode mode =
       has_double && IsFastObjectElementsKind(elements_kind)
       ? INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE : DONT_INITIALIZE_ARRAY_ELEMENTS;
   JSArray* result_array;
   // Allocate result.
   MaybeObject* maybe_array =
       heap->AllocateJSArrayAndStorage(elements_kind,
                                       result_len,
                                       result_len,
-                                      DONT_TRACK_ALLOCATION_SITE,
-                                      NULL,
                                       mode);
   if (!maybe_array->To(&result_array)) return maybe_array;
   if (result_len == 0) return result_array;
 
   int j = 0;
   FixedArrayBase* storage = result_array->elements();
   ElementsAccessor* accessor = ElementsAccessor::ForKind(elements_kind);
   for (int i = 0; i < n_arguments; i++) {
     JSArray* array = JSArray::cast(args[i]);
     int len = Smi::cast(array->length())->value();
@@ skipping 686 matching lines @@
   return Handle<Code>(code_address);                        \
 }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 
 
 } }  // namespace v8::internal