Lines Matching refs:isolate
34 #include "src/execution/isolate-inl.h"
35 #include "src/execution/isolate.h"
36 #include "src/execution/local-isolate.h"
104 static void TracePrepareJob(Isolate* isolate, OptimizedCompilationInfo* info,
107 CodeTracer::Scope scope(isolate->GetCodeTracer());
114 static void TraceStartBaselineCompile(Isolate* isolate,
117 CodeTracer::Scope scope(isolate->GetCodeTracer());
123 static void TraceOptimizeOSR(Isolate* isolate, Handle<JSFunction> function,
127 CodeTracer::Scope scope(isolate->GetCodeTracer());
133 static void TraceOptimizeOSRUnavailable(Isolate* isolate,
138 CodeTracer::Scope scope(isolate->GetCodeTracer());
145 static void TraceCompilationStats(Isolate* isolate,
150 CodeTracer::Scope scope(isolate->GetCodeTracer());
157 static void TraceFinishBaselineCompile(Isolate* isolate,
161 CodeTracer::Scope scope(isolate->GetCodeTracer());
167 static void TraceCompletedJob(Isolate* isolate,
170 CodeTracer::Scope scope(isolate->GetCodeTracer());
175 static void TraceAbortedJob(Isolate* isolate,
178 CodeTracer::Scope scope(isolate->GetCodeTracer());
185 static void TraceOptimizedCodeCacheHit(Isolate* isolate,
190 CodeTracer::Scope scope(isolate->GetCodeTracer());
198 static void TraceOptimizeForAlwaysOpt(Isolate* isolate,
202 CodeTracer::Scope scope(isolate->GetCodeTracer());
208 static void TraceMarkForAlwaysOpt(Isolate* isolate,
211 CodeTracer::Scope scope(isolate->GetCodeTracer());
247 void LogFunctionCompilation(Isolate* isolate,
256 DCHECK_NE(*abstract_code, FromCodeT(*BUILTIN_CODE(isolate, CompileLazy)));
258 DCHECK(!abstract_code.is_identical_to(BUILTIN_CODE(isolate, CompileLazy)));
264 if (!isolate->logger()->is_listening_to_code_events() &&
265 !isolate->is_profiling() && !FLAG_log_function_events &&
266 !isolate->code_event_dispatcher()->IsListeningToCodeEvents()) {
274 : ReadOnlyRoots(isolate).empty_string(),
275 isolate);
278 PROFILE(isolate, CodeCreateEvent(log_tag, abstract_code, shared, script_name,
281 LOG(isolate, FeedbackVectorEvent(*vector, *abstract_code));
316 LOG(isolate, FunctionEvent(name.c_str(), script->id(), time_taken_ms,
368 Handle<SharedFunctionInfo> shared_info, Isolate* isolate) {
369 DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
371 DisallowJavascriptExecution no_js(isolate);
376 return UpdateState(FinalizeJobImpl(shared_info, isolate), State::kSucceeded);
380 Handle<SharedFunctionInfo> shared_info, LocalIsolate* isolate) {
384 return UpdateState(FinalizeJobImpl(shared_info, isolate), State::kSucceeded);
389 void RecordUnoptimizedCompilationStats(Isolate* isolate,
394 ? shared_info->GetBytecodeArray(isolate).SizeIncludingMetadata()
398 shared_info->GetBytecodeArray(isolate).SizeIncludingMetadata();
401 Counters* counters = isolate->counters();
411 Isolate* isolate, CodeEventListener::LogEventsAndTags tag,
417 handle(AbstractCode::cast(shared->GetBytecodeArray(isolate)), isolate);
422 ToAbstractCode(BUILTIN_CODE(isolate, InstantiateAsmJs), isolate);
431 Handle<Script> script(Script::cast(shared->script()), isolate);
432 LogFunctionCompilation(isolate, tag, script, shared, Handle<FeedbackVector>(),
442 CompilationJob::Status OptimizedCompilationJob::PrepareJob(Isolate* isolate) {
443 DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
444 DisallowJavascriptExecution no_js(isolate);
449 return UpdateState(PrepareJobImpl(isolate), State::kReadyToExecute);
462 CompilationJob::Status OptimizedCompilationJob::FinalizeJob(Isolate* isolate) {
463 DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
464 DisallowJavascriptExecution no_js(isolate);
469 return UpdateState(FinalizeJobImpl(isolate), State::kSucceeded);
487 Isolate* isolate) const {
494 isolate, compilation_info(), ms_creategraph, ms_optimize, ms_codegen);
510 Counters* const counters = isolate->counters();
557 CodeEventListener::LogEventsAndTags tag, Isolate* isolate) const {
566 Script::cast(compilation_info()->shared_info()->script()), isolate);
568 compilation_info()->closure()->feedback_vector(), isolate);
570 isolate, tag, script, compilation_info()->shared_info(), feedback_vector,
597 Isolate* isolate, Handle<SharedFunctionInfo> shared_info,
604 Handle<BytecodeArray> bytecode_array(shared_info->GetBytecodeArray(isolate),
605 isolate);
607 Handle<Code> code = isolate->factory()->CopyCode(Handle<Code>::cast(
608 isolate->factory()->interpreter_entry_trampoline_for_profiling()));
611 Handle<InterpreterData>::cast(isolate->factory()->NewStruct(
619 Handle<Script> script(Script::cast(shared_info->script()), isolate);
627 : ReadOnlyRoots(isolate).empty_string(),
628 isolate);
629 PROFILE(isolate, CodeCreateEvent(log_tag, abstract_code, shared_info,
636 IsolateT* isolate) {
653 isolate, compilation_info->feedback_vector_spec());
662 ReadOnlyRoots(isolate).empty_feedback_metadata(), kReleaseStore);
669 void LogUnoptimizedCompilation(Isolate* isolate,
674 RecordUnoptimizedFunctionCompilation(isolate, log_tag, shared_info,
677 RecordUnoptimizedCompilationStats(isolate, shared_info);
683 IsolateT* isolate) {
692 Handle<WeakFixedArray> infos(isolate->factory()->NewWeakFixedArray(
723 IsolateT* isolate,
728 CompilationJob::Status status = job->FinalizeJob(shared_info, isolate);
730 InstallUnoptimizedCode(compilation_info, shared_info, isolate);
739 isolate, shared_info, coverage_info, job->time_taken_to_execute(),
782 IsolateT* isolate, Handle<SharedFunctionInfo> outer_shared_info,
789 DeclarationScope::AllocateScopeInfos(parse_info, isolate);
808 shared_info = Compiler::GetSharedFunctionInfo(literal, script, isolate);
816 isolate->AsLocalIsolate());
823 job.get(), shared_info, isolate,
830 *is_compiled_scope = shared_info->is_compiled_scope(isolate);
848 isolate, shared_info, std::move(job));
855 parse_info->pending_error_handler()->PrepareWarnings(isolate);
862 Isolate* isolate, Handle<Script> script,
867 DCHECK(AllowCompilation::IsAllowed(isolate));
878 job.job(), shared_info, isolate,
887 pending_error_handler->PrepareWarnings(isolate);
898 Isolate* isolate, Handle<JSFunction> function, BytecodeOffset osr_offset,
904 RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileGetFromOptimizedCodeMap);
910 shared, osr_offset, isolate);
929 CompilerTracer::TraceOptimizedCodeCacheHit(isolate, function, osr_offset,
931 return handle(code, isolate);
940 Isolate* isolate = function->GetIsolate();
941 Handle<CodeT> code = ToCodeT(compilation_info->code(), isolate);
947 Handle<SharedFunctionInfo> shared(function->shared(), isolate);
948 Handle<NativeContext> native_context(function->native_context(), isolate);
949 OSROptimizedCodeCache::Insert(isolate, native_context, shared, code,
972 bool PrepareJobWithHandleScope(OptimizedCompilationJob* job, Isolate* isolate,
974 CompilationHandleScope compilation(isolate, compilation_info);
975 CanonicalHandleScopeForTurbofan canonical(isolate, compilation_info);
976 CompilerTracer::TracePrepareJob(isolate, compilation_info,
978 compilation_info->ReopenHandlesInNewHandleScope(isolate);
979 return job->PrepareJob(isolate) == CompilationJob::SUCCEEDED;
982 bool CompileTurbofan_NotConcurrent(Isolate* isolate,
987 TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
988 RCS_SCOPE(isolate, RuntimeCallCounterId::kOptimizeNonConcurrent);
992 if (!PrepareJobWithHandleScope(job, isolate, compilation_info)) {
993 CompilerTracer::TraceAbortedJob(isolate, compilation_info);
999 ParkedScope parked_scope(isolate->main_thread_local_isolate());
1000 if (job->ExecuteJob(isolate->counters()->runtime_call_stats(),
1001 isolate->main_thread_local_isolate())) {
1002 UnparkedScope unparked_scope(isolate->main_thread_local_isolate());
1003 CompilerTracer::TraceAbortedJob(isolate, compilation_info);
1008 if (job->FinalizeJob(isolate) != CompilationJob::SUCCEEDED) {
1009 CompilerTracer::TraceAbortedJob(isolate, compilation_info);
1014 job->RecordCompilationStats(ConcurrencyMode::kSynchronous, isolate);
1015 DCHECK(!isolate->has_pending_exception());
1017 job->RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, isolate);
1021 bool CompileTurbofan_Concurrent(Isolate* isolate,
1027 if (!isolate->optimizing_compile_dispatcher()->IsQueueAvailable()) {
1036 if (isolate->heap()->HighMemoryPressure()) {
1045 TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
1046 RCS_SCOPE(isolate, RuntimeCallCounterId::kOptimizeConcurrentPrepare);
1050 if (!PrepareJobWithHandleScope(job.get(), isolate, compilation_info)) {
1055 isolate->optimizing_compile_dispatcher()->QueueForOptimization(job.release());
1090 MaybeHandle<CodeT> CompileTurbofan(Isolate* isolate,
1097 VMState<COMPILER> state(isolate);
1098 TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
1099 RCS_SCOPE(isolate, RuntimeCallCounterId::kOptimizeCode);
1102 DCHECK(!isolate->has_pending_exception());
1103 PostponeInterruptsScope postpone(isolate);
1109 compiler::Pipeline::NewCompilationJob(isolate, function,
1119 if (CompileTurbofan_Concurrent(isolate, std::move(job))) return {};
1122 if (CompileTurbofan_NotConcurrent(isolate, job.get())) {
1123 return ToCodeT(job->compilation_info()->code(), isolate);
1127 if (isolate->has_pending_exception()) isolate->clear_pending_exception();
1133 void RecordMaglevFunctionCompilation(Isolate* isolate,
1136 AbstractCode::cast(FromCodeT(function->code())), isolate);
1137 Handle<SharedFunctionInfo> shared(function->shared(), isolate);
1138 Handle<Script> script(Script::cast(shared->script()), isolate);
1139 Handle<FeedbackVector> feedback_vector(function->feedback_vector(), isolate);
1144 LogFunctionCompilation(isolate, CodeEventListener::FUNCTION_TAG, script,
1150 MaybeHandle<CodeT> CompileMaglev(Isolate* isolate, Handle<JSFunction> function,
1164 DCHECK(!isolate->has_pending_exception());
1165 PostponeInterruptsScope postpone(isolate);
1174 auto job = maglev::MaglevCompilationJob::New(isolate, function);
1175 CompilationJob::Status status = job->PrepareJob(isolate);
1183 ParkedScope parked_scope(isolate->main_thread_local_isolate());
1184 if (job->ExecuteJob(isolate->counters()->runtime_call_stats(),
1185 isolate->main_thread_local_isolate()) !=
1191 if (job->FinalizeJob(isolate) != CompilationJob::SUCCEEDED) {
1195 RecordMaglevFunctionCompilation(isolate, function);
1196 return handle(function->code(), isolate);
1202 isolate->maglev_concurrent_dispatcher()->EnqueueJob(std::move(job));
1214 Isolate* isolate, Handle<JSFunction> function, ConcurrencyMode mode,
1220 Handle<SharedFunctionInfo> shared(function->shared(), isolate);
1235 if (isolate->debug()->needs_check_on_function_call()) return {};
1247 PendingOptimizationTable::FunctionWasOptimized(isolate, function);
1251 if (OptimizedCodeCache::Get(isolate, function, osr_offset, code_kind)
1261 return CompileTurbofan(isolate, function, shared, mode, osr_offset,
1265 return CompileMaglev(isolate, function, mode, osr_offset, osr_frame,
1274 void SpawnDuplicateConcurrentJobForStressTesting(Isolate* isolate,
1282 isolate->concurrent_recompilation_enabled() && IsSynchronous(mode) &&
1283 isolate->node_observer() == nullptr);
1288 USE(GetOrCompileOptimized(isolate, function, ConcurrencyMode::kConcurrent,
1293 bool FailAndClearPendingException(Isolate* isolate) {
1294 isolate->clear_pending_exception();
1299 bool PreparePendingException(IsolateT* isolate, ParseInfo* parse_info) {
1302 isolate, parse_info->ast_value_factory());
1308 Isolate* isolate, Handle<Script> script,
1312 return FailAndClearPendingException(isolate);
1315 if (!isolate->has_pending_exception()) {
1317 pending_error_handler->ReportErrors(isolate, script);
1319 isolate->StackOverflow();
1325 bool FailWithPendingException(Isolate* isolate, Handle<Script> script,
1328 PreparePendingException(isolate, parse_info);
1330 isolate, script, parse_info->pending_error_handler(), flag);
1334 Isolate* isolate, Handle<Script> script,
1340 compile_state->pending_error_handler()->ReportWarnings(isolate, script);
1345 isolate->NeedsSourcePositionsForProfiling());
1352 IsCompiledScope is_compiled_scope(*shared_info, isolate);
1356 SharedFunctionInfo::EnsureSourcePositionsAvailable(isolate, shared_info);
1368 InstallInterpreterTrampolineCopy(isolate, shared_info, log_tag);
1372 isolate->debug()->InstallCoverageInfo(shared_info, coverage_info);
1375 LogUnoptimizedCompilation(isolate, shared_info, log_tag,
1382 Isolate* isolate, Handle<Script> script,
1387 FinalizeUnoptimizedCompilation(isolate, script, flags, compile_state,
1392 if (isolate->NeedsSourcePositionsForProfiling()) {
1393 Script::InitLineEnds(isolate, script);
1397 void CompileAllWithBaseline(Isolate* isolate,
1400 CodePageCollectionMemoryModificationScope code_allocation(isolate->heap());
1403 IsCompiledScope is_compiled_scope(*shared_info, isolate);
1405 if (!CanCompileWithBaseline(isolate, *shared_info)) continue;
1407 isolate, shared_info, Compiler::CLEAR_EXCEPTION, &is_compiled_scope);
1415 ParseInfo* parse_info, Handle<Script> script, IsolateT* isolate) {
1416 EnsureSharedFunctionInfosArrayOnScript(script, parse_info, isolate);
1419 return isolate->factory()->NewSharedFunctionInfoForLiteral(
1425 MaybeHandle<ScopeInfo> maybe_outer_scope_info, Isolate* isolate,
1427 TimerEventScope<TimerEventCompileCode> top_level_timer(isolate);
1429 DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
1431 PostponeInterruptsScope postpone(isolate);
1432 DCHECK(!isolate->native_context().is_null());
1433 RCS_SCOPE(isolate, parse_info->flags().is_eval()
1436 VMState<BYTECODE_COMPILER> state(isolate);
1439 isolate, parsing::ReportStatisticsMode::kYes)) {
1440 FailWithPendingException(isolate, script, parse_info,
1448 ? isolate->counters()->compile_eval()
1449 : isolate->counters()->compile();
1456 CreateTopLevelSharedFunctionInfo(parse_info, script, isolate);
1463 isolate, shared_info, script, parse_info, isolate->allocator(),
1466 FailWithPendingException(isolate, script, parse_info,
1475 isolate, script, parse_info->flags(), parse_info->state(),
1479 CompileAllWithBaseline(isolate, finalize_unoptimized_compilation_data_list);
1504 LocalIsolate* isolate, Handle<SharedFunctionInfo> function_handle,
1510 function_handle_(isolate->heap()->NewPersistentHandle(function_handle)),
1511 coverage_info_(isolate->heap()->NewPersistentMaybeHandle(coverage_info)) {
1515 LocalIsolate* isolate, Handle<SharedFunctionInfo> function_handle,
1517 : function_handle_(isolate->heap()->NewPersistentHandle(function_handle)),
1521 Isolate* isolate, ScriptType type)
1522 : isolate_for_local_isolate_(isolate),
1524 isolate, true, construct_language_mode(FLAG_use_strict),
1530 isolate->counters()->worker_thread_runtime_call_stats()),
1531 timer_(isolate->counters()->compile_script_on_background()),
1535 VMState<PARSER> state(isolate);
1537 LOG(isolate, ScriptEvent(Logger::ScriptEventType::kStreamingCompile,
1542 Isolate* isolate, Handle<SharedFunctionInfo> shared_info,
1546 : isolate_for_local_isolate_(isolate),
1550 UnoptimizedCompileFlags::ForFunctionCompile(isolate, *shared_info)),
1565 persistent_handles_ = std::make_unique<PersistentHandles>(isolate);
1573 void SetScriptFieldsFromDetails(Isolate* isolate, Script script,
1588 script.source_mapping_url(isolate).IsUndefined(isolate)) {
1604 LocalIsolate isolate(isolate_for_local_isolate_, ThreadKind::kBackground);
1605 UnparkedScope unparked_scope(&isolate);
1606 LocalHandleScope handle_scope(&isolate);
1608 ReusableUnoptimizedCompileState reusable_state(&isolate);
1610 Run(&isolate, &reusable_state);
1613 void BackgroundCompileTask::RunOnMainThread(Isolate* isolate) {
1614 LocalHandleScope handle_scope(isolate->main_thread_local_isolate());
1615 ReusableUnoptimizedCompileState reusable_state(isolate);
1616 Run(isolate->main_thread_local_isolate(), &reusable_state);
1620 LocalIsolate* isolate, ReusableUnoptimizedCompileState* reusable_state) {
1625 RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileCompileTask,
1630 ParseInfo info(isolate, flags_, &compile_state_, reusable_state,
1641 isolate, isolate->factory()->empty_string(), kNullMaybeHandle,
1643 script_ = isolate->heap()->NewPersistentHandle(script);
1646 isolate->heap()->AttachPersistentHandles(std::move(persistent_handles_));
1649 script_ = isolate->heap()->NewPersistentHandle(
1654 SharedStringAccessGuardIfNeeded access_guard(isolate);
1662 isolate, handle(shared_info->uncompiled_data_with_preparse_data()
1663 .preparse_data(isolate),
1664 isolate)));
1673 Parser parser(isolate, &info, script_);
1685 handle(shared_info->GetOuterScopeInfo(), isolate);
1688 isolate, &info, maybe_outer_scope_info,
1692 parser.ParseOnBackground(isolate, &info, start_position_, end_position_,
1698 RCS_SCOPE(isolate, RuntimeCallCounterIdForCompile(&info),
1705 shared_info = CreateTopLevelSharedFunctionInfo(&info, script_, isolate);
1708 shared_info = isolate->factory()->CloneSharedFunctionInfo(
1713 isolate, shared_info, script_, &info, reusable_state->allocator(),
1721 PreparePendingException(isolate, &info);
1724 outer_function_sfi_ = isolate->heap()->NewPersistentMaybeHandle(maybe_result);
1725 DCHECK(isolate->heap()->ContainsPersistentHandle(script_.location()));
1726 persistent_handles_ = isolate->heap()->DetachPersistentHandles();
1730 Isolate* isolate, Handle<String> source,
1742 isolate, script_, &jobs_to_retry_finalization_on_main_thread_,
1752 Handle<WeakArrayList> scripts = isolate->factory()->script_list();
1754 WeakArrayList::Append(isolate, scripts, MaybeObjectHandle::Weak(script_));
1755 isolate->heap()->SetRootScriptList(*scripts);
1761 SetScriptFieldsFromDetails(isolate, *script_, script_details, &no_gc);
1762 LOG(isolate, ScriptDetails(*script_));
1765 ReportStatistics(isolate);
1769 FailWithPreparedPendingException(isolate, script_,
1774 FinalizeUnoptimizedScriptCompilation(isolate, script_, flags_,
1778 return handle(*result, isolate);
1782 Isolate* isolate, Compiler::ClearExceptionFlag flag) {
1798 isolate, script_, &jobs_to_retry_finalization_on_main_thread_,
1804 ReportStatistics(isolate);
1809 isolate, script_, compile_state_.pending_error_handler(), flag);
1813 FinalizeUnoptimizedCompilation(isolate, script_, flags_, &compile_state_,
1830 void BackgroundCompileTask::ReportStatistics(Isolate* isolate) {
1833 isolate->CountUsage(feature);
1836 isolate->counters()->total_preparse_skipped()->Increment(
1842 Isolate* isolate, std::unique_ptr<ScriptCompiler::CachedData> cached_data)
1843 : isolate_for_local_isolate_(isolate),
1855 LocalIsolate isolate(isolate_for_local_isolate_, ThreadKind::kBackground);
1856 UnparkedScope unparked_scope(&isolate);
1857 LocalHandleScope handle_scope(&isolate);
1861 CodeSerializer::StartDeserializeOffThread(&isolate, &cached_data_);
1865 Isolate* isolate, Handle<String> source,
1868 isolate, std::move(off_thread_data_), &cached_data_, source,
1876 bool Compiler::CollectSourcePositions(Isolate* isolate,
1880 DCHECK(!shared_info->GetBytecodeArray(isolate).HasSourcePositionTable());
1883 NullContextScope null_context_scope(isolate);
1890 handle(shared_info->GetBytecodeArray(isolate), isolate);
1896 if (GetCurrentStackPosition() < isolate->stack_guard()->real_climit()) {
1904 if (Script::cast(shared_info->script()).IsMaybeUnfinalized(isolate)) {
1909 DCHECK(AllowCompilation::IsAllowed(isolate));
1910 DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
1911 DCHECK(!isolate->has_pending_exception());
1912 VMState<BYTECODE_COMPILER> state(isolate);
1913 PostponeInterruptsScope postpone(isolate);
1914 RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileCollectSourcePositions);
1918 isolate->counters()->collect_source_positions());
1922 UnoptimizedCompileFlags::ForFunctionCompile(isolate, *shared_info);
1929 ReusableUnoptimizedCompileState reusable_state(isolate);
1930 ParseInfo parse_info(isolate, flags, &compile_state, &reusable_state);
1934 if (!parsing::ParseAny(&parse_info, shared_info, isolate,
1938 return FailAndClearPendingException(isolate);
1950 &parse_info, parse_info.literal(), bytecode, isolate->allocator(),
1951 isolate->main_thread_local_isolate());
1954 job->FinalizeJob(shared_info, isolate) != CompilationJob::SUCCEEDED) {
1957 return FailAndClearPendingException(isolate);
1973 DCHECK(!isolate->has_pending_exception());
1974 DCHECK(shared_info->is_compiled_scope(isolate).is_compiled());
1979 bool Compiler::Compile(Isolate* isolate, Handle<SharedFunctionInfo> shared_info,
1986 DCHECK(AllowCompilation::IsAllowed(isolate));
1987 DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
1988 DCHECK(!isolate->has_pending_exception());
1991 VMState<BYTECODE_COMPILER> state(isolate);
1992 PostponeInterruptsScope postpone(isolate);
1993 TimerEventScope<TimerEventCompileCode> compile_timer(isolate);
1994 RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileFunction);
1996 AggregatedHistogramTimerScope timer(isolate->counters()->compile_lazy());
1998 Handle<Script> script(Script::cast(shared_info->script()), isolate);
2002 UnoptimizedCompileFlags::ForFunctionCompile(isolate, *shared_info);
2008 ReusableUnoptimizedCompileState reusable_state(isolate);
2009 ParseInfo parse_info(isolate, flags, &compile_state, &reusable_state);
2012 LazyCompileDispatcher* dispatcher = isolate->lazy_compile_dispatcher();
2015 return FailWithPendingException(isolate, script, &parse_info, flag);
2017 *is_compiled_scope = shared_info->is_compiled_scope(isolate);
2024 isolate,
2027 isolate)));
2031 if (!parsing::ParseAny(&parse_info, shared_info, isolate,
2033 return FailWithPendingException(isolate, script, &parse_info, flag);
2041 isolate, shared_info, script, &parse_info, isolate->allocator(),
2044 return FailWithPendingException(isolate, script, &parse_info, flag);
2047 FinalizeUnoptimizedCompilation(isolate, script, flags, &compile_state,
2051 CompileAllWithBaseline(isolate, finalize_unoptimized_compilation_data_list);
2054 DCHECK(!isolate->has_pending_exception());
2060 bool Compiler::Compile(Isolate* isolate, Handle<JSFunction> function,
2073 Handle<SharedFunctionInfo> shared_info = handle(function->shared(), isolate);
2076 *is_compiled_scope = shared_info->is_compiled_scope(isolate);
2078 !Compile(isolate, shared_info, flag, is_compiled_scope)) {
2083 Handle<CodeT> code = handle(shared_info->GetCode(), isolate);
2099 CompilerTracer::TraceOptimizeForAlwaysOpt(isolate, function,
2106 isolate->concurrent_recompilation_enabled() &&
2107 isolate->node_observer() == nullptr) {
2108 SpawnDuplicateConcurrentJobForStressTesting(isolate, function,
2113 if (GetOrCompileOptimized(isolate, function, concurrency_mode, code_kind)
2124 JSFunction::EnsureFeedbackVector(isolate, function, is_compiled_scope);
2128 DCHECK(!isolate->has_pending_exception());
2135 bool Compiler::CompileSharedWithBaseline(Isolate* isolate,
2146 if (!CanCompileWithBaseline(isolate, *shared)) return false;
2148 StackLimitCheck check(isolate);
2151 isolate->StackOverflow();
2156 CompilerTracer::TraceStartBaselineCompile(isolate, shared);
2161 if (!GenerateBaselineCode(isolate, shared).ToHandle(&code)) {
2169 shared->GetBytecodeArray(isolate).RequestOsrAtNextOpportunity();
2174 CompilerTracer::TraceFinishBaselineCompile(isolate, shared, time_taken_ms);
2177 LogFunctionCompilation(isolate, CodeEventListener::FUNCTION_TAG,
2178 handle(Script::cast(shared->script()), isolate),
2187 bool Compiler::CompileBaseline(Isolate* isolate, Handle<JSFunction> function,
2190 Handle<SharedFunctionInfo> shared(function->shared(isolate), isolate);
2191 if (!CompileSharedWithBaseline(isolate, shared, flag, is_compiled_scope)) {
2196 JSFunction::EnsureFeedbackVector(isolate, function, is_compiled_scope);
2206 bool Compiler::CompileMaglev(Isolate* isolate, Handle<JSFunction> function,
2216 JSFunction::EnsureFeedbackVector(isolate, function, is_compiled_scope);
2218 MaybeHandle<CodeT> maybe_code = Maglev::Compile(isolate, function);
2233 ParseInfo* parse_info, Handle<Script> script, Isolate* isolate,
2236 isolate, is_compiled_scope);
2241 Isolate* isolate,
2245 RCS_SCOPE(isolate,
2248 HandleScope scope(isolate);
2250 if (!task->FinalizeFunction(isolate, flag)) return false;
2252 DCHECK(!isolate->has_pending_exception());
2257 void Compiler::CompileOptimized(Isolate* isolate, Handle<JSFunction> function,
2260 DCHECK(AllowCompilation::IsAllowed(isolate));
2263 isolate->concurrent_recompilation_enabled() && IsSynchronous(mode) &&
2264 isolate->node_observer() == nullptr) {
2265 SpawnDuplicateConcurrentJobForStressTesting(isolate, function, mode,
2270 if (GetOrCompileOptimized(isolate, function, mode, code_kind)
2276 DCHECK(!isolate->has_pending_exception());
2288 ParseInfo* parse_info, Handle<Script> script, Isolate* isolate) {
2290 return Compiler::CompileToplevel(parse_info, script, isolate,
2301 Isolate* isolate = context->GetIsolate();
2303 isolate->counters()->total_eval_size()->Increment(source_length);
2304 isolate->counters()->total_compile_size()->Increment(source_length);
2321 CompilationCache* compilation_cache = isolate->compilation_cache();
2326 feedback_cell = handle(eval_result.feedback_cell(), isolate);
2334 shared_info = Handle<SharedFunctionInfo>(eval_result.shared(), isolate);
2335 script = Handle<Script>(Script::cast(shared_info->script()), isolate);
2336 is_compiled_scope = shared_info->is_compiled_scope(isolate);
2340 isolate, true, language_mode, REPLMode::kNo, ScriptType::kClassic,
2348 ReusableUnoptimizedCompileState reusable_state(isolate);
2349 ParseInfo parse_info(isolate, flags, &compile_state, &reusable_state);
2354 maybe_outer_scope_info = handle(context->scope_info(), isolate);
2357 isolate, source, kNullMaybeHandle,
2364 StackTraceFrameIterator it(isolate);
2379 maybe_outer_scope_info, isolate,
2393 result = Factory::JSFunctionBuilder{isolate, shared_info, context}
2398 result = Factory::JSFunctionBuilder{isolate, shared_info, context}
2407 isolate);
2413 result = Factory::JSFunctionBuilder{isolate, shared_info, context}
2423 isolate);
2435 bool CodeGenerationFromStringsAllowed(Isolate* isolate, Handle<Context> context,
2437 RCS_SCOPE(isolate, RuntimeCallCounterId::kCodeGenerationFromStringsCallbacks);
2438 DCHECK(context->allow_code_gen_from_strings().IsFalse(isolate));
2439 DCHECK(isolate->allow_code_gen_callback());
2441 isolate->allow_code_gen_callback();
2442 ExternalCallbackScope external_callback(isolate,
2451 bool ModifyCodeGenerationFromStrings(Isolate* isolate, Handle<Context> context,
2454 DCHECK(isolate->modify_code_gen_callback() ||
2455 isolate->modify_code_gen_callback2());
2460 VMState<EXTERNAL> state(isolate);
2461 RCS_SCOPE(isolate, RuntimeCallCounterId::kCodeGenerationFromStringsCallbacks);
2463 isolate->modify_code_gen_callback()
2464 ? isolate->modify_code_gen_callback()(v8::Utils::ToLocal(context),
2466 : isolate->modify_code_gen_callback2()(v8::Utils::ToLocal(context),
2493 Isolate* isolate, Handle<Context> context,
2499 if (!context->allow_code_gen_from_strings().IsFalse(isolate) &&
2507 if (isolate->allow_code_gen_callback()) {
2511 DCHECK(!original_source->IsCodeLike(isolate));
2517 if (!CodeGenerationFromStringsAllowed(isolate, context, string_source)) {
2526 if (isolate->modify_code_gen_callback() ||
2527 isolate->modify_code_gen_callback2()) {
2529 if (!ModifyCodeGenerationFromStrings(isolate, context, &modified_source,
2539 if (!context->allow_code_gen_from_strings().IsFalse(isolate) &&
2540 original_source->IsCodeLike(isolate)) {
2544 Object::ToString(isolate, original_source);
2557 Isolate* const isolate = context->GetIsolate();
2558 Handle<Context> native_context(context->native_context(), isolate);
2565 isolate,
2574 native_context->empty_function().shared(), isolate);
2585 Isolate* const isolate = context->GetIsolate();
2587 ValidateDynamicCompilationSource(isolate, context, source, is_code_like)
2598 // figure out a way to push produce/hit-isolate-cache/consume/consume-failed
2626 Isolate* isolate, ScriptCompiler::NoCacheReason no_cache_reason)
2627 : isolate_(isolate),
2628 all_scripts_histogram_scope_(isolate->counters()->compile_script()),
2743 // Even if we hit the isolate's compilation cache, we currently recompile
2796 Isolate* isolate, ParseInfo* parse_info, Handle<String> source,
2801 parse_info->CreateScript(isolate, source, maybe_wrapped_arguments,
2804 SetScriptFieldsFromDetails(isolate, *script, script_details, &no_gc);
2805 LOG(isolate, ScriptDetails(*script));
2812 v8::Extension* extension, Isolate* isolate,
2815 ReusableUnoptimizedCompileState reusable_state(isolate);
2816 ParseInfo parse_info(isolate, flags, &compile_state, &reusable_state);
2820 NewScript(isolate, &parse_info, source, script_details, natives);
2825 return Compiler::CompileToplevel(&parse_info, script, isolate,
2831 StressBackgroundCompileThread(Isolate* isolate, Handle<String> source,
2836 streamed_source_(std::make_unique<SourceStream>(source, isolate),
2839 std::make_unique<i::BackgroundCompileTask>(data(), isolate, type);
2851 SourceStream(Handle<String> source, Isolate* isolate) : done_(false) {
2888 bool CompilationExceptionIsRangeError(Isolate* isolate, Handle<Object> obj) {
2889 if (!obj->IsJSError(isolate)) return false;
2892 if (!JSReceiver::GetConstructor(isolate, js_obj).ToHandle(&constructor)) {
2895 return *constructor == *isolate->range_error_function();
2900 Isolate* isolate, IsCompiledScope* is_compiled_scope) {
2903 isolate, source,
2920 TryCatch ignore_try_catch(reinterpret_cast<v8::Isolate*>(isolate));
2923 flags_copy, source, script_details, NOT_NATIVES_CODE, nullptr, isolate,
2928 isolate, handle(isolate->pending_exception(), isolate));
2929 isolate->clear_pending_exception();
2935 ParkedScope scope(isolate->main_thread_local_isolate());
2941 isolate, source, script_details, background_compile_thread.data());
2958 *is_compiled_scope = result->is_compiled_scope(isolate);
2965 Isolate* isolate, Handle<String> source,
2970 ScriptCompileTimerScope compile_timer(isolate, no_cache_reason);
2984 isolate->counters()->total_load_size()->Increment(source_length);
2985 isolate->counters()->total_compile_size()->Increment(source_length);
3006 isolate, source, script_details.name_obj);
3011 CompilationCache* compilation_cache = isolate->compilation_cache();
3026 // First check per-isolate compilation cache.
3035 isolate->counters()->compile_deserialize());
3036 RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileDeserialize);
3041 maybe_result = deserialize_task->Finish(isolate, source,
3045 isolate, cached_data, source, script_details.origin_options);
3051 is_compiled_scope = result->is_compiled_scope(isolate);
3054 // Promote to per-isolate compilation cache.
3073 source, script_details, isolate, &is_compiled_scope);
3077 isolate, natives == NOT_NATIVES_CODE, language_mode,
3087 extension, isolate, &is_compiled_scope);
3090 // Add the result to the isolate cache.
3096 isolate->ReportPendingMessages();
3106 Isolate* isolate, Handle<String> source,
3111 isolate, source, script_details, nullptr, nullptr, nullptr,
3117 Isolate* isolate, Handle<String> source,
3121 isolate, source, script_details, extension, nullptr, nullptr,
3127 Isolate* isolate, Handle<String> source,
3132 isolate, source, script_details, nullptr, cached_data, nullptr,
3138 Isolate* isolate, Handle<String> source,
3144 isolate, source, script_details, nullptr, nullptr, deserialize_task,
3155 Isolate* isolate = context->GetIsolate();
3156 ScriptCompileTimerScope compile_timer(isolate, no_cache_reason);
3167 isolate->counters()->total_compile_size()->Increment(source_length);
3177 NestedTimedHistogramScope timer(isolate->counters()->compile_deserialize());
3178 RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileDeserialize);
3181 maybe_result = CodeSerializer::Deserialize(isolate, cached_data, source,
3194 isolate, true, language_mode, script_details.repl_mode,
3205 ReusableUnoptimizedCompileState reusable_state(isolate);
3206 ParseInfo parse_info(isolate, flags, &compile_state, &reusable_state);
3210 maybe_outer_scope_info = handle(context->scope_info(), isolate);
3213 script = NewScript(isolate, &parse_info, source, script_details,
3219 isolate, &is_compiled_scope);
3220 if (maybe_result.is_null()) isolate->ReportPendingMessages();
3221 ASSIGN_RETURN_ON_EXCEPTION(isolate, top_level, maybe_result, JSFunction);
3223 SharedFunctionInfo::ScriptIterator infos(isolate, *script);
3227 wrapped = Handle<SharedFunctionInfo>(info, isolate);
3233 is_compiled_scope = wrapped->is_compiled_scope(isolate);
3234 script = Handle<Script>(Script::cast(wrapped->script()), isolate);
3238 return Factory::JSFunctionBuilder{isolate, wrapped, context}
3246 Isolate* isolate, Handle<String> source,
3251 isolate, ScriptCompiler::kNoCacheBecauseStreamingSource);
3252 PostponeInterruptsScope postpone(isolate);
3255 isolate->counters()->total_load_size()->Increment(source_length);
3256 isolate->counters()->total_compile_size()->Increment(source_length);
3263 CompilationCache* compilation_cache = isolate->compilation_cache();
3276 // the isolate cache.
3277 RCS_SCOPE(isolate,
3282 maybe_result = task->FinalizeScript(isolate, source, script_details);
3286 // Add compiled code to the isolate cache.
3302 Isolate* isolate, Handle<String> source,
3307 isolate->factory()->NewWeakFixedArray(1, AllocationType::kOld);
3308 Handle<Script> script = isolate->factory()->NewScript(source);
3315 script->set_name(*isolate->factory()->empty_string());
3319 isolate->factory()->NewSharedFunctionInfoForWebSnapshot();
3320 shared->SetScript(isolate->factory()->read_only_roots(), *script, 0, false);
3327 FunctionLiteral* literal, Handle<Script> script, IsolateT* isolate) {
3332 maybe_existing = Script::FindSharedFunctionInfo(script, isolate, literal);
3343 handle(existing->uncompiled_data(), isolate);
3351 handle(existing_uncompiled_data->inferred_name(), isolate);
3353 literal->produced_preparse_data()->Serialize(isolate);
3355 isolate->factory()->NewUncompiledDataWithPreparseData(
3365 isolate->factory()->NewSharedFunctionInfoForLiteral(literal, script,
3371 FunctionLiteral* literal, Handle<Script> script, Isolate* isolate);
3373 FunctionLiteral* literal, Handle<Script> script, LocalIsolate* isolate);
3376 MaybeHandle<CodeT> Compiler::CompileOptimizedOSR(Isolate* isolate,
3384 if (V8_UNLIKELY(isolate->serializer_enabled())) return {};
3408 Handle<BytecodeArray> bytecode(frame->GetBytecodeArray(), isolate);
3411 CompilerTracer::TraceOptimizeOSR(isolate, function, osr_offset, mode);
3413 isolate, function, mode, CodeKind::TURBOFAN, osr_offset, frame);
3416 CompilerTracer::TraceOptimizeOSRUnavailable(isolate, function, osr_offset,
3435 Isolate* isolate) {
3436 VMState<COMPILER> state(isolate);
3439 TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
3440 RCS_SCOPE(isolate, RuntimeCallCounterId::kOptimizeConcurrentFinalize);
3464 } else if (job->FinalizeJob(isolate) == CompilationJob::SUCCEEDED) {
3465 job->RecordCompilationStats(ConcurrencyMode::kConcurrent, isolate);
3467 isolate);
3471 CompilerTracer::TraceCompletedJob(isolate, compilation_info);
3474 PrintF(CodeTracer::Scope{isolate->GetCodeTracer()}.file(),
3478 shared->GetBytecodeArray(isolate).set_osr_install_target(osr_offset);
3488 CompilerTracer::TraceAbortedJob(isolate, compilation_info);
3500 Isolate* isolate) {
3502 VMState<COMPILER> state(isolate);
3503 RecordMaglevFunctionCompilation(isolate, job->function());
3510 Isolate* isolate = function->GetIsolate();
3511 Handle<SharedFunctionInfo> shared(function->shared(), isolate);
3512 IsCompiledScope is_compiled_scope(shared->is_compiled_scope(isolate));
3545 CompilerTracer::TraceMarkForAlwaysOpt(isolate, function);
3546 JSFunction::EnsureFeedbackVector(isolate, function, &is_compiled_scope);
3547 function->MarkForOptimization(isolate, CodeKind::TURBOFAN,
3554 Handle<Script> script(Script::cast(shared->script()), isolate);
3555 isolate->debug()->OnAfterCompile(script);