parse-info.h 10.5 KB
Newer Older
1 2 3 4 5 6 7
// 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_PARSING_PARSE_INFO_H_
#define V8_PARSING_PARSE_INFO_H_

8
#include <map>
9
#include <memory>
10
#include <vector>
11

12 13 14
#include "include/v8.h"
#include "src/globals.h"
#include "src/handles.h"
15
#include "src/parsing/preparsed-scope-data.h"
16
#include "src/pending-compilation-error-handler.h"
17 18 19 20 21 22 23

namespace v8 {

class Extension;

namespace internal {

24
class AccountingAllocator;
25
class AstRawString;
26
class AstStringConstants;
27 28 29
class AstValueFactory;
class DeclarationScope;
class FunctionLiteral;
30
class RuntimeCallStats;
31
class Logger;
32
class ScriptData;
33
class SourceRangeMap;
34 35 36 37 38
class UnicodeCache;
class Utf16CharacterStream;
class Zone;

// A container for the inputs, configuration options, and outputs of parsing.
39
class V8_EXPORT_PRIVATE ParseInfo {
40
 public:
41 42 43 44
  explicit ParseInfo(AccountingAllocator* zone_allocator);
  ParseInfo(Handle<Script> script);
  ParseInfo(Handle<SharedFunctionInfo> shared);

45
  ~ParseInfo();
46

47 48
  void InitFromIsolate(Isolate* isolate);

49 50
  static ParseInfo* AllocateWithoutScript(Handle<SharedFunctionInfo> shared);

51 52 53 54
  // Either returns the ast-value-factory associcated with this ParseInfo, or
  // creates and returns a new factory if none exists.
  AstValueFactory* GetOrCreateAstValueFactory();

55 56
  Zone* zone() const { return zone_.get(); }

57 58
  // Sets this parse info to share the same zone as |other|
  void ShareZone(ParseInfo* other);
59

60 61
  // Sets this parse info to share the same ast value factory as |other|
  void ShareAstValueFactory(ParseInfo* other);
62

63 64 65 66 67 68 69
// Convenience accessor methods for flags.
#define FLAG_ACCESSOR(flag, getter, setter)     \
  bool getter() const { return GetFlag(flag); } \
  void setter() { SetFlag(flag); }              \
  void setter(bool val) { SetFlag(flag, val); }

  FLAG_ACCESSOR(kToplevel, is_toplevel, set_toplevel)
70
  FLAG_ACCESSOR(kEager, is_eager, set_eager)
71 72 73 74 75 76 77
  FLAG_ACCESSOR(kEval, is_eval, set_eval)
  FLAG_ACCESSOR(kStrictMode, is_strict_mode, set_strict_mode)
  FLAG_ACCESSOR(kNative, is_native, set_native)
  FLAG_ACCESSOR(kModule, is_module, set_module)
  FLAG_ACCESSOR(kAllowLazyParsing, allow_lazy_parsing, set_allow_lazy_parsing)
  FLAG_ACCESSOR(kIsNamedExpression, is_named_expression,
                set_is_named_expression)
78
  FLAG_ACCESSOR(kLazyCompile, lazy_compile, set_lazy_compile)
79 80
  FLAG_ACCESSOR(kCollectTypeProfile, collect_type_profile,
                set_collect_type_profile)
81 82 83
  FLAG_ACCESSOR(kIsAsmWasmBroken, is_asm_wasm_broken, set_asm_wasm_broken)
  FLAG_ACCESSOR(kBlockCoverageEnabled, block_coverage_enabled,
                set_block_coverage_enabled)
84 85
  FLAG_ACCESSOR(kOnBackgroundThread, on_background_thread,
                set_on_background_thread)
86 87
  FLAG_ACCESSOR(kWrappedAsFunction, is_wrapped_as_function,
                set_wrapped_as_function)
88 89 90 91 92 93 94 95 96 97 98
#undef FLAG_ACCESSOR

  void set_parse_restriction(ParseRestriction restriction) {
    SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION);
  }

  ParseRestriction parse_restriction() const {
    return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL
                                      : NO_PARSE_RESTRICTION;
  }

99 100
  Utf16CharacterStream* character_stream() const {
    return character_stream_.get();
101
  }
102 103 104
  void set_character_stream(
      std::unique_ptr<Utf16CharacterStream> character_stream);
  void ResetCharacterStream();
105 106 107 108 109 110 111

  v8::Extension* extension() const { return extension_; }
  void set_extension(v8::Extension* extension) { extension_ = extension; }

  ScriptData** cached_data() const { return cached_data_; }
  void set_cached_data(ScriptData** cached_data) { cached_data_ = cached_data; }

112 113 114
  ConsumedPreParsedScopeData* consumed_preparsed_scope_data() {
    return &consumed_preparsed_scope_data_;
  }
115

116 117 118 119 120 121 122 123 124 125 126 127
  ScriptCompiler::CompileOptions compile_options() const {
    return compile_options_;
  }
  void set_compile_options(ScriptCompiler::CompileOptions compile_options) {
    compile_options_ = compile_options;
  }

  DeclarationScope* script_scope() const { return script_scope_; }
  void set_script_scope(DeclarationScope* script_scope) {
    script_scope_ = script_scope;
  }

128 129 130
  AstValueFactory* ast_value_factory() const {
    DCHECK(ast_value_factory_.get());
    return ast_value_factory_.get();
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
  }

  const AstRawString* function_name() const { return function_name_; }
  void set_function_name(const AstRawString* function_name) {
    function_name_ = function_name;
  }

  FunctionLiteral* literal() const { return literal_; }
  void set_literal(FunctionLiteral* literal) { literal_ = literal; }

  DeclarationScope* scope() const;

  UnicodeCache* unicode_cache() const { return unicode_cache_; }
  void set_unicode_cache(UnicodeCache* unicode_cache) {
    unicode_cache_ = unicode_cache;
  }

  uintptr_t stack_limit() const { return stack_limit_; }
  void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; }

  uint32_t hash_seed() const { return hash_seed_; }
  void set_hash_seed(uint32_t hash_seed) { hash_seed_ = hash_seed; }

  int compiler_hints() const { return compiler_hints_; }
  void set_compiler_hints(int compiler_hints) {
    compiler_hints_ = compiler_hints;
  }

  int start_position() const { return start_position_; }
  void set_start_position(int start_position) {
    start_position_ = start_position;
  }

  int end_position() const { return end_position_; }
  void set_end_position(int end_position) { end_position_ = end_position; }

167 168 169 170 171
  int parameters_end_pos() const { return parameters_end_pos_; }
  void set_parameters_end_pos(int parameters_end_pos) {
    parameters_end_pos_ = parameters_end_pos;
  }

172 173 174 175 176
  int function_literal_id() const { return function_literal_id_; }
  void set_function_literal_id(int function_literal_id) {
    function_literal_id_ = function_literal_id;
  }

177 178 179 180 181
  int max_function_literal_id() const { return max_function_literal_id_; }
  void set_max_function_literal_id(int max_function_literal_id) {
    max_function_literal_id_ = max_function_literal_id;
  }

182 183 184 185 186 187 188 189 190 191 192 193
  const AstStringConstants* ast_string_constants() const {
    return ast_string_constants_;
  }
  void set_ast_string_constants(
      const AstStringConstants* ast_string_constants) {
    ast_string_constants_ = ast_string_constants;
  }

  RuntimeCallStats* runtime_call_stats() const { return runtime_call_stats_; }
  void set_runtime_call_stats(RuntimeCallStats* runtime_call_stats) {
    runtime_call_stats_ = runtime_call_stats;
  }
194 195
  Logger* logger() const { return logger_; }
  void set_logger(Logger* logger) { logger_ = logger; }
196

197
  void AllocateSourceRangeMap();
198 199 200 201 202
  SourceRangeMap* source_range_map() const { return source_range_map_; }
  void set_source_range_map(SourceRangeMap* source_range_map) {
    source_range_map_ = source_range_map;
  }

203 204 205 206
  PendingCompilationErrorHandler* pending_error_handler() {
    return &pending_error_handler_;
  }

207 208 209
  // Getters for individual compiler hints.
  bool is_declaration() const;
  FunctionKind function_kind() const;
210
  bool requires_instance_fields_initializer() const;
211 212 213 214 215

  //--------------------------------------------------------------------------
  // TODO(titzer): these should not be part of ParseInfo.
  //--------------------------------------------------------------------------
  Handle<Script> script() const { return script_; }
216 217 218
  MaybeHandle<ScopeInfo> maybe_outer_scope_info() const {
    return maybe_outer_scope_info_;
  }
219
  void clear_script() { script_ = Handle<Script>::null(); }
220 221 222
  void set_outer_scope_info(Handle<ScopeInfo> outer_scope_info) {
    maybe_outer_scope_info_ = outer_scope_info;
  }
223 224 225 226 227 228 229
  void set_script(Handle<Script> script) { script_ = script; }
  //--------------------------------------------------------------------------

  LanguageMode language_mode() const {
    return construct_language_mode(is_strict_mode());
  }
  void set_language_mode(LanguageMode language_mode) {
230
    STATIC_ASSERT(LanguageModeSize == 2);
231 232 233 234
    set_strict_mode(is_strict(language_mode));
  }

  void ReopenHandlesInNewHandleScope() {
235 236 237
    if (!script_.is_null()) {
      script_ = Handle<Script>(*script_);
    }
238 239 240 241
    Handle<ScopeInfo> outer_scope_info;
    if (maybe_outer_scope_info_.ToHandle(&outer_scope_info)) {
      maybe_outer_scope_info_ = Handle<ScopeInfo>(*outer_scope_info);
    }
242 243
  }

244 245
  void EmitBackgroundParseStatisticsOnBackgroundThread();
  void UpdateBackgroundParseStatisticsOnMainThread(Isolate* isolate);
246

247 248 249 250 251
 private:
  // Various configuration flags for parsing.
  enum Flag {
    // ---------- Input flags ---------------------------
    kToplevel = 1 << 0,
252
    kEager = 1 << 1,
253
    kEval = 1 << 2,
254 255 256 257 258 259
    kStrictMode = 1 << 3,
    kNative = 1 << 4,
    kParseRestriction = 1 << 5,
    kModule = 1 << 6,
    kAllowLazyParsing = 1 << 7,
    kIsNamedExpression = 1 << 8,
260 261 262 263
    kLazyCompile = 1 << 9,
    kCollectTypeProfile = 1 << 10,
    kBlockCoverageEnabled = 1 << 11,
    kIsAsmWasmBroken = 1 << 12,
264 265
    kOnBackgroundThread = 1 << 13,
    kWrappedAsFunction = 1 << 14,  // Implicitly wrapped as function.
266 267 268
  };

  //------------- Inputs to parsing and scope analysis -----------------------
269
  std::shared_ptr<Zone> zone_;
270 271 272 273 274 275 276 277 278 279
  unsigned flags_;
  v8::Extension* extension_;
  ScriptCompiler::CompileOptions compile_options_;
  DeclarationScope* script_scope_;
  UnicodeCache* unicode_cache_;
  uintptr_t stack_limit_;
  uint32_t hash_seed_;
  int compiler_hints_;
  int start_position_;
  int end_position_;
280
  int parameters_end_pos_;
281
  int function_literal_id_;
282
  int max_function_literal_id_;
283

284
  // TODO(titzer): Move handles out of ParseInfo.
285
  Handle<Script> script_;
286
  MaybeHandle<ScopeInfo> maybe_outer_scope_info_;
287 288

  //----------- Inputs+Outputs of parsing and scope analysis -----------------
289
  std::unique_ptr<Utf16CharacterStream> character_stream_;
290
  ScriptData** cached_data_;  // used if available, populated if requested.
291
  ConsumedPreParsedScopeData consumed_preparsed_scope_data_;
292
  std::shared_ptr<AstValueFactory> ast_value_factory_;
293
  const class AstStringConstants* ast_string_constants_;
294
  const AstRawString* function_name_;
295
  RuntimeCallStats* runtime_call_stats_;
296
  Logger* logger_;
297
  SourceRangeMap* source_range_map_;  // Used when block coverage is enabled.
298 299 300

  //----------- Output of parsing and scope analysis ------------------------
  FunctionLiteral* literal_;
301
  std::shared_ptr<DeferredHandles> deferred_handles_;
302
  PendingCompilationErrorHandler pending_error_handler_;
303 304 305 306 307 308 309 310 311 312

  void SetFlag(Flag f) { flags_ |= f; }
  void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
  bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
};

}  // namespace internal
}  // namespace v8

#endif  // V8_PARSING_PARSE_INFO_H_