Delay canonicalization of 1.0 * N until after representation selection.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, 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/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1364 matching lines @@
 
 
 intptr_t BinaryDoubleOpInstr::ResultCid() const {
   // The output is not an instance but when it is boxed it becomes double.
   return kDoubleCid;
 }
 
 
 static bool ToIntegerConstant(Value* value, intptr_t* result) {
   if (!value->BindsToConstant()) {
+    if (value->definition()->IsUnboxDouble()) {
+      return ToIntegerConstant(value->definition()->AsUnboxDouble()->value(),
+                               result);
+    }
+
     return false;
   }
 
   const Object& constant = value->BoundConstant();
   if (constant.IsDouble()) {
     const Double& double_constant = Double::Cast(constant);
     *result = static_cast<intptr_t>(double_constant.value());
     return (static_cast<double>(*result) == double_constant.value());
   } else if (constant.IsSmi()) {
     *result = Smi::Cast(constant).Value();
     return true;
   }
 
   return false;
 }
 
 
-static Definition* CanonicalizeCommutativeArithmetic(
-  FlowGraphOptimizer* optimizer,
-  Definition* defn,
-  Token::Kind op,
-  intptr_t cid,
-  Value* left,
-  Value* right) {
+static Definition* CanonicalizeCommutativeArithmetic(Token::Kind op,
+                                                     intptr_t cid,
+                                                     Value* left,
+                                                     Value* right) {
   ASSERT((cid == kSmiCid) || (cid == kDoubleCid) || (cid == kMintCid));
 
   intptr_t left_value;
   if (!ToIntegerConstant(left, &left_value)) {
     return NULL;
   }
 
   switch (op) {
     case Token::kMUL:
       if (left_value == 1) {
         if ((cid == kDoubleCid) &&
             (right->definition()->representation() != kUnboxedDouble)) {
-          // Ensure that the result of the operation (right value) is coerced
-          // to double.
-          UnboxDoubleInstr* unbox =
-              new UnboxDoubleInstr(right->Copy(),
-                                   defn->DeoptimizationTarget());
-          optimizer->InsertBefore(defn,
-                                  unbox,
-                                  defn->env(),
-                                  Definition::kValue);
-          return unbox;
+          // Can't yet apply the equivalence because representation selection
+          // did not run yet. We need it to guarantee that right value is
+          // correctly coerced to double. The second canonicalization pass
+          // will apply this equivalence.
+          return NULL;
         } else {
           return right->definition();
         }
       } else if ((left_value == 0) && (cid != kDoubleCid)) {
         // Can't apply this equivalence to double operation because
         // 0.0 * NaN is NaN not 0.0.
         return left->definition();
       }
       break;
     case Token::kADD:
@@ skipping 29 matching lines @@
       break;
   }
 
   return NULL;
 }
 
 
 Definition* BinaryDoubleOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   Definition* result = NULL;
 
-  result = CanonicalizeCommutativeArithmetic(optimizer,
-                                             this,
-                                             op_kind(),
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kDoubleCid,
                                              left(),
                                              right());
   if (result != NULL) {
     return result;
   }
 
-  result = CanonicalizeCommutativeArithmetic(optimizer,
-                                             this,
-                                             op_kind(),
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kDoubleCid,
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
 Definition* BinarySmiOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   Definition* result = NULL;
 
-  result = CanonicalizeCommutativeArithmetic(optimizer,
-                                             this,
-                                             op_kind(),
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kSmiCid,
                                              left(),
                                              right());
   if (result != NULL) {
     return result;
   }
 
-  result = CanonicalizeCommutativeArithmetic(optimizer,
-                                             this,
-                                             op_kind(),
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kSmiCid,
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
 Definition* BinaryMintOpInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   Definition* result = NULL;
 
-  result = CanonicalizeCommutativeArithmetic(optimizer,
-                                             this,
-                                             op_kind(),
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kMintCid,
                                              left(),
                                              right());
   if (result != NULL) {
     return result;
   }
 
-  result = CanonicalizeCommutativeArithmetic(optimizer,
-                                             this,
-                                             op_kind(),
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
                                              kMintCid,
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
@@ skipping 1397 matching lines @@
     default:
       UNREACHABLE();
       return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart