[builtins] Implement %TypedArray%.prototype.map 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 136 matching lines @@
     }
     BIND(&false_continue);
     return a();
   }
 
   Node* MapResultGenerator() {
     // 5. Let A be ? ArraySpeciesCreate(O, len).
     return ArraySpeciesCreate(context(), o(), len_);
   }
 
+  Node* TypedArrayMapResultGenerator() {
+    // 6. Let A be ? TypedArraySpeciesCreate(O, len).
+    Node* A = TypedArraySpeciesCreateByLength(context(), o(), len_);

[danno, 2017/04/24 16:11:16]

super nit: elsewhere to conform to the coding style that we've been using for
this stuff so far, perhaps a lower-case "a"?

+    // In the Spec and our current implementation, the length check is already
+    // performed in TypedArraySpeciesCreate. Repeating the check here to
+    // keep this invariant local.
+    fast_typed_array_target_ = WordAnd(
+        WordEqual(LoadInstanceType(LoadElements(o_)),
+                  LoadInstanceType(LoadElements(A))),
+        WordEqual(len_, LoadObjectField(A, JSTypedArray::kLengthOffset)));
+    return A;
+  }
+
   Node* MapProcessor(Node* k_value, Node* k) {
     //  i. Let kValue be ? Get(O, Pk). Performed by the caller of MapProcessor.
     // 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);
     return a();
   }
 
+  // See tc39.github.io/ecma262/#sec-%typedarray%.prototype.map.
+  Node* TypedArrayMapProcessor(Node* k_value, Node* k) {
+    // 8. c. Let mappedValue be ? Call(callbackfn, T, « kValue, k, O »).
+    Node* mappedValue = CallJS(CodeFactory::Call(isolate()), context(),
+                               callbackfn(), this_arg(), k_value, k, o());
+    Label fast(this), slow(this), done(this), detached(this, Label::kDeferred);
+
+    // 8. d. Perform ? Set(A, Pk, mappedValue, true).
+    // Since we know that A is a TypedArray, this always ends up in
+    // #sec-integer-indexed-exotic-objects-set-p-v-receiver and then
+    // tc39.github.io/ecma262/#sec-integerindexedelementset .
+    Branch(fast_typed_array_target_, &fast, &slow);
+
+    BIND(&fast);
+    // #sec-integerindexedelementset 3. Let numValue be ? ToNumber(value).
+    Node* num_value = ToNumber(context(), mappedValue);
+    // The only way how this can bailout is because of a detached buffer.
+    EmitElementStore(
+        a(), k, num_value, false, source_elements_kind_,
+        KeyedAccessStoreMode::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS,
+        &detached);
+    Goto(&done);
+
+    BIND(&slow);
+    CallRuntime(Runtime::kSetProperty, context(), a(), k, mappedValue,
+                SmiConstant(STRICT));
+    Goto(&done);
+
+    BIND(&detached);
+    {
+      // tc39.github.io/ecma262/#sec-integerindexedelementset
+      // 5. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+      CallRuntime(Runtime::kThrowTypeError, context_,
+                  SmiConstant(MessageTemplate::kDetachedOperation),
+                  name_string_);
+      Unreachable();
+    }
+
+    BIND(&done);
+    return a();
+  }
+
   void NullPostLoopAction() {}
 
  protected:
   Node* context() { return context_; }
   Node* receiver() { return receiver_; }
   Node* new_target() { return new_target_; }
   Node* o() { return o_; }
   Node* len() { return len_; }
   Node* callbackfn() { return callbackfn_; }
   Node* this_arg() { return this_arg_; }
@@ skipping 110 matching lines @@
     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,
       ForEachDirection direction = ForEachDirection::kForward) {
-    Node* name_string =
+    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),
               &throw_not_typed_array);
@@ skipping 14 matching lines @@
     {
       CallRuntime(Runtime::kThrowTypeError, context_,
                   SmiConstant(MessageTemplate::kNotTypedArray));
       Unreachable();
     }
 
     BIND(&throw_detached);
     {
       CallRuntime(Runtime::kThrowTypeError, context_,
                   SmiConstant(MessageTemplate::kDetachedOperation),
-                  name_string);
+                  name_string_);
       Unreachable();
     }
 
     BIND(&throw_not_callable);
     {
       CallRuntime(Runtime::kThrowTypeError, context_,
                   SmiConstant(MessageTemplate::kCalledNonCallable),
                   callbackfn_);
       Unreachable();
     }
@@ skipping 16 matching lines @@
       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(),
+    Node* instance_type = LoadInstanceType(LoadElements(o_));
+    Switch(instance_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);
+      source_elements_kind_ = ElementsKindForInstanceType(
+          static_cast<InstanceType>(instance_types[i]));
+      a_.Bind(generator(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, direction);
+      // spec violation. Should go to &throw_detached_ and throw a TypeError
+      // instead.
+      VisitAllTypedArrayElements(array_buffer, processor, &done, direction);
       Goto(&done);
       // No exception, return success
       BIND(&done);
       action(this);
       Return(a_.value());
     }
   }
 
   void GenerateIteratingArrayBuiltinLoopContinuation(
       const CallResultProcessor& processor, const PostLoopAction& action,
@@ skipping 58 matching lines @@
 
       TYPED_ARRAYS(INSTANCE_TYPE_TO_ELEMENTS_KIND)
 #undef INSTANCE_TYPE_TO_ELEMENTS_KIND
 
       default:
         UNREACHABLE();
         return static_cast<ElementsKind>(-1);
     }
   }
 
-  void VisitAllTypedArrayElements(ElementsKind kind, Node* array_buffer,
+  void VisitAllTypedArrayElements(Node* array_buffer,
                                   const CallResultProcessor& processor,
                                   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);
+      Node* value = LoadFixedTypedArrayElementAsTagged(
+          data_ptr, index, source_elements_kind_, SMI_PARAMETERS);
       k_.Bind(index);
       a_.Bind(processor(this, value, index));
     };
     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;
@@ skipping 118 matching lines @@
     }
   }
 
   Node* callbackfn_ = nullptr;
   Node* o_ = nullptr;
   Node* this_arg_ = nullptr;
   Node* len_ = nullptr;
   Node* context_ = nullptr;
   Node* receiver_ = nullptr;
   Node* new_target_ = nullptr;
+  Node* fast_typed_array_target_ = nullptr;
+  Node* name_string_ = nullptr;
   Variable k_;
   Variable a_;
   Variable to_;
+  ElementsKind source_elements_kind_ = ElementsKind::NO_ELEMENTS;
 };
 
 TF_BUILTIN(FastArrayPush, CodeStubAssembler) {
   VARIABLE(arg_index, 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 474 matching lines @@
   InitIteratingArrayBuiltinBody(context, receiver, callbackfn, this_arg,
                                 new_target);
 
   GenerateIteratingArrayBuiltinBody(
       "Array.prototype.map", &ArrayBuiltinCodeStubAssembler::MapResultGenerator,
       &ArrayBuiltinCodeStubAssembler::MapProcessor,
       &ArrayBuiltinCodeStubAssembler::NullPostLoopAction,
       CodeFactory::ArrayMapLoopContinuation(isolate()));
 }
 
+TF_BUILTIN(TypedArrayPrototypeMap, ArrayBuiltinCodeStubAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* callbackfn = Parameter(Descriptor::kCallbackFn);
+  Node* this_arg = Parameter(Descriptor::kThisArg);
+  Node* new_target = Parameter(Descriptor::kNewTarget);
+
+  InitIteratingArrayBuiltinBody(context, receiver, callbackfn, this_arg,
+                                new_target);
+
+  GenerateIteratingTypedArrayBuiltinBody(
+      "%TypedArray%.prototype.map",
+      &ArrayBuiltinCodeStubAssembler::TypedArrayMapResultGenerator,
+      &ArrayBuiltinCodeStubAssembler::TypedArrayMapProcessor,
+      &ArrayBuiltinCodeStubAssembler::NullPostLoopAction);
+}
+
 TF_BUILTIN(ArrayIsArray, CodeStubAssembler) {
   Node* object = Parameter(Descriptor::kArg);
   Node* context = Parameter(Descriptor::kContext);
 
   Label call_runtime(this), return_true(this), return_false(this);
 
   GotoIf(TaggedIsSmi(object), &return_false);
   Node* instance_type = LoadInstanceType(object);
 
   GotoIf(Word32Equal(instance_type, Int32Constant(JS_ARRAY_TYPE)),
@@ skipping 1041 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8