1// Copyright 2016 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "src/builtins/builtins.h"
6#include "src/builtins/builtins-utils.h"
7
8namespace v8 {
9namespace internal {
10
11// -----------------------------------------------------------------------------
12// ES6 section 22.2 TypedArray Objects
13
14// ES6 section 22.2.3.1 get %TypedArray%.prototype.buffer
15BUILTIN(TypedArrayPrototypeBuffer) {
16  HandleScope scope(isolate);
17  CHECK_RECEIVER(JSTypedArray, typed_array, "get TypedArray.prototype.buffer");
18  return *typed_array->GetBuffer();
19}
20
21namespace {
22
23void Generate_TypedArrayProtoypeGetter(CodeStubAssembler* assembler,
24                                       const char* method_name,
25                                       int object_offset) {
26  typedef CodeStubAssembler::Label Label;
27  typedef compiler::Node Node;
28
29  Node* receiver = assembler->Parameter(0);
30  Node* context = assembler->Parameter(3);
31
32  // Check if the {receiver} is actually a JSTypedArray.
33  Label if_receiverisincompatible(assembler, Label::kDeferred);
34  assembler->GotoIf(assembler->TaggedIsSmi(receiver),
35                    &if_receiverisincompatible);
36  Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
37  assembler->GotoUnless(
38      assembler->Word32Equal(receiver_instance_type,
39                             assembler->Int32Constant(JS_TYPED_ARRAY_TYPE)),
40      &if_receiverisincompatible);
41
42  // Check if the {receiver}'s JSArrayBuffer was neutered.
43  Node* receiver_buffer =
44      assembler->LoadObjectField(receiver, JSTypedArray::kBufferOffset);
45  Label if_receiverisneutered(assembler, Label::kDeferred);
46  assembler->GotoIf(assembler->IsDetachedBuffer(receiver_buffer),
47                    &if_receiverisneutered);
48  assembler->Return(assembler->LoadObjectField(receiver, object_offset));
49
50  assembler->Bind(&if_receiverisneutered);
51  {
52    // The {receiver}s buffer was neutered, default to zero.
53    assembler->Return(assembler->SmiConstant(0));
54  }
55
56  assembler->Bind(&if_receiverisincompatible);
57  {
58    // The {receiver} is not a valid JSGeneratorObject.
59    Node* result = assembler->CallRuntime(
60        Runtime::kThrowIncompatibleMethodReceiver, context,
61        assembler->HeapConstant(assembler->factory()->NewStringFromAsciiChecked(
62            method_name, TENURED)),
63        receiver);
64    assembler->Return(result);  // Never reached.
65  }
66}
67
68}  // namespace
69
70// ES6 section 22.2.3.2 get %TypedArray%.prototype.byteLength
71void Builtins::Generate_TypedArrayPrototypeByteLength(
72    CodeStubAssembler* assembler) {
73  Generate_TypedArrayProtoypeGetter(assembler,
74                                    "get TypedArray.prototype.byteLength",
75                                    JSTypedArray::kByteLengthOffset);
76}
77
78// ES6 section 22.2.3.3 get %TypedArray%.prototype.byteOffset
79void Builtins::Generate_TypedArrayPrototypeByteOffset(
80    CodeStubAssembler* assembler) {
81  Generate_TypedArrayProtoypeGetter(assembler,
82                                    "get TypedArray.prototype.byteOffset",
83                                    JSTypedArray::kByteOffsetOffset);
84}
85
86// ES6 section 22.2.3.18 get %TypedArray%.prototype.length
87void Builtins::Generate_TypedArrayPrototypeLength(
88    CodeStubAssembler* assembler) {
89  Generate_TypedArrayProtoypeGetter(assembler,
90                                    "get TypedArray.prototype.length",
91                                    JSTypedArray::kLengthOffset);
92}
93
94namespace {
95
96template <IterationKind kIterationKind>
97void Generate_TypedArrayPrototypeIterationMethod(CodeStubAssembler* assembler,
98                                                 const char* method_name) {
99  typedef compiler::Node Node;
100  typedef CodeStubAssembler::Label Label;
101  typedef CodeStubAssembler::Variable Variable;
102
103  Node* receiver = assembler->Parameter(0);
104  Node* context = assembler->Parameter(3);
105
106  Label throw_bad_receiver(assembler, Label::kDeferred);
107  Label throw_typeerror(assembler, Label::kDeferred);
108
109  assembler->GotoIf(assembler->TaggedIsSmi(receiver), &throw_bad_receiver);
110
111  Node* map = assembler->LoadMap(receiver);
112  Node* instance_type = assembler->LoadMapInstanceType(map);
113  assembler->GotoIf(
114      assembler->Word32NotEqual(instance_type,
115                                assembler->Int32Constant(JS_TYPED_ARRAY_TYPE)),
116      &throw_bad_receiver);
117
118  // Check if the {receiver}'s JSArrayBuffer was neutered.
119  Node* receiver_buffer =
120      assembler->LoadObjectField(receiver, JSTypedArray::kBufferOffset);
121  Label if_receiverisneutered(assembler, Label::kDeferred);
122  assembler->GotoIf(assembler->IsDetachedBuffer(receiver_buffer),
123                    &if_receiverisneutered);
124
125  assembler->Return(assembler->CreateArrayIterator(receiver, map, instance_type,
126                                                   context, kIterationKind));
127
128  Variable var_message(assembler, MachineRepresentation::kTagged);
129  assembler->Bind(&throw_bad_receiver);
130  var_message.Bind(
131      assembler->SmiConstant(Smi::FromInt(MessageTemplate::kNotTypedArray)));
132  assembler->Goto(&throw_typeerror);
133
134  assembler->Bind(&if_receiverisneutered);
135  var_message.Bind(assembler->SmiConstant(
136      Smi::FromInt(MessageTemplate::kDetachedOperation)));
137  assembler->Goto(&throw_typeerror);
138
139  assembler->Bind(&throw_typeerror);
140  {
141    Node* arg1 = assembler->HeapConstant(
142        assembler->isolate()->factory()->NewStringFromAsciiChecked(method_name,
143                                                                   TENURED));
144    Node* result = assembler->CallRuntime(Runtime::kThrowTypeError, context,
145                                          var_message.value(), arg1);
146    assembler->Return(result);
147  }
148}
149}  // namespace
150
151void Builtins::Generate_TypedArrayPrototypeValues(
152    CodeStubAssembler* assembler) {
153  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kValues>(
154      assembler, "%TypedArray%.prototype.values()");
155}
156
157void Builtins::Generate_TypedArrayPrototypeEntries(
158    CodeStubAssembler* assembler) {
159  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kEntries>(
160      assembler, "%TypedArray%.prototype.entries()");
161}
162
163void Builtins::Generate_TypedArrayPrototypeKeys(CodeStubAssembler* assembler) {
164  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kKeys>(
165      assembler, "%TypedArray%.prototype.keys()");
166}
167
168}  // namespace internal
169}  // namespace v8
170