Give simple types to Math.Min, Math.Max, Math.Fround, Math.Clz32.

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/graph-inl.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 34 matching lines @@
   Type* object = Type::Object();
   Type* undefined = Type::Undefined();
   Type* weakint = Type::Union(
       integer, Type::Union(Type::NaN(), Type::MinusZero(), zone), zone);
 
   number_fun0_ = Type::Function(number, zone);
   number_fun1_ = Type::Function(number, number, zone);
   number_fun2_ = Type::Function(number, number, number, zone);
   weakint_fun1_ = Type::Function(weakint, number, zone);
   imul_fun_ = Type::Function(signed32, integral32, integral32, zone);
+  clz32_fun_ = Type::Function(
+      Type::Range(zero, f->NewNumber(32), zone), number, zone);
   random_fun_ = Type::Function(Type::Union(
       Type::UnsignedSmall(), Type::OtherNumber(), zone), zone);
 
   Type* int8 = Type::Intersect(
       Type::Range(f->NewNumber(-0x7F), f->NewNumber(0x7F-1), zone),
       Type::UntaggedInt8(), zone);
   Type* int16 = Type::Intersect(
       Type::Range(f->NewNumber(-0x7FFF), f->NewNumber(0x7FFF-1), zone),
       Type::UntaggedInt16(), zone);
   Type* uint8 = Type::Intersect(
@@ skipping 1462 matching lines @@
 }
 
 
 // Heap constants.
 
 
 Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
   if (value->IsJSFunction()) {
     if (JSFunction::cast(*value)->shared()->HasBuiltinFunctionId()) {
       switch (JSFunction::cast(*value)->shared()->builtin_function_id()) {
         // TODO(rossberg): can't express overloading

[rossberg, 2014/10/15 12:32:08]

This comment should stay with MathAbs

+        case kMathRandom:
+          return typer_->random_fun_;
+        case kMathFloor:
+          return typer_->weakint_fun1_;
+        case kMathRound:
+          return typer_->weakint_fun1_;
+        case kMathCeil:
+          return typer_->weakint_fun1_;
         case kMathAbs:
           return typer_->number_fun1_;
+        case kMathLog:
+          return typer_->number_fun1_;
+        case kMathExp:
+          return typer_->number_fun1_;
+        case kMathSqrt:
+          return typer_->number_fun1_;
+        case kMathPow:
+          return typer_->number_fun2_;
+        case kMathMax:
+          return typer_->number_fun2_;
+        case kMathMin:
+          return typer_->number_fun2_;
+        case kMathCos:
+          return typer_->number_fun1_;
+        case kMathSin:
+          return typer_->number_fun1_;
+        case kMathTan:
+          return typer_->number_fun1_;
         case kMathAcos:
           return typer_->number_fun1_;
         case kMathAsin:
           return typer_->number_fun1_;
         case kMathAtan:
           return typer_->number_fun1_;
         case kMathAtan2:
           return typer_->number_fun2_;
-        case kMathCeil:
-          return typer_->weakint_fun1_;
-        case kMathCos:
-          return typer_->number_fun1_;
-        case kMathExp:
-          return typer_->number_fun1_;
-        case kMathFloor:
-          return typer_->weakint_fun1_;
         case kMathImul:
           return typer_->imul_fun_;
-        case kMathLog:
-          return typer_->number_fun1_;
-        case kMathPow:
-          return typer_->number_fun2_;
-        case kMathRandom:
-          return typer_->random_fun_;
-        case kMathRound:
-          return typer_->weakint_fun1_;
-        case kMathSin:
-          return typer_->number_fun1_;
-        case kMathSqrt:
-          return typer_->number_fun1_;
-        case kMathTan:
+        case kMathClz32:
+          return typer_->clz32_fun_;
+        case kMathFround:
           return typer_->number_fun1_;
         default:
           break;
       }
     } else if (JSFunction::cast(*value)->IsBuiltin() && !context().is_null()) {
       Handle<Context> native =
           handle(context().ToHandleChecked()->native_context(), isolate());
       if (*value == native->array_buffer_fun()) {
         return typer_->array_buffer_fun_;
       } else if (*value == native->int8_array_fun()) {
@@ skipping 33 matching lines @@
 }
 
 
 void Typer::DecorateGraph(Graph* graph) {
   graph->AddDecorator(new (zone()) TyperDecorator(this));
 }
 
 }
 }
 }  // namespace v8::internal::compiler