[Intepreter] Always use BytecodeGraphBuilder when --turbo-from-bytecode

src/compiler.h

 // Copyright 2012 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_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/bailout-reason.h"
@@ skipping 19 matching lines @@
 // the object heap should be kept inside this class.
 //
 // General strategy: Scripts are translated into anonymous functions w/o
 // parameters which then can be executed. If the source code contains other
 // functions, they might be compiled and allocated as part of the compilation
 // of the source code or deferred for lazy compilation at a later point.
 class Compiler : public AllStatic {
  public:
   enum ClearExceptionFlag { KEEP_EXCEPTION, CLEAR_EXCEPTION };
   enum ConcurrencyMode { NOT_CONCURRENT, CONCURRENT };
+  enum CompilationTier { INTERPRETED, BASELINE, OPTIMIZED };
 
   // ===========================================================================
   // The following family of methods ensures a given function is compiled. The
   // general contract is that failures will be reported by returning {false},
   // whereas successful compilation ensures the {is_compiled} predicate on the
   // given function holds (except for live-edit, which compiles the world).
 
   static bool Compile(Handle<JSFunction> function, ClearExceptionFlag flag);
   static bool CompileBaseline(Handle<JSFunction> function);
   static bool CompileOptimized(Handle<JSFunction> function, ConcurrencyMode);
   static bool CompileDebugCode(Handle<JSFunction> function);
   static bool CompileDebugCode(Handle<SharedFunctionInfo> shared);
   static MaybeHandle<JSArray> CompileForLiveEdit(Handle<Script> script);
 
   // Generate and install code from previously queued compilation job.
   static void FinalizeCompilationJob(CompilationJob* job);
 
   // Give the compiler a chance to perform low-latency initialization tasks of
   // the given {function} on its instantiation. Note that only the runtime will
   // offer this chance, optimized closure instantiation will not call this.
   static void PostInstantiation(Handle<JSFunction> function, PretenureFlag);
 
   // Parser::Parse, then Compiler::Analyze.
   static bool ParseAndAnalyze(ParseInfo* info);
   // Rewrite, analyze scopes, and renumber.
   static bool Analyze(ParseInfo* info);
   // Adds deoptimization support, requires ParseAndAnalyze.
   static bool EnsureDeoptimizationSupport(CompilationInfo* info);
+  // Ensures that bytecode is generated.
+  static bool EnsureBytecode(CompilationInfo* info);
+
+  // The next compilation tier which the function should  be compiled to for
+  // optimization.
+  static CompilationTier NextCompilationTier(JSFunction* function);
+
+  // True if the given function compilation should use Ignition for unoptimized
+  // compilation.
+  static bool ShouldUseIgnition(CompilationInfo* info);

[Michael Starzinger, 2016/07/19 09:36:02]

There seems to be only one use of this predicate outside the compiler and it is
inside an assertion. Could we instead move the assertion from the
{AstGraphBuilder} into {GetOptimizedCode} where we decide to call
{info->MarkAsOptimizeFromBytecode} or not? I really would like to avoid exposing
this predicate.

[rmcilroy, 2016/07/19 13:13:50]

Yeah I thought you might say this :). I've removed the assertion - there isn't
really any other assertion we can add to GetOptimizedCode, it should mark it
unconditinally now (or bail out of optimization if EnsureBytecode fails), so
this should be just as good.

 
   // ===========================================================================
   // The following family of methods instantiates new functions for scripts or
   // function literals. The decision whether those functions will be compiled,
   // is left to the discretion of the compiler.
   //
   // Please note this interface returns shared function infos.  This means you
   // need to call Factory::NewFunctionFromSharedFunctionInfo before you have a
   // real function with a context.
 
@@ skipping 494 matching lines @@
   MUST_USE_RESULT Status SetLastStatus(Status status) {
     last_status_ = status;
     return last_status_;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_H_