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_PARSING_PARSE_INFO_H_ 6 #define V8_PARSING_PARSE_INFO_H_ 7 8 #include <map> 9 #include <memory> 10 #include <vector> 11 12 #include "include/v8.h" 13 #include "src/base/export-template.h" 14 #include "src/common/globals.h" 15 #include "src/handles/handles.h" 16 #include "src/objects/function-kind.h" 17 #include "src/objects/function-syntax-kind.h" 18 #include "src/objects/script.h" 19 #include "src/parsing/pending-compilation-error-handler.h" 20 #include "src/parsing/preparse-data.h" 21 22 namespace v8 { 23 24 class Extension; 25 26 namespace internal { 27 28 class AccountingAllocator; 29 class AstRawString; 30 class AstStringConstants; 31 class AstValueFactory; 32 class CompilerDispatcher; 33 class DeclarationScope; 34 class FunctionLiteral; 35 class RuntimeCallStats; 36 class Logger; 37 class SourceRangeMap; 38 class Utf16CharacterStream; 39 class Zone; 40 41 // A container for the inputs, configuration options, and outputs of parsing. 42 class V8_EXPORT_PRIVATE ParseInfo { 43 public: 44 explicit ParseInfo(Isolate*); 45 ParseInfo(Isolate* isolate, Script script); 46 ParseInfo(Isolate* isolate, SharedFunctionInfo shared); 47 48 // Creates a new parse info based on parent top-level |outer_parse_info| for 49 // function |literal|. 50 static std::unique_ptr<ParseInfo> FromParent( 51 const ParseInfo* outer_parse_info, AccountingAllocator* zone_allocator, 52 const FunctionLiteral* literal, const AstRawString* function_name); 53 54 ~ParseInfo(); 55 56 template <typename LocalIsolate> 57 EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) 58 Handle<Script> CreateScript(LocalIsolate* isolate, Handle<String> source, 59 ScriptOriginOptions origin_options, 60 NativesFlag natives = NOT_NATIVES_CODE); 61 62 // Either returns the ast-value-factory associcated with this ParseInfo, or 63 // creates and returns a new factory if none exists. 64 AstValueFactory* GetOrCreateAstValueFactory(); 65 zone()66 Zone* zone() const { return zone_.get(); } 67 68 // Convenience accessor methods for flags. 69 #define FLAG_ACCESSOR(flag, getter, setter) \ 70 bool getter() const { return GetFlag(flag); } \ 71 void setter() { SetFlag(flag); } \ 72 void setter(bool val) { SetFlag(flag, val); } 73 FLAG_ACCESSOR(kToplevel,is_toplevel,set_toplevel)74 FLAG_ACCESSOR(kToplevel, is_toplevel, set_toplevel) 75 FLAG_ACCESSOR(kEager, is_eager, set_eager) 76 FLAG_ACCESSOR(kEval, is_eval, set_eval) 77 FLAG_ACCESSOR(kStrictMode, is_strict_mode, set_strict_mode) 78 FLAG_ACCESSOR(kModule, is_module, set_module) 79 FLAG_ACCESSOR(kAllowLazyParsing, allow_lazy_parsing, set_allow_lazy_parsing) 80 FLAG_ACCESSOR(kLazyCompile, lazy_compile, set_lazy_compile) 81 FLAG_ACCESSOR(kCollectTypeProfile, collect_type_profile, 82 set_collect_type_profile) 83 FLAG_ACCESSOR(kIsAsmWasmBroken, is_asm_wasm_broken, set_asm_wasm_broken) 84 FLAG_ACCESSOR(kContainsAsmModule, contains_asm_module, 85 set_contains_asm_module) 86 FLAG_ACCESSOR(kCoverageEnabled, coverage_enabled, set_coverage_enabled) 87 FLAG_ACCESSOR(kBlockCoverageEnabled, block_coverage_enabled, 88 set_block_coverage_enabled) 89 FLAG_ACCESSOR(kAllowEvalCache, allow_eval_cache, set_allow_eval_cache) 90 FLAG_ACCESSOR(kRequiresInstanceMembersInitializer, 91 requires_instance_members_initializer, 92 set_requires_instance_members_initializer) 93 FLAG_ACCESSOR(kClassScopeHasPrivateBrand, class_scope_has_private_brand, 94 set_class_scope_has_private_brand) 95 FLAG_ACCESSOR(kHasStaticPrivateMethodsOrAccessors, 96 has_static_private_methods_or_accessors, 97 set_has_static_private_methods_or_accessors) 98 FLAG_ACCESSOR(kMightAlwaysOpt, might_always_opt, set_might_always_opt) 99 FLAG_ACCESSOR(kAllowNativeSyntax, allow_natives_syntax, 100 set_allow_natives_syntax) 101 FLAG_ACCESSOR(kAllowLazyCompile, allow_lazy_compile, set_allow_lazy_compile) 102 FLAG_ACCESSOR(kAllowNativeSyntax, allow_native_syntax, 103 set_allow_native_syntax) 104 FLAG_ACCESSOR(kAllowHarmonyDynamicImport, allow_harmony_dynamic_import, 105 set_allow_harmony_dynamic_import) 106 FLAG_ACCESSOR(kAllowHarmonyImportMeta, allow_harmony_import_meta, 107 set_allow_harmony_import_meta) 108 FLAG_ACCESSOR(kAllowHarmonyOptionalChaining, allow_harmony_optional_chaining, 109 set_allow_harmony_optional_chaining) 110 FLAG_ACCESSOR(kAllowHarmonyPrivateMethods, allow_harmony_private_methods, 111 set_allow_harmony_private_methods) 112 FLAG_ACCESSOR(kIsOneshotIIFE, is_oneshot_iife, set_is_oneshot_iife) 113 FLAG_ACCESSOR(kCollectSourcePositions, collect_source_positions, 114 set_collect_source_positions) 115 FLAG_ACCESSOR(kAllowHarmonyNullish, allow_harmony_nullish, 116 set_allow_harmony_nullish) 117 FLAG_ACCESSOR(kAllowHarmonyTopLevelAwait, allow_harmony_top_level_await, 118 set_allow_harmony_top_level_await) 119 FLAG_ACCESSOR(kREPLMode, is_repl_mode, set_repl_mode) 120 121 #undef FLAG_ACCESSOR 122 123 void set_parse_restriction(ParseRestriction restriction) { 124 SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION); 125 } 126 parse_restriction()127 ParseRestriction parse_restriction() const { 128 return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL 129 : NO_PARSE_RESTRICTION; 130 } 131 character_stream()132 Utf16CharacterStream* character_stream() const { 133 return character_stream_.get(); 134 } 135 void set_character_stream( 136 std::unique_ptr<Utf16CharacterStream> character_stream); 137 void ResetCharacterStream(); 138 extension()139 v8::Extension* extension() const { return extension_; } set_extension(v8::Extension * extension)140 void set_extension(v8::Extension* extension) { extension_ = extension; } 141 set_consumed_preparse_data(std::unique_ptr<ConsumedPreparseData> data)142 void set_consumed_preparse_data(std::unique_ptr<ConsumedPreparseData> data) { 143 consumed_preparse_data_.swap(data); 144 } consumed_preparse_data()145 ConsumedPreparseData* consumed_preparse_data() { 146 return consumed_preparse_data_.get(); 147 } 148 script_scope()149 DeclarationScope* script_scope() const { return script_scope_; } set_script_scope(DeclarationScope * script_scope)150 void set_script_scope(DeclarationScope* script_scope) { 151 script_scope_ = script_scope; 152 } 153 ast_value_factory()154 AstValueFactory* ast_value_factory() const { 155 DCHECK(ast_value_factory_.get()); 156 return ast_value_factory_.get(); 157 } 158 function_name()159 const AstRawString* function_name() const { return function_name_; } set_function_name(const AstRawString * function_name)160 void set_function_name(const AstRawString* function_name) { 161 function_name_ = function_name; 162 } 163 literal()164 FunctionLiteral* literal() const { return literal_; } set_literal(FunctionLiteral * literal)165 void set_literal(FunctionLiteral* literal) { literal_ = literal; } 166 167 DeclarationScope* scope() const; 168 stack_limit()169 uintptr_t stack_limit() const { return stack_limit_; } set_stack_limit(uintptr_t stack_limit)170 void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; } 171 hash_seed()172 uint64_t hash_seed() const { return hash_seed_; } set_hash_seed(uint64_t hash_seed)173 void set_hash_seed(uint64_t hash_seed) { hash_seed_ = hash_seed; } 174 start_position()175 int start_position() const { return start_position_; } set_start_position(int start_position)176 void set_start_position(int start_position) { 177 start_position_ = start_position; 178 } 179 end_position()180 int end_position() const { return end_position_; } set_end_position(int end_position)181 void set_end_position(int end_position) { end_position_ = end_position; } 182 parameters_end_pos()183 int parameters_end_pos() const { return parameters_end_pos_; } set_parameters_end_pos(int parameters_end_pos)184 void set_parameters_end_pos(int parameters_end_pos) { 185 parameters_end_pos_ = parameters_end_pos; 186 } 187 function_literal_id()188 int function_literal_id() const { return function_literal_id_; } set_function_literal_id(int function_literal_id)189 void set_function_literal_id(int function_literal_id) { 190 function_literal_id_ = function_literal_id; 191 } 192 function_kind()193 FunctionKind function_kind() const { return function_kind_; } set_function_kind(FunctionKind function_kind)194 void set_function_kind(FunctionKind function_kind) { 195 function_kind_ = function_kind; 196 } 197 function_syntax_kind()198 FunctionSyntaxKind function_syntax_kind() const { 199 return function_syntax_kind_; 200 } set_function_syntax_kind(FunctionSyntaxKind function_syntax_kind)201 void set_function_syntax_kind(FunctionSyntaxKind function_syntax_kind) { 202 function_syntax_kind_ = function_syntax_kind; 203 } 204 is_wrapped_as_function()205 bool is_wrapped_as_function() const { 206 return function_syntax_kind() == FunctionSyntaxKind::kWrapped; 207 } 208 max_function_literal_id()209 int max_function_literal_id() const { return max_function_literal_id_; } set_max_function_literal_id(int max_function_literal_id)210 void set_max_function_literal_id(int max_function_literal_id) { 211 max_function_literal_id_ = max_function_literal_id; 212 } 213 ast_string_constants()214 const AstStringConstants* ast_string_constants() const { 215 return ast_string_constants_; 216 } set_ast_string_constants(const AstStringConstants * ast_string_constants)217 void set_ast_string_constants( 218 const AstStringConstants* ast_string_constants) { 219 ast_string_constants_ = ast_string_constants; 220 } 221 runtime_call_stats()222 RuntimeCallStats* runtime_call_stats() const { return runtime_call_stats_; } set_runtime_call_stats(RuntimeCallStats * runtime_call_stats)223 void set_runtime_call_stats(RuntimeCallStats* runtime_call_stats) { 224 runtime_call_stats_ = runtime_call_stats; 225 } logger()226 Logger* logger() const { return logger_; } set_logger(Logger * logger)227 void set_logger(Logger* logger) { logger_ = logger; } 228 229 void AllocateSourceRangeMap(); source_range_map()230 SourceRangeMap* source_range_map() const { return source_range_map_; } set_source_range_map(SourceRangeMap * source_range_map)231 void set_source_range_map(SourceRangeMap* source_range_map) { 232 source_range_map_ = source_range_map; 233 } 234 pending_error_handler()235 PendingCompilationErrorHandler* pending_error_handler() { 236 return &pending_error_handler_; 237 } 238 239 class ParallelTasks { 240 public: ParallelTasks(CompilerDispatcher * compiler_dispatcher)241 explicit ParallelTasks(CompilerDispatcher* compiler_dispatcher) 242 : dispatcher_(compiler_dispatcher) { 243 DCHECK(dispatcher_); 244 } 245 246 void Enqueue(ParseInfo* outer_parse_info, const AstRawString* function_name, 247 FunctionLiteral* literal); 248 249 using EnqueuedJobsIterator = 250 std::forward_list<std::pair<FunctionLiteral*, uintptr_t>>::iterator; 251 begin()252 EnqueuedJobsIterator begin() { return enqueued_jobs_.begin(); } end()253 EnqueuedJobsIterator end() { return enqueued_jobs_.end(); } 254 dispatcher()255 CompilerDispatcher* dispatcher() { return dispatcher_; } 256 257 private: 258 CompilerDispatcher* dispatcher_; 259 std::forward_list<std::pair<FunctionLiteral*, uintptr_t>> enqueued_jobs_; 260 }; 261 parallel_tasks()262 ParallelTasks* parallel_tasks() { return parallel_tasks_.get(); } 263 264 void SetFlagsForToplevelCompile(bool is_collecting_type_profile, 265 bool is_user_javascript, 266 LanguageMode language_mode, 267 REPLMode repl_mode); 268 269 void CheckFlagsForFunctionFromScript(Script script); 270 script_id()271 int script_id() const { return script_id_; } 272 //-------------------------------------------------------------------------- 273 language_mode()274 LanguageMode language_mode() const { 275 return construct_language_mode(is_strict_mode()); 276 } set_language_mode(LanguageMode language_mode)277 void set_language_mode(LanguageMode language_mode) { 278 STATIC_ASSERT(LanguageModeSize == 2); 279 set_strict_mode(is_strict(language_mode)); 280 } 281 282 private: 283 ParseInfo(AccountingAllocator* zone_allocator, int script_id); 284 ParseInfo(Isolate*, AccountingAllocator* zone_allocator, int script_id); 285 286 void SetFlagsForFunctionFromScript(Script script); 287 288 template <typename LocalIsolate> 289 void SetFlagsForToplevelCompileFromScript(LocalIsolate* isolate, 290 Script script, 291 bool is_collecting_type_profile); 292 void CheckFlagsForToplevelCompileFromScript(Script script, 293 bool is_collecting_type_profile); 294 295 // Set function info flags based on those in either FunctionLiteral or 296 // SharedFunctionInfo |function| 297 template <typename T> 298 void SetFunctionInfo(T function); 299 300 // Various configuration flags for parsing. 301 enum Flag : uint32_t { 302 // ---------- Input flags --------------------------- 303 kToplevel = 1u << 0, 304 kEager = 1u << 1, 305 kEval = 1u << 2, 306 kStrictMode = 1u << 3, 307 kNative = 1u << 4, 308 kParseRestriction = 1u << 5, 309 kModule = 1u << 6, 310 kAllowLazyParsing = 1u << 7, 311 kLazyCompile = 1u << 8, 312 kCollectTypeProfile = 1u << 9, 313 kCoverageEnabled = 1u << 10, 314 kBlockCoverageEnabled = 1u << 11, 315 kIsAsmWasmBroken = 1u << 12, 316 kAllowEvalCache = 1u << 13, 317 kRequiresInstanceMembersInitializer = 1u << 14, 318 kContainsAsmModule = 1u << 15, 319 kMightAlwaysOpt = 1u << 16, 320 kAllowLazyCompile = 1u << 17, 321 kAllowNativeSyntax = 1u << 18, 322 kAllowHarmonyPublicFields = 1u << 19, 323 kAllowHarmonyStaticFields = 1u << 20, 324 kAllowHarmonyDynamicImport = 1u << 21, 325 kAllowHarmonyImportMeta = 1u << 22, 326 kAllowHarmonyOptionalChaining = 1u << 23, 327 kHasStaticPrivateMethodsOrAccessors = 1u << 24, 328 kAllowHarmonyPrivateMethods = 1u << 25, 329 kIsOneshotIIFE = 1u << 26, 330 kCollectSourcePositions = 1u << 27, 331 kAllowHarmonyNullish = 1u << 28, 332 kAllowHarmonyTopLevelAwait = 1u << 29, 333 kREPLMode = 1u << 30, 334 kClassScopeHasPrivateBrand = 1u << 31, 335 }; 336 337 //------------- Inputs to parsing and scope analysis ----------------------- 338 std::unique_ptr<Zone> zone_; 339 uint32_t flags_; 340 v8::Extension* extension_; 341 DeclarationScope* script_scope_; 342 uintptr_t stack_limit_; 343 uint64_t hash_seed_; 344 FunctionKind function_kind_; 345 FunctionSyntaxKind function_syntax_kind_; 346 int script_id_; 347 int start_position_; 348 int end_position_; 349 int parameters_end_pos_; 350 int function_literal_id_; 351 int max_function_literal_id_; 352 353 //----------- Inputs+Outputs of parsing and scope analysis ----------------- 354 std::unique_ptr<Utf16CharacterStream> character_stream_; 355 std::unique_ptr<ConsumedPreparseData> consumed_preparse_data_; 356 std::unique_ptr<AstValueFactory> ast_value_factory_; 357 const class AstStringConstants* ast_string_constants_; 358 const AstRawString* function_name_; 359 RuntimeCallStats* runtime_call_stats_; 360 Logger* logger_; 361 SourceRangeMap* source_range_map_; // Used when block coverage is enabled. 362 std::unique_ptr<ParallelTasks> parallel_tasks_; 363 364 //----------- Output of parsing and scope analysis ------------------------ 365 FunctionLiteral* literal_; 366 PendingCompilationErrorHandler pending_error_handler_; 367 SetFlag(Flag f)368 void SetFlag(Flag f) { flags_ |= f; } SetFlag(Flag f,bool v)369 void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; } GetFlag(Flag f)370 bool GetFlag(Flag f) const { return (flags_ & f) != 0; } 371 }; 372 373 } // namespace internal 374 } // namespace v8 375 376 #endif // V8_PARSING_PARSE_INFO_H_ 377