Lines Matching refs:Type
22 infinity_ = Type::NewConstant(factory->infinity_value(), zone);
23 minus_infinity_ = Type::NewConstant(factory->minus_infinity_value(), zone);
24 Type* truncating_to_zero = Type::MinusZeroOrNaN();
25 DCHECK(!truncating_to_zero->Maybe(Type::Integral32()));
27 singleton_false_ = Type::HeapConstant(factory->false_value(), zone);
28 singleton_true_ = Type::HeapConstant(factory->true_value(), zone);
29 singleton_the_hole_ = Type::HeapConstant(factory->the_hole_value(), zone);
30 signed32ish_ = Type::Union(Type::Signed32(), truncating_to_zero, zone);
31 unsigned32ish_ = Type::Union(Type::Unsigned32(), truncating_to_zero, zone);
34 Type* OperationTyper::Merge(Type* left, Type* right) {
35 return Type::Union(left, right, zone());
38 Type* OperationTyper::WeakenRange(Type* previous_range, Type* current_range) {
111 return Type::Range(new_min, new_max, zone());
114 Type* OperationTyper::Rangify(Type* type) {
127 return Type::Range(min, max, zone());
164 Type* OperationTyper::AddRanger(double lhs_min, double lhs_max, double rhs_min,
179 if (nans == 4) return Type::NaN();
180 Type* type =
181 Type::Range(array_min(results, 4), array_max(results, 4), zone());
182 if (nans > 0) type = Type::Union(type, Type::NaN(), zone());
191 Type* OperationTyper::SubtractRanger(double lhs_min, double lhs_max,
206 if (nans == 4) return Type::NaN(); // [inf..inf] - [inf..inf] (all same sign)
207 Type* type =
208 Type::Range(array_min(results, 4), array_max(results, 4), zone());
209 return nans == 0 ? type : Type::Union(type, Type::NaN(), zone());
217 Type* OperationTyper::MultiplyRanger(Type* lhs, Type* rhs) {
238 Type* range =
239 Type::Range(array_min(results, 4), array_max(results, 4), zone());
240 return maybe_minuszero ? Type::Union(range, Type::MinusZero(), zone())
244 Type* OperationTyper::ToNumber(Type* type) {
245 if (type->Is(Type::Number())) return type;
246 if (type->Is(Type::NullOrUndefined())) {
247 if (type->Is(Type::Null())) return cache_.kSingletonZero;
248 if (type->Is(Type::Undefined())) return Type::NaN();
249 return Type::Union(Type::NaN(), cache_.kSingletonZero, zone());
251 if (type->Is(Type::Boolean())) {
256 if (type->Is(Type::NumberOrOddball())) {
257 if (type->Is(Type::NumberOrUndefined())) {
258 type = Type::Union(type, Type::NaN(), zone());
259 } else if (type->Is(Type::NullOrNumber())) {
260 type = Type::Union(type, cache_.kSingletonZero, zone());
261 } else if (type->Is(Type::BooleanOrNullOrNumber())) {
262 type = Type::Union(type, cache_.kZeroOrOne, zone());
264 type = Type::Union(type, cache_.kZeroOrOneOrNaN, zone());
266 return Type::Intersect(type, Type::Number(), zone());
268 return Type::Number();
271 Type* OperationTyper::NumberAbs(Type* type) {
272 DCHECK(type->Is(Type::Number()));
275 return Type::None();
278 bool const maybe_nan = type->Maybe(Type::NaN());
279 bool const maybe_minuszero = type->Maybe(Type::MinusZero());
280 type = Type::Intersect(type, Type::PlainNumber(), zone());
285 type = Type::Range(0.0, std::max(std::fabs(min), std::fabs(max)), zone());
287 type = Type::PlainNumber();
291 type = Type::Union(type, cache_.kSingletonZero, zone());
294 type = Type::Union(type, Type::NaN(), zone());
299 Type* OperationTyper::NumberAcos(Type* type) {
300 DCHECK(type->Is(Type::Number()));
301 return Type::Number();
304 Type* OperationTyper::NumberAcosh(Type* type) {
305 DCHECK(type->Is(Type::Number()));
306 return Type::Number();
309 Type* OperationTyper::NumberAsin(Type* type) {
310 DCHECK(type->Is(Type::Number()));
311 return Type::Number();
314 Type* OperationTyper::NumberAsinh(Type* type) {
315 DCHECK(type->Is(Type::Number()));
316 return Type::Number();
319 Type* OperationTyper::NumberAtan(Type* type) {
320 DCHECK(type->Is(Type::Number()));
321 return Type::Number();
324 Type* OperationTyper::NumberAtanh(Type* type) {
325 DCHECK(type->Is(Type::Number()));
326 return Type::Number();
329 Type* OperationTyper::NumberCbrt(Type* type) {
330 DCHECK(type->Is(Type::Number()));
331 return Type::Number();
334 Type* OperationTyper::NumberCeil(Type* type) {
335 DCHECK(type->Is(Type::Number()));
341 Type* OperationTyper::NumberClz32(Type* type) {
342 DCHECK(type->Is(Type::Number()));
346 Type* OperationTyper::NumberCos(Type* type) {
347 DCHECK(type->Is(Type::Number()));
348 return Type::Number();
351 Type* OperationTyper::NumberCosh(Type* type) {
352 DCHECK(type->Is(Type::Number()));
353 return Type::Number();
356 Type* OperationTyper::NumberExp(Type* type) {
357 DCHECK(type->Is(Type::Number()));
358 return Type::Union(Type::PlainNumber(), Type::NaN(), zone());
361 Type* OperationTyper::NumberExpm1(Type* type) {
362 DCHECK(type->Is(Type::Number()));
363 return Type::Union(Type::PlainNumber(), Type::NaN(), zone());
366 Type* OperationTyper::NumberFloor(Type* type) {
367 DCHECK(type->Is(Type::Number()));
369 type = Type::Intersect(type, Type::MinusZeroOrNaN(), zone());
370 type = Type::Union(type, cache_.kInteger, zone());
374 Type* OperationTyper::NumberFround(Type* type) {
375 DCHECK(type->Is(Type::Number()));
376 return Type::Number();
379 Type* OperationTyper::NumberLog(Type* type) {
380 DCHECK(type->Is(Type::Number()));
381 return Type::Number();
384 Type* OperationTyper::NumberLog1p(Type* type) {
385 DCHECK(type->Is(Type::Number()));
386 return Type::Number();
389 Type* OperationTyper::NumberLog2(Type* type) {
390 DCHECK(type->Is(Type::Number()));
391 return Type::Number();
394 Type* OperationTyper::NumberLog10(Type* type) {
395 DCHECK(type->Is(Type::Number()));
396 return Type::Number();
399 Type* OperationTyper::NumberRound(Type* type) {
400 DCHECK(type->Is(Type::Number()));
406 Type* OperationTyper::NumberSign(Type* type) {
407 DCHECK(type->Is(Type::Number()));
409 bool maybe_minuszero = type->Maybe(Type::MinusZero());
410 bool maybe_nan = type->Maybe(Type::NaN());
411 type = Type::Intersect(type, Type::PlainNumber(), zone());
421 type = Type::Range(-1.0, 1.0, zone());
423 if (maybe_minuszero) type = Type::Union(type, Type::MinusZero(), zone());
424 if (maybe_nan) type = Type::Union(type, Type::NaN(), zone());
428 Type* OperationTyper::NumberSin(Type* type) {
429 DCHECK(type->Is(Type::Number()));
430 return Type::Number();
433 Type* OperationTyper::NumberSinh(Type* type) {
434 DCHECK(type->Is(Type::Number()));
435 return Type::Number();
438 Type* OperationTyper::NumberSqrt(Type* type) {
439 DCHECK(type->Is(Type::Number()));
440 return Type::Number();
443 Type* OperationTyper::NumberTan(Type* type) {
444 DCHECK(type->Is(Type::Number()));
445 return Type::Number();
448 Type* OperationTyper::NumberTanh(Type* type) {
449 DCHECK(type->Is(Type::Number()));
450 return Type::Number();
453 Type* OperationTyper::NumberTrunc(Type* type) {
454 DCHECK(type->Is(Type::Number()));
460 Type* OperationTyper::NumberToBoolean(Type* type) {
461 DCHECK(type->Is(Type::Number()));
462 if (!type->IsInhabited()) return Type::None();
464 if (type->Is(Type::PlainNumber()) && (type->Max() < 0 || 0 < type->Min())) {
467 return Type::Boolean();
470 Type* OperationTyper::NumberToInt32(Type* type) {
471 DCHECK(type->Is(Type::Number()));
473 if (type->Is(Type::Signed32())) return type;
476 return Type::Intersect(Type::Union(type, cache_.kSingletonZero, zone()),
477 Type::Signed32(), zone());
479 return Type::Signed32();
482 Type* OperationTyper::NumberToUint32(Type* type) {
483 DCHECK(type->Is(Type::Number()));
485 if (type->Is(Type::Unsigned32())) return type;
488 return Type::Intersect(Type::Union(type, cache_.kSingletonZero, zone()),
489 Type::Unsigned32(), zone());
491 return Type::Unsigned32();
494 Type* OperationTyper::NumberToUint8Clamped(Type* type) {
495 DCHECK(type->Is(Type::Number()));
501 Type* OperationTyper::NumberSilenceNaN(Type* type) {
502 DCHECK(type->Is(Type::Number()));
506 if (type->Maybe(Type::NaN())) return Type::Number();
510 Type* OperationTyper::NumberAdd(Type* lhs, Type* rhs) {
511 DCHECK(lhs->Is(Type::Number()));
512 DCHECK(rhs->Is(Type::Number()));
515 return Type::None();
520 bool maybe_nan = lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN());
524 if (lhs->Maybe(Type::MinusZero())) {
525 lhs = Type::Union(lhs, cache_.kSingletonZero, zone());
529 if (rhs->Maybe(Type::MinusZero())) {
530 rhs = Type::Union(rhs, cache_.kSingletonZero, zone());
536 Type* type = Type::None();
537 lhs = Type::Intersect(lhs, Type::PlainNumber(), zone());
538 rhs = Type::Intersect(rhs, Type::PlainNumber(), zone());
547 type = Type::PlainNumber();
552 if (maybe_minuszero) type = Type::Union(type, Type::MinusZero(), zone());
553 if (maybe_nan) type = Type::Union(type, Type::NaN(), zone());
557 Type* OperationTyper::NumberSubtract(Type* lhs, Type* rhs) {
558 DCHECK(lhs->Is(Type::Number()));
559 DCHECK(rhs->Is(Type::Number()));
562 return Type::None();
567 bool maybe_nan = lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN());
572 if (lhs->Maybe(Type::MinusZero())) {
573 lhs = Type::Union(lhs, cache_.kSingletonZero, zone());
576 if (rhs->Maybe(Type::MinusZero())) {
577 rhs = Type::Union(rhs, cache_.kSingletonZero, zone());
581 Type* type = Type::None();
582 lhs = Type::Intersect(lhs, Type::PlainNumber(), zone());
583 rhs = Type::Intersect(rhs, Type::PlainNumber(), zone());
592 type = Type::PlainNumber();
597 if (maybe_minuszero) type = Type::Union(type, Type::MinusZero(), zone());
598 if (maybe_nan) type = Type::Union(type, Type::NaN(), zone());
602 Type* OperationTyper::NumberMultiply(Type* lhs, Type* rhs) {
603 DCHECK(lhs->Is(Type::Number()));
604 DCHECK(rhs->Is(Type::Number()));
607 return Type::None();
612 if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
616 return Type::Number();
619 Type* OperationTyper::NumberDivide(Type* lhs, Type* rhs) {
620 DCHECK(lhs->Is(Type::Number()));
621 DCHECK(rhs->Is(Type::Number()));
624 return Type::None();
627 if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
632 lhs->Maybe(Type::NaN()) || rhs->Maybe(cache_.kZeroish) ||
637 Type* type = Type::PlainNumber();
638 if (maybe_minuszero) type = Type::Union(type, Type::MinusZero(), zone());
639 if (maybe_nan) type = Type::Union(type, Type::NaN(), zone());
643 Type* OperationTyper::NumberModulus(Type* lhs, Type* rhs) {
644 DCHECK(lhs->Is(Type::Number()));
645 DCHECK(rhs->Is(Type::Number()));
649 bool maybe_nan = lhs->Maybe(Type::NaN()) || rhs->Maybe(cache_.kZeroish) ||
654 if (lhs->Maybe(Type::MinusZero())) {
656 lhs = Type::Union(lhs, cache_.kSingletonZero, zone());
658 if (rhs->Maybe(Type::MinusZero())) {
659 rhs = Type::Union(rhs, cache_.kSingletonZero, zone());
663 Type* type = Type::None();
664 lhs = Type::Intersect(lhs, Type::PlainNumber(), zone());
665 rhs = Type::Intersect(rhs, Type::PlainNumber(), zone());
698 type = Type::Range(min, max, zone());
700 type = Type::PlainNumber();
705 if (maybe_minuszero) type = Type::Union(type, Type::MinusZero(), zone());
706 if (maybe_nan) type = Type::Union(type, Type::NaN(), zone());
710 Type* OperationTyper::NumberBitwiseOr(Type* lhs, Type* rhs) {
711 DCHECK(lhs->Is(Type::Number()));
712 DCHECK(rhs->Is(Type::Number()));
714 if (!lhs->IsInhabited() || !rhs->IsInhabited()) return Type::None();
744 return Type::Range(min, max, zone());
747 Type* OperationTyper::NumberBitwiseAnd(Type* lhs, Type* rhs) {
748 DCHECK(lhs->Is(Type::Number()));
749 DCHECK(rhs->Is(Type::Number()));
751 if (!lhs->IsInhabited() || !rhs->IsInhabited()) return Type::None();
775 return Type::Range(min, max, zone());
778 Type* OperationTyper::NumberBitwiseXor(Type* lhs, Type* rhs) {
779 DCHECK(lhs->Is(Type::Number()));
780 DCHECK(rhs->Is(Type::Number()));
782 if (!lhs->IsInhabited() || !rhs->IsInhabited()) return Type::None();
793 return Type::Unsigned31();
798 return Type::Negative32();
800 return Type::Signed32();
803 Type* OperationTyper::NumberShiftLeft(Type* lhs, Type* rhs) {
804 DCHECK(lhs->Is(Type::Number()));
805 DCHECK(rhs->Is(Type::Number()));
807 if (!lhs->IsInhabited() || !rhs->IsInhabited()) return Type::None();
824 return Type::Signed32();
834 if (max == kMaxInt && min == kMinInt) return Type::Signed32();
835 return Type::Range(min, max, zone());
838 Type* OperationTyper::NumberShiftRight(Type* lhs, Type* rhs) {
839 DCHECK(lhs->Is(Type::Number()));
840 DCHECK(rhs->Is(Type::Number()));
842 if (!lhs->IsInhabited() || !rhs->IsInhabited()) return Type::None();
859 if (max == kMaxInt && min == kMinInt) return Type::Signed32();
860 return Type::Range(min, max, zone());
863 Type* OperationTyper::NumberShiftRightLogical(Type* lhs, Type* rhs) {
864 DCHECK(lhs->Is(Type::Number()));
865 DCHECK(rhs->Is(Type::Number()));
867 if (!lhs->IsInhabited() || !rhs->IsInhabited()) return Type::None();
887 if (min == 0 && max == kMaxInt) return Type::Unsigned31();
888 if (min == 0 && max == kMaxUInt32) return Type::Unsigned32();
889 return Type::Range(min, max, zone());
892 Type* OperationTyper::NumberAtan2(Type* lhs, Type* rhs) {
893 DCHECK(lhs->Is(Type::Number()));
894 DCHECK(rhs->Is(Type::Number()));
895 return Type::Number();
898 Type* OperationTyper::NumberImul(Type* lhs, Type* rhs) {
899 DCHECK(lhs->Is(Type::Number()));
900 DCHECK(rhs->Is(Type::Number()));
902 return Type::Signed32();
905 Type* OperationTyper::NumberMax(Type* lhs, Type* rhs) {
906 DCHECK(lhs->Is(Type::Number()));
907 DCHECK(rhs->Is(Type::Number()));
908 if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) {
909 return Type::NaN();
911 Type* type = Type::None();
913 if (lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN())) {
914 type = Type::Union(type, Type::NaN(), zone());
916 lhs = Type::Intersect(lhs, Type::OrderedNumber(), zone());
917 rhs = Type::Intersect(rhs, Type::OrderedNumber(), zone());
921 type = Type::Union(type, Type::Range(min, max, zone()), zone());
923 type = Type::Union(type, Type::Union(lhs, rhs, zone()), zone());
928 Type* OperationTyper::NumberMin(Type* lhs, Type* rhs) {
929 DCHECK(lhs->Is(Type::Number()));
930 DCHECK(rhs->Is(Type::Number()));
931 if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) {
932 return Type::NaN();
934 Type* type = Type::None();
936 if (lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN())) {
937 type = Type::Union(type, Type::NaN(), zone());
939 lhs = Type::Intersect(lhs, Type::OrderedNumber(), zone());
940 rhs = Type::Intersect(rhs, Type::OrderedNumber(), zone());
944 type = Type::Union(type, Type::Range(min, max, zone()), zone());
946 type = Type::Union(type, Type::Union(lhs, rhs, zone()), zone());
951 Type* OperationTyper::NumberPow(Type* lhs, Type* rhs) {
952 DCHECK(lhs->Is(Type::Number()));
953 DCHECK(rhs->Is(Type::Number()));
955 return Type::Number();
959 Type* OperationTyper::Speculative##Name(Type* lhs, Type* rhs) { \
960 lhs = ToNumber(Type::Intersect(lhs, Type::NumberOrOddball(), zone())); \
961 rhs = ToNumber(Type::Intersect(rhs, Type::NumberOrOddball(), zone())); \
977 Type* OperationTyper::ToPrimitive(Type* type) {
978 if (type->Is(Type::Primitive()) && !type->Maybe(Type::Receiver())) {
981 return Type::Primitive();
984 Type* OperationTyper::Invert(Type* type) {
985 DCHECK(type->Is(Type::Boolean()));
1001 Type* OperationTyper::FalsifyUndefined(ComparisonOutcome outcome) {
1004 return (outcome & kComparisonTrue) != 0 ? Type::Boolean()
1007 // Type should be non empty, so we know it should be true.
1012 Type* OperationTyper::TypeTypeGuard(const Operator* sigma_op, Type* input) {
1013 return Type::Intersect(input, TypeGuardTypeOf(sigma_op), zone());