Better typing and type verification

src/compiler/pipeline.h

 // 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.
 
 #ifndef V8_COMPILER_PIPELINE_H_
 #define V8_COMPILER_PIPELINE_H_
 
 #include <fstream>  // NOLINT(readability/streams)
 
 #include "src/v8.h"
 
 #include "src/compiler.h"
+#include "src/compiler/verifier.h"

[Michael Starzinger, 2014/10/14 18:28:27]

Nope! Please don't inlclude any other header in this file from the compiler
directory. The reason is that pipeline.h is the only header allowed to be
included from outside the compiler directory and this leaks all definitions from
the verifier.h file to outside the compiler directory.

[rossberg, 2014/10/15 06:47:58]

Sigh. Proliferation like this is just one ugly consequence of not making the
graph sufficiently self-describing with respect to its being typed or not. You
asked for that.

I will try to make VerifyAndPrintGraph and its dependencies from private methods
into local static functions in pipeline.cc -- or forego best practice and use a
boolean argument. Whatever turns out less hacky.

[rossberg, 2014/10/15 08:59:08]

Done.

 
 // Note: TODO(turbofan) implies a performance improvement opportunity,
 //   and TODO(name) implies an incomplete implementation
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Clients of this interface shouldn't depend on lots of compiler internals.
 class Graph;
@@ skipping 28 matching lines @@
   Isolate* isolate() { return info_->isolate(); }
   Zone* zone() { return info_->zone(); }
 
   Schedule* ComputeSchedule(Graph* graph);
   void OpenTurboCfgFile(std::ofstream* stream);
   void PrintCompilationStart();
   void PrintScheduleAndInstructions(const char* phase, const Schedule* schedule,
                                     const SourcePositionTable* positions,
                                     const InstructionSequence* instructions);
   void PrintAllocator(const char* phase, const RegisterAllocator* allocator);
-  void VerifyAndPrintGraph(Graph* graph, const char* phase);
+  void VerifyAndPrintGraph(Graph* graph, const char* phase,
+                           Verifier::Typing = Verifier::TYPED);
   Handle<Code> GenerateCode(Linkage* linkage, Graph* graph, Schedule* schedule,
                             SourcePositionTable* source_positions);
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_PIPELINE_H_