[turbofan] Remove deprecated --turbo-from-bytecode flag.

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 <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 601 matching lines @@
   Isolate* isolate = function->GetIsolate();
   Handle<SharedFunctionInfo> shared(function->shared(), isolate);
 
   bool ignition_osr = osr_frame && osr_frame->is_interpreted();
   DCHECK_IMPLIES(ignition_osr, !osr_ast_id.IsNone());
   DCHECK_IMPLIES(ignition_osr, FLAG_ignition_osr);
 
   // Shared function no longer needs to be tiered up
   shared->set_marked_for_tier_up(false);
 
-  // Flag combination --ignition-osr --no-turbo-from-bytecode is unsupported.
-  if (ignition_osr && !FLAG_turbo_from_bytecode) return MaybeHandle<Code>();
-
   Handle<Code> cached_code;
   // TODO(4764): When compiling for OSR from bytecode, BailoutId might derive
   // from bytecode offset and overlap with actual BailoutId. No lookup!
   if (!ignition_osr &&
       GetCodeFromOptimizedCodeMap(function, osr_ast_id)
           .ToHandle(&cached_code)) {
     if (FLAG_trace_opt) {
       PrintF("[found optimized code for ");
       function->ShortPrint();
       if (!osr_ast_id.IsNone()) {
@@ skipping 33 matching lines @@
   if (info->shared_info()->opt_count() > kMaxOptCount) {
     info->AbortOptimization(kOptimizedTooManyTimes);
     return MaybeHandle<Code>();
   }
 
   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 && ShouldUseIgnition(info)) {
+  if (use_turbofan && ShouldUseIgnition(info)) {
     if (info->is_osr() && !ignition_osr) return MaybeHandle<Code>();
     if (!Compiler::EnsureBytecode(info)) {
       if (isolate->has_pending_exception()) isolate->clear_pending_exception();
       return MaybeHandle<Code>();
     }
     info->MarkAsOptimizeFromBytecode();
   }
 
   // Verify that OSR compilations are delegated to the correct graph builder.
   // Depending on the underlying frame the semantics of the {BailoutId} differ
@@ skipping 92 matching lines @@
                                      public OptimizedFunctionVisitor {
  public:
   explicit InterpreterActivationsFinder(SharedFunctionInfo* shared)
       : shared_(shared), has_activations_(false) {}
 
   void VisitThread(Isolate* isolate, ThreadLocalTop* top) {
     Address* activation_pc_address = nullptr;
     JavaScriptFrameIterator it(isolate, top);
     for (; !it.done(); it.Advance()) {
       JavaScriptFrame* frame = it.frame();
-      if (FLAG_turbo_from_bytecode && FLAG_ignition_osr &&
-          frame->is_optimized() && frame->function()->shared() == shared_) {
-        // If we are able to optimize functions directly from bytecode, then
-        // there might be optimized OSR code active on the stack that is not
+      if (FLAG_ignition_osr && frame->is_optimized() &&
+          frame->function()->shared() == shared_) {
+        // There might be optimized OSR code active on the stack that is not
         // reachable through a function. We count this as an activation.
         has_activations_ = true;
       }
       if (frame->is_interpreted() && frame->function()->shared() == shared_) {
         has_activations_ = true;
         activation_pc_address = frame->pc_address();
       }
     }
 
     if (activation_pc_address) {
@@ skipping 26 matching lines @@
  private:
   SharedFunctionInfo* shared_;
   bool has_activations_;
   std::vector<Address*> activation_pc_addresses_;
 };
 
 bool HasInterpreterActivations(
     Isolate* isolate, InterpreterActivationsFinder* activations_finder) {
   activations_finder->VisitThread(isolate, isolate->thread_local_top());
   isolate->thread_manager()->IterateArchivedThreads(activations_finder);
-  if (FLAG_turbo_from_bytecode) {
-    // If we are able to optimize functions directly from bytecode, then there
-    // might be optimized functions that rely on bytecode being around. We need
-    // to prevent switching the given function to baseline code in those cases.
-    Deoptimizer::VisitAllOptimizedFunctions(isolate, activations_finder);
-  }
+  // There might be optimized functions that rely on bytecode being around. We
+  // need to prevent switching the given function to baseline code.
+  Deoptimizer::VisitAllOptimizedFunctions(isolate, activations_finder);
   return activations_finder->has_activations();
 }
 
 MaybeHandle<Code> GetBaselineCode(Handle<JSFunction> function) {
   Isolate* isolate = function->GetIsolate();
   VMState<COMPILER> state(isolate);
   PostponeInterruptsScope postpone(isolate);
   Zone zone(isolate->allocator(), ZONE_NAME);
   ParseInfo parse_info(&zone, handle(function->shared()));
   CompilationInfo info(&parse_info, function);
@@ skipping 508 matching lines @@
     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)) {
+    if (UseTurboFan(shared)) {
       return OPTIMIZED;
     } else {
       return BASELINE;
     }
   } else {
     return OPTIMIZED;
   }
 }
 
 MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
@@ skipping 441 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