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 <sstream>
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/compiler/ast-graph-builder.h"
@@ skipping 87 matching lines @@
 
 
 void Pipeline::OpenTurboCfgFile(std::ofstream* stream) {
   char buffer[512];
   Vector<char> filename(buffer, sizeof(buffer));
   isolate()->GetTurboCfgFileName(filename);
   stream->open(filename.start(), std::fstream::out | std::fstream::app);
 }
 
 
-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;
     if (!info_->shared_info().is_null()) {
       functionname = info_->shared_info()->DebugName()->ToCString();
       if (strlen(functionname.get()) > 0) {
         SNPrintF(filename, "turbo-%s-%s", functionname.get(), phase);
       } else {
         SNPrintF(filename, "turbo-%p-%s", static_cast<void*>(info_), phase);
@@ skipping 17 matching lines @@
     SNPrintF(json_filename, "%s.json", filename.start());
     FILE* json_file = base::OS::FOpen(json_filename.start(), "w+");
     OFStream json_of(json_file);
     json_of << AsJSON(*graph);
     fclose(json_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);
+  }
 }
 
 
 void Pipeline::PrintScheduleAndInstructions(
     const char* phase, const Schedule* schedule,
     const SourcePositionTable* positions,
     const InstructionSequence* instructions) {
   std::ofstream turbo_cfg_stream;
   OpenTurboCfgFile(&turbo_cfg_stream);
   turbo_cfg_stream << AsC1V(phase, schedule, positions, instructions);
@@ skipping 67 matching lines @@
     PrintCompilationStart();
   }
 
   // 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());
   MachineOperatorBuilder machine;
   CommonOperatorBuilder common(zone());
   JSOperatorBuilder javascript(zone());
-  JSGraph jsgraph(&graph, &common, &javascript, &typer, &machine);
+  JSGraph jsgraph(&graph, &common, &javascript, &machine);
   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 (info()->is_context_specializing()) {
     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 (info()->is_inlining_enabled()) {
     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);
   }
 
   // Bailout here in case target architecture is not supported.
   if (!SupportedTarget()) return Handle<Code>::null();
 
   if (info()->is_typing_enabled()) {
     {
       // Type the graph.
       PhaseStats typer_stats(info(), PhaseStats::CREATE_GRAPH, "typer");
-      typer.Run(&graph, info()->context());
+      typer.Run();
       VerifyAndPrintGraph(&graph, "Typed");
     }
-    // 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 23 matching lines @@
       ChangeLowering lowering(&jsgraph, &linkage);
       MachineOperatorReducer mach_reducer(&jsgraph);
       GraphReducer graph_reducer(&graph);
       // TODO(titzer): Figure out if we should run all reducers at once here.
       graph_reducer.AddReducer(&vn_reducer);
       graph_reducer.AddReducer(&simple_reducer);
       graph_reducer.AddReducer(&lowering);
       graph_reducer.AddReducer(&mach_reducer);
       graph_reducer.ReduceGraph();
 
-      VerifyAndPrintGraph(&graph, "Lowered changes");
+      // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
+      VerifyAndPrintGraph(&graph, "Lowered changes", Verifier::UNTYPED);
     }
   }
 
   {
     // Lower any remaining generic JSOperators.
     PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
                               "generic lowering");
     SourcePositionTable::Scope pos(&source_positions,
                                    SourcePosition::Unknown());
     JSGenericLowering lowering(info(), &jsgraph);
     GraphReducer graph_reducer(&graph);
     graph_reducer.AddReducer(&lowering);
     graph_reducer.ReduceGraph();
 
-    VerifyAndPrintGraph(&graph, "Lowered generic");
+    // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
+    VerifyAndPrintGraph(&graph, "Lowered generic", Verifier::UNTYPED);
   }
 
   source_positions.RemoveDecorator();
 
   Handle<Code> code = Handle<Code>::null();
   {
     // Compute a schedule.
     Schedule* schedule = ComputeSchedule(&graph);
     // Generate optimized code.
     PhaseStats codegen_stats(info(), PhaseStats::CODEGEN, "codegen");
@@ skipping 24 matching lines @@
   if (VerifyGraphs()) ScheduleVerifier::Run(schedule);
   return schedule;
 }
 
 
 Handle<Code> Pipeline::GenerateCodeForMachineGraph(Linkage* linkage,
                                                    Graph* graph,
                                                    Schedule* schedule) {
   CHECK(SupportedBackend());
   if (schedule == NULL) {
-    VerifyAndPrintGraph(graph, "Machine");
+    VerifyAndPrintGraph(graph, "Machine", Verifier::UNTYPED);
     schedule = ComputeSchedule(graph);
   }
   TraceSchedule(schedule);
 
   SourcePositionTable source_positions(graph);
   Handle<Code> code = GenerateCode(linkage, graph, schedule, &source_positions);
 #if ENABLE_DISASSEMBLER
   if (!code.is_null() && FLAG_print_opt_code) {
     CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
     OFStream os(tracing_scope.file());
@@ skipping 75 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8