Revert "Suppress canonicalization of Unbox() instruction that can deoptimize."

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/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 771 matching lines @@
       if (curr == this) return true;
     }
 
     return false;
   }
 
   return dom_block->Dominates(block);
 }
 
 
-bool Instruction::HasUnmatchedInputRepresentations() const {
-  for (intptr_t i = 0; i < InputCount(); i++) {
-    Definition* input = InputAt(i)->definition();
-    if (RequiredInputRepresentation(i) != input->representation()) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-
 void Definition::ReplaceWith(Definition* other,
                              ForwardInstructionIterator* iterator) {
   // Record other's input uses.
   for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
     Value* input = other->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   // Take other's environment from this definition.
   ASSERT(other->env() == NULL);
   other->SetEnvironment(env());
@@ skipping 1185 matching lines @@
     }
 
     return replacement;
   }
 
   return this;
 }
 
 
 Definition* UnboxInstr::Canonicalize(FlowGraph* flow_graph) {
-  if (!HasUses() && !CanDeoptimize()) return NULL;
+  if (!HasUses()) return NULL;
 
   // Fold away Unbox<rep>(Box<rep>(v)).
   BoxInstr* box_defn = value()->definition()->AsBox();
   if ((box_defn != NULL) &&
       (box_defn->from_representation() == representation())) {
     return box_defn->value()->definition();
   }
 
   if ((representation() == kUnboxedDouble) && value()->BindsToConstant()) {
     UnboxedConstantInstr* uc = NULL;
@@ skipping 235 matching lines @@
   Isolate* isolate = flow_graph->isolate();
   // Only handle strict-compares.
   if (comparison()->IsStrictCompare()) {
     bool negated = false;
     Definition* replacement =
         CanonicalizeStrictCompare(comparison()->AsStrictCompare(), &negated);
     if (replacement == comparison()) {
       return this;
     }
     ComparisonInstr* comp = replacement->AsComparison();
-    if ((comp == NULL) ||
-        comp->CanDeoptimize() ||
-        comp->HasUnmatchedInputRepresentations()) {
+    if ((comp == NULL) || comp->CanDeoptimize()) {
       return this;
     }
 
+    // Assert that the comparison is not serving as a pending deoptimization
+    // target for conversions.
+    for (intptr_t i = 0; i < comp->InputCount(); i++) {
+      if (comp->RequiredInputRepresentation(i) !=
+          comp->InputAt(i)->definition()->representation()) {
+        return this;
+      }
+    }
+
     // Replace the comparison if the replacement is used at this branch,
     // and has exactly one use.
     Value* use = comp->input_use_list();
     if ((use->instruction() == this) && comp->HasOnlyUse(use)) {
       if (negated) {
         comp->NegateComparison();
       }
       RemoveEnvironment();
       flow_graph->CopyDeoptTarget(this, comp);
       // Unlink environment from the comparison since it is copied to the
@@ skipping 1089 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart