Refactor Hydrogen environment liveness analysis into an HPhase.

src/hydrogen-environment-liveness.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 16 matching lines @@
 
 
 #include "hydrogen-environment-liveness.h"
 
 
 namespace v8 {
 namespace internal {
 
 
 EnvironmentSlotLivenessAnalyzer::EnvironmentSlotLivenessAnalyzer(
-    HGraph* graph)
+    HGraph* graph,
+    Zone* phase_zone)

[danno, 2013/06/24 12:11:21]

This should take an CompilationInfo rather than a zone, just like GVN. Also,
should't you refactor into a common base class to share the phase_zone_scope_
machinery before you port over too many of these?

[Benedikt Meurer, 2013/06/24 12:18:28]

Separate CL, see https://codereview.chromium.org/17572011/
I can rebase this one on 17572011 and subclass HPhase. You said you wanted a
small patch with only one class adjusted, that's why I did it this way. :-)

     : graph_(graph),
-      zone_(graph->isolate()),
-      zone_scope_(&zone_, DELETE_ON_EXIT),
+      phase_zone_(phase_zone),
+      phase_zone_scope_(phase_zone_, DELETE_ON_EXIT),
       block_count_(graph->blocks()->length()),
       maximum_environment_size_(graph->maximum_environment_size()),
       collect_markers_(true),
       last_simulate_(NULL) {
   if (maximum_environment_size_ == 0) return;
 
   live_at_block_start_ =
-      new(zone()) ZoneList<BitVector*>(block_count_, zone());
-  first_simulate_ = new(zone()) ZoneList<HSimulate*>(block_count_, zone());
+      new(phase_zone) ZoneList<BitVector*>(block_count_, phase_zone);
+  first_simulate_ = new(phase_zone) ZoneList<HSimulate*>(block_count_,
+                                                         phase_zone);
   first_simulate_invalid_for_index_ =
-      new(zone()) ZoneList<BitVector*>(block_count_, zone());
-  markers_ = new(zone())
-      ZoneList<HEnvironmentMarker*>(maximum_environment_size_, zone());
+      new(phase_zone) ZoneList<BitVector*>(block_count_, phase_zone);
+  markers_ = new(phase_zone)
+      ZoneList<HEnvironmentMarker*>(maximum_environment_size_, phase_zone);
   went_live_since_last_simulate_ =
-      new(zone()) BitVector(maximum_environment_size_, zone());
+      new(phase_zone) BitVector(maximum_environment_size_, phase_zone);
 
   for (int i = 0; i < block_count_; ++i) {
     live_at_block_start_->Add(
-        new(zone()) BitVector(maximum_environment_size_, zone()), zone());
-    first_simulate_->Add(NULL, zone());
+        new(phase_zone) BitVector(maximum_environment_size_, phase_zone),
+        phase_zone);
+    first_simulate_->Add(NULL, phase_zone);
     first_simulate_invalid_for_index_->Add(
-        new(zone()) BitVector(maximum_environment_size_, zone()), zone());
+        new(phase_zone) BitVector(maximum_environment_size_, phase_zone),
+        phase_zone);
   }
 }
 
 
 void EnvironmentSlotLivenessAnalyzer::ZapEnvironmentSlot(int index,
                                                          HSimulate* simulate) {
   int operand_index = simulate->ToOperandIndex(index);
   if (operand_index == -1) {
     simulate->AddAssignedValue(index, graph_->GetConstantUndefined());
   } else {
@@ skipping 67 matching lines @@
       }
       if (marker->kind() == HEnvironmentMarker::LOOKUP) {
         live->Add(index);
       } else {
         ASSERT(marker->kind() == HEnvironmentMarker::BIND);
         live->Remove(index);
         went_live_since_last_simulate_->Add(index);
       }
       if (collect_markers_) {
         // Populate |markers_| list during the first pass.
-        markers_->Add(marker, &zone_);
+        markers_->Add(marker, phase_zone());
       }
       break;
     }
     case HValue::kLeaveInlined:
       // No environment values are live at the end of an inlined section.
       live->Clear();
       last_simulate_ = NULL;
 
       // The following ASSERTs guard the assumption used in case
       // kEnterInlined below:
@@ skipping 32 matching lines @@
     case HValue::kSimulate:
       last_simulate_ = HSimulate::cast(instr);
       went_live_since_last_simulate_->Clear();
       break;
     default:
       break;
   }
 }
 
 
-void EnvironmentSlotLivenessAnalyzer::AnalyzeAndTrim() {
+void EnvironmentSlotLivenessAnalyzer::Run() {
   HPhase phase("H_EnvironmentLivenessAnalysis", graph_);
   if (maximum_environment_size_ == 0) return;
 
   // Main iteration. Compute liveness of environment slots, and store it
   // for each block until it doesn't change any more. For efficiency, visit
   // blocks in reverse order and walk backwards through each block. We
   // need several iterations to propagate liveness through nested loops.
-  BitVector* live = new(zone()) BitVector(maximum_environment_size_, zone());
-  BitVector* worklist = new(zone()) BitVector(block_count_, zone());
+  BitVector* live = new(phase_zone()) BitVector(maximum_environment_size_,
+                                                phase_zone());
+  BitVector* worklist = new(phase_zone()) BitVector(block_count_, phase_zone());
   for (int i = 0; i < block_count_; ++i) {
     worklist->Add(i);
   }
   while (!worklist->IsEmpty()) {
     for (int block_id = block_count_ - 1; block_id >= 0; --block_id) {
       if (!worklist->Contains(block_id)) {
         continue;
       }
       worklist->Remove(block_id);
       last_simulate_ = NULL;
@@ skipping 35 matching lines @@
     ZapEnvironmentSlotsInSuccessors(block, live);
   }
 
   // Finally, remove the HEnvironment{Bind,Lookup} markers.
   for (int i = 0; i < markers_->length(); ++i) {
     markers_->at(i)->DeleteAndReplaceWith(NULL);
   }
 }
 
 } }  // namespace v8::internal