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

runtime/vm/flow_graph.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/flow_graph.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 22 matching lines @@
       num_copied_params_(parsed_function.num_copied_params()),
       num_non_copied_params_(parsed_function.num_non_copied_params()),
       graph_entry_(graph_entry),
       preorder_(),
       postorder_(),
       reverse_postorder_(),
       optimized_block_order_(),
       constant_null_(NULL),
       constant_dead_(NULL),
       constant_empty_context_(NULL),
-      block_effects_(NULL),
       licm_allowed_(true),
       loop_headers_(NULL),
       loop_invariant_loads_(NULL),
       deferred_prefixes_(parsed_function.deferred_prefixes()),
       await_token_positions_(NULL),
       captured_parameters_(new (zone()) BitVector(zone(), variable_count())),
       inlining_id_(-1) {
   DiscoverBlocks();
 }
 
@@ skipping 178 matching lines @@
   }
 
   ASSERT(postorder_.length() == preorder_.length());
 
   // Create an array of blocks in reverse postorder.
   intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; ++i) {
     reverse_postorder_.Add(postorder_[block_count - i - 1]);
   }
 
-  // Block effects are using postorder numbering. Discard computed information.
-  block_effects_ = NULL;
   loop_headers_ = NULL;
   loop_invariant_loads_ = NULL;
 }
 
 void FlowGraph::MergeBlocks() {
   bool changed = false;
   BitVector* merged = new (zone()) BitVector(zone(), postorder().length());
   for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
@@ skipping 1153 matching lines @@
   // Iterate each block, skipping the graph entry.
   for (intptr_t i = 1; i < preorder_.length(); ++i) {
     for (ForwardInstructionIterator it(preorder_[i]); !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
-void FlowGraph::ComputeBlockEffects() {
-  block_effects_ = new (zone()) BlockEffects(this);
-}
-
-BlockEffects::BlockEffects(FlowGraph* flow_graph)
-    : available_at_(flow_graph->postorder().length()) {
-  // We are tracking a single effect.
-  ASSERT(EffectSet::kLastEffect == 1);
-  Zone* zone = flow_graph->zone();
-  const intptr_t block_count = flow_graph->postorder().length();
-
-  // Set of blocks that contain side-effects.
-  BitVector* kill = new (zone) BitVector(zone, block_count);
-
-  // Per block available-after sets. Block A is available after the block B if
-  // and only if A is either equal to B or A is available at B and B contains no
-  // side-effects. Initially we consider all blocks available after all other
-  // blocks.
-  GrowableArray<BitVector*> available_after(block_count);
-
-  // Discover all blocks with side-effects.
-  for (BlockIterator it = flow_graph->postorder_iterator(); !it.Done();
-       it.Advance()) {
-    available_at_.Add(NULL);
-    available_after.Add(NULL);
-
-    BlockEntryInstr* block = it.Current();
-    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
-      if (it.Current()->HasUnknownSideEffects()) {
-        kill->Add(block->postorder_number());
-        break;
-      }
-    }
-  }
-
-  BitVector* temp = new (zone) BitVector(zone, block_count);
-
-  // Recompute available-at based on predecessors' available-after until the fix
-  // point is reached.
-  bool changed;
-  do {
-    changed = false;
-
-    for (BlockIterator it = flow_graph->reverse_postorder_iterator();
-         !it.Done(); it.Advance()) {
-      BlockEntryInstr* block = it.Current();
-      const intptr_t block_num = block->postorder_number();
-
-      if (block->IsGraphEntry()) {
-        temp->Clear();  // Nothing is live-in into graph entry.
-      } else {
-        // Available-at is an intersection of all predecessors' available-after
-        // sets.
-        temp->SetAll();
-        for (intptr_t i = 0; i < block->PredecessorCount(); i++) {
-          const intptr_t pred = block->PredecessorAt(i)->postorder_number();
-          if (available_after[pred] != NULL) {
-            temp->Intersect(available_after[pred]);
-          }
-        }
-      }
-
-      BitVector* current = available_at_[block_num];
-      if ((current == NULL) || !current->Equals(*temp)) {
-        // Available-at changed: update it and recompute available-after.
-        if (available_at_[block_num] == NULL) {
-          current = available_at_[block_num] =
-              new (zone) BitVector(zone, block_count);
-          available_after[block_num] = new (zone) BitVector(zone, block_count);
-          // Block is always available after itself.
-          available_after[block_num]->Add(block_num);
-        }
-        current->CopyFrom(temp);
-        if (!kill->Contains(block_num)) {
-          available_after[block_num]->CopyFrom(temp);
-          // Block is always available after itself.
-          available_after[block_num]->Add(block_num);
-        }
-        changed = true;
-      }
-    }
-  } while (changed);
-}
-
-bool BlockEffects::IsAvailableAt(Instruction* instr,
-                                 BlockEntryInstr* block) const {
-  ASSERT(instr->AllowsCSE());
-  ASSERT(instr->Dependencies().IsNone());
-  return true;  // TODO(dartbug.com/30474): cleanup
-}
-
-bool BlockEffects::CanBeMovedTo(Instruction* instr,
-                                BlockEntryInstr* block) const {
-  ASSERT(instr->AllowsCSE());
-  ASSERT(instr->Dependencies().IsNone());
-  return true;  // TODO(dartbug.com/30474): cleanup
-}
-
-bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
-                                        BlockEntryInstr* to) const {
-  return available_at_[to->postorder_number()]->Contains(
-      from->postorder_number());
-}
-
 // Quick access to the current zone.
 #define Z (zone())
 
 void FlowGraph::ConvertUse(Value* use, Representation from_rep) {
   const Representation to_rep =
       use->instruction()->RequiredInputRepresentation(use->use_index());
   if (from_rep == to_rep || to_rep == kNoRepresentation) {
     return;
   }
   InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/false);
@@ skipping 735 matching lines @@
                                                 intptr_t index,
                                                 Representation rep,
                                                 intptr_t cid) {
   ExtractNthOutputInstr* extract =
       new (Z) ExtractNthOutputInstr(new (Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 }  // namespace dart