Revert "Introduce InvokeMathCFunction that can be used to directly invoke mathematical function pro…

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 1271 matching lines @@
                                           index->Copy(),
                                           cid,
                                           call),
                  call->env(),
                  Definition::kEffect);
   }
   return new LoadIndexedInstr(str, index, cid);
 }
 
 
-void FlowGraphOptimizer::ReplaceWithMathCFunction(
-  InstanceCallInstr* call,
-  MethodRecognizer::Kind recognized_kind) {
-  AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-  ZoneGrowableArray<Value*>* args =
-      new ZoneGrowableArray<Value*>(call->ArgumentCount());
-  for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
-    args->Add(call->ArgumentAt(i)->value());
-  }
-  InvokeMathCFunctionInstr* invoke =
-      new InvokeMathCFunctionInstr(args, call, recognized_kind);
-  call->ReplaceWith(invoke, current_iterator());
-  RemovePushArguments(call);
-}
-
-
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
@@ skipping 27 matching lines @@
   if ((recognized_kind == MethodRecognizer::kIntegerToDouble) &&
       (class_ids[0] == kSmiCid)) {
     SmiToDoubleInstr* s2d_instr = new SmiToDoubleInstr(call);
     call->ReplaceWith(s2d_instr, current_iterator());
     // Pushed arguments are not removed because SmiToDouble is implemented
     // as a call.
     return true;
   }
 
   if (class_ids[0] == kDoubleCid) {
-    switch (recognized_kind) {
-      case MethodRecognizer::kDoubleToInteger: {
-        AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-        ASSERT(call->HasICData());
-        const ICData& ic_data = *call->ic_data();
-        Definition* d2i_instr = NULL;
-        if (ic_data.deopt_reason() == kDeoptDoubleToSmi) {
-          // Do not repeatedly deoptimize because result didn't fit into Smi.
-          d2i_instr = new DoubleToIntegerInstr(call->ArgumentAt(0)->value(),
-                                               call);
-        } else {
-          // Optimistically assume result fits into Smi.
-          d2i_instr = new DoubleToSmiInstr(call->ArgumentAt(0)->value(), call);
-        }
-        call->ReplaceWith(d2i_instr, current_iterator());
-        RemovePushArguments(call);
-        return true;
+    if (recognized_kind == MethodRecognizer::kDoubleToInteger) {
+      AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+      ASSERT(call->HasICData());
+      const ICData& ic_data = *call->ic_data();
+      Definition* d2i_instr = NULL;
+      if (ic_data.deopt_reason() == kDeoptDoubleToSmi) {
+        // Do not repeatedly deoptimize because result didn't fit into Smi.
+        d2i_instr = new DoubleToIntegerInstr(call->ArgumentAt(0)->value(),
+                                             call);
+      } else {
+        // Optimistically assume result fits into Smi.
+        d2i_instr = new DoubleToSmiInstr(call->ArgumentAt(0)->value(), call);
       }
-      case MethodRecognizer::kDoublePow:
-        ReplaceWithMathCFunction(call, recognized_kind);
-        return true;
-      case MethodRecognizer::kDoubleTruncate:
-      case MethodRecognizer::kDoubleRound:
-      case MethodRecognizer::kDoubleFloor:
-      case MethodRecognizer::kDoubleCeil:
-        if (!CPUFeatures::double_truncate_round_supported()) {
-          ReplaceWithMathCFunction(call, recognized_kind);
-        } else {
-          AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
-          DoubleToDoubleInstr* d2d_instr =
-              new DoubleToDoubleInstr(call->ArgumentAt(0)->value(),
-                                      call,
-                                      recognized_kind);
-          call->ReplaceWith(d2d_instr, current_iterator());
-          RemovePushArguments(call);
-        }
-        return true;
-      default:
-        // Unsupported method.
+      call->ReplaceWith(d2i_instr, current_iterator());
+      RemovePushArguments(call);
+      return true;
+    }
+    if ((recognized_kind == MethodRecognizer::kDoubleTruncate) ||
+        (recognized_kind == MethodRecognizer::kDoubleRound) ||
+        (recognized_kind == MethodRecognizer::kDoubleFloor) ||
+        (recognized_kind == MethodRecognizer::kDoubleCeil)) {
+      if (!CPUFeatures::double_truncate_round_supported()) {
         return false;
+      }
+      AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
+      DoubleToDoubleInstr* d2d_instr =
+          new DoubleToDoubleInstr(call->ArgumentAt(0)->value(),
+                                  call,
+                                  recognized_kind);
+      call->ReplaceWith(d2d_instr, current_iterator());
+      RemovePushArguments(call);
+      return true;
     }
   }
 
   return false;
 }
 
 
 // Returns a Boolean constant if all classes in ic_data yield the same type-test
 // result and the type tests do not depend on type arguments. Otherwise return
 // Bool::null().
@@ skipping 2962 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitDoubleToDouble(DoubleToDoubleInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitInvokeMathCFunction(
-    InvokeMathCFunctionInstr* instr) {
-  // TODO(kmillikin): Handle conversion.
-  SetValue(instr, non_constant_);
-}
-
 void ConstantPropagator::VisitConstant(ConstantInstr* instr) {
   SetValue(instr, instr->value());
 }
 
 
 void ConstantPropagator::VisitConstraint(ConstraintInstr* instr) {
   // Should not be used outside of range analysis.
   UNREACHABLE();
 }
 
@@ skipping 207 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart