Better typing and type verification

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 "src/base/platform/elapsed-timer.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/code-generator.h"
 #include "src/compiler/graph-replay.h"
@@ skipping 65 matching lines @@
 
 static inline bool VerifyGraphs() {
 #ifdef DEBUG
   return true;
 #else
   return FLAG_turbo_verify;
 #endif
 }
 
 
-void Pipeline::VerifyAndPrintGraph(Graph* graph, const char* phase) {
+void Pipeline::VerifyAndPrintGraph(
+    Graph* graph, const char* phase, Verifier::Typing typing) {
   if (FLAG_trace_turbo) {
     char buffer[256];
     Vector<char> filename(buffer, sizeof(buffer));
     SmartArrayPointer<char> functionname =
         info_->shared_info()->DebugName()->ToCString();
     if (strlen(functionname.get()) > 0) {
       SNPrintF(filename, "turbo-%s-%s.dot", functionname.get(), phase);
     } else {
       SNPrintF(filename, "turbo-%p-%s.dot", static_cast<void*>(info_), phase);
     }
     std::replace(filename.start(), filename.start() + filename.length(), ' ',
                  '_');
     FILE* file = base::OS::FOpen(filename.start(), "w+");
     OFStream of(file);
     of << AsDOT(*graph);
     fclose(file);
 
     OFStream os(stdout);
     os << "-- " << phase << " graph printed to file " << filename.start()
        << "\n";
   }
-  if (VerifyGraphs()) Verifier::Run(graph);
+  if (VerifyGraphs()) {
+    Verifier::Run(graph, FLAG_turbo_types ? typing : Verifier::UNTYPED);
+  }
 }
 
 
 class AstGraphBuilderWithPositions : public AstGraphBuilder {
  public:
   explicit AstGraphBuilderWithPositions(CompilationInfo* info, JSGraph* jsgraph,
                                         SourcePositionTable* source_positions)
       : AstGraphBuilder(info, jsgraph), source_positions_(source_positions) {}
 
   bool CreateGraph() {
@@ skipping 31 matching lines @@
     os << "---------------------------------------------------\n"
        << "Begin compiling method "
        << info()->function()->debug_name()->ToCString().get()
        << " using Turbofan" << endl;
   }
 
   // Build the graph.
   Graph graph(zone());
   SourcePositionTable source_positions(&graph);
   source_positions.AddDecorator();
-  // TODO(turbofan): there is no need to type anything during initial graph
-  // construction.  This is currently only needed for the node cache, which the
-  // typer could sweep over later.
-  Typer typer(zone());
+  Typer typer(&graph, info()->context());
   CommonOperatorBuilder common(zone());
-  JSGraph jsgraph(&graph, &common, &typer);
+  JSGraph jsgraph(&graph, &common);
   Node* context_node;
   {
     PhaseStats graph_builder_stats(info(), PhaseStats::CREATE_GRAPH,
                                    "graph builder");
     AstGraphBuilderWithPositions graph_builder(info(), &jsgraph,
                                                &source_positions);
     graph_builder.CreateGraph();
     context_node = graph_builder.GetFunctionContext();
   }
   {
     PhaseStats phi_reducer_stats(info(), PhaseStats::CREATE_GRAPH,
                                  "phi reduction");
     PhiReducer phi_reducer;
     GraphReducer graph_reducer(&graph);
     graph_reducer.AddReducer(&phi_reducer);
     graph_reducer.ReduceGraph();
     // TODO(mstarzinger): Running reducer once ought to be enough for everyone.
     graph_reducer.ReduceGraph();
     graph_reducer.ReduceGraph();
   }
 
-  VerifyAndPrintGraph(&graph, "Initial untyped");
+  VerifyAndPrintGraph(&graph, "Initial untyped", Verifier::UNTYPED);
 
   if (context_specialization_) {
     SourcePositionTable::Scope pos(&source_positions,
                                    SourcePosition::Unknown());
     // Specialize the code to the context as aggressively as possible.
     JSContextSpecializer spec(info(), &jsgraph, context_node);
     spec.SpecializeToContext();
-    VerifyAndPrintGraph(&graph, "Context specialized");
+    VerifyAndPrintGraph(&graph, "Context specialized", Verifier::UNTYPED);
   }
 
   if (FLAG_turbo_inlining) {
     SourcePositionTable::Scope pos(&source_positions,
                                    SourcePosition::Unknown());
     JSInliner inliner(info(), &jsgraph);
     inliner.Inline();
-    VerifyAndPrintGraph(&graph, "Inlined");
+    VerifyAndPrintGraph(&graph, "Inlined", Verifier::UNTYPED);
   }
 
   // Print a replay of the initial graph.
   if (FLAG_print_turbo_replay) {
     GraphReplayPrinter::PrintReplay(&graph);
   }
 
   if (FLAG_turbo_types) {
     {
       // Type the graph.
       PhaseStats typer_stats(info(), PhaseStats::CREATE_GRAPH, "typer");
-      typer.Run(&graph, info()->context());
+      typer.Run();
     }
-    // All new nodes must be typed.
-    typer.DecorateGraph(&graph);
     {
       // Lower JSOperators where we can determine types.
       PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
                                 "typed lowering");
       SourcePositionTable::Scope pos(&source_positions,
                                      SourcePosition::Unknown());
       JSTypedLowering lowering(&jsgraph);
       GraphReducer graph_reducer(&graph);
       graph_reducer.AddReducer(&lowering);
       graph_reducer.ReduceGraph();
@@ skipping 130 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8