[builtins] Implement %TypedArray%.prototype.{reduce,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 {
 
 class ArrayBuiltinCodeStubAssembler : public CodeStubAssembler {
  public:
   explicit ArrayBuiltinCodeStubAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state),
-        k_(this, MachineRepresentation::kTagged, SmiConstant(0)),
-        a_(this, MachineRepresentation::kTagged, SmiConstant(0)),

[Tobias Tebbi, 2017/04/05 11:53:05]

I removed these defaults because we should never rely on them anyway.

+        k_(this, MachineRepresentation::kTagged),
+        a_(this, MachineRepresentation::kTagged),
         to_(this, MachineRepresentation::kTagged, SmiConstant(0)) {}
 
   typedef std::function<Node*(ArrayBuiltinCodeStubAssembler* masm)>
       BuiltinResultGenerator;
 
   typedef std::function<void(ArrayBuiltinCodeStubAssembler* masm)>
       BuiltinResultIndexInitializer;
 
   typedef std::function<Node*(ArrayBuiltinCodeStubAssembler* masm,
                               Node* k_value, Node* k)>
@@ skipping 151 matching lines @@
   Node* a() { return a_.value(); }
 
   void InitIteratingArrayBuiltinBody(Node* context, Node* receiver,
                                      Node* callbackfn, Node* this_arg,
                                      Node* new_target) {
     context_ = context;
     receiver_ = receiver;
     new_target_ = new_target;
     callbackfn_ = callbackfn;
     this_arg_ = this_arg;
-
-    k_.Bind(SmiConstant(0));
-    a_.Bind(UndefinedConstant());

[Tobias Tebbi, 2017/04/05 11:53:05]

Same here.

   }
 
   void GenerateIteratingArrayBuiltinBody(
       const char* name, const BuiltinResultGenerator& generator,
       const CallResultProcessor& processor, const PostLoopAction& action,
       const Callable& slow_case_continuation,
       ForEachDirection direction = ForEachDirection::kForward) {
     Label non_array(this), slow(this, {&k_, &a_, &to_}),
         array_changes(this, {&k_, &a_, &to_});
 
@@ skipping 52 matching lines @@
 
     Bind(&done);
 
     // 6. If thisArg was supplied, let T be thisArg; else let T be undefined.
     // [Already done by the arguments adapter]
 
     if (direction == ForEachDirection::kForward) {
       // 7. Let k be 0.
       k_.Bind(SmiConstant(0));
     } else {
-      k_.Bind(len());
-      k_.Bind(NumberDec(k_.value()));
+      k_.Bind(NumberDec(len()));
     }
 
     a_.Bind(generator(this));
 
     HandleFastElements(processor, action, &slow, direction);
 
     Bind(&slow);
 
     Node* target = LoadFromFrame(StandardFrameConstants::kFunctionOffset,
                                  MachineType::TaggedPointer());
@@ skipping 14 matching lines @@
     callbackfn_ = callbackfn;
     a_.Bind(a);
     k_.Bind(initial_k);
     o_ = o;
     len_ = len;
     to_.Bind(to);
   }
 
   void GenerateIteratingTypedArrayBuiltinBody(
       const char* name, const BuiltinResultGenerator& generator,
-      const CallResultProcessor& processor, const PostLoopAction& action) {
+      const CallResultProcessor& processor, const PostLoopAction& action,
+      ForEachDirection direction = ForEachDirection::kForward) {
     Node* name_string =
         HeapConstant(isolate()->factory()->NewStringFromAsciiChecked(name));
 
     // ValidateTypedArray: tc39.github.io/ecma262/#sec-validatetypedarray
 
     Label throw_not_typed_array(this, Label::kDeferred),
         throw_detached(this, Label::kDeferred);
 
     GotoIf(TaggedIsSmi(receiver_), &throw_not_typed_array);
     GotoIfNot(HasInstanceType(receiver_, JS_TYPED_ARRAY_TYPE),
@@ skipping 46 matching lines @@
     std::vector<Label> labels;
     for (size_t i = 0; i < instance_types.size(); ++i) {
       labels.push_back(Label(this));
     }
     std::vector<Label*> label_ptrs;
     for (Label& label : labels) {
       label_ptrs.push_back(&label);
     }
 
     Bind(&distinguish_types);
+
+    if (direction == ForEachDirection::kForward) {
+      k_.Bind(SmiConstant(0));
+    } else {
+      k_.Bind(NumberDec(len()));
+    }
     a_.Bind(generator(this));
     Node* elements_type = LoadInstanceType(LoadElements(o_));
     Switch(elements_type, &unexpected_instance_type, instance_types.data(),
            label_ptrs.data(), labels.size());
 
     for (size_t i = 0; i < labels.size(); ++i) {
       Bind(&labels[i]);
       Label done(this);
       // TODO(tebbi): Silently cancelling the loop on buffer detachment is a
       // spec violation. Should go to &detached and throw a TypeError instead.
       VisitAllTypedArrayElements(
           ElementsKindForInstanceType(
               static_cast<InstanceType>(instance_types[i])),
-          array_buffer, processor, &done);
+          array_buffer, processor, &done, direction);
       Goto(&done);
-      action(this);
       // No exception, return success
       Bind(&done);
+      action(this);
       Return(a_.value());
     }
   }
 
   void GenerateIteratingArrayBuiltinLoopContinuation(
       const CallResultProcessor& processor, const PostLoopAction& action,
       ForEachDirection direction = ForEachDirection::kForward) {
     Label loop(this, {&k_, &a_, &to_});
     Label after_loop(this);
     Goto(&loop);
@@ skipping 56 matching lines @@
 #undef INSTANCE_TYPE_TO_ELEMENTS_KIND
 
       default:
         UNREACHABLE();
         return static_cast<ElementsKind>(-1);
     }
   }
 
   void VisitAllTypedArrayElements(ElementsKind kind, Node* array_buffer,
                                   const CallResultProcessor& processor,
-                                  Label* detached) {
+                                  Label* detached, ForEachDirection direction) {
     VariableList list({&a_, &k_, &to_}, zone());
 
     FastLoopBody body = [&](Node* index) {
       GotoIf(IsDetachedBuffer(array_buffer), detached);
       Node* elements = LoadElements(o_);
       Node* base_ptr =
           LoadObjectField(elements, FixedTypedArrayBase::kBasePointerOffset);
       Node* external_ptr =
           LoadObjectField(elements, FixedTypedArrayBase::kExternalPointerOffset,
                           MachineType::Pointer());
       Node* data_ptr = IntPtrAdd(BitcastTaggedToWord(base_ptr), external_ptr);
       Node* value = LoadFixedTypedArrayElementAsTagged(data_ptr, index, kind,
                                                        SMI_PARAMETERS);
       k_.Bind(index);
       a_.Bind(processor(this, value, index));
     };
-    BuildFastLoop(list, SmiConstant(0), len_, body, 1,
-                  ParameterMode::SMI_PARAMETERS, IndexAdvanceMode::kPost);
+    Node* start = SmiConstant(0);
+    Node* end = len_;
+    IndexAdvanceMode advance_mode = IndexAdvanceMode::kPost;
+    int incr = 1;
+    if (direction == ForEachDirection::kReverse) {
+      std::swap(start, end);
+      advance_mode = IndexAdvanceMode::kPre;
+      incr = -1;
+    }
+    BuildFastLoop(list, start, end, body, incr, ParameterMode::SMI_PARAMETERS,
+                  advance_mode);
   }
 
   void VisitAllFastElementsOneKind(ElementsKind kind,
                                    const CallResultProcessor& processor,
                                    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());
@@ skipping 451 matching lines @@
                                 new_target);
 
   GenerateIteratingArrayBuiltinBody(
       "Array.prototype.reduce",
       &ArrayBuiltinCodeStubAssembler::ReduceResultGenerator,
       &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
       &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction,
       CodeFactory::ArrayReduceLoopContinuation(isolate()));
 }
 
+TF_BUILTIN(TypedArrayPrototypeReduce, 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);
+
+  GenerateIteratingTypedArrayBuiltinBody(
+      "%TypedArray%.prototype.reduce",
+      &ArrayBuiltinCodeStubAssembler::ReduceResultGenerator,
+      &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
+      &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction);
+}
+
 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);
@@ skipping 20 matching lines @@
 
   GenerateIteratingArrayBuiltinBody(
       "Array.prototype.reduceRight",
       &ArrayBuiltinCodeStubAssembler::ReduceResultGenerator,
       &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
       &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction,
       CodeFactory::ArrayReduceRightLoopContinuation(isolate()),
       ForEachDirection::kReverse);
 }
 
+TF_BUILTIN(TypedArrayPrototypeReduceRight, 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);
+
+  GenerateIteratingTypedArrayBuiltinBody(
+      "%TypedArray%.prototype.reduceRight",
+      &ArrayBuiltinCodeStubAssembler::ReduceResultGenerator,
+      &ArrayBuiltinCodeStubAssembler::ReduceProcessor,
+      &ArrayBuiltinCodeStubAssembler::ReducePostLoopAction,
+      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