parse-info.h 10 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 ScriptData;
32
class SourceRangeMap;
33 34 35 36 37
class UnicodeCache;
class Utf16CharacterStream;
class Zone;

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

44
  ~ParseInfo();
45

46 47
  void InitFromIsolate(Isolate* isolate);

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

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

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

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

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

62 63 64 65 66 67 68
// 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)
69
  FLAG_ACCESSOR(kEager, is_eager, set_eager)
70 71 72 73 74 75 76
  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)
77
  FLAG_ACCESSOR(kSerializing, will_serialize, set_will_serialize)
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 86 87 88 89 90 91 92 93 94
#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;
  }

95 96
  Utf16CharacterStream* character_stream() const {
    return character_stream_.get();
97
  }
98 99 100
  void set_character_stream(
      std::unique_ptr<Utf16CharacterStream> character_stream);
  void ResetCharacterStream();
101 102 103 104 105 106 107

  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; }

108 109 110
  ConsumedPreParsedScopeData* consumed_preparsed_scope_data() {
    return &consumed_preparsed_scope_data_;
  }
111

112 113 114 115 116 117 118 119 120 121 122 123
  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;
  }

124 125 126
  AstValueFactory* ast_value_factory() const {
    DCHECK(ast_value_factory_.get());
    return ast_value_factory_.get();
127 128 129 130 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
  }

  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; }

163 164 165 166 167
  int parameters_end_pos() const { return parameters_end_pos_; }
  void set_parameters_end_pos(int parameters_end_pos) {
    parameters_end_pos_ = parameters_end_pos;
  }

168 169 170 171 172
  int function_literal_id() const { return function_literal_id_; }
  void set_function_literal_id(int function_literal_id) {
    function_literal_id_ = function_literal_id;
  }

173 174 175 176 177
  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;
  }

178 179 180 181 182 183 184 185 186 187 188 189 190
  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;
  }

191
  void AllocateSourceRangeMap();
192 193 194 195 196
  SourceRangeMap* source_range_map() const { return source_range_map_; }
  void set_source_range_map(SourceRangeMap* source_range_map) {
    source_range_map_ = source_range_map;
  }

197 198 199 200
  PendingCompilationErrorHandler* pending_error_handler() {
    return &pending_error_handler_;
  }

201 202 203 204 205 206 207 208
  // Getters for individual compiler hints.
  bool is_declaration() const;
  FunctionKind function_kind() const;

  //--------------------------------------------------------------------------
  // TODO(titzer): these should not be part of ParseInfo.
  //--------------------------------------------------------------------------
  Handle<Script> script() const { return script_; }
209 210 211
  MaybeHandle<ScopeInfo> maybe_outer_scope_info() const {
    return maybe_outer_scope_info_;
  }
212
  void clear_script() { script_ = Handle<Script>::null(); }
213 214 215
  void set_outer_scope_info(Handle<ScopeInfo> outer_scope_info) {
    maybe_outer_scope_info_ = outer_scope_info;
  }
216 217 218 219 220 221 222
  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) {
223
    STATIC_ASSERT(LanguageModeSize == 2);
224 225 226 227
    set_strict_mode(is_strict(language_mode));
  }

  void ReopenHandlesInNewHandleScope() {
228 229 230
    if (!script_.is_null()) {
      script_ = Handle<Script>(*script_);
    }
231 232 233 234
    Handle<ScopeInfo> outer_scope_info;
    if (maybe_outer_scope_info_.ToHandle(&outer_scope_info)) {
      maybe_outer_scope_info_ = Handle<ScopeInfo>(*outer_scope_info);
    }
235 236
  }

237 238
  void UpdateStatisticsAfterBackgroundParse(Isolate* isolate);

239 240 241 242 243
 private:
  // Various configuration flags for parsing.
  enum Flag {
    // ---------- Input flags ---------------------------
    kToplevel = 1 << 0,
244
    kEager = 1 << 1,
245
    kEval = 1 << 2,
246 247 248 249 250 251
    kStrictMode = 1 << 3,
    kNative = 1 << 4,
    kParseRestriction = 1 << 5,
    kModule = 1 << 6,
    kAllowLazyParsing = 1 << 7,
    kIsNamedExpression = 1 << 8,
252 253 254 255 256
    kSerializing = 1 << 9,
    kLazyCompile = 1 << 10,
    kCollectTypeProfile = 1 << 11,
    kBlockCoverageEnabled = 1 << 12,
    kIsAsmWasmBroken = 1 << 13,
257 258 259
  };

  //------------- Inputs to parsing and scope analysis -----------------------
260
  std::shared_ptr<Zone> zone_;
261 262 263 264 265 266 267 268 269 270
  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_;
271
  int parameters_end_pos_;
272
  int function_literal_id_;
273
  int max_function_literal_id_;
274

275
  // TODO(titzer): Move handles out of ParseInfo.
276
  Handle<Script> script_;
277
  MaybeHandle<ScopeInfo> maybe_outer_scope_info_;
278 279

  //----------- Inputs+Outputs of parsing and scope analysis -----------------
280
  std::unique_ptr<Utf16CharacterStream> character_stream_;
281
  ScriptData** cached_data_;  // used if available, populated if requested.
282
  ConsumedPreParsedScopeData consumed_preparsed_scope_data_;
283
  std::shared_ptr<AstValueFactory> ast_value_factory_;
284
  const class AstStringConstants* ast_string_constants_;
285
  const AstRawString* function_name_;
286
  RuntimeCallStats* runtime_call_stats_;
287
  SourceRangeMap* source_range_map_;  // Used when block coverage is enabled.
288 289 290

  //----------- Output of parsing and scope analysis ------------------------
  FunctionLiteral* literal_;
291
  std::shared_ptr<DeferredHandles> deferred_handles_;
292
  PendingCompilationErrorHandler pending_error_handler_;
293 294 295 296 297 298 299 300 301 302

  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_