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

src/compiler.cc

 // 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.
 
 #include "src/compiler.h"
 
 #include <algorithm>
 
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
@@ skipping 423 matching lines @@
         info->isolate(), info->literal()->feedback_vector_spec());
     info->shared_info()->set_feedback_metadata(*feedback_metadata);
   }
 
   // It's very important that recompiles do not alter the structure of the type
   // feedback vector. Verify that the structure fits the function literal.
   CHECK(!info->shared_info()->feedback_metadata()->SpecDiffersFrom(
       info->literal()->feedback_vector_spec()));
 }
 
-bool UseIgnition(CompilationInfo* info) {
-  DCHECK(info->has_shared_info());
-
-  // When requesting debug code as a replacement for existing code, we provide
-  // the same kind as the existing code (to prevent implicit tier-change).
-  if (info->is_debug() && info->shared_info()->is_compiled()) {
-    return info->shared_info()->HasBytecodeArray();
-  }
-
-  // For generator or async functions we might avoid Ignition wholesale.
-  if (info->shared_info()->is_resumable() && !FLAG_ignition_generators) {
-    return false;
-  }
-
-  // Since we can't OSR from Ignition, skip Ignition for asm.js functions.
-  if (info->shared_info()->asm_function()) {
-    return false;
-  }
-
-  // Checks whether top level functions should be passed by the filter.
-  if (info->shared_info()->is_toplevel()) {
-    Vector<const char> filter = CStrVector(FLAG_ignition_filter);
-    return (filter.length() == 0) || (filter.length() == 1 && filter[0] == '*');
-  }
-
-  // Finally respect the filter.
-  return info->shared_info()->PassesFilter(FLAG_ignition_filter);
-}
-
 int CodeAndMetadataSize(CompilationInfo* info) {
   if (info->has_bytecode_array()) {
     return info->bytecode_array()->SizeIncludingMetadata();
   }
   return info->code()->SizeIncludingMetadata();
 }
 
 bool GenerateUnoptimizedCode(CompilationInfo* info) {
   bool success;
   EnsureFeedbackMetadata(info);
   if (FLAG_validate_asm && info->scope()->asm_module()) {
     MaybeHandle<FixedArray> wasm_data;
     wasm_data = AsmJs::ConvertAsmToWasm(info->parse_info());
     if (!wasm_data.is_null()) {
       info->shared_info()->set_asm_wasm_data(*wasm_data.ToHandleChecked());
       info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
       return true;
     }
   }
-  if (FLAG_ignition && UseIgnition(info)) {
+  if (FLAG_ignition && Compiler::ShouldUseIgnition(info)) {
     success = interpreter::Interpreter::MakeBytecode(info);
   } else {
     success = FullCodeGenerator::MakeCode(info);
   }
   if (success) {
     Isolate* isolate = info->isolate();
     Counters* counters = isolate->counters();
     // TODO(4280): Rename counters from "baseline" to "unoptimized" eventually.
     counters->total_baseline_code_size()->Increment(CodeAndMetadataSize(info));
     counters->total_baseline_compile_count()->Increment(1);
@@ skipping 292 matching lines @@
     return MaybeHandle<Code>();
   }
 
   CanonicalHandleScope canonical(isolate);
   TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
   RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::OptimizeCode);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.OptimizeCode");
 
   // TurboFan can optimize directly from existing bytecode.
   if (FLAG_turbo_from_bytecode && use_turbofan &&
-      info->shared_info()->HasBytecodeArray()) {
+      Compiler::ShouldUseIgnition(info)) {
+    if (!Compiler::EnsureBytecode(info)) return MaybeHandle<Code>();
     info->MarkAsOptimizeFromBytecode();
   }
 
   if (IsEvalToplevel(shared)) {
     parse_info->set_eval();
     if (function->context()->IsNativeContext()) parse_info->set_global();
     parse_info->set_toplevel();
     parse_info->set_allow_lazy_parsing(false);
     parse_info->set_lazy(false);
   }
@@ skipping 521 matching lines @@
   }
 
   // Restore the original function info list in order to remain side-effect
   // free as much as possible, since some code expects the old shared function
   // infos to stick around.
   script->set_shared_function_infos(*old_function_infos);
 
   return infos;
 }
 
+bool Compiler::EnsureBytecode(CompilationInfo* info) {
+  DCHECK(Compiler::ShouldUseIgnition(info));
+  if (!info->shared_info()->HasBytecodeArray()) {
+    DCHECK(!info->shared_info()->is_compiled());
+    if (GetUnoptimizedCode(info).is_null()) return false;
+  }
+  DCHECK(info->shared_info()->HasBytecodeArray());
+  return true;
+}
+
 // TODO(turbofan): In the future, unoptimized code with deopt support could
 // be generated lazily once deopt is triggered.
 bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
   DCHECK_NOT_NULL(info->literal());
   DCHECK_NOT_NULL(info->scope());
   Handle<SharedFunctionInfo> shared = info->shared_info();
   if (!shared->has_deoptimization_support()) {
     Zone zone(info->isolate()->allocator());
     CompilationInfo unoptimized(info->parse_info(), info->closure());
     unoptimized.EnableDeoptimizationSupport();
@@ skipping 41 matching lines @@
     // Install compilation result on the shared function info
     shared->EnableDeoptimizationSupport(*unoptimized.code());
 
     // The existing unoptimized code was replaced with the new one.
     RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG,
                               &unoptimized);
   }
   return true;
 }
 
+// static
+Compiler::CompilationTier Compiler::NextCompilationTier(JSFunction* function) {
+  Handle<SharedFunctionInfo> shared(function->shared(), function->GetIsolate());
+  if (shared->code()->is_interpreter_trampoline_builtin()) {
+    if (FLAG_turbo_from_bytecode && UseTurboFan(shared)) {
+      return OPTIMIZED;
+    } else {
+      return BASELINE;
+    }
+  } else {
+    return OPTIMIZED;
+  }
+}
+
+// static
+bool Compiler::ShouldUseIgnition(CompilationInfo* info) {
+  DCHECK(info->has_shared_info());
+
+  // When requesting debug code as a replacement for existing code, we provide
+  // the same kind as the existing code (to prevent implicit tier-change).
+  if (info->is_debug() && info->shared_info()->is_compiled()) {
+    return info->shared_info()->HasBytecodeArray();
+  }
+
+  // For generator or async functions we might avoid Ignition wholesale.
+  if (info->shared_info()->is_resumable() && !FLAG_ignition_generators) {
+    return false;
+  }
+
+  // Since we can't OSR from Ignition, skip Ignition for asm.js functions.
+  if (info->shared_info()->asm_function()) {
+    return false;
+  }
+
+  // Checks whether top level functions should be passed by the filter.
+  if (info->shared_info()->is_toplevel()) {
+    Vector<const char> filter = CStrVector(FLAG_ignition_filter);
+    return (filter.length() == 0) || (filter.length() == 1 && filter[0] == '*');
+  }
+
+  // Finally respect the filter.
+  return info->shared_info()->PassesFilter(FLAG_ignition_filter);
+}
+
 MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
     Handle<String> source, Handle<SharedFunctionInfo> outer_info,
     Handle<Context> context, LanguageMode language_mode,
     ParseRestriction restriction, int eval_scope_position, int eval_position,
     int line_offset, int column_offset, Handle<Object> script_name,
     ScriptOriginOptions options) {
   Isolate* isolate = source->GetIsolate();
   int source_length = source->length();
   isolate->counters()->total_eval_size()->Increment(source_length);
   isolate->counters()->total_compile_size()->Increment(source_length);
@@ skipping 425 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8