Revert of 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