| // Copyright 2016 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_COMPILER_DISPATCHER_UNOPTIMIZED_COMPILE_JOB_H_ |
| #define V8_COMPILER_DISPATCHER_UNOPTIMIZED_COMPILE_JOB_H_ |
| |
| #include <memory> |
| |
| #include "include/v8.h" |
| #include "src/base/macros.h" |
| #include "src/compiler-dispatcher/compiler-dispatcher-job.h" |
| #include "src/globals.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| class AstValueFactory; |
| class AstStringConstants; |
| class CompilerDispatcherTracer; |
| class CompilationInfo; |
| class CompilationJob; |
| class DeferredHandles; |
| class FunctionLiteral; |
| class Isolate; |
| class ParseInfo; |
| class Parser; |
| class SharedFunctionInfo; |
| class String; |
| class UnicodeCache; |
| class Utf16CharacterStream; |
| |
| class V8_EXPORT_PRIVATE UnoptimizedCompileJob : public CompilerDispatcherJob { |
| public: |
| enum class Status { |
| kInitial, |
| kReadyToParse, |
| kParsed, |
| kReadyToAnalyze, |
| kAnalyzed, |
| kReadyToCompile, |
| kCompiled, |
| kDone, |
| kFailed, |
| }; |
| |
| // Creates a UnoptimizedCompileJob in the initial state. |
| UnoptimizedCompileJob(Isolate* isolate, CompilerDispatcherTracer* tracer, |
| Handle<SharedFunctionInfo> shared, |
| size_t max_stack_size); |
| ~UnoptimizedCompileJob() override; |
| |
| Type type() const override { return kUnoptimizedCompile; } |
| |
| Handle<SharedFunctionInfo> shared() const { return shared_; } |
| |
| // Returns true if this UnoptimizedCompileJob was created for the given |
| // function. |
| bool IsAssociatedWith(Handle<SharedFunctionInfo> shared) const; |
| |
| bool IsFinished() override { |
| return status() == Status::kDone || status() == Status::kFailed; |
| } |
| |
| bool IsFailed() override { return status() == Status::kFailed; } |
| |
| // Return true if the next step can be run on any thread, that is when both |
| // StepNextOnMainThread and StepNextOnBackgroundThread could be used for the |
| // next step. |
| bool CanStepNextOnAnyThread() override { |
| return status() == Status::kReadyToParse || |
| status() == Status::kReadyToCompile; |
| } |
| |
| // Step the job forward by one state on the main thread. |
| void StepNextOnMainThread(Isolate* isolate) override; |
| |
| // Step the job forward by one state on a background thread. |
| void StepNextOnBackgroundThread() override; |
| |
| // Transition from any state to kInitial and free all resources. |
| void ResetOnMainThread(Isolate* isolate) override; |
| |
| // Estimate how long the next step will take using the tracer. |
| double EstimateRuntimeOfNextStepInMs() const override; |
| |
| void ShortPrintOnMainThread() override; |
| |
| private: |
| friend class CompilerDispatcherTest; |
| friend class UnoptimizedCompileJobTest; |
| |
| bool has_context() const { return !context_.is_null(); } |
| Context* context() { return *context_; } |
| |
| Status status() const { return status_; } |
| |
| Status status_; |
| int main_thread_id_; |
| CompilerDispatcherTracer* tracer_; |
| Handle<Context> context_; // Global handle. |
| Handle<SharedFunctionInfo> shared_; // Global handle. |
| Handle<String> source_; // Global handle. |
| Handle<String> wrapper_; // Global handle. |
| std::unique_ptr<v8::String::ExternalStringResourceBase> source_wrapper_; |
| size_t max_stack_size_; |
| |
| // Members required for parsing. |
| std::unique_ptr<UnicodeCache> unicode_cache_; |
| std::unique_ptr<ParseInfo> parse_info_; |
| std::unique_ptr<Parser> parser_; |
| |
| // Members required for compiling. |
| std::unique_ptr<CompilationJob> compilation_job_; |
| |
| bool trace_compiler_dispatcher_jobs_; |
| |
| // Transition from kInitial to kReadyToParse. |
| void PrepareToParseOnMainThread(Isolate* isolate); |
| |
| // Transition from kReadyToParse to kParsed. |
| void Parse(); |
| |
| // Transition from kParsed to kReadyToAnalyze (or kFailed). |
| void FinalizeParsingOnMainThread(Isolate* isolate); |
| |
| // Transition from kReadyToAnalyze to kAnalyzed (or kFailed). |
| void AnalyzeOnMainThread(Isolate* isolate); |
| |
| // Transition from kAnalyzed to kReadyToCompile (or kFailed). |
| void PrepareToCompileOnMainThread(Isolate* isolate); |
| |
| // Transition from kReadyToCompile to kCompiled. |
| void Compile(); |
| |
| // Transition from kCompiled to kDone (or kFailed). |
| void FinalizeCompilingOnMainThread(Isolate* isolate); |
| |
| DISALLOW_COPY_AND_ASSIGN(UnoptimizedCompileJob); |
| }; |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_COMPILER_DISPATCHER_UNOPTIMIZED_COMPILE_JOB_H_ |