Add phase zone to CompilationInfo and use it in GVN pass.

src/hydrogen-gvn.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 347 matching lines @@
       data_[i] = instr;
     }
   }
 }
 
 
 HGlobalValueNumberer::HGlobalValueNumberer(HGraph* graph, CompilationInfo* info)
       : graph_(graph),
         info_(info),
         removed_side_effects_(false),
-        block_side_effects_(graph->blocks()->length(), graph->zone()),
-        loop_side_effects_(graph->blocks()->length(), graph->zone()),
-        visited_on_paths_(graph->zone(), graph->blocks()->length()) {
+        phase_zone_(info->phase_zone()),
+        phase_zone_scope_(phase_zone_, DELETE_ON_EXIT),
+        block_side_effects_(graph->blocks()->length(), phase_zone_),
+        loop_side_effects_(graph->blocks()->length(), phase_zone_),
+        visited_on_paths_(phase_zone_, graph->blocks()->length()) {
     ASSERT(!AllowHandleAllocation::IsAllowed());
     block_side_effects_.AddBlock(GVNFlagSet(), graph_->blocks()->length(),
-                                 graph_->zone());
+                                 phase_zone_);
     loop_side_effects_.AddBlock(GVNFlagSet(), graph_->blocks()->length(),
-                                graph_->zone());
+                                phase_zone_);
   }
 
 bool HGlobalValueNumberer::Analyze() {
   removed_side_effects_ = false;
   ComputeBlockSideEffects();
   if (FLAG_loop_invariant_code_motion) {
     LoopInvariantCodeMotion();
   }
   AnalyzeGraph();
   return removed_side_effects_;
@@ skipping 363 matching lines @@
   int dominated_index_;
   int length_;
 };
 
 // This is a recursive traversal of the dominator tree but it has been turned
 // into a loop to avoid stack overflows.
 // The logical "stack frames" of the recursion are kept in a list of
 // GvnBasicBlockState instances.
 void HGlobalValueNumberer::AnalyzeGraph() {
   HBasicBlock* entry_block = graph_->entry_block();
-  HValueMap* entry_map = new(zone()) HValueMap(zone());
+  HValueMap* entry_map = new(phase_zone()) HValueMap(phase_zone());
   GvnBasicBlockState* current =
-      GvnBasicBlockState::CreateEntry(zone(), entry_block, entry_map);
+      GvnBasicBlockState::CreateEntry(phase_zone(), entry_block, entry_map);
 
   while (current != NULL) {
     HBasicBlock* block = current->block();
     HValueMap* map = current->map();
     HSideEffectMap* dominators = current->dominators();
 
     TRACE_GVN_2("Analyzing block B%d%s\n",
                 block->block_id(),
                 block->IsLoopHeader() ? " (loop header)" : "");
 
@@ skipping 21 matching lines @@
         if (other != NULL) {
           ASSERT(instr->Equals(other) && other->Equals(instr));
           TRACE_GVN_4("Replacing value %d (%s) with value %d (%s)\n",
                       instr->id(),
                       instr->Mnemonic(),
                       other->id(),
                       other->Mnemonic());
           if (instr->HasSideEffects()) removed_side_effects_ = true;
           instr->DeleteAndReplaceWith(other);
         } else {
-          map->Add(instr, zone());
+          map->Add(instr, phase_zone());
         }
       }
       if (instr->IsLinked() &&
           instr->CheckFlag(HValue::kTrackSideEffectDominators)) {
         for (int i = 0; i < kNumberOfTrackedSideEffects; i++) {
           HValue* other = dominators->at(i);
           GVNFlag changes_flag = HValue::ChangesFlagFromInt(i);
           GVNFlag depends_on_flag = HValue::DependsOnFlagFromInt(i);
           if (instr->DependsOnFlags().Contains(depends_on_flag) &&
               (other != NULL)) {
             TRACE_GVN_5("Side-effect #%d in %d (%s) is dominated by %d (%s)\n",
                         i,
                         instr->id(),
                         instr->Mnemonic(),
                         other->id(),
                         other->Mnemonic());
             instr->SetSideEffectDominator(changes_flag, other);
           }
         }
       }
       instr = next;
     }
 
     HBasicBlock* dominator_block;
     GvnBasicBlockState* next =
-        current->next_in_dominator_tree_traversal(zone(), &dominator_block);
+        current->next_in_dominator_tree_traversal(phase_zone(),
+                                                  &dominator_block);
 
     if (next != NULL) {
       HBasicBlock* dominated = next->block();
       HValueMap* successor_map = next->map();
       HSideEffectMap* successor_dominators = next->dominators();
 
       // Kill everything killed on any path between this block and the
       // dominated block.  We don't have to traverse these paths if the
       // value map and the dominators list is already empty.  If the range
       // of block ids (block_id, dominated_id) is empty there are no such
       // paths.
       if ((!successor_map->IsEmpty() || !successor_dominators->IsEmpty()) &&
           dominator_block->block_id() + 1 < dominated->block_id()) {
         visited_on_paths_.Clear();
         GVNFlagSet side_effects_on_all_paths =
             CollectSideEffectsOnPathsToDominatedBlock(dominator_block,
                                                       dominated);
         successor_map->Kill(side_effects_on_all_paths);
         successor_dominators->Kill(side_effects_on_all_paths);
       }
     }
     current = next;
   }
 }
 
 } }  // namespace v8::internal