Convert BinadryDoubleOp to MathUnaryInstr double-square if both inputs are the same. Uses less regi…

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1344 matching lines @@
   return this;
 }
 
 
 Definition* FloatToDoubleInstr::Canonicalize(FlowGraph* flow_graph) {
   return HasUses() ? this : NULL;
 }
 
 
 Definition* BinaryDoubleOpInstr::Canonicalize(FlowGraph* flow_graph) {
+  if (!HasUses()) return NULL;
+
   Definition* result = NULL;
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kDoubleCid,
                                              left(),
                                              right());
+  if (result == NULL) {
+    result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                               kDoubleCid,
+                                               right(),
+                                               left());
+  }
   if (result != NULL) {
     return result;
   }
 
-  result = CanonicalizeCommutativeArithmetic(op_kind(),
-                                             kDoubleCid,
-                                             right(),
-                                             left());
-  if (result != NULL) {
-    return result;
+  if ((op_kind() == Token::kMUL) &&
+      (left()->definition() == right()->definition())) {
+    MathUnaryInstr* math_unary =
+        new MathUnaryInstr(MathUnaryInstr::kDoubleSquare,
+                           new Value(left()->definition()),
+                           Isolate::kNoDeoptId);
+    flow_graph->InsertBefore(this, math_unary, NULL, Definition::kValue);
+    return math_unary;
   }
 
   return this;
 }
 
 
 Definition* BinarySmiOpInstr::Canonicalize(FlowGraph* flow_graph) {
   Definition* result = NULL;
 
   result = CanonicalizeCommutativeArithmetic(op_kind(),
@@ skipping 1935 matching lines @@
     "libc_cos", reinterpret_cast<RuntimeFunction>(
         static_cast<UnaryMathCFunction>(&cos)), 1, true, true);
 
 extern const RuntimeEntry kSinRuntimeEntry(
     "libc_sin", reinterpret_cast<RuntimeFunction>(
         static_cast<UnaryMathCFunction>(&sin)), 1, true, true);
 
 
 const RuntimeEntry& MathUnaryInstr::TargetFunction() const {
   switch (kind()) {
-    case MethodRecognizer::kMathSin:
+    case MathUnaryInstr::kSin:
       return kSinRuntimeEntry;
-    case MethodRecognizer::kMathCos:
+    case MathUnaryInstr::kCos:
       return kCosRuntimeEntry;
     default:
       UNREACHABLE();
   }
   return kSinRuntimeEntry;
 }
 
 
+const char* MathUnaryInstr::KindToCString(MathUnaryKind kind) {
+  switch (kind) {
+    case kIllegal:       return "illegal";
+    case kSin:           return "sin";
+    case kCos:           return "cos";
+    case kSqrt:          return "sqrt";
+    case kDoubleSquare:  return "double-square";
+  }
+  UNREACHABLE();
+  return "";
+}
+
+
 MergedMathInstr::MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                                  intptr_t original_deopt_id,
                                  MergedMathInstr::Kind kind)
     : inputs_(inputs),
       kind_(kind) {
   ASSERT(inputs_->length() == InputCountFor(kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
@@ skipping 16 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart