Enable more redundancy elimination for checked mode asserts.

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 68 matching lines @@
 }
 
 
 bool CheckArrayBoundInstr::AttributesEqual(Instruction* other) const {
   CheckArrayBoundInstr* other_check = other->AsCheckArrayBound();
   ASSERT(other_check != NULL);
   return array_type() == other_check->array_type();
 }
 
 
+bool AssertAssignableInstr::AttributesEqual(Instruction* other) const {
+  AssertAssignableInstr* other_assert = other->AsAssertAssignable();
+  ASSERT(other_assert != NULL);
+  // This predicate has to be commutative for DominatorBasedCSE to work.
+  // TODO(fschneider): Eliminate more asserts with subtype relation.
+  return dst_type().raw() == other_assert->dst_type().raw();
+}
+
+
 bool StrictCompareInstr::AttributesEqual(Instruction* other) const {
   StrictCompareInstr* other_op = other->AsStrictCompare();
   ASSERT(other_op != NULL);
   return kind() == other_op->kind();
 }
 
 
 bool BinarySmiOpInstr::AttributesEqual(Instruction* other) const {
   BinarySmiOpInstr* other_op = other->AsBinarySmiOp();
   ASSERT(other_op != NULL);
@@ skipping 1298 matching lines @@
   return this;
 }
 
 
 Definition* AssertBooleanInstr::Canonicalize() {
   const intptr_t value_cid = value()->ResultCid();
   return (value_cid == kBoolCid) ? value()->definition() : this;
 }
 
 
+Definition* AssertAssignableInstr::Canonicalize() {
+  // (1) Replace the assert with its input if the input has a known compatible
+  // class-id. The class-ids handled here are those that are known to be
+  // results of IL instructions.
+  intptr_t cid = value()->ResultCid();
+  bool is_redundant = false;
+  if (dst_type().IsIntType()) {
+    is_redundant = (cid == kSmiCid) || (cid == kMintCid);
+  } else if (dst_type().IsDoubleType()) {
+    is_redundant = (cid == kDoubleCid);
+  } else if (dst_type().IsBoolType()) {
+    is_redundant = (cid == kBoolCid);
+  }
+  if (is_redundant) return value()->definition();
+
+  // (2) Replace the assert with its input if the input is the result of a
+  // compatible assert itself.
+  AssertAssignableInstr* check = value()->definition()->AsAssertAssignable();
+  if ((check != NULL) && (check->dst_type().raw() == dst_type().raw())) {
+    // TODO(fschneider): Eliminate more asserts with subtype relation.
+    return check;
+  }
+  return this;
+}
+
 Definition* StrictCompareInstr::Canonicalize() {
   if (!right()->BindsToConstant()) return this;
   const Object& right_constant = right()->BoundConstant();
   Definition* left_defn = left()->definition();
   // TODO(fschneider): Handle other cases: e === false and e !== true/false.
   // Handles e === true.
   if ((kind() == Token::kEQ_STRICT) &&
       (right_constant.raw() == Bool::True()) &&
       (left()->ResultCid() == kBoolCid)) {
     // Return left subexpression as the replacement for this instruction.
@@ skipping 751 matching lines @@
     new_max = new_max.Clamp();
   }
 
   return Range::Update(&range_, new_min, new_max);
 }
 
 
 #undef __
 
 }  // namespace dart