Track side-effect free paths in the graph to allow CSE and LICM for instructions that depend on som…

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/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 85 matching lines @@
     // TODO(fschneider): Make sure ic_data are sorted to hit more cases.
     if (unary_checks().GetReceiverClassIdAt(i) !=
         other_check->unary_checks().GetReceiverClassIdAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
-bool CheckClassInstr::AffectedBySideEffect() const {
-  // The class-id of string objects is not invariant: Externalization of strings
-  // via the API can change the class-id.
-  return unary_checks().HasReceiverClassId(kOneByteStringCid)
-      || unary_checks().HasReceiverClassId(kTwoByteStringCid);
+EffectSet CheckClassInstr::Dependencies() const {
+  // Externalization of strings via the API can change the class-id.
+  const bool externalizable =
+      unary_checks().HasReceiverClassId(kOneByteStringCid) ||
+      unary_checks().HasReceiverClassId(kTwoByteStringCid);

[srdjan, 2013/04/29 17:16:26]

Need to add all typed data arrays as well.

[Vyacheslav Egorov (Google), 2013/04/30 14:01:33]

I suggest we add them in a separate CL.

+  return externalizable ? EffectSet::All() : EffectSet::None();

[Florian Schneider, 2013/04/29 12:11:54]

Shouldn't the dependencies be EffectSet::kExternalizable?

Right now, there is no difference because it is equals to All().

[Vyacheslav Egorov (Google), 2013/04/30 14:01:33]

Done.

 }
 
 
 bool GuardFieldInstr::AttributesEqual(Instruction* other) const {
   return field().raw() == other->AsGuardField()->field().raw();
 }
 
 
-bool GuardFieldInstr::AffectedBySideEffect() const {
-  return false;
-}
-
-
 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);
@@ skipping 12 matching lines @@
 
 bool BinarySmiOpInstr::AttributesEqual(Instruction* other) const {
   BinarySmiOpInstr* other_op = other->AsBinarySmiOp();
   ASSERT(other_op != NULL);
   return (op_kind() == other_op->op_kind()) &&
       (overflow_ == other_op->overflow_) &&
       (is_truncating_ == other_op->is_truncating_);
 }
 
 
+EffectSet LoadFieldInstr::Dependencies() const {
+  return immutable_ ? EffectSet::None() : EffectSet::All();
+}
+
+
 bool LoadFieldInstr::AttributesEqual(Instruction* other) const {
   LoadFieldInstr* other_load = other->AsLoadField();
   ASSERT(other_load != NULL);
   ASSERT((offset_in_bytes() != other_load->offset_in_bytes()) ||
          ((immutable_ == other_load->immutable_)));
   return offset_in_bytes() == other_load->offset_in_bytes();
 }
 
 
+EffectSet LoadStaticFieldInstr::Dependencies() const {
+  return field().is_final() ? EffectSet::None() : EffectSet::All();
+}
+
+
 bool LoadStaticFieldInstr::AttributesEqual(Instruction* other) const {
   LoadStaticFieldInstr* other_load = other->AsLoadStaticField();
   ASSERT(other_load != NULL);
   // Assert that the field is initialized.
   ASSERT(field().value() != Object::sentinel().raw());
   ASSERT(field().value() != Object::transition_sentinel().raw());
   return field().raw() == other_load->field().raw();
 }
 
 
+EffectSet LoadIndexedInstr::Dependencies() const {
+  return EffectSet::All();
+}
+
+
 bool LoadIndexedInstr::AttributesEqual(Instruction* other) const {
   LoadIndexedInstr* other_load = other->AsLoadIndexed();
   ASSERT(other_load != NULL);
   return class_id() == other_load->class_id();
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
   ASSERT(other_constant != NULL);
@@ skipping 1518 matching lines @@
     defn = defn->AsConstraint()->value()->definition();
   }
   return defn;
 }
 
 
 static bool AreEqualDefinitions(Definition* a, Definition* b) {
   a = UnwrapConstraint(a);
   b = UnwrapConstraint(b);
   return (a == b) ||
-      (!a->AffectedBySideEffect() &&
-       !b->AffectedBySideEffect() &&
+      (a->AllowsCSE() &&
+       a->Dependencies().IsNone() &&
+       b->AllowsCSE() &&
+       b->Dependencies().IsNone() &&
        a->Equals(b));
 }
 
 
 // Returns true if two range boundaries refer to the same symbol.
 static bool DependOnSameSymbol(const RangeBoundary& a, const RangeBoundary& b) {
   return a.IsSymbol() && b.IsSymbol() &&
       AreEqualDefinitions(a.symbol(), b.symbol());
 }
 
@@ skipping 655 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart