[builtins] Unify most of the remaining Math builtins.

src/compiler/typer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/typer.h"
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/common-operator.h"
@@ skipping 240 matching lines @@
   static Type* ToInteger(Type*, Typer*);
   static Type* ToLength(Type*, Typer*);
   static Type* ToName(Type*, Typer*);
   static Type* ToNumber(Type*, Typer*);
   static Type* ToObject(Type*, Typer*);
   static Type* ToString(Type*, Typer*);
   static Type* NumberAbs(Type*, Typer*);
   static Type* NumberCeil(Type*, Typer*);
   static Type* NumberFloor(Type*, Typer*);
   static Type* NumberRound(Type*, Typer*);
+  static Type* NumberSign(Type*, Typer*);
   static Type* NumberTrunc(Type*, Typer*);
   static Type* NumberToInt32(Type*, Typer*);
   static Type* NumberToUint32(Type*, Typer*);
 
   static Type* ObjectIsCallable(Type*, Typer*);
   static Type* ObjectIsNumber(Type*, Typer*);
   static Type* ObjectIsReceiver(Type*, Typer*);
   static Type* ObjectIsSmi(Type*, Typer*);
   static Type* ObjectIsString(Type*, Typer*);
   static Type* ObjectIsUndetectable(Type*, Typer*);
@@ skipping 265 matching lines @@
 
 // static
 Type* Typer::Visitor::NumberRound(Type* type, Typer* t) {
   DCHECK(type->Is(Type::Number()));
   if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) return type;
   // TODO(bmeurer): We could infer a more precise type here.
   return t->cache_.kIntegerOrMinusZeroOrNaN;
 }
 
 // static
+Type* Typer::Visitor::NumberSign(Type* type, Typer* t) {
+  DCHECK(type->Is(Type::Number()));
+  if (type->Is(t->cache_.kZeroish)) return type;
+  bool maybe_minuszero = type->Maybe(Type::MinusZero());
+  bool maybe_nan = type->Maybe(Type::NaN());
+  type = Type::Intersect(type, Type::PlainNumber(), t->zone());
+  if (type->Max() < 0.0) {
+    type = t->cache_.kSingletonMinusOne;
+  } else if (type->Max() <= 0.0) {
+    type = t->cache_.kMinusOneOrZero;
+  } else if (type->Min() > 0.0) {
+    type = t->cache_.kSingletonOne;
+  } else if (type->Min() >= 0.0) {
+    type = t->cache_.kZeroOrOne;
+  } else {
+    type = Type::Range(-1.0, 1.0, t->zone());
+  }
+  if (maybe_minuszero) {
+    type = Type::Union(type, Type::MinusZero(), t->zone());
+  }
+  if (maybe_nan) {
+    type = Type::Union(type, Type::NaN(), t->zone());
+  }
+  return type;
+}
+
+// static
 Type* Typer::Visitor::NumberTrunc(Type* type, Typer* t) {
   DCHECK(type->Is(Type::Number()));
   if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) return type;
   // TODO(bmeurer): We could infer a more precise type here.
   return t->cache_.kIntegerOrMinusZeroOrNaN;
 }
 
 Type* Typer::Visitor::NumberToInt32(Type* type, Typer* t) {
   if (type->Is(Type::Signed32())) return type;
   if (type->Is(t->cache_.kZeroish)) return t->cache_.kSingletonZero;
@@ skipping 821 matching lines @@
         // Unary math functions.
         case kMathAbs:
         case kMathExp:
           return Type::Union(Type::PlainNumber(), Type::NaN(), t->zone());
         case kMathLog:
         case kMathSqrt:
         case kMathCos:
         case kMathSin:
         case kMathTan:
         case kMathAcos:
+        case kMathAcosh:
         case kMathAsin:
+        case kMathAsinh:
         case kMathAtan:
+        case kMathAtanh:
         case kMathFround:
+        case kMathSign:
           return Type::Number();
         // Binary math functions.
         case kMathAtan2:
         case kMathPow:
         case kMathMax:
         case kMathMin:
           return Type::Number();
         case kMathImul:
           return Type::Signed32();
         case kMathClz32:
@@ skipping 233 matching lines @@
 Type* Typer::Visitor::TypeNumberCeil(Node* node) {
   return TypeUnaryOp(node, NumberCeil);
 }
 
 Type* Typer::Visitor::TypeNumberFloor(Node* node) {
   return TypeUnaryOp(node, NumberFloor);
 }
 
 Type* Typer::Visitor::TypeNumberFround(Node* node) { return Type::Number(); }
 
+Type* Typer::Visitor::TypeNumberSign(Node* node) {
+  return TypeUnaryOp(node, NumberSign);
+}
+
+Type* Typer::Visitor::TypeNumberAcos(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeNumberAcosh(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeNumberAsin(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeNumberAsinh(Node* node) { return Type::Number(); }
+
 Type* Typer::Visitor::TypeNumberAtan(Node* node) { return Type::Number(); }
 
+Type* Typer::Visitor::TypeNumberAtanh(Node* node) { return Type::Number(); }
+
 Type* Typer::Visitor::TypeNumberAtan2(Node* node) { return Type::Number(); }
 
-Type* Typer::Visitor::TypeNumberAtanh(Node* node) { return Type::Number(); }
-
 Type* Typer::Visitor::TypeNumberCos(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeNumberCosh(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeNumberExp(Node* node) {
   return Type::Union(Type::PlainNumber(), Type::NaN(), zone());
 }
 
 // TODO(mvstanton): Is this type sufficient, or should it look like Exp()?
 Type* Typer::Visitor::TypeNumberExpm1(Node* node) { return Type::Number(); }
@@ skipping 658 matching lines @@
 
 
 Type* Typer::Visitor::TypeFloat64Min(Node* node) { return Type::Number(); }
 
 
 Type* Typer::Visitor::TypeFloat64Abs(Node* node) {
   // TODO(turbofan): We should be able to infer a better type here.
   return Type::Number();
 }
 
+Type* Typer::Visitor::TypeFloat64Acos(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeFloat64Acosh(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeFloat64Asin(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeFloat64Asinh(Node* node) { return Type::Number(); }
+
 Type* Typer::Visitor::TypeFloat64Atan(Node* node) { return Type::Number(); }
 
+Type* Typer::Visitor::TypeFloat64Atanh(Node* node) { return Type::Number(); }
+
 Type* Typer::Visitor::TypeFloat64Atan2(Node* node) { return Type::Number(); }
 
-Type* Typer::Visitor::TypeFloat64Atanh(Node* node) { return Type::Number(); }
-
 Type* Typer::Visitor::TypeFloat64Cbrt(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeFloat64Cos(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeFloat64Cosh(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeFloat64Exp(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeFloat64Expm1(Node* node) { return Type::Number(); }
 
@@ skipping 175 matching lines @@
   }
   if (Type::IsInteger(*value)) {
     return Type::Range(value->Number(), value->Number(), zone());
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8