#ifndef V8_CODEGEN_COMPILER_H_

#define V8_CODEGEN_COMPILER_H_

#include <forward_list>

#include <memory>

#include "src/ast/ast-value-factory.h"

#include "src/base/platform/elapsed-timer.h"

#include "src/base/small-vector.h"

#include "src/base/threaded-list.h"

#include "src/codegen/background-merge-task.h"

#include "src/codegen/bailout-reason.h"

#include "src/common/globals.h"

#include "src/execution/isolate.h"

#include "src/execution/local-isolate.h"

#include "src/handles/persistent-handles.h"

#include "src/logging/code-events.h"

#include "src/objects/contexts.h"

#include "src/objects/debug-objects.h"

#include "src/parsing/parse-info.h"

#include "src/parsing/pending-compilation-error-handler.h"

#include "src/snapshot/code-serializer.h"

#include "src/utils/allocation.h"

#include "src/zone/zone.h"

namespace v8 {

namespace tracing {

class TracedValue;

} // namespace tracing

namespace internal {

class AlignedCachedData;

class BackgroundCompileTask;

class IsCompiledScope;

class OptimizedCompilationInfo;

class ParseInfo;

class RuntimeCallStats;

class TimedHistogram;

class TurbofanCompilationJob;

class UnoptimizedCompilationInfo;

class UnoptimizedCompilationJob;

class UnoptimizedJSFrame;

class WorkerThreadRuntimeCallStats;

struct ScriptDetails;

struct ScriptStreamingData;

namespace maglev {

class MaglevCompilationJob;

static inline bool IsMaglevEnabled() { return v8_flags.maglev; }

static inline bool IsMaglevOsrEnabled() {

return IsMaglevEnabled() && v8_flags.maglev_osr;

}

} // namespace maglev

class V8_EXPORT_PRIVATE Compiler : public AllStatic {

public:

enum ClearExceptionFlag { KEEP_EXCEPTION, CLEAR_EXCEPTION };

// ===========================================================================

// The following family of methods ensures a given function is compiled. The

// general contract is that failures will be reported by returning {false},

// whereas successful compilation ensures the {is_compiled} predicate on the

// given function holds (except for live-edit, which compiles the world).

static bool Compile(Isolate* isolate, Handle<SharedFunctionInfo> shared,

ClearExceptionFlag flag,

IsCompiledScope* is_compiled_scope,

CreateSourcePositions create_source_positions_flag =

CreateSourcePositions::kNo);

static bool Compile(Isolate* isolate, DirectHandle<JSFunction> function,

ClearExceptionFlag flag,

IsCompiledScope* is_compiled_scope);

static MaybeHandle<SharedFunctionInfo> CompileToplevel(

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

IsCompiledScope* is_compiled_scope);

static bool CompileSharedWithBaseline(Isolate* isolate,

Handle<SharedFunctionInfo> shared,

ClearExceptionFlag flag,

IsCompiledScope* is_compiled_scope);

static bool CompileBaseline(Isolate* isolate,

DirectHandle<JSFunction> function,

ClearExceptionFlag flag,

IsCompiledScope* is_compiled_scope);

static void CompileOptimized(Isolate* isolate,

DirectHandle<JSFunction> function,

ConcurrencyMode mode, CodeKind code_kind);

// Generate and return optimized code for OSR. The empty handle is returned

// either on failure, or after spawning a concurrent OSR task (in which case

// a future OSR request will pick up the resulting code object).

V8_WARN_UNUSED_RESULT static MaybeHandle<Code> CompileOptimizedOSR(

Isolate* isolate, DirectHandle<JSFunction> function,

BytecodeOffset osr_offset, ConcurrencyMode mode, CodeKind code_kind);

V8_WARN_UNUSED_RESULT static MaybeDirectHandle<SharedFunctionInfo>

CompileForLiveEdit(ParseInfo* parse_info, Handle<Script> script,

MaybeDirectHandle<ScopeInfo> outer_scope_info,

Isolate* isolate);

// Collect source positions for a function that has already been compiled to

// bytecode, but for which source positions were not collected (e.g. because

// they were not immediately needed).

static bool CollectSourcePositions(Isolate* isolate,

DirectHandle<SharedFunctionInfo> shared);

// Finalize and install code from previously run background compile task.

static bool FinalizeBackgroundCompileTask(BackgroundCompileTask* task,

Isolate* isolate,

ClearExceptionFlag flag);

// Dispose a job without finalization.

static void DisposeTurbofanCompilationJob(Isolate* isolate,

TurbofanCompilationJob* job);

// Finalize and install Turbofan code from a previously run job.

static void FinalizeTurbofanCompilationJob(TurbofanCompilationJob* job,

Isolate* isolate);

// Finalize and install Maglev code from a previously run job.

static void FinalizeMaglevCompilationJob(maglev::MaglevCompilationJob* job,

Isolate* isolate);

// Dispose a Maglev compile job.

static void DisposeMaglevCompilationJob(maglev::MaglevCompilationJob* job,

Isolate* isolate);

// Give the compiler a chance to perform low-latency initialization tasks of

// the given {function} on its instantiation. Note that only the runtime will

// offer this chance, optimized closure instantiation will not call this.

static void PostInstantiation(Isolate* isolate,

DirectHandle<JSFunction> function,

IsCompiledScope* is_compiled_scope);

// ===========================================================================

// The following family of methods instantiates new functions for scripts or

// function literals. The decision whether those functions will be compiled,

// is left to the discretion of the compiler.

//

// Please note this interface returns shared function infos. This means you

// need to call Factory::NewFunctionFromSharedFunctionInfo before you have a

// real function with a context.

// Create a (bound) function for a String source within a context for eval.

V8_WARN_UNUSED_RESULT static MaybeDirectHandle<JSFunction>

GetFunctionFromEval(Isolate* isolate, DirectHandle<String> source,

DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<Context> context, LanguageMode language_mode,

ParseRestriction restriction, int parameters_end_pos,

int eval_position,

ParsingWhileDebugging parsing_while_debugging =

ParsingWhileDebugging::kNo);

// Create a function that results from wrapping |source| in a function,

// with |arguments| being a list of parameters for that function.

V8_WARN_UNUSED_RESULT static MaybeDirectHandle<JSFunction> GetWrappedFunction(

Isolate* isolate, Handle<String> source, DirectHandle<Context> context,

const ScriptDetails& script_details, AlignedCachedData* cached_data,

v8::ScriptCompiler::CompileOptions compile_options,

v8::ScriptCompiler::NoCacheReason no_cache_reason);

// Create a (bound) function for a String source within a context for eval.

V8_WARN_UNUSED_RESULT static MaybeDirectHandle<JSFunction>

GetFunctionFromString(Isolate* isolate, DirectHandle<NativeContext> context,

Handle<i::Object> source, int parameters_end_pos,

bool is_code_like);

// Decompose GetFunctionFromString into two functions, to allow callers to

// deal separately with a case of object not handled by the embedder.

V8_WARN_UNUSED_RESULT static std::pair<MaybeDirectHandle<String>, bool>

ValidateDynamicCompilationSource(Isolate* isolate,

DirectHandle<NativeContext> context,

Handle<i::Object> source_object,

bool is_code_like = false);

V8_WARN_UNUSED_RESULT static MaybeDirectHandle<JSFunction>

GetFunctionFromValidatedString(Isolate* isolate,

DirectHandle<NativeContext> context,

MaybeDirectHandle<String> source,

ParseRestriction restriction,

int parameters_end_pos);

// Create a shared function info object for a String source.

static MaybeDirectHandle<SharedFunctionInfo> GetSharedFunctionInfoForScript(

Isolate* isolate, Handle<String> source,

const ScriptDetails& script_details,

ScriptCompiler::CompileOptions compile_options,

ScriptCompiler::NoCacheReason no_cache_reason,

NativesFlag is_natives_code,

ScriptCompiler::CompilationDetails* compilation_details);

// Create a shared function info object for a String source.

static MaybeDirectHandle<SharedFunctionInfo>

GetSharedFunctionInfoForScriptWithExtension(

Isolate* isolate, Handle<String> source,

const ScriptDetails& script_details, v8::Extension* extension,

ScriptCompiler::CompileOptions compile_options,

NativesFlag is_natives_code,

ScriptCompiler::CompilationDetails* compilation_details);

// Create a shared function info object for a String source and serialized

// cached data. The cached data may be rejected, in which case this function

// will set cached_data->rejected() to true.

static MaybeDirectHandle<SharedFunctionInfo>

GetSharedFunctionInfoForScriptWithCachedData(

Isolate* isolate, Handle<String> source,

const ScriptDetails& script_details, AlignedCachedData* cached_data,

ScriptCompiler::CompileOptions compile_options,

ScriptCompiler::NoCacheReason no_cache_reason,

NativesFlag is_natives_code,

ScriptCompiler::CompilationDetails* compilation_details);

// Create a shared function info object for a String source and a task that

// has deserialized cached data on a background thread. The cached data from

// the task may be rejected, in which case this function will set

// deserialize_task->rejected() to true.

static MaybeDirectHandle<SharedFunctionInfo>

GetSharedFunctionInfoForScriptWithDeserializeTask(

Isolate* isolate, Handle<String> source,

const ScriptDetails& script_details,

BackgroundDeserializeTask* deserialize_task,

ScriptCompiler::CompileOptions compile_options,

ScriptCompiler::NoCacheReason no_cache_reason,

NativesFlag is_natives_code,

ScriptCompiler::CompilationDetails* compilation_details);

static MaybeDirectHandle<SharedFunctionInfo>

GetSharedFunctionInfoForScriptWithCompileHints(

Isolate* isolate, Handle<String> source,

const ScriptDetails& script_details,

v8::CompileHintCallback compile_hint_callback,

void* compile_hint_callback_data,

ScriptCompiler::CompileOptions compile_options,

ScriptCompiler::NoCacheReason no_cache_reason,

NativesFlag is_natives_code,

ScriptCompiler::CompilationDetails* compilation_details);

// Create a shared function info object for a Script source that has already

// been parsed and possibly compiled on a background thread while being loaded

// from a streamed source. On return, the data held by |streaming_data| will

// have been released, however the object itself isn't freed and is still

// owned by the caller.

static MaybeDirectHandle<SharedFunctionInfo>

GetSharedFunctionInfoForStreamedScript(

Isolate* isolate, Handle<String> source,

const ScriptDetails& script_details, ScriptStreamingData* streaming_data,

IsCompiledScope* is_compiled_scope,

ScriptCompiler::CompilationDetails* compilation_details);

// Create a shared function info object for the given function literal

// node (the code may be lazily compiled).

template <typename IsolateT>

static DirectHandle<SharedFunctionInfo> GetSharedFunctionInfo(

FunctionLiteral* node, DirectHandle<Script> script, IsolateT* isolate);

static void LogFunctionCompilation(Isolate* isolate,

LogEventListener::CodeTag code_type,

DirectHandle<Script> script,

DirectHandle<SharedFunctionInfo> shared,

DirectHandle<FeedbackVector> vector,

DirectHandle<AbstractCode> abstract_code,

CodeKind kind, double time_taken_ms);

static void InstallInterpreterTrampolineCopy(

Isolate* isolate, DirectHandle<SharedFunctionInfo> shared_info,

LogEventListener::CodeTag log_tag);

};

class V8_EXPORT_PRIVATE CompilationJob {

public:

enum Status { SUCCEEDED, FAILED, RETRY_ON_MAIN_THREAD };

enum class State {

};

explicit CompilationJob(State initial_state) : state_(initial_state) {}

virtual ~CompilationJob() = default;

State state() const { return state_; }

protected:

V8_WARN_UNUSED_RESULT Status UpdateState(Status status, State next_state) {

switch (status) {

case SUCCEEDED:

state_ = next_state;

break;

case FAILED:

state_ = State::kFailed;

break;

case RETRY_ON_MAIN_THREAD:

// Don't change the state, we'll re-try on the main thread.

break;

}

return status;

}

private:

State state_;

};

class UnoptimizedCompilationJob : public CompilationJob {

};

class OptimizedCompilationJob : public CompilationJob {

}

protected:

// Overridden by the actual implementation.

virtual Status PrepareJobImpl(Isolate* isolate) = 0;

virtual Status ExecuteJobImpl(RuntimeCallStats* stats,

LocalIsolate* local_heap) = 0;

virtual Status FinalizeJobImpl(Isolate* isolate) = 0;

// Register weak object to optimized code dependencies.

GlobalHandleVector<Map> CollectRetainedMaps(Isolate* isolate,

DirectHandle<Code> code);

void RegisterWeakObjectsInOptimizedCode(Isolate* isolate,

DirectHandle<NativeContext> context,

DirectHandle<Code> code,

GlobalHandleVector<Map> maps);

base::TimeDelta time_taken_to_prepare_;

base::TimeDelta time_taken_to_execute_;

base::TimeDelta time_taken_to_finalize_;

base::ElapsedTimer timer_;

private:

const char* const compiler_name_;

};

class TurbofanCompilationJob : public OptimizedCompilationJob {

};

class FinalizeUnoptimizedCompilationData {

};

using FinalizeUnoptimizedCompilationDataList =

std::vector<FinalizeUnoptimizedCompilationData>;

class DeferredFinalizationJobData {

};

class V8_NODISCARD CompilationHandleScope final {

public:

explicit CompilationHandleScope(Isolate* isolate,

OptimizedCompilationInfo* info)

: persistent_(isolate), info_(info) {}

V8_EXPORT_PRIVATE ~CompilationHandleScope();

private:

PersistentHandlesScope persistent_;

OptimizedCompilationInfo* info_;

};

using DeferredFinalizationJobDataList =

std::vector<DeferredFinalizationJobData>;

class V8_EXPORT_PRIVATE BackgroundCompileTask {

public:

// Creates a new task that when run will parse and compile the streamed

// script associated with |data| and can be finalized with FinalizeScript.

// Note: does not take ownership of |data|.

BackgroundCompileTask(ScriptStreamingData* data, Isolate* isolate,

v8::ScriptType type,

ScriptCompiler::CompileOptions options,

ScriptCompiler::CompilationDetails* compilation_details,

CompileHintCallback compile_hint_callback = nullptr,

void* compile_hint_callback_data = nullptr);

BackgroundCompileTask(const BackgroundCompileTask&) = delete;

BackgroundCompileTask& operator=(const BackgroundCompileTask&) = delete;

~BackgroundCompileTask();

// Creates a new task that when run will parse and compile the non-top-level

// |shared_info| and can be finalized with FinalizeFunction in

// Compiler::FinalizeBackgroundCompileTask.

BackgroundCompileTask(

Isolate* isolate, Handle<SharedFunctionInfo> shared_info,

std::unique_ptr<Utf16CharacterStream> character_stream,

WorkerThreadRuntimeCallStats* worker_thread_runtime_stats,

TimedHistogram* timer, int max_stack_size);

void Run();

void RunOnMainThread(Isolate* isolate);

void Run(LocalIsolate* isolate,

ReusableUnoptimizedCompileState* reusable_state);

MaybeHandle<SharedFunctionInfo> FinalizeScript(

Isolate* isolate, DirectHandle<String> source,

const ScriptDetails& script_details,

MaybeDirectHandle<Script> maybe_cached_script);

bool FinalizeFunction(Isolate* isolate, Compiler::ClearExceptionFlag flag);

void AbortFunction();

UnoptimizedCompileFlags flags() const { return flags_; }

private:

void ReportStatistics(Isolate* isolate);

void ClearFunctionJobPointer();

bool is_streaming_compilation() const;

// Data needed for parsing and compilation. These need to be initialized

// before the compilation starts.

Isolate* isolate_for_local_isolate_;

UnoptimizedCompileFlags flags_;

UnoptimizedCompileState compile_state_;

std::unique_ptr<Utf16CharacterStream> character_stream_;

int stack_size_;

WorkerThreadRuntimeCallStats* worker_thread_runtime_call_stats_;

TimedHistogram* timer_;

ScriptCompiler::CompilationDetails* compilation_details_;

// Data needed for merging onto the main thread after background finalization.

std::unique_ptr<PersistentHandles> persistent_handles_;

MaybeIndirectHandle<SharedFunctionInfo> outer_function_sfi_;

IndirectHandle<Script> script_;

IsCompiledScope is_compiled_scope_;

FinalizeUnoptimizedCompilationDataList finalize_unoptimized_compilation_data_;

DeferredFinalizationJobDataList jobs_to_retry_finalization_on_main_thread_;

base::SmallVector<v8::Isolate::UseCounterFeature, 8> use_counts_;

int total_preparse_skipped_ = 0;

// Single function data for top-level function compilation.

MaybeIndirectHandle<SharedFunctionInfo> input_shared_info_;

int start_position_;

int end_position_;

int function_literal_id_;

CompileHintCallback compile_hint_callback_ = nullptr;

void* compile_hint_callback_data_ = nullptr;

};

struct V8_EXPORT_PRIVATE ScriptStreamingData {

ScriptStreamingData(

std::unique_ptr<ScriptCompiler::ExternalSourceStream> source_stream,

ScriptCompiler::StreamedSource::Encoding encoding);

ScriptStreamingData(const ScriptStreamingData&) = delete;

ScriptStreamingData& operator=(const ScriptStreamingData&) = delete;

~ScriptStreamingData();

void Release();

// Internal implementation of v8::ScriptCompiler::StreamedSource.

std::unique_ptr<ScriptCompiler::ExternalSourceStream> source_stream;

ScriptCompiler::StreamedSource::Encoding encoding;

// Task that performs background parsing and compilation.

std::unique_ptr<BackgroundCompileTask> task;

};

class V8_EXPORT_PRIVATE BackgroundDeserializeTask {

public:

BackgroundDeserializeTask(Isolate* isolate,

std::unique_ptr<ScriptCompiler::CachedData> data);

void Run();

// Checks the Isolate compilation cache to see whether it will be necessary to

// merge the newly deserialized objects into an existing Script. This can

// change the value of ShouldMergeWithExistingScript, and embedders should

// check the latter after calling this. May only be called on a thread where

// the Isolate is currently entered.

void SourceTextAvailable(Isolate* isolate, Handle<String> source_text,

const ScriptDetails& script_details);

// Returns whether the embedder should call MergeWithExistingScript. This

// function may be called from any thread, any number of times, but its return

// value is only meaningful after SourceTextAvailable has completed.

bool ShouldMergeWithExistingScript() const;

// Partially merges newly deserialized objects into an existing Script with

// the same source, as provided by SourceTextAvailable, and generates a list

// of follow-up work for the main thread. May be called from any thread, only

// once.

void MergeWithExistingScript();

MaybeDirectHandle<SharedFunctionInfo> Finish(

Isolate* isolate, DirectHandle<String> source,

const ScriptDetails& script_details);

bool rejected() const { return cached_data_.rejected(); }

int64_t background_time_in_microseconds() const {

return background_time_in_microseconds_;

}

private:

Isolate* isolate_for_local_isolate_;

AlignedCachedData cached_data_;

CodeSerializer::OffThreadDeserializeData off_thread_data_;

BackgroundMergeTask background_merge_task_;

TimedHistogram* timer_;

int64_t background_time_in_microseconds_ = 0;

};

} // namespace internal

} // namespace v8

#endif // V8_CODEGEN_COMPILER_H_