[builtins] implement Array.prototype[@@iterator] in TFJ builtins

src/builtins/builtins-typedarray.cc

 // Copyright 2016 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.h"
 #include "src/builtins/builtins-utils.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // ES6 section 22.2 TypedArray Objects
 
 // ES6 section 22.2.3.1 get %TypedArray%.prototype.buffer
 BUILTIN(TypedArrayPrototypeBuffer) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSTypedArray, typed_array, "get TypedArray.prototype.buffer");
   return *typed_array->GetBuffer();
 }
 
 namespace {
 
+static void GotoIfIsDetachedBuffer(CodeStubAssembler* assembler,
+                                   compiler::Node* buffer,
+                                   CodeStubAssembler::Label* if_detached) {
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
+
+  Label if_notdetached(assembler);
+  assembler->Assert(
+      assembler->Word32Equal(assembler->LoadInstanceType(buffer),
+                             assembler->Int32Constant(JS_ARRAY_BUFFER_TYPE)));
+  Node* buffer_bit_field = assembler->LoadObjectField(
+      buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
+  assembler->Branch(
+      assembler->Word32Equal(
+          assembler->Word32And(
+              buffer_bit_field,
+              assembler->Int32Constant(JSArrayBuffer::WasNeutered::kMask)),
+          assembler->Int32Constant(0)),
+      &if_notdetached, if_detached);
+  assembler->Bind(&if_notdetached);
+}
+
 void Generate_TypedArrayProtoypeGetter(CodeStubAssembler* assembler,
                                        const char* method_name,
                                        int object_offset) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* context = assembler->Parameter(3);
 
   // Check if the {receiver} is actually a JSTypedArray.
   Label if_receiverisincompatible(assembler, Label::kDeferred);
   assembler->GotoIf(assembler->TaggedIsSmi(receiver),
                     &if_receiverisincompatible);
   Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
   assembler->GotoUnless(
       assembler->Word32Equal(receiver_instance_type,
                              assembler->Int32Constant(JS_TYPED_ARRAY_TYPE)),
       &if_receiverisincompatible);
 
   // Check if the {receiver}'s JSArrayBuffer was neutered.
   Node* receiver_buffer =
       assembler->LoadObjectField(receiver, JSTypedArray::kBufferOffset);
-  Node* receiver_buffer_bit_field = assembler->LoadObjectField(
-      receiver_buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
   Label if_receiverisneutered(assembler, Label::kDeferred);
-  assembler->GotoUnless(
-      assembler->Word32Equal(
-          assembler->Word32And(
-              receiver_buffer_bit_field,
-              assembler->Int32Constant(JSArrayBuffer::WasNeutered::kMask)),
-          assembler->Int32Constant(0)),
-      &if_receiverisneutered);
+  GotoIfIsDetachedBuffer(assembler, receiver_buffer, &if_receiverisneutered);
   assembler->Return(assembler->LoadObjectField(receiver, object_offset));
 
   assembler->Bind(&if_receiverisneutered);
   {
     // The {receiver}s buffer was neutered, default to zero.
     assembler->Return(assembler->SmiConstant(0));
   }
 
   assembler->Bind(&if_receiverisincompatible);
   {
@@ skipping 26 matching lines @@
 }
 
 // ES6 section 22.2.3.18 get %TypedArray%.prototype.length
 void Builtins::Generate_TypedArrayPrototypeLength(
     CodeStubAssembler* assembler) {
   Generate_TypedArrayProtoypeGetter(assembler,
                                     "get TypedArray.prototype.length",
                                     JSTypedArray::kLengthOffset);
 }
 
+namespace {
+
+template <IterationKind kIterationKind>
+void Generate_TypedArrayPrototypeIterationMethod(CodeStubAssembler* assembler,
+                                                 const char* method_name) {
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
+  typedef CodeStubAssembler::Variable Variable;
+
+  Node* receiver = assembler->Parameter(0);
+  Node* context = assembler->Parameter(3);
+
+  Label throw_bad_receiver(assembler, Label::kDeferred);
+  Label throw_typeerror(assembler, Label::kDeferred);
+
+  assembler->GotoIf(assembler->TaggedIsSmi(receiver), &throw_bad_receiver);
+
+  Node* map = assembler->LoadMap(receiver);
+  Node* instance_type = assembler->LoadMapInstanceType(map);
+  assembler->GotoIf(
+      assembler->Word32NotEqual(instance_type,
+                                assembler->Int32Constant(JS_TYPED_ARRAY_TYPE)),
+      &throw_bad_receiver);
+
+  // Check if the {receiver}'s JSArrayBuffer was neutered.
+  Node* receiver_buffer =
+      assembler->LoadObjectField(receiver, JSTypedArray::kBufferOffset);
+  Label if_receiverisneutered(assembler, Label::kDeferred);
+  GotoIfIsDetachedBuffer(assembler, receiver_buffer, &if_receiverisneutered);
+
+  assembler->Return(assembler->CreateArrayIterator(receiver, map, instance_type,
+                                                   context, kIterationKind));
+
+  Variable var_message(assembler, MachineRepresentation::kTagged);
+  assembler->Bind(&throw_bad_receiver);
+  var_message.Bind(
+      assembler->SmiConstant(Smi::FromInt(MessageTemplate::kNotTypedArray)));
+  assembler->Goto(&throw_typeerror);
+
+  assembler->Bind(&if_receiverisneutered);
+  var_message.Bind(assembler->SmiConstant(
+      Smi::FromInt(MessageTemplate::kDetachedOperation)));
+  assembler->Goto(&throw_typeerror);
+
+  assembler->Bind(&throw_typeerror);
+  {
+    Node* arg1 = assembler->HeapConstant(
+        assembler->isolate()->factory()->NewStringFromAsciiChecked(method_name,
+                                                                   TENURED));
+    Node* result = assembler->CallRuntime(Runtime::kThrowTypeError, context,
+                                          var_message.value(), arg1);
+    assembler->Return(result);
+  }
+}
+}  // namespace
+
+void Builtins::Generate_TypedArrayPrototypeValues(
+    CodeStubAssembler* assembler) {
+  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kValues>(
+      assembler, "%TypedArray%.prototype.values()");
+}
+
+void Builtins::Generate_TypedArrayPrototypeEntries(
+    CodeStubAssembler* assembler) {
+  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kEntries>(
+      assembler, "%TypedArray%.prototype.entries()");
+}
+
+void Builtins::Generate_TypedArrayPrototypeKeys(CodeStubAssembler* assembler) {
+  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kKeys>(
+      assembler, "%TypedArray%.prototype.keys()");
+}
+
 }  // namespace internal
 }  // namespace v8