Pass isolate to BitVector constructor.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 4713 matching lines @@
 
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
 // Smi widening pass is only meaningful on platforms where Smi
 // is smaller than 32bit. For now only support it on ARM and ia32.
 
 class DefinitionWorklist : public ValueObject {
  public:
   DefinitionWorklist(FlowGraph* flow_graph,
                      intptr_t initial_capacity)
       : defs_(initial_capacity),
-        contains_vector_(new BitVector(flow_graph->current_ssa_temp_index())) {
+        contains_vector_(new(flow_graph->isolate()) BitVector(
+            flow_graph->isolate(), flow_graph->current_ssa_temp_index())) {
   }
 
   void Add(Definition* defn) {
     if (!Contains(defn)) {
       defs_.Add(defn);
       contains_vector_->Add(defn->ssa_temp_index());
     }
   }
 
   bool Contains(Definition* defn) const {
@@ skipping 84 matching lines @@
   }
 
   // Step 3. For each candidate transitively collect all other BinarySmiOpInstr
   // and PhiInstr that depend on it and that it depends on and count amount of
   // untagging operations that we save in assumption that this whole graph of
   // values is using kUnboxedInt32 representation instead of kTagged.
   // Convert those graphs that have positive gain to kUnboxedInt32.
 
   // BitVector containing SSA indexes of all processed definitions. Used to skip
   // those candidates that belong to dependency graph of another candidate.
-  BitVector* processed = new BitVector(flow_graph_->current_ssa_temp_index());
+  BitVector* processed =
+      new(I) BitVector(I, flow_graph_->current_ssa_temp_index());
 
   // Worklist used to collect dependency graph.
   DefinitionWorklist worklist(flow_graph_, candidates.length());
   for (intptr_t i = 0; i < candidates.length(); i++) {
     BinarySmiOpInstr* op = candidates[i];
     if (op->WasEliminated() || processed->Contains(op->ssa_temp_index())) {
       continue;
     }
 
     if (FLAG_trace_smi_widening) {
@@ skipping 846 matching lines @@
   AliasedSet(Isolate* isolate,
              ZoneGrowableArray<Place*>* places,
              PhiPlaceMoves* phi_moves)
       : isolate_(isolate),
         places_(*places),
         phi_moves_(phi_moves),
         aliases_(5),
         aliases_map_(),
         representatives_(),
         killed_(),
-        aliased_by_effects_(new(isolate) BitVector(places->length())) {
+        aliased_by_effects_(new(isolate) BitVector(isolate, places->length())) {
     InsertAlias(Place::CreateAnyInstanceAnyIndexAlias(isolate_,
         kAnyInstanceAnyIndexAlias));
     for (intptr_t i = 0; i < places_.length(); i++) {
       AddRepresentative(places_[i]);
     }
     ComputeKillSets();
   }
 
   intptr_t LookupAliasId(const Place& alias) {
     const Place* result = aliases_map_.Lookup(&alias);
@@ skipping 154 matching lines @@
   }
 
   BitVector* EnsureSet(GrowableArray<BitVector*>* sets,
                        intptr_t alias) {
     while (sets->length() <= alias) {
       sets->Add(NULL);
     }
 
     BitVector* set = (*sets)[alias];
     if (set == NULL) {
-      (*sets)[alias] = set = new(isolate_) BitVector(max_place_id());
+      (*sets)[alias] = set = new(isolate_) BitVector(isolate_, max_place_id());
     }
     return set;
   }
 
   void AddAllRepresentatives(const Place* to, intptr_t from) {
     AddAllRepresentatives(to->id(), from);
   }
 
   void AddAllRepresentatives(intptr_t to, intptr_t from) {
     BitVector* from_set = GetRepresentativesSet(from);
@@ skipping 405 matching lines @@
         exposed_values_(graph_->preorder().length()),
         out_values_(graph_->preorder().length()),
         phis_(5),
         worklist_(5),
         congruency_worklist_(6),
         in_worklist_(NULL),
         forwarded_(false) {
     const intptr_t num_blocks = graph_->preorder().length();
     for (intptr_t i = 0; i < num_blocks; i++) {
       out_.Add(NULL);
-      gen_.Add(new(I) BitVector(aliased_set_->max_place_id()));
-      kill_.Add(new(I) BitVector(aliased_set_->max_place_id()));
-      in_.Add(new(I) BitVector(aliased_set_->max_place_id()));
+      gen_.Add(new(I) BitVector(I, aliased_set_->max_place_id()));
+      kill_.Add(new(I) BitVector(I, aliased_set_->max_place_id()));
+      in_.Add(new(I) BitVector(I, aliased_set_->max_place_id()));
 
       exposed_values_.Add(NULL);
       out_values_.Add(NULL);
     }
   }
 
   ~LoadOptimizer() {
     aliased_set_->RollbackAliasedIdentites();
   }
 
@@ skipping 227 matching lines @@
 
       out->Remove(to);
     }
 
     out->AddAll(forwarded_loads);
   }
 
   // Compute OUT sets by propagating them iteratively until fix point
   // is reached.
   void ComputeOutSets() {
-    BitVector* temp = new(I) BitVector(aliased_set_->max_place_id());
-    BitVector* forwarded_loads = new(I) BitVector(aliased_set_->max_place_id());
-    BitVector* temp_out = new(I) BitVector(aliased_set_->max_place_id());
+    BitVector* temp = new(I) BitVector(I, aliased_set_->max_place_id());
+    BitVector* forwarded_loads =
+        new(I) BitVector(I, aliased_set_->max_place_id());
+    BitVector* temp_out = new(I) BitVector(I, aliased_set_->max_place_id());
 
     bool changed = true;
     while (changed) {
       changed = false;
 
       for (BlockIterator block_it = graph_->reverse_postorder_iterator();
            !block_it.Done();
            block_it.Advance()) {
         BlockEntryInstr* block = block_it.Current();
 
@@ skipping 31 matching lines @@
         if (!temp->Equals(*block_in) || (block_out == NULL)) {
           // If IN set has changed propagate the change to OUT set.
           block_in->CopyFrom(temp);
 
           temp->RemoveAll(block_kill);
           temp->AddAll(block_gen);
 
           if ((block_out == NULL) || !block_out->Equals(*temp)) {
             if (block_out == NULL) {
               block_out = out_[preorder_number] =
-                  new(I) BitVector(aliased_set_->max_place_id());
+                  new(I) BitVector(I, aliased_set_->max_place_id());
             }
             block_out->CopyFrom(temp);
             changed = true;
           }
         }
       }
     }
   }
 
   // Compute out_values mappings by propagating them in reverse postorder once
@@ skipping 116 matching lines @@
         new(I) ZoneGrowableArray<BitVector*>(loop_headers.length());
 
     for (intptr_t i = 0; i < loop_headers.length(); i++) {
       BlockEntryInstr* header = loop_headers[i];
       BlockEntryInstr* pre_header = FindPreHeader(header);
       if (pre_header == NULL) {
         invariant_loads->Add(NULL);
         continue;
       }
 
-      BitVector* loop_gen = new(I) BitVector(aliased_set_->max_place_id());
+      BitVector* loop_gen = new(I) BitVector(I, aliased_set_->max_place_id());
       for (BitVector::Iterator loop_it(header->loop_info());
            !loop_it.Done();
            loop_it.Advance()) {
         const intptr_t preorder_number = loop_it.Current();
         loop_gen->AddAll(gen_[preorder_number]);
       }
 
       for (BitVector::Iterator loop_it(header->loop_info());
            !loop_it.Done();
            loop_it.Advance()) {
@@ skipping 131 matching lines @@
   // Eliminate it as redundant if this is the case.
   // When analyzing phi operands assumes that only generated during
   // this load phase can be redundant. They can be distinguished because
   // they are not marked alive.
   // TODO(vegorov): move this into a separate phase over all phis.
   bool EliminateRedundantPhi(PhiInstr* phi) {
     Definition* value = NULL;  // Possible value of this phi.
 
     worklist_.Clear();
     if (in_worklist_ == NULL) {
-      in_worklist_ = new(I) BitVector(graph_->current_ssa_temp_index());
+      in_worklist_ = new(I) BitVector(I, graph_->current_ssa_temp_index());
     } else {
       in_worklist_->Clear();
     }
 
     worklist_.Add(phi);
     in_worklist_->Add(phi->ssa_temp_index());
 
     for (intptr_t i = 0; i < worklist_.length(); i++) {
       PhiInstr* phi = worklist_[i];
 
@@ skipping 102 matching lines @@
   }
 
   // Replace the given phi with another if they are congruent.
   // Returns true if succeeds.
   bool ReplacePhiWith(PhiInstr* phi, PhiInstr* replacement) {
     ASSERT(phi->InputCount() == replacement->InputCount());
     ASSERT(phi->block() == replacement->block());
 
     congruency_worklist_.Clear();
     if (in_worklist_ == NULL) {
-      in_worklist_ = new(I) BitVector(graph_->current_ssa_temp_index());
+      in_worklist_ = new(I) BitVector(I, graph_->current_ssa_temp_index());
     } else {
       in_worklist_->Clear();
     }
 
     // During the comparison worklist contains pairs of definitions to be
     // compared.
     if (!AddPairToCongruencyWorklist(phi, replacement)) {
       return false;
     }
 
@@ skipping 191 matching lines @@
       case Instruction::kStoreStaticField:
         return true;
       default:
         UNREACHABLE();
         return false;
     }
   }
 
   virtual void ComputeInitialSets() {
     Isolate* isolate = graph_->isolate();
-    BitVector* all_places = new(isolate) BitVector(
+    BitVector* all_places = new(isolate) BitVector(isolate,
         aliased_set_->max_place_id());
     all_places->SetAll();
     for (BlockIterator block_it = graph_->postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       BlockEntryInstr* block = block_it.Current();
       const intptr_t postorder_number = block->postorder_number();
 
       BitVector* kill = kill_[postorder_number];
       BitVector* live_in = live_in_[postorder_number];
@@ skipping 321 matching lines @@
 }
 
 
 ConstantPropagator::ConstantPropagator(
     FlowGraph* graph,
     const GrowableArray<BlockEntryInstr*>& ignored)
     : FlowGraphVisitor(ignored),
       graph_(graph),
       unknown_(Object::unknown_constant()),
       non_constant_(Object::non_constant()),
-      reachable_(new(graph->isolate()) BitVector(graph->preorder().length())),
+      reachable_(new(graph->isolate()) BitVector(
+          graph->isolate(), graph->preorder().length())),
       definition_marks_(new(graph->isolate()) BitVector(
-          graph->max_virtual_register_number())),
+          graph->isolate(), graph->max_virtual_register_number())),
       block_worklist_(),
       definition_worklist_() {}
 
 
 void ConstantPropagator::Optimize(FlowGraph* graph) {
   GrowableArray<BlockEntryInstr*> ignored;
   ConstantPropagator cp(graph, ignored);
   cp.Analyze();
   cp.Transform();
 }
@@ skipping 1359 matching lines @@
     current = current->next()->AsGoto()->successor();
   }
   return current;
 }
 
 
 void ConstantPropagator::EliminateRedundantBranches() {
   // Canonicalize branches that have no side-effects and where true- and
   // false-targets are the same.
   bool changed = false;
-  BitVector* empty_blocks = new(I) BitVector(graph_->preorder().length());
+  BitVector* empty_blocks = new(I) BitVector(I, graph_->preorder().length());
   for (BlockIterator b = graph_->postorder_iterator();
        !b.Done();
        b.Advance()) {
     BlockEntryInstr* block = b.Current();
     BranchInstr* branch = block->last_instruction()->AsBranch();
     empty_blocks->Clear();
     if ((branch != NULL) && branch->Effects().IsNone()) {
       ASSERT(branch->previous() != NULL);  // Not already eliminated.
       BlockEntryInstr* if_true =
           FindFirstNonEmptySuccessor(branch->true_successor(), empty_blocks);
@@ skipping 1146 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart