[builtins] Array.prototype.filter implemented as a TurboFan code stub.

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 {
 
 class ArrayBuiltinCodeStubAssembler : public CodeStubAssembler {
  public:
   explicit ArrayBuiltinCodeStubAssembler(compiler::CodeAssemblerState* state)
-      : CodeStubAssembler(state) {}
+      : CodeStubAssembler(state), to_(this, OptimalParameterRepresentation()) {
+    to_.Bind(IntPtrOrSmiConstant(0, OptimalParameterMode()));
+  }
 
-  typedef std::function<Node*(Node* o, Node* len)> BuiltinResultGenerator;
-  typedef std::function<void(Node* a, Node* pK, Node* value)>
+  typedef std::function<Node*(Node* context, Node* o, Node* len)>
+      BuiltinResultGenerator;
+  typedef std::function<void(Node* context, Node* a)>
+      BuiltinResultIndexInitializer;
+  typedef std::function<void(Node* context, Node* value, Node* a,
+                             Node* callback_result)>
       CallResultProcessor;
 
   void GenerateIteratingArrayBuiltinBody(
       const char* name, const BuiltinResultGenerator& generator,
       const CallResultProcessor& processor,
       const Callable& slow_case_continuation) {
     Node* receiver = Parameter(IteratingArrayBuiltinDescriptor::kReceiver);
     Node* callbackfn = Parameter(IteratingArrayBuiltinDescriptor::kCallback);
     Node* this_arg = Parameter(IteratingArrayBuiltinDescriptor::kThisArg);
     Node* context = Parameter(IteratingArrayBuiltinDescriptor::kContext);
@@ skipping 49 matching lines @@
 
     Bind(&type_exception);
     {
       CallRuntime(Runtime::kThrowTypeError, context,
                   SmiConstant(MessageTemplate::kCalledNonCallable), callbackfn);
       Unreachable();
     }
 
     Bind(&done);
 
-    Node* a = generator(o, len);
+    Node* a = generator(context, o, len);
 
     // 6. If thisArg was supplied, let T be thisArg; else let T be undefined.
     // [Already done by the arguments adapter]
 
     HandleFastElements(context, this_arg, o, len, callbackfn, processor, a, k,
                        &slow);
 
     // 7. Let k be 0.
     // Already done above in initialization of the Variable k
 
     Bind(&slow);
 
     Node* target = LoadFromFrame(StandardFrameConstants::kFunctionOffset,
                                  MachineType::TaggedPointer());
     TailCallStub(
         slow_case_continuation, context, target, new_target,
         Int32Constant(IteratingArrayBuiltinLoopContinuationDescriptor::kArity),
         receiver, callbackfn, this_arg, a, o, k.value(), len);
   }
 
   void GenerateIteratingArrayBuiltinLoopContinuation(
+      const BuiltinResultIndexInitializer& index_initializer,
       const CallResultProcessor& processor) {
     Node* callbackfn =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kCallback);
     Node* this_arg =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kThisArg);
     Node* a =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kArray);
     Node* o =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kObject);
     Node* initial_k =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kInitialK);
     Node* len =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kLength);
     Node* context =
         Parameter(IteratingArrayBuiltinLoopContinuationDescriptor::kContext);
 
+    index_initializer(context, a);
+
     // 8. Repeat, while k < len
     Variable k(this, MachineRepresentation::kTagged, initial_k);
-    Label loop(this, &k);
+    VariableList list({&k, &to_}, zone());
+    Label loop(this, list);
     Label after_loop(this);
     Goto(&loop);
     Bind(&loop);
     {
       GotoUnlessNumberLessThan(k.value(), len, &after_loop);
 
-      Label done_element(this);
+      Label done_element(this, &to_);
       // a. Let Pk be ToString(k).
       Node* p_k = ToString(context, k.value());
 
       // b. Let kPresent be HasProperty(O, Pk).
       // c. ReturnIfAbrupt(kPresent).
       Node* k_present = HasProperty(o, p_k, context);
 
       // d. If kPresent is true, then
       GotoIf(WordNotEqual(k_present, TrueConstant()), &done_element);
 
       // i. Let kValue be Get(O, Pk).
       // ii. ReturnIfAbrupt(kValue).
       Node* k_value = GetProperty(context, o, k.value());
 
       // iii. Let funcResult be Call(callbackfn, T, «kValue, k, O»).
       // iv. ReturnIfAbrupt(funcResult).
-      Node* result = CallJS(CodeFactory::Call(isolate()), context, callbackfn,
-                            this_arg, k_value, k.value(), o);
+      Node* callback_result =
+          CallJS(CodeFactory::Call(isolate()), context, callbackfn, this_arg,
+                 k_value, k.value(), o);
 
-      processor(a, p_k, result);
+      processor(context, k_value, a, callback_result);
       Goto(&done_element);
       Bind(&done_element);
 
       // e. Increase k by 1.
       k.Bind(NumberInc(k.value()));
       Goto(&loop);
     }
     Bind(&after_loop);
     Return(a);
   }
 
-  void ForEachProcessor(Node* a, Node* p_k, Node* value) {}
+  Node* FilterResultGenerator(Node* context, Node* o, Node* len) {
+    // 7. Let A be ArraySpeciesCreate(O, 0).
+    // TODO(mvstanton): avoid this runtime call if possible.
+    Node* constructor =
+        CallRuntime(Runtime::kArraySpeciesConstructor, context, o);
+    return ConstructJS(CodeFactory::Construct(isolate()), context, constructor,
+                       SmiConstant(0));
+  }
 
-  void SomeProcessor(Node* a, Node* p_k, Node* value) {
+  void FilterResultIndexReinitializer(Node* context, Node* a) {
+    Variable merged_length(this, MachineRepresentation::kTagged);
+    Label has_length(this, &merged_length), not_js_array(this);
+    GotoIf(DoesntHaveInstanceType(a, JS_ARRAY_TYPE), &not_js_array);
+    merged_length.Bind(LoadJSArrayLength(a));
+    Goto(&has_length);
+    Bind(&not_js_array);
+    Node* len_property =
+        GetProperty(context, a, isolate()->factory()->length_string());

[danno, 2017/03/20 08:06:25]

Careful, this call is observable. I don't think it's safe to access the property
like this. We'll have to discuss how it's safe to pass this through, I think it
may indeed need to be a parameter to the the Continuation builder.

[mvstanton, 2017/03/20 16:10:53]

Good catch! Actually, test262 didn't even see this (I had a failure there that
led me to introduce the GetProperty() call here).

I'd like to check in with this issue and with a follow on CL fix it by passing a
parameter to the continuation builder. Since the implementation isn't turned on
yet, that should be reasonable.

+    merged_length.Bind(
+        CallStub(CodeFactory::ToLength(isolate()), context, len_property));
+    Goto(&has_length);
+    Bind(&has_length);
+    Node* len = merged_length.value();
+
+    to_.Bind(len);
+  }
+
+  void ForEachProcessor(Node* context, Node* value, Node* a,
+                        Node* callback_result) {}
+
+  void SomeProcessor(Node* context, Node* value, Node* a,
+                     Node* callback_result) {
     Label false_continue(this), return_true(this);
-    BranchIfToBooleanIsTrue(value, &return_true, &false_continue);
+    BranchIfToBooleanIsTrue(callback_result, &return_true, &false_continue);
     Bind(&return_true);
     Return(TrueConstant());
     Bind(&false_continue);
   }
 
-  void EveryProcessor(Node* a, Node* p_k, Node* value) {
+  void EveryProcessor(Node* context, Node* value, Node* a,
+                      Node* callback_result) {
     Label true_continue(this), return_false(this);
-    BranchIfToBooleanIsTrue(value, &true_continue, &return_false);
+    BranchIfToBooleanIsTrue(callback_result, &true_continue, &return_false);
     Bind(&return_false);
     Return(FalseConstant());
     Bind(&true_continue);
   }
 
+  void FilterProcessor(Node* context, Node* value, Node* a,
+                       Node* callback_result) {
+    Label true_continue(this, &to_), false_continue(this);
+    BranchIfToBooleanIsTrue(callback_result, &true_continue, &false_continue);
+    Bind(&true_continue);
+
+    // 1. let status be CreateDataPropertyOrThrow(A, ToString(to), kValue).
+    // 2. ReturnIfAbrupt(status)
+    Node* const p_to = ToString(context, to_.value());
+    CallRuntime(Runtime::kCreateDataProperty, context, a, p_to, value);
+
+    // 3. Increase to by 1.
+    to_.Bind(NumberInc(to_.value()));
+    Goto(&false_continue);
+    Bind(&false_continue);
+  }
+
  private:
   Node* VisitAllFastElementsOneKind(Node* context, ElementsKind kind,
                                     Node* this_arg, Node* o, Node* len,
                                     Node* callbackfn,
                                     const CallResultProcessor& processor,
                                     Node* a, Label* array_changed,
                                     ParameterMode mode) {
     Comment("begin VisitAllFastElementsOneKind");
     Variable original_map(this, MachineRepresentation::kTagged);
     original_map.Bind(LoadMap(o));
-    VariableList list({&original_map}, zone());
+    VariableList list({&original_map, &to_}, zone());
     Node* last_index = nullptr;
     BuildFastLoop(
         list, IntPtrOrSmiConstant(0, mode), TaggedToParameter(len, mode),
         [=, &original_map, &last_index](Node* index) {
           last_index = index;
           Label one_element_done(this), hole_element(this);
 
           // Check if o's map has changed during the callback. If so, we have to
           // fall back to the slower spec implementation for the rest of the
           // iteration.
@@ skipping 18 matching lines @@
           Node* offset = ElementOffsetFromIndex(index, kind, mode, base_size);
           Node* value = nullptr;
           if (kind == FAST_ELEMENTS) {
             value = LoadObjectField(elements, offset);
             GotoIf(WordEqual(value, TheHoleConstant()), &hole_element);
           } else {
             Node* double_value =
                 LoadDoubleWithHoleCheck(elements, offset, &hole_element);
             value = AllocateHeapNumberWithValue(double_value);
           }
-          Node* result = CallJS(CodeFactory::Call(isolate()), context,
-                                callbackfn, this_arg, value, tagged_index, o);
-          processor(a, tagged_index, result);
+          Node* callback_result =
+              CallJS(CodeFactory::Call(isolate()), context, callbackfn,
+                     this_arg, value, tagged_index, o);
+          processor(context, value, a, callback_result);

[danno, 2017/03/20 08:06:25]

Instead of adding new parameters, I think it's cleaner to have accessors in the
Assembler.

[mvstanton, 2017/03/20 16:10:53]

Yep, as per your upcoming CL. I'll leave this one alone and then religiously
follow the model you have in that one.

           Goto(&one_element_done);
 
           Bind(&hole_element);
           // Check if o's prototype change unexpectedly has elements after the
           // callback in the case of a hole.
           BranchIfPrototypesHaveNoElements(o_map, &one_element_done,
                                            array_changed);
 
           Bind(&one_element_done);
         },
@@ skipping 52 matching lines @@
           processor, a, &array_changed, mode);
 
       // No exception, return success
       Return(a);
 
       Bind(&array_changed);
       k.Bind(ParameterToTagged(last_index, mode));
       Goto(slow);
     }
   }
+
+  Variable to_;
 };
 
 TF_BUILTIN(FastArrayPush, CodeStubAssembler) {
   Variable arg_index(this, MachineType::PointerRepresentation());
   Label default_label(this, &arg_index);
   Label smi_transition(this);
   Label object_push_pre(this);
   Label object_push(this, &arg_index);
   Label double_push(this, &arg_index);
   Label double_transition(this);
@@ skipping 138 matching lines @@
   {
     Node* target = LoadFromFrame(StandardFrameConstants::kFunctionOffset,
                                  MachineType::TaggedPointer());
     TailCallStub(CodeFactory::ArrayPush(isolate()), context, target, new_target,
                  argc);
   }
 }
 
 TF_BUILTIN(ArrayForEachLoopContinuation, ArrayBuiltinCodeStubAssembler) {
   GenerateIteratingArrayBuiltinLoopContinuation(
-      [this](Node* a, Node* p_k, Node* value) {
-        ForEachProcessor(a, p_k, value);
+      [this](Node* context, Node* a) {},
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        ForEachProcessor(context, value, a, callback_result);
+      });
+}
+
+TF_BUILTIN(ArrayFilter, ArrayBuiltinCodeStubAssembler) {
+  GenerateIteratingArrayBuiltinBody(
+      "Array.prototype.filter",
+      [=](Node* context, Node* o, Node* len) {
+        return FilterResultGenerator(context, o, len);
+      },
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        FilterProcessor(context, value, a, callback_result);
+      },
+      CodeFactory::ArrayFilterLoopContinuation(isolate()));
+}
+
+TF_BUILTIN(ArrayFilterLoopContinuation, ArrayBuiltinCodeStubAssembler) {
+  GenerateIteratingArrayBuiltinLoopContinuation(
+      [this](Node* context, Node* a) {
+        FilterResultIndexReinitializer(context, a);
+      },
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        FilterProcessor(context, value, a, callback_result);
       });
 }
 
 TF_BUILTIN(ArrayForEach, ArrayBuiltinCodeStubAssembler) {
   GenerateIteratingArrayBuiltinBody(
       "Array.prototype.forEach",
-      [=](Node*, Node*) { return UndefinedConstant(); },
-      [this](Node* a, Node* p_k, Node* value) {
-        ForEachProcessor(a, p_k, value);
+      [=](Node*, Node*, Node*) { return UndefinedConstant(); },
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        ForEachProcessor(context, value, a, callback_result);
       },
       CodeFactory::ArrayForEachLoopContinuation(isolate()));
 }
 
 TF_BUILTIN(ArraySomeLoopContinuation, ArrayBuiltinCodeStubAssembler) {
   GenerateIteratingArrayBuiltinLoopContinuation(
-      [this](Node* a, Node* p_k, Node* value) {
-        SomeProcessor(a, p_k, value);
+      [](Node* context, Node* a) {},
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        SomeProcessor(context, value, a, callback_result);
       });
 }
 
 TF_BUILTIN(ArraySome, ArrayBuiltinCodeStubAssembler) {
   GenerateIteratingArrayBuiltinBody(
-      "Array.prototype.some", [=](Node*, Node*) { return FalseConstant(); },
-      [this](Node* a, Node* p_k, Node* value) { SomeProcessor(a, p_k, value); },
+      "Array.prototype.some",
+      [=](Node*, Node*, Node*) { return FalseConstant(); },
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        SomeProcessor(context, value, a, callback_result);
+      },
       CodeFactory::ArraySomeLoopContinuation(isolate()));
 }
 
 TF_BUILTIN(ArrayEveryLoopContinuation, ArrayBuiltinCodeStubAssembler) {
   GenerateIteratingArrayBuiltinLoopContinuation(
-      [this](Node* a, Node* p_k, Node* value) {
-        EveryProcessor(a, p_k, value);
+      [](Node* context, Node* a) {},
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        EveryProcessor(context, value, a, callback_result);
       });
 }
 
 TF_BUILTIN(ArrayEvery, ArrayBuiltinCodeStubAssembler) {
   GenerateIteratingArrayBuiltinBody(
-      "Array.prototype.every", [=](Node*, Node*) { return TrueConstant(); },
-      [this](Node* a, Node* p_k, Node* value) {
-        EveryProcessor(a, p_k, value);
+      "Array.prototype.every",
+      [=](Node*, Node*, Node*) { return TrueConstant(); },
+      [this](Node* context, Node* value, Node* a, Node* callback_result) {
+        EveryProcessor(context, value, a, callback_result);
       },
       CodeFactory::ArrayEveryLoopContinuation(isolate()));
 }
 
 TF_BUILTIN(ArrayIsArray, CodeStubAssembler) {
   Node* object = Parameter(1);
   Node* context = Parameter(4);
 
   Label call_runtime(this), return_true(this), return_false(this);
 
@@ skipping 1038 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8