Collect type feedback on result of Math.[round|ceil|floor]

src/ic/ic.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/base/bits.h"
@@ skipping 2205 matching lines @@
 }
 
 
 bool CallIC::DoCustomHandler(Handle<Object> function,
                              const CallICState& callic_state) {
   DCHECK(FLAG_use_ic && function->IsJSFunction());
 
   // Are we the array function?
   Handle<JSFunction> array_function =
       Handle<JSFunction>(isolate()->native_context()->array_function());
+  CallICNexus* nexus = casted_nexus<CallICNexus>();
   if (array_function.is_identical_to(Handle<JSFunction>::cast(function))) {
     // Alter the slot.
-    CallICNexus* nexus = casted_nexus<CallICNexus>();
     nexus->ConfigureMonomorphicArray();
 
     // Vector-based ICs have a different calling convention in optimized code
     // than full code so the correct stub has to be chosen.
     if (AddressIsOptimizedCode()) {
       CallIC_ArrayStub stub(isolate(), callic_state);
       set_target(*stub.GetCode());
     } else {
       CallIC_ArrayTrampolineStub stub(isolate(), callic_state);
       set_target(*stub.GetCode());
     }
 
     Handle<String> name;
     if (array_function->shared()->name()->IsString()) {
       name = Handle<String>(String::cast(array_function->shared()->name()),
                             isolate());
     }
     TRACE_IC("CallIC", name);
     OnTypeFeedbackChanged(isolate(), get_host(), nexus->vector(), state(),
                           MONOMORPHIC);
     return true;
+  } else {
+    Handle<JSFunction> maybe_builtin(Handle<JSFunction>::cast(function));
+    if (maybe_builtin->shared()->HasBuiltinFunctionId()) {
+      BuiltinFunctionId id = maybe_builtin->shared()->builtin_function_id();
+      switch (id) {
+        case kMathRound: {
+          nexus->ConfigureMonomorphicMathFunction(maybe_builtin);
+          if (AddressIsOptimizedCode()) {
+            CallIC_RoundStub stub(isolate(), callic_state);
+            set_target(*stub.GetCode());
+          } else {
+            CallIC_RoundTrampolineStub stub(isolate(), callic_state);
+            set_target(*stub.GetCode());
+          }
+          return true;
+        }
+        case kMathFloor:
+          nexus->ConfigureMonomorphicMathFunction(maybe_builtin);
+          if (AddressIsOptimizedCode()) {
+            CallIC_FloorStub stub(isolate(), callic_state);
+            set_target(*stub.GetCode());
+          } else {
+            CallIC_FloorTrampolineStub stub(isolate(), callic_state);
+            set_target(*stub.GetCode());
+          }
+          return true;
+          break;
+        case kMathCeil:
+          nexus->ConfigureMonomorphicMathFunction(maybe_builtin);
+          if (AddressIsOptimizedCode()) {
+            CallIC_CeilStub stub(isolate(), callic_state);
+            set_target(*stub.GetCode());
+          } else {
+            CallIC_CeilTrampolineStub stub(isolate(), callic_state);
+            set_target(*stub.GetCode());
+          }
+          return true;
+          break;
+        default:
+          break;
+      }
+    }
   }
   return false;
 }
 
 
 void CallIC::PatchMegamorphic(Handle<Object> function) {
   CallICState callic_state(target()->extra_ic_state());
 
   // We are going generic.
   CallICNexus* nexus = casted_nexus<CallICNexus>();
@@ skipping 791 matching lines @@
 static const Address IC_utilities[] = {
 #define ADDR(name) FUNCTION_ADDR(name),
     IC_UTIL_LIST(ADDR) NULL
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) { return IC_utilities[id]; }
 }
 }  // namespace v8::internal