public:

static void TraceStartBaselineCompile(

Isolate* isolate, DirectHandle<SharedFunctionInfo> shared) {

if (!v8_flags.trace_baseline) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "compiling method", shared, CodeKind::BASELINE);

PrintTraceSuffix(scope);

}

static void TraceStartMaglevCompile(Isolate* isolate,

DirectHandle<JSFunction> function,

bool osr, ConcurrencyMode mode) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "compiling method", function, CodeKind::MAGLEV);

if (osr) PrintF(scope.file(), " OSR");

PrintF(scope.file(), ", mode: %s", ToString(mode));

PrintTraceSuffix(scope);

}

static void TracePrepareJob(Isolate* isolate, OptimizedCompilationInfo* info,

ConcurrencyMode mode) {

if (!v8_flags.trace_opt || !info->IsOptimizing()) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "compiling method", info);

if (info->is_osr()) PrintF(scope.file(), " OSR");

PrintF(scope.file(), ", mode: %s", ToString(mode));

PrintTraceSuffix(scope);

}

static void TraceOptimizeOSRStarted(Isolate* isolate,

DirectHandle<JSFunction> function,

BytecodeOffset osr_offset,

ConcurrencyMode mode) {

if (!v8_flags.trace_osr) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintF(

scope.file(),

"[OSR - compilation started. function: %s, osr offset: %d, mode: %s]\n",

function->DebugNameCStr().get(), osr_offset.ToInt(), ToString(mode));

}

static void TraceOptimizeOSRFinished(Isolate* isolate,

DirectHandle<JSFunction> function,

BytecodeOffset osr_offset) {

if (!v8_flags.trace_osr) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintF(scope.file(),

"[OSR - compilation finished. function: %s, osr offset: %d]\n",

function->DebugNameCStr().get(), osr_offset.ToInt());

}

static void TraceOptimizeOSRAvailable(Isolate* isolate,

DirectHandle<JSFunction> function,

BytecodeOffset osr_offset,

ConcurrencyMode mode) {

if (!v8_flags.trace_osr) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintF(scope.file(),

"[OSR - available (compilation completed or cache hit). function: "

"%s, osr offset: %d, mode: %s]\n",

function->DebugNameCStr().get(), osr_offset.ToInt(), ToString(mode));

}

static void TraceOptimizeOSRUnavailable(Isolate* isolate,

DirectHandle<JSFunction> function,

BytecodeOffset osr_offset,

ConcurrencyMode mode) {

if (!v8_flags.trace_osr) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintF(scope.file(),

"[OSR - unavailable (failed or in progress). function: %s, osr "

"offset: %d, mode: %s]\n",

function->DebugNameCStr().get(), osr_offset.ToInt(), ToString(mode));

}

static void TraceFinishTurbofanCompile(Isolate* isolate,

OptimizedCompilationInfo* info,

double ms_creategraph,

double ms_optimize,

double ms_codegen) {

DCHECK(v8_flags.trace_opt);

DCHECK(info->IsOptimizing());

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "completed compiling", info);

if (info->is_osr()) PrintF(scope.file(), " OSR");

PrintF(scope.file(), " - took %0.3f, %0.3f, %0.3f ms", ms_creategraph,

ms_optimize, ms_codegen);

PrintTraceSuffix(scope);

}

static void TraceFinishBaselineCompile(

Isolate* isolate, DirectHandle<SharedFunctionInfo> shared,

double ms_timetaken) {

if (!v8_flags.trace_baseline) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "completed compiling", shared, CodeKind::BASELINE);

PrintF(scope.file(), " - took %0.3f ms", ms_timetaken);

PrintTraceSuffix(scope);

}

static void TraceFinishMaglevCompile(Isolate* isolate,

DirectHandle<JSFunction> function,

bool osr, double ms_prepare,

double ms_execute, double ms_finalize) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "completed compiling", function, CodeKind::MAGLEV);

if (osr) PrintF(scope.file(), " OSR");

PrintF(scope.file(), " - took %0.3f, %0.3f, %0.3f ms", ms_prepare,

ms_execute, ms_finalize);

PrintTraceSuffix(scope);

}

static void TraceAbortedMaglevCompile(Isolate* isolate,

DirectHandle<JSFunction> function,

BailoutReason bailout_reason) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "aborted compiling", function, CodeKind::MAGLEV);

PrintF(scope.file(), " because: %s", GetBailoutReason(bailout_reason));

PrintTraceSuffix(scope);

}

static void TraceCompletedJob(Isolate* isolate,

OptimizedCompilationInfo* info) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "completed optimizing", info);

if (info->is_osr()) PrintF(scope.file(), " OSR");

PrintTraceSuffix(scope);

}

static void TraceAbortedJob(Isolate* isolate, OptimizedCompilationInfo* info,

double ms_prepare, double ms_execute,

double ms_finalize) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "aborted optimizing", info);

if (info->is_osr()) PrintF(scope.file(), " OSR");

PrintF(scope.file(), " because: %s",

GetBailoutReason(info->bailout_reason()));

PrintF(scope.file(), " - took %0.3f, %0.3f, %0.3f ms", ms_prepare,

ms_execute, ms_finalize);

PrintTraceSuffix(scope);

}

static void TraceOptimizedCodeCacheHit(Isolate* isolate,

DirectHandle<JSFunction> function,

BytecodeOffset osr_offset,

CodeKind code_kind) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "found optimized code for", function, code_kind);

if (IsOSR(osr_offset)) {

PrintF(scope.file(), " at OSR bytecode offset %d", osr_offset.ToInt());

}

PrintTraceSuffix(scope);

}

static void TraceOptimizeForAlwaysOpt(Isolate* isolate,

DirectHandle<JSFunction> function,

CodeKind code_kind) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintTracePrefix(scope, "optimizing", function, code_kind);

PrintF(scope.file(), " because --always-turbofan");

PrintTraceSuffix(scope);

}

static void TraceMarkForAlwaysOpt(Isolate* isolate,

DirectHandle<JSFunction> function) {

if (!v8_flags.trace_opt) return;

CodeTracer::Scope scope(isolate->GetCodeTracer());

PrintF(scope.file(), "[marking ");

ShortPrint(*function, scope.file());

PrintF(scope.file(),

" for optimized recompilation because --always-turbofan");

PrintF(scope.file(), "]\n");

}

private:

static void PrintTracePrefix(const CodeTracer::Scope& scope,

const char* header,

OptimizedCompilationInfo* info) {

PrintTracePrefix(scope, header, info->closure(), info->code_kind());

}

static void PrintTracePrefix(const CodeTracer::Scope& scope,

const char* header,

DirectHandle<JSFunction> function,

CodeKind code_kind) {

PrintF(scope.file(), "[%s ", header);

ShortPrint(*function, scope.file());

PrintF(scope.file(), " (target %s)", CodeKindToString(code_kind));

}

static void PrintTracePrefix(const CodeTracer::Scope& scope,

const char* header,

DirectHandle<SharedFunctionInfo> shared,

CodeKind code_kind) {

PrintF(scope.file(), "[%s ", header);

ShortPrint(*shared, scope.file());

PrintF(scope.file(), " (target %s)", CodeKindToString(code_kind));

}

static void PrintTraceSuffix(const CodeTracer::Scope& scope) {

PrintF(scope.file(), "]\n");

}

LogEventListener::CodeTag code_type,

DirectHandle<Script> script,

DirectHandle<SharedFunctionInfo> shared,

DirectHandle<FeedbackVector> vector,

DirectHandle<AbstractCode> abstract_code,

CodeKind kind, double time_taken_ms) {

DCHECK_NE(*abstract_code,

Cast<AbstractCode>(*BUILTIN_CODE(isolate, CompileLazy)));

// Log the code generation. If source information is available include

// script name and line number. Check explicitly whether logging is

// enabled as finding the line number is not free.

if (!isolate->IsLoggingCodeCreation()) return;

Script::PositionInfo info;

Script::GetPositionInfo(script, shared->StartPosition(), &info);

int line_num = info.line + 1;

int column_num = info.column + 1;

DirectHandle<String> script_name(IsString(script->name())

? Cast<String>(script->name())

: ReadOnlyRoots(isolate).empty_string(),

isolate);

LogEventListener::CodeTag log_tag =

V8FileLogger::ToNativeByScript(code_type, *script);

PROFILE(isolate, CodeCreateEvent(log_tag, abstract_code, shared, script_name,

line_num, column_num));

if (!vector.is_null()) {

LOG(isolate, FeedbackVectorEvent(*vector, *abstract_code));

}

if (!v8_flags.log_function_events) return;

std::string name;

switch (kind) {

case CodeKind::INTERPRETED_FUNCTION:

name = "interpreter";

break;

case CodeKind::BASELINE:

name = "baseline";

break;

case CodeKind::MAGLEV:

name = "maglev";

break;

case CodeKind::TURBOFAN_JS:

name = "turbofan";

break;

default:

UNREACHABLE();

}

switch (code_type) {

case LogEventListener::CodeTag::kEval:

name += "-eval";

break;

case LogEventListener::CodeTag::kScript:

case LogEventListener::CodeTag::kFunction:

break;

default:

UNREACHABLE();

}

DirectHandle<String> debug_name =

SharedFunctionInfo::DebugName(isolate, shared);

DisallowGarbageCollection no_gc;

LOG(isolate, FunctionEvent(name.c_str(), script->id(), time_taken_ms,

shared->StartPosition(), shared->EndPosition(),

*debug_name));

Tagged<Object> script, ParsingWhileDebugging parsing_while_debugging) {

bool is_shared_cross_origin =

parsing_while_debugging == ParsingWhileDebugging::kYes;

bool is_opaque = false;

if (IsScript(script)) {

auto script_origin_options = Cast<Script>(script)->origin_options();

if (script_origin_options.IsSharedCrossOrigin()) {

is_shared_cross_origin = true;

}

if (script_origin_options.IsOpaque()) {

is_opaque = true;

}

}

return ScriptOriginOptions(is_shared_cross_origin, is_opaque);

// Delegate to the underlying implementation.

DCHECK_EQ(state(), State::kReadyToExecute);

base::ScopedTimer t(v8_flags.log_function_events ? &time_taken_to_execute_

: nullptr);

return UpdateState(ExecuteJobImpl(), State::kReadyToFinalize);

DirectHandle<SharedFunctionInfo> shared_info, Isolate* isolate) {

DCHECK_EQ(ThreadId::Current(), isolate->thread_id());

DisallowCodeDependencyChange no_dependency_change;

DisallowJavascriptExecution no_js(isolate);

// Delegate to the underlying implementation.

DCHECK_EQ(state(), State::kReadyToFinalize);

base::ScopedTimer t(v8_flags.log_function_events ? &time_taken_to_finalize_

: nullptr);

return UpdateState(FinalizeJobImpl(shared_info, isolate), State::kSucceeded);

DirectHandle<SharedFunctionInfo> shared_info, LocalIsolate* isolate) {

// Delegate to the underlying implementation.

DCHECK_EQ(state(), State::kReadyToFinalize);

base::ScopedTimer t(v8_flags.log_function_events ? &time_taken_to_finalize_

: nullptr);

return UpdateState(FinalizeJobImpl(shared_info, isolate), State::kSucceeded);

DirectHandle<SharedFunctionInfo> shared,

LogEventListener::CodeTag code_type,

base::TimeDelta time_taken_to_execute,

base::TimeDelta time_taken_to_finalize) {

DirectHandle<AbstractCode> abstract_code;

if (shared->HasBytecodeArray()) {

abstract_code = direct_handle(

Cast<AbstractCode>(shared->GetBytecodeArray(isolate)), isolate);

} else {

#if V8_ENABLE_WEBASSEMBLY

DCHECK(shared->HasAsmWasmData());

abstract_code = Cast<AbstractCode>(BUILTIN_CODE(isolate, InstantiateAsmJs));

#else

UNREACHABLE();

#endif // V8_ENABLE_WEBASSEMBLY

}

double time_taken_ms = time_taken_to_execute.InMillisecondsF() +

time_taken_to_finalize.InMillisecondsF();

DirectHandle<Script> script(Cast<Script>(shared->script()), isolate);

Compiler::LogFunctionCompilation(

isolate, code_type, script, shared, DirectHandle<FeedbackVector>(),

abstract_code, CodeKind::INTERPRETED_FUNCTION, time_taken_ms);

DCHECK_EQ(ThreadId::Current(), isolate->thread_id());

DisallowJavascriptExecution no_js(isolate);

// Delegate to the underlying implementation.

DCHECK_EQ(state(), State::kReadyToPrepare);

base::ScopedTimer t(&time_taken_to_prepare_);

return UpdateState(PrepareJobImpl(isolate), State::kReadyToExecute);

RuntimeCallStats* stats, LocalIsolate* local_isolate) {

DCHECK_IMPLIES(local_isolate && !local_isolate->is_main_thread(),

local_isolate->heap()->IsParked());

// Delegate to the underlying implementation.

DCHECK_EQ(state(), State::kReadyToExecute);

base::ScopedTimer t(&time_taken_to_execute_);

return UpdateState(ExecuteJobImpl(stats, local_isolate),

State::kReadyToFinalize);

DCHECK_EQ(ThreadId::Current(), isolate->thread_id());

DisallowJavascriptExecution no_js(isolate);

// Delegate to the underlying implementation.

DCHECK_EQ(state(), State::kReadyToFinalize);

base::ScopedTimer t(&time_taken_to_finalize_);

return UpdateState(FinalizeJobImpl(isolate), State::kSucceeded);

Isolate* isolate, DirectHandle<Code> code) {

DCHECK(code->is_optimized_code());

DisallowGarbageCollection no_gc;

GlobalHandleVector<Map> maps(isolate->heap());

PtrComprCageBase cage_base(isolate);

int const mode_mask = RelocInfo::EmbeddedObjectModeMask();

for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {

DCHECK(RelocInfo::IsEmbeddedObjectMode(it.rinfo()->rmode()));

Tagged<HeapObject> target_object = it.rinfo()->target_object(cage_base);

if (code->IsWeakObjectInOptimizedCode(target_object)) {

if (IsMap(target_object, cage_base)) {

maps.Push(Cast<Map>(target_object));

}

}

}

return maps;

Isolate* isolate, DirectHandle<NativeContext> context,

DirectHandle<Code> code, GlobalHandleVector<Map> maps) {

isolate->heap()->AddRetainedMaps(context, std::move(maps));

code->set_can_have_weak_objects(true);

// Define a global counter for optimized compile trace ids, which

// counts in the top 32 bits of a uint64_t. This will be mixed into

// the TurbofanCompilationJob `this` pointer, which hopefully will

// make the ids unique enough even when the job memory is reused

// for future jobs.

static std::atomic_uint32_t next_trace_id = 0xfa5701d0;

return static_cast<uint64_t>(next_trace_id++) << 32;

Isolate* isolate, OptimizedCompilationInfo* compilation_info,

State initial_state)

: OptimizedCompilationJob("Turbofan", initial_state),

isolate_(isolate),

compilation_info_(compilation_info),

BailoutReason reason) {

DCHECK(compilation_info_->IsOptimizing());

compilation_info_->RetryOptimization(reason);

return UpdateState(FAILED, State::kFailed);

BailoutReason reason) {

DCHECK(compilation_info_->IsOptimizing());

compilation_info_->AbortOptimization(reason);

return UpdateState(FAILED, State::kFailed);

Isolate* isolate) const {

DCHECK(compilation_info()->IsOptimizing());

DirectHandle<SharedFunctionInfo> shared = compilation_info()->shared_info();

if (v8_flags.trace_opt || v8_flags.trace_opt_stats) {

double ms_creategraph = time_taken_to_prepare_.InMillisecondsF();

double ms_optimize = time_taken_to_execute_.InMillisecondsF();

double ms_codegen = time_taken_to_finalize_.InMillisecondsF();

if (v8_flags.trace_opt) {

CompilerTracer::TraceFinishTurbofanCompile(

isolate, compilation_info(), ms_creategraph, ms_optimize, ms_codegen);

}

if (v8_flags.trace_opt_stats) {

static double compilation_time = 0.0;

static int compiled_functions = 0;

static int code_size = 0;

compilation_time += (ms_creategraph + ms_optimize + ms_codegen);

compiled_functions++;

code_size += shared->SourceSize();

PrintF(

"[turbofan] Compiled: %d functions with %d byte source size in "

"%fms.\n",

compiled_functions, code_size, compilation_time);

}

}

// Don't record samples from machines without high-resolution timers,

// as that can cause serious reporting issues. See the thread at

// http://g/chrome-metrics-team/NwwJEyL8odU/discussion for more details.

if (!base::TimeTicks::IsHighResolution()) return;

int elapsed_microseconds = static_cast<int>(ElapsedTime().InMicroseconds());

Counters* const counters = isolate->counters();

counters->turbofan_ticks()->AddSample(static_cast<int>(

compilation_info()->tick_counter().CurrentTicks() / 1000));

if (compilation_info()->is_osr()) {

counters->turbofan_osr_prepare()->AddSample(

static_cast<int>(time_taken_to_prepare_.InMicroseconds()));

counters->turbofan_osr_execute()->AddSample(

static_cast<int>(time_taken_to_execute_.InMicroseconds()));

counters->turbofan_osr_finalize()->AddSample(

static_cast<int>(time_taken_to_finalize_.InMicroseconds()));

counters->turbofan_osr_total_time()->AddSample(elapsed_microseconds);

return;

}

DCHECK(!compilation_info()->is_osr());

counters->turbofan_optimize_prepare()->AddSample(

static_cast<int>(time_taken_to_prepare_.InMicroseconds()));

counters->turbofan_optimize_execute()->AddSample(

static_cast<int>(time_taken_to_execute_.InMicroseconds()));

counters->turbofan_optimize_finalize()->AddSample(

static_cast<int>(time_taken_to_finalize_.InMicroseconds()));

counters->turbofan_optimize_total_time()->AddSample(elapsed_microseconds);

// Compute foreground / background time.

base::TimeDelta time_background;

base::TimeDelta time_foreground =

time_taken_to_prepare_ + time_taken_to_finalize_;

switch (mode) {

case ConcurrencyMode::kConcurrent:

time_background += time_taken_to_execute_;

counters->turbofan_optimize_concurrent_total_time()->AddSample(

elapsed_microseconds);

break;

case ConcurrencyMode::kSynchronous:

counters->turbofan_optimize_non_concurrent_total_time()->AddSample(

elapsed_microseconds);

time_foreground += time_taken_to_execute_;

break;

}

counters->turbofan_optimize_total_background()->AddSample(

static_cast<int>(time_background.InMicroseconds()));

counters->turbofan_optimize_total_foreground()->AddSample(

static_cast<int>(time_foreground.InMicroseconds()));

if (v8_flags.profile_guided_optimization &&

shared->cached_tiering_decision() ==

CachedTieringDecision::kEarlyMaglev) {

shared->set_cached_tiering_decision(CachedTieringDecision::kEarlyTurbofan);

}

LogEventListener::CodeTag code_type, Isolate* isolate) const {

DirectHandle<AbstractCode> abstract_code =

Cast<AbstractCode>(compilation_info()->code());

double time_taken_ms = time_taken_to_prepare_.InMillisecondsF() +

time_taken_to_execute_.InMillisecondsF() +

time_taken_to_finalize_.InMillisecondsF();

DirectHandle<Script> script(

Cast<Script>(compilation_info()->shared_info()->script()), isolate);

DirectHandle<FeedbackVector> feedback_vector(

compilation_info()->closure()->feedback_vector(), isolate);

Compiler::LogFunctionCompilation(

isolate, code_type, script, compilation_info()->shared_info(),

feedback_vector, abstract_code, compilation_info()->code_kind(),

time_taken_ms);

// Xor together the this pointer and the optimization id, to try to make the

// id more unique on platforms where just the `this` pointer is likely to be

// reused.

return trace_id_;

// Check whether asm.js validation is enabled.

if (!v8_flags.validate_asm) return false;

// Modules that have validated successfully, but were subsequently broken by

// invalid module instantiation attempts are off limit forever.

if (asm_wasm_broken) return false;

// In stress mode we want to run the validator on everything.

if (v8_flags.stress_validate_asm) return true;

// In general, we respect the "use asm" directive.

return literal->scope()->IsAsmModule();

Isolate* isolate, DirectHandle<SharedFunctionInfo> shared_info,

LogEventListener::CodeTag log_tag) {

DCHECK(isolate->interpreted_frames_native_stack());

if (!IsBytecodeArray(shared_info->GetTrustedData(isolate))) {

DCHECK(!shared_info->HasInterpreterData(isolate));

return;

}

DirectHandle<BytecodeArray> bytecode_array(

shared_info->GetBytecodeArray(isolate), isolate);

DirectHandle<Code> code =

Builtins::CreateInterpreterEntryTrampolineForProfiling(isolate);

DirectHandle<InterpreterData> interpreter_data =

isolate->factory()->NewInterpreterData(bytecode_array, code);

if (shared_info->HasBaselineCode()) {

shared_info->baseline_code(kAcquireLoad)

->set_bytecode_or_interpreter_data(*interpreter_data);

} else {

// IsBytecodeArray

shared_info->set_interpreter_data(isolate, *interpreter_data);

}

DirectHandle<Script> script(Cast<Script>(shared_info->script()), isolate);

DirectHandle<AbstractCode> abstract_code = Cast<AbstractCode>(code);

Script::PositionInfo info;

Script::GetPositionInfo(script, shared_info->StartPosition(), &info);

int line_num = info.line + 1;

int column_num = info.column + 1;

DirectHandle<String> script_name(IsString(script->name())

? Cast<String>(script->name())

: ReadOnlyRoots(isolate).empty_string(),

isolate);

PROFILE(isolate, CodeCreateEvent(log_tag, abstract_code, shared_info,

script_name, line_num, column_num));

DirectHandle<SharedFunctionInfo> shared_info,

IsolateT* isolate) {

if (compilation_info->has_bytecode_array()) {

DCHECK(!shared_info->HasBytecodeArray()); // Only compiled once.

DCHECK(!compilation_info->has_asm_wasm_data());

DCHECK(!shared_info->HasFeedbackMetadata());

#if V8_ENABLE_WEBASSEMBLY

// If the function failed asm-wasm compilation, mark asm_wasm as broken

// to ensure we don't try to compile as asm-wasm.

if (compilation_info->literal()->scope()->IsAsmModule()) {

shared_info->set_is_asm_wasm_broken(true);

}

#endif // V8_ENABLE_WEBASSEMBLY

DirectHandle<FeedbackMetadata> feedback_metadata = FeedbackMetadata::New(

isolate, compilation_info->feedback_vector_spec());

shared_info->set_feedback_metadata(*feedback_metadata, kReleaseStore);

shared_info->set_age(0);

shared_info->set_bytecode_array(*compilation_info->bytecode_array());

} else {

#if V8_ENABLE_WEBASSEMBLY

DCHECK(compilation_info->has_asm_wasm_data());

// We should only have asm/wasm data when finalizing on the main thread.

DCHECK((std::is_same<IsolateT, Isolate>::value));

shared_info->set_asm_wasm_data(*compilation_info->asm_wasm_data());

shared_info->set_feedback_metadata(

ReadOnlyRoots(isolate).empty_feedback_metadata(), kReleaseStore);

#else

UNREACHABLE();

#endif // V8_ENABLE_WEBASSEMBLY

}

ParseInfo* parse_info, IsolateT* isolate) {

DCHECK(parse_info->flags().is_toplevel());

if (script->infos()->length() > 0) {

DCHECK_EQ(script->infos()->length(), parse_info->max_info_id() + 1);

return;

}

DirectHandle<WeakFixedArray> infos(isolate->factory()->NewWeakFixedArray(

parse_info->max_info_id() + 1, AllocationType::kOld));

script->set_infos(*infos);

Tagged<SharedFunctionInfo> shared_info = *literal->shared_function_info();

DCHECK_EQ(shared_info->language_mode(), literal->language_mode());

// These fields are all initialised in ParseInfo from the SharedFunctionInfo,

// and then set back on the literal after parse. Hence, they should already

// match.

DCHECK_EQ(shared_info->requires_instance_members_initializer(),

literal->requires_instance_members_initializer());

DCHECK_EQ(shared_info->class_scope_has_private_brand(),

literal->class_scope_has_private_brand());

DCHECK_EQ(shared_info->has_static_private_methods_or_accessors(),

literal->has_static_private_methods_or_accessors());

shared_info->set_has_duplicate_parameters(

literal->has_duplicate_parameters());

shared_info->UpdateAndFinalizeExpectedNofPropertiesFromEstimate(literal);

shared_info->SetScopeInfo(*literal->scope()->scope_info());

UnoptimizedCompilationJob* job, Handle<SharedFunctionInfo> shared_info,

IsolateT* isolate,

FinalizeUnoptimizedCompilationDataList*

finalize_unoptimized_compilation_data_list) {

UnoptimizedCompilationInfo* compilation_info = job->compilation_info();

CompilationJob::Status status = job->FinalizeJob(shared_info, isolate);

if (status == CompilationJob::SUCCEEDED) {

InstallUnoptimizedCode(compilation_info, shared_info, isolate);

MaybeHandle<CoverageInfo> coverage_info;

if (compilation_info->has_coverage_info()) {

MutexGuardIfOffThread<IsolateT> mutex_guard(

isolate->shared_function_info_access(), isolate);

if (!shared_info->HasCoverageInfo(

isolate->GetMainThreadIsolateUnsafe())) {

coverage_info = compilation_info->coverage_info();

}

}

finalize_unoptimized_compilation_data_list->emplace_back(

isolate, shared_info, coverage_info, job->time_taken_to_execute(),

job->time_taken_to_finalize());

}

DCHECK_IMPLIES(status == CompilationJob::RETRY_ON_MAIN_THREAD,

(std::is_same<IsolateT, LocalIsolate>::value));

return status;

ParseInfo* parse_info, FunctionLiteral* literal, Handle<Script> script,

AccountingAllocator* allocator,

std::vector<FunctionLiteral*>* eager_inner_literals,

LocalIsolate* local_isolate) {

#if V8_ENABLE_WEBASSEMBLY

if (UseAsmWasm(literal, parse_info->flags().is_asm_wasm_broken())) {

std::unique_ptr<UnoptimizedCompilationJob> asm_job(

AsmJs::NewCompilationJob(parse_info, literal, allocator));

if (asm_job->ExecuteJob() == CompilationJob::SUCCEEDED) {

return asm_job;

}

// asm.js validation failed, fall through to standard unoptimized compile.

// Note: we rely on the fact that AsmJs jobs have done all validation in the

// PrepareJob and ExecuteJob phases and can't fail in FinalizeJob with

// with a validation error or another error that could be solve by falling

// through to standard unoptimized compile.

}

#endif

std::unique_ptr<UnoptimizedCompilationJob> job(

interpreter::Interpreter::NewCompilationJob(

parse_info, literal, script, allocator, eager_inner_literals,

local_isolate));

if (job->ExecuteJob() != CompilationJob::SUCCEEDED) {

// Compilation failed, return null.

return std::unique_ptr<UnoptimizedCompilationJob>();

}

return job;

IsolateT* isolate, Handle<Script> script, ParseInfo* parse_info,

AccountingAllocator* allocator, IsCompiledScope* is_compiled_scope,

FinalizeUnoptimizedCompilationDataList*

finalize_unoptimized_compilation_data_list,

DeferredFinalizationJobDataList*

jobs_to_retry_finalization_on_main_thread) {

DeclarationScope::AllocateScopeInfos(parse_info, script, isolate);

std::vector<FunctionLiteral*> functions_to_compile;

functions_to_compile.push_back(parse_info->literal());

bool compilation_succeeded = true;

while (!functions_to_compile.empty()) {

FunctionLiteral* literal = functions_to_compile.back();

functions_to_compile.pop_back();

Handle<SharedFunctionInfo> shared_info = literal->shared_function_info();

// It's possible that compilation of an outer function overflowed the stack,

// so a literal we'd like to compile won't have its SFI yet. Skip compiling

// the inner function in that case.

if (shared_info.is_null()) continue;

if (shared_info->is_compiled()) continue;

std::unique_ptr<UnoptimizedCompilationJob> job =

ExecuteSingleUnoptimizedCompilationJob(parse_info, literal, script,

allocator, &functions_to_compile,

isolate->AsLocalIsolate());

if (!job) {

// Compilation failed presumably because of stack overflow, make sure

// the shared function info contains uncompiled data for the next

// compilation attempts.

if (!shared_info->HasUncompiledData()) {

SharedFunctionInfo::CreateAndSetUncompiledData(isolate, literal);

}

compilation_succeeded = false;

// Proceed finalizing other functions in case they don't have uncompiled

// data.

continue;

}

UpdateSharedFunctionFlagsAfterCompilation(literal);

auto finalization_status = FinalizeSingleUnoptimizedCompilationJob(

job.get(), shared_info, isolate,

finalize_unoptimized_compilation_data_list);

switch (finalization_status) {

case CompilationJob::SUCCEEDED:

if (literal == parse_info->literal()) {

// Ensure that the top level function is retained.

*is_compiled_scope = shared_info->is_compiled_scope(isolate);

DCHECK(is_compiled_scope->is_compiled());

}

break;

case CompilationJob::FAILED:

compilation_succeeded = false;

// Proceed finalizing other functions in case they don't have uncompiled

// data.

continue;

case CompilationJob::RETRY_ON_MAIN_THREAD:

// This should not happen on the main thread.

DCHECK((!std::is_same<IsolateT, Isolate>::value));

DCHECK_NOT_NULL(jobs_to_retry_finalization_on_main_thread);

// Clear the literal and ParseInfo to prevent further attempts to

// access them.

job->compilation_info()->ClearLiteral();

job->ClearParseInfo();

jobs_to_retry_finalization_on_main_thread->emplace_back(

isolate, shared_info, std::move(job));

break;

}

}

// Report any warnings generated during compilation.

if (parse_info->pending_error_handler()->has_pending_warnings()) {

parse_info->pending_error_handler()->PrepareWarnings(isolate);

}

return compilation_succeeded;

Isolate* isolate, DirectHandle<Script> script,

DeferredFinalizationJobDataList* deferred_jobs,

PendingCompilationErrorHandler* pending_error_handler,

FinalizeUnoptimizedCompilationDataList*

finalize_unoptimized_compilation_data_list) {

DCHECK(AllowCompilation::IsAllowed(isolate));

if (deferred_jobs->empty()) return true;

// TODO(rmcilroy): Clear native context in debug once AsmJS generates doesn't

// rely on accessing native context during finalization.

// Finalize the deferred compilation jobs.

for (auto&& job : *deferred_jobs) {

Handle<SharedFunctionInfo> shared_info = job.function_handle();

if (FinalizeSingleUnoptimizedCompilationJob(

job.job(), shared_info, isolate,

finalize_unoptimized_compilation_data_list) !=

CompilationJob::SUCCEEDED) {

return false;

}

}

// Report any warnings generated during deferred finalization.

if (pending_error_handler->has_pending_warnings()) {

pending_error_handler->PrepareWarnings(isolate);

}

return true;

public:

static V8_WARN_UNUSED_RESULT MaybeHandle<Code> Get(

Isolate* isolate, DirectHandle<JSFunction> function,

BytecodeOffset osr_offset, CodeKind code_kind) {

DCHECK_IMPLIES(V8_ENABLE_LEAPTIERING_BOOL, IsOSR(osr_offset));

if (!CodeKindIsStoredInOptimizedCodeCache(code_kind)) return {};

if (!function->has_feedback_vector()) return {};

DisallowGarbageCollection no_gc;

Tagged<SharedFunctionInfo> shared = function->shared();

RCS_SCOPE(isolate, RuntimeCallCounterId::kCompileGetFromOptimizedCodeMap);

Tagged<Code> code;

Tagged<FeedbackVector> feedback_vector = function->feedback_vector();

if (IsOSR(osr_offset)) {

Handle<BytecodeArray> bytecode(shared->GetBytecodeArray(isolate),

isolate);

interpreter::BytecodeArrayIterator it(bytecode, osr_offset.ToInt());

// Bytecode may be different, so make sure we're at a valid OSR entry.

SBXCHECK(it.CurrentBytecodeIsValidOSREntry());

std::optional<Tagged<Code>> maybe_code =