Make loop assignment analysis a separate phase.

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/platform/elapsed-timer.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/change-lowering.h"
 #include "src/compiler/code-generator.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph-replay.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/js-context-specialization.h"
 #include "src/compiler/js-generic-lowering.h"
@@ skipping 28 matching lines @@
       : isolate_(info->zone()->isolate()),
         info_(info),
         outer_zone_(nullptr),
         zone_pool_(zone_pool),
         pipeline_statistics_(nullptr),
         compilation_failed_(false),
         code_(Handle<Code>::null()),
         graph_zone_scope_(zone_pool_),
         graph_zone_(nullptr),
         graph_(nullptr),
+        loop_assignment_(nullptr),
         machine_(nullptr),
         common_(nullptr),
         javascript_(nullptr),
         jsgraph_(nullptr),
         typer_(nullptr),
         context_node_(nullptr),
         schedule_(nullptr),
         instruction_zone_scope_(zone_pool_),
         instruction_zone_(nullptr),
         sequence_(nullptr),
@@ skipping 57 matching lines @@
   Graph* graph() const { return graph_; }
   SourcePositionTable* source_positions() const {
     return source_positions_.get();
   }
   MachineOperatorBuilder* machine() const { return machine_; }
   CommonOperatorBuilder* common() const { return common_; }
   JSOperatorBuilder* javascript() const { return javascript_; }
   JSGraph* jsgraph() const { return jsgraph_; }
   Typer* typer() const { return typer_.get(); }
 
+  LoopAssignmentAnalysis* loop_assignment() const { return loop_assignment_; }
+  void set_loop_assignment(LoopAssignmentAnalysis* loop_assignment) {
+    DCHECK_EQ(nullptr, loop_assignment_);
+    loop_assignment_ = loop_assignment;
+  }
+
   Node* context_node() const { return context_node_; }
   void set_context_node(Node* context_node) {
     DCHECK_EQ(nullptr, context_node_);
     context_node_ = context_node;
   }
 
   Schedule* schedule() const { return schedule_; }
   void set_schedule(Schedule* schedule) {
     DCHECK_EQ(nullptr, schedule_);
     schedule_ = schedule;
   }
 
   Zone* instruction_zone() const { return instruction_zone_; }
   InstructionSequence* sequence() const { return sequence_; }
   Frame* frame() const { return frame_; }
   RegisterAllocator* register_allocator() const { return register_allocator_; }
 
   void DeleteGraphZone() {
     // Destroy objects with destructors first.
     source_positions_.Reset(nullptr);
     typer_.Reset(nullptr);
     if (graph_zone_ == nullptr) return;
     // Destroy zone and clear pointers.
     graph_zone_scope_.Destroy();
     graph_zone_ = nullptr;
     graph_ = nullptr;
+    loop_assignment_ = nullptr;
     machine_ = nullptr;
     common_ = nullptr;
     javascript_ = nullptr;
     jsgraph_ = nullptr;
     context_node_ = nullptr;
     schedule_ = nullptr;
   }
 
   void DeleteInstructionZone() {
     if (instruction_zone_ == nullptr) return;
@@ skipping 25 matching lines @@
 
  private:
   Isolate* isolate_;
   CompilationInfo* info_;
   Zone* outer_zone_;
   ZonePool* const zone_pool_;
   PipelineStatistics* pipeline_statistics_;
   bool compilation_failed_;
   Handle<Code> code_;
 
+  // All objects in the following group of fields are allocated in graph_zone_.
+  // They are all set to NULL when the graph_zone_ is destroyed.
   ZonePool::Scope graph_zone_scope_;
   Zone* graph_zone_;
-  // All objects in the following group of fields are allocated in graph_zone_.
-  // They are all set to NULL when the graph_zone_ is destroyed.
   Graph* graph_;
   // TODO(dcarney): make this into a ZoneObject.
   SmartPointer<SourcePositionTable> source_positions_;
+  LoopAssignmentAnalysis* loop_assignment_;
   MachineOperatorBuilder* machine_;
   CommonOperatorBuilder* common_;
   JSOperatorBuilder* javascript_;
   JSGraph* jsgraph_;
   // TODO(dcarney): make this into a ZoneObject.
   SmartPointer<Typer> typer_;
   Node* context_node_;
   Schedule* schedule_;
 
   // All objects in the following group of fields are allocated in
@@ skipping 45 matching lines @@
   } else {
     AllowHandleDereference allow_deref;
     name = info->function()->debug_name()->ToCString();
   }
   return name;
 }
 
 
 class AstGraphBuilderWithPositions : public AstGraphBuilder {
  public:
-  explicit AstGraphBuilderWithPositions(Zone* local_zone, CompilationInfo* info,
-                                        JSGraph* jsgraph,
-                                        SourcePositionTable* source_positions)
-      : AstGraphBuilder(local_zone, info, jsgraph),
+  AstGraphBuilderWithPositions(Zone* local_zone, CompilationInfo* info,
+                               JSGraph* jsgraph,
+                               LoopAssignmentAnalysis* loop_assignment,
+                               SourcePositionTable* source_positions)
+      : AstGraphBuilder(local_zone, info, jsgraph, loop_assignment),
         source_positions_(source_positions) {}
 
   bool CreateGraph() {
     SourcePositionTable::Scope pos(source_positions_,
                                    SourcePosition::Unknown());
     return AstGraphBuilder::CreateGraph();
   }
 
 #define DEF_VISIT(type)                                               \
   virtual void Visit##type(type* node) OVERRIDE {                     \
@@ skipping 36 matching lines @@
 
 
 template <typename Phase, typename Arg0>
 void Pipeline::Run(Arg0 arg_0) {
   PipelineRunScope scope(this->data_, Phase::phase_name());
   Phase phase;
   phase.Run(this->data_, scope.zone(), arg_0);
 }
 
 
+struct LoopAssignmentAnalysisPhase {
+  static const char* phase_name() { return "loop assignment analysis"; }
+
+  void Run(PipelineData* data, Zone* temp_zone) {
+    AstLoopAssignmentAnalyzer analyzer(data->graph_zone(), data->info());
+    LoopAssignmentAnalysis* loop_assignment = analyzer.Analyze();
+    data->set_loop_assignment(loop_assignment);
+  }
+};
+
+
 struct GraphBuilderPhase {
   static const char* phase_name() { return "graph builder"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
     AstGraphBuilderWithPositions graph_builder(
-        temp_zone, data->info(), data->jsgraph(), data->source_positions());
+        temp_zone, data->info(), data->jsgraph(), data->loop_assignment(),
+        data->source_positions());
     if (graph_builder.CreateGraph()) {
       data->set_context_node(graph_builder.GetFunctionContext());
     } else {
       data->set_compilation_failed();
     }
   }
 };
 
 
 struct ContextSpecializerPhase {
@@ skipping 380 matching lines @@
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Begin compiling method " << GetDebugName(info()).get()
        << " using Turbofan" << std::endl;
     TurboCfgFile tcf(isolate());
     tcf << AsC1VCompilation(info());
   }
 
   data.source_positions()->AddDecorator();
 
+  if (FLAG_loop_assignment_analysis) {
+    Run<LoopAssignmentAnalysisPhase>();
+  }
+
   Run<GraphBuilderPhase>();
   if (data.compilation_failed()) return Handle<Code>::null();
   RunPrintAndVerify("Initial untyped", true);
 
   Run<EarlyControlReductionPhase>();
   RunPrintAndVerify("Early Control reduced", true);
 
   if (info()->is_context_specializing()) {
     // Specialize the code to the context as aggressively as possible.
     Run<ContextSpecializerPhase>();
@@ skipping 277 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8