[Turbofan] Simplified lowering to be done concurrently.

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 <memory>
 #include <sstream>
 
@@ skipping 927 matching lines @@
     AddReducer(data, &graph_reducer, &escape_reducer);
     graph_reducer.ReduceGraph();
     if (escape_reducer.compilation_failed()) {
       data->set_compilation_failed();
       return;
     }
     escape_reducer.VerifyReplacement();
   }
 };
 
-struct RepresentationSelectionPhase {
-  static const char* phase_name() { return "representation selection"; }
+struct SimplifiedLoweringPhase {
+  static const char* phase_name() { return "simplified lowering"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
     SimplifiedLowering lowering(data->jsgraph(), temp_zone,
                                 data->source_positions());
     lowering.LowerAllNodes();
   }
 };
 
 struct LoopPeelingPhase {
   static const char* phase_name() { return "loop peeling"; }
@@ skipping 586 matching lines @@
         if (data->compilation_failed()) {
           info()->AbortOptimization(kCyclicObjectStateDetectedInEscapeAnalysis);
           data->EndPhaseKind();
           return false;
         }
         RunPrintAndVerify("Escape Analysed");
       }
     }
   }
 
-  // Select representations. This has to run w/o the Typer decorator, because
-  // we cannot compute meaningful types anyways, and the computed types might
-  // even conflict with the representation/truncation logic.
-  Run<RepresentationSelectionPhase>();
-  RunPrintAndVerify("Representations selected", true);
+  // Do some hacky things to prepare generic lowering.
+  Run<GenericLoweringPrepPhase>();
+
+  data->EndPhaseKind();
+
+  return true;
+}
+
+bool PipelineImpl::OptimizeGraph(Linkage* linkage) {
+  PipelineData* data = this->data_;
+
+  // Perform simplified lowering. This has to run w/o the Typer decorator,
+  // because we cannot compute meaningful types anyways, and the computed types
+  // might even conflict with the representation/truncation logic.
+  Run<SimplifiedLoweringPhase>();
+  RunPrintAndVerify("Simplified lowering", true);
 
 #ifdef DEBUG
   // From now on it is invalid to look at types on the nodes, because:
   //
   //  (a) The remaining passes (might) run concurrent to the main thread and
   //      therefore must not access the Heap or the Isolate in an uncontrolled
   //      way (as done by the type system), and
   //  (b) the types on the nodes might not make sense after representation
   //      selection due to the way we handle truncations; if we'd want to look
   //      at types afterwards we'd essentially need to re-type (large portions
   //      of) the graph.
   //
   // In order to catch bugs related to type access after this point we remove
   // the types from the nodes at this point (currently only in Debug builds).
   Run<UntyperPhase>();
   RunPrintAndVerify("Untyped", true);
 #endif
 
-  // Do some hacky things to prepare generic lowering.
-  Run<GenericLoweringPrepPhase>();
-
-  data->EndPhaseKind();
-
-  return true;
-}
-
-bool PipelineImpl::OptimizeGraph(Linkage* linkage) {
-  PipelineData* data = this->data_;
-
   // Run generic lowering pass.
   Run<GenericLoweringPhase>();
   RunPrintAndVerify("Generic lowering", true);
 
   data->BeginPhaseKind("block building");
 
   // Run early optimization pass.
   Run<EarlyOptimizationPhase>();
   RunPrintAndVerify("Early optimized", true);
 
@@ skipping 393 matching lines @@
   data->DeleteRegisterAllocationZone();
 }
 
 CompilationInfo* PipelineImpl::info() const { return data_->info(); }
 
 Isolate* PipelineImpl::isolate() const { return info()->isolate(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8