[builtins] Implement Array.prototype.reduceRight in the CSA

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 176 matching lines @@
     callbackfn_ = callbackfn;
     this_arg_ = this_arg;
 
     k_.Bind(SmiConstant(0));
     a_.Bind(UndefinedConstant());
   }
 
   void GenerateIteratingArrayBuiltinBody(
       const char* name, const BuiltinResultGenerator& generator,
       const CallResultProcessor& processor, const PostLoopAction& action,
-      const Callable& slow_case_continuation) {
+      const Callable& slow_case_continuation,
+      ForEachDirection direction = ForEachDirection::kForward) {
     Label non_array(this), slow(this, {&k_, &a_, &to_}),
         array_changes(this, {&k_, &a_, &to_});
 
     // TODO(danno): Seriously? Do we really need to throw the exact error
     // message on null and undefined so that the webkit tests pass?
     Label throw_null_undefined_exception(this, Label::kDeferred);
     GotoIf(WordEqual(receiver(), NullConstant()),
            &throw_null_undefined_exception);
     GotoIf(WordEqual(receiver(), UndefinedConstant()),
            &throw_null_undefined_exception);
@@ skipping 41 matching lines @@
                   SmiConstant(MessageTemplate::kCalledNonCallable),
                   callbackfn());
       Unreachable();
     }
 
     Bind(&done);
 
     // 6. If thisArg was supplied, let T be thisArg; else let T be undefined.
     // [Already done by the arguments adapter]
 
-    // 7. Let k be 0.
-    // [Already done in code assembler initialization]
+    if (direction == ForEachDirection::kForward) {
+      // 7. Let k be 0.
+      k_.Bind(SmiConstant(0));
+    } else {
+      k_.Bind(len());
+      k_.Bind(NumberDec(k_.value()));
+    }
 
     a_.Bind(generator(this));
 
-    HandleFastElements(processor, action, &slow);
+    HandleFastElements(processor, action, &slow, direction);
 
     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_.value(), o(), k_.value(),
         len(), to_.value());
   }
 
   void InitIteratingArrayBuiltinLoopContinuation(Node* context, Node* receiver,
                                                  Node* callbackfn,
                                                  Node* this_arg, Node* a,
                                                  Node* o, Node* initial_k,
                                                  Node* len, Node* to) {
     context_ = context;
     this_arg_ = this_arg;
     callbackfn_ = callbackfn;
     a_.Bind(a);
     k_.Bind(initial_k);
     o_ = o;
     len_ = len;
     to_.Bind(to);
   }
 
   void GenerateIteratingArrayBuiltinLoopContinuation(
-      const CallResultProcessor& processor, const PostLoopAction& action) {
-    // 8. Repeat, while k < len
+      const CallResultProcessor& processor, const PostLoopAction& action,
+      ForEachDirection direction = ForEachDirection::kForward) {
     Label loop(this, {&k_, &a_, &to_});
     Label after_loop(this);
     Goto(&loop);
     Bind(&loop);
     {
-      GotoUnlessNumberLessThan(k(), len_, &after_loop);
+      if (direction == ForEachDirection::kForward) {
+        // 8. Repeat, while k < len
+        GotoUnlessNumberLessThan(k(), len_, &after_loop);
+      } else {
+        // OR
+        // 10. Repeat, while k >= 0
+        GotoUnlessNumberLessThan(SmiConstant(-1), k(), &after_loop);
+      }
 
       Label done_element(this, &to_);
       // a. Let Pk be ToString(k).
       Node* p_k = ToString(context(), k());
 
       // 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());
 
       // iii. Let funcResult be Call(callbackfn, T, «kValue, k, O»).
       // iv. ReturnIfAbrupt(funcResult).
       a_.Bind(processor(this, k_value, k()));
       Goto(&done_element);
 
       Bind(&done_element);
 
-      // e. Increase k by 1.
-      k_.Bind(NumberInc(k_.value()));
+      if (direction == ForEachDirection::kForward) {
+        // e. Increase k by 1.
+        k_.Bind(NumberInc(k()));
+      } else {
+        // e. Decrease k by 1.
+        k_.Bind(NumberDec(k()));
+      }
       Goto(&loop);
     }
     Bind(&after_loop);
 
     action(this);
     Return(a_.value());
   }
 
  private:
   void VisitAllFastElementsOneKind(ElementsKind kind,
                                    const CallResultProcessor& processor,
-                                   Label* array_changed, ParameterMode mode) {
+                                   Label* array_changed, ParameterMode mode,
+                                   ForEachDirection direction) {
     Comment("begin VisitAllFastElementsOneKind");
     Variable original_map(this, MachineRepresentation::kTagged);
     original_map.Bind(LoadMap(o()));
     VariableList list({&original_map, &a_, &k_, &to_}, zone());
+    Node* start = IntPtrOrSmiConstant(0, mode);
+    Node* end = TaggedToParameter(len(), mode);
+    IndexAdvanceMode advance_mode = direction == ForEachDirection::kReverse
+                                        ? IndexAdvanceMode::kPre
+                                        : IndexAdvanceMode::kPost;
+    if (direction == ForEachDirection::kReverse) std::swap(start, end);
     BuildFastLoop(
-        list, IntPtrOrSmiConstant(0, mode), TaggedToParameter(len(), mode),
+        list, start, end,
         [=, &original_map](Node* index) {
           k_.Bind(ParameterToTagged(index, mode));
           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.
           Node* o_map = LoadMap(o());
           GotoIf(WordNotEqual(o_map, original_map.value()), array_changed);
 
@@ skipping 25 matching lines @@
           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);
         },
-        1, mode, IndexAdvanceMode::kPost);
+        1, mode, advance_mode);
     Comment("end VisitAllFastElementsOneKind");
   }
 
   void HandleFastElements(const CallResultProcessor& processor,
-                          const PostLoopAction& action, Label* slow) {
+                          const PostLoopAction& action, Label* slow,
+                          ForEachDirection direction) {
     Label switch_on_elements_kind(this), fast_elements(this),
         maybe_double_elements(this), fast_double_elements(this);
 
     Comment("begin HandleFastElements");
     // Non-smi lengths must use the slow path.
     GotoIf(TaggedIsNotSmi(len()), slow);
 
     BranchIfFastJSArray(o(), context(),
                         CodeStubAssembler::FastJSArrayAccessMode::INBOUNDS_READ,
                         &switch_on_elements_kind, slow);
 
     Bind(&switch_on_elements_kind);
     // Select by ElementsKind
     Node* o_map = LoadMap(o());
     Node* bit_field2 = LoadMapBitField2(o_map);
     Node* kind = DecodeWord32<Map::ElementsKindBits>(bit_field2);
     Branch(Int32GreaterThan(kind, Int32Constant(FAST_HOLEY_ELEMENTS)),
            &maybe_double_elements, &fast_elements);
 
     ParameterMode mode = OptimalParameterMode();
     Bind(&fast_elements);
     {
-      VisitAllFastElementsOneKind(FAST_ELEMENTS, processor, slow, mode);
+      VisitAllFastElementsOneKind(FAST_ELEMENTS, processor, slow, mode,
+                                  direction);
 
       action(this);
 
       // No exception, return success
       Return(a_.value());
     }
 
     Bind(&maybe_double_elements);
     Branch(Int32GreaterThan(kind, Int32Constant(FAST_HOLEY_DOUBLE_ELEMENTS)),
            slow, &fast_double_elements);
 
     Bind(&fast_double_elements);
     {
-      VisitAllFastElementsOneKind(FAST_DOUBLE_ELEMENTS, processor, slow, mode);
+      VisitAllFastElementsOneKind(FAST_DOUBLE_ELEMENTS, processor, slow, mode,
+                                  direction);
 
       action(this);
 
       // No exception, return success
       Return(a_.value());
     }
   }
 
   Node* callbackfn_ = nullptr;
   Node* o_ = nullptr;
@@ skipping 308 matching lines @@
                                 new_target);
 
   GenerateIteratingArrayBuiltinBody(
       "Array.prototype.reduce",
       &ArrayBuiltinCodeStubAssembler::ReduceResultGenerator,
       &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
       &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction,
       CodeFactory::ArrayReduceLoopContinuation(isolate()));
 }
 
+TF_BUILTIN(ArrayReduceRightLoopContinuation, ArrayBuiltinCodeStubAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* callbackfn = Parameter(Descriptor::kCallbackFn);
+  Node* this_arg = Parameter(Descriptor::kThisArg);
+  Node* accumulator = Parameter(Descriptor::kAccumulator);
+  Node* object = Parameter(Descriptor::kObject);
+  Node* initial_k = Parameter(Descriptor::kInitialK);
+  Node* len = Parameter(Descriptor::kLength);
+  Node* to = Parameter(Descriptor::kTo);
+
+  InitIteratingArrayBuiltinLoopContinuation(context, receiver, callbackfn,
+                                            this_arg, accumulator, object,
+                                            initial_k, len, to);
+
+  GenerateIteratingArrayBuiltinLoopContinuation(
+      &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
+      &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction,
+      ForEachDirection::kReverse);
+}
+
+TF_BUILTIN(ArrayReduceRight, ArrayBuiltinCodeStubAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* callbackfn = Parameter(Descriptor::kCallbackFn);
+  Node* initial_value = Parameter(Descriptor::kInitialValue);
+  Node* new_target = Parameter(Descriptor::kNewTarget);
+
+  InitIteratingArrayBuiltinBody(context, receiver, callbackfn, initial_value,
+                                new_target);
+
+  GenerateIteratingArrayBuiltinBody(
+      "Array.prototype.reduceRight",
+      &ArrayBuiltinCodeStubAssembler::ReduceResultGenerator,
+      &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
+      &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction,
+      CodeFactory::ArrayReduceRightLoopContinuation(isolate()),
+      ForEachDirection::kReverse);
+}
+
 TF_BUILTIN(ArrayFilterLoopContinuation, ArrayBuiltinCodeStubAssembler) {
   Node* context = Parameter(Descriptor::kContext);
   Node* receiver = Parameter(Descriptor::kReceiver);
   Node* callbackfn = Parameter(Descriptor::kCallbackFn);
   Node* this_arg = Parameter(Descriptor::kThisArg);
   Node* array = Parameter(Descriptor::kArray);
   Node* object = Parameter(Descriptor::kObject);
   Node* initial_k = Parameter(Descriptor::kInitialK);
   Node* len = Parameter(Descriptor::kLength);
   Node* to = Parameter(Descriptor::kTo);
@@ skipping 1116 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8