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 
8 namespace v8 {
9 namespace internal {
10 
11 // -----------------------------------------------------------------------------
12 // ES6 section 22.2 TypedArray Objects
13 
14 // ES6 section 22.2.3.1 get %TypedArray%.prototype.buffer
BUILTIN(TypedArrayPrototypeBuffer)15 BUILTIN(TypedArrayPrototypeBuffer) {
16   HandleScope scope(isolate);
17   CHECK_RECEIVER(JSTypedArray, typed_array, "get TypedArray.prototype.buffer");
18   return *typed_array->GetBuffer();
19 }
20 
21 namespace {
22 
Generate_TypedArrayProtoypeGetter(CodeStubAssembler * assembler,const char * method_name,int object_offset)23 void 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
Generate_TypedArrayPrototypeByteLength(CodeStubAssembler * assembler)71 void 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
Generate_TypedArrayPrototypeByteOffset(CodeStubAssembler * assembler)79 void 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
Generate_TypedArrayPrototypeLength(CodeStubAssembler * assembler)87 void Builtins::Generate_TypedArrayPrototypeLength(
88     CodeStubAssembler* assembler) {
89   Generate_TypedArrayProtoypeGetter(assembler,
90                                     "get TypedArray.prototype.length",
91                                     JSTypedArray::kLengthOffset);
92 }
93 
94 namespace {
95 
96 template <IterationKind kIterationKind>
Generate_TypedArrayPrototypeIterationMethod(CodeStubAssembler * assembler,const char * method_name)97 void 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 
Generate_TypedArrayPrototypeValues(CodeStubAssembler * assembler)151 void Builtins::Generate_TypedArrayPrototypeValues(
152     CodeStubAssembler* assembler) {
153   Generate_TypedArrayPrototypeIterationMethod<IterationKind::kValues>(
154       assembler, "%TypedArray%.prototype.values()");
155 }
156 
Generate_TypedArrayPrototypeEntries(CodeStubAssembler * assembler)157 void Builtins::Generate_TypedArrayPrototypeEntries(
158     CodeStubAssembler* assembler) {
159   Generate_TypedArrayPrototypeIterationMethod<IterationKind::kEntries>(
160       assembler, "%TypedArray%.prototype.entries()");
161 }
162 
Generate_TypedArrayPrototypeKeys(CodeStubAssembler * assembler)163 void Builtins::Generate_TypedArrayPrototypeKeys(CodeStubAssembler* assembler) {
164   Generate_TypedArrayPrototypeIterationMethod<IterationKind::kKeys>(
165       assembler, "%TypedArray%.prototype.keys()");
166 }
167 
168 }  // namespace internal
169 }  // namespace v8
170