[compiler] Introduce a simple store-store elimination, disabled by default.

src/compiler/pipeline.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/pipeline.h"
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/base/adapters.h"
 #include "src/base/platform/elapsed-timer.h"
+#include "src/compiler/all-nodes.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/basic-block-instrumentor.h"
 #include "src/compiler/branch-elimination.h"
 #include "src/compiler/bytecode-graph-builder.h"
 #include "src/compiler/checkpoint-elimination.h"
 #include "src/compiler/code-generator.h"
 #include "src/compiler/common-operator-reducer.h"
 #include "src/compiler/control-flow-optimizer.h"
 #include "src/compiler/dead-code-elimination.h"
@@ skipping 28 matching lines @@
 #include "src/compiler/osr.h"
 #include "src/compiler/pipeline-statistics.h"
 #include "src/compiler/register-allocator-verifier.h"
 #include "src/compiler/register-allocator.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/select-lowering.h"
 #include "src/compiler/simplified-lowering.h"
 #include "src/compiler/simplified-operator-reducer.h"
 #include "src/compiler/simplified-operator.h"
+#include "src/compiler/store-store-elimination.h"
 #include "src/compiler/tail-call-optimization.h"
 #include "src/compiler/type-hint-analyzer.h"
 #include "src/compiler/typer.h"
 #include "src/compiler/value-numbering-reducer.h"
 #include "src/compiler/verifier.h"
 #include "src/compiler/zone-pool.h"
 #include "src/isolate-inl.h"
 #include "src/ostreams.h"
 #include "src/parsing/parser.h"
 #include "src/register-configuration.h"
@@ skipping 951 matching lines @@
     // Post-pass for wiring the control/effects
     // - connect allocating representation changes into the control&effect
     //   chains and lower them,
     // - get rid of the region markers,
     // - introduce effect phis and rewire effects to get SSA again.
     EffectControlLinearizer linearizer(data->jsgraph(), schedule, temp_zone);
     linearizer.Run();
   }
 };
 
+struct StoreStoreEliminationPhase {
+  static const char* phase_name() { return "Store-store elimination"; }
+
+  void Run(PipelineData* data, Zone* temp_zone) {
+    StoreStoreElimination store_store_elimination(data->jsgraph(), temp_zone);
+
+    // The store-store elimination does work on chains of certain types of
+    // nodes. The elimination must be invoked on the lowest node in such a
+    // chain; we have a helper function IsEligibleNode that returns true
+    // precisely on the lowest node in such a chain.
+    //
+    // Because the elimination removes nodes from the graph, even remove nodes
+    // that the elimination was not invoked on, we cannot use a normal
+    // AdvancedReducer but we manually find which nodes to invoke the
+    // elimination on. Then in a next step, we invoke the elimination for each
+    // node that was eligible.
+
+    NodeVector eligible(temp_zone);

[Jarin, 2016/06/21 13:28:32]

Could we move this code into the StoreStoreElimination class? E.g., you could
have a Run method there that does all this.

[bgeron, 2016/06/21 17:48:58]

Done.

+
+    for (Node* node : MarkingPreDFS(data->jsgraph()->graph())) {
+      if (StoreStoreElimination::IsEligibleNode(node)) {
+        eligible.push_back(node);
+      }
+    }
+
+    for (Node* node : eligible) {
+      store_store_elimination.ReduceEligibleNode(node);
+    }
+  }
+};
+
 struct MemoryOptimizationPhase {
   static const char* phase_name() { return "memory optimization"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
     MemoryOptimizer optimizer(data->jsgraph(), temp_zone);
     optimizer.Optimize();
   }
 };
 
 struct LateOptimizationPhase {
@@ skipping 416 matching lines @@
 }
 
 bool PipelineImpl::OptimizeGraph(Linkage* linkage) {
   PipelineData* data = this->data_;
 
   data->BeginPhaseKind("block building");
 
   Run<EffectControlLinearizationPhase>();
   RunPrintAndVerify("Effect and control linearized", true);
 
+  Run<StoreStoreEliminationPhase>();
+  RunPrintAndVerify("Store-store elimination", true);
+
   Run<BranchEliminationPhase>();
   RunPrintAndVerify("Branch conditions eliminated", true);
 
   // Optimize control flow.
   if (FLAG_turbo_cf_optimization) {
     Run<ControlFlowOptimizationPhase>();
     RunPrintAndVerify("Control flow optimized", true);
   }
 
   // Optimize memory access and allocation operations.
@@ skipping 328 matching lines @@
   data->DeleteRegisterAllocationZone();
 }
 
 CompilationInfo* PipelineImpl::info() const { return data_->info(); }
 
 Isolate* PipelineImpl::isolate() const { return info()->isolate(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8