Reland r17365.

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

[srdjan, 2013/01/22 21:19:42]

Indent 4 spaces

+  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) {
-    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);
+    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;
       }
-      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()) {
+      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()) {

[srdjan, 2013/01/22 21:19:42]

I prefer to test for positive instead of for negative as IMHO it makes code more
readable.

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