Line data Source code
1 : // Copyright 2014 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/compiler/typer.h"
6 :
7 : #include <iomanip>
8 :
9 : #include "src/base/flags.h"
10 : #include "src/bootstrapper.h"
11 : #include "src/compiler/common-operator.h"
12 : #include "src/compiler/graph-reducer.h"
13 : #include "src/compiler/js-operator.h"
14 : #include "src/compiler/linkage.h"
15 : #include "src/compiler/loop-variable-optimizer.h"
16 : #include "src/compiler/node-properties.h"
17 : #include "src/compiler/node.h"
18 : #include "src/compiler/operation-typer.h"
19 : #include "src/compiler/simplified-operator.h"
20 : #include "src/compiler/type-cache.h"
21 : #include "src/objects-inl.h"
22 :
23 : namespace v8 {
24 : namespace internal {
25 : namespace compiler {
26 :
27 0 : class Typer::Decorator final : public GraphDecorator {
28 : public:
29 396090 : explicit Decorator(Typer* typer) : typer_(typer) {}
30 : void Decorate(Node* node) final;
31 :
32 : private:
33 : Typer* const typer_;
34 : };
35 :
36 396090 : Typer::Typer(Isolate* isolate, Flags flags, Graph* graph)
37 : : isolate_(isolate),
38 : flags_(flags),
39 : graph_(graph),
40 : decorator_(nullptr),
41 396090 : cache_(TypeCache::Get()),
42 1584360 : operation_typer_(isolate, zone()) {
43 : Zone* zone = this->zone();
44 : Factory* const factory = isolate->factory();
45 :
46 396090 : singleton_empty_string_ = Type::HeapConstant(factory->empty_string(), zone);
47 396090 : singleton_false_ = operation_typer_.singleton_false();
48 396090 : singleton_true_ = operation_typer_.singleton_true();
49 : falsish_ = Type::Union(
50 : Type::Undetectable(),
51 : Type::Union(Type::Union(singleton_false_, cache_.kZeroish, zone),
52 : Type::Union(singleton_empty_string_, Type::Hole(), zone),
53 : zone),
54 396090 : zone);
55 : truish_ = Type::Union(
56 : singleton_true_,
57 396090 : Type::Union(Type::DetectableReceiver(), Type::Symbol(), zone), zone);
58 :
59 396090 : decorator_ = new (zone) Decorator(this);
60 396090 : graph_->AddDecorator(decorator_);
61 396090 : }
62 :
63 :
64 396090 : Typer::~Typer() {
65 396090 : graph_->RemoveDecorator(decorator_);
66 396090 : }
67 :
68 :
69 2867352 : class Typer::Visitor : public Reducer {
70 : public:
71 : explicit Visitor(Typer* typer, LoopVariableOptimizer* induction_vars)
72 : : typer_(typer),
73 : induction_vars_(induction_vars),
74 2867353 : weakened_nodes_(typer->zone()) {}
75 :
76 31205208 : Reduction Reduce(Node* node) override {
77 31205208 : if (node->op()->ValueOutputCount() == 0) return NoChange();
78 23097472 : switch (node->opcode()) {
79 : #define DECLARE_CASE(x) \
80 : case IrOpcode::k##x: \
81 : return UpdateType(node, TypeBinaryOp(node, x##Typer));
82 23184 : JS_SIMPLE_BINOP_LIST(DECLARE_CASE)
83 : #undef DECLARE_CASE
84 :
85 : #define DECLARE_CASE(x) \
86 : case IrOpcode::k##x: \
87 : return UpdateType(node, Type##x(node));
88 395343 : DECLARE_CASE(Start)
89 221891 : DECLARE_CASE(IfException)
90 : // VALUE_OP_LIST without JS_SIMPLE_BINOP_LIST:
91 5730761 : COMMON_OP_LIST(DECLARE_CASE)
92 313686 : SIMPLIFIED_COMPARE_BINOP_LIST(DECLARE_CASE)
93 331692 : SIMPLIFIED_OTHER_OP_LIST(DECLARE_CASE)
94 138841 : JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
95 821 : JS_OBJECT_OP_LIST(DECLARE_CASE)
96 420237 : JS_CONTEXT_OP_LIST(DECLARE_CASE)
97 270712 : JS_OTHER_OP_LIST(DECLARE_CASE)
98 : #undef DECLARE_CASE
99 :
100 : #define DECLARE_CASE(x) \
101 : case IrOpcode::k##x: \
102 : return UpdateType(node, TypeBinaryOp(node, x));
103 0 : SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_CASE)
104 269269 : SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_CASE)
105 : #undef DECLARE_CASE
106 :
107 : #define DECLARE_CASE(x) \
108 : case IrOpcode::k##x: \
109 : return UpdateType(node, TypeUnaryOp(node, x));
110 0 : SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_CASE)
111 12647 : SIMPLIFIED_SPECULATIVE_NUMBER_UNOP_LIST(DECLARE_CASE)
112 : #undef DECLARE_CASE
113 :
114 : #define DECLARE_CASE(x) case IrOpcode::k##x:
115 : DECLARE_CASE(Loop)
116 : DECLARE_CASE(Branch)
117 : DECLARE_CASE(IfTrue)
118 : DECLARE_CASE(IfFalse)
119 : DECLARE_CASE(IfSuccess)
120 : DECLARE_CASE(Switch)
121 : DECLARE_CASE(IfValue)
122 : DECLARE_CASE(IfDefault)
123 : DECLARE_CASE(Merge)
124 : DECLARE_CASE(Deoptimize)
125 : DECLARE_CASE(DeoptimizeIf)
126 : DECLARE_CASE(DeoptimizeUnless)
127 : DECLARE_CASE(TrapIf)
128 : DECLARE_CASE(TrapUnless)
129 : DECLARE_CASE(Return)
130 : DECLARE_CASE(TailCall)
131 : DECLARE_CASE(Terminate)
132 : DECLARE_CASE(OsrNormalEntry)
133 : DECLARE_CASE(OsrLoopEntry)
134 : DECLARE_CASE(Throw)
135 : DECLARE_CASE(End)
136 : SIMPLIFIED_CHANGE_OP_LIST(DECLARE_CASE)
137 : SIMPLIFIED_CHECKED_OP_LIST(DECLARE_CASE)
138 : MACHINE_SIMD_OP_LIST(DECLARE_CASE)
139 : MACHINE_OP_LIST(DECLARE_CASE)
140 : #undef DECLARE_CASE
141 : break;
142 : }
143 : return NoChange();
144 : }
145 :
146 2471901 : Type* TypeNode(Node* node) {
147 2471562 : switch (node->opcode()) {
148 : #define DECLARE_CASE(x) \
149 : case IrOpcode::k##x: return TypeBinaryOp(node, x##Typer);
150 571 : JS_SIMPLE_BINOP_LIST(DECLARE_CASE)
151 : #undef DECLARE_CASE
152 :
153 : #define DECLARE_CASE(x) case IrOpcode::k##x: return Type##x(node);
154 : DECLARE_CASE(Start)
155 0 : DECLARE_CASE(IfException)
156 : // VALUE_OP_LIST without JS_SIMPLE_BINOP_LIST:
157 670092 : COMMON_OP_LIST(DECLARE_CASE)
158 20599 : SIMPLIFIED_COMPARE_BINOP_LIST(DECLARE_CASE)
159 416821 : SIMPLIFIED_OTHER_OP_LIST(DECLARE_CASE)
160 3746 : JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
161 1 : JS_OBJECT_OP_LIST(DECLARE_CASE)
162 175866 : JS_CONTEXT_OP_LIST(DECLARE_CASE)
163 719 : JS_OTHER_OP_LIST(DECLARE_CASE)
164 : #undef DECLARE_CASE
165 :
166 : #define DECLARE_CASE(x) \
167 : case IrOpcode::k##x: \
168 : return TypeBinaryOp(node, x);
169 10021 : SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_CASE)
170 100 : SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_CASE)
171 : #undef DECLARE_CASE
172 :
173 : #define DECLARE_CASE(x) \
174 : case IrOpcode::k##x: \
175 : return TypeUnaryOp(node, x);
176 320 : SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_CASE)
177 0 : SIMPLIFIED_SPECULATIVE_NUMBER_UNOP_LIST(DECLARE_CASE)
178 : #undef DECLARE_CASE
179 :
180 : #define DECLARE_CASE(x) case IrOpcode::k##x:
181 : DECLARE_CASE(Loop)
182 : DECLARE_CASE(Branch)
183 : DECLARE_CASE(IfTrue)
184 : DECLARE_CASE(IfFalse)
185 : DECLARE_CASE(IfSuccess)
186 : DECLARE_CASE(Switch)
187 : DECLARE_CASE(IfValue)
188 : DECLARE_CASE(IfDefault)
189 : DECLARE_CASE(Merge)
190 : DECLARE_CASE(Deoptimize)
191 : DECLARE_CASE(DeoptimizeIf)
192 : DECLARE_CASE(DeoptimizeUnless)
193 : DECLARE_CASE(TrapIf)
194 : DECLARE_CASE(TrapUnless)
195 : DECLARE_CASE(Return)
196 : DECLARE_CASE(TailCall)
197 : DECLARE_CASE(Terminate)
198 : DECLARE_CASE(OsrNormalEntry)
199 : DECLARE_CASE(OsrLoopEntry)
200 : DECLARE_CASE(Throw)
201 : DECLARE_CASE(End)
202 : SIMPLIFIED_CHANGE_OP_LIST(DECLARE_CASE)
203 : SIMPLIFIED_CHECKED_OP_LIST(DECLARE_CASE)
204 : MACHINE_SIMD_OP_LIST(DECLARE_CASE)
205 : MACHINE_OP_LIST(DECLARE_CASE)
206 : #undef DECLARE_CASE
207 : break;
208 : }
209 0 : UNREACHABLE();
210 : return nullptr;
211 : }
212 :
213 : Type* TypeConstant(Handle<Object> value);
214 :
215 : private:
216 : Typer* typer_;
217 : LoopVariableOptimizer* induction_vars_;
218 : ZoneSet<NodeId> weakened_nodes_;
219 :
220 : #define DECLARE_METHOD(x) inline Type* Type##x(Node* node);
221 : DECLARE_METHOD(Start)
222 : DECLARE_METHOD(IfException)
223 : COMMON_OP_LIST(DECLARE_METHOD)
224 : SIMPLIFIED_COMPARE_BINOP_LIST(DECLARE_METHOD)
225 : SIMPLIFIED_OTHER_OP_LIST(DECLARE_METHOD)
226 : JS_OP_LIST(DECLARE_METHOD)
227 : #undef DECLARE_METHOD
228 :
229 : Type* TypeOrNone(Node* node) {
230 : return NodeProperties::IsTyped(node) ? NodeProperties::GetType(node)
231 6458916 : : Type::None();
232 : }
233 :
234 : Type* Operand(Node* node, int i) {
235 6423533 : Node* operand_node = NodeProperties::GetValueInput(node, i);
236 : return TypeOrNone(operand_node);
237 : }
238 :
239 : Type* Weaken(Node* node, Type* current_type, Type* previous_type);
240 :
241 : Zone* zone() { return typer_->zone(); }
242 : Isolate* isolate() { return typer_->isolate(); }
243 : Graph* graph() { return typer_->graph(); }
244 :
245 : void SetWeakened(NodeId node_id) { weakened_nodes_.insert(node_id); }
246 : bool IsWeakened(NodeId node_id) {
247 : return weakened_nodes_.find(node_id) != weakened_nodes_.end();
248 : }
249 :
250 : typedef Type* (*UnaryTyperFun)(Type*, Typer* t);
251 : typedef Type* (*BinaryTyperFun)(Type*, Type*, Typer* t);
252 :
253 : Type* TypeUnaryOp(Node* node, UnaryTyperFun);
254 : Type* TypeBinaryOp(Node* node, BinaryTyperFun);
255 :
256 : enum ComparisonOutcomeFlags {
257 : kComparisonTrue = 1,
258 : kComparisonFalse = 2,
259 : kComparisonUndefined = 4
260 : };
261 : typedef base::Flags<ComparisonOutcomeFlags> ComparisonOutcome;
262 :
263 : static ComparisonOutcome Invert(ComparisonOutcome, Typer*);
264 : static Type* FalsifyUndefined(ComparisonOutcome, Typer*);
265 :
266 : static Type* ToPrimitive(Type*, Typer*);
267 : static Type* ToBoolean(Type*, Typer*);
268 : static Type* ToInteger(Type*, Typer*);
269 : static Type* ToLength(Type*, Typer*);
270 : static Type* ToName(Type*, Typer*);
271 : static Type* ToNumber(Type*, Typer*);
272 : static Type* ToObject(Type*, Typer*);
273 : static Type* ToString(Type*, Typer*);
274 : #define DECLARE_METHOD(Name) \
275 : static Type* Name(Type* type, Typer* t) { \
276 : return t->operation_typer_.Name(type); \
277 : }
278 76029 : SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_METHOD)
279 12426 : SIMPLIFIED_SPECULATIVE_NUMBER_UNOP_LIST(DECLARE_METHOD)
280 : #undef DECLARE_METHOD
281 : #define DECLARE_METHOD(Name) \
282 : static Type* Name(Type* lhs, Type* rhs, Typer* t) { \
283 : return t->operation_typer_.Name(lhs, rhs); \
284 : }
285 284966 : SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_METHOD)
286 348548 : SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_METHOD)
287 : #undef DECLARE_METHOD
288 :
289 : static Type* ObjectIsDetectableCallable(Type*, Typer*);
290 : static Type* ObjectIsNaN(Type*, Typer*);
291 : static Type* ObjectIsNonCallable(Type*, Typer*);
292 : static Type* ObjectIsNumber(Type*, Typer*);
293 : static Type* ObjectIsReceiver(Type*, Typer*);
294 : static Type* ObjectIsSmi(Type*, Typer*);
295 : static Type* ObjectIsString(Type*, Typer*);
296 : static Type* ObjectIsSymbol(Type*, Typer*);
297 : static Type* ObjectIsUndetectable(Type*, Typer*);
298 :
299 : static ComparisonOutcome JSCompareTyper(Type*, Type*, Typer*);
300 : static ComparisonOutcome NumberCompareTyper(Type*, Type*, Typer*);
301 :
302 : #define DECLARE_METHOD(x) static Type* x##Typer(Type*, Type*, Typer*);
303 : JS_SIMPLE_BINOP_LIST(DECLARE_METHOD)
304 : #undef DECLARE_METHOD
305 :
306 : static Type* JSCallTyper(Type*, Typer*);
307 :
308 : static Type* NumberEqualTyper(Type*, Type*, Typer*);
309 : static Type* NumberLessThanTyper(Type*, Type*, Typer*);
310 : static Type* NumberLessThanOrEqualTyper(Type*, Type*, Typer*);
311 : static Type* ReferenceEqualTyper(Type*, Type*, Typer*);
312 : static Type* StringFromCharCodeTyper(Type*, Typer*);
313 : static Type* StringFromCodePointTyper(Type*, Typer*);
314 :
315 25919050 : Reduction UpdateType(Node* node, Type* current) {
316 23097452 : if (NodeProperties::IsTyped(node)) {
317 : // Widen the type of a previously typed node.
318 : Type* previous = NodeProperties::GetType(node);
319 2821598 : if (node->opcode() == IrOpcode::kPhi ||
320 : node->opcode() == IrOpcode::kInductionVariablePhi) {
321 : // Speed up termination in the presence of range types:
322 276454 : current = Weaken(node, current, previous);
323 : }
324 :
325 2821598 : CHECK(previous->Is(current));
326 :
327 : NodeProperties::SetType(node, current);
328 2821598 : if (!current->Is(previous)) {
329 : // If something changed, revisit all uses.
330 : return Changed(node);
331 : }
332 : return NoChange();
333 : } else {
334 : // No previous type, simply update the type.
335 : NodeProperties::SetType(node, current);
336 : return Changed(node);
337 : }
338 : }
339 : };
340 :
341 896 : void Typer::Run() { Run(NodeVector(zone()), nullptr); }
342 :
343 395791 : void Typer::Run(const NodeVector& roots,
344 : LoopVariableOptimizer* induction_vars) {
345 395791 : if (induction_vars != nullptr) {
346 395343 : induction_vars->ChangeToInductionVariablePhis();
347 : }
348 : Visitor visitor(this, induction_vars);
349 791582 : GraphReducer graph_reducer(zone(), graph());
350 395791 : graph_reducer.AddReducer(&visitor);
351 5816345 : for (Node* const root : roots) graph_reducer.ReduceNode(root);
352 395791 : graph_reducer.ReduceGraph();
353 :
354 395791 : if (induction_vars != nullptr) {
355 395343 : induction_vars->ChangeToPhisAndInsertGuards();
356 : }
357 395791 : }
358 :
359 3629641 : void Typer::Decorator::Decorate(Node* node) {
360 7259282 : if (node->op()->ValueOutputCount() > 0) {
361 : // Only eagerly type-decorate nodes with known input types.
362 : // Other cases will generally require a proper fixpoint iteration with Run.
363 : bool is_typed = NodeProperties::IsTyped(node);
364 2538552 : if (is_typed || NodeProperties::AllValueInputsAreTyped(node)) {
365 2471562 : Visitor typing(typer_, nullptr);
366 2471562 : Type* type = typing.TypeNode(node);
367 2471561 : if (is_typed) {
368 : type = Type::Intersect(type, NodeProperties::GetType(node),
369 0 : typer_->zone());
370 : }
371 : NodeProperties::SetType(node, type);
372 : }
373 : }
374 3629640 : }
375 :
376 :
377 : // -----------------------------------------------------------------------------
378 :
379 : // Helper functions that lift a function f on types to a function on bounds,
380 : // and uses that to type the given node. Note that f is never called with None
381 : // as an argument.
382 :
383 :
384 594623 : Type* Typer::Visitor::TypeUnaryOp(Node* node, UnaryTyperFun f) {
385 : Type* input = Operand(node, 0);
386 594623 : return input->IsInhabited() ? f(input, typer_) : Type::None();
387 : }
388 :
389 :
390 1536459 : Type* Typer::Visitor::TypeBinaryOp(Node* node, BinaryTyperFun f) {
391 : Type* left = Operand(node, 0);
392 : Type* right = Operand(node, 1);
393 1395879 : return left->IsInhabited() && right->IsInhabited() ? f(left, right, typer_)
394 2922827 : : Type::None();
395 : }
396 :
397 :
398 0 : Typer::Visitor::ComparisonOutcome Typer::Visitor::Invert(
399 : ComparisonOutcome outcome, Typer* t) {
400 : ComparisonOutcome result(0);
401 15053 : if ((outcome & kComparisonUndefined) != 0) result |= kComparisonUndefined;
402 15053 : if ((outcome & kComparisonTrue) != 0) result |= kComparisonFalse;
403 15053 : if ((outcome & kComparisonFalse) != 0) result |= kComparisonTrue;
404 0 : return result;
405 : }
406 :
407 :
408 0 : Type* Typer::Visitor::FalsifyUndefined(ComparisonOutcome outcome, Typer* t) {
409 104007 : if ((outcome & kComparisonFalse) != 0 ||
410 : (outcome & kComparisonUndefined) != 0) {
411 : return (outcome & kComparisonTrue) != 0 ? Type::Boolean()
412 98632 : : t->singleton_false_;
413 : }
414 : // Type should be non empty, so we know it should be true.
415 : DCHECK((outcome & kComparisonTrue) != 0);
416 2153 : return t->singleton_true_;
417 : }
418 :
419 : // Type conversion.
420 :
421 408389 : Type* Typer::Visitor::ToPrimitive(Type* type, Typer* t) {
422 408389 : if (type->Is(Type::Primitive()) && !type->Maybe(Type::Receiver())) {
423 310454 : return type;
424 : }
425 : return Type::Primitive();
426 : }
427 :
428 :
429 118124 : Type* Typer::Visitor::ToBoolean(Type* type, Typer* t) {
430 118124 : if (type->Is(Type::Boolean())) return type;
431 166030 : if (type->Is(t->falsish_)) return t->singleton_false_;
432 164812 : if (type->Is(t->truish_)) return t->singleton_true_;
433 82083 : if (type->Is(Type::Number())) {
434 3070 : return t->operation_typer()->NumberToBoolean(type);
435 : }
436 : return Type::Boolean();
437 : }
438 :
439 :
440 : // static
441 682 : Type* Typer::Visitor::ToInteger(Type* type, Typer* t) {
442 : // ES6 section 7.1.4 ToInteger ( argument )
443 : type = ToNumber(type, t);
444 1364 : if (type->Is(t->cache_.kIntegerOrMinusZero)) return type;
445 1272 : if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) {
446 : return Type::Union(
447 : Type::Intersect(type, t->cache_.kIntegerOrMinusZero, t->zone()),
448 10 : t->cache_.kSingletonZero, t->zone());
449 : }
450 626 : return t->cache_.kIntegerOrMinusZero;
451 : }
452 :
453 :
454 : // static
455 334 : Type* Typer::Visitor::ToLength(Type* type, Typer* t) {
456 : // ES6 section 7.1.15 ToLength ( argument )
457 334 : type = ToInteger(type, t);
458 334 : double min = type->Min();
459 334 : double max = type->Max();
460 334 : if (max <= 0.0) {
461 16 : return Type::NewConstant(0, t->zone());
462 : }
463 318 : if (min >= kMaxSafeInteger) {
464 4 : return Type::NewConstant(kMaxSafeInteger, t->zone());
465 : }
466 314 : if (min <= 0.0) min = 0.0;
467 314 : if (max >= kMaxSafeInteger) max = kMaxSafeInteger;
468 314 : return Type::Range(min, max, t->zone());
469 : }
470 :
471 :
472 : // static
473 1608 : Type* Typer::Visitor::ToName(Type* type, Typer* t) {
474 : // ES6 section 7.1.14 ToPropertyKey ( argument )
475 1608 : type = ToPrimitive(type, t);
476 1608 : if (type->Is(Type::Name())) return type;
477 1441 : if (type->Maybe(Type::Symbol())) return Type::Name();
478 124 : return ToString(type, t);
479 : }
480 :
481 :
482 : // static
483 32387 : Type* Typer::Visitor::ToNumber(Type* type, Typer* t) {
484 420340 : return t->operation_typer_.ToNumber(type);
485 : }
486 :
487 :
488 : // static
489 2522 : Type* Typer::Visitor::ToObject(Type* type, Typer* t) {
490 : // ES6 section 7.1.13 ToObject ( argument )
491 2522 : if (type->Is(Type::Receiver())) return type;
492 1462 : if (type->Is(Type::Primitive())) return Type::OtherObject();
493 1395 : if (!type->Maybe(Type::OtherUndetectable())) {
494 : return Type::DetectableReceiver();
495 : }
496 1391 : return Type::Receiver();
497 : }
498 :
499 :
500 : // static
501 2625 : Type* Typer::Visitor::ToString(Type* type, Typer* t) {
502 : // ES6 section 7.1.12 ToString ( argument )
503 2625 : type = ToPrimitive(type, t);
504 2625 : if (type->Is(Type::String())) return type;
505 : return Type::String();
506 : }
507 :
508 : // Type checks.
509 :
510 22584 : Type* Typer::Visitor::ObjectIsDetectableCallable(Type* type, Typer* t) {
511 22584 : if (type->Is(Type::DetectableCallable())) return t->singleton_true_;
512 22580 : if (!type->Maybe(Type::DetectableCallable())) return t->singleton_false_;
513 : return Type::Boolean();
514 : }
515 :
516 8569 : Type* Typer::Visitor::ObjectIsNaN(Type* type, Typer* t) {
517 8569 : if (type->Is(Type::NaN())) return t->singleton_true_;
518 8559 : if (!type->Maybe(Type::NaN())) return t->singleton_false_;
519 : return Type::Boolean();
520 : }
521 :
522 13167 : Type* Typer::Visitor::ObjectIsNonCallable(Type* type, Typer* t) {
523 13167 : if (type->Is(Type::NonCallable())) return t->singleton_true_;
524 13128 : if (!type->Maybe(Type::NonCallable())) return t->singleton_false_;
525 : return Type::Boolean();
526 : }
527 :
528 16197 : Type* Typer::Visitor::ObjectIsNumber(Type* type, Typer* t) {
529 16197 : if (type->Is(Type::Number())) return t->singleton_true_;
530 12778 : if (!type->Maybe(Type::Number())) return t->singleton_false_;
531 : return Type::Boolean();
532 : }
533 :
534 :
535 23336 : Type* Typer::Visitor::ObjectIsReceiver(Type* type, Typer* t) {
536 23336 : if (type->Is(Type::Receiver())) return t->singleton_true_;
537 20119 : if (!type->Maybe(Type::Receiver())) return t->singleton_false_;
538 : return Type::Boolean();
539 : }
540 :
541 :
542 4550 : Type* Typer::Visitor::ObjectIsSmi(Type* type, Typer* t) {
543 4550 : if (!type->Maybe(Type::SignedSmall())) return t->singleton_false_;
544 : return Type::Boolean();
545 : }
546 :
547 4893 : Type* Typer::Visitor::ObjectIsString(Type* type, Typer* t) {
548 4893 : if (type->Is(Type::String())) return t->singleton_true_;
549 4885 : if (!type->Maybe(Type::String())) return t->singleton_false_;
550 : return Type::Boolean();
551 : }
552 :
553 740 : Type* Typer::Visitor::ObjectIsSymbol(Type* type, Typer* t) {
554 740 : if (type->Is(Type::Symbol())) return t->singleton_true_;
555 740 : if (!type->Maybe(Type::Symbol())) return t->singleton_false_;
556 : return Type::Boolean();
557 : }
558 :
559 9589 : Type* Typer::Visitor::ObjectIsUndetectable(Type* type, Typer* t) {
560 9589 : if (type->Is(Type::Undetectable())) return t->singleton_true_;
561 9325 : if (!type->Maybe(Type::Undetectable())) return t->singleton_false_;
562 : return Type::Boolean();
563 : }
564 :
565 :
566 : // -----------------------------------------------------------------------------
567 :
568 :
569 : // Control operators.
570 :
571 : Type* Typer::Visitor::TypeStart(Node* node) { return Type::Internal(); }
572 :
573 : Type* Typer::Visitor::TypeIfException(Node* node) {
574 : return Type::NonInternal();
575 : }
576 :
577 : // Common operators.
578 :
579 2047912 : Type* Typer::Visitor::TypeParameter(Node* node) {
580 1023956 : Node* const start = node->InputAt(0);
581 : DCHECK_EQ(IrOpcode::kStart, start->opcode());
582 2047912 : int const parameter_count = start->op()->ValueOutputCount() - 4;
583 : DCHECK_LE(1, parameter_count);
584 1023956 : int const index = ParameterIndexOf(node->op());
585 1023956 : if (index == Linkage::kJSCallClosureParamIndex) {
586 : return Type::Function();
587 996200 : } else if (index == 0) {
588 775076 : if (typer_->flags() & Typer::kThisIsReceiver) {
589 : return Type::Receiver();
590 : } else {
591 : // Parameter[this] can be the_hole for derived class constructors.
592 86447 : return Type::Union(Type::Hole(), Type::NonInternal(), typer_->zone());
593 : }
594 608662 : } else if (index == Linkage::GetJSCallNewTargetParamIndex(parameter_count)) {
595 19752 : if (typer_->flags() & Typer::kNewTargetIsReceiver) {
596 : return Type::Receiver();
597 : } else {
598 9274 : return Type::Union(Type::Receiver(), Type::Undefined(), typer_->zone());
599 : }
600 598786 : } else if (index == Linkage::GetJSCallArgCountParamIndex(parameter_count)) {
601 0 : return Type::Range(0.0, Code::kMaxArguments, typer_->zone());
602 598786 : } else if (index == Linkage::GetJSCallContextParamIndex(parameter_count)) {
603 : return Type::OtherInternal();
604 : }
605 209256 : return Type::NonInternal();
606 : }
607 :
608 : Type* Typer::Visitor::TypeOsrValue(Node* node) { return Type::Any(); }
609 :
610 53845 : Type* Typer::Visitor::TypeOsrGuard(Node* node) {
611 53845 : switch (OsrGuardTypeOf(node->op())) {
612 : case OsrGuardType::kUninitialized:
613 : return Type::None();
614 : case OsrGuardType::kSignedSmall:
615 : return Type::SignedSmall();
616 : case OsrGuardType::kAny:
617 : return Type::Any();
618 : }
619 0 : UNREACHABLE();
620 : return nullptr;
621 : }
622 :
623 0 : Type* Typer::Visitor::TypeRetain(Node* node) {
624 0 : UNREACHABLE();
625 : return nullptr;
626 : }
627 :
628 0 : Type* Typer::Visitor::TypeInt32Constant(Node* node) {
629 0 : UNREACHABLE();
630 : return nullptr;
631 : }
632 :
633 0 : Type* Typer::Visitor::TypeInt64Constant(Node* node) {
634 0 : UNREACHABLE();
635 : return nullptr;
636 : }
637 :
638 0 : Type* Typer::Visitor::TypeRelocatableInt32Constant(Node* node) {
639 0 : UNREACHABLE();
640 : return nullptr;
641 : }
642 :
643 0 : Type* Typer::Visitor::TypeRelocatableInt64Constant(Node* node) {
644 0 : UNREACHABLE();
645 : return nullptr;
646 : }
647 :
648 0 : Type* Typer::Visitor::TypeFloat32Constant(Node* node) {
649 0 : UNREACHABLE();
650 : return nullptr;
651 : }
652 :
653 0 : Type* Typer::Visitor::TypeFloat64Constant(Node* node) {
654 0 : UNREACHABLE();
655 : return nullptr;
656 : }
657 :
658 2885681 : Type* Typer::Visitor::TypeNumberConstant(Node* node) {
659 2885681 : double number = OpParameter<double>(node);
660 2885681 : return Type::NewConstant(number, zone());
661 : }
662 :
663 : Type* Typer::Visitor::TypeHeapConstant(Node* node) {
664 3161751 : return TypeConstant(OpParameter<Handle<HeapObject>>(node));
665 : }
666 :
667 : Type* Typer::Visitor::TypeExternalConstant(Node* node) {
668 : return Type::ExternalPointer();
669 : }
670 :
671 : Type* Typer::Visitor::TypePointerConstant(Node* node) {
672 : return Type::ExternalPointer();
673 : }
674 :
675 16674 : Type* Typer::Visitor::TypeSelect(Node* node) {
676 16674 : return Type::Union(Operand(node, 1), Operand(node, 2), zone());
677 : }
678 :
679 2083429 : Type* Typer::Visitor::TypePhi(Node* node) {
680 729735 : int arity = node->op()->ValueInputCount();
681 : Type* type = Operand(node, 0);
682 2083429 : for (int i = 1; i < arity; ++i) {
683 1353694 : type = Type::Union(type, Operand(node, i), zone());
684 : }
685 729735 : return type;
686 : }
687 :
688 105305 : Type* Typer::Visitor::TypeInductionVariablePhi(Node* node) {
689 47316 : int arity = NodeProperties::GetControlInput(node)->op()->ControlInputCount();
690 : DCHECK_EQ(IrOpcode::kLoop, NodeProperties::GetControlInput(node)->opcode());
691 : DCHECK_EQ(2, NodeProperties::GetControlInput(node)->InputCount());
692 :
693 : Type* initial_type = Operand(node, 0);
694 : Type* increment_type = Operand(node, 2);
695 :
696 : // We only handle integer induction variables (otherwise ranges
697 : // do not apply and we cannot do anything).
698 130560 : if (!initial_type->Is(typer_->cache_.kInteger) ||
699 35928 : !increment_type->Is(typer_->cache_.kInteger)) {
700 : // Fallback to normal phi typing, but ensure monotonicity.
701 : // (Unfortunately, without baking in the previous type, monotonicity might
702 : // be violated because we might not yet have retyped the incrementing
703 : // operation even though the increment's type might been already reflected
704 : // in the induction variable phi.)
705 : Type* type = NodeProperties::IsTyped(node) ? NodeProperties::GetType(node)
706 11448 : : Type::None();
707 34344 : for (int i = 0; i < arity; ++i) {
708 22896 : type = Type::Union(type, Operand(node, i), zone());
709 : }
710 : return type;
711 : }
712 : // If we do not have enough type information for the initial value or
713 : // the increment, just return the initial value's type.
714 70980 : if (!initial_type->IsInhabited() ||
715 35112 : increment_type->Is(typer_->cache_.kSingletonZero)) {
716 : return initial_type;
717 : }
718 :
719 : // Now process the bounds.
720 70186 : auto res = induction_vars_->induction_variables().find(node->id());
721 : DCHECK(res != induction_vars_->induction_variables().end());
722 35093 : InductionVariable* induction_var = res->second;
723 :
724 : InductionVariable::ArithmeticType arithmetic_type = induction_var->Type();
725 :
726 35093 : double min = -V8_INFINITY;
727 35093 : double max = V8_INFINITY;
728 :
729 : double increment_min;
730 : double increment_max;
731 35093 : if (arithmetic_type == InductionVariable::ArithmeticType::kAddition) {
732 4023 : increment_min = increment_type->Min();
733 4023 : increment_max = increment_type->Max();
734 : } else {
735 : DCHECK(arithmetic_type == InductionVariable::ArithmeticType::kSubtraction);
736 31070 : increment_min = -increment_type->Max();
737 31070 : increment_max = -increment_type->Min();
738 : }
739 :
740 35093 : if (increment_min >= 0) {
741 : // increasing sequence
742 34769 : min = initial_type->Min();
743 104451 : for (auto bound : induction_var->upper_bounds()) {
744 : Type* bound_type = TypeOrNone(bound.bound);
745 : // If the type is not an integer, just skip the bound.
746 69898 : if (!bound_type->Is(typer_->cache_.kInteger)) continue;
747 : // If the type is not inhabited, then we can take the initial value.
748 16216 : if (!bound_type->IsInhabited()) {
749 36 : max = initial_type->Max();
750 36 : break;
751 : }
752 16180 : double bound_max = bound_type->Max();
753 16180 : if (bound.kind == InductionVariable::kStrict) {
754 15788 : bound_max -= 1;
755 : }
756 32360 : max = std::min(max, bound_max + increment_max);
757 : }
758 : // The upper bound must be at least the initial value's upper bound.
759 69538 : max = std::max(max, initial_type->Max());
760 324 : } else if (increment_max <= 0) {
761 : // decreasing sequence
762 324 : max = initial_type->Max();
763 1078 : for (auto bound : induction_var->lower_bounds()) {
764 : Type* bound_type = TypeOrNone(bound.bound);
765 : // If the type is not an integer, just skip the bound.
766 868 : if (!bound_type->Is(typer_->cache_.kInteger)) continue;
767 : // If the type is not inhabited, then we can take the initial value.
768 434 : if (!bound_type->IsInhabited()) {
769 4 : min = initial_type->Min();
770 4 : break;
771 : }
772 430 : double bound_min = bound_type->Min();
773 430 : if (bound.kind == InductionVariable::kStrict) {
774 192 : bound_min += 1;
775 : }
776 860 : min = std::max(min, bound_min + increment_min);
777 : }
778 : // The lower bound must be at most the initial value's lower bound.
779 648 : min = std::min(min, initial_type->Min());
780 : } else {
781 : // Shortcut: If the increment can be both positive and negative,
782 : // the variable can go arbitrarily far, so just return integer.
783 0 : return typer_->cache_.kInteger;
784 : }
785 35093 : if (FLAG_trace_turbo_loop) {
786 0 : OFStream os(stdout);
787 : os << std::setprecision(10);
788 0 : os << "Loop (" << NodeProperties::GetControlInput(node)->id()
789 0 : << ") variable bounds in "
790 : << (arithmetic_type == InductionVariable::ArithmeticType::kAddition
791 : ? "addition"
792 0 : : "subtraction")
793 0 : << " for phi " << node->id() << ": (" << min << ", " << max << ")\n";
794 : }
795 105279 : return Type::Range(min, max, typer_->zone());
796 : }
797 :
798 0 : Type* Typer::Visitor::TypeEffectPhi(Node* node) {
799 0 : UNREACHABLE();
800 : return nullptr;
801 : }
802 :
803 0 : Type* Typer::Visitor::TypeLoopExit(Node* node) {
804 0 : UNREACHABLE();
805 : return nullptr;
806 : }
807 :
808 : Type* Typer::Visitor::TypeLoopExitValue(Node* node) { return Operand(node, 0); }
809 :
810 0 : Type* Typer::Visitor::TypeLoopExitEffect(Node* node) {
811 0 : UNREACHABLE();
812 : return nullptr;
813 : }
814 :
815 : Type* Typer::Visitor::TypeEnsureWritableFastElements(Node* node) {
816 : return Operand(node, 1);
817 : }
818 :
819 : Type* Typer::Visitor::TypeMaybeGrowFastElements(Node* node) {
820 : return Operand(node, 1);
821 : }
822 :
823 0 : Type* Typer::Visitor::TypeTransitionElementsKind(Node* node) {
824 0 : UNREACHABLE();
825 : return nullptr;
826 : }
827 :
828 0 : Type* Typer::Visitor::TypeCheckpoint(Node* node) {
829 0 : UNREACHABLE();
830 : return nullptr;
831 : }
832 :
833 0 : Type* Typer::Visitor::TypeBeginRegion(Node* node) {
834 0 : UNREACHABLE();
835 : return nullptr;
836 : }
837 :
838 :
839 : Type* Typer::Visitor::TypeFinishRegion(Node* node) { return Operand(node, 0); }
840 :
841 :
842 : Type* Typer::Visitor::TypeFrameState(Node* node) {
843 : // TODO(rossberg): Ideally FrameState wouldn't have a value output.
844 : return Type::Internal();
845 : }
846 :
847 : Type* Typer::Visitor::TypeStateValues(Node* node) { return Type::Internal(); }
848 :
849 : Type* Typer::Visitor::TypeTypedStateValues(Node* node) {
850 : return Type::Internal();
851 : }
852 :
853 : Type* Typer::Visitor::TypeArgumentsElementsState(Node* node) {
854 : return Type::Internal();
855 : }
856 :
857 : Type* Typer::Visitor::TypeArgumentsLengthState(Node* node) {
858 : return Type::Internal();
859 : }
860 :
861 : Type* Typer::Visitor::TypeObjectState(Node* node) { return Type::Internal(); }
862 :
863 : Type* Typer::Visitor::TypeTypedObjectState(Node* node) {
864 : return Type::Internal();
865 : }
866 :
867 : Type* Typer::Visitor::TypeCall(Node* node) { return Type::Any(); }
868 :
869 :
870 10821 : Type* Typer::Visitor::TypeProjection(Node* node) {
871 : Type* const type = Operand(node, 0);
872 5598 : if (type->Is(Type::None())) return Type::None();
873 5223 : int const index = static_cast<int>(ProjectionIndexOf(node->op()));
874 9156 : if (type->IsTuple() && index < type->AsTuple()->Arity()) {
875 : return type->AsTuple()->Element(index);
876 : }
877 : return Type::Any();
878 : }
879 :
880 16620 : Type* Typer::Visitor::TypeTypeGuard(Node* node) {
881 : Type* const type = Operand(node, 0);
882 8310 : return typer_->operation_typer()->TypeTypeGuard(node->op(), type);
883 : }
884 :
885 : Type* Typer::Visitor::TypeDead(Node* node) { return Type::None(); }
886 :
887 : // JS comparison operators.
888 :
889 :
890 40849 : Type* Typer::Visitor::JSEqualTyper(Type* lhs, Type* rhs, Typer* t) {
891 81070 : if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false_;
892 40180 : if (lhs->Is(Type::NullOrUndefined()) && rhs->Is(Type::NullOrUndefined())) {
893 0 : return t->singleton_true_;
894 : }
895 138678 : if (lhs->Is(Type::Number()) && rhs->Is(Type::Number()) &&
896 56105 : (lhs->Max() < rhs->Min() || lhs->Min() > rhs->Max())) {
897 1431 : return t->singleton_false_;
898 : }
899 39237 : if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
900 : // Types are equal and are inhabited only by a single semantic value,
901 : // which is not nan due to the earlier check.
902 34 : return t->singleton_true_;
903 : }
904 : return Type::Boolean();
905 : }
906 :
907 :
908 600996 : static Type* JSType(Type* type) {
909 600996 : if (type->Is(Type::Boolean())) return Type::Boolean();
910 596553 : if (type->Is(Type::String())) return Type::String();
911 446758 : if (type->Is(Type::Number())) return Type::Number();
912 243965 : if (type->Is(Type::Undefined())) return Type::Undefined();
913 243463 : if (type->Is(Type::Null())) return Type::Null();
914 243448 : if (type->Is(Type::Symbol())) return Type::Symbol();
915 243446 : if (type->Is(Type::Receiver())) return Type::Receiver(); // JS "Object"
916 242537 : return Type::Any();
917 : }
918 :
919 :
920 300498 : Type* Typer::Visitor::JSStrictEqualTyper(Type* lhs, Type* rhs, Typer* t) {
921 300498 : if (!JSType(lhs)->Maybe(JSType(rhs))) return t->singleton_false_;
922 596616 : if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false_;
923 763382 : if (lhs->Is(Type::Number()) && rhs->Is(Type::Number()) &&
924 166505 : (lhs->Max() < rhs->Min() || lhs->Min() > rhs->Max())) {
925 2641 : return t->singleton_false_;
926 : }
927 589964 : if ((lhs->Is(Type::Hole()) || rhs->Is(Type::Hole())) && !lhs->Maybe(rhs)) {
928 24 : return t->singleton_false_;
929 : }
930 295751 : if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
931 : // Types are equal and are inhabited only by a single semantic value,
932 : // which is not nan due to the earlier check.
933 603 : return t->singleton_true_;
934 : }
935 : return Type::Boolean();
936 : }
937 :
938 :
939 : // The EcmaScript specification defines the four relational comparison operators
940 : // (<, <=, >=, >) with the help of a single abstract one. It behaves like <
941 : // but returns undefined when the inputs cannot be compared.
942 : // We implement the typing analogously.
943 48388 : Typer::Visitor::ComparisonOutcome Typer::Visitor::JSCompareTyper(Type* lhs,
944 : Type* rhs,
945 : Typer* t) {
946 48388 : lhs = ToPrimitive(lhs, t);
947 48388 : rhs = ToPrimitive(rhs, t);
948 48388 : if (lhs->Maybe(Type::String()) && rhs->Maybe(Type::String())) {
949 : return ComparisonOutcome(kComparisonTrue) |
950 : ComparisonOutcome(kComparisonFalse);
951 : }
952 44830 : return NumberCompareTyper(ToNumber(lhs, t), ToNumber(rhs, t), t);
953 : }
954 :
955 97227 : Typer::Visitor::ComparisonOutcome Typer::Visitor::NumberCompareTyper(Type* lhs,
956 : Type* rhs,
957 : Typer* t) {
958 : // Shortcut for NaNs.
959 193892 : if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return kComparisonUndefined;
960 :
961 : ComparisonOutcome result;
962 96170 : if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
963 : // Types are equal and are inhabited only by a single semantic value.
964 : result = kComparisonFalse;
965 96170 : } else if (lhs->Min() >= rhs->Max()) {
966 : result = kComparisonFalse;
967 93846 : } else if (lhs->Max() < rhs->Min()) {
968 : result = kComparisonTrue;
969 : } else {
970 : // We cannot figure out the result, return both true and false. (We do not
971 : // have to return undefined because that cannot affect the result of
972 : // FalsifyUndefined.)
973 : return ComparisonOutcome(kComparisonTrue) |
974 : ComparisonOutcome(kComparisonFalse);
975 : }
976 : // Add the undefined if we could see NaN.
977 4185 : if (lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN())) {
978 : result |= kComparisonUndefined;
979 : }
980 4185 : return result;
981 : }
982 :
983 :
984 23655 : Type* Typer::Visitor::JSLessThanTyper(Type* lhs, Type* rhs, Typer* t) {
985 47310 : return FalsifyUndefined(JSCompareTyper(lhs, rhs, t), t);
986 : }
987 :
988 :
989 9680 : Type* Typer::Visitor::JSGreaterThanTyper(Type* lhs, Type* rhs, Typer* t) {
990 19360 : return FalsifyUndefined(JSCompareTyper(rhs, lhs, t), t);
991 : }
992 :
993 :
994 3400 : Type* Typer::Visitor::JSLessThanOrEqualTyper(Type* lhs, Type* rhs, Typer* t) {
995 6800 : return FalsifyUndefined(Invert(JSCompareTyper(rhs, lhs, t), t), t);
996 : }
997 :
998 :
999 5243 : Type* Typer::Visitor::JSGreaterThanOrEqualTyper(
1000 : Type* lhs, Type* rhs, Typer* t) {
1001 10486 : return FalsifyUndefined(Invert(JSCompareTyper(lhs, rhs, t), t), t);
1002 : }
1003 :
1004 : // JS bitwise operators.
1005 :
1006 :
1007 33755 : Type* Typer::Visitor::JSBitwiseOrTyper(Type* lhs, Type* rhs, Typer* t) {
1008 33755 : return NumberBitwiseOr(ToNumber(lhs, t), ToNumber(rhs, t), t);
1009 : }
1010 :
1011 :
1012 8240 : Type* Typer::Visitor::JSBitwiseAndTyper(Type* lhs, Type* rhs, Typer* t) {
1013 8240 : return NumberBitwiseAnd(ToNumber(lhs, t), ToNumber(rhs, t), t);
1014 : }
1015 :
1016 :
1017 7467 : Type* Typer::Visitor::JSBitwiseXorTyper(Type* lhs, Type* rhs, Typer* t) {
1018 7467 : return NumberBitwiseXor(ToNumber(lhs, t), ToNumber(rhs, t), t);
1019 : }
1020 :
1021 :
1022 8296 : Type* Typer::Visitor::JSShiftLeftTyper(Type* lhs, Type* rhs, Typer* t) {
1023 8296 : return NumberShiftLeft(ToNumber(lhs, t), ToNumber(rhs, t), t);
1024 : }
1025 :
1026 :
1027 15206 : Type* Typer::Visitor::JSShiftRightTyper(Type* lhs, Type* rhs, Typer* t) {
1028 15206 : return NumberShiftRight(ToNumber(lhs, t), ToNumber(rhs, t), t);
1029 : }
1030 :
1031 :
1032 9082 : Type* Typer::Visitor::JSShiftRightLogicalTyper(Type* lhs, Type* rhs, Typer* t) {
1033 9082 : return NumberShiftRightLogical(ToNumber(lhs, t), ToNumber(rhs, t), t);
1034 : }
1035 :
1036 :
1037 : // JS arithmetic operators.
1038 :
1039 153690 : Type* Typer::Visitor::JSAddTyper(Type* lhs, Type* rhs, Typer* t) {
1040 153690 : lhs = ToPrimitive(lhs, t);
1041 153690 : rhs = ToPrimitive(rhs, t);
1042 153690 : if (lhs->Maybe(Type::String()) || rhs->Maybe(Type::String())) {
1043 140802 : if (lhs->Is(Type::String()) || rhs->Is(Type::String())) {
1044 : return Type::String();
1045 : } else {
1046 25115 : return Type::NumberOrString();
1047 : }
1048 : }
1049 : // The addition must be numeric.
1050 53262 : return NumberAdd(ToNumber(lhs, t), ToNumber(rhs, t), t);
1051 : }
1052 :
1053 61606 : Type* Typer::Visitor::JSSubtractTyper(Type* lhs, Type* rhs, Typer* t) {
1054 61606 : return NumberSubtract(ToNumber(lhs, t), ToNumber(rhs, t), t);
1055 : }
1056 :
1057 33610 : Type* Typer::Visitor::JSMultiplyTyper(Type* lhs, Type* rhs, Typer* t) {
1058 33610 : return NumberMultiply(ToNumber(lhs, t), ToNumber(rhs, t), t);
1059 : }
1060 :
1061 27439 : Type* Typer::Visitor::JSDivideTyper(Type* lhs, Type* rhs, Typer* t) {
1062 27439 : return NumberDivide(ToNumber(lhs, t), ToNumber(rhs, t), t);
1063 : }
1064 :
1065 5546 : Type* Typer::Visitor::JSModulusTyper(Type* lhs, Type* rhs, Typer* t) {
1066 5546 : return NumberModulus(ToNumber(lhs, t), ToNumber(rhs, t), t);
1067 : }
1068 :
1069 :
1070 : // JS unary operators.
1071 :
1072 : Type* Typer::Visitor::TypeJSClassOf(Node* node) {
1073 : return Type::InternalizedStringOrNull();
1074 : }
1075 :
1076 : Type* Typer::Visitor::TypeJSTypeOf(Node* node) {
1077 : return Type::InternalizedString();
1078 : }
1079 :
1080 :
1081 : // JS conversion operators.
1082 :
1083 :
1084 : Type* Typer::Visitor::TypeJSToBoolean(Node* node) {
1085 120555 : return TypeUnaryOp(node, ToBoolean);
1086 : }
1087 :
1088 : Type* Typer::Visitor::TypeJSToInteger(Node* node) {
1089 371 : return TypeUnaryOp(node, ToInteger);
1090 : }
1091 :
1092 : Type* Typer::Visitor::TypeJSToLength(Node* node) {
1093 357 : return TypeUnaryOp(node, ToLength);
1094 : }
1095 :
1096 : Type* Typer::Visitor::TypeJSToName(Node* node) {
1097 1631 : return TypeUnaryOp(node, ToName);
1098 : }
1099 :
1100 : Type* Typer::Visitor::TypeJSToNumber(Node* node) {
1101 14545 : return TypeUnaryOp(node, ToNumber);
1102 : }
1103 :
1104 : Type* Typer::Visitor::TypeJSToObject(Node* node) {
1105 2594 : return TypeUnaryOp(node, ToObject);
1106 : }
1107 :
1108 : Type* Typer::Visitor::TypeJSToString(Node* node) {
1109 2534 : return TypeUnaryOp(node, ToString);
1110 : }
1111 :
1112 : // JS object operators.
1113 :
1114 :
1115 : Type* Typer::Visitor::TypeJSCreate(Node* node) { return Type::Object(); }
1116 :
1117 :
1118 9338 : Type* Typer::Visitor::TypeJSCreateArguments(Node* node) {
1119 9338 : switch (CreateArgumentsTypeOf(node->op())) {
1120 : case CreateArgumentsType::kRestParameter:
1121 : return Type::Array();
1122 : case CreateArgumentsType::kMappedArguments:
1123 : case CreateArgumentsType::kUnmappedArguments:
1124 : return Type::OtherObject();
1125 : }
1126 0 : UNREACHABLE();
1127 : return nullptr;
1128 : }
1129 :
1130 : Type* Typer::Visitor::TypeJSCreateArray(Node* node) { return Type::Array(); }
1131 :
1132 : Type* Typer::Visitor::TypeJSCreateClosure(Node* node) {
1133 : return Type::Function();
1134 : }
1135 :
1136 :
1137 : Type* Typer::Visitor::TypeJSCreateIterResultObject(Node* node) {
1138 : return Type::OtherObject();
1139 : }
1140 :
1141 : Type* Typer::Visitor::TypeJSCreateKeyValueArray(Node* node) {
1142 : return Type::OtherObject();
1143 : }
1144 :
1145 : Type* Typer::Visitor::TypeJSCreateLiteralArray(Node* node) {
1146 : return Type::Array();
1147 : }
1148 :
1149 :
1150 : Type* Typer::Visitor::TypeJSCreateLiteralObject(Node* node) {
1151 : return Type::OtherObject();
1152 : }
1153 :
1154 :
1155 : Type* Typer::Visitor::TypeJSCreateLiteralRegExp(Node* node) {
1156 : return Type::OtherObject();
1157 : }
1158 :
1159 :
1160 : Type* Typer::Visitor::TypeJSLoadProperty(Node* node) {
1161 : return Type::NonInternal();
1162 : }
1163 :
1164 :
1165 : Type* Typer::Visitor::TypeJSLoadNamed(Node* node) {
1166 : return Type::NonInternal();
1167 : }
1168 :
1169 : Type* Typer::Visitor::TypeJSLoadGlobal(Node* node) {
1170 : return Type::NonInternal();
1171 : }
1172 :
1173 : // Returns a somewhat larger range if we previously assigned
1174 : // a (smaller) range to this node. This is used to speed up
1175 : // the fixpoint calculation in case there appears to be a loop
1176 : // in the graph. In the current implementation, we are
1177 : // increasing the limits to the closest power of two.
1178 616011 : Type* Typer::Visitor::Weaken(Node* node, Type* current_type,
1179 438566 : Type* previous_type) {
1180 : static const double kWeakenMinLimits[] = {
1181 : 0.0, -1073741824.0, -2147483648.0, -4294967296.0, -8589934592.0,
1182 : -17179869184.0, -34359738368.0, -68719476736.0, -137438953472.0,
1183 : -274877906944.0, -549755813888.0, -1099511627776.0, -2199023255552.0,
1184 : -4398046511104.0, -8796093022208.0, -17592186044416.0, -35184372088832.0,
1185 : -70368744177664.0, -140737488355328.0, -281474976710656.0,
1186 : -562949953421312.0};
1187 : static const double kWeakenMaxLimits[] = {
1188 : 0.0, 1073741823.0, 2147483647.0, 4294967295.0, 8589934591.0,
1189 : 17179869183.0, 34359738367.0, 68719476735.0, 137438953471.0,
1190 : 274877906943.0, 549755813887.0, 1099511627775.0, 2199023255551.0,
1191 : 4398046511103.0, 8796093022207.0, 17592186044415.0, 35184372088831.0,
1192 : 70368744177663.0, 140737488355327.0, 281474976710655.0,
1193 : 562949953421311.0};
1194 : STATIC_ASSERT(arraysize(kWeakenMinLimits) == arraysize(kWeakenMaxLimits));
1195 :
1196 : // If the types have nothing to do with integers, return the types.
1197 276454 : Type* const integer = typer_->cache_.kInteger;
1198 276454 : if (!previous_type->Maybe(integer)) {
1199 : return current_type;
1200 : }
1201 : DCHECK(current_type->Maybe(integer));
1202 :
1203 219283 : Type* current_integer = Type::Intersect(current_type, integer, zone());
1204 219283 : Type* previous_integer = Type::Intersect(previous_type, integer, zone());
1205 :
1206 : // Once we start weakening a node, we should always weaken.
1207 219283 : if (!IsWeakened(node->id())) {
1208 : // Only weaken if there is range involved; we should converge quickly
1209 : // for all other types (the exception is a union of many constants,
1210 : // but we currently do not increase the number of constants in unions).
1211 120845 : Type* previous = previous_integer->GetRange();
1212 120845 : Type* current = current_integer->GetRange();
1213 120845 : if (current == nullptr || previous == nullptr) {
1214 : return current_type;
1215 : }
1216 : // Range is involved => we are weakening.
1217 : SetWeakened(node->id());
1218 : }
1219 :
1220 218712 : double current_min = current_integer->Min();
1221 : double new_min = current_min;
1222 : // Find the closest lower entry in the list of allowed
1223 : // minima (or negative infinity if there is no such entry).
1224 218712 : if (current_min != previous_integer->Min()) {
1225 : new_min = -V8_INFINITY;
1226 1080538 : for (double const min : kWeakenMinLimits) {
1227 550222 : if (min <= current_min) {
1228 : new_min = min;
1229 : break;
1230 : }
1231 : }
1232 : }
1233 :
1234 218712 : double current_max = current_integer->Max();
1235 : double new_max = current_max;
1236 : // Find the closest greater entry in the list of allowed
1237 : // maxima (or infinity if there is no such entry).
1238 218712 : if (current_max != previous_integer->Max()) {
1239 : new_max = V8_INFINITY;
1240 2182693 : for (double const max : kWeakenMaxLimits) {
1241 1121892 : if (max >= current_max) {
1242 : new_max = max;
1243 : break;
1244 : }
1245 : }
1246 : }
1247 :
1248 : return Type::Union(current_type,
1249 : Type::Range(new_min, new_max, typer_->zone()),
1250 437424 : typer_->zone());
1251 : }
1252 :
1253 :
1254 0 : Type* Typer::Visitor::TypeJSStoreProperty(Node* node) {
1255 0 : UNREACHABLE();
1256 : return nullptr;
1257 : }
1258 :
1259 :
1260 0 : Type* Typer::Visitor::TypeJSStoreNamed(Node* node) {
1261 0 : UNREACHABLE();
1262 : return nullptr;
1263 : }
1264 :
1265 :
1266 0 : Type* Typer::Visitor::TypeJSStoreGlobal(Node* node) {
1267 0 : UNREACHABLE();
1268 : return nullptr;
1269 : }
1270 :
1271 0 : Type* Typer::Visitor::TypeJSStoreNamedOwn(Node* node) {
1272 0 : UNREACHABLE();
1273 : return nullptr;
1274 : }
1275 :
1276 0 : Type* Typer::Visitor::TypeJSStoreDataPropertyInLiteral(Node* node) {
1277 0 : UNREACHABLE();
1278 : return nullptr;
1279 : }
1280 :
1281 : Type* Typer::Visitor::TypeJSDeleteProperty(Node* node) {
1282 : return Type::Boolean();
1283 : }
1284 :
1285 : Type* Typer::Visitor::TypeJSHasProperty(Node* node) { return Type::Boolean(); }
1286 :
1287 : // JS instanceof operator.
1288 :
1289 1021 : Type* Typer::Visitor::JSInstanceOfTyper(Type* lhs, Type* rhs, Typer* t) {
1290 1021 : return Type::Boolean();
1291 : }
1292 :
1293 119 : Type* Typer::Visitor::JSOrdinaryHasInstanceTyper(Type* lhs, Type* rhs,
1294 : Typer* t) {
1295 119 : return Type::Boolean();
1296 : }
1297 :
1298 : Type* Typer::Visitor::TypeJSGetSuperConstructor(Node* node) {
1299 : return Type::Callable();
1300 : }
1301 :
1302 : // JS context operators.
1303 :
1304 :
1305 596103 : Type* Typer::Visitor::TypeJSLoadContext(Node* node) {
1306 596103 : ContextAccess const& access = ContextAccessOf(node->op());
1307 596103 : switch (access.index()) {
1308 : case Context::PREVIOUS_INDEX:
1309 : case Context::NATIVE_CONTEXT_INDEX:
1310 : return Type::OtherInternal();
1311 : case Context::CLOSURE_INDEX:
1312 : return Type::Function();
1313 : default:
1314 : return Type::Any();
1315 : }
1316 : }
1317 :
1318 :
1319 0 : Type* Typer::Visitor::TypeJSStoreContext(Node* node) {
1320 0 : UNREACHABLE();
1321 : return nullptr;
1322 : }
1323 :
1324 :
1325 : Type* Typer::Visitor::TypeJSCreateFunctionContext(Node* node) {
1326 : return Type::OtherInternal();
1327 : }
1328 :
1329 : Type* Typer::Visitor::TypeJSCreateCatchContext(Node* node) {
1330 : return Type::OtherInternal();
1331 : }
1332 :
1333 : Type* Typer::Visitor::TypeJSCreateWithContext(Node* node) {
1334 : return Type::OtherInternal();
1335 : }
1336 :
1337 : Type* Typer::Visitor::TypeJSCreateBlockContext(Node* node) {
1338 : return Type::OtherInternal();
1339 : }
1340 :
1341 : Type* Typer::Visitor::TypeJSCreateScriptContext(Node* node) {
1342 : return Type::OtherInternal();
1343 : }
1344 :
1345 : // JS other operators.
1346 :
1347 : Type* Typer::Visitor::TypeJSConstruct(Node* node) { return Type::Receiver(); }
1348 :
1349 : Type* Typer::Visitor::TypeJSConstructWithSpread(Node* node) {
1350 : return Type::Receiver();
1351 : }
1352 :
1353 237220 : Type* Typer::Visitor::JSCallTyper(Type* fun, Typer* t) {
1354 454308 : if (fun->IsHeapConstant() && fun->AsHeapConstant()->Value()->IsJSFunction()) {
1355 : Handle<JSFunction> function =
1356 : Handle<JSFunction>::cast(fun->AsHeapConstant()->Value());
1357 216913 : if (function->shared()->HasBuiltinFunctionId()) {
1358 88735 : switch (function->shared()->builtin_function_id()) {
1359 : case kMathRandom:
1360 : return Type::PlainNumber();
1361 : case kMathFloor:
1362 : case kMathCeil:
1363 : case kMathRound:
1364 : case kMathTrunc:
1365 46621 : return t->cache_.kIntegerOrMinusZeroOrNaN;
1366 : // Unary math functions.
1367 : case kMathAbs:
1368 : case kMathExp:
1369 : case kMathExpm1:
1370 464 : return Type::Union(Type::PlainNumber(), Type::NaN(), t->zone());
1371 : case kMathAcos:
1372 : case kMathAcosh:
1373 : case kMathAsin:
1374 : case kMathAsinh:
1375 : case kMathAtan:
1376 : case kMathAtanh:
1377 : case kMathCbrt:
1378 : case kMathCos:
1379 : case kMathFround:
1380 : case kMathLog:
1381 : case kMathLog1p:
1382 : case kMathLog10:
1383 : case kMathLog2:
1384 : case kMathSin:
1385 : case kMathSqrt:
1386 : case kMathTan:
1387 1717 : return Type::Number();
1388 : case kMathSign:
1389 34 : return t->cache_.kMinusOneToOneOrMinusZeroOrNaN;
1390 : // Binary math functions.
1391 : case kMathAtan2:
1392 : case kMathPow:
1393 : case kMathMax:
1394 : case kMathMin:
1395 2030 : return Type::Number();
1396 : case kMathImul:
1397 166 : return Type::Signed32();
1398 : case kMathClz32:
1399 59 : return t->cache_.kZeroToThirtyTwo;
1400 : // Date functions.
1401 : case kDateNow:
1402 8 : return t->cache_.kTimeValueType;
1403 : case kDateGetDate:
1404 0 : return t->cache_.kJSDateDayType;
1405 : case kDateGetDay:
1406 0 : return t->cache_.kJSDateWeekdayType;
1407 : case kDateGetFullYear:
1408 0 : return t->cache_.kJSDateYearType;
1409 : case kDateGetHours:
1410 0 : return t->cache_.kJSDateHourType;
1411 : case kDateGetMilliseconds:
1412 : return Type::Union(Type::Range(0.0, 999.0, t->zone()), Type::NaN(),
1413 2 : t->zone());
1414 : case kDateGetMinutes:
1415 0 : return t->cache_.kJSDateMinuteType;
1416 : case kDateGetMonth:
1417 0 : return t->cache_.kJSDateMonthType;
1418 : case kDateGetSeconds:
1419 0 : return t->cache_.kJSDateSecondType;
1420 : case kDateGetTime:
1421 4 : return t->cache_.kJSDateValueType;
1422 :
1423 : // Number functions.
1424 : case kNumberIsFinite:
1425 : case kNumberIsInteger:
1426 : case kNumberIsNaN:
1427 : case kNumberIsSafeInteger:
1428 119 : return Type::Boolean();
1429 : case kNumberParseFloat:
1430 30 : return Type::Number();
1431 : case kNumberParseInt:
1432 467 : return t->cache_.kIntegerOrMinusZeroOrNaN;
1433 : case kNumberToString:
1434 237 : return Type::String();
1435 :
1436 : // String functions.
1437 : case kStringCharCodeAt:
1438 : return Type::Union(Type::Range(0, kMaxUInt16, t->zone()), Type::NaN(),
1439 534 : t->zone());
1440 : case kStringCharAt:
1441 147 : return Type::String();
1442 : case kStringCodePointAt:
1443 : return Type::Union(Type::Range(0.0, String::kMaxCodePoint, t->zone()),
1444 16 : Type::Undefined(), t->zone());
1445 : case kStringConcat:
1446 : case kStringFromCharCode:
1447 : case kStringFromCodePoint:
1448 786 : return Type::String();
1449 : case kStringIndexOf:
1450 : case kStringLastIndexOf:
1451 173 : return Type::Range(-1.0, String::kMaxLength - 1.0, t->zone());
1452 : case kStringEndsWith:
1453 : case kStringIncludes:
1454 0 : return Type::Boolean();
1455 : case kStringRaw:
1456 : case kStringRepeat:
1457 : case kStringSlice:
1458 2 : return Type::String();
1459 : case kStringStartsWith:
1460 0 : return Type::Boolean();
1461 : case kStringSubstr:
1462 : case kStringSubstring:
1463 : case kStringToLowerCase:
1464 : case kStringToString:
1465 : case kStringToUpperCase:
1466 : case kStringTrim:
1467 : case kStringTrimLeft:
1468 : case kStringTrimRight:
1469 : case kStringValueOf:
1470 628 : return Type::String();
1471 :
1472 : case kStringIterator:
1473 : case kStringIteratorNext:
1474 99 : return Type::OtherObject();
1475 :
1476 : case kArrayEntries:
1477 : case kArrayKeys:
1478 : case kArrayValues:
1479 : case kTypedArrayEntries:
1480 : case kTypedArrayKeys:
1481 : case kTypedArrayValues:
1482 : case kArrayIteratorNext:
1483 3098 : return Type::OtherObject();
1484 :
1485 : // Array functions.
1486 : case kArrayIsArray:
1487 21 : return Type::Boolean();
1488 : case kArrayConcat:
1489 106 : return Type::Receiver();
1490 : case kArrayEvery:
1491 62 : return Type::Boolean();
1492 : case kArrayFill:
1493 : case kArrayFilter:
1494 62 : return Type::Receiver();
1495 : case kArrayFindIndex:
1496 0 : return Type::Range(-1, kMaxSafeInteger, t->zone());
1497 : case kArrayForEach:
1498 71 : return Type::Undefined();
1499 : case kArrayIncludes:
1500 21 : return Type::Boolean();
1501 : case kArrayIndexOf:
1502 149 : return Type::Range(-1, kMaxSafeInteger, t->zone());
1503 : case kArrayJoin:
1504 33 : return Type::String();
1505 : case kArrayLastIndexOf:
1506 63 : return Type::Range(-1, kMaxSafeInteger, t->zone());
1507 : case kArrayMap:
1508 63 : return Type::Receiver();
1509 : case kArrayPush:
1510 1855 : return t->cache_.kPositiveSafeInteger;
1511 : case kArrayReverse:
1512 : case kArraySlice:
1513 124 : return Type::Receiver();
1514 : case kArraySome:
1515 62 : return Type::Boolean();
1516 : case kArraySplice:
1517 131 : return Type::Receiver();
1518 : case kArrayUnshift:
1519 51 : return t->cache_.kPositiveSafeInteger;
1520 :
1521 : // Object functions.
1522 : case kObjectAssign:
1523 0 : return Type::Receiver();
1524 : case kObjectCreate:
1525 21 : return Type::OtherObject();
1526 : case kObjectHasOwnProperty:
1527 199 : return Type::Boolean();
1528 : case kObjectToString:
1529 43 : return Type::String();
1530 :
1531 : // RegExp functions.
1532 : case kRegExpCompile:
1533 0 : return Type::OtherObject();
1534 : case kRegExpExec:
1535 53 : return Type::Union(Type::Array(), Type::Null(), t->zone());
1536 : case kRegExpTest:
1537 499 : return Type::Boolean();
1538 : case kRegExpToString:
1539 6 : return Type::String();
1540 :
1541 : // Function functions.
1542 : case kFunctionHasInstance:
1543 0 : return Type::Boolean();
1544 :
1545 : // Global functions.
1546 : case kGlobalDecodeURI:
1547 : case kGlobalDecodeURIComponent:
1548 : case kGlobalEncodeURI:
1549 : case kGlobalEncodeURIComponent:
1550 : case kGlobalEscape:
1551 : case kGlobalUnescape:
1552 241 : return Type::String();
1553 : case kGlobalIsFinite:
1554 : case kGlobalIsNaN:
1555 25946 : return Type::Boolean();
1556 :
1557 : // Map functions.
1558 : case kMapClear:
1559 : case kMapForEach:
1560 0 : return Type::Undefined();
1561 : case kMapDelete:
1562 : case kMapHas:
1563 4 : return Type::Boolean();
1564 : case kMapEntries:
1565 : case kMapKeys:
1566 : case kMapSet:
1567 : case kMapValues:
1568 3 : return Type::OtherObject();
1569 :
1570 : // Set functions.
1571 : case kSetAdd:
1572 : case kSetEntries:
1573 : case kSetKeys:
1574 : case kSetValues:
1575 7 : return Type::OtherObject();
1576 : case kSetClear:
1577 : case kSetForEach:
1578 0 : return Type::Undefined();
1579 : case kSetDelete:
1580 : case kSetHas:
1581 0 : return Type::Boolean();
1582 :
1583 : // WeakMap functions.
1584 : case kWeakMapDelete:
1585 : case kWeakMapHas:
1586 0 : return Type::Boolean();
1587 : case kWeakMapSet:
1588 0 : return Type::OtherObject();
1589 :
1590 : // WeakSet functions.
1591 : case kWeakSetAdd:
1592 0 : return Type::OtherObject();
1593 : case kWeakSetDelete:
1594 : case kWeakSetHas:
1595 0 : return Type::Boolean();
1596 : default:
1597 : break;
1598 : }
1599 : }
1600 : }
1601 : return Type::NonInternal();
1602 : }
1603 :
1604 : Type* Typer::Visitor::TypeJSCallForwardVarargs(Node* node) {
1605 215 : return TypeUnaryOp(node, JSCallTyper);
1606 : }
1607 :
1608 : Type* Typer::Visitor::TypeJSCall(Node* node) {
1609 : // TODO(bmeurer): We could infer better types if we wouldn't ignore the
1610 : // argument types for the JSCallTyper above.
1611 236837 : return TypeUnaryOp(node, JSCallTyper);
1612 : }
1613 :
1614 : Type* Typer::Visitor::TypeJSCallWithSpread(Node* node) {
1615 175 : return TypeUnaryOp(node, JSCallTyper);
1616 : }
1617 :
1618 339734 : Type* Typer::Visitor::TypeJSCallRuntime(Node* node) {
1619 339734 : switch (CallRuntimeParametersOf(node->op()).id()) {
1620 : case Runtime::kInlineIsJSReceiver:
1621 0 : return TypeUnaryOp(node, ObjectIsReceiver);
1622 : case Runtime::kInlineIsSmi:
1623 0 : return TypeUnaryOp(node, ObjectIsSmi);
1624 : case Runtime::kInlineIsArray:
1625 : case Runtime::kInlineIsDate:
1626 : case Runtime::kInlineIsTypedArray:
1627 : case Runtime::kInlineIsRegExp:
1628 : return Type::Boolean();
1629 : case Runtime::kInlineCreateIterResultObject:
1630 0 : return Type::OtherObject();
1631 : case Runtime::kInlineSubString:
1632 : case Runtime::kInlineStringCharFromCode:
1633 0 : return Type::String();
1634 : case Runtime::kInlineToInteger:
1635 0 : return TypeUnaryOp(node, ToInteger);
1636 : case Runtime::kInlineToLength:
1637 0 : return TypeUnaryOp(node, ToLength);
1638 : case Runtime::kInlineToNumber:
1639 0 : return TypeUnaryOp(node, ToNumber);
1640 : case Runtime::kInlineToObject:
1641 0 : return TypeUnaryOp(node, ToObject);
1642 : case Runtime::kInlineToString:
1643 0 : return TypeUnaryOp(node, ToString);
1644 : case Runtime::kInlineClassOf:
1645 0 : return Type::InternalizedStringOrNull();
1646 : case Runtime::kHasInPrototypeChain:
1647 : return Type::Boolean();
1648 : default:
1649 : break;
1650 : }
1651 : // TODO(turbofan): This should be Type::NonInternal(), but unfortunately we
1652 : // have a few weird runtime calls that return the hole or even FixedArrays;
1653 : // change this once those weird runtime calls have been removed.
1654 338746 : return Type::Any();
1655 : }
1656 :
1657 :
1658 : Type* Typer::Visitor::TypeJSConvertReceiver(Node* node) {
1659 : return Type::Receiver();
1660 : }
1661 :
1662 :
1663 3090 : Type* Typer::Visitor::TypeJSForInNext(Node* node) {
1664 3090 : return Type::Union(Type::String(), Type::Undefined(), zone());
1665 : }
1666 :
1667 :
1668 1368 : Type* Typer::Visitor::TypeJSForInPrepare(Node* node) {
1669 : STATIC_ASSERT(Map::EnumLengthBits::kMax <= FixedArray::kMaxLength);
1670 : Type* const cache_type =
1671 1368 : Type::Union(Type::SignedSmall(), Type::OtherInternal(), zone());
1672 : Type* const cache_array = Type::OtherInternal();
1673 1368 : Type* const cache_length = typer_->cache_.kFixedArrayLengthType;
1674 1368 : return Type::Tuple(cache_type, cache_array, cache_length, zone());
1675 : }
1676 :
1677 :
1678 : Type* Typer::Visitor::TypeJSLoadMessage(Node* node) { return Type::Any(); }
1679 :
1680 :
1681 0 : Type* Typer::Visitor::TypeJSStoreMessage(Node* node) {
1682 0 : UNREACHABLE();
1683 : return nullptr;
1684 : }
1685 :
1686 : Type* Typer::Visitor::TypeJSLoadModule(Node* node) { return Type::Any(); }
1687 :
1688 0 : Type* Typer::Visitor::TypeJSStoreModule(Node* node) {
1689 0 : UNREACHABLE();
1690 : return nullptr;
1691 : }
1692 :
1693 0 : Type* Typer::Visitor::TypeJSGeneratorStore(Node* node) {
1694 0 : UNREACHABLE();
1695 : return nullptr;
1696 : }
1697 :
1698 : Type* Typer::Visitor::TypeJSGeneratorRestoreContinuation(Node* node) {
1699 : return Type::SignedSmall();
1700 : }
1701 :
1702 : Type* Typer::Visitor::TypeJSGeneratorRestoreRegister(Node* node) {
1703 : return Type::Any();
1704 : }
1705 :
1706 : Type* Typer::Visitor::TypeJSStackCheck(Node* node) { return Type::Any(); }
1707 :
1708 : Type* Typer::Visitor::TypeJSDebugger(Node* node) { return Type::Any(); }
1709 :
1710 : // Simplified operators.
1711 :
1712 : Type* Typer::Visitor::TypeBooleanNot(Node* node) { return Type::Boolean(); }
1713 :
1714 : // static
1715 20125 : Type* Typer::Visitor::NumberEqualTyper(Type* lhs, Type* rhs, Typer* t) {
1716 20125 : return JSEqualTyper(ToNumber(lhs, t), ToNumber(rhs, t), t);
1717 : }
1718 :
1719 : // static
1720 52397 : Type* Typer::Visitor::NumberLessThanTyper(Type* lhs, Type* rhs, Typer* t) {
1721 : return FalsifyUndefined(
1722 104794 : NumberCompareTyper(ToNumber(lhs, t), ToNumber(rhs, t), t), t);
1723 : }
1724 :
1725 : // static
1726 6410 : Type* Typer::Visitor::NumberLessThanOrEqualTyper(Type* lhs, Type* rhs,
1727 : Typer* t) {
1728 : return FalsifyUndefined(
1729 12820 : Invert(JSCompareTyper(ToNumber(rhs, t), ToNumber(lhs, t), t), t), t);
1730 : }
1731 :
1732 : Type* Typer::Visitor::TypeNumberEqual(Node* node) {
1733 11766 : return TypeBinaryOp(node, NumberEqualTyper);
1734 : }
1735 :
1736 : Type* Typer::Visitor::TypeNumberLessThan(Node* node) {
1737 3091 : return TypeBinaryOp(node, NumberLessThanTyper);
1738 : }
1739 :
1740 : Type* Typer::Visitor::TypeNumberLessThanOrEqual(Node* node) {
1741 4859 : return TypeBinaryOp(node, NumberLessThanOrEqualTyper);
1742 : }
1743 :
1744 : Type* Typer::Visitor::TypeSpeculativeNumberEqual(Node* node) {
1745 11164 : return TypeBinaryOp(node, NumberEqualTyper);
1746 : }
1747 :
1748 : Type* Typer::Visitor::TypeSpeculativeNumberLessThan(Node* node) {
1749 88637 : return TypeBinaryOp(node, NumberLessThanTyper);
1750 : }
1751 :
1752 : Type* Typer::Visitor::TypeSpeculativeNumberLessThanOrEqual(Node* node) {
1753 2673 : return TypeBinaryOp(node, NumberLessThanOrEqualTyper);
1754 : }
1755 :
1756 : Type* Typer::Visitor::TypePlainPrimitiveToNumber(Node* node) {
1757 18350 : return TypeUnaryOp(node, ToNumber);
1758 : }
1759 :
1760 : Type* Typer::Visitor::TypePlainPrimitiveToWord32(Node* node) {
1761 : return Type::Integral32();
1762 : }
1763 :
1764 : Type* Typer::Visitor::TypePlainPrimitiveToFloat64(Node* node) {
1765 : return Type::Number();
1766 : }
1767 :
1768 : // static
1769 209154 : Type* Typer::Visitor::ReferenceEqualTyper(Type* lhs, Type* rhs, Typer* t) {
1770 216343 : if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
1771 2180 : return t->singleton_true_;
1772 : }
1773 : return Type::Boolean();
1774 : }
1775 :
1776 :
1777 : Type* Typer::Visitor::TypeReferenceEqual(Node* node) {
1778 212095 : return TypeBinaryOp(node, ReferenceEqualTyper);
1779 : }
1780 :
1781 : Type* Typer::Visitor::TypeStringEqual(Node* node) { return Type::Boolean(); }
1782 :
1783 : Type* Typer::Visitor::TypeStringLessThan(Node* node) { return Type::Boolean(); }
1784 :
1785 : Type* Typer::Visitor::TypeStringLessThanOrEqual(Node* node) {
1786 : return Type::Boolean();
1787 : }
1788 :
1789 706 : Type* Typer::Visitor::StringFromCharCodeTyper(Type* type, Typer* t) {
1790 706 : return Type::String();
1791 : }
1792 :
1793 45 : Type* Typer::Visitor::StringFromCodePointTyper(Type* type, Typer* t) {
1794 45 : return Type::String();
1795 : }
1796 :
1797 : Type* Typer::Visitor::TypeStringCharAt(Node* node) { return Type::String(); }
1798 :
1799 : Type* Typer::Visitor::TypeStringCharCodeAt(Node* node) {
1800 339 : return typer_->cache_.kUint16;
1801 : }
1802 :
1803 : Type* Typer::Visitor::TypeStringFromCharCode(Node* node) {
1804 706 : return TypeUnaryOp(node, StringFromCharCodeTyper);
1805 : }
1806 :
1807 : Type* Typer::Visitor::TypeStringFromCodePoint(Node* node) {
1808 45 : return TypeUnaryOp(node, StringFromCodePointTyper);
1809 : }
1810 :
1811 0 : Type* Typer::Visitor::TypeStringIndexOf(Node* node) {
1812 0 : return Type::Range(-1.0, String::kMaxLength - 1.0, zone());
1813 : }
1814 :
1815 106007 : Type* Typer::Visitor::TypeCheckBounds(Node* node) {
1816 : Type* index = Operand(node, 0);
1817 : Type* length = Operand(node, 1);
1818 37833 : if (index->Maybe(Type::MinusZero())) {
1819 3368 : index = Type::Union(index, typer_->cache_.kSingletonZero, zone());
1820 : }
1821 37833 : index = Type::Intersect(index, Type::Integral32(), zone());
1822 64855 : if (!index->IsInhabited() || !length->IsInhabited()) return Type::None();
1823 54044 : double min = std::max(index->Min(), 0.0);
1824 54044 : double max = std::min(index->Max(), length->Max() - 1);
1825 27022 : if (max < min) return Type::None();
1826 26973 : return Type::Range(min, max, zone());
1827 : }
1828 :
1829 : Type* Typer::Visitor::TypeCheckHeapObject(Node* node) {
1830 : Type* type = Operand(node, 0);
1831 : return type;
1832 : }
1833 :
1834 0 : Type* Typer::Visitor::TypeCheckIf(Node* node) {
1835 0 : UNREACHABLE();
1836 : return nullptr;
1837 : }
1838 :
1839 8796 : Type* Typer::Visitor::TypeCheckInternalizedString(Node* node) {
1840 : Type* arg = Operand(node, 0);
1841 4398 : return Type::Intersect(arg, Type::InternalizedString(), zone());
1842 : }
1843 :
1844 0 : Type* Typer::Visitor::TypeCheckMaps(Node* node) {
1845 0 : UNREACHABLE();
1846 : return nullptr;
1847 : }
1848 :
1849 4482 : Type* Typer::Visitor::TypeCheckNumber(Node* node) {
1850 4482 : return typer_->operation_typer_.CheckNumber(Operand(node, 0));
1851 : }
1852 :
1853 946 : Type* Typer::Visitor::TypeCheckReceiver(Node* node) {
1854 : Type* arg = Operand(node, 0);
1855 473 : return Type::Intersect(arg, Type::Receiver(), zone());
1856 : }
1857 :
1858 35964 : Type* Typer::Visitor::TypeCheckSmi(Node* node) {
1859 : Type* arg = Operand(node, 0);
1860 17982 : return Type::Intersect(arg, Type::SignedSmall(), zone());
1861 : }
1862 :
1863 6222 : Type* Typer::Visitor::TypeCheckString(Node* node) {
1864 : Type* arg = Operand(node, 0);
1865 3111 : return Type::Intersect(arg, Type::String(), zone());
1866 : }
1867 :
1868 772 : Type* Typer::Visitor::TypeCheckFloat64Hole(Node* node) {
1869 772 : return typer_->operation_typer_.CheckFloat64Hole(Operand(node, 0));
1870 : }
1871 :
1872 1618 : Type* Typer::Visitor::TypeCheckTaggedHole(Node* node) {
1873 : Type* type = Operand(node, 0);
1874 809 : type = Type::Intersect(type, Type::NonInternal(), zone());
1875 809 : return type;
1876 : }
1877 :
1878 4730 : Type* Typer::Visitor::TypeConvertTaggedHoleToUndefined(Node* node) {
1879 : Type* type = Operand(node, 0);
1880 1616 : if (type->Maybe(Type::Hole())) {
1881 : // Turn "the hole" into undefined.
1882 1557 : type = Type::Intersect(type, Type::NonInternal(), zone());
1883 1557 : type = Type::Union(type, Type::Undefined(), zone());
1884 : }
1885 1616 : return type;
1886 : }
1887 :
1888 : Type* Typer::Visitor::TypeAllocate(Node* node) {
1889 112796 : return AllocateTypeOf(node->op());
1890 : }
1891 :
1892 : Type* Typer::Visitor::TypeLoadField(Node* node) {
1893 426250 : return FieldAccessOf(node->op()).type;
1894 : }
1895 :
1896 11610 : Type* Typer::Visitor::TypeLoadBuffer(Node* node) {
1897 11610 : switch (BufferAccessOf(node->op()).external_array_type()) {
1898 : #define TYPED_ARRAY_CASE(ElemType, type, TYPE, ctype, size) \
1899 : case kExternal##ElemType##Array: \
1900 : return Type::Union(typer_->cache_.k##ElemType, Type::Undefined(), zone());
1901 5805 : TYPED_ARRAYS(TYPED_ARRAY_CASE)
1902 : #undef TYPED_ARRAY_CASE
1903 : }
1904 0 : UNREACHABLE();
1905 : return nullptr;
1906 : }
1907 :
1908 :
1909 : Type* Typer::Visitor::TypeLoadElement(Node* node) {
1910 32575 : return ElementAccessOf(node->op()).type;
1911 : }
1912 :
1913 3257 : Type* Typer::Visitor::TypeLoadTypedElement(Node* node) {
1914 3257 : switch (ExternalArrayTypeOf(node->op())) {
1915 : #define TYPED_ARRAY_CASE(ElemType, type, TYPE, ctype, size) \
1916 : case kExternal##ElemType##Array: \
1917 : return typer_->cache_.k##ElemType;
1918 283 : TYPED_ARRAYS(TYPED_ARRAY_CASE)
1919 : #undef TYPED_ARRAY_CASE
1920 : }
1921 0 : UNREACHABLE();
1922 : return nullptr;
1923 : }
1924 :
1925 0 : Type* Typer::Visitor::TypeStoreField(Node* node) {
1926 0 : UNREACHABLE();
1927 : return nullptr;
1928 : }
1929 :
1930 :
1931 0 : Type* Typer::Visitor::TypeStoreBuffer(Node* node) {
1932 0 : UNREACHABLE();
1933 : return nullptr;
1934 : }
1935 :
1936 :
1937 0 : Type* Typer::Visitor::TypeStoreElement(Node* node) {
1938 0 : UNREACHABLE();
1939 : return nullptr;
1940 : }
1941 :
1942 0 : Type* Typer::Visitor::TypeStoreTypedElement(Node* node) {
1943 0 : UNREACHABLE();
1944 : return nullptr;
1945 : }
1946 :
1947 : Type* Typer::Visitor::TypeObjectIsDetectableCallable(Node* node) {
1948 23104 : return TypeUnaryOp(node, ObjectIsDetectableCallable);
1949 : }
1950 :
1951 : Type* Typer::Visitor::TypeObjectIsNaN(Node* node) {
1952 8592 : return TypeUnaryOp(node, ObjectIsNaN);
1953 : }
1954 :
1955 : Type* Typer::Visitor::TypeObjectIsNonCallable(Node* node) {
1956 13666 : return TypeUnaryOp(node, ObjectIsNonCallable);
1957 : }
1958 :
1959 : Type* Typer::Visitor::TypeObjectIsNumber(Node* node) {
1960 16813 : return TypeUnaryOp(node, ObjectIsNumber);
1961 : }
1962 :
1963 :
1964 : Type* Typer::Visitor::TypeObjectIsReceiver(Node* node) {
1965 24930 : return TypeUnaryOp(node, ObjectIsReceiver);
1966 : }
1967 :
1968 :
1969 : Type* Typer::Visitor::TypeObjectIsSmi(Node* node) {
1970 4573 : return TypeUnaryOp(node, ObjectIsSmi);
1971 : }
1972 :
1973 : Type* Typer::Visitor::TypeObjectIsString(Node* node) {
1974 4924 : return TypeUnaryOp(node, ObjectIsString);
1975 : }
1976 :
1977 : Type* Typer::Visitor::TypeObjectIsSymbol(Node* node) {
1978 763 : return TypeUnaryOp(node, ObjectIsSymbol);
1979 : }
1980 :
1981 : Type* Typer::Visitor::TypeObjectIsUndetectable(Node* node) {
1982 9651 : return TypeUnaryOp(node, ObjectIsUndetectable);
1983 : }
1984 :
1985 : Type* Typer::Visitor::TypeArgumentsLength(Node* node) {
1986 4410 : return TypeCache::Get().kArgumentsLengthType;
1987 : }
1988 :
1989 : Type* Typer::Visitor::TypeArgumentsFrame(Node* node) {
1990 : return Type::ExternalPointer();
1991 : }
1992 :
1993 : Type* Typer::Visitor::TypeNewUnmappedArgumentsElements(Node* node) {
1994 : return Type::OtherInternal();
1995 : }
1996 :
1997 : Type* Typer::Visitor::TypeArrayBufferWasNeutered(Node* node) {
1998 : return Type::Boolean();
1999 : }
2000 :
2001 : // Heap constants.
2002 :
2003 6323502 : Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
2004 3161751 : if (Type::IsInteger(*value)) {
2005 0 : return Type::Range(value->Number(), value->Number(), zone());
2006 : }
2007 3161751 : return Type::NewConstant(value, zone());
2008 : }
2009 :
2010 : } // namespace compiler
2011 : } // namespace internal
2012 : } // namespace v8
|
