LCOV - code coverage report
Current view: top level - src - compiler.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 616 685 89.9 %
Date: 2017-04-26 Functions: 62 64 96.9 %

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/compiler.h"
       6             : 
       7             : #include <algorithm>
       8             : #include <memory>
       9             : 
      10             : #include "src/asmjs/asm-js.h"
      11             : #include "src/asmjs/asm-typer.h"
      12             : #include "src/assembler-inl.h"
      13             : #include "src/ast/ast-numbering.h"
      14             : #include "src/ast/prettyprinter.h"
      15             : #include "src/ast/scopes.h"
      16             : #include "src/bootstrapper.h"
      17             : #include "src/codegen.h"
      18             : #include "src/compilation-cache.h"
      19             : #include "src/compiler-dispatcher/compiler-dispatcher.h"
      20             : #include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
      21             : #include "src/compiler/pipeline.h"
      22             : #include "src/crankshaft/hydrogen.h"
      23             : #include "src/debug/debug.h"
      24             : #include "src/debug/liveedit.h"
      25             : #include "src/frames-inl.h"
      26             : #include "src/full-codegen/full-codegen.h"
      27             : #include "src/globals.h"
      28             : #include "src/heap/heap.h"
      29             : #include "src/interpreter/interpreter.h"
      30             : #include "src/isolate-inl.h"
      31             : #include "src/log-inl.h"
      32             : #include "src/messages.h"
      33             : #include "src/parsing/parsing.h"
      34             : #include "src/parsing/rewriter.h"
      35             : #include "src/parsing/scanner-character-streams.h"
      36             : #include "src/runtime-profiler.h"
      37             : #include "src/snapshot/code-serializer.h"
      38             : #include "src/vm-state-inl.h"
      39             : 
      40             : namespace v8 {
      41             : namespace internal {
      42             : 
      43             : // A wrapper around a ParseInfo that detaches the parser handles from the
      44             : // underlying DeferredHandleScope and stores them in info_ on destruction.
      45             : class ParseHandleScope final {
      46             :  public:
      47             :   explicit ParseHandleScope(ParseInfo* info, Isolate* isolate)
      48           0 :       : deferred_(isolate), info_(info) {}
      49           0 :   ~ParseHandleScope() { info_->set_deferred_handles(deferred_.Detach()); }
      50             : 
      51             :  private:
      52             :   DeferredHandleScope deferred_;
      53             :   ParseInfo* info_;
      54             : };
      55             : 
      56             : // A wrapper around a CompilationInfo that detaches the Handles from
      57             : // the underlying DeferredHandleScope and stores them in info_ on
      58             : // destruction.
      59             : class CompilationHandleScope final {
      60             :  public:
      61      148169 :   explicit CompilationHandleScope(CompilationInfo* info)
      62      148169 :       : deferred_(info->isolate()), info_(info) {}
      63      148169 :   ~CompilationHandleScope() { info_->set_deferred_handles(deferred_.Detach()); }
      64             : 
      65             :  private:
      66             :   DeferredHandleScope deferred_;
      67             :   CompilationInfo* info_;
      68             : };
      69             : 
      70             : // Helper that times a scoped region and records the elapsed time.
      71             : struct ScopedTimer {
      72    10869608 :   explicit ScopedTimer(base::TimeDelta* location) : location_(location) {
      73             :     DCHECK(location_ != NULL);
      74             :     timer_.Start();
      75             :   }
      76             : 
      77    32609002 :   ~ScopedTimer() { *location_ += timer_.Elapsed(); }
      78             : 
      79             :   base::ElapsedTimer timer_;
      80             :   base::TimeDelta* location_;
      81             : };
      82             : 
      83             : // ----------------------------------------------------------------------------
      84             : // Implementation of CompilationJob
      85             : 
      86     3415224 : CompilationJob::CompilationJob(Isolate* isolate, CompilationInfo* info,
      87             :                                const char* compiler_name, State initial_state)
      88             :     : info_(info),
      89             :       isolate_thread_id_(isolate->thread_id()),
      90             :       compiler_name_(compiler_name),
      91             :       state_(initial_state),
      92     3794247 :       stack_limit_(isolate->stack_guard()->real_climit()),
      93    11382741 :       executed_on_background_thread_(false) {}
      94             : 
      95     3582808 : CompilationJob::Status CompilationJob::PrepareJob() {
      96             :   DCHECK(ThreadId::Current().Equals(info()->isolate()->thread_id()));
      97     3582808 :   DisallowJavascriptExecution no_js(isolate());
      98             : 
      99     3582810 :   if (FLAG_trace_opt && info()->IsOptimizing()) {
     100           0 :     OFStream os(stdout);
     101           0 :     os << "[compiling method " << Brief(*info()->closure()) << " using "
     102           0 :        << compiler_name_;
     103           0 :     if (info()->is_osr()) os << " OSR";
     104           0 :     os << "]" << std::endl;
     105             :   }
     106             : 
     107             :   // Delegate to the underlying implementation.
     108             :   DCHECK(state() == State::kReadyToPrepare);
     109     7165615 :   ScopedTimer t(&time_taken_to_prepare_);
     110     7165640 :   return UpdateState(PrepareJobImpl(), State::kReadyToExecute);
     111             : }
     112             : 
     113     3647507 : CompilationJob::Status CompilationJob::ExecuteJob() {
     114             :   std::unique_ptr<DisallowHeapAllocation> no_allocation;
     115             :   std::unique_ptr<DisallowHandleAllocation> no_handles;
     116             :   std::unique_ptr<DisallowHandleDereference> no_deref;
     117             :   std::unique_ptr<DisallowCodeDependencyChange> no_dependency_change;
     118     3647507 :   if (can_execute_on_background_thread()) {
     119     2798690 :     no_allocation.reset(new DisallowHeapAllocation());
     120     2798712 :     no_handles.reset(new DisallowHandleAllocation());
     121     2798707 :     no_deref.reset(new DisallowHandleDereference());
     122     2798711 :     no_dependency_change.reset(new DisallowCodeDependencyChange());
     123             :     executed_on_background_thread_ =
     124     5597387 :         !ThreadId::Current().Equals(isolate_thread_id_);
     125             :   } else {
     126             :     DCHECK(ThreadId::Current().Equals(isolate_thread_id_));
     127             :   }
     128             : 
     129             :   // Delegate to the underlying implementation.
     130             :   DCHECK(state() == State::kReadyToExecute);
     131     7294996 :   ScopedTimer t(&time_taken_to_execute_);
     132     7295081 :   return UpdateState(ExecuteJobImpl(), State::kReadyToFinalize);
     133             : }
     134             : 
     135     3639310 : CompilationJob::Status CompilationJob::FinalizeJob() {
     136             :   DCHECK(ThreadId::Current().Equals(info()->isolate()->thread_id()));
     137             :   DisallowCodeDependencyChange no_dependency_change;
     138     3639310 :   DisallowJavascriptExecution no_js(isolate());
     139             :   DCHECK(!info()->dependencies()->HasAborted());
     140             : 
     141             :   // Delegate to the underlying implementation.
     142             :   DCHECK(state() == State::kReadyToFinalize);
     143     7278629 :   ScopedTimer t(&time_taken_to_finalize_);
     144     7278658 :   return UpdateState(FinalizeJobImpl(), State::kSucceeded);
     145             : }
     146             : 
     147           0 : CompilationJob::Status CompilationJob::RetryOptimization(BailoutReason reason) {
     148             :   DCHECK(info_->IsOptimizing());
     149          90 :   info_->RetryOptimization(reason);
     150          90 :   state_ = State::kFailed;
     151           0 :   return FAILED;
     152             : }
     153             : 
     154         697 : CompilationJob::Status CompilationJob::AbortOptimization(BailoutReason reason) {
     155             :   DCHECK(info_->IsOptimizing());
     156         697 :   info_->AbortOptimization(reason);
     157         697 :   state_ = State::kFailed;
     158         697 :   return FAILED;
     159             : }
     160             : 
     161     2926261 : void CompilationJob::RecordUnoptimizedCompilationStats() const {
     162             :   int code_size;
     163     2926261 :   if (info()->has_bytecode_array()) {
     164     2077425 :     code_size = info()->bytecode_array()->SizeIncludingMetadata();
     165             :   } else {
     166      848836 :     code_size = info()->code()->SizeIncludingMetadata();
     167             :   }
     168             : 
     169     2926260 :   Counters* counters = isolate()->counters();
     170             :   // TODO(4280): Rename counters from "baseline" to "unoptimized" eventually.
     171     2926260 :   counters->total_baseline_code_size()->Increment(code_size);
     172     2926260 :   counters->total_baseline_compile_count()->Increment(1);
     173             : 
     174             :   // TODO(5203): Add timers for each phase of compilation.
     175     2926262 : }
     176             : 
     177      642433 : void CompilationJob::RecordOptimizedCompilationStats() const {
     178             :   DCHECK(info()->IsOptimizing());
     179             :   Handle<JSFunction> function = info()->closure();
     180      642433 :   if (!function->IsOptimized()) {
     181             :     // Concurrent recompilation and OSR may race.  Increment only once.
     182             :     int opt_count = function->shared()->opt_count();
     183      642255 :     function->shared()->set_opt_count(opt_count + 1);
     184             :   }
     185      642433 :   double ms_creategraph = time_taken_to_prepare_.InMillisecondsF();
     186      642436 :   double ms_optimize = time_taken_to_execute_.InMillisecondsF();
     187      642436 :   double ms_codegen = time_taken_to_finalize_.InMillisecondsF();
     188      642436 :   if (FLAG_trace_opt) {
     189           0 :     PrintF("[optimizing ");
     190           0 :     function->ShortPrint();
     191             :     PrintF(" - took %0.3f, %0.3f, %0.3f ms]\n", ms_creategraph, ms_optimize,
     192           0 :            ms_codegen);
     193             :   }
     194      642436 :   if (FLAG_trace_opt_stats) {
     195             :     static double compilation_time = 0.0;
     196             :     static int compiled_functions = 0;
     197             :     static int code_size = 0;
     198             : 
     199           0 :     compilation_time += (ms_creategraph + ms_optimize + ms_codegen);
     200           0 :     compiled_functions++;
     201           0 :     code_size += function->shared()->SourceSize();
     202             :     PrintF("Compiled: %d functions with %d byte source size in %fms.\n",
     203           0 :            compiled_functions, code_size, compilation_time);
     204             :   }
     205      642436 :   if (FLAG_hydrogen_stats) {
     206             :     isolate()->GetHStatistics()->IncrementSubtotals(time_taken_to_prepare_,
     207             :                                                     time_taken_to_execute_,
     208           0 :                                                     time_taken_to_finalize_);
     209             :   }
     210      642436 : }
     211             : 
     212    13408061 : Isolate* CompilationJob::isolate() const { return info()->isolate(); }
     213             : 
     214             : namespace {
     215             : 
     216     1976332 : void AddWeakObjectToCodeDependency(Isolate* isolate, Handle<HeapObject> object,
     217             :                                    Handle<Code> code) {
     218     1976332 :   Handle<WeakCell> cell = Code::WeakCellFor(code);
     219     1976333 :   Heap* heap = isolate->heap();
     220     1976333 :   if (heap->InNewSpace(*object)) {
     221      926002 :     heap->AddWeakNewSpaceObjectToCodeDependency(object, cell);
     222             :   } else {
     223     1050331 :     Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(object));
     224             :     dep =
     225     1050332 :         DependentCode::InsertWeakCode(dep, DependentCode::kWeakCodeGroup, cell);
     226     1050332 :     heap->AddWeakObjectToCodeDependency(object, dep);
     227             :   }
     228     1976334 : }
     229             : 
     230             : }  // namespace
     231             : 
     232      640383 : void CompilationJob::RegisterWeakObjectsInOptimizedCode(Handle<Code> code) {
     233             :   // TODO(turbofan): Move this to pipeline.cc once Crankshaft dies.
     234             :   Isolate* const isolate = code->GetIsolate();
     235             :   DCHECK(code->is_optimized_code());
     236             :   std::vector<Handle<Map>> maps;
     237             :   std::vector<Handle<HeapObject>> objects;
     238             :   {
     239             :     DisallowHeapAllocation no_gc;
     240             :     int const mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
     241             :                           RelocInfo::ModeMask(RelocInfo::CELL);
     242     6680808 :     for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
     243     6040424 :       RelocInfo::Mode mode = it.rinfo()->rmode();
     244     6040424 :       if (mode == RelocInfo::CELL &&
     245           0 :           code->IsWeakObjectInOptimizedCode(it.rinfo()->target_cell())) {
     246           0 :         objects.push_back(handle(it.rinfo()->target_cell(), isolate));
     247    12080848 :       } else if (mode == RelocInfo::EMBEDDED_OBJECT &&
     248             :                  code->IsWeakObjectInOptimizedCode(
     249    12080848 :                      it.rinfo()->target_object())) {
     250     2180925 :         Handle<HeapObject> object(HeapObject::cast(it.rinfo()->target_object()),
     251             :                                   isolate);
     252     2180926 :         if (object->IsMap()) {
     253      204592 :           maps.push_back(Handle<Map>::cast(object));
     254             :         } else {
     255     1976334 :           objects.push_back(object);
     256             :         }
     257             :       }
     258             :     }
     259             :   }
     260     1485356 :   for (Handle<Map> map : maps) {
     261      204592 :     if (map->dependent_code()->IsEmpty(DependentCode::kWeakCodeGroup)) {
     262       38141 :       isolate->heap()->AddRetainedMap(map);
     263             :     }
     264      204592 :     Map::AddDependentCode(map, DependentCode::kWeakCodeGroup, code);
     265             :   }
     266     3257098 :   for (Handle<HeapObject> object : objects) {
     267     1976333 :     AddWeakObjectToCodeDependency(isolate, object, code);
     268             :   }
     269             :   code->set_can_have_weak_objects(true);
     270      640383 : }
     271             : 
     272             : // ----------------------------------------------------------------------------
     273             : // Local helper methods that make up the compilation pipeline.
     274             : 
     275             : namespace {
     276             : 
     277     4686855 : void RecordFunctionCompilation(CodeEventListener::LogEventsAndTags tag,
     278     4692948 :                                CompilationInfo* info) {
     279             :   // Log the code generation. If source information is available include
     280             :   // script name and line number. Check explicitly whether logging is
     281             :   // enabled as finding the line number is not free.
     282    14060081 :   if (info->isolate()->logger()->is_logging_code_events() ||
     283     4686371 :       info->isolate()->is_profiling()) {
     284        1539 :     Handle<SharedFunctionInfo> shared = info->shared_info();
     285             :     Handle<Script> script = info->parse_info()->script();
     286             :     Handle<AbstractCode> abstract_code =
     287             :         info->has_bytecode_array()
     288             :             ? Handle<AbstractCode>::cast(info->bytecode_array())
     289        1539 :             : Handle<AbstractCode>::cast(info->code());
     290        1539 :     if (abstract_code.is_identical_to(
     291        3078 :             info->isolate()->builtins()->CompileLazy())) {
     292     4686855 :       return;
     293             :     }
     294        1539 :     int line_num = Script::GetLineNumber(script, shared->start_position()) + 1;
     295             :     int column_num =
     296        1539 :         Script::GetColumnNumber(script, shared->start_position()) + 1;
     297             :     String* script_name = script->name()->IsString()
     298             :                               ? String::cast(script->name())
     299        3015 :                               : info->isolate()->heap()->empty_string();
     300             :     CodeEventListener::LogEventsAndTags log_tag =
     301             :         Logger::ToNativeByScript(tag, *script);
     302        1539 :     PROFILE(info->isolate(),
     303             :             CodeCreateEvent(log_tag, *abstract_code, *shared, script_name,
     304             :                             line_num, column_num));
     305             :   }
     306             : }
     307             : 
     308     7119154 : void EnsureFeedbackMetadata(CompilationInfo* info) {
     309             :   DCHECK(info->has_shared_info());
     310             : 
     311             :   // If no type feedback metadata exists, create it. At this point the
     312             :   // AstNumbering pass has already run. Note the snapshot can contain outdated
     313             :   // vectors for a different configuration, hence we also recreate a new vector
     314             :   // when the function is not compiled (i.e. no code was serialized).
     315             : 
     316             :   // TODO(mvstanton): reintroduce is_empty() predicate to feedback_metadata().
     317    12093237 :   if (info->shared_info()->feedback_metadata()->length() == 0 ||
     318     4531529 :       !info->shared_info()->is_compiled()) {
     319             :     Handle<FeedbackMetadata> feedback_metadata = FeedbackMetadata::New(
     320     6676606 :         info->isolate(), info->literal()->feedback_vector_spec());
     321     6676603 :     info->shared_info()->set_feedback_metadata(*feedback_metadata);
     322             :   }
     323             : 
     324             :   // It's very important that recompiles do not alter the structure of the type
     325             :   // feedback vector. Verify that the structure fits the function literal.
     326     7561726 :   CHECK(!info->shared_info()->feedback_metadata()->SpecDiffersFrom(
     327             :       info->literal()->feedback_vector_spec()));
     328     3780862 : }
     329             : 
     330     3743060 : bool UseTurboFan(Handle<SharedFunctionInfo> shared) {
     331             :   bool must_use_ignition_turbo = shared->must_use_ignition_turbo();
     332             : 
     333             :   // Check the enabling conditions for Turbofan.
     334             :   // 1. "use asm" code.
     335     7486121 :   bool is_turbofanable_asm = FLAG_turbo_asm && shared->asm_function();
     336             : 
     337             :   // 2. Fallback for features unsupported by Crankshaft.
     338             :   bool is_unsupported_by_crankshaft_but_turbofanable =
     339     3743060 :       must_use_ignition_turbo && strcmp(FLAG_turbo_filter, "~~") == 0;
     340             : 
     341             :   // 3. Explicitly enabled by the command-line filter.
     342     3743060 :   bool passes_turbo_filter = shared->PassesFilter(FLAG_turbo_filter);
     343             : 
     344     3743061 :   return is_turbofanable_asm || is_unsupported_by_crankshaft_but_turbofanable ||
     345     3743061 :          passes_turbo_filter;
     346             : }
     347             : 
     348     3550504 : bool ShouldUseIgnition(Handle<SharedFunctionInfo> shared,
     349             :                        bool marked_as_debug) {
     350             :   // Code which can't be supported by the old pipeline should use Ignition.
     351     3550504 :   if (shared->must_use_ignition_turbo()) return true;
     352             : 
     353             :   // Resumable functions are not supported by {FullCodeGenerator}, suspended
     354             :   // activations stored as {JSGeneratorObject} on the heap always assume the
     355             :   // underlying code to be based on the bytecode array.
     356             :   DCHECK(!IsResumableFunction(shared->kind()));
     357             : 
     358             :   // Skip Ignition for asm.js functions.
     359     2952785 :   if (shared->asm_function()) return false;
     360             : 
     361             :   // Skip Ignition for asm wasm code.
     362     2945716 :   if (FLAG_validate_asm && shared->HasAsmWasmData()) {
     363             :     return false;
     364             :   }
     365             : 
     366             :   // Code destined for TurboFan should be compiled with Ignition first.
     367     2945705 :   if (UseTurboFan(shared)) return true;
     368             : 
     369             :   // Only use Ignition for any other function if FLAG_ignition is true.
     370     1083393 :   return FLAG_ignition;
     371             : }
     372             : 
     373     3550501 : bool ShouldUseIgnition(CompilationInfo* info) {
     374             :   DCHECK(info->has_shared_info());
     375     3550501 :   return ShouldUseIgnition(info->shared_info(), info->is_debug());
     376             : }
     377             : 
     378             : bool UseAsmWasm(DeclarationScope* scope, Handle<SharedFunctionInfo> shared_info,
     379             :                 bool is_debug) {
     380             :   // Check whether asm.js validation is enabled.
     381     2929887 :   if (!FLAG_validate_asm) return false;
     382             : 
     383             :   // Modules that have validated successfully, but were subsequently broken by
     384             :   // invalid module instantiation attempts are off limit forever.
     385      381675 :   if (shared_info->is_asm_wasm_broken()) return false;
     386             : 
     387             :   // Compiling for debugging is not supported, fall back.
     388      381168 :   if (is_debug) return false;
     389             : 
     390             :   // In stress mode we want to run the validator on everything.
     391      380169 :   if (FLAG_stress_validate_asm) return true;
     392             : 
     393             :   // In general, we respect the "use asm" directive.
     394             :   return scope->asm_module();
     395             : }
     396             : 
     397      702138 : bool UseCompilerDispatcher(Compiler::ConcurrencyMode inner_function_mode,
     398             :                            CompilerDispatcher* dispatcher,
     399             :                            DeclarationScope* scope,
     400             :                            Handle<SharedFunctionInfo> shared_info,
     401             :                            bool is_debug, bool will_serialize) {
     402           0 :   return inner_function_mode == Compiler::CONCURRENT &&
     403      702138 :          dispatcher->IsEnabled() && !is_debug && !will_serialize &&
     404      702138 :          !UseAsmWasm(scope, shared_info, is_debug);
     405             : }
     406             : 
     407     2926291 : CompilationJob* GetUnoptimizedCompilationJob(CompilationInfo* info) {
     408             :   // Function should have been parsed and analyzed before creating a compilation
     409             :   // job.
     410             :   DCHECK_NOT_NULL(info->literal());
     411             :   DCHECK_NOT_NULL(info->scope());
     412             : 
     413     2926291 :   if (ShouldUseIgnition(info)) {
     414     2077460 :     return interpreter::Interpreter::NewCompilationJob(info);
     415             :   } else {
     416      848839 :     return FullCodeGenerator::NewCompilationJob(info);
     417             :   }
     418             : }
     419             : 
     420     2932913 : void InstallSharedScopeInfo(CompilationInfo* info,
     421             :                             Handle<SharedFunctionInfo> shared) {
     422     2932913 :   Handle<ScopeInfo> scope_info = info->scope()->scope_info();
     423     2932922 :   shared->set_scope_info(*scope_info);
     424     2932924 :   Scope* outer_scope = info->scope()->GetOuterScopeWithContext();
     425     2932925 :   if (outer_scope) {
     426     2647981 :     shared->set_outer_scope_info(*outer_scope->scope_info());
     427             :   }
     428     2932925 : }
     429             : 
     430     2929875 : void InstallSharedCompilationResult(CompilationInfo* info,
     431             :                                     Handle<SharedFunctionInfo> shared) {
     432             :   // TODO(mstarzinger): Compiling for debug code might be used to reveal inner
     433             :   // functions via {FindSharedFunctionInfoInScript}, in which case we end up
     434             :   // regenerating existing bytecode. Fix this!
     435     2940046 :   if (info->is_debug() && info->has_bytecode_array()) {
     436             :     shared->ClearBytecodeArray();
     437             :   }
     438             :   DCHECK(!info->code().is_null());
     439     2929874 :   shared->ReplaceCode(*info->code());
     440     2929880 :   if (info->has_bytecode_array()) {
     441             :     DCHECK(!shared->HasBytecodeArray());  // Only compiled once.
     442             :     shared->set_bytecode_array(*info->bytecode_array());
     443             :   }
     444     2929879 : }
     445             : 
     446     2929868 : void InstallUnoptimizedCode(CompilationInfo* info) {
     447     2929868 :   Handle<SharedFunctionInfo> shared = info->shared_info();
     448             : 
     449             :   // Update the shared function info with the scope info.
     450     2929878 :   InstallSharedScopeInfo(info, shared);
     451             : 
     452             :   // Install compilation result on the shared function info
     453     2929874 :   InstallSharedCompilationResult(info, shared);
     454     2929879 : }
     455             : 
     456     5852513 : CompilationJob::Status FinalizeUnoptimizedCompilationJob(CompilationJob* job) {
     457     2926248 :   CompilationJob::Status status = job->FinalizeJob();
     458     2926265 :   if (status == CompilationJob::SUCCEEDED) {
     459     2926310 :     CompilationInfo* info = job->info();
     460     2926265 :     EnsureFeedbackMetadata(info);
     461             :     DCHECK(!info->code().is_null());
     462     5852524 :     if (info->parse_info()->literal()->should_be_used_once_hint()) {
     463          48 :       info->code()->MarkToBeExecutedOnce(info->isolate());
     464             :     }
     465     2926262 :     InstallUnoptimizedCode(info);
     466     2926263 :     RecordFunctionCompilation(CodeEventListener::FUNCTION_TAG, info);
     467     2926263 :     job->RecordUnoptimizedCompilationStats();
     468             :   }
     469     2926263 :   return status;
     470             : }
     471             : 
     472    10308030 : void SetSharedFunctionFlagsFromLiteral(FunctionLiteral* literal,
     473             :                                        Handle<SharedFunctionInfo> shared_info) {
     474             :   // Don't overwrite values set by the bootstrapper.
     475     3341373 :   if (!shared_info->HasLength()) {
     476             :     shared_info->set_length(literal->function_length());
     477             :   }
     478             :   shared_info->set_ast_node_count(literal->ast_node_count());
     479             :   shared_info->set_has_duplicate_parameters(
     480             :       literal->has_duplicate_parameters());
     481     3341373 :   shared_info->SetExpectedNofPropertiesFromEstimate(literal);
     482     3341377 :   if (literal->dont_optimize_reason() != kNoReason) {
     483        2674 :     shared_info->DisableOptimization(literal->dont_optimize_reason());
     484             :   }
     485     3341378 :   if (literal->flags() & AstProperties::kMustUseIgnitionTurbo) {
     486             :     shared_info->set_must_use_ignition_turbo(true);
     487             :   }
     488     3341378 : }
     489             : 
     490    10680558 : bool Renumber(ParseInfo* parse_info,
     491             :               Compiler::EagerInnerFunctionLiterals* eager_literals) {
     492             :   RuntimeCallTimerScope runtimeTimer(parse_info->runtime_call_stats(),
     493     2680438 :                                      &RuntimeCallStats::CompileRenumber);
     494             : 
     495             :   // CollectTypeProfile uses its own feedback slots. If we have existing
     496             :   // FeedbackMetadata, we can only collect type profile, if the feedback vector
     497             :   // has the appropriate slots.
     498             :   bool collect_type_profile;
     499     5319721 :   if (parse_info->shared_info().is_null() ||
     500             :       parse_info->shared_info()->feedback_metadata()->length() == 0) {
     501             :     collect_type_profile =
     502     2292492 :         FLAG_type_profile && parse_info->script()->IsUserJavaScript();
     503             :   } else {
     504             :     collect_type_profile =
     505      388049 :         parse_info->shared_info()->feedback_metadata()->HasTypeProfileSlot();
     506             :   }
     507             : 
     508     2680444 :   if (!AstNumbering::Renumber(parse_info->stack_limit(), parse_info->zone(),
     509             :                               parse_info->literal(), eager_literals,
     510     5360882 :                               collect_type_profile)) {
     511             :     return false;
     512             :   }
     513     2680398 :   if (!parse_info->shared_info().is_null()) {
     514             :     SetSharedFunctionFlagsFromLiteral(parse_info->literal(),
     515     2639238 :                                       parse_info->shared_info());
     516             :   }
     517             :   return true;
     518             : }
     519             : 
     520     2933500 : bool GenerateUnoptimizedCode(CompilationInfo* info) {
     521     5859771 :   if (UseAsmWasm(info->scope(), info->shared_info(), info->is_debug())) {
     522      354696 :     EnsureFeedbackMetadata(info);
     523             :     MaybeHandle<FixedArray> wasm_data;
     524      354696 :     wasm_data = AsmJs::CompileAsmViaWasm(info);
     525      354696 :     if (!wasm_data.is_null()) {
     526        7232 :       info->shared_info()->set_asm_wasm_data(*wasm_data.ToHandleChecked());
     527        3616 :       info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
     528        3616 :       InstallUnoptimizedCode(info);
     529             :       return true;
     530             :     }
     531             :   }
     532             : 
     533     2926271 :   std::unique_ptr<CompilationJob> job(GetUnoptimizedCompilationJob(info));
     534     2926267 :   if (job->PrepareJob() != CompilationJob::SUCCEEDED) return false;
     535     2926275 :   if (job->ExecuteJob() != CompilationJob::SUCCEEDED) return false;
     536     2926233 :   if (FinalizeUnoptimizedCompilationJob(job.get()) !=
     537             :       CompilationJob::SUCCEEDED) {
     538             :     return false;
     539             :   }
     540     2926241 :   return true;
     541             : }
     542             : 
     543     2227739 : bool CompileUnoptimizedInnerFunctions(
     544             :     Compiler::EagerInnerFunctionLiterals* literals,
     545             :     Compiler::ConcurrencyMode inner_function_mode,
     546     2929880 :     std::shared_ptr<Zone> parse_zone, CompilationInfo* outer_info) {
     547     4455478 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
     548             :                "V8.CompileUnoptimizedInnerFunctions");
     549      702141 :   Isolate* isolate = outer_info->isolate();
     550     2227739 :   Handle<Script> script = outer_info->script();
     551     2227736 :   bool is_debug = outer_info->is_debug();
     552             :   bool will_serialize = outer_info->will_serialize();
     553             :   RuntimeCallTimerScope runtimeTimer(isolate,
     554     2227749 :                                      &RuntimeCallStats::CompileInnerFunction);
     555             : 
     556     5861701 :   for (auto it : *literals) {
     557     1404282 :     FunctionLiteral* literal = it->value();
     558             :     Handle<SharedFunctionInfo> shared =
     559      703093 :         Compiler::GetSharedFunctionInfo(literal, script, outer_info);
     560      703108 :     if (shared->is_compiled()) continue;
     561             : 
     562             :     // The {literal} has already been numbered because AstNumbering decends into
     563             :     // eagerly compiled function literals.
     564      702141 :     SetSharedFunctionFlagsFromLiteral(literal, shared);
     565             : 
     566             :     // Try to enqueue the eager function on the compiler dispatcher.
     567             :     CompilerDispatcher* dispatcher = isolate->compiler_dispatcher();
     568     1404274 :     if (UseCompilerDispatcher(inner_function_mode, dispatcher, literal->scope(),
     569     1404282 :                               shared, is_debug, will_serialize) &&
     570             :         dispatcher->EnqueueAndStep(outer_info->script(), shared, literal,
     571             :                                    parse_zone,
     572             :                                    outer_info->parse_info()->deferred_handles(),
     573      702137 :                                    outer_info->deferred_handles())) {
     574             :       // If we have successfully queued up the function for compilation on the
     575             :       // compiler dispatcher then we are done.
     576             :       continue;
     577             :     } else {
     578             :       // Otherwise generate unoptimized code now.
     579      702138 :       ParseInfo parse_info(script);
     580             :       CompilationInfo info(parse_info.zone(), &parse_info, isolate,
     581     1404279 :                            Handle<JSFunction>::null());
     582             : 
     583             :       parse_info.set_literal(literal);
     584             :       parse_info.set_shared_info(shared);
     585             :       parse_info.set_function_literal_id(shared->function_literal_id());
     586             :       parse_info.set_language_mode(literal->scope()->language_mode());
     587             :       parse_info.set_ast_value_factory(
     588      702141 :           outer_info->parse_info()->ast_value_factory());
     589             :       parse_info.set_ast_value_factory_owned(false);
     590             : 
     591      702141 :       if (will_serialize) info.PrepareForSerializing();
     592      702142 :       if (is_debug) info.MarkAsDebug();
     593             : 
     594      702142 :       if (!GenerateUnoptimizedCode(&info)) {
     595           0 :         if (!isolate->has_pending_exception()) isolate->StackOverflow();
     596           0 :         return false;
     597      702134 :       }
     598             :     }
     599             :   }
     600     2227764 :   return true;
     601             : }
     602             : 
     603     2224738 : bool InnerFunctionIsAsmModule(
     604             :     ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>* literals) {
     605     5852146 :   for (auto it : *literals) {
     606      702980 :     FunctionLiteral* literal = it->value();
     607      702980 :     if (literal->scope()->IsAsmModule()) return true;
     608             :   }
     609             :   return false;
     610             : }
     611             : 
     612     2227788 : bool CompileUnoptimizedCode(CompilationInfo* info,
     613             :                             Compiler::ConcurrencyMode inner_function_mode) {
     614             :   Isolate* isolate = info->isolate();
     615             :   DCHECK(AllowCompilation::IsAllowed(isolate));
     616             : 
     617             :   Compiler::EagerInnerFunctionLiterals inner_literals;
     618             :   {
     619             :     std::unique_ptr<CompilationHandleScope> compilation_handle_scope;
     620     2227788 :     if (inner_function_mode == Compiler::CONCURRENT) {
     621           0 :       compilation_handle_scope.reset(new CompilationHandleScope(info));
     622             :     }
     623     2227797 :     if (!Compiler::Analyze(info, &inner_literals)) {
     624          45 :       if (!isolate->has_pending_exception()) isolate->StackOverflow();
     625             :       return false;
     626             :     }
     627             :   }
     628             : 
     629             :   // Disable concurrent inner compilation for asm-wasm code.
     630             :   // TODO(rmcilroy,bradnelson): Remove this AsmWasm check once the asm-wasm
     631             :   // builder doesn't do parsing when visiting function declarations.
     632     4452489 :   if (info->scope()->IsAsmModule() ||
     633     2224736 :       InnerFunctionIsAsmModule(&inner_literals)) {
     634             :     inner_function_mode = Compiler::NOT_CONCURRENT;
     635             :   }
     636             : 
     637             :   std::shared_ptr<Zone> parse_zone;
     638     2227750 :   if (inner_function_mode == Compiler::CONCURRENT) {
     639             :     // Seal the parse zone so that it can be shared by parallel inner function
     640             :     // compilation jobs.
     641             :     DCHECK_NE(info->parse_info()->zone(), info->zone());
     642             :     parse_zone = info->parse_info()->zone_shared();
     643             :     parse_zone->Seal();
     644             :   }
     645             : 
     646     2227740 :   if (!CompileUnoptimizedInnerFunctions(&inner_literals, inner_function_mode,
     647     6683237 :                                         parse_zone, info) ||
     648     2227747 :       !GenerateUnoptimizedCode(info)) {
     649          36 :     if (!isolate->has_pending_exception()) isolate->StackOverflow();
     650             :     return false;
     651             :   }
     652             : 
     653             :   return true;
     654             : }
     655             : 
     656     2813091 : void EnsureSharedFunctionInfosArrayOnScript(ParseInfo* info, Isolate* isolate) {
     657             :   DCHECK(info->is_toplevel());
     658             :   DCHECK(!info->script().is_null());
     659     1467534 :   if (info->script()->shared_function_infos()->length() > 0) {
     660             :     DCHECK_EQ(info->script()->shared_function_infos()->length(),
     661             :               info->max_function_literal_id() + 1);
     662      121977 :     return;
     663             :   }
     664             :   Handle<FixedArray> infos(
     665     1345557 :       isolate->factory()->NewFixedArray(info->max_function_literal_id() + 1));
     666     1345552 :   info->script()->set_shared_function_infos(*infos);
     667             : }
     668             : 
     669     1341980 : void EnsureSharedFunctionInfosArrayOnScript(CompilationInfo* info) {
     670             :   return EnsureSharedFunctionInfosArrayOnScript(info->parse_info(),
     671     1341980 :                                                 info->isolate());
     672             : }
     673             : 
     674      889274 : MUST_USE_RESULT MaybeHandle<Code> GetUnoptimizedCode(
     675     3554280 :     CompilationInfo* info, Compiler::ConcurrencyMode inner_function_mode) {
     676             :   RuntimeCallTimerScope runtimeTimer(
     677      889274 :       info->isolate(), &RuntimeCallStats::CompileGetUnoptimizedCode);
     678             :   VMState<COMPILER> state(info->isolate());
     679             :   PostponeInterruptsScope postpone(info->isolate());
     680             : 
     681             :   // Parse and update ParseInfo with the results.
     682             :   {
     683      889274 :     if (!parsing::ParseAny(info->parse_info(), info->isolate(),
     684     1778548 :                            inner_function_mode != Compiler::CONCURRENT)) {
     685             :       return MaybeHandle<Code>();
     686             :     }
     687             : 
     688      886458 :     if (inner_function_mode == Compiler::CONCURRENT) {
     689             :       ParseHandleScope parse_handles(info->parse_info(), info->isolate());
     690           0 :       info->parse_info()->ReopenHandlesInNewHandleScope();
     691           0 :       info->parse_info()->ast_value_factory()->Internalize(info->isolate());
     692             :     }
     693             :   }
     694             : 
     695      886458 :   if (info->parse_info()->is_toplevel()) {
     696             :     EnsureSharedFunctionInfosArrayOnScript(info);
     697             :   }
     698             :   DCHECK_EQ(info->shared_info()->language_mode(),
     699             :             info->literal()->language_mode());
     700             : 
     701             :   // Compile either unoptimized code or bytecode for the interpreter.
     702      886458 :   if (!CompileUnoptimizedCode(info, inner_function_mode)) {
     703             :     return MaybeHandle<Code>();
     704             :   }
     705             : 
     706             :   // Record the function compilation event.
     707      886391 :   RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);
     708             : 
     709             :   return info->code();
     710             : }
     711             : 
     712     1957921 : MUST_USE_RESULT MaybeHandle<Code> GetCodeFromOptimizedCodeMap(
     713             :     Handle<JSFunction> function, BailoutId osr_ast_id) {
     714             :   RuntimeCallTimerScope runtimeTimer(
     715             :       function->GetIsolate(),
     716     1957921 :       &RuntimeCallStats::CompileGetFromOptimizedCodeMap);
     717             :   Handle<SharedFunctionInfo> shared(function->shared());
     718             :   DisallowHeapAllocation no_gc;
     719             :   Code* code = shared->SearchOptimizedCodeMap(
     720     1957923 :       function->context()->native_context(), osr_ast_id);
     721     1957923 :   if (code != nullptr) {
     722             :     // Caching of optimized code enabled and optimized code found.
     723             :     DCHECK(!code->marked_for_deoptimization());
     724             :     DCHECK(function->shared()->is_compiled());
     725             :     return Handle<Code>(code);
     726             :   }
     727             :   return MaybeHandle<Code>();
     728             : }
     729             : 
     730      642413 : void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
     731             :   Handle<Code> code = info->code();
     732     1006615 :   if (code->kind() != Code::OPTIMIZED_FUNCTION) return;  // Nothing to do.
     733             : 
     734             :   // Function context specialization folds-in the function context,
     735             :   // so no sharing can occur.
     736      642413 :   if (info->is_function_context_specializing()) return;
     737             :   // Frame specialization implies function context specialization.
     738             :   DCHECK(!info->is_frame_specializing());
     739             : 
     740             :   // Cache optimized context-specific code.
     741             :   Handle<JSFunction> function = info->closure();
     742             :   Handle<SharedFunctionInfo> shared(function->shared());
     743             :   Handle<Context> native_context(function->context()->native_context());
     744             :   SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
     745      278211 :                                             info->osr_ast_id());
     746             : }
     747             : 
     748      604781 : bool GetOptimizedCodeNow(CompilationJob* job) {
     749      604781 :   CompilationInfo* info = job->info();
     750             :   Isolate* isolate = info->isolate();
     751             : 
     752             :   // Parsing is not required when optimizing from existing bytecode.
     753      604781 :   if (!info->is_optimizing_from_bytecode()) {
     754      231950 :     if (!Compiler::ParseAndAnalyze(info)) return false;
     755      231904 :     EnsureFeedbackMetadata(info);
     756             :   }
     757             : 
     758      604735 :   JSFunction::EnsureLiterals(info->closure());
     759             : 
     760             :   TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
     761             :   RuntimeCallTimerScope runtimeTimer(isolate,
     762      604736 :                                      &RuntimeCallStats::RecompileSynchronous);
     763     1814207 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
     764             :                "V8.RecompileSynchronous");
     765             : 
     766     1808534 :   if (job->PrepareJob() != CompilationJob::SUCCEEDED ||
     767     1203749 :       job->ExecuteJob() != CompilationJob::SUCCEEDED ||
     768      599017 :       job->FinalizeJob() != CompilationJob::SUCCEEDED) {
     769        5723 :     if (FLAG_trace_opt) {
     770           0 :       PrintF("[aborted optimizing ");
     771           0 :       info->closure()->ShortPrint();
     772           0 :       PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
     773             :     }
     774             :     return false;
     775             :   }
     776             : 
     777             :   // Success!
     778      599010 :   job->RecordOptimizedCompilationStats();
     779             :   DCHECK(!isolate->has_pending_exception());
     780      599012 :   InsertCodeIntoOptimizedCodeMap(info);
     781      599012 :   RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);
     782      599012 :   return true;
     783             : }
     784             : 
     785      148169 : bool GetOptimizedCodeLater(CompilationJob* job) {
     786      251725 :   CompilationInfo* info = job->info();
     787      103479 :   Isolate* isolate = info->isolate();
     788             : 
     789      296338 :   if (FLAG_mark_optimizing_shared_functions &&
     790             :       info->closure()->shared()->has_concurrent_optimization_job()) {
     791       96342 :     if (FLAG_trace_concurrent_recompilation) {
     792           0 :       PrintF("  ** Compilation job already running for ");
     793           0 :       info->shared_info()->ShortPrint();
     794           0 :       PrintF(".\n");
     795             :     }
     796             :     return false;
     797             :   }
     798             : 
     799       51827 :   if (!isolate->optimizing_compile_dispatcher()->IsQueueAvailable()) {
     800           0 :     if (FLAG_trace_concurrent_recompilation) {
     801           0 :       PrintF("  ** Compilation queue full, will retry optimizing ");
     802           0 :       info->closure()->ShortPrint();
     803           0 :       PrintF(" later.\n");
     804             :     }
     805             :     return false;
     806             :   }
     807             : 
     808       51827 :   if (isolate->heap()->HighMemoryPressure()) {
     809           0 :     if (FLAG_trace_concurrent_recompilation) {
     810           0 :       PrintF("  ** High memory pressure, will retry optimizing ");
     811           0 :       info->closure()->ShortPrint();
     812           0 :       PrintF(" later.\n");
     813             :     }
     814             :     return false;
     815             :   }
     816             : 
     817             :   // Parsing is not required when optimizing from existing bytecode.
     818       51827 :   if (!info->is_optimizing_from_bytecode()) {
     819       36275 :     if (!Compiler::ParseAndAnalyze(info)) return false;
     820       36226 :     EnsureFeedbackMetadata(info);
     821             :   }
     822             : 
     823       51778 :   JSFunction::EnsureLiterals(info->closure());
     824             : 
     825             :   TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
     826             :   RuntimeCallTimerScope runtimeTimer(info->isolate(),
     827       51778 :                                      &RuntimeCallStats::RecompileSynchronous);
     828      155334 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
     829             :                "V8.RecompileSynchronous");
     830             : 
     831       51778 :   if (job->PrepareJob() != CompilationJob::SUCCEEDED) return false;
     832       51652 :   isolate->optimizing_compile_dispatcher()->QueueForOptimization(job);
     833             :   info->closure()->shared()->set_has_concurrent_optimization_job(true);
     834             : 
     835       51652 :   if (FLAG_trace_concurrent_recompilation) {
     836           0 :     PrintF("  ** Queued ");
     837           0 :     info->closure()->ShortPrint();
     838           0 :     PrintF(" for concurrent optimization.\n");
     839             :   }
     840             :   return true;
     841             : }
     842             : 
     843      800219 : MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
     844             :                                    Compiler::ConcurrencyMode mode,
     845             :                                    BailoutId osr_ast_id = BailoutId::None(),
     846             :                                    JavaScriptFrame* osr_frame = nullptr) {
     847             :   Isolate* isolate = function->GetIsolate();
     848             :   Handle<SharedFunctionInfo> shared(function->shared(), isolate);
     849             : 
     850      808697 :   bool ignition_osr = osr_frame && osr_frame->is_interpreted();
     851             :   DCHECK_IMPLIES(ignition_osr, !osr_ast_id.IsNone());
     852             :   DCHECK_IMPLIES(ignition_osr, FLAG_ignition_osr);
     853             : 
     854             :   Handle<Code> cached_code;
     855      800218 :   if (GetCodeFromOptimizedCodeMap(function, osr_ast_id)
     856     1600438 :           .ToHandle(&cached_code)) {
     857        2860 :     if (FLAG_trace_opt) {
     858           0 :       PrintF("[found optimized code for ");
     859           0 :       function->ShortPrint();
     860           0 :       if (!osr_ast_id.IsNone()) {
     861           0 :         PrintF(" at OSR AST id %d", osr_ast_id.ToInt());
     862             :       }
     863           0 :       PrintF("]\n");
     864             :     }
     865             :     return cached_code;
     866             :   }
     867             : 
     868             :   // Reset profiler ticks, function is no longer considered hot.
     869             :   DCHECK(shared->is_compiled());
     870      797358 :   if (shared->HasBaselineCode()) {
     871             :     shared->code()->set_profiler_ticks(0);
     872      416539 :   } else if (shared->HasBytecodeArray()) {
     873             :     shared->set_profiler_ticks(0);
     874             :   }
     875             : 
     876             :   VMState<COMPILER> state(isolate);
     877             :   DCHECK(!isolate->has_pending_exception());
     878             :   PostponeInterruptsScope postpone(isolate);
     879      797360 :   bool use_turbofan = UseTurboFan(shared) || ignition_osr;
     880             :   bool has_script = shared->script()->IsScript();
     881             :   // BUG(5946): This DCHECK is necessary to make certain that we won't tolerate
     882             :   // the lack of a script without bytecode.
     883             :   DCHECK_IMPLIES(!has_script, ShouldUseIgnition(shared, false));
     884             :   std::unique_ptr<CompilationJob> job(
     885      418336 :       use_turbofan ? compiler::Pipeline::NewCompilationJob(function, has_script)
     886     1215696 :                    : new HCompilationJob(function));
     887     1189381 :   CompilationInfo* info = job->info();
     888             :   ParseInfo* parse_info = info->parse_info();
     889             : 
     890             :   info->SetOptimizingForOsr(osr_ast_id, osr_frame);
     891             : 
     892             :   // Do not use Crankshaft/TurboFan if we need to be able to set break points.
     893     1594718 :   if (info->shared_info()->HasDebugInfo()) {
     894             :     info->AbortOptimization(kFunctionBeingDebugged);
     895             :     return MaybeHandle<Code>();
     896             :   }
     897             : 
     898             :   // Do not use Crankshaft/TurboFan when %NeverOptimizeFunction was applied.
     899      840733 :   if (shared->optimization_disabled() &&
     900             :       shared->disable_optimization_reason() == kOptimizationDisabledForTest) {
     901             :     info->AbortOptimization(kOptimizationDisabledForTest);
     902             :     return MaybeHandle<Code>();
     903             :   }
     904             : 
     905             :   // Limit the number of times we try to optimize functions.
     906             :   const int kMaxDeoptCount =
     907      796412 :       FLAG_deopt_every_n_times == 0 ? FLAG_max_deopt_count : 1000;
     908     1592824 :   if (info->shared_info()->deopt_count() > kMaxDeoptCount) {
     909             :     info->AbortOptimization(kDeoptimizedTooManyTimes);
     910             :     return MaybeHandle<Code>();
     911             :   }
     912             : 
     913             :   TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
     914      752950 :   RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::OptimizeCode);
     915     2258847 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.OptimizeCode");
     916             : 
     917             :   // TurboFan can optimize directly from existing bytecode.
     918      752949 :   if (use_turbofan && ShouldUseIgnition(info)) {
     919             :     DCHECK(shared->HasBytecodeArray());
     920             :     info->MarkAsOptimizeFromBytecode();
     921             :   }
     922             : 
     923             :   // Verify that OSR compilations are delegated to the correct graph builder.
     924             :   // Depending on the underlying frame the semantics of the {BailoutId} differ
     925             :   // and the various graph builders hard-code a certain semantic:
     926             :   //  - Interpreter : The BailoutId represents a bytecode offset.
     927             :   //  - FullCodegen : The BailoutId represents the id of an AST node.
     928             :   DCHECK_IMPLIES(info->is_osr() && ignition_osr,
     929             :                  info->is_optimizing_from_bytecode());
     930             :   DCHECK_IMPLIES(info->is_osr() && !ignition_osr,
     931             :                  !info->is_optimizing_from_bytecode());
     932             : 
     933             :   // In case of concurrent recompilation, all handles below this point will be
     934             :   // allocated in a deferred handle scope that is detached and handed off to
     935             :   // the background thread when we return.
     936             :   std::unique_ptr<CompilationHandleScope> compilation;
     937      752950 :   if (mode == Compiler::CONCURRENT) {
     938      148169 :     compilation.reset(new CompilationHandleScope(info));
     939             :   }
     940             : 
     941             :   // In case of TurboFan, all handles below will be canonicalized.
     942             :   std::unique_ptr<CanonicalHandleScope> canonical;
     943     1144971 :   if (use_turbofan) canonical.reset(new CanonicalHandleScope(info->isolate()));
     944             : 
     945             :   // Reopen handles in the new CompilationHandleScope.
     946      752950 :   info->ReopenHandlesInNewHandleScope();
     947      752951 :   parse_info->ReopenHandlesInNewHandleScope();
     948             : 
     949      752951 :   if (mode == Compiler::CONCURRENT) {
     950      148169 :     if (GetOptimizedCodeLater(job.get())) {
     951             :       job.release();  // The background recompile job owns this now.
     952       51652 :       return isolate->builtins()->InOptimizationQueue();
     953             :     }
     954             :   } else {
     955      604782 :     if (GetOptimizedCodeNow(job.get())) return info->code();
     956             :   }
     957             : 
     958      102289 :   if (isolate->has_pending_exception()) isolate->clear_pending_exception();
     959             :   return MaybeHandle<Code>();
     960             : }
     961             : 
     962       23670 : MaybeHandle<Code> GetOptimizedCodeMaybeLater(Handle<JSFunction> function) {
     963       23670 :   Isolate* isolate = function->GetIsolate();
     964             :   return GetOptimizedCode(function, isolate->concurrent_recompilation_enabled()
     965             :                                         ? Compiler::CONCURRENT
     966       23670 :                                         : Compiler::NOT_CONCURRENT);
     967             : }
     968             : 
     969       87090 : CompilationJob::Status FinalizeOptimizedCompilationJob(CompilationJob* job) {
     970       43545 :   CompilationInfo* info = job->info();
     971             :   Isolate* isolate = info->isolate();
     972             : 
     973             :   TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
     974             :   RuntimeCallTimerScope runtimeTimer(isolate,
     975       43545 :                                      &RuntimeCallStats::RecompileSynchronous);
     976      130635 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
     977             :                "V8.RecompileSynchronous");
     978             : 
     979       43545 :   Handle<SharedFunctionInfo> shared = info->shared_info();
     980             : 
     981             :   // Reset profiler ticks, function is no longer considered hot.
     982       43545 :   if (shared->HasBaselineCode()) {
     983             :     shared->code()->set_profiler_ticks(0);
     984       12082 :   } else if (shared->HasBytecodeArray()) {
     985             :     shared->set_profiler_ticks(0);
     986             :   }
     987             : 
     988             :   shared->set_has_concurrent_optimization_job(false);
     989             : 
     990             :   // Shared function no longer needs to be tiered up.
     991             :   shared->set_marked_for_tier_up(false);
     992             : 
     993             :   DCHECK(!shared->HasDebugInfo());
     994             : 
     995             :   // 1) Optimization on the concurrent thread may have failed.
     996             :   // 2) The function may have already been optimized by OSR.  Simply continue.
     997             :   //    Except when OSR already disabled optimization for some reason.
     998             :   // 3) The code may have already been invalidated due to dependency change.
     999             :   // 4) Code generation may have failed.
    1000       43545 :   if (job->state() == CompilationJob::State::kReadyToFinalize) {
    1001       43545 :     if (shared->optimization_disabled()) {
    1002             :       job->RetryOptimization(kOptimizationDisabled);
    1003       43545 :     } else if (info->dependencies()->HasAborted()) {
    1004             :       job->RetryOptimization(kBailedOutDueToDependencyChange);
    1005       43455 :     } else if (job->FinalizeJob() == CompilationJob::SUCCEEDED) {
    1006       43423 :       job->RecordOptimizedCompilationStats();
    1007       43423 :       RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);
    1008       43423 :       if (shared->SearchOptimizedCodeMap(info->context()->native_context(),
    1009       86846 :                                          info->osr_ast_id()) == nullptr) {
    1010       43402 :         InsertCodeIntoOptimizedCodeMap(info);
    1011             :       }
    1012       43423 :       if (FLAG_trace_opt) {
    1013           0 :         PrintF("[completed optimizing ");
    1014           0 :         info->closure()->ShortPrint();
    1015           0 :         PrintF("]\n");
    1016             :       }
    1017       43423 :       info->closure()->ReplaceCode(*info->code());
    1018       43423 :       return CompilationJob::SUCCEEDED;
    1019             :     }
    1020             :   }
    1021             : 
    1022             :   DCHECK(job->state() == CompilationJob::State::kFailed);
    1023         122 :   if (FLAG_trace_opt) {
    1024           0 :     PrintF("[aborted optimizing ");
    1025           0 :     info->closure()->ShortPrint();
    1026           0 :     PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
    1027             :   }
    1028         122 :   info->closure()->ReplaceCode(shared->code());
    1029         122 :   return CompilationJob::FAILED;
    1030             : }
    1031             : 
    1032     1157703 : MaybeHandle<Code> GetLazyCode(Handle<JSFunction> function) {
    1033     2041187 :   Isolate* isolate = function->GetIsolate();
    1034             :   DCHECK(!isolate->has_pending_exception());
    1035             :   DCHECK(!function->is_compiled());
    1036             :   TimerEventScope<TimerEventCompileCode> compile_timer(isolate);
    1037             :   RuntimeCallTimerScope runtimeTimer(isolate,
    1038     1157703 :                                      &RuntimeCallStats::CompileFunction);
    1039     3473109 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileCode");
    1040     2315406 :   AggregatedHistogramTimerScope timer(isolate->counters()->compile_lazy());
    1041             : 
    1042             :   Handle<Code> cached_code;
    1043     1157703 :   if (GetCodeFromOptimizedCodeMap(function, BailoutId::None())
    1044     2315406 :           .ToHandle(&cached_code)) {
    1045           5 :     if (FLAG_trace_opt) {
    1046           0 :       PrintF("[found optimized code for ");
    1047           0 :       function->ShortPrint();
    1048           0 :       PrintF(" during unoptimized compile]\n");
    1049             :     }
    1050             :     DCHECK(function->shared()->is_compiled());
    1051             :     return cached_code;
    1052             :   }
    1053             : 
    1054     1431912 :   if (function->shared()->is_compiled() &&
    1055             :       function->shared()->marked_for_tier_up()) {
    1056             :     DCHECK(FLAG_mark_shared_functions_for_tier_up);
    1057             : 
    1058             :     function->shared()->set_marked_for_tier_up(false);
    1059             : 
    1060       23670 :     if (FLAG_trace_opt) {
    1061           0 :       PrintF("[optimizing method ");
    1062           0 :       function->ShortPrint();
    1063           0 :       PrintF(" eagerly (shared function marked for tier up)]\n");
    1064             :     }
    1065             : 
    1066             :     Handle<Code> code;
    1067       47340 :     if (GetOptimizedCodeMaybeLater(function).ToHandle(&code)) {
    1068             :       return code;
    1069             :     }
    1070             :   }
    1071             : 
    1072     1141975 :   if (function->shared()->is_compiled()) {
    1073             :     return Handle<Code>(function->shared()->code());
    1074             :   }
    1075             : 
    1076      883484 :   if (function->shared()->HasBytecodeArray()) {
    1077           0 :     Handle<Code> entry = isolate->builtins()->InterpreterEntryTrampoline();
    1078           0 :     function->shared()->ReplaceCode(*entry);
    1079             :     return entry;
    1080             :   }
    1081             : 
    1082     1766968 :   ParseInfo parse_info(handle(function->shared()));
    1083     1766967 :   Zone compile_zone(isolate->allocator(), ZONE_NAME);
    1084     1766967 :   CompilationInfo info(&compile_zone, &parse_info, isolate, function);
    1085      883484 :   if (FLAG_experimental_preparser_scope_analysis) {
    1086             :     Handle<SharedFunctionInfo> shared(function->shared());
    1087             :     Handle<Script> script(Script::cast(function->shared()->script()));
    1088          42 :     if (script->HasPreparsedScopeData()) {
    1089             :       parse_info.preparsed_scope_data()->Deserialize(
    1090          42 :           script->preparsed_scope_data());
    1091             :     }
    1092             :   }
    1093             :   Compiler::ConcurrencyMode inner_function_mode =
    1094             :       FLAG_compiler_dispatcher_eager_inner ? Compiler::CONCURRENT
    1095      883484 :                                            : Compiler::NOT_CONCURRENT;
    1096             :   Handle<Code> result;
    1097     1766967 :   ASSIGN_RETURN_ON_EXCEPTION(
    1098             :       isolate, result, GetUnoptimizedCode(&info, inner_function_mode), Code);
    1099             : 
    1100      977045 :   if (FLAG_always_opt && !info.shared_info()->HasAsmWasmData()) {
    1101             :     Handle<Code> opt_code;
    1102       96378 :     if (GetOptimizedCode(function, Compiler::NOT_CONCURRENT)
    1103      192757 :             .ToHandle(&opt_code)) {
    1104             :       result = opt_code;
    1105             :     }
    1106             :   }
    1107             : 
    1108             :   return result;
    1109             : }
    1110             : 
    1111             : 
    1112     5852183 : Handle<SharedFunctionInfo> CompileToplevel(CompilationInfo* info) {
    1113             :   Isolate* isolate = info->isolate();
    1114             :   TimerEventScope<TimerEventCompileCode> timer(isolate);
    1115     4510844 :   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileCode");
    1116             :   PostponeInterruptsScope postpone(isolate);
    1117             :   DCHECK(!isolate->native_context().is_null());
    1118     2844956 :   ParseInfo* parse_info = info->parse_info();
    1119             :   Compiler::ConcurrencyMode inner_function_mode =
    1120             :       FLAG_compiler_dispatcher_eager_inner ? Compiler::CONCURRENT
    1121     1503615 :                                            : Compiler::NOT_CONCURRENT;
    1122             : 
    1123             :   RuntimeCallTimerScope runtimeTimer(
    1124             :       isolate, parse_info->is_eval() ? &RuntimeCallStats::CompileEval
    1125     1503615 :                                      : &RuntimeCallStats::CompileScript);
    1126             : 
    1127             :   Handle<Script> script = parse_info->script();
    1128             : 
    1129             :   Handle<SharedFunctionInfo> result;
    1130             : 
    1131             :   { VMState<COMPILER> state(info->isolate());
    1132     1503617 :     if (parse_info->literal() == nullptr) {
    1133     1503496 :       if (!parsing::ParseProgram(parse_info, info->isolate(),
    1134     1503502 :                                  inner_function_mode != Compiler::CONCURRENT)) {
    1135             :         return Handle<SharedFunctionInfo>::null();
    1136             :       }
    1137             : 
    1138     1341221 :       if (inner_function_mode == Compiler::CONCURRENT) {
    1139             :         ParseHandleScope parse_handles(parse_info, info->isolate());
    1140           0 :         parse_info->ReopenHandlesInNewHandleScope();
    1141           0 :         parse_info->ast_value_factory()->Internalize(info->isolate());
    1142             :       }
    1143             :     }
    1144             : 
    1145             :     EnsureSharedFunctionInfosArrayOnScript(info);
    1146             : 
    1147             :     // Measure how long it takes to do the compilation; only take the
    1148             :     // rest of the function into account to avoid overlap with the
    1149             :     // parsing statistics.
    1150             :     HistogramTimer* rate = parse_info->is_eval()
    1151     1135581 :                                ? info->isolate()->counters()->compile_eval()
    1152     2682680 :                                : info->isolate()->counters()->compile();
    1153             :     HistogramTimerScope timer(rate);
    1154     4024004 :     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
    1155             :                  parse_info->is_eval() ? "V8.CompileEval" : "V8.Compile");
    1156             : 
    1157             :     // Allocate a shared function info object.
    1158             :     FunctionLiteral* lit = parse_info->literal();
    1159             :     DCHECK_EQ(kNoSourcePosition, lit->function_token_position());
    1160     1341339 :     result = isolate->factory()->NewSharedFunctionInfoForLiteral(lit, script);
    1161             :     result->set_is_toplevel(true);
    1162             :     parse_info->set_shared_info(result);
    1163             :     parse_info->set_function_literal_id(result->function_literal_id());
    1164             : 
    1165             :     // Compile the code.
    1166     1341339 :     if (!CompileUnoptimizedCode(info, inner_function_mode)) {
    1167          15 :       return Handle<SharedFunctionInfo>::null();
    1168             :     }
    1169             : 
    1170             :     Handle<String> script_name =
    1171             :         script->name()->IsString()
    1172             :             ? Handle<String>(String::cast(script->name()))
    1173     1341321 :             : isolate->factory()->empty_string();
    1174             :     CodeEventListener::LogEventsAndTags log_tag =
    1175             :         parse_info->is_eval()
    1176             :             ? CodeEventListener::EVAL_TAG
    1177     1341326 :             : Logger::ToNativeByScript(CodeEventListener::SCRIPT_TAG, *script);
    1178             : 
    1179     1341323 :     PROFILE(isolate, CodeCreateEvent(log_tag, result->abstract_code(), *result,
    1180             :                                      *script_name));
    1181             : 
    1182     1341326 :     if (!script.is_null()) {
    1183             :       script->set_compilation_state(Script::COMPILATION_STATE_COMPILED);
    1184     1341326 :       if (FLAG_experimental_preparser_scope_analysis) {
    1185             :         Handle<PodArray<uint32_t>> data =
    1186          23 :             parse_info->preparsed_scope_data()->Serialize(isolate);
    1187          23 :         script->set_preparsed_scope_data(*data);
    1188             :       }
    1189             :     }
    1190             :   }
    1191             : 
    1192     1341322 :   return result;
    1193             : }
    1194             : 
    1195             : }  // namespace
    1196             : 
    1197             : // ----------------------------------------------------------------------------
    1198             : // Implementation of Compiler
    1199             : 
    1200     2680431 : bool Compiler::Analyze(ParseInfo* info, Isolate* isolate,
    1201             :                        EagerInnerFunctionLiterals* eager_literals) {
    1202             :   DCHECK_NOT_NULL(info->literal());
    1203             :   RuntimeCallTimerScope runtimeTimer(isolate,
    1204     2680431 :                                      &RuntimeCallStats::CompileAnalyse);
    1205     2680439 :   if (!Rewriter::Rewrite(info, isolate)) return false;
    1206     2680439 :   DeclarationScope::Analyze(info, isolate, AnalyzeMode::kRegular);
    1207     2680442 :   if (!Renumber(info, eager_literals)) {
    1208             :     return false;
    1209             :   }
    1210             :   DCHECK_NOT_NULL(info->scope());
    1211     2680392 :   return true;
    1212             : }
    1213             : 
    1214     2227814 : bool Compiler::Analyze(CompilationInfo* info,
    1215             :                        EagerInnerFunctionLiterals* eager_literals) {
    1216     2227814 :   return Compiler::Analyze(info->parse_info(), info->isolate(), eager_literals);
    1217             : }
    1218             : 
    1219      406700 : bool Compiler::ParseAndAnalyze(ParseInfo* info, Isolate* isolate) {
    1220      406700 :   if (!parsing::ParseAny(info, isolate)) return false;
    1221      406598 :   if (info->is_toplevel()) {
    1222      125552 :     EnsureSharedFunctionInfosArrayOnScript(info, isolate);
    1223             :   }
    1224      406598 :   if (!Compiler::Analyze(info, isolate)) return false;
    1225             :   DCHECK_NOT_NULL(info->literal());
    1226             :   DCHECK_NOT_NULL(info->scope());
    1227      406598 :   return true;
    1228             : }
    1229             : 
    1230      391217 : bool Compiler::ParseAndAnalyze(CompilationInfo* info) {
    1231      391217 :   return Compiler::ParseAndAnalyze(info->parse_info(), info->isolate());
    1232             : }
    1233             : 
    1234     1169586 : bool Compiler::Compile(Handle<JSFunction> function, ClearExceptionFlag flag) {
    1235     1169586 :   if (function->is_compiled()) return true;
    1236     1157706 :   Isolate* isolate = function->GetIsolate();
    1237             :   DCHECK(AllowCompilation::IsAllowed(isolate));
    1238             : 
    1239             :   CompilerDispatcher* dispatcher = isolate->compiler_dispatcher();
    1240             :   Handle<SharedFunctionInfo> shared(function->shared(), isolate);
    1241             :   Handle<Code> code;
    1242     1157706 :   if (dispatcher->IsEnqueued(shared)) {
    1243           3 :     if (!dispatcher->FinishNow(shared)) {
    1244           0 :       if (flag == CLEAR_EXCEPTION) {
    1245             :         isolate->clear_pending_exception();
    1246             :       }
    1247             :       return false;
    1248             :     }
    1249             :     code = handle(shared->code(), isolate);
    1250             :   } else {
    1251             :     // Start a compilation.
    1252     2315406 :     if (!GetLazyCode(function).ToHandle(&code)) {
    1253        2867 :       if (flag == CLEAR_EXCEPTION) {
    1254             :         isolate->clear_pending_exception();
    1255             :       }
    1256             :       return false;
    1257             :     }
    1258             :   }
    1259             : 
    1260             :   // Install code on closure.
    1261     1154839 :   function->ReplaceCode(*code);
    1262     1154839 :   JSFunction::EnsureLiterals(function);
    1263             : 
    1264             :   // Check postconditions on success.
    1265             :   DCHECK(!isolate->has_pending_exception());
    1266             :   DCHECK(function->shared()->is_compiled());
    1267             :   DCHECK(function->is_compiled());
    1268     1154839 :   return true;
    1269             : }
    1270             : 
    1271      671693 : bool Compiler::CompileOptimized(Handle<JSFunction> function,
    1272             :                                 ConcurrencyMode mode) {
    1273      671693 :   if (function->IsOptimized()) return true;
    1274             :   Isolate* isolate = function->GetIsolate();
    1275             :   DCHECK(AllowCompilation::IsAllowed(isolate));
    1276             : 
    1277             :   // Start a compilation.
    1278             :   Handle<Code> code;
    1279     1343386 :   if (!GetOptimizedCode(function, mode).ToHandle(&code)) {
    1280             :     // Optimization failed, get unoptimized code. Unoptimized code must exist
    1281             :     // already if we are optimizing.
    1282             :     DCHECK(!isolate->has_pending_exception());
    1283             :     DCHECK(function->shared()->is_compiled());
    1284             :     code = handle(function->shared()->code(), isolate);
    1285             :   }
    1286             : 
    1287             :   // Install code on closure.
    1288      671693 :   function->ReplaceCode(*code);
    1289      671692 :   JSFunction::EnsureLiterals(function);
    1290             : 
    1291             :   // Check postconditions on success.
    1292             :   DCHECK(!isolate->has_pending_exception());
    1293             :   DCHECK(function->shared()->is_compiled());
    1294             :   DCHECK(function->is_compiled());
    1295      671694 :   return true;
    1296             : }
    1297             : 
    1298        4461 : bool Compiler::CompileDebugCode(Handle<SharedFunctionInfo> shared) {
    1299             :   Isolate* isolate = shared->GetIsolate();
    1300             :   DCHECK(AllowCompilation::IsAllowed(isolate));
    1301             : 
    1302             :   // Start a compilation.
    1303        4461 :   ParseInfo parse_info(shared);
    1304             :   CompilationInfo info(parse_info.zone(), &parse_info, isolate,
    1305        8922 :                        Handle<JSFunction>::null());
    1306             :   info.MarkAsDebug();
    1307        8922 :   if (GetUnoptimizedCode(&info, Compiler::NOT_CONCURRENT).is_null()) {
    1308             :     isolate->clear_pending_exception();
    1309           0 :     return false;
    1310             :   }
    1311             : 
    1312             :   // Check postconditions on success.
    1313             :   DCHECK(!isolate->has_pending_exception());
    1314             :   DCHECK(shared->is_compiled());
    1315             :   DCHECK(shared->HasDebugCode());
    1316        4461 :   return true;
    1317             : }
    1318             : 
    1319        1644 : MaybeHandle<JSArray> Compiler::CompileForLiveEdit(Handle<Script> script) {
    1320        1644 :   Isolate* isolate = script->GetIsolate();
    1321             :   DCHECK(AllowCompilation::IsAllowed(isolate));
    1322             : 
    1323             :   // In order to ensure that live edit function info collection finds the newly
    1324             :   // generated shared function infos, clear the script's list temporarily
    1325             :   // and restore it at the end of this method.
    1326             :   Handle<FixedArray> old_function_infos(script->shared_function_infos(),
    1327             :                                         isolate);
    1328        3288 :   script->set_shared_function_infos(isolate->heap()->empty_fixed_array());
    1329             : 
    1330             :   // Start a compilation.
    1331        1644 :   ParseInfo parse_info(script);
    1332        3288 :   Zone compile_zone(isolate->allocator(), ZONE_NAME);
    1333             :   CompilationInfo info(&compile_zone, &parse_info, isolate,
    1334        3288 :                        Handle<JSFunction>::null());
    1335             :   info.MarkAsDebug();
    1336             : 
    1337             :   // TODO(635): support extensions.
    1338        3288 :   const bool compilation_succeeded = !CompileToplevel(&info).is_null();
    1339             :   Handle<JSArray> infos;
    1340        1644 :   if (compilation_succeeded) {
    1341             :     // Check postconditions on success.
    1342             :     DCHECK(!isolate->has_pending_exception());
    1343             :     infos = LiveEditFunctionTracker::Collect(parse_info.literal(), script,
    1344        1618 :                                              parse_info.zone(), isolate);
    1345             :   }
    1346             : 
    1347             :   // Restore the original function info list in order to remain side-effect
    1348             :   // free as much as possible, since some code expects the old shared function
    1349             :   // infos to stick around.
    1350        1644 :   script->set_shared_function_infos(*old_function_infos);
    1351             : 
    1352        1644 :   return infos;
    1353             : }
    1354             : 
    1355       41184 : bool Compiler::EnsureBytecode(CompilationInfo* info) {
    1356       79710 :   if (!info->shared_info()->is_compiled()) {
    1357        1329 :     CompilerDispatcher* dispatcher = info->isolate()->compiler_dispatcher();
    1358        1329 :     if (dispatcher->IsEnqueued(info->shared_info())) {
    1359           0 :       if (!dispatcher->FinishNow(info->shared_info())) return false;
    1360        2658 :     } else if (GetUnoptimizedCode(info, Compiler::NOT_CONCURRENT).is_null()) {
    1361             :       return false;
    1362             :     }
    1363             :   }
    1364             :   DCHECK(info->shared_info()->is_compiled());
    1365             : 
    1366       79680 :   if (info->shared_info()->HasAsmWasmData()) return false;
    1367             : 
    1368             :   DCHECK_EQ(ShouldUseIgnition(info), info->shared_info()->HasBytecodeArray());
    1369       79680 :   return info->shared_info()->HasBytecodeArray();
    1370             : }
    1371             : 
    1372             : // TODO(turbofan): In the future, unoptimized code with deopt support could
    1373             : // be generated lazily once deopt is triggered.
    1374     1813819 : bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
    1375             :   DCHECK_NOT_NULL(info->literal());
    1376             :   DCHECK_NOT_NULL(info->scope());
    1377      327472 :   Handle<SharedFunctionInfo> shared = info->shared_info();
    1378             : 
    1379      327472 :   CompilerDispatcher* dispatcher = info->isolate()->compiler_dispatcher();
    1380      327472 :   if (dispatcher->IsEnqueued(shared)) {
    1381           0 :     if (!dispatcher->FinishNow(shared)) return false;
    1382             :   }
    1383             : 
    1384      327472 :   if (!shared->has_deoptimization_support()) {
    1385             :     // Don't generate full-codegen code for functions which should use Ignition.
    1386      232605 :     if (ShouldUseIgnition(info)) return false;
    1387             : 
    1388             :     DCHECK(!shared->must_use_ignition_turbo());
    1389             :     DCHECK(!IsResumableFunction(shared->kind()));
    1390             : 
    1391      231775 :     Zone compile_zone(info->isolate()->allocator(), ZONE_NAME);
    1392             :     CompilationInfo unoptimized(&compile_zone, info->parse_info(),
    1393      463550 :                                 info->isolate(), info->closure());
    1394             :     unoptimized.EnableDeoptimizationSupport();
    1395             : 
    1396             :     // When we call PrepareForSerializing below, we will change the shared
    1397             :     // ParseInfo. Make sure to reset it.
    1398             :     bool old_will_serialize_value = info->parse_info()->will_serialize();
    1399             : 
    1400             :     // If the current code has reloc info for serialization, also include
    1401             :     // reloc info for serialization for the new code, so that deopt support
    1402             :     // can be added without losing IC state.
    1403      460480 :     if (shared->code()->kind() == Code::FUNCTION &&
    1404             :         shared->code()->has_reloc_info_for_serialization()) {
    1405          41 :       unoptimized.PrepareForSerializing();
    1406             :     }
    1407      231775 :     EnsureFeedbackMetadata(&unoptimized);
    1408             : 
    1409      231775 :     if (!FullCodeGenerator::MakeCode(&unoptimized)) return false;
    1410             : 
    1411             :     info->parse_info()->set_will_serialize(old_will_serialize_value);
    1412             : 
    1413             :     // The scope info might not have been set if a lazily compiled
    1414             :     // function is inlined before being called for the first time.
    1415      231775 :     if (shared->scope_info() == ScopeInfo::Empty(info->isolate())) {
    1416        3052 :       InstallSharedScopeInfo(info, shared);
    1417             :     }
    1418             : 
    1419             :     // Install compilation result on the shared function info
    1420      231775 :     shared->EnableDeoptimizationSupport(*unoptimized.code());
    1421             : 
    1422             :     // The existing unoptimized code was replaced with the new one.
    1423             :     RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG,
    1424      463550 :                               &unoptimized);
    1425             :   }
    1426             :   return true;
    1427             : }
    1428             : 
    1429     5596538 : MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
    1430             :     Handle<String> source, Handle<SharedFunctionInfo> outer_info,
    1431             :     Handle<Context> context, LanguageMode language_mode,
    1432             :     ParseRestriction restriction, int parameters_end_pos,
    1433             :     int eval_scope_position, int eval_position, int line_offset,
    1434             :     int column_offset, Handle<Object> script_name,
    1435             :     ScriptOriginOptions options) {
    1436    23520376 :   Isolate* isolate = source->GetIsolate();
    1437             :   int source_length = source->length();
    1438     5596538 :   isolate->counters()->total_eval_size()->Increment(source_length);
    1439     5596538 :   isolate->counters()->total_compile_size()->Increment(source_length);
    1440             : 
    1441             :   // The cache lookup key needs to be aware of the separation between the
    1442             :   // parameters and the body to prevent this valid invocation:
    1443             :   //   Function("", "function anonymous(\n/**/) {\n}");
    1444             :   // from adding an entry that falsely approves this invalid invocation:
    1445             :   //   Function("\n/**/) {\nfunction anonymous(", "}");
    1446             :   // The actual eval_scope_position for indirect eval and CreateDynamicFunction
    1447             :   // is unused (just 0), which means it's an available field to use to indicate
    1448             :   // this separation. But to make sure we're not causing other false hits, we
    1449             :   // negate the scope position.
    1450             :   int position = eval_scope_position;
    1451     5596538 :   if (FLAG_harmony_function_tostring &&
    1452       16392 :       restriction == ONLY_SINGLE_FUNCTION_LITERAL &&
    1453        8196 :       parameters_end_pos != kNoSourcePosition) {
    1454             :     // use the parameters_end_pos as the eval_scope_position in the eval cache.
    1455             :     DCHECK_EQ(eval_scope_position, 0);
    1456        3966 :     position = -parameters_end_pos;
    1457             :   }
    1458             :   CompilationCache* compilation_cache = isolate->compilation_cache();
    1459             :   InfoVectorPair eval_result = compilation_cache->LookupEval(
    1460     5596538 :       source, outer_info, context, language_mode, position);
    1461             :   Handle<Cell> vector;
    1462     5596538 :   if (eval_result.has_vector()) {
    1463     3577590 :     vector = Handle<Cell>(eval_result.vector(), isolate);
    1464             :   }
    1465             : 
    1466             :   Handle<SharedFunctionInfo> shared_info;
    1467             :   Handle<Script> script;
    1468     5596538 :   if (eval_result.has_shared()) {
    1469             :     shared_info = Handle<SharedFunctionInfo>(eval_result.shared(), isolate);
    1470             :     script = Handle<Script>(Script::cast(shared_info->script()), isolate);
    1471             :   } else {
    1472     1294323 :     script = isolate->factory()->NewScript(source);
    1473     1294323 :     if (isolate->NeedsSourcePositionsForProfiling()) {
    1474       21013 :       Script::InitLineEnds(script);
    1475             :     }
    1476     1294323 :     if (!script_name.is_null()) {
    1477          21 :       script->set_name(*script_name);
    1478             :       script->set_line_offset(line_offset);
    1479             :       script->set_column_offset(column_offset);
    1480             :     }
    1481             :     script->set_origin_options(options);
    1482             :     script->set_compilation_type(Script::COMPILATION_TYPE_EVAL);
    1483     1294323 :     Script::SetEvalOrigin(script, outer_info, eval_position);
    1484             : 
    1485     1294323 :     ParseInfo parse_info(script);
    1486     2428547 :     Zone compile_zone(isolate->allocator(), ZONE_NAME);
    1487             :     CompilationInfo info(&compile_zone, &parse_info, isolate,
    1488     2428547 :                          Handle<JSFunction>::null());
    1489             :     parse_info.set_eval();
    1490             :     parse_info.set_language_mode(language_mode);
    1491             :     parse_info.set_parse_restriction(restriction);
    1492             :     parse_info.set_parameters_end_pos(parameters_end_pos);
    1493     1294323 :     if (!context->IsNativeContext()) {
    1494      769342 :       parse_info.set_outer_scope_info(handle(context->scope_info()));
    1495             :     }
    1496             : 
    1497     1294323 :     shared_info = CompileToplevel(&info);
    1498     1294323 :     if (shared_info.is_null()) {
    1499      160099 :       return MaybeHandle<JSFunction>();
    1500     1134224 :     }
    1501             :   }
    1502             : 
    1503             :   // If caller is strict mode, the result must be in strict mode as well.
    1504             :   DCHECK(is_sloppy(language_mode) || is_strict(shared_info->language_mode()));
    1505             : 
    1506             :   Handle<JSFunction> result;
    1507     5436439 :   if (eval_result.has_shared()) {
    1508     4302215 :     if (eval_result.has_vector()) {
    1509             :       result = isolate->factory()->NewFunctionFromSharedFunctionInfo(
    1510     3577590 :           shared_info, context, vector, NOT_TENURED);
    1511             :     } else {
    1512             :       result = isolate->factory()->NewFunctionFromSharedFunctionInfo(
    1513      724625 :           shared_info, context, NOT_TENURED);
    1514      724625 :       JSFunction::EnsureLiterals(result);
    1515             :       // Make sure to cache this result.
    1516             :       Handle<Cell> new_vector(result->feedback_vector_cell(), isolate);
    1517             :       compilation_cache->PutEval(source, outer_info, context, shared_info,
    1518      724625 :                                  new_vector, eval_scope_position);
    1519             :     }
    1520             :   } else {
    1521             :     result = isolate->factory()->NewFunctionFromSharedFunctionInfo(
    1522     1134224 :         shared_info, context, NOT_TENURED);
    1523     1134224 :     JSFunction::EnsureLiterals(result);
    1524             :     // Add the SharedFunctionInfo and the LiteralsArray to the eval cache if
    1525             :     // we didn't retrieve from there.
    1526             :     Handle<Cell> vector(result->feedback_vector_cell(), isolate);
    1527             :     compilation_cache->PutEval(source, outer_info, context, shared_info, vector,
    1528     1134224 :                                eval_scope_position);
    1529             :   }
    1530             : 
    1531             :   // OnAfterCompile has to be called after we create the JSFunction, which we
    1532             :   // may require to recompile the eval for debugging, if we find a function
    1533             :   // that contains break points in the eval script.
    1534     5436439 :   isolate->debug()->OnAfterCompile(script);
    1535             : 
    1536             :   return result;
    1537             : }
    1538             : 
    1539             : namespace {
    1540             : 
    1541          42 : bool CodeGenerationFromStringsAllowed(Isolate* isolate,
    1542             :                                       Handle<Context> context) {
    1543             :   DCHECK(context->allow_code_gen_from_strings()->IsFalse(isolate));
    1544             :   // Check with callback if set.
    1545             :   AllowCodeGenerationFromStringsCallback callback =
    1546             :       isolate->allow_code_gen_callback();
    1547          42 :   if (callback == NULL) {
    1548             :     // No callback set and code generation disallowed.
    1549             :     return false;
    1550             :   } else {
    1551             :     // Callback set. Let it decide if code generation is allowed.
    1552          28 :     VMState<EXTERNAL> state(isolate);
    1553          28 :     return callback(v8::Utils::ToLocal(context));
    1554             :   }
    1555             : }
    1556             : 
    1557         404 : bool ContainsAsmModule(Handle<Script> script) {
    1558             :   DisallowHeapAllocation no_gc;
    1559         404 :   SharedFunctionInfo::ScriptIterator iter(script);
    1560        7755 :   while (SharedFunctionInfo* info = iter.Next()) {
    1561        7366 :     if (info->HasAsmWasmData()) return true;
    1562             :   }
    1563             :   return false;
    1564             : }
    1565             : 
    1566             : }  // namespace
    1567             : 
    1568     1799796 : MaybeHandle<JSFunction> Compiler::GetFunctionFromString(
    1569             :     Handle<Context> context, Handle<String> source,
    1570             :     ParseRestriction restriction, int parameters_end_pos) {
    1571             :   Isolate* const isolate = context->GetIsolate();
    1572             :   Handle<Context> native_context(context->native_context(), isolate);
    1573             : 
    1574             :   // Check if native context allows code generation from
    1575             :   // strings. Throw an exception if it doesn't.
    1576     1799838 :   if (native_context->allow_code_gen_from_strings()->IsFalse(isolate) &&
    1577          42 :       !CodeGenerationFromStringsAllowed(isolate, native_context)) {
    1578             :     Handle<Object> error_message =
    1579          28 :         native_context->ErrorMessageForCodeGenerationFromStrings();
    1580          56 :     THROW_NEW_ERROR(isolate, NewEvalError(MessageTemplate::kCodeGenFromStrings,
    1581             :                                           error_message),
    1582             :                     JSFunction);
    1583             :   }
    1584             : 
    1585             :   // Compile source string in the native context.
    1586             :   int eval_scope_position = 0;
    1587             :   int eval_position = kNoSourcePosition;
    1588             :   Handle<SharedFunctionInfo> outer_info(native_context->closure()->shared());
    1589             :   return Compiler::GetFunctionFromEval(source, outer_info, native_context,
    1590             :                                        SLOPPY, restriction, parameters_end_pos,
    1591     1799768 :                                        eval_scope_position, eval_position);
    1592             : }
    1593             : 
    1594      348960 : Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
    1595             :     Handle<String> source, Handle<Object> script_name, int line_offset,
    1596             :     int column_offset, ScriptOriginOptions resource_options,
    1597             :     Handle<Object> source_map_url, Handle<Context> context,
    1598             :     v8::Extension* extension, ScriptData** cached_data,
    1599             :     ScriptCompiler::CompileOptions compile_options, NativesFlag natives) {
    1600     1460996 :   Isolate* isolate = source->GetIsolate();
    1601      348960 :   if (compile_options == ScriptCompiler::kNoCompileOptions) {
    1602             :     cached_data = NULL;
    1603             :   } else if (compile_options == ScriptCompiler::kProduceParserCache ||
    1604             :              compile_options == ScriptCompiler::kProduceCodeCache) {
    1605             :     DCHECK(cached_data && !*cached_data);
    1606             :     DCHECK(extension == NULL);
    1607             :     DCHECK(!isolate->debug()->is_loaded());
    1608             :   } else {
    1609             :     DCHECK(compile_options == ScriptCompiler::kConsumeParserCache ||
    1610             :            compile_options == ScriptCompiler::kConsumeCodeCache);
    1611             :     DCHECK(cached_data && *cached_data);
    1612             :     DCHECK(extension == NULL);
    1613             :   }
    1614             :   int source_length = source->length();
    1615      348960 :   isolate->counters()->total_load_size()->Increment(source_length);
    1616      348964 :   isolate->counters()->total_compile_size()->Increment(source_length);
    1617             : 
    1618      348965 :   LanguageMode language_mode = construct_language_mode(FLAG_use_strict);
    1619             :   CompilationCache* compilation_cache = isolate->compilation_cache();
    1620             : 
    1621             :   // Do a lookup in the compilation cache but not for extensions.
    1622             :   Handle<SharedFunctionInfo> result;
    1623             :   Handle<Cell> vector;
    1624      348965 :   if (extension == NULL) {
    1625             :     // First check per-isolate compilation cache.
    1626             :     InfoVectorPair pair = compilation_cache->LookupScript(
    1627             :         source, script_name, line_offset, column_offset, resource_options,
    1628      344223 :         context, language_mode);
    1629      547276 :     if (!pair.has_shared() && FLAG_serialize_toplevel &&
    1630      344502 :         compile_options == ScriptCompiler::kConsumeCodeCache &&
    1631             :         !isolate->debug()->is_loaded()) {
    1632             :       // Then check cached code provided by embedder.
    1633         279 :       HistogramTimerScope timer(isolate->counters()->compile_deserialize());
    1634             :       RuntimeCallTimerScope runtimeTimer(isolate,
    1635         279 :                                          &RuntimeCallStats::CompileDeserialize);
    1636         576 :       TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
    1637             :                    "V8.CompileDeserialize");
    1638             :       Handle<SharedFunctionInfo> inner_result;
    1639         279 :       if (CodeSerializer::Deserialize(isolate, *cached_data, source)
    1640         558 :               .ToHandle(&inner_result)) {
    1641             :         // Promote to per-isolate compilation cache.
    1642             :         DCHECK(inner_result->is_compiled());
    1643             :         Handle<FeedbackVector> feedback_vector =
    1644         261 :             FeedbackVector::New(isolate, inner_result);
    1645         261 :         vector = isolate->factory()->NewCell(feedback_vector);
    1646             :         compilation_cache->PutScript(source, context, language_mode,
    1647         261 :                                      inner_result, vector);
    1648             :         Handle<Script> script(Script::cast(inner_result->script()), isolate);
    1649         261 :         isolate->debug()->OnAfterCompile(script);
    1650         261 :         return inner_result;
    1651             :       }
    1652             :       // Deserializer failed. Fall through to compile.
    1653             :     } else {
    1654      343944 :       if (pair.has_shared()) {
    1655             :         result = Handle<SharedFunctionInfo>(pair.shared(), isolate);
    1656             :       }
    1657      343944 :       if (pair.has_vector()) {
    1658             :         vector = Handle<Cell>(pair.vector(), isolate);
    1659             :       }
    1660             :     }
    1661             :   }
    1662             : 
    1663             :   base::ElapsedTimer timer;
    1664      348704 :   if (FLAG_profile_deserialization && FLAG_serialize_toplevel &&
    1665             :       compile_options == ScriptCompiler::kProduceCodeCache) {
    1666             :     timer.Start();
    1667             :   }
    1668             : 
    1669      697408 :   if (result.is_null() ||
    1670      141169 :       (FLAG_serialize_toplevel &&
    1671             :        compile_options == ScriptCompiler::kProduceCodeCache)) {
    1672             :     // No cache entry found, or embedder wants a code cache. Compile the script.
    1673             : 
    1674             :     // Create a script object describing the script to be compiled.
    1675      207535 :     Handle<Script> script = isolate->factory()->NewScript(source);
    1676      207532 :     if (isolate->NeedsSourcePositionsForProfiling()) {
    1677       16171 :       Script::InitLineEnds(script);
    1678             :     }
    1679      207536 :     if (natives == NATIVES_CODE) {
    1680             :       script->set_type(Script::TYPE_NATIVE);
    1681      189621 :     } else if (natives == EXTENSION_CODE) {
    1682             :       script->set_type(Script::TYPE_EXTENSION);
    1683      184793 :     } else if (natives == INSPECTOR_CODE) {
    1684             :       script->set_type(Script::TYPE_INSPECTOR);
    1685             :     }
    1686      207536 :     if (!script_name.is_null()) {
    1687      143268 :       script->set_name(*script_name);
    1688             :       script->set_line_offset(line_offset);
    1689             :       script->set_column_offset(column_offset);
    1690             :     }
    1691             :     script->set_origin_options(resource_options);
    1692      207535 :     if (!source_map_url.is_null()) {
    1693        4816 :       script->set_source_mapping_url(*source_map_url);
    1694             :     }
    1695             : 
    1696             :     // Compile the function and add it to the cache.
    1697      207535 :     ParseInfo parse_info(script);
    1698      415068 :     Zone compile_zone(isolate->allocator(), ZONE_NAME);
    1699             :     CompilationInfo info(&compile_zone, &parse_info, isolate,
    1700      415069 :                          Handle<JSFunction>::null());
    1701      207535 :     if (resource_options.IsModule()) parse_info.set_module();
    1702      207535 :     if (compile_options != ScriptCompiler::kNoCompileOptions) {
    1703             :       parse_info.set_cached_data(cached_data);
    1704             :     }
    1705             :     parse_info.set_compile_options(compile_options);
    1706             :     parse_info.set_extension(extension);
    1707      207535 :     if (!context->IsNativeContext()) {
    1708           0 :       parse_info.set_outer_scope_info(handle(context->scope_info()));
    1709             :     }
    1710      207535 :     if (FLAG_serialize_toplevel &&
    1711             :         compile_options == ScriptCompiler::kProduceCodeCache) {
    1712         404 :       info.PrepareForSerializing();
    1713             :     }
    1714             : 
    1715             :     parse_info.set_language_mode(
    1716      207534 :         static_cast<LanguageMode>(parse_info.language_mode() | language_mode));
    1717      207534 :     result = CompileToplevel(&info);
    1718      207525 :     if (extension == NULL && !result.is_null()) {
    1719             :       // We need a feedback vector.
    1720             :       DCHECK(result->is_compiled());
    1721             :       Handle<FeedbackVector> feedback_vector =
    1722      200659 :           FeedbackVector::New(isolate, result);
    1723      200664 :       vector = isolate->factory()->NewCell(feedback_vector);
    1724             :       compilation_cache->PutScript(source, context, language_mode, result,
    1725      200663 :                                    vector);
    1726      401328 :       if (FLAG_serialize_toplevel &&
    1727      201068 :           compile_options == ScriptCompiler::kProduceCodeCache &&
    1728         404 :           !ContainsAsmModule(script)) {
    1729             :         HistogramTimerScope histogram_timer(
    1730         389 :             isolate->counters()->compile_serialize());
    1731             :         RuntimeCallTimerScope runtimeTimer(isolate,
    1732         389 :                                            &RuntimeCallStats::CompileSerialize);
    1733        1167 :         TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
    1734             :                      "V8.CompileSerialize");
    1735         389 :         *cached_data = CodeSerializer::Serialize(isolate, result, source);
    1736         389 :         if (FLAG_profile_deserialization) {
    1737             :           PrintF("[Compiling and serializing took %0.3f ms]\n",
    1738           0 :                  timer.Elapsed().InMillisecondsF());
    1739             :         }
    1740             :       }
    1741             :     }
    1742             : 
    1743      207530 :     if (result.is_null()) {
    1744        2165 :       if (natives != EXTENSION_CODE && natives != NATIVES_CODE) {
    1745        1509 :         isolate->ReportPendingMessages();
    1746             :       }
    1747             :     } else {
    1748      205365 :       isolate->debug()->OnAfterCompile(script);
    1749      207533 :     }
    1750      141169 :   } else if (result->ic_age() != isolate->heap()->global_ic_age()) {
    1751         573 :     result->ResetForNewContext(isolate->heap()->global_ic_age());
    1752             :   }
    1753      348703 :   return result;
    1754             : }
    1755             : 
    1756         114 : Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForStreamedScript(
    1757             :     Handle<Script> script, ParseInfo* parse_info, int source_length) {
    1758         456 :   Isolate* isolate = script->GetIsolate();
    1759             :   // TODO(titzer): increment the counters in caller.
    1760         114 :   isolate->counters()->total_load_size()->Increment(source_length);
    1761         114 :   isolate->counters()->total_compile_size()->Increment(source_length);
    1762             : 
    1763         114 :   LanguageMode language_mode = construct_language_mode(FLAG_use_strict);
    1764             :   parse_info->set_language_mode(
    1765         114 :       static_cast<LanguageMode>(parse_info->language_mode() | language_mode));
    1766             : 
    1767         114 :   Zone compile_zone(isolate->allocator(), ZONE_NAME);
    1768             :   CompilationInfo compile_info(&compile_zone, parse_info, isolate,
    1769         228 :                                Handle<JSFunction>::null());
    1770             : 
    1771             :   // The source was parsed lazily, so compiling for debugging is not possible.
    1772             :   DCHECK(!compile_info.is_debug());
    1773             : 
    1774         114 :   Handle<SharedFunctionInfo> result = CompileToplevel(&compile_info);
    1775         228 :   if (!result.is_null()) isolate->debug()->OnAfterCompile(script);
    1776         228 :   return result;
    1777             : }
    1778             : 
    1779     5862863 : Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfo(
    1780     4894051 :     FunctionLiteral* literal, Handle<Script> script,
    1781     5862863 :     CompilationInfo* outer_info) {
    1782             :   // Precondition: code has been parsed and scopes have been analyzed.
    1783             :   Isolate* isolate = outer_info->isolate();
    1784             :   MaybeHandle<SharedFunctionInfo> maybe_existing;
    1785             : 
    1786             :   // Find any previously allocated shared function info for the given literal.
    1787     5862863 :   maybe_existing = script->FindSharedFunctionInfo(isolate, literal);
    1788             : 
    1789             :   // If we found an existing shared function info, return it.
    1790             :   Handle<SharedFunctionInfo> existing;
    1791     5862880 :   if (maybe_existing.ToHandle(&existing)) {
    1792             :     DCHECK(!existing->is_toplevel());
    1793      968830 :     return existing;
    1794             :   }
    1795             : 
    1796             :   // Allocate a shared function info object which will be compiled lazily.
    1797             :   Handle<SharedFunctionInfo> result =
    1798     4894050 :       isolate->factory()->NewSharedFunctionInfoForLiteral(literal, script);
    1799             :   result->set_is_toplevel(false);
    1800     4894051 :   Scope* outer_scope = literal->scope()->GetOuterScopeWithContext();
    1801     4894051 :   if (outer_scope) {
    1802     4432085 :     result->set_outer_scope_info(*outer_scope->scope_info());
    1803             :   }
    1804     4894051 :   return result;
    1805             : }
    1806             : 
    1807        2988 : Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForNative(
    1808             :     v8::Extension* extension, Handle<String> name) {
    1809             :   Isolate* isolate = name->GetIsolate();
    1810             :   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
    1811             : 
    1812             :   // Compute the function template for the native function.
    1813             :   v8::Local<v8::FunctionTemplate> fun_template =
    1814             :       extension->GetNativeFunctionTemplate(v8_isolate,
    1815        2988 :                                            v8::Utils::ToLocal(name));
    1816             :   DCHECK(!fun_template.IsEmpty());
    1817             : 
    1818             :   // Instantiate the function and create a shared function info from it.
    1819             :   Handle<JSFunction> fun = Handle<JSFunction>::cast(Utils::OpenHandle(
    1820        2988 :       *fun_template->GetFunction(v8_isolate->GetCurrentContext())
    1821        2988 :            .ToLocalChecked()));
    1822             :   Handle<Code> code = Handle<Code>(fun->shared()->code());
    1823             :   Handle<Code> construct_stub = Handle<Code>(fun->shared()->construct_stub());
    1824             :   Handle<SharedFunctionInfo> shared = isolate->factory()->NewSharedFunctionInfo(
    1825             :       name, FunctionKind::kNormalFunction, code,
    1826        2988 :       Handle<ScopeInfo>(fun->shared()->scope_info()));
    1827        2988 :   shared->set_outer_scope_info(fun->shared()->outer_scope_info());
    1828        2988 :   shared->SetConstructStub(*construct_stub);
    1829        2988 :   shared->set_feedback_metadata(fun->shared()->feedback_metadata());
    1830             : 
    1831             :   // Copy the function data to the shared function info.
    1832        2988 :   shared->set_function_data(fun->shared()->function_data());
    1833             :   int parameters = fun->shared()->internal_formal_parameter_count();
    1834             :   shared->set_internal_formal_parameter_count(parameters);
    1835             : 
    1836        2988 :   return shared;
    1837             : }
    1838             : 
    1839        8477 : MaybeHandle<Code> Compiler::GetOptimizedCodeForOSR(Handle<JSFunction> function,
    1840             :                                                    BailoutId osr_ast_id,
    1841             :                                                    JavaScriptFrame* osr_frame) {
    1842             :   DCHECK(!osr_ast_id.IsNone());
    1843             :   DCHECK_NOT_NULL(osr_frame);
    1844        8477 :   return GetOptimizedCode(function, NOT_CONCURRENT, osr_ast_id, osr_frame);
    1845             : }
    1846             : 
    1847          29 : CompilationJob* Compiler::PrepareUnoptimizedCompilationJob(
    1848          29 :     CompilationInfo* info) {
    1849             :   VMState<COMPILER> state(info->isolate());
    1850          29 :   std::unique_ptr<CompilationJob> job(GetUnoptimizedCompilationJob(info));
    1851          29 :   if (job->PrepareJob() != CompilationJob::SUCCEEDED) {
    1852             :     return nullptr;
    1853             :   }
    1854          29 :   return job.release();
    1855             : }
    1856             : 
    1857       43566 : bool Compiler::FinalizeCompilationJob(CompilationJob* raw_job) {
    1858             :   // Take ownership of compilation job.  Deleting job also tears down the zone.
    1859             :   std::unique_ptr<CompilationJob> job(raw_job);
    1860             : 
    1861       43566 :   VMState<COMPILER> state(job->info()->isolate());
    1862       43566 :   if (job->info()->IsOptimizing()) {
    1863       43545 :     return FinalizeOptimizedCompilationJob(job.get()) ==
    1864       43545 :            CompilationJob::SUCCEEDED;
    1865             :   } else {
    1866          21 :     return FinalizeUnoptimizedCompilationJob(job.get()) ==
    1867          21 :            CompilationJob::SUCCEEDED;
    1868             :   }
    1869             : }
    1870             : 
    1871    25956039 : void Compiler::PostInstantiation(Handle<JSFunction> function,
    1872             :                                  PretenureFlag pretenure) {
    1873             :   Handle<SharedFunctionInfo> shared(function->shared());
    1874             : 
    1875    31367104 :   if (FLAG_always_opt && shared->allows_lazy_compilation() &&
    1876    30758023 :       !function->shared()->HasAsmWasmData() &&
    1877             :       function->shared()->is_compiled()) {
    1878     1017032 :     function->MarkForOptimization();
    1879             :   }
    1880             : 
    1881             :   Code* code = shared->SearchOptimizedCodeMap(
    1882    25956051 :       function->context()->native_context(), BailoutId::None());
    1883    25956046 :   if (code != nullptr) {
    1884             :     // Caching of optimized code enabled and optimized code found.
    1885             :     DCHECK(!code->marked_for_deoptimization());
    1886             :     DCHECK(function->shared()->is_compiled());
    1887      835750 :     function->ReplaceCode(code);
    1888             :   }
    1889             : 
    1890    25956052 :   if (shared->is_compiled()) {
    1891             :     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
    1892    14244718 :     JSFunction::EnsureLiterals(function);
    1893             :   }
    1894    25956056 : }
    1895             : 
    1896             : }  // namespace internal
    1897             : }  // namespace v8

Generated by: LCOV version 1.10