1 // Copyright 2016 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 #ifndef V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_ 6 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_ 7 8 #include <memory> 9 10 #include "include/v8.h" 11 #include "src/base/macros.h" 12 #include "src/globals.h" 13 #include "src/handles.h" 14 #include "testing/gtest/include/gtest/gtest_prod.h" 15 16 namespace v8 { 17 namespace internal { 18 19 class AstValueFactory; 20 class CompilerDispatcherTracer; 21 class CompilationInfo; 22 class CompilationJob; 23 class DeferredHandles; 24 class FunctionLiteral; 25 class Isolate; 26 class ParseInfo; 27 class Parser; 28 class SharedFunctionInfo; 29 class String; 30 class UnicodeCache; 31 class Utf16CharacterStream; 32 33 enum class CompileJobStatus { 34 kInitial, 35 kReadyToParse, 36 kParsed, 37 kReadyToAnalyze, 38 kAnalyzed, 39 kReadyToCompile, 40 kCompiled, 41 kFailed, 42 kDone, 43 }; 44 45 class V8_EXPORT_PRIVATE CompilerDispatcherJob { 46 public: 47 // Creates a CompilerDispatcherJob in the initial state. 48 CompilerDispatcherJob(Isolate* isolate, CompilerDispatcherTracer* tracer, 49 Handle<SharedFunctionInfo> shared, 50 size_t max_stack_size); 51 // Creates a CompilerDispatcherJob in the analyzed state. 52 CompilerDispatcherJob(Isolate* isolate, CompilerDispatcherTracer* tracer, 53 Handle<Script> script, 54 Handle<SharedFunctionInfo> shared, 55 FunctionLiteral* literal, 56 std::shared_ptr<Zone> parse_zone, 57 std::shared_ptr<DeferredHandles> parse_handles, 58 std::shared_ptr<DeferredHandles> compile_handles, 59 size_t max_stack_size); 60 ~CompilerDispatcherJob(); 61 status()62 CompileJobStatus status() const { return status_; } 63 context()64 Context* context() { return *context_; } 65 66 // Returns true if this CompilerDispatcherJob was created for the given 67 // function. 68 bool IsAssociatedWith(Handle<SharedFunctionInfo> shared) const; 69 70 // Transition from kInitial to kReadyToParse. 71 void PrepareToParseOnMainThread(); 72 73 // Transition from kReadyToParse to kParsed. 74 void Parse(); 75 76 // Transition from kParsed to kReadyToAnalyze (or kFailed). Returns false 77 // when transitioning to kFailed. In that case, an exception is pending. 78 bool FinalizeParsingOnMainThread(); 79 80 // Transition from kReadyToAnalyze to kAnalyzed (or kFailed). Returns 81 // false when transitioning to kFailed. In that case, an exception is pending. 82 bool AnalyzeOnMainThread(); 83 84 // Transition from kAnalyzed to kReadyToCompile (or kFailed). Returns 85 // false when transitioning to kFailed. In that case, an exception is pending. 86 bool PrepareToCompileOnMainThread(); 87 88 // Transition from kReadyToCompile to kCompiled. 89 void Compile(); 90 91 // Transition from kCompiled to kDone (or kFailed). Returns false when 92 // transitioning to kFailed. In that case, an exception is pending. 93 bool FinalizeCompilingOnMainThread(); 94 95 // Transition from any state to kInitial and free all resources. 96 void ResetOnMainThread(); 97 98 // Estimate how long the next step will take using the tracer. 99 double EstimateRuntimeOfNextStepInMs() const; 100 101 // Even though the name does not imply this, ShortPrint() must only be invoked 102 // on the main thread. 103 void ShortPrint(); 104 105 private: 106 FRIEND_TEST(CompilerDispatcherJobTest, ScopeChain); 107 108 CompileJobStatus status_; 109 Isolate* isolate_; 110 CompilerDispatcherTracer* tracer_; 111 Handle<Context> context_; // Global handle. 112 Handle<SharedFunctionInfo> shared_; // Global handle. 113 Handle<String> source_; // Global handle. 114 Handle<String> wrapper_; // Global handle. 115 std::unique_ptr<v8::String::ExternalStringResourceBase> source_wrapper_; 116 size_t max_stack_size_; 117 118 // Members required for parsing. 119 std::unique_ptr<UnicodeCache> unicode_cache_; 120 std::unique_ptr<Utf16CharacterStream> character_stream_; 121 std::unique_ptr<ParseInfo> parse_info_; 122 std::unique_ptr<Parser> parser_; 123 124 // Members required for compiling a parsed function. 125 std::shared_ptr<Zone> parse_zone_; 126 127 // Members required for compiling. 128 std::unique_ptr<CompilationInfo> compile_info_; 129 std::unique_ptr<CompilationJob> compile_job_; 130 131 bool trace_compiler_dispatcher_jobs_; 132 133 DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherJob); 134 }; 135 136 } // namespace internal 137 } // namespace v8 138 139 #endif // V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_ 140