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);
-      } else {
-        AllocationSiteMode mode = AllocationSiteInfo::GetMode(kind);
-        maybe_array = isolate->heap()->AllocateEmptyJSArray(kind,
-                                                            mode,
-                                                            &type_info);
-      }
+      AllocationSiteMode mode = AllocationSiteInfo::GetMode(to_kind);
+      maybe_array = isolate->heap()->AllocateEmptyJSArray(kind,
+                                                          mode,
+                                                          &type_info);
       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());
+    MaybeObject* maybe_array = array->Initialize(0);
+    if (maybe_array->IsFailure()) return maybe_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->TransitionElementsKind(to_kind);
+        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;
-  }
+  MaybeObject* maybe_obj = ArrayConstructInitializeElements(array,
+      &adjusted_arguments);
+  if (!maybe_obj->To(&array)) return maybe_obj;
 
   return array;
 }
 
 
 BUILTIN(InternalArrayCodeGeneric) {
   return ArrayCodeGenericCommon(
       &args,
       isolate,
       isolate->context()->native_context()->internal_array_function());
@@ skipping 1560 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