Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/compiler.h b/src/compiler.h
index 3db32ce..9b43939 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -6,8 +6,10 @@
#define V8_COMPILER_H_
#include "src/allocation.h"
-#include "src/ast.h"
+#include "src/ast/ast.h"
#include "src/bailout-reason.h"
+#include "src/compilation-dependencies.h"
+#include "src/signature.h"
#include "src/zone.h"
namespace v8 {
@@ -15,53 +17,89 @@
class AstValueFactory;
class HydrogenCodeStub;
-
-// ParseRestriction is used to restrict the set of valid statements in a
-// unit of compilation. Restriction violations cause a syntax error.
-enum ParseRestriction {
- NO_PARSE_RESTRICTION, // All expressions are allowed.
- ONLY_SINGLE_FUNCTION_LITERAL // Only a single FunctionLiteral expression.
-};
-
-struct OffsetRange {
- OffsetRange(int from, int to) : from(from), to(to) {}
- int from;
- int to;
-};
+class JavaScriptFrame;
+class ParseInfo;
+class ScriptData;
-class ScriptData {
+// This class encapsulates encoding and decoding of sources positions from
+// which hydrogen values originated.
+// When FLAG_track_hydrogen_positions is set this object encodes the
+// identifier of the inlining and absolute offset from the start of the
+// inlined function.
+// When the flag is not set we simply track absolute offset from the
+// script start.
+class SourcePosition {
public:
- ScriptData(const byte* data, int length);
- ~ScriptData() {
- if (owns_data_) DeleteArray(data_);
+ static SourcePosition Unknown() {
+ return SourcePosition::FromRaw(kNoPosition);
}
- const byte* data() const { return data_; }
- int length() const { return length_; }
- bool rejected() const { return rejected_; }
+ bool IsUnknown() const { return value_ == kNoPosition; }
- void Reject() { rejected_ = true; }
-
- void AcquireDataOwnership() {
- DCHECK(!owns_data_);
- owns_data_ = true;
+ uint32_t position() const { return PositionField::decode(value_); }
+ void set_position(uint32_t position) {
+ if (FLAG_hydrogen_track_positions) {
+ value_ = static_cast<uint32_t>(PositionField::update(value_, position));
+ } else {
+ value_ = position;
+ }
}
- void ReleaseDataOwnership() {
- DCHECK(owns_data_);
- owns_data_ = false;
+ uint32_t inlining_id() const { return InliningIdField::decode(value_); }
+ void set_inlining_id(uint32_t inlining_id) {
+ if (FLAG_hydrogen_track_positions) {
+ value_ =
+ static_cast<uint32_t>(InliningIdField::update(value_, inlining_id));
+ }
}
+ uint32_t raw() const { return value_; }
+
private:
- bool owns_data_ : 1;
- bool rejected_ : 1;
- const byte* data_;
- int length_;
+ static const uint32_t kNoPosition =
+ static_cast<uint32_t>(RelocInfo::kNoPosition);
+ typedef BitField<uint32_t, 0, 9> InliningIdField;
- DISALLOW_COPY_AND_ASSIGN(ScriptData);
+ // Offset from the start of the inlined function.
+ typedef BitField<uint32_t, 9, 23> PositionField;
+
+ friend class HPositionInfo;
+ friend class Deoptimizer;
+
+ static SourcePosition FromRaw(uint32_t raw_position) {
+ SourcePosition position;
+ position.value_ = raw_position;
+ return position;
+ }
+
+ // If FLAG_hydrogen_track_positions is set contains bitfields InliningIdField
+ // and PositionField.
+ // Otherwise contains absolute offset from the script start.
+ uint32_t value_;
};
+
+std::ostream& operator<<(std::ostream& os, const SourcePosition& p);
+
+
+struct InlinedFunctionInfo {
+ InlinedFunctionInfo(int parent_id, SourcePosition inline_position,
+ int script_id, int start_position)
+ : parent_id(parent_id),
+ inline_position(inline_position),
+ script_id(script_id),
+ start_position(start_position) {}
+ int parent_id;
+ SourcePosition inline_position;
+ int script_id;
+ int start_position;
+ std::vector<size_t> deopt_pc_offsets;
+
+ static const int kNoParentId = -1;
+};
+
+
// CompilationInfo encapsulates some information known at compile time. It
// is constructed based on the resources available at compile-time.
class CompilationInfo {
@@ -69,100 +107,76 @@
// Various configuration flags for a compilation, as well as some properties
// of the compiled code produced by a compilation.
enum Flag {
- kLazy = 1 << 0,
- kEval = 1 << 1,
- kGlobal = 1 << 2,
- kStrictMode = 1 << 3,
- kThisHasUses = 1 << 4,
- kNative = 1 << 5,
- kDeferredCalling = 1 << 6,
- kNonDeferredCalling = 1 << 7,
- kSavesCallerDoubles = 1 << 8,
- kRequiresFrame = 1 << 9,
- kMustNotHaveEagerFrame = 1 << 10,
- kDeoptimizationSupport = 1 << 11,
- kDebug = 1 << 12,
- kCompilingForDebugging = 1 << 13,
- kParseRestriction = 1 << 14,
- kSerializing = 1 << 15,
- kContextSpecializing = 1 << 16,
- kInliningEnabled = 1 << 17,
- kTypingEnabled = 1 << 18,
- kDisableFutureOptimization = 1 << 19,
- kToplevel = 1 << 20
+ kDeferredCalling = 1 << 0,
+ kNonDeferredCalling = 1 << 1,
+ kSavesCallerDoubles = 1 << 2,
+ kRequiresFrame = 1 << 3,
+ kMustNotHaveEagerFrame = 1 << 4,
+ kDeoptimizationSupport = 1 << 5,
+ kDebug = 1 << 6,
+ kSerializing = 1 << 7,
+ kFunctionContextSpecializing = 1 << 8,
+ kFrameSpecializing = 1 << 9,
+ kNativeContextSpecializing = 1 << 10,
+ kInliningEnabled = 1 << 11,
+ kTypingEnabled = 1 << 12,
+ kDisableFutureOptimization = 1 << 13,
+ kSplittingEnabled = 1 << 14,
+ kDeoptimizationEnabled = 1 << 16,
+ kSourcePositionsEnabled = 1 << 17,
+ kFirstCompile = 1 << 18,
};
- CompilationInfo(Handle<JSFunction> closure, Zone* zone);
- CompilationInfo(Isolate* isolate, Zone* zone);
+ explicit CompilationInfo(ParseInfo* parse_info);
+ CompilationInfo(CodeStub* stub, Isolate* isolate, Zone* zone);
+ CompilationInfo(const char* debug_name, Isolate* isolate, Zone* zone);
virtual ~CompilationInfo();
+ ParseInfo* parse_info() const { return parse_info_; }
+
+ // -----------------------------------------------------------
+ // TODO(titzer): inline and delete accessors of ParseInfo
+ // -----------------------------------------------------------
+ Handle<Script> script() const;
+ bool is_eval() const;
+ bool is_native() const;
+ bool is_module() const;
+ LanguageMode language_mode() const;
+ Handle<JSFunction> closure() const;
+ FunctionLiteral* literal() const;
+ Scope* scope() const;
+ Handle<Context> context() const;
+ Handle<SharedFunctionInfo> shared_info() const;
+ bool has_shared_info() const;
+ bool has_context() const;
+ bool has_literal() const;
+ bool has_scope() const;
+ // -----------------------------------------------------------
+
Isolate* isolate() const {
return isolate_;
}
Zone* zone() { return zone_; }
bool is_osr() const { return !osr_ast_id_.IsNone(); }
- bool is_lazy() const { return GetFlag(kLazy); }
- bool is_eval() const { return GetFlag(kEval); }
- bool is_global() const { return GetFlag(kGlobal); }
- StrictMode strict_mode() const {
- return GetFlag(kStrictMode) ? STRICT : SLOPPY;
- }
- FunctionLiteral* function() const { return function_; }
- Scope* scope() const { return scope_; }
- Scope* script_scope() const { return script_scope_; }
Handle<Code> code() const { return code_; }
- Handle<JSFunction> closure() const { return closure_; }
- Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
- Handle<Script> script() const { return script_; }
- void set_script(Handle<Script> script) { script_ = script; }
- HydrogenCodeStub* code_stub() const {return code_stub_; }
- v8::Extension* extension() const { return extension_; }
- ScriptData** cached_data() const { return cached_data_; }
- ScriptCompiler::CompileOptions compile_options() const {
- return compile_options_;
- }
- ScriptCompiler::ExternalSourceStream* source_stream() const {
- return source_stream_;
- }
- ScriptCompiler::StreamedSource::Encoding source_stream_encoding() const {
- return source_stream_encoding_;
- }
- Handle<Context> context() const { return context_; }
+ CodeStub* code_stub() const { return code_stub_; }
BailoutId osr_ast_id() const { return osr_ast_id_; }
Handle<Code> unoptimized_code() const { return unoptimized_code_; }
int opt_count() const { return opt_count_; }
int num_parameters() const;
+ int num_parameters_including_this() const;
+ bool is_this_defined() const;
int num_heap_slots() const;
- Code::Flags flags() const;
-
- void MarkAsEval() {
- DCHECK(!is_lazy());
- SetFlag(kEval);
- }
-
- void MarkAsGlobal() {
- DCHECK(!is_lazy());
- SetFlag(kGlobal);
- }
void set_parameter_count(int parameter_count) {
DCHECK(IsStub());
parameter_count_ = parameter_count;
}
- void set_this_has_uses(bool has_no_uses) {
- SetFlag(kThisHasUses, has_no_uses);
- }
+ bool has_bytecode_array() const { return !bytecode_array_.is_null(); }
+ Handle<BytecodeArray> bytecode_array() const { return bytecode_array_; }
- bool this_has_uses() { return GetFlag(kThisHasUses); }
-
- void SetStrictMode(StrictMode strict_mode) {
- SetFlag(kStrictMode, strict_mode == STRICT);
- }
-
- void MarkAsNative() { SetFlag(kNative); }
-
- bool is_native() const { return GetFlag(kNative); }
+ bool is_tracking_positions() const { return track_positions_; }
bool is_calling() const {
return GetFlag(kDeferredCalling) || GetFlag(kNonDeferredCalling);
@@ -190,7 +204,13 @@
return GetFlag(kMustNotHaveEagerFrame);
}
- void MarkAsDebug() { SetFlag(kDebug); }
+ // Compiles marked as debug produce unoptimized code with debug break slots.
+ // Inner functions that cannot be compiled w/o context are compiled eagerly.
+ // Always include deoptimization support to avoid having to recompile again.
+ void MarkAsDebug() {
+ SetFlag(kDebug);
+ SetFlag(kDeoptimizationSupport);
+ }
bool is_debug() const { return GetFlag(kDebug); }
@@ -198,9 +218,37 @@
bool will_serialize() const { return GetFlag(kSerializing); }
- void MarkAsContextSpecializing() { SetFlag(kContextSpecializing); }
+ void MarkAsFunctionContextSpecializing() {
+ SetFlag(kFunctionContextSpecializing);
+ }
- bool is_context_specializing() const { return GetFlag(kContextSpecializing); }
+ bool is_function_context_specializing() const {
+ return GetFlag(kFunctionContextSpecializing);
+ }
+
+ void MarkAsFrameSpecializing() { SetFlag(kFrameSpecializing); }
+
+ bool is_frame_specializing() const { return GetFlag(kFrameSpecializing); }
+
+ void MarkAsNativeContextSpecializing() {
+ SetFlag(kNativeContextSpecializing);
+ }
+
+ bool is_native_context_specializing() const {
+ return GetFlag(kNativeContextSpecializing);
+ }
+
+ void MarkAsDeoptimizationEnabled() { SetFlag(kDeoptimizationEnabled); }
+
+ bool is_deoptimization_enabled() const {
+ return GetFlag(kDeoptimizationEnabled);
+ }
+
+ void MarkAsSourcePositionsEnabled() { SetFlag(kSourcePositionsEnabled); }
+
+ bool is_source_positions_enabled() const {
+ return GetFlag(kSourcePositionsEnabled);
+ }
void MarkAsInliningEnabled() { SetFlag(kInliningEnabled); }
@@ -210,60 +258,32 @@
bool is_typing_enabled() const { return GetFlag(kTypingEnabled); }
- void MarkAsToplevel() { SetFlag(kToplevel); }
+ void MarkAsSplittingEnabled() { SetFlag(kSplittingEnabled); }
- bool is_toplevel() const { return GetFlag(kToplevel); }
+ bool is_splitting_enabled() const { return GetFlag(kSplittingEnabled); }
- bool IsCodePreAgingActive() const {
+ void MarkAsFirstCompile() { SetFlag(kFirstCompile); }
+
+ void MarkAsCompiled() { SetFlag(kFirstCompile, false); }
+
+ bool is_first_compile() const { return GetFlag(kFirstCompile); }
+
+ bool GeneratePreagedPrologue() const {
+ // Generate a pre-aged prologue if we are optimizing for size, which
+ // will make code flushing more aggressive. Only apply to Code::FUNCTION,
+ // since StaticMarkingVisitor::IsFlushable only flushes proper functions.
return FLAG_optimize_for_size && FLAG_age_code && !will_serialize() &&
- !is_debug();
+ !is_debug() && output_code_kind_ == Code::FUNCTION;
}
- void SetParseRestriction(ParseRestriction restriction) {
- SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION);
- }
-
- ParseRestriction parse_restriction() const {
- return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL
- : NO_PARSE_RESTRICTION;
- }
-
- void SetFunction(FunctionLiteral* literal) {
- DCHECK(function_ == NULL);
- function_ = literal;
- }
- void PrepareForCompilation(Scope* scope);
- void SetScriptScope(Scope* script_scope) {
- DCHECK(script_scope_ == NULL);
- script_scope_ = script_scope;
- }
void EnsureFeedbackVector();
Handle<TypeFeedbackVector> feedback_vector() const {
return feedback_vector_;
}
void SetCode(Handle<Code> code) { code_ = code; }
- void SetExtension(v8::Extension* extension) {
- DCHECK(!is_lazy());
- extension_ = extension;
- }
- void SetCachedData(ScriptData** cached_data,
- ScriptCompiler::CompileOptions compile_options) {
- compile_options_ = compile_options;
- if (compile_options == ScriptCompiler::kNoCompileOptions) {
- cached_data_ = NULL;
- } else {
- DCHECK(!is_lazy());
- cached_data_ = cached_data;
- }
- }
- void SetContext(Handle<Context> context) {
- context_ = context;
- }
- void MarkCompilingForDebugging() { SetFlag(kCompilingForDebugging); }
- bool IsCompilingForDebugging() { return GetFlag(kCompilingForDebugging); }
- void MarkNonOptimizable() {
- SetMode(CompilationInfo::NONOPT);
+ void SetBytecodeArray(Handle<BytecodeArray> bytecode_array) {
+ bytecode_array_ = bytecode_array;
}
bool ShouldTrapOnDeopt() const {
@@ -271,25 +291,30 @@
(FLAG_trap_on_stub_deopt && IsStub());
}
- bool has_global_object() const {
- return !closure().is_null() &&
- (closure()->context()->global_object() != NULL);
+ bool has_native_context() const {
+ return !closure().is_null() && (closure()->native_context() != nullptr);
}
- GlobalObject* global_object() const {
- return has_global_object() ? closure()->context()->global_object() : NULL;
+ Context* native_context() const {
+ return has_native_context() ? closure()->native_context() : nullptr;
+ }
+
+ bool has_global_object() const { return has_native_context(); }
+
+ JSGlobalObject* global_object() const {
+ return has_global_object() ? native_context()->global_object() : nullptr;
}
// Accessors for the different compilation modes.
bool IsOptimizing() const { return mode_ == OPTIMIZE; }
- bool IsOptimizable() const { return mode_ == BASE; }
bool IsStub() const { return mode_ == STUB; }
void SetOptimizing(BailoutId osr_ast_id, Handle<Code> unoptimized) {
- DCHECK(!shared_info_.is_null());
+ DCHECK(has_shared_info());
SetMode(OPTIMIZE);
osr_ast_id_ = osr_ast_id;
unoptimized_code_ = unoptimized;
optimization_id_ = isolate()->NextOptimizationId();
+ set_output_code_kind(Code::OPTIMIZED_FUNCTION);
}
// Deoptimization support.
@@ -297,9 +322,12 @@
return GetFlag(kDeoptimizationSupport);
}
void EnableDeoptimizationSupport() {
- DCHECK(IsOptimizable());
+ DCHECK_EQ(BASE, mode_);
SetFlag(kDeoptimizationSupport);
}
+ bool ShouldEnsureSpaceForLazyDeopt() { return !IsStub(); }
+
+ bool ExpectsJSReceiverAsReceiver();
// Determines whether or not to insert a self-optimization header.
bool ShouldSelfOptimize();
@@ -309,33 +337,20 @@
deferred_handles_ = deferred_handles;
}
- ZoneList<Handle<HeapObject> >* dependencies(
- DependentCode::DependencyGroup group) {
- if (dependencies_[group] == NULL) {
- dependencies_[group] = new(zone_) ZoneList<Handle<HeapObject> >(2, zone_);
- }
- return dependencies_[group];
- }
-
- void CommitDependencies(Handle<Code> code);
-
- void RollbackDependencies();
-
- void SaveHandles() {
- SaveHandle(&closure_);
- SaveHandle(&shared_info_);
- SaveHandle(&context_);
- SaveHandle(&script_);
- SaveHandle(&unoptimized_code_);
+ void ReopenHandlesInNewHandleScope() {
+ unoptimized_code_ = Handle<Code>(*unoptimized_code_);
}
void AbortOptimization(BailoutReason reason) {
- if (bailout_reason_ != kNoReason) bailout_reason_ = reason;
+ DCHECK(reason != kNoReason);
+ if (bailout_reason_ == kNoReason) bailout_reason_ = reason;
SetFlag(kDisableFutureOptimization);
}
void RetryOptimization(BailoutReason reason) {
- if (bailout_reason_ != kNoReason) bailout_reason_ = reason;
+ DCHECK(reason != kNoReason);
+ if (GetFlag(kDisableFutureOptimization)) return;
+ bailout_reason_ = reason;
}
BailoutReason bailout_reason() const { return bailout_reason_; }
@@ -350,79 +365,92 @@
prologue_offset_ = prologue_offset;
}
- // Adds offset range [from, to) where fp register does not point
- // to the current frame base. Used in CPU profiler to detect stack
- // samples where top frame is not set up.
- inline void AddNoFrameRange(int from, int to) {
- if (no_frame_ranges_) no_frame_ranges_->Add(OffsetRange(from, to));
+ int start_position_for(uint32_t inlining_id) {
+ return inlined_function_infos_.at(inlining_id).start_position;
+ }
+ const std::vector<InlinedFunctionInfo>& inlined_function_infos() {
+ return inlined_function_infos_;
}
- List<OffsetRange>* ReleaseNoFrameRanges() {
- List<OffsetRange>* result = no_frame_ranges_;
- no_frame_ranges_ = NULL;
- return result;
- }
+ void LogDeoptCallPosition(int pc_offset, int inlining_id);
+ int TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
+ SourcePosition position, int pareint_id);
- Handle<Foreign> object_wrapper() {
- if (object_wrapper_.is_null()) {
- object_wrapper_ =
- isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
- }
- return object_wrapper_;
- }
-
- void AbortDueToDependencyChange() {
- DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
- aborted_due_to_dependency_change_ = true;
- }
-
- bool HasAbortedDueToDependencyChange() const {
- DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
- return aborted_due_to_dependency_change_;
- }
+ CompilationDependencies* dependencies() { return &dependencies_; }
bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) {
- return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure_);
+ return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure());
}
int optimization_id() const { return optimization_id_; }
- AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
- void SetAstValueFactory(AstValueFactory* ast_value_factory,
- bool owned = true) {
- ast_value_factory_ = ast_value_factory;
- ast_value_factory_owned_ = owned;
+ int osr_expr_stack_height() { return osr_expr_stack_height_; }
+ void set_osr_expr_stack_height(int height) {
+ DCHECK(height >= 0);
+ osr_expr_stack_height_ = height;
+ }
+ JavaScriptFrame* osr_frame() const { return osr_frame_; }
+ void set_osr_frame(JavaScriptFrame* osr_frame) { osr_frame_ = osr_frame; }
+
+#if DEBUG
+ void PrintAstForTesting();
+#endif
+
+ bool has_simple_parameters();
+
+ struct InlinedFunctionHolder {
+ Handle<SharedFunctionInfo> shared_info;
+
+ // Root that holds the unoptimized code of the inlined function alive
+ // (and out of reach of code flushing) until we finish compilation.
+ // Do not remove.
+ Handle<Code> inlined_code_object_root;
+
+ explicit InlinedFunctionHolder(
+ Handle<SharedFunctionInfo> inlined_shared_info)
+ : shared_info(inlined_shared_info),
+ inlined_code_object_root(inlined_shared_info->code()) {}
+ };
+
+ typedef std::vector<InlinedFunctionHolder> InlinedFunctionList;
+ InlinedFunctionList const& inlined_functions() const {
+ return inlined_functions_;
}
- protected:
- CompilationInfo(Handle<Script> script,
- Zone* zone);
- CompilationInfo(Handle<SharedFunctionInfo> shared_info,
- Zone* zone);
- CompilationInfo(HydrogenCodeStub* stub,
- Isolate* isolate,
- Zone* zone);
- CompilationInfo(ScriptCompiler::ExternalSourceStream* source_stream,
- ScriptCompiler::StreamedSource::Encoding encoding,
- Isolate* isolate, Zone* zone);
+ void AddInlinedFunction(Handle<SharedFunctionInfo> inlined_function) {
+ inlined_functions_.push_back(InlinedFunctionHolder(inlined_function));
+ }
+ base::SmartArrayPointer<char> GetDebugName() const;
+
+ Code::Kind output_code_kind() const { return output_code_kind_; }
+
+ void set_output_code_kind(Code::Kind kind) { output_code_kind_ = kind; }
+
+ protected:
+ ParseInfo* parse_info_;
+
+ void DisableFutureOptimization() {
+ if (GetFlag(kDisableFutureOptimization) && has_shared_info()) {
+ shared_info()->DisableOptimization(bailout_reason());
+ }
+ }
private:
- Isolate* isolate_;
-
// Compilation mode.
// BASE is generated by the full codegen, optionally prepared for bailouts.
// OPTIMIZE is optimized code generated by the Hydrogen-based backend.
- // NONOPT is generated by the full codegen and is not prepared for
- // recompilation/bailouts. These functions are never recompiled.
enum Mode {
BASE,
OPTIMIZE,
- NONOPT,
STUB
};
- void Initialize(Isolate* isolate, Mode mode, Zone* zone);
+ CompilationInfo(ParseInfo* parse_info, CodeStub* code_stub,
+ const char* debug_name, Mode mode, Isolate* isolate,
+ Zone* zone);
+
+ Isolate* isolate_;
void SetMode(Mode mode) {
mode_ = mode;
@@ -438,35 +466,13 @@
unsigned flags_;
- // Fields filled in by the compilation pipeline.
- // AST filled in by the parser.
- FunctionLiteral* function_;
- // The scope of the function literal as a convenience. Set to indicate
- // that scopes have been analyzed.
- Scope* scope_;
- // The script scope provided as a convenience.
- Scope* script_scope_;
+ Code::Kind output_code_kind_;
+
// For compiled stubs, the stub object
- HydrogenCodeStub* code_stub_;
+ CodeStub* code_stub_;
// The compiled code.
Handle<Code> code_;
- // Possible initial inputs to the compilation process.
- Handle<JSFunction> closure_;
- Handle<SharedFunctionInfo> shared_info_;
- Handle<Script> script_;
- ScriptCompiler::ExternalSourceStream* source_stream_; // Not owned.
- ScriptCompiler::StreamedSource::Encoding source_stream_encoding_;
-
- // Fields possibly needed for eager compilation, NULL by default.
- v8::Extension* extension_;
- ScriptData** cached_data_;
- ScriptCompiler::CompileOptions compile_options_;
-
- // The context of the caller for eval code, and the script context for a
- // global script. Will be a null handle otherwise.
- Handle<Context> context_;
-
// Used by codegen, ultimately kept rooted by the SharedFunctionInfo.
Handle<TypeFeedbackVector> feedback_vector_;
@@ -478,27 +484,28 @@
// data. Keep track which code we patched.
Handle<Code> unoptimized_code_;
+ // Holds the bytecode array generated by the interpreter.
+ // TODO(rmcilroy/mstarzinger): Temporary work-around until compiler.cc is
+ // refactored to avoid us needing to carry the BytcodeArray around.
+ Handle<BytecodeArray> bytecode_array_;
+
// The zone from which the compilation pipeline working on this
// CompilationInfo allocates.
Zone* zone_;
DeferredHandles* deferred_handles_;
- ZoneList<Handle<HeapObject> >* dependencies_[DependentCode::kGroupCount];
-
- template<typename T>
- void SaveHandle(Handle<T> *object) {
- if (!object->is_null()) {
- Handle<T> handle(*(*object));
- *object = handle;
- }
- }
+ // Dependencies for this compilation, e.g. stable maps.
+ CompilationDependencies dependencies_;
BailoutReason bailout_reason_;
int prologue_offset_;
- List<OffsetRange>* no_frame_ranges_;
+ std::vector<InlinedFunctionInfo> inlined_function_infos_;
+ bool track_positions_;
+
+ InlinedFunctionList inlined_functions_;
// A copy of shared_info()->opt_count() to avoid handle deref
// during graph optimization.
@@ -507,54 +514,19 @@
// Number of parameters used for compilation of stubs that require arguments.
int parameter_count_;
- Handle<Foreign> object_wrapper_;
-
int optimization_id_;
- AstValueFactory* ast_value_factory_;
- bool ast_value_factory_owned_;
+ int osr_expr_stack_height_;
- // This flag is used by the main thread to track whether this compilation
- // should be abandoned due to dependency change.
- bool aborted_due_to_dependency_change_;
+ // The current OSR frame for specialization or {nullptr}.
+ JavaScriptFrame* osr_frame_ = nullptr;
+
+ const char* debug_name_;
DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
};
-// Exactly like a CompilationInfo, except also creates and enters a
-// Zone on construction and deallocates it on exit.
-class CompilationInfoWithZone: public CompilationInfo {
- public:
- explicit CompilationInfoWithZone(Handle<Script> script)
- : CompilationInfo(script, &zone_),
- zone_(script->GetIsolate()) {}
- explicit CompilationInfoWithZone(Handle<SharedFunctionInfo> shared_info)
- : CompilationInfo(shared_info, &zone_),
- zone_(shared_info->GetIsolate()) {}
- explicit CompilationInfoWithZone(Handle<JSFunction> closure)
- : CompilationInfo(closure, &zone_),
- zone_(closure->GetIsolate()) {}
- CompilationInfoWithZone(HydrogenCodeStub* stub, Isolate* isolate)
- : CompilationInfo(stub, isolate, &zone_),
- zone_(isolate) {}
- CompilationInfoWithZone(ScriptCompiler::ExternalSourceStream* stream,
- ScriptCompiler::StreamedSource::Encoding encoding,
- Isolate* isolate)
- : CompilationInfo(stream, encoding, isolate, &zone_), zone_(isolate) {}
-
- // Virtual destructor because a CompilationInfoWithZone has to exit the
- // zone scope and get rid of dependent maps even when the destructor is
- // called when cast as a CompilationInfo.
- virtual ~CompilationInfoWithZone() {
- RollbackDependencies();
- }
-
- private:
- Zone zone_;
-};
-
-
// A wrapper around a CompilationInfo that detaches the Handles from
// the underlying DeferredHandleScope and stores them in info_ on
// destruction.
@@ -673,44 +645,43 @@
Handle<JSFunction> function);
MUST_USE_RESULT static MaybeHandle<Code> GetLazyCode(
Handle<JSFunction> function);
- MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCode(
- Handle<SharedFunctionInfo> shared);
- MUST_USE_RESULT static MaybeHandle<Code> GetDebugCode(
- Handle<JSFunction> function);
+
+ static bool Compile(Handle<JSFunction> function, ClearExceptionFlag flag);
+ static bool CompileDebugCode(Handle<JSFunction> function);
+ static bool CompileDebugCode(Handle<SharedFunctionInfo> shared);
+ static void CompileForLiveEdit(Handle<Script> script);
// Parser::Parse, then Compiler::Analyze.
- static bool ParseAndAnalyze(CompilationInfo* info);
+ static bool ParseAndAnalyze(ParseInfo* info);
// Rewrite, analyze scopes, and renumber.
- static bool Analyze(CompilationInfo* info);
+ static bool Analyze(ParseInfo* info);
// Adds deoptimization support, requires ParseAndAnalyze.
static bool EnsureDeoptimizationSupport(CompilationInfo* info);
- static bool EnsureCompiled(Handle<JSFunction> function,
- ClearExceptionFlag flag);
-
- static void CompileForLiveEdit(Handle<Script> script);
-
// Compile a String source within a context for eval.
MUST_USE_RESULT static MaybeHandle<JSFunction> GetFunctionFromEval(
Handle<String> source, Handle<SharedFunctionInfo> outer_info,
- Handle<Context> context, StrictMode strict_mode,
- ParseRestriction restriction, int scope_position);
+ Handle<Context> context, LanguageMode language_mode,
+ ParseRestriction restriction, int line_offset, int column_offset = 0,
+ Handle<Object> script_name = Handle<Object>(),
+ ScriptOriginOptions options = ScriptOriginOptions());
// Compile a String source within a context.
static Handle<SharedFunctionInfo> CompileScript(
Handle<String> source, Handle<Object> script_name, int line_offset,
- int column_offset, bool is_shared_cross_origin, Handle<Context> context,
+ int column_offset, ScriptOriginOptions resource_options,
+ Handle<Object> source_map_url, Handle<Context> context,
v8::Extension* extension, ScriptData** cached_data,
ScriptCompiler::CompileOptions compile_options,
- NativesFlag is_natives_code);
+ NativesFlag is_natives_code, bool is_module);
- static Handle<SharedFunctionInfo> CompileStreamedScript(CompilationInfo* info,
+ static Handle<SharedFunctionInfo> CompileStreamedScript(Handle<Script> script,
+ ParseInfo* info,
int source_length);
// Create a shared function info object (the code may be lazily compiled).
- static Handle<SharedFunctionInfo> BuildFunctionInfo(FunctionLiteral* node,
- Handle<Script> script,
- CompilationInfo* outer);
+ static Handle<SharedFunctionInfo> GetSharedFunctionInfo(
+ FunctionLiteral* node, Handle<Script> script, CompilationInfo* outer);
enum ConcurrencyMode { NOT_CONCURRENT, CONCURRENT };
@@ -718,17 +689,13 @@
// In the latter case, return the InOptimizationQueue builtin. On failure,
// return the empty handle.
MUST_USE_RESULT static MaybeHandle<Code> GetOptimizedCode(
- Handle<JSFunction> function,
- Handle<Code> current_code,
- ConcurrencyMode mode,
- BailoutId osr_ast_id = BailoutId::None());
+ Handle<JSFunction> function, Handle<Code> current_code,
+ ConcurrencyMode mode, BailoutId osr_ast_id = BailoutId::None(),
+ JavaScriptFrame* osr_frame = nullptr);
// Generate and return code from previously queued optimization job.
// On failure, return the empty handle.
static Handle<Code> GetConcurrentlyOptimizedCode(OptimizedCompileJob* job);
-
- static bool DebuggerWantsEagerCompilation(
- CompilationInfo* info, bool allow_lazy_without_ctx = false);
};
@@ -749,12 +716,13 @@
const char* name_;
CompilationInfo* info_;
Zone zone_;
- unsigned info_zone_start_allocation_size_;
+ size_t info_zone_start_allocation_size_;
base::ElapsedTimer timer_;
DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
};
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_H_