Allocation Info Tracking, continued.

src/elements.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 1967 matching lines @@
     JSArray* array, Arguments* args) {
   Heap* heap = array->GetIsolate()->heap();
 
   // Optimize the case where there is one argument and the argument is a
   // small smi.
   if (args->length() == 1) {
     Object* obj = (*args)[0];
     if (obj->IsSmi()) {
       int len = Smi::cast(obj)->value();
       if (len > 0 && len < JSObject::kInitialMaxFastElementArray) {
-        FixedArrayBase* fixed_array;
         ElementsKind elements_kind = array->GetElementsKind();
-        {
-          MaybeObject* maybe_obj;
-          if (IsFastDoubleElementsKind(elements_kind)) {
-            maybe_obj = heap->AllocateFixedDoubleArrayWithHoles(len);
-          } else {
-            maybe_obj = heap->AllocateFixedArrayWithHoles(len);
-          }
-          if (!maybe_obj->To(&fixed_array)) return maybe_obj;
-        }
+        MaybeObject* maybe_array = array->Initialize(len, len);
+        if (maybe_array->IsFailure()) return maybe_array;
+
         if (!IsFastHoleyElementsKind(elements_kind)) {
           elements_kind = GetHoleyElementsKind(elements_kind);
-          MaybeObject* maybe_array =
-              array->TransitionElementsKind(elements_kind);
+          maybe_array = array->TransitionElementsKind(elements_kind);
           if (maybe_array->IsFailure()) return maybe_array;
         }
-        // We do not use SetContent to skip the unnecessary elements type check.
-        array->set_elements(fixed_array);
-        array->set_length(Smi::cast(obj));
+
         return array;
       } else if (len == 0) {
         return array->Initialize(JSArray::kPreallocatedArrayElements);
       }
     }
+
     // Take the argument as the length.
-    { MaybeObject* maybe_obj = array->Initialize(0);
-      if (!maybe_obj->ToObject(&obj)) return maybe_obj;
-    }
+    MaybeObject* maybe_obj = array->Initialize(0);
+    if (!maybe_obj->To(&obj)) return maybe_obj;
+
     return array->SetElementsLength((*args)[0]);
   }
 
   // Optimize the case where there are no parameters passed.
   if (args->length() == 0) {
     return array->Initialize(JSArray::kPreallocatedArrayElements);
   }
 
   // Set length and elements on the array.
   int number_of_elements = args->length();
   MaybeObject* maybe_object =
       array->EnsureCanContainElements(args, 0, number_of_elements,
                                       ALLOW_CONVERTED_DOUBLE_ELEMENTS);
   if (maybe_object->IsFailure()) return maybe_object;
 
-
   // Allocate an appropriately typed elements array.
   MaybeObject* maybe_elms;
   ElementsKind elements_kind = array->GetElementsKind();
   if (IsFastDoubleElementsKind(elements_kind)) {
     maybe_elms = heap->AllocateUninitializedFixedDoubleArray(
         number_of_elements);
   } else {
     maybe_elms = heap->AllocateFixedArrayWithHoles(number_of_elements);
   }
   FixedArrayBase* elms;
@@ skipping 31 matching lines @@
       UNREACHABLE();
       break;
   }
 
   array->set_elements(elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 } }  // namespace v8::internal