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/ast-graph-builder.h b/src/compiler/ast-graph-builder.h
index 0337c81..3b6302d 100644
--- a/src/compiler/ast-graph-builder.h
+++ b/src/compiler/ast-graph-builder.h
@@ -5,133 +5,87 @@
#ifndef V8_COMPILER_AST_GRAPH_BUILDER_H_
#define V8_COMPILER_AST_GRAPH_BUILDER_H_
-#include "src/v8.h"
-
-#include "src/ast.h"
-#include "src/compiler/graph-builder.h"
+#include "src/ast/ast.h"
#include "src/compiler/js-graph.h"
+#include "src/compiler/liveness-analyzer.h"
+#include "src/compiler/state-values-utils.h"
namespace v8 {
namespace internal {
+
+// Forward declarations.
+class BitVector;
+
+
namespace compiler {
+// Forward declarations.
class ControlBuilder;
class Graph;
class LoopAssignmentAnalysis;
class LoopBuilder;
+class Node;
+class TypeHintAnalysis;
+
// The AstGraphBuilder produces a high-level IR graph, based on an
// underlying AST. The produced graph can either be compiled into a
// stand-alone function or be wired into another graph for the purposes
// of function inlining.
-class AstGraphBuilder : public StructuredGraphBuilder, public AstVisitor {
+class AstGraphBuilder : public AstVisitor {
public:
AstGraphBuilder(Zone* local_zone, CompilationInfo* info, JSGraph* jsgraph,
- LoopAssignmentAnalysis* loop_assignment = NULL);
+ LoopAssignmentAnalysis* loop_assignment = nullptr,
+ TypeHintAnalysis* type_hint_analysis = nullptr);
// Creates a graph by visiting the entire AST.
- bool CreateGraph();
+ bool CreateGraph(bool stack_check = true);
- protected:
- class AstContext;
- class AstEffectContext;
- class AstValueContext;
- class AstTestContext;
- class BreakableScope;
- class ContextScope;
- class Environment;
-
- Environment* environment() {
- return reinterpret_cast<Environment*>(
- StructuredGraphBuilder::environment());
+ // Helpers to create new control nodes.
+ Node* NewIfTrue() { return NewNode(common()->IfTrue()); }
+ Node* NewIfFalse() { return NewNode(common()->IfFalse()); }
+ Node* NewMerge() { return NewNode(common()->Merge(1), true); }
+ Node* NewLoop() { return NewNode(common()->Loop(1), true); }
+ Node* NewBranch(Node* condition, BranchHint hint = BranchHint::kNone) {
+ return NewNode(common()->Branch(hint), condition);
}
- AstContext* ast_context() const { return ast_context_; }
- BreakableScope* breakable() const { return breakable_; }
- ContextScope* execution_context() const { return execution_context_; }
-
- void set_ast_context(AstContext* ctx) { ast_context_ = ctx; }
- void set_breakable(BreakableScope* brk) { breakable_ = brk; }
- void set_execution_context(ContextScope* ctx) { execution_context_ = ctx; }
-
- // Support for control flow builders. The concrete type of the environment
- // depends on the graph builder, but environments themselves are not virtual.
- typedef StructuredGraphBuilder::Environment BaseEnvironment;
- BaseEnvironment* CopyEnvironment(BaseEnvironment* env) OVERRIDE;
-
- // Getters for values in the activation record.
- Node* GetFunctionClosure();
- Node* GetFunctionContext();
-
- //
- // The following build methods all generate graph fragments and return one
- // resulting node. The operand stack height remains the same, variables and
- // other dependencies tracked by the environment might be mutated though.
- //
-
- // Builder to create a receiver check for sloppy mode.
- Node* BuildPatchReceiverToGlobalProxy(Node* receiver);
-
- // Builder to create a local function context.
- Node* BuildLocalFunctionContext(Node* context, Node* closure);
-
- // Builder to create an arguments object if it is used.
- Node* BuildArgumentsObject(Variable* arguments);
-
- // Builders for variable load and assignment.
- Node* BuildVariableAssignment(Variable* var, Node* value, Token::Value op,
- BailoutId bailout_id,
- OutputFrameStateCombine state_combine =
- OutputFrameStateCombine::Ignore());
- Node* BuildVariableDelete(Variable* var, BailoutId bailout_id,
- OutputFrameStateCombine state_combine);
- Node* BuildVariableLoad(Variable* var, BailoutId bailout_id,
- const VectorSlotPair& feedback,
- ContextualMode mode = CONTEXTUAL);
-
- // Builders for accessing the function context.
- Node* BuildLoadBuiltinsObject();
- Node* BuildLoadGlobalObject();
- Node* BuildLoadGlobalProxy();
- Node* BuildLoadClosure();
- Node* BuildLoadObjectField(Node* object, int offset);
-
- // Builders for automatic type conversion.
- Node* BuildToBoolean(Node* value);
-
- // Builders for error reporting at runtime.
- Node* BuildThrowReferenceError(Variable* var, BailoutId bailout_id);
- Node* BuildThrowConstAssignError(BailoutId bailout_id);
-
- // Builders for dynamic hole-checks at runtime.
- Node* BuildHoleCheckSilent(Node* value, Node* for_hole, Node* not_hole);
- Node* BuildHoleCheckThrow(Node* value, Variable* var, Node* not_hole,
- BailoutId bailout_id);
-
- // Builders for binary operations.
- Node* BuildBinaryOp(Node* left, Node* right, Token::Value op);
-
- // Builder for stack-check guards.
- Node* BuildStackCheck();
-
-#define DECLARE_VISIT(type) void Visit##type(type* node) OVERRIDE;
+ protected:
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
// Visiting functions for AST nodes make this an AstVisitor.
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
// Visiting function for declarations list is overridden.
- void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
private:
+ class AstContext;
+ class AstEffectContext;
+ class AstValueContext;
+ class AstTestContext;
+ class ContextScope;
+ class ControlScope;
+ class ControlScopeForBreakable;
+ class ControlScopeForIteration;
+ class ControlScopeForCatch;
+ class ControlScopeForFinally;
+ class Environment;
+ class FrameStateBeforeAndAfter;
+ friend class ControlBuilder;
+
+ Isolate* isolate_;
+ Zone* local_zone_;
CompilationInfo* info_;
- AstContext* ast_context_;
JSGraph* jsgraph_;
+ Environment* environment_;
+ AstContext* ast_context_;
// List of global declarations for functions and variables.
ZoneVector<Handle<Object>> globals_;
- // Stack of breakable statements entered by the visitor.
- BreakableScope* breakable_;
+ // Stack of control scopes currently entered by the visitor.
+ ControlScope* execution_control_;
// Stack of context objects pushed onto the chain by the visitor.
ContextScope* execution_context_;
@@ -139,28 +93,308 @@
// Nodes representing values in the activation record.
SetOncePointer<Node> function_closure_;
SetOncePointer<Node> function_context_;
+ SetOncePointer<Node> new_target_;
+
+ // Tracks how many try-blocks are currently entered.
+ int try_catch_nesting_level_;
+ int try_nesting_level_;
+
+ // Temporary storage for building node input lists.
+ int input_buffer_size_;
+ Node** input_buffer_;
+
+ // Optimization to cache loaded feedback vector.
+ SetOncePointer<Node> feedback_vector_;
+
+ // Control nodes that exit the function body.
+ ZoneVector<Node*> exit_controls_;
// Result of loop assignment analysis performed before graph creation.
LoopAssignmentAnalysis* loop_assignment_analysis_;
+ // Result of type hint analysis performed before graph creation.
+ TypeHintAnalysis* type_hint_analysis_;
+
+ // Cache for StateValues nodes for frame states.
+ StateValuesCache state_values_cache_;
+
+ // Analyzer of local variable liveness.
+ LivenessAnalyzer liveness_analyzer_;
+
+ // Function info for frame state construction.
+ const FrameStateFunctionInfo* const frame_state_function_info_;
+
+ // Growth increment for the temporary buffer used to construct input lists to
+ // new nodes.
+ static const int kInputBufferSizeIncrement = 64;
+
+ Zone* local_zone() const { return local_zone_; }
+ Environment* environment() const { return environment_; }
+ AstContext* ast_context() const { return ast_context_; }
+ ControlScope* execution_control() const { return execution_control_; }
+ ContextScope* execution_context() const { return execution_context_; }
+ CommonOperatorBuilder* common() const { return jsgraph_->common(); }
CompilationInfo* info() const { return info_; }
- inline StrictMode strict_mode() const;
+ Isolate* isolate() const { return isolate_; }
+ LanguageMode language_mode() const;
JSGraph* jsgraph() { return jsgraph_; }
+ Graph* graph() { return jsgraph_->graph(); }
+ Zone* graph_zone() { return graph()->zone(); }
JSOperatorBuilder* javascript() { return jsgraph_->javascript(); }
ZoneVector<Handle<Object>>* globals() { return &globals_; }
+ Scope* current_scope() const;
+ Node* current_context() const;
+ LivenessAnalyzer* liveness_analyzer() { return &liveness_analyzer_; }
+ const FrameStateFunctionInfo* frame_state_function_info() const {
+ return frame_state_function_info_;
+ }
- // Current scope during visitation.
- inline Scope* current_scope() const;
+ void set_environment(Environment* env) { environment_ = env; }
+ void set_ast_context(AstContext* ctx) { ast_context_ = ctx; }
+ void set_execution_control(ControlScope* ctrl) { execution_control_ = ctrl; }
+ void set_execution_context(ContextScope* ctx) { execution_context_ = ctx; }
+
+ // Create the main graph body by visiting the AST.
+ void CreateGraphBody(bool stack_check);
+
+ // Get or create the node that represents the incoming function closure.
+ Node* GetFunctionClosureForContext();
+ Node* GetFunctionClosure();
+
+ // Get or create the node that represents the incoming function context.
+ Node* GetFunctionContext();
+
+ // Get or create the node that represents the incoming new target value.
+ Node* GetNewTarget();
+
+ // Node creation helpers.
+ Node* NewNode(const Operator* op, bool incomplete = false) {
+ return MakeNode(op, 0, static_cast<Node**>(nullptr), incomplete);
+ }
+
+ Node* NewNode(const Operator* op, Node* n1) {
+ return MakeNode(op, 1, &n1, false);
+ }
+
+ Node* NewNode(const Operator* op, Node* n1, Node* n2) {
+ Node* buffer[] = {n1, n2};
+ return MakeNode(op, arraysize(buffer), buffer, false);
+ }
+
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3) {
+ Node* buffer[] = {n1, n2, n3};
+ return MakeNode(op, arraysize(buffer), buffer, false);
+ }
+
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4) {
+ Node* buffer[] = {n1, n2, n3, n4};
+ return MakeNode(op, arraysize(buffer), buffer, false);
+ }
+
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+ Node* n5) {
+ Node* buffer[] = {n1, n2, n3, n4, n5};
+ return MakeNode(op, arraysize(buffer), buffer, false);
+ }
+
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+ Node* n5, Node* n6) {
+ Node* nodes[] = {n1, n2, n3, n4, n5, n6};
+ return MakeNode(op, arraysize(nodes), nodes, false);
+ }
+
+ Node* NewNode(const Operator* op, int value_input_count, Node** value_inputs,
+ bool incomplete = false) {
+ return MakeNode(op, value_input_count, value_inputs, incomplete);
+ }
+
+ // Creates a new Phi node having {count} input values.
+ Node* NewPhi(int count, Node* input, Node* control);
+ Node* NewEffectPhi(int count, Node* input, Node* control);
+
+ // Helpers for merging control, effect or value dependencies.
+ Node* MergeControl(Node* control, Node* other);
+ Node* MergeEffect(Node* value, Node* other, Node* control);
+ Node* MergeValue(Node* value, Node* other, Node* control);
+
+ // The main node creation chokepoint. Adds context, frame state, effect,
+ // and control dependencies depending on the operator.
+ Node* MakeNode(const Operator* op, int value_input_count, Node** value_inputs,
+ bool incomplete);
+
+ // Helper to indicate a node exits the function body.
+ void UpdateControlDependencyToLeaveFunction(Node* exit);
+
+ // Builds deoptimization for a given node.
+ void PrepareFrameState(Node* node, BailoutId ast_id,
+ OutputFrameStateCombine framestate_combine =
+ OutputFrameStateCombine::Ignore());
+
+ BitVector* GetVariablesAssignedInLoop(IterationStatement* stmt);
+
+ // Check if the given statement is an OSR entry.
+ // If so, record the stack height into the compilation and return {true}.
+ bool CheckOsrEntry(IterationStatement* stmt);
+
+ // Computes local variable liveness and replaces dead variables in
+ // frame states with the undefined values.
+ void ClearNonLiveSlotsInFrameStates();
+
+ Node** EnsureInputBufferSize(int size);
// Named and keyed loads require a VectorSlotPair for successful lowering.
- VectorSlotPair CreateVectorSlotPair(FeedbackVectorICSlot slot) const;
+ VectorSlotPair CreateVectorSlotPair(FeedbackVectorSlot slot) const;
+
+ // Determine which contexts need to be checked for extension objects that
+ // might shadow the optimistic declaration of dynamic lookup variables.
+ uint32_t ComputeBitsetForDynamicGlobal(Variable* variable);
+ uint32_t ComputeBitsetForDynamicContext(Variable* variable);
+
+ // ===========================================================================
+ // The following build methods all generate graph fragments and return one
+ // resulting node. The operand stack height remains the same, variables and
+ // other dependencies tracked by the environment might be mutated though.
+
+ // Builders to create local function, script and block contexts.
+ Node* BuildLocalActivationContext(Node* context);
+ Node* BuildLocalFunctionContext(Scope* scope);
+ Node* BuildLocalScriptContext(Scope* scope);
+ Node* BuildLocalBlockContext(Scope* scope);
+
+ // Builder to create an arguments object if it is used.
+ Node* BuildArgumentsObject(Variable* arguments);
+
+ // Builder to create an array of rest parameters if used
+ Node* BuildRestArgumentsArray(Variable* rest, int index);
+
+ // Builder that assigns to the {.this_function} internal variable if needed.
+ Node* BuildThisFunctionVariable(Variable* this_function_var);
+
+ // Builder that assigns to the {new.target} internal variable if needed.
+ Node* BuildNewTargetVariable(Variable* new_target_var);
+
+ // Builders for variable load and assignment.
+ Node* BuildVariableAssignment(Variable* variable, Node* value,
+ Token::Value op, const VectorSlotPair& slot,
+ BailoutId bailout_id,
+ FrameStateBeforeAndAfter& states,
+ OutputFrameStateCombine framestate_combine =
+ OutputFrameStateCombine::Ignore());
+ Node* BuildVariableDelete(Variable* variable, BailoutId bailout_id,
+ OutputFrameStateCombine framestate_combine);
+ Node* BuildVariableLoad(Variable* variable, BailoutId bailout_id,
+ FrameStateBeforeAndAfter& states,
+ const VectorSlotPair& feedback,
+ OutputFrameStateCombine framestate_combine,
+ TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
+
+ // Builders for property loads and stores.
+ Node* BuildKeyedLoad(Node* receiver, Node* key,
+ const VectorSlotPair& feedback);
+ Node* BuildNamedLoad(Node* receiver, Handle<Name> name,
+ const VectorSlotPair& feedback);
+ Node* BuildKeyedStore(Node* receiver, Node* key, Node* value,
+ const VectorSlotPair& feedback);
+ Node* BuildNamedStore(Node* receiver, Handle<Name> name, Node* value,
+ const VectorSlotPair& feedback);
+
+ // Builders for super property loads and stores.
+ Node* BuildKeyedSuperStore(Node* receiver, Node* home_object, Node* key,
+ Node* value);
+ Node* BuildNamedSuperStore(Node* receiver, Node* home_object,
+ Handle<Name> name, Node* value);
+ Node* BuildNamedSuperLoad(Node* receiver, Node* home_object,
+ Handle<Name> name, const VectorSlotPair& feedback);
+ Node* BuildKeyedSuperLoad(Node* receiver, Node* home_object, Node* key,
+ const VectorSlotPair& feedback);
+
+ // Builders for global variable loads and stores.
+ Node* BuildGlobalLoad(Handle<Name> name, const VectorSlotPair& feedback,
+ TypeofMode typeof_mode);
+ Node* BuildGlobalStore(Handle<Name> name, Node* value,
+ const VectorSlotPair& feedback);
+
+ // Builders for accessing the function context.
+ Node* BuildLoadGlobalObject();
+ Node* BuildLoadNativeContextField(int index);
+ Node* BuildLoadFeedbackVector();
+
+ // Builder for accessing a (potentially immutable) object field.
+ Node* BuildLoadObjectField(Node* object, int offset);
+ Node* BuildLoadImmutableObjectField(Node* object, int offset);
+
+ // Builders for automatic type conversion.
+ Node* BuildToBoolean(Node* input, TypeFeedbackId feedback_id);
+ Node* BuildToName(Node* input, BailoutId bailout_id);
+ Node* BuildToObject(Node* input, BailoutId bailout_id);
+
+ // Builder for adding the [[HomeObject]] to a value if the value came from a
+ // function literal and needs a home object. Do nothing otherwise.
+ Node* BuildSetHomeObject(Node* value, Node* home_object,
+ ObjectLiteralProperty* property,
+ int slot_number = 0);
+
+ // Builders for error reporting at runtime.
+ Node* BuildThrowError(Node* exception, BailoutId bailout_id);
+ Node* BuildThrowReferenceError(Variable* var, BailoutId bailout_id);
+ Node* BuildThrowConstAssignError(BailoutId bailout_id);
+ Node* BuildThrowStaticPrototypeError(BailoutId bailout_id);
+ Node* BuildThrowUnsupportedSuperError(BailoutId bailout_id);
+
+ // Builders for dynamic hole-checks at runtime.
+ Node* BuildHoleCheckSilent(Node* value, Node* for_hole, Node* not_hole);
+ Node* BuildHoleCheckThenThrow(Node* value, Variable* var, Node* not_hole,
+ BailoutId bailout_id);
+ Node* BuildHoleCheckElseThrow(Node* value, Variable* var, Node* for_hole,
+ BailoutId bailout_id);
+
+ // Builders for conditional errors.
+ Node* BuildThrowIfStaticPrototype(Node* name, BailoutId bailout_id);
+
+ // Builders for non-local control flow.
+ Node* BuildReturn(Node* return_value);
+ Node* BuildThrow(Node* exception_value);
+
+ // Builders for binary operations.
+ Node* BuildBinaryOp(Node* left, Node* right, Token::Value op,
+ TypeFeedbackId feedback_id);
// Process arguments to a call by popping {arity} elements off the operand
// stack and build a call node using the given call operator.
Node* ProcessArguments(const Operator* op, int arity);
+ // ===========================================================================
+ // The following build methods have the same contract as the above ones, but
+ // they can also return {nullptr} to indicate that no fragment was built. Note
+ // that these are optimizations, disabling any of them should still produce
+ // correct graphs.
+
+ // Optimization for variable load from global object.
+ Node* TryLoadGlobalConstant(Handle<Name> name);
+
+ // Optimization for variable load of dynamic lookup slot that is most likely
+ // to resolve to a global slot or context slot (inferred from scope chain).
+ Node* TryLoadDynamicVariable(Variable* variable, Handle<String> name,
+ BailoutId bailout_id,
+ FrameStateBeforeAndAfter& states,
+ const VectorSlotPair& feedback,
+ OutputFrameStateCombine combine,
+ TypeofMode typeof_mode);
+
+ // Optimizations for automatic type conversion.
+ Node* TryFastToBoolean(Node* input);
+ Node* TryFastToName(Node* input);
+
+ // ===========================================================================
+ // The following visitation methods all recursively visit a subtree of the
+ // underlying AST and extent the graph. The operand stack is mutated in a way
+ // consistent with other compilers:
+ // - Expressions pop operands and push result, depending on {AstContext}.
+ // - Statements keep the operand stack balanced.
+
// Visit statements.
void VisitIfNotNull(Statement* stmt);
+ void VisitInScope(Statement* stmt, Scope* scope, Node* context);
// Visit expressions.
void Visit(Expression* expr);
@@ -168,10 +402,14 @@
void VisitForEffect(Expression* expr);
void VisitForValue(Expression* expr);
void VisitForValueOrNull(Expression* expr);
+ void VisitForValueOrTheHole(Expression* expr);
void VisitForValues(ZoneList<Expression*>* exprs);
// Common for all IterationStatement bodies.
- void VisitIterationBody(IterationStatement* stmt, LoopBuilder* loop, int);
+ void VisitIterationBody(IterationStatement* stmt, LoopBuilder* loop);
+
+ // Dispatched from VisitCall.
+ void VisitCallSuper(Call* expr);
// Dispatched from VisitCallRuntime.
void VisitCallJSRuntime(CallRuntime* expr);
@@ -188,14 +426,17 @@
void VisitArithmeticExpression(BinaryOperation* expr);
// Dispatched from VisitForInStatement.
- void VisitForInAssignment(Expression* expr, Node* value);
+ void VisitForInAssignment(Expression* expr, Node* value,
+ const VectorSlotPair& feedback,
+ BailoutId bailout_id_before,
+ BailoutId bailout_id_after);
- // Builds deoptimization for a given node.
- void PrepareFrameState(
- Node* node, BailoutId ast_id,
- OutputFrameStateCombine combine = OutputFrameStateCombine::Ignore());
+ // Dispatched from VisitObjectLiteral.
+ void VisitObjectLiteralAccessor(Node* home_object,
+ ObjectLiteralProperty* property);
- BitVector* GetVariablesAssignedInLoop(IterationStatement* stmt);
+ // Dispatched from VisitClassLiteral.
+ void VisitClassLiteralContents(ClassLiteral* expr);
DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
DISALLOW_COPY_AND_ASSIGN(AstGraphBuilder);
@@ -210,38 +451,33 @@
//
// [parameters (+receiver)] [locals] [operand stack]
//
-class AstGraphBuilder::Environment
- : public StructuredGraphBuilder::Environment {
+class AstGraphBuilder::Environment : public ZoneObject {
public:
Environment(AstGraphBuilder* builder, Scope* scope, Node* control_dependency);
- Environment(const Environment& copy);
int parameters_count() const { return parameters_count_; }
int locals_count() const { return locals_count_; }
+ int context_chain_length() { return static_cast<int>(contexts_.size()); }
int stack_height() {
return static_cast<int>(values()->size()) - parameters_count_ -
locals_count_;
}
- // Operations on parameter or local variables. The parameter indices are
- // shifted by 1 (receiver is parameter index -1 but environment index 0).
- void Bind(Variable* variable, Node* node) {
- DCHECK(variable->IsStackAllocated());
- if (variable->IsParameter()) {
- values()->at(variable->index() + 1) = node;
- } else {
- DCHECK(variable->IsStackLocal());
- values()->at(variable->index() + parameters_count_) = node;
- }
- }
- Node* Lookup(Variable* variable) {
- DCHECK(variable->IsStackAllocated());
- if (variable->IsParameter()) {
- return values()->at(variable->index() + 1);
- } else {
- DCHECK(variable->IsStackLocal());
- return values()->at(variable->index() + parameters_count_);
- }
+ // Operations on parameter or local variables.
+ void Bind(Variable* variable, Node* node);
+ Node* Lookup(Variable* variable);
+ void MarkAllLocalsLive();
+
+ // Raw operations on parameter variables.
+ void RawParameterBind(int index, Node* node);
+ Node* RawParameterLookup(int index);
+
+ // Operations on the context chain.
+ Node* Context() const { return contexts_.back(); }
+ void PushContext(Node* context) { contexts()->push_back(context); }
+ void PopContext() { contexts()->pop_back(); }
+ void TrimContextChain(int trim_to_length) {
+ contexts()->resize(trim_to_length);
}
// Operations on the operand stack.
@@ -274,176 +510,82 @@
DCHECK(depth >= 0 && depth <= stack_height());
values()->erase(values()->end() - depth, values()->end());
}
+ void TrimStack(int trim_to_height) {
+ int depth = stack_height() - trim_to_height;
+ DCHECK(depth >= 0 && depth <= stack_height());
+ values()->erase(values()->end() - depth, values()->end());
+ }
// Preserve a checkpoint of the environment for the IR graph. Any
// further mutation of the environment will not affect checkpoints.
- Node* Checkpoint(BailoutId ast_id, OutputFrameStateCombine combine);
+ Node* Checkpoint(BailoutId ast_id, OutputFrameStateCombine combine =
+ OutputFrameStateCombine::Ignore());
- protected:
- AstGraphBuilder* builder() const {
- return reinterpret_cast<AstGraphBuilder*>(
- StructuredGraphBuilder::Environment::builder());
+ // Control dependency tracked by this environment.
+ Node* GetControlDependency() { return control_dependency_; }
+ void UpdateControlDependency(Node* dependency) {
+ control_dependency_ = dependency;
}
- private:
- void UpdateStateValues(Node** state_values, int offset, int count);
+ // Effect dependency tracked by this environment.
+ Node* GetEffectDependency() { return effect_dependency_; }
+ void UpdateEffectDependency(Node* dependency) {
+ effect_dependency_ = dependency;
+ }
+ // Mark this environment as being unreachable.
+ void MarkAsUnreachable() {
+ UpdateControlDependency(builder()->jsgraph()->Dead());
+ liveness_block_ = nullptr;
+ }
+ bool IsMarkedAsUnreachable() {
+ return GetControlDependency()->opcode() == IrOpcode::kDead;
+ }
+
+ // Merge another environment into this one.
+ void Merge(Environment* other);
+
+ // Copies this environment at a control-flow split point.
+ Environment* CopyForConditional();
+
+ // Copies this environment to a potentially unreachable control-flow point.
+ Environment* CopyAsUnreachable();
+
+ // Copies this environment at a loop header control-flow point.
+ Environment* CopyForLoop(BitVector* assigned, bool is_osr = false);
+
+ private:
+ AstGraphBuilder* builder_;
int parameters_count_;
int locals_count_;
+ LivenessAnalyzerBlock* liveness_block_;
+ NodeVector values_;
+ NodeVector contexts_;
+ Node* control_dependency_;
+ Node* effect_dependency_;
Node* parameters_node_;
Node* locals_node_;
Node* stack_node_;
+
+ explicit Environment(Environment* copy,
+ LivenessAnalyzerBlock* liveness_block);
+ Environment* CopyAndShareLiveness();
+ void UpdateStateValues(Node** state_values, int offset, int count);
+ void UpdateStateValuesWithCache(Node** state_values, int offset, int count);
+ Zone* zone() const { return builder_->local_zone(); }
+ Graph* graph() const { return builder_->graph(); }
+ AstGraphBuilder* builder() const { return builder_; }
+ CommonOperatorBuilder* common() { return builder_->common(); }
+ NodeVector* values() { return &values_; }
+ NodeVector* contexts() { return &contexts_; }
+ LivenessAnalyzerBlock* liveness_block() { return liveness_block_; }
+ bool IsLivenessAnalysisEnabled();
+ bool IsLivenessBlockConsistent();
+
+ // Prepare environment to be used as loop header.
+ void PrepareForLoop(BitVector* assigned, bool is_osr = false);
};
-
-// Each expression in the AST is evaluated in a specific context. This context
-// decides how the evaluation result is passed up the visitor.
-class AstGraphBuilder::AstContext BASE_EMBEDDED {
- public:
- bool IsEffect() const { return kind_ == Expression::kEffect; }
- bool IsValue() const { return kind_ == Expression::kValue; }
- bool IsTest() const { return kind_ == Expression::kTest; }
-
- // Determines how to combine the frame state with the value
- // that is about to be plugged into this AstContext.
- OutputFrameStateCombine GetStateCombine() {
- return IsEffect() ? OutputFrameStateCombine::Ignore()
- : OutputFrameStateCombine::Push();
- }
-
- // Plug a node into this expression context. Call this function in tail
- // position in the Visit functions for expressions.
- virtual void ProduceValue(Node* value) = 0;
-
- // Unplugs a node from this expression context. Call this to retrieve the
- // result of another Visit function that already plugged the context.
- virtual Node* ConsumeValue() = 0;
-
- // Shortcut for "context->ProduceValue(context->ConsumeValue())".
- void ReplaceValue() { ProduceValue(ConsumeValue()); }
-
- protected:
- AstContext(AstGraphBuilder* owner, Expression::Context kind);
- virtual ~AstContext();
-
- AstGraphBuilder* owner() const { return owner_; }
- Environment* environment() const { return owner_->environment(); }
-
-// We want to be able to assert, in a context-specific way, that the stack
-// height makes sense when the context is filled.
-#ifdef DEBUG
- int original_height_;
-#endif
-
- private:
- Expression::Context kind_;
- AstGraphBuilder* owner_;
- AstContext* outer_;
-};
-
-
-// Context to evaluate expression for its side effects only.
-class AstGraphBuilder::AstEffectContext FINAL : public AstContext {
- public:
- explicit AstEffectContext(AstGraphBuilder* owner)
- : AstContext(owner, Expression::kEffect) {}
- ~AstEffectContext() FINAL;
- void ProduceValue(Node* value) FINAL;
- Node* ConsumeValue() FINAL;
-};
-
-
-// Context to evaluate expression for its value (and side effects).
-class AstGraphBuilder::AstValueContext FINAL : public AstContext {
- public:
- explicit AstValueContext(AstGraphBuilder* owner)
- : AstContext(owner, Expression::kValue) {}
- ~AstValueContext() FINAL;
- void ProduceValue(Node* value) FINAL;
- Node* ConsumeValue() FINAL;
-};
-
-
-// Context to evaluate expression for a condition value (and side effects).
-class AstGraphBuilder::AstTestContext FINAL : public AstContext {
- public:
- explicit AstTestContext(AstGraphBuilder* owner)
- : AstContext(owner, Expression::kTest) {}
- ~AstTestContext() FINAL;
- void ProduceValue(Node* value) FINAL;
- Node* ConsumeValue() FINAL;
-};
-
-
-// Scoped class tracking breakable statements entered by the visitor. Allows to
-// properly 'break' and 'continue' iteration statements as well as to 'break'
-// from blocks within switch statements.
-class AstGraphBuilder::BreakableScope BASE_EMBEDDED {
- public:
- BreakableScope(AstGraphBuilder* owner, BreakableStatement* target,
- ControlBuilder* control, int drop_extra)
- : owner_(owner),
- target_(target),
- next_(owner->breakable()),
- control_(control),
- drop_extra_(drop_extra) {
- owner_->set_breakable(this); // Push.
- }
-
- ~BreakableScope() {
- owner_->set_breakable(next_); // Pop.
- }
-
- // Either 'break' or 'continue' the target statement.
- void BreakTarget(BreakableStatement* target);
- void ContinueTarget(BreakableStatement* target);
-
- private:
- AstGraphBuilder* owner_;
- BreakableStatement* target_;
- BreakableScope* next_;
- ControlBuilder* control_;
- int drop_extra_;
-
- // Find the correct scope for the target statement. Note that this also drops
- // extra operands from the environment for each scope skipped along the way.
- BreakableScope* FindBreakable(BreakableStatement* target);
-};
-
-
-// Scoped class tracking context objects created by the visitor. Represents
-// mutations of the context chain within the function body and allows to
-// change the current {scope} and {context} during visitation.
-class AstGraphBuilder::ContextScope BASE_EMBEDDED {
- public:
- ContextScope(AstGraphBuilder* owner, Scope* scope, Node* context)
- : owner_(owner),
- next_(owner->execution_context()),
- outer_(owner->current_context()),
- scope_(scope) {
- owner_->set_execution_context(this); // Push.
- owner_->set_current_context(context);
- }
-
- ~ContextScope() {
- owner_->set_execution_context(next_); // Pop.
- owner_->set_current_context(outer_);
- }
-
- // Current scope during visitation.
- Scope* scope() const { return scope_; }
-
- private:
- AstGraphBuilder* owner_;
- ContextScope* next_;
- Node* outer_;
- Scope* scope_;
-};
-
-Scope* AstGraphBuilder::current_scope() const {
- return execution_context_->scope();
-}
-
} // namespace compiler
} // namespace internal
} // namespace v8