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 2194 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()) {

[mvstanton, 2015/04/28 14:21:20]

Could this AddressIsOptimizedCode() { STUB1 } else { STUB2 } sequence be
templatized as a method on CallIC?

[danno, 2015/04/30 13:34:32]

I'd like to avoid the template in this case, since it seems like a little bit
too much meta template zealotry for just a few lines of code that are pretty
easy to understand, but I probably could be convinced otherwise.

+            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 796 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