Refactor Hydrogen GVN into an HPhase and use the phase zone.

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 343 matching lines @@
   for (int i = 0; i < kNumberOfTrackedSideEffects; i++) {
     GVNFlag changes_flag = HValue::ChangesFlagFromInt(i);
     if (flags.Contains(changes_flag)) {
       if (data_[i] == NULL) count_++;
       data_[i] = instr;
     }
   }
 }
 
 
-HGlobalValueNumberer::HGlobalValueNumberer(HGraph* graph, CompilationInfo* info)
-      : graph_(graph),
-        info_(info),
+HGlobalValueNumberingPhase::HGlobalValueNumberingPhase(HGraph* graph,
+                                                       Zone* zone)
+      : HPhase("H_Global value numbering", graph, zone),
         removed_side_effects_(false),
-        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()) {
+        block_side_effects_(graph->blocks()->length(), zone),
+        loop_side_effects_(graph->blocks()->length(), zone),
+        visited_on_paths_(zone, graph->blocks()->length()) {
     ASSERT(!AllowHandleAllocation::IsAllowed());
-    block_side_effects_.AddBlock(GVNFlagSet(), graph_->blocks()->length(),
-                                 phase_zone_);
-    loop_side_effects_.AddBlock(GVNFlagSet(), graph_->blocks()->length(),
-                                phase_zone_);
+    block_side_effects_.AddBlock(GVNFlagSet(), graph->blocks()->length(), zone);
+    loop_side_effects_.AddBlock(GVNFlagSet(), graph->blocks()->length(), zone);
   }
 
-bool HGlobalValueNumberer::Analyze() {
+bool HGlobalValueNumberingPhase::Analyze() {
   removed_side_effects_ = false;
   ComputeBlockSideEffects();
   if (FLAG_loop_invariant_code_motion) {
     LoopInvariantCodeMotion();
   }
   AnalyzeGraph();
   return removed_side_effects_;
 }
 
 
-void HGlobalValueNumberer::ComputeBlockSideEffects() {
+void HGlobalValueNumberingPhase::ComputeBlockSideEffects() {
   // The Analyze phase of GVN can be called multiple times. Clear loop side
   // effects before computing them to erase the contents from previous Analyze
   // passes.
   for (int i = 0; i < loop_side_effects_.length(); ++i) {
     loop_side_effects_[i].RemoveAll();
   }
-  for (int i = graph_->blocks()->length() - 1; i >= 0; --i) {
+  for (int i = graph()->blocks()->length() - 1; i >= 0; --i) {
     // Compute side effects for the block.
-    HBasicBlock* block = graph_->blocks()->at(i);
+    HBasicBlock* block = graph()->blocks()->at(i);
     HInstruction* instr = block->first();
     int id = block->block_id();
     GVNFlagSet side_effects;
     while (instr != NULL) {
       side_effects.Add(instr->ChangesFlags());
       if (instr->IsSoftDeoptimize()) {
         block_side_effects_[id].RemoveAll();
         side_effects.RemoveAll();
         break;
       }
@@ skipping 96 matching lines @@
   OS::SNPrintF(buffer, "0x%08X", flags.ToIntegral());
 #endif
   size_t string_len = strlen(underlying_buffer) + 1;
   ASSERT(string_len <= sizeof(underlying_buffer));
   char* result = new char[strlen(underlying_buffer) + 1];
   OS::MemCopy(result, underlying_buffer, string_len);
   return SmartArrayPointer<char>(result);
 }
 
 
-void HGlobalValueNumberer::LoopInvariantCodeMotion() {
+void HGlobalValueNumberingPhase::LoopInvariantCodeMotion() {
   TRACE_GVN_1("Using optimistic loop invariant code motion: %s\n",
-              graph_->use_optimistic_licm() ? "yes" : "no");
-  for (int i = graph_->blocks()->length() - 1; i >= 0; --i) {
-    HBasicBlock* block = graph_->blocks()->at(i);
+              graph()->use_optimistic_licm() ? "yes" : "no");
+  for (int i = graph()->blocks()->length() - 1; i >= 0; --i) {
+    HBasicBlock* block = graph()->blocks()->at(i);
     if (block->IsLoopHeader()) {
       GVNFlagSet side_effects = loop_side_effects_[block->block_id()];
       TRACE_GVN_2("Try loop invariant motion for block B%d %s\n",
                   block->block_id(),
                   *GetGVNFlagsString(side_effects));
 
       GVNFlagSet accumulated_first_time_depends;
       GVNFlagSet accumulated_first_time_changes;
       HBasicBlock* last = block->loop_information()->GetLastBackEdge();
       for (int j = block->block_id(); j <= last->block_id(); ++j) {
-        ProcessLoopBlock(graph_->blocks()->at(j), block, side_effects,
+        ProcessLoopBlock(graph()->blocks()->at(j), block, side_effects,
                          &accumulated_first_time_depends,
                          &accumulated_first_time_changes);
       }
     }
   }
 }
 
 
-void HGlobalValueNumberer::ProcessLoopBlock(
+void HGlobalValueNumberingPhase::ProcessLoopBlock(
     HBasicBlock* block,
     HBasicBlock* loop_header,
     GVNFlagSet loop_kills,
     GVNFlagSet* first_time_depends,
     GVNFlagSet* first_time_changes) {
   HBasicBlock* pre_header = loop_header->predecessors()->at(0);
   GVNFlagSet depends_flags = HValue::ConvertChangesToDependsFlags(loop_kills);
   TRACE_GVN_2("Loop invariant motion for B%d %s\n",
               block->block_id(),
               *GetGVNFlagsString(depends_flags));
@@ skipping 44 matching lines @@
       if (!(previous_changes == *first_time_changes)) {
         TRACE_GVN_1("Updated first-time accumulated %s\n",
                     *GetGVNFlagsString(*first_time_changes));
       }
     }
     instr = next;
   }
 }
 
 
-bool HGlobalValueNumberer::AllowCodeMotion() {
+bool HGlobalValueNumberingPhase::AllowCodeMotion() {
   return info()->IsStub() || info()->opt_count() + 1 < FLAG_max_opt_count;
 }
 
 
-bool HGlobalValueNumberer::ShouldMove(HInstruction* instr,
-                                      HBasicBlock* loop_header) {
+bool HGlobalValueNumberingPhase::ShouldMove(HInstruction* instr,
+                                            HBasicBlock* loop_header) {
   // If we've disabled code motion or we're in a block that unconditionally
   // deoptimizes, don't move any instructions.
   return AllowCodeMotion() && !instr->block()->IsDeoptimizing();
 }
 
 
-GVNFlagSet HGlobalValueNumberer::CollectSideEffectsOnPathsToDominatedBlock(
-    HBasicBlock* dominator, HBasicBlock* dominated) {
+GVNFlagSet HGlobalValueNumberingPhase::CollectSideEffectsOnPathsToDominatedBlock
+(HBasicBlock* dominator, HBasicBlock* dominated) {
   GVNFlagSet side_effects;
   for (int i = 0; i < dominated->predecessors()->length(); ++i) {
     HBasicBlock* block = dominated->predecessors()->at(i);
     if (dominator->block_id() < block->block_id() &&
         block->block_id() < dominated->block_id() &&
         visited_on_paths_.Add(block->block_id())) {
       side_effects.Add(block_side_effects_[block->block_id()]);
       if (block->IsLoopHeader()) {
         side_effects.Add(loop_side_effects_[block->block_id()]);
       }
@@ skipping 118 matching lines @@
   HValueMap* map_;
   HSideEffectMap dominators_;
   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(phase_zone()) HValueMap(phase_zone());
+void HGlobalValueNumberingPhase::AnalyzeGraph() {
+  HBasicBlock* entry_block = graph()->entry_block();
+  HValueMap* entry_map = new(zone()) HValueMap(zone());
   GvnBasicBlockState* current =
-      GvnBasicBlockState::CreateEntry(phase_zone(), entry_block, entry_map);
+      GvnBasicBlockState::CreateEntry(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, phase_zone());
+          map->Add(instr, 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(phase_zone(),
+        current->next_in_dominator_tree_traversal(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