[array] Fast allocation in Array.p.map

src/builtins/builtins-array-gen.cc

 // Copyright 2017 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/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 73 matching lines @@
     Label ok(this);
     GotoIf(WordNotEqual(a(), TheHoleConstant()), &ok);
     CallRuntime(Runtime::kThrowTypeError, context(),
                 SmiConstant(MessageTemplate::kReduceNoInitial));
     Unreachable();
     BIND(&ok);
   }
 
   void FilterResultGenerator() {
     // 7. Let A be ArraySpeciesCreate(O, 0).
-    a_.Bind(ArraySpeciesCreate(context(), o(), SmiConstant(0)));
+    Node* len = SmiConstant(0);
+    ArraySpeciesCreate(len);
   }
 
   Node* FilterProcessor(Node* k_value, Node* k) {
     // ii. Let selected be ToBoolean(? Call(callbackfn, T, kValue, k, O)).
     Node* selected = CallJS(CodeFactory::Call(isolate()), context(),
                             callbackfn(), this_arg(), k_value, k, o());
     Label true_continue(this, &to_), false_continue(this);
     BranchIfToBooleanIsTrue(selected, &true_continue, &false_continue);
     BIND(&true_continue);
     // iii. If selected is true, then...
@@ skipping 48 matching lines @@
       {
         // 2. Increase to by 1.
         to_.Bind(NumberInc(to_.value()));
         Goto(&false_continue);
       }
     }
     BIND(&false_continue);
     return a();
   }
 
-  void MapResultGenerator() {
-    Label runtime(this), done(this, {&a_});
-    GotoIf(DoesntHaveInstanceType(o(), JS_ARRAY_TYPE), &runtime);
-    Node* o_map = LoadMap(o());
-    Node* const initial_array_prototype = LoadContextElement(
-        LoadNativeContext(context()), Context::INITIAL_ARRAY_PROTOTYPE_INDEX);
-    Node* proto = LoadMapPrototype(o_map);
-    GotoIf(WordNotEqual(proto, initial_array_prototype), &runtime);
-
-    Node* species_protector = SpeciesProtectorConstant();
-    Node* value = LoadObjectField(species_protector, Cell::kValueOffset);
-    Node* const protector_invalid = SmiConstant(Isolate::kProtectorInvalid);
-    GotoIf(WordEqual(value, protector_invalid), &runtime);
-
-    Node* const initial_array_constructor = LoadContextElement(
-        LoadNativeContext(context()), Context::ARRAY_FUNCTION_INDEX);
-    a_.Bind(ConstructJS(CodeFactory::Construct(isolate()), context(),
-                        initial_array_constructor, len_));
-    Goto(&done);
-
-    BIND(&runtime);
-    {
-      // 5. Let A be ? ArraySpeciesCreate(O, len).
-      Node* constructor =
-          CallRuntime(Runtime::kArraySpeciesConstructor, context(), o());
-      a_.Bind(ConstructJS(CodeFactory::Construct(isolate()), context(),
-                          constructor, len_));
-      Goto(&fully_spec_compliant_);
-    }
-    BIND(&done);
-  }
+  void MapResultGenerator() { ArraySpeciesCreate(len_); }
 
   Node* SpecCompliantMapProcessor(Node* k_value, Node* k) {
     //  i. Let kValue be ? Get(O, Pk). Performed by the caller of
     //  SpecCompliantMapProcessor.
     // ii. Let mappedValue be ? Call(callbackfn, T, kValue, k, O).
     Node* mappedValue = CallJS(CodeFactory::Call(isolate()), context(),
                                callbackfn(), this_arg(), k_value, k, o());
 
     // iii. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
     CallRuntime(Runtime::kCreateDataProperty, context(), a(), k, mappedValue);
@@ skipping 505 matching lines @@
       VisitAllFastElementsOneKind(FAST_DOUBLE_ELEMENTS, processor, slow, mode,
                                   direction);
 
       action(this);
 
       // No exception, return success
       ReturnFromBuiltin(a_.value());
     }
   }
 
+  // Perform ArraySpeciesCreate (ES6 #sec-arrayspeciescreate).
+  void ArraySpeciesCreate(Node* len) {
+    Label runtime(this, Label::kDeferred), done(this);
+
+    Node* const original_map = LoadMap(o());
+    GotoIf(Word32NotEqual(LoadMapInstanceType(original_map),
+                          Int32Constant(JS_ARRAY_TYPE)),
+           &runtime);
+
+    Node* const native_context = LoadNativeContext(context());
+    Node* const initial_array_prototype = LoadContextElement(
+        native_context, Context::INITIAL_ARRAY_PROTOTYPE_INDEX);
+    Node* proto = LoadMapPrototype(original_map);
+    GotoIf(WordNotEqual(proto, initial_array_prototype), &runtime);
+
+    Node* species_protector = SpeciesProtectorConstant();
+    Node* value = LoadObjectField(species_protector, Cell::kValueOffset);
+    Node* const protector_invalid = SmiConstant(Isolate::kProtectorInvalid);
+    GotoIf(WordEqual(value, protector_invalid), &runtime);
+
+    GotoIfNot(TaggedIsPositiveSmi(len), &runtime);
+    GotoIf(SmiAbove(len, SmiConstant(JSArray::kInitialMaxFastElementArray)),
+           &runtime);
+
+    const ElementsKind elements_kind =
+        GetHoleyElementsKind(GetInitialFastElementsKind());
+    Node* array_map = LoadJSArrayElementsMap(elements_kind, native_context);
+    a_.Bind(AllocateJSArray(FAST_SMI_ELEMENTS, array_map, len, len, nullptr,
+                            CodeStubAssembler::SMI_PARAMETERS));
+
+    Goto(&done);
+
+    BIND(&runtime);
+    {
+      // 5. Let A be ? ArraySpeciesCreate(O, len).
+      Node* constructor =
+          CallRuntime(Runtime::kArraySpeciesConstructor, context(), o());
+      a_.Bind(ConstructJS(CodeFactory::Construct(isolate()), context(),
+                          constructor, len));
+      Goto(&fully_spec_compliant_);
+    }
+
+    BIND(&done);
+  }
+
   Node* callbackfn_ = nullptr;
   Node* o_ = nullptr;
   Node* this_arg_ = nullptr;
   Node* len_ = nullptr;
   Node* context_ = nullptr;
   Node* receiver_ = nullptr;
   Node* new_target_ = nullptr;
   Node* argc_ = nullptr;
   Variable k_;
   Variable a_;
@@ skipping 1671 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8