v8
V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++.
Loading...
Searching...
No Matches
builtins-number-gen.cc
Go to the documentation of this file.
1// Copyright 2017 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-utils-gen.h"
6#include "src/builtins/builtins.h"
7#include "src/codegen/code-stub-assembler-inl.h"
8#include "src/ic/binary-op-assembler.h"
9#include "src/ic/unary-op-assembler.h"
10
11namespace v8 {
12namespace internal {
13
14#include "src/codegen/define-code-stub-assembler-macros.inc"
15
16// -----------------------------------------------------------------------------
17// ES6 section 20.1 Number Objects
18
19#define DEF_BINOP(Name, Generator) \
20 TF_BUILTIN(Name, CodeStubAssembler) { \
21 auto lhs = Parameter<Object>(Descriptor::kLeft); \
22 auto rhs = Parameter<Object>(Descriptor::kRight); \
23 auto context = Parameter<Context>(Descriptor::kContext); \
24 auto feedback_vector = \
25 Parameter<FeedbackVector>(Descriptor::kFeedbackVector); \
26 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
27 \
28 BinaryOpAssembler binop_asm(state()); \
29 TNode<Object> result = \
30 binop_asm.Generator([&]() { return context; }, lhs, rhs, slot, \
31 [&]() { return feedback_vector; }, \
32 UpdateFeedbackMode::kGuaranteedFeedback, false); \
33 \
34 Return(result); \
35 }
36DEF_BINOP(Add_WithFeedback, Generate_AddWithFeedback)
37DEF_BINOP(Subtract_WithFeedback, Generate_SubtractWithFeedback)
38DEF_BINOP(Multiply_WithFeedback, Generate_MultiplyWithFeedback)
39DEF_BINOP(Divide_WithFeedback, Generate_DivideWithFeedback)
40DEF_BINOP(Modulus_WithFeedback, Generate_ModulusWithFeedback)
41DEF_BINOP(Exponentiate_WithFeedback, Generate_ExponentiateWithFeedback)
42DEF_BINOP(BitwiseOr_WithFeedback, Generate_BitwiseOrWithFeedback)
43DEF_BINOP(BitwiseXor_WithFeedback, Generate_BitwiseXorWithFeedback)
44DEF_BINOP(BitwiseAnd_WithFeedback, Generate_BitwiseAndWithFeedback)
45DEF_BINOP(ShiftLeft_WithFeedback, Generate_ShiftLeftWithFeedback)
46DEF_BINOP(ShiftRight_WithFeedback, Generate_ShiftRightWithFeedback)
47DEF_BINOP(ShiftRightLogical_WithFeedback,
48 Generate_ShiftRightLogicalWithFeedback)
49#undef DEF_BINOP
50
51#define DEF_BINOP(Name, Generator) \
52 TF_BUILTIN(Name, CodeStubAssembler) { \
53 auto lhs = Parameter<Object>(Descriptor::kLeft); \
54 auto rhs = Parameter<Object>(Descriptor::kRight); \
55 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
56 \
57 BinaryOpAssembler binop_asm(state()); \
58 TNode<Object> result = binop_asm.Generator( \
59 [&]() { return LoadContextFromBaseline(); }, lhs, rhs, slot, \
60 [&]() { return LoadFeedbackVectorFromBaseline(); }, \
61 UpdateFeedbackMode::kGuaranteedFeedback, false); \
62 \
63 Return(result); \
64 }
65DEF_BINOP(Add_Baseline, Generate_AddWithFeedback)
66DEF_BINOP(Subtract_Baseline, Generate_SubtractWithFeedback)
67DEF_BINOP(Multiply_Baseline, Generate_MultiplyWithFeedback)
68DEF_BINOP(Divide_Baseline, Generate_DivideWithFeedback)
69DEF_BINOP(Modulus_Baseline, Generate_ModulusWithFeedback)
70DEF_BINOP(Exponentiate_Baseline, Generate_ExponentiateWithFeedback)
71DEF_BINOP(BitwiseOr_Baseline, Generate_BitwiseOrWithFeedback)
72DEF_BINOP(BitwiseXor_Baseline, Generate_BitwiseXorWithFeedback)
73DEF_BINOP(BitwiseAnd_Baseline, Generate_BitwiseAndWithFeedback)
74DEF_BINOP(ShiftLeft_Baseline, Generate_ShiftLeftWithFeedback)
75DEF_BINOP(ShiftRight_Baseline, Generate_ShiftRightWithFeedback)
76DEF_BINOP(ShiftRightLogical_Baseline, Generate_ShiftRightLogicalWithFeedback)
77#undef DEF_BINOP
78
79#define DEF_BINOP_RHS_SMI(Name, Generator) \
80 TF_BUILTIN(Name, CodeStubAssembler) { \
81 auto lhs = Parameter<Object>(Descriptor::kLeft); \
82 auto rhs = Parameter<Object>(Descriptor::kRight); \
83 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
84 \
85 BinaryOpAssembler binop_asm(state()); \
86 TNode<Object> result = binop_asm.Generator( \
87 [&]() { return LoadContextFromBaseline(); }, lhs, rhs, slot, \
88 [&]() { return LoadFeedbackVectorFromBaseline(); }, \
89 UpdateFeedbackMode::kGuaranteedFeedback, true); \
90 \
91 Return(result); \
92 }
93DEF_BINOP_RHS_SMI(AddSmi_Baseline, Generate_AddWithFeedback)
94DEF_BINOP_RHS_SMI(SubtractSmi_Baseline, Generate_SubtractWithFeedback)
95DEF_BINOP_RHS_SMI(MultiplySmi_Baseline, Generate_MultiplyWithFeedback)
96DEF_BINOP_RHS_SMI(DivideSmi_Baseline, Generate_DivideWithFeedback)
97DEF_BINOP_RHS_SMI(ModulusSmi_Baseline, Generate_ModulusWithFeedback)
98DEF_BINOP_RHS_SMI(ExponentiateSmi_Baseline, Generate_ExponentiateWithFeedback)
99DEF_BINOP_RHS_SMI(BitwiseOrSmi_Baseline, Generate_BitwiseOrWithFeedback)
100DEF_BINOP_RHS_SMI(BitwiseXorSmi_Baseline, Generate_BitwiseXorWithFeedback)
101DEF_BINOP_RHS_SMI(BitwiseAndSmi_Baseline, Generate_BitwiseAndWithFeedback)
102DEF_BINOP_RHS_SMI(ShiftLeftSmi_Baseline, Generate_ShiftLeftWithFeedback)
103DEF_BINOP_RHS_SMI(ShiftRightSmi_Baseline, Generate_ShiftRightWithFeedback)
104DEF_BINOP_RHS_SMI(ShiftRightLogicalSmi_Baseline,
105 Generate_ShiftRightLogicalWithFeedback)
106#undef DEF_BINOP_RHS_SMI
107
108#define DEF_UNOP(Name, Generator) \
109 TF_BUILTIN(Name, CodeStubAssembler) { \
110 auto value = Parameter<Object>(Descriptor::kValue); \
111 auto context = Parameter<Context>(Descriptor::kContext); \
112 auto feedback_vector = \
113 Parameter<FeedbackVector>(Descriptor::kFeedbackVector); \
114 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
115 \
116 UnaryOpAssembler a(state()); \
117 TNode<Object> result = \
118 a.Generator(context, value, slot, feedback_vector, \
119 UpdateFeedbackMode::kGuaranteedFeedback); \
120 \
121 Return(result); \
122 }
123#ifndef V8_ENABLE_EXPERIMENTAL_TSA_BUILTINS
124DEF_UNOP(BitwiseNot_WithFeedback, Generate_BitwiseNotWithFeedback)
125#endif
126DEF_UNOP(Decrement_WithFeedback, Generate_DecrementWithFeedback)
127DEF_UNOP(Increment_WithFeedback, Generate_IncrementWithFeedback)
128DEF_UNOP(Negate_WithFeedback, Generate_NegateWithFeedback)
129#undef DEF_UNOP
130
131#define DEF_UNOP(Name, Generator) \
132 TF_BUILTIN(Name, CodeStubAssembler) { \
133 auto value = Parameter<Object>(Descriptor::kValue); \
134 auto context = LoadContextFromBaseline(); \
135 auto feedback_vector = LoadFeedbackVectorFromBaseline(); \
136 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
137 \
138 UnaryOpAssembler a(state()); \
139 TNode<Object> result = \
140 a.Generator(context, value, slot, feedback_vector, \
141 UpdateFeedbackMode::kGuaranteedFeedback); \
142 \
143 Return(result); \
144 }
145DEF_UNOP(BitwiseNot_Baseline, Generate_BitwiseNotWithFeedback)
146DEF_UNOP(Decrement_Baseline, Generate_DecrementWithFeedback)
147DEF_UNOP(Increment_Baseline, Generate_IncrementWithFeedback)
148DEF_UNOP(Negate_Baseline, Generate_NegateWithFeedback)
149#undef DEF_UNOP
150
151#define DEF_COMPARE(Name) \
152 TF_BUILTIN(Name##_WithFeedback, CodeStubAssembler) { \
153 auto lhs = Parameter<Object>(Descriptor::kLeft); \
154 auto rhs = Parameter<Object>(Descriptor::kRight); \
155 auto context = Parameter<Context>(Descriptor::kContext); \
156 auto feedback_vector = \
157 Parameter<FeedbackVector>(Descriptor::kFeedbackVector); \
158 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
159 \
160 TVARIABLE(Smi, var_type_feedback); \
161 TVARIABLE(Object, var_exception); \
162 Label if_exception(this, Label::kDeferred); \
163 TNode<Boolean> result; \
164 { \
165 ScopedExceptionHandler handler(this, &if_exception, &var_exception); \
166 result = RelationalComparison(Operation::k##Name, lhs, rhs, context, \
167 &var_type_feedback); \
168 } \
169 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot); \
170 \
171 Return(result); \
172 BIND(&if_exception); \
173 { \
174 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot); \
175 CallRuntime(Runtime::kReThrow, context, var_exception.value()); \
176 Unreachable(); \
177 } \
178 }
179DEF_COMPARE(LessThan)
180DEF_COMPARE(LessThanOrEqual)
181DEF_COMPARE(GreaterThan)
182DEF_COMPARE(GreaterThanOrEqual)
183#undef DEF_COMPARE
184
185#define DEF_COMPARE(Name) \
186 TF_BUILTIN(Name##_Baseline, CodeStubAssembler) { \
187 auto lhs = Parameter<Object>(Descriptor::kLeft); \
188 auto rhs = Parameter<Object>(Descriptor::kRight); \
189 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot); \
190 \
191 TVARIABLE(Smi, var_type_feedback); \
192 TVARIABLE(Object, var_exception); \
193 Label if_exception(this, Label::kDeferred); \
194 TNode<Boolean> result; \
195 { \
196 ScopedExceptionHandler handler(this, &if_exception, &var_exception); \
197 result = RelationalComparison( \
198 Operation::k##Name, lhs, rhs, \
199 [&]() { return LoadContextFromBaseline(); }, &var_type_feedback); \
200 } \
201 auto feedback_vector = LoadFeedbackVectorFromBaseline(); \
202 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot); \
203 \
204 Return(result); \
205 BIND(&if_exception); \
206 { \
207 feedback_vector = LoadFeedbackVectorFromBaseline(); \
208 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot); \
209 CallRuntime(Runtime::kReThrow, LoadContextFromBaseline(), \
210 var_exception.value()); \
211 Unreachable(); \
212 } \
213 }
214DEF_COMPARE(LessThan)
215DEF_COMPARE(LessThanOrEqual)
216DEF_COMPARE(GreaterThan)
217DEF_COMPARE(GreaterThanOrEqual)
218#undef DEF_COMPARE
219
220TF_BUILTIN(Equal_WithFeedback, CodeStubAssembler) {
221 auto lhs = Parameter<Object>(Descriptor::kLeft);
222 auto rhs = Parameter<Object>(Descriptor::kRight);
223 auto context = Parameter<Context>(Descriptor::kContext);
224 auto feedback_vector = Parameter<FeedbackVector>(Descriptor::kFeedbackVector);
225 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);
226
227 TVARIABLE(Smi, var_type_feedback);
228 TVARIABLE(Object, var_exception);
229 Label if_exception(this, Label::kDeferred);
230 TNode<Boolean> result;
231 {
232 ScopedExceptionHandler handler(this, &if_exception, &var_exception);
233 result = Equal(lhs, rhs, [&]() { return context; }, &var_type_feedback);
234 }
235 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot);
236 Return(result);
237
238 BIND(&if_exception);
239 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot);
240 CallRuntime(Runtime::kReThrow, LoadContextFromBaseline(),
241 var_exception.value());
242 Unreachable();
243}
244
245TF_BUILTIN(StrictEqual_WithFeedback, CodeStubAssembler) {
246 auto lhs = Parameter<Object>(Descriptor::kLeft);
247 auto rhs = Parameter<Object>(Descriptor::kRight);
248 auto feedback_vector = Parameter<FeedbackVector>(Descriptor::kFeedbackVector);
249 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);
250
251 TVARIABLE(Smi, var_type_feedback);
252 TNode<Boolean> result = StrictEqual(lhs, rhs, &var_type_feedback);
253 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot);
254
255 Return(result);
256}
257
258TF_BUILTIN(Equal_Baseline, CodeStubAssembler) {
259 auto lhs = Parameter<Object>(Descriptor::kLeft);
260 auto rhs = Parameter<Object>(Descriptor::kRight);
261 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);
262
263 TVARIABLE(Smi, var_type_feedback);
264 TVARIABLE(Object, var_exception);
265 Label if_exception(this, Label::kDeferred);
266 TNode<Boolean> result;
267 {
268 ScopedExceptionHandler handler(this, &if_exception, &var_exception);
269 result = Equal(
270 lhs, rhs, [&]() { return LoadContextFromBaseline(); },
271 &var_type_feedback);
272 }
273 auto feedback_vector = LoadFeedbackVectorFromBaseline();
274 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot);
275 Return(result);
276
277 BIND(&if_exception);
278 {
279 feedback_vector = LoadFeedbackVectorFromBaseline();
280 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot);
281 CallRuntime(Runtime::kReThrow, LoadContextFromBaseline(),
282 var_exception.value());
283 Unreachable();
284 }
285}
286
287TF_BUILTIN(StrictEqual_Baseline, CodeStubAssembler) {
288 auto lhs = Parameter<Object>(Descriptor::kLeft);
289 auto rhs = Parameter<Object>(Descriptor::kRight);
290 auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);
291
292 TVARIABLE(Smi, var_type_feedback);
293 TNode<Boolean> result = StrictEqual(lhs, rhs, &var_type_feedback);
294 auto feedback_vector = LoadFeedbackVectorFromBaseline();
295 UpdateFeedback(var_type_feedback.value(), feedback_vector, slot);
296
297 Return(result);
298}
299
300#include "src/codegen/undef-code-stub-assembler-macros.inc"
301
302} // namespace internal
303} // namespace v8
BIND
#define BIND(label)
TVARIABLE
#define TVARIABLE(...)
DEF_BINOP_RHS_SMI
#define DEF_BINOP_RHS_SMI(Name, Generator)
DEF_UNOP
#define DEF_UNOP(Name, Generator)
Definition builtins-number-gen.cc:108
DEF_COMPARE
#define DEF_COMPARE(Name)
Definition builtins-number-gen.cc:151
DEF_BINOP
#define DEF_BINOP(Name, Generator)
Definition builtins-number-gen.cc:19
TF_BUILTIN
#define TF_BUILTIN(Name, AssemblerBase)
Definition builtins-utils-gen.h:30
context
TNode< Context > context
Definition js-call-reducer.cc:1495
result
ZoneVector< RpoNumber > & result
Definition jump-threading.cc:21
handler
MovableLabel handler
Definition liftoff-compiler.cc:9469