[vm] Cleanup Instruction::Dependencies(), EffectSet, BlockEffects

runtime/vm/redundancy_elimination.cc

 // Copyright (c) 2016, 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/redundancy_elimination.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
@@ skipping 13 matching lines @@
 #define Z (zone())
 
 class CSEInstructionMap : public ValueObject {
  public:
   CSEInstructionMap() : map_() {}
   explicit CSEInstructionMap(const CSEInstructionMap& other)
       : ValueObject(), map_(other.map_) {}
 
   Instruction* Lookup(Instruction* other) const {
     ASSERT(other->AllowsCSE());
-    ASSERT(other->Dependencies().IsNone());
     return map_.LookupValue(other);
   }
 
   void Insert(Instruction* instr) {
     ASSERT(instr->AllowsCSE());
-    ASSERT(instr->Dependencies().IsNone());
     return map_.Insert(instr);
   }
 
  private:
   typedef DirectChainedHashMap<PointerKeyValueTrait<Instruction> > Map;
 
   Map map_;
 };
 
 // Place describes an abstract location (e.g. field) that IR can load
@@ skipping 1307 matching lines @@
     // Do not hoist any.
     return;
   }
 
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
       flow_graph()->LoopHeaders();
 
   ZoneGrowableArray<BitVector*>* loop_invariant_loads =
       flow_graph()->loop_invariant_loads();
 
-  BlockEffects* block_effects = flow_graph()->block_effects();
-
   for (intptr_t i = 0; i < loop_headers.length(); ++i) {
     BlockEntryInstr* header = loop_headers[i];
     // Skip loop that don't have a pre-header block.
     BlockEntryInstr* pre_header = header->ImmediateDominator();
     if (pre_header == NULL) continue;
 
     for (BitVector::Iterator loop_it(header->loop_info()); !loop_it.Done();
          loop_it.Advance()) {
       BlockEntryInstr* block = flow_graph()->preorder()[loop_it.Current()];
       for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
         Instruction* current = it.Current();
-        if ((current->AllowsCSE() &&
-             block_effects->CanBeMovedTo(current, pre_header)) ||
+        if (current->AllowsCSE() ||
             IsLoopInvariantLoad(loop_invariant_loads, i, current)) {
           bool inputs_loop_invariant = true;
           for (int i = 0; i < current->InputCount(); ++i) {
             Definition* input_def = current->InputAt(i)->definition();
             if (!input_def->GetBlock()->Dominates(pre_header)) {
               inputs_loop_invariant = false;
               break;
             }
           }
           if (inputs_loop_invariant && !current->IsAssertAssignable() &&
@@ skipping 691 matching lines @@
     }
 
     return true;
   }
 
   // Returns true if definitions are congruent assuming their inputs
   // are congruent.
   bool CanBeCongruent(Definition* a, Definition* b) {
     return (a->tag() == b->tag()) &&
            ((a->IsPhi() && (a->GetBlock() == b->GetBlock())) ||
-            (a->AllowsCSE() && a->Dependencies().IsNone() &&
-             a->AttributesEqual(b)));
+            (a->AllowsCSE() && a->AttributesEqual(b)));
   }
 
   // Given two definitions check if they are congruent under assumption that
   // their inputs will be proven congruent. If they are - add them to the
   // worklist to check their inputs' congruency.
   // Returns true if pair was added to the worklist or is already in the
   // worklist and false if a and b are not congruent.
   bool AddPairToCongruencyWorklist(Definition* a, Definition* b) {
     if (!CanBeCongruent(a, b)) {
       return false;
@@ skipping 221 matching lines @@
 }
 
 bool DominatorBasedCSE::OptimizeRecursive(FlowGraph* graph,
                                           BlockEntryInstr* block,
                                           CSEInstructionMap* map) {
   bool changed = false;
   for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     if (current->AllowsCSE()) {
       Instruction* replacement = map->Lookup(current);
-      ASSERT((replacement == NULL) || replacement->AllowsCSE());
-      if ((replacement != NULL) &&
-          graph->block_effects()->IsAvailableAt(replacement, block)) {
+
+      if (replacement != NULL) {
         // Replace current with lookup result.
+        ASSERT(replacement->AllowsCSE());
         graph->ReplaceCurrentInstruction(&it, current, replacement);
         changed = true;
         continue;
       }
 
-      // For simplicity we assume that instruction either does not depend on
-      // anything or does not affect anything. If this is not the case then
-      // we should first remove affected instructions from the map and
-      // then add instruction to the map so that it does not kill itself.
-      ASSERT(!current->HasUnknownSideEffects() ||
-             current->Dependencies().IsNone());
       map->Insert(current);
     }
   }
 
   // Process children in the dominator tree recursively.
   intptr_t num_children = block->dominated_blocks().length();
   if (num_children != 0) {
     graph->thread()->CheckForSafepoint();
   }
   for (intptr_t i = 0; i < num_children; ++i) {
@@ skipping 943 matching lines @@
       if (to_index == 0) {
         join->phis_ = NULL;
       } else {
         join->phis_->TruncateTo(to_index);
       }
     }
   }
 }
 
 }  // namespace dart