Unify use-sites of EnsureDeoptimizationSupport.

test/cctest/compiler/function-tester.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_CCTEST_COMPILER_FUNCTION_TESTER_H_
 #define V8_CCTEST_COMPILER_FUNCTION_TESTER_H_
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
@@ skipping 39 matching lines @@
       info.MarkAsContextSpecializing();
     }
     if (flags_ & CompilationInfo::kInliningEnabled) {
       info.MarkAsInliningEnabled();
     }
     if (flags_ & CompilationInfo::kTypingEnabled) {
       info.MarkAsTypingEnabled();
     }
     CHECK(Rewriter::Rewrite(&info));
     CHECK(Scope::Analyze(&info));
-    CHECK_NE(NULL, info.scope());
-    Handle<ScopeInfo> scope_info = ScopeInfo::Create(info.scope(), info.zone());
-    info.shared_info()->set_scope_info(*scope_info);
-
-    EnsureDeoptimizationSupport(&info);
+    CHECK(Compiler::EnsureDeoptimizationSupport(&info));
 
     Pipeline pipeline(&info);
     Handle<Code> code = pipeline.GenerateCode();
     if (FLAG_turbo_deoptimization) {
       info.context()->native_context()->AddOptimizedCode(*code);
     }
 
     CHECK(!code.is_null());
     function->ReplaceCode(*code);
 #elif USE_CRANKSHAFT
     Handle<Code> unoptimized = Handle<Code>(function->code());
     Handle<Code> code = Compiler::GetOptimizedCode(function, unoptimized,
                                                    Compiler::NOT_CONCURRENT);
     CHECK(!code.is_null());
 #if ENABLE_DISASSEMBLER
     if (FLAG_print_opt_code) {
       CodeTracer::Scope tracing_scope(isolate->GetCodeTracer());
       code->Disassemble("test code", tracing_scope.file());
     }
 #endif
     function->ReplaceCode(*code);
 #endif
     return function;
   }
 
-  static void EnsureDeoptimizationSupport(CompilationInfo* info) {
-    bool should_recompile = !info->shared_info()->has_deoptimization_support();
-    if (should_recompile) {
-      CompilationInfoWithZone unoptimized(info->shared_info());
-      // Note that we use the same AST that we will use for generating the
-      // optimized code.
-      unoptimized.SetFunction(info->function());
-      unoptimized.PrepareForCompilation(info->scope());
-      unoptimized.SetContext(info->context());
-      if (should_recompile) unoptimized.EnableDeoptimizationSupport();
-      bool succeeded = FullCodeGenerator::MakeCode(&unoptimized);
-      CHECK(succeeded);
-      Handle<SharedFunctionInfo> shared = info->shared_info();
-      shared->EnableDeoptimizationSupport(*unoptimized.code());
-    }
-  }
-
   MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b) {
     Handle<Object> args[] = {a, b};
     return Execution::Call(isolate, function, undefined(), 2, args, false);
   }
 
   void CheckThrows(Handle<Object> a, Handle<Object> b) {
     TryCatch try_catch;
     MaybeHandle<Object> no_result = Call(a, b);
     CHECK(isolate->has_pending_exception());
     CHECK(try_catch.HasCaught());
@@ skipping 88 matching lines @@
   Handle<Object> false_value() { return isolate->factory()->false_value(); }
 
  private:
   uint32_t flags_;
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_CCTEST_COMPILER_FUNCTION_TESTER_H_