LCOV - code coverage report
Current view: top level - src/compiler - ast-graph-builder.h (source / functions) Hit Total Coverage
Test: app.info Lines: 65 65 100.0 %
Date: 2017-04-26 Functions: 43 66 65.2 %

          Line data    Source code
       1             : // Copyright 2014 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_COMPILER_AST_GRAPH_BUILDER_H_
       6             : #define V8_COMPILER_AST_GRAPH_BUILDER_H_
       7             : 
       8             : #include "src/ast/ast.h"
       9             : #include "src/compiler/compiler-source-position-table.h"
      10             : #include "src/compiler/js-graph.h"
      11             : #include "src/compiler/liveness-analyzer.h"
      12             : #include "src/compiler/state-values-utils.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : // Forward declarations.
      18             : class BitVector;
      19             : class CompilationInfo;
      20             : 
      21             : namespace compiler {
      22             : 
      23             : // Forward declarations.
      24             : class ControlBuilder;
      25             : class Graph;
      26             : class LoopAssignmentAnalysis;
      27             : class LoopBuilder;
      28             : class Node;
      29             : 
      30             : 
      31             : // The AstGraphBuilder produces a high-level IR graph, based on an
      32             : // underlying AST. The produced graph can either be compiled into a
      33             : // stand-alone function or be wired into another graph for the purposes
      34             : // of function inlining.
      35             : // This AstVistor is not final, and provides the AstVisitor methods as virtual
      36             : // methods so they can be specialized by subclasses.
      37             : class AstGraphBuilder : public AstVisitor<AstGraphBuilder> {
      38             :  public:
      39             :   AstGraphBuilder(Zone* local_zone, CompilationInfo* info, JSGraph* jsgraph,
      40             :                   float invocation_frequency,
      41             :                   LoopAssignmentAnalysis* loop_assignment = nullptr);
      42        2507 :   virtual ~AstGraphBuilder() {}
      43             : 
      44             :   // Creates a graph by visiting the entire AST.
      45             :   bool CreateGraph(bool stack_check = true);
      46             : 
      47             :   // Helpers to create new control nodes.
      48       14463 :   Node* NewIfTrue() { return NewNode(common()->IfTrue()); }
      49       14463 :   Node* NewIfFalse() { return NewNode(common()->IfFalse()); }
      50       13293 :   Node* NewMerge() { return NewNode(common()->Merge(1), true); }
      51        2502 :   Node* NewLoop() { return NewNode(common()->Loop(1), true); }
      52        4821 :   Node* NewBranch(Node* condition, BranchHint hint = BranchHint::kNone) {
      53        9642 :     return NewNode(common()->Branch(hint), condition);
      54             :   }
      55             : 
      56             :  protected:
      57             : #define DECLARE_VISIT(type) virtual void Visit##type(type* node);
      58             :   // Visiting functions for AST nodes make this an AstVisitor.
      59             :   AST_NODE_LIST(DECLARE_VISIT)
      60             : #undef DECLARE_VISIT
      61             : 
      62             :   // Visiting function for declarations list is overridden.
      63             :   void VisitDeclarations(Declaration::List* declarations);
      64             : 
      65             :  private:
      66             :   class AstContext;
      67             :   class AstEffectContext;
      68             :   class AstValueContext;
      69             :   class AstTestContext;
      70             :   class ContextScope;
      71             :   class ControlScope;
      72             :   class ControlScopeForBreakable;
      73             :   class ControlScopeForIteration;
      74             :   class Environment;
      75             :   friend class ControlBuilder;
      76             : 
      77             :   Isolate* isolate_;
      78             :   Zone* local_zone_;
      79             :   CompilationInfo* info_;
      80             :   JSGraph* jsgraph_;
      81             :   float const invocation_frequency_;
      82             :   Environment* environment_;
      83             :   AstContext* ast_context_;
      84             : 
      85             :   // List of global declarations for functions and variables.
      86             :   ZoneVector<Handle<Object>> globals_;
      87             : 
      88             :   // Stack of control scopes currently entered by the visitor.
      89             :   ControlScope* execution_control_;
      90             : 
      91             :   // Stack of context objects pushed onto the chain by the visitor.
      92             :   ContextScope* execution_context_;
      93             : 
      94             :   // Nodes representing values in the activation record.
      95             :   SetOncePointer<Node> function_closure_;
      96             :   SetOncePointer<Node> function_context_;
      97             : 
      98             :   // Temporary storage for building node input lists.
      99             :   int input_buffer_size_;
     100             :   Node** input_buffer_;
     101             : 
     102             :   // Optimization to cache loaded feedback vector.
     103             :   SetOncePointer<Node> feedback_vector_;
     104             : 
     105             :   // Optimization to cache empty frame state.
     106             :   SetOncePointer<Node> empty_frame_state_;
     107             : 
     108             :   // Control nodes that exit the function body.
     109             :   ZoneVector<Node*> exit_controls_;
     110             : 
     111             :   // Result of loop assignment analysis performed before graph creation.
     112             :   LoopAssignmentAnalysis* loop_assignment_analysis_;
     113             : 
     114             :   // Cache for StateValues nodes for frame states.
     115             :   StateValuesCache state_values_cache_;
     116             : 
     117             :   // Analyzer of local variable liveness.
     118             :   LivenessAnalyzer liveness_analyzer_;
     119             : 
     120             :   // Function info for frame state construction.
     121             :   const FrameStateFunctionInfo* const frame_state_function_info_;
     122             : 
     123             :   // Growth increment for the temporary buffer used to construct input lists to
     124             :   // new nodes.
     125             :   static const int kInputBufferSizeIncrement = 64;
     126             : 
     127             :   Zone* local_zone() const { return local_zone_; }
     128             :   Environment* environment() const { return environment_; }
     129             :   AstContext* ast_context() const { return ast_context_; }
     130             :   ControlScope* execution_control() const { return execution_control_; }
     131             :   ContextScope* execution_context() const { return execution_context_; }
     132      182379 :   CommonOperatorBuilder* common() const { return jsgraph_->common(); }
     133             :   CompilationInfo* info() const { return info_; }
     134             :   Isolate* isolate() const { return isolate_; }
     135             :   LanguageMode language_mode() const;
     136             :   JSGraph* jsgraph() { return jsgraph_; }
     137      273994 :   Graph* graph() { return jsgraph_->graph(); }
     138       37102 :   Zone* graph_zone() { return graph()->zone(); }
     139       81005 :   JSOperatorBuilder* javascript() { return jsgraph_->javascript(); }
     140             :   ZoneVector<Handle<Object>>* globals() { return &globals_; }
     141             :   Scope* current_scope() const;
     142             :   Node* current_context() const;
     143             :   LivenessAnalyzer* liveness_analyzer() { return &liveness_analyzer_; }
     144             :   const FrameStateFunctionInfo* frame_state_function_info() const {
     145             :     return frame_state_function_info_;
     146             :   }
     147             : 
     148       17862 :   void set_environment(Environment* env) { environment_ = env; }
     149      362784 :   void set_ast_context(AstContext* ctx) { ast_context_ = ctx; }
     150       18056 :   void set_execution_control(ControlScope* ctrl) { execution_control_ = ctrl; }
     151        5110 :   void set_execution_context(ContextScope* ctx) { execution_context_ = ctx; }
     152             : 
     153             :   // Create the main graph body by visiting the AST.
     154             :   void CreateGraphBody(bool stack_check);
     155             : 
     156             :   // Get or create the node that represents the incoming function closure.
     157             :   Node* GetFunctionClosureForContext();
     158             :   Node* GetFunctionClosure();
     159             : 
     160             :   // Get or create the node that represents the incoming function context.
     161             :   Node* GetFunctionContext();
     162             : 
     163             :   // Get or create the node that represents the empty frame state.
     164             :   Node* GetEmptyFrameState();
     165             : 
     166             :   // Node creation helpers.
     167             :   Node* NewNode(const Operator* op, bool incomplete = false) {
     168      112345 :     return MakeNode(op, 0, static_cast<Node**>(nullptr), incomplete);
     169             :   }
     170             : 
     171             :   Node* NewNode(const Operator* op, Node* n1) {
     172        9050 :     return MakeNode(op, 1, &n1, false);
     173             :   }
     174             : 
     175             :   Node* NewNode(const Operator* op, Node* n1, Node* n2) {
     176       63387 :     Node* buffer[] = {n1, n2};
     177       63387 :     return MakeNode(op, arraysize(buffer), buffer, false);
     178             :   }
     179             : 
     180             :   Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3) {
     181        5130 :     Node* buffer[] = {n1, n2, n3};
     182        5130 :     return MakeNode(op, arraysize(buffer), buffer, false);
     183             :   }
     184             : 
     185             :   Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4) {
     186           2 :     Node* buffer[] = {n1, n2, n3, n4};
     187           2 :     return MakeNode(op, arraysize(buffer), buffer, false);
     188             :   }
     189             : 
     190             :   Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
     191             :                 Node* n5) {
     192           2 :     Node* buffer[] = {n1, n2, n3, n4, n5};
     193           2 :     return MakeNode(op, arraysize(buffer), buffer, false);
     194             :   }
     195             : 
     196             :   Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
     197             :                 Node* n5, Node* n6) {
     198             :     Node* nodes[] = {n1, n2, n3, n4, n5, n6};
     199             :     return MakeNode(op, arraysize(nodes), nodes, false);
     200             :   }
     201             : 
     202             :   Node* NewNode(const Operator* op, int value_input_count, Node** value_inputs,
     203             :                 bool incomplete = false) {
     204        1547 :     return MakeNode(op, value_input_count, value_inputs, incomplete);
     205             :   }
     206             : 
     207             :   // Creates a new Phi node having {count} input values.
     208             :   Node* NewPhi(int count, Node* input, Node* control);
     209             :   Node* NewEffectPhi(int count, Node* input, Node* control);
     210             : 
     211             :   // Helpers for merging control, effect or value dependencies.
     212             :   Node* MergeControl(Node* control, Node* other);
     213             :   Node* MergeEffect(Node* value, Node* other, Node* control);
     214             :   Node* MergeValue(Node* value, Node* other, Node* control);
     215             : 
     216             :   // The main node creation chokepoint. Adds context, frame state, effect,
     217             :   // and control dependencies depending on the operator.
     218             :   Node* MakeNode(const Operator* op, int value_input_count, Node** value_inputs,
     219             :                  bool incomplete);
     220             : 
     221             :   // Helper to indicate a node exits the function body.
     222             :   void UpdateControlDependencyToLeaveFunction(Node* exit);
     223             : 
     224             :   // Prepare information for lazy deoptimization. This information is attached
     225             :   // to the given node and the output value produced by the node is combined.
     226             :   // Conceptually this frame state is "after" a given operation.
     227             :   void PrepareFrameState(Node* node, BailoutId ast_id,
     228             :                          OutputFrameStateCombine framestate_combine =
     229             :                              OutputFrameStateCombine::Ignore());
     230             : 
     231             :   // Prepare information for eager deoptimization. This information is carried
     232             :   // by dedicated {Checkpoint} nodes that are wired into the effect chain.
     233             :   // Conceptually this frame state is "before" a given operation.
     234             :   void PrepareEagerCheckpoint(BailoutId ast_id);
     235             : 
     236             :   BitVector* GetVariablesAssignedInLoop(IterationStatement* stmt);
     237             : 
     238             :   // Check if the given statement is an OSR entry.
     239             :   // If so, record the stack height into the compilation and return {true}.
     240             :   bool CheckOsrEntry(IterationStatement* stmt);
     241             : 
     242             :   // Computes local variable liveness and replaces dead variables in
     243             :   // frame states with the undefined values.
     244             :   void ClearNonLiveSlotsInFrameStates();
     245             : 
     246             :   Node** EnsureInputBufferSize(int size);
     247             : 
     248             :   // Named and keyed loads require a VectorSlotPair for successful lowering.
     249             :   VectorSlotPair CreateVectorSlotPair(FeedbackSlot slot) const;
     250             : 
     251             :   // Computes the frequency for JSCall and JSConstruct nodes.
     252             :   float ComputeCallFrequency(FeedbackSlot slot) const;
     253             : 
     254             :   // ===========================================================================
     255             :   // The following build methods all generate graph fragments and return one
     256             :   // resulting node. The operand stack height remains the same, variables and
     257             :   // other dependencies tracked by the environment might be mutated though.
     258             : 
     259             :   // Builders to create local function, script and block contexts.
     260             :   Node* BuildLocalActivationContext(Node* context);
     261             :   Node* BuildLocalFunctionContext(Scope* scope);
     262             :   Node* BuildLocalScriptContext(Scope* scope);
     263             :   Node* BuildLocalBlockContext(Scope* scope);
     264             : 
     265             :   // Builder to create an arguments object if it is used.
     266             :   Node* BuildArgumentsObject(Variable* arguments);
     267             : 
     268             :   // Builders for variable load and assignment.
     269             :   Node* BuildVariableAssignment(Variable* variable, Node* value,
     270             :                                 Token::Value op, const VectorSlotPair& slot,
     271             :                                 BailoutId bailout_id,
     272             :                                 OutputFrameStateCombine framestate_combine =
     273             :                                     OutputFrameStateCombine::Ignore());
     274             :   Node* BuildVariableDelete(Variable* variable, BailoutId bailout_id,
     275             :                             OutputFrameStateCombine framestate_combine);
     276             :   Node* BuildVariableLoad(Variable* variable, BailoutId bailout_id,
     277             :                           const VectorSlotPair& feedback,
     278             :                           OutputFrameStateCombine framestate_combine,
     279             :                           TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
     280             : 
     281             :   // Builders for property loads and stores.
     282             :   Node* BuildKeyedLoad(Node* receiver, Node* key,
     283             :                        const VectorSlotPair& feedback);
     284             :   Node* BuildNamedLoad(Node* receiver, Handle<Name> name,
     285             :                        const VectorSlotPair& feedback);
     286             :   Node* BuildKeyedStore(Node* receiver, Node* key, Node* value,
     287             :                         const VectorSlotPair& feedback);
     288             :   Node* BuildNamedStore(Node* receiver, Handle<Name> name, Node* value,
     289             :                         const VectorSlotPair& feedback);
     290             :   Node* BuildNamedStoreOwn(Node* receiver, Handle<Name> name, Node* value,
     291             :                            const VectorSlotPair& feedback);
     292             : 
     293             :   // Builders for global variable loads and stores.
     294             :   Node* BuildGlobalLoad(Handle<Name> name, const VectorSlotPair& feedback,
     295             :                         TypeofMode typeof_mode);
     296             :   Node* BuildGlobalStore(Handle<Name> name, Node* value,
     297             :                          const VectorSlotPair& feedback);
     298             : 
     299             :   // Builders for accessing the function context.
     300             :   Node* BuildLoadGlobalObject();
     301             :   Node* BuildLoadNativeContextField(int index);
     302             : 
     303             :   // Builders for automatic type conversion.
     304             :   Node* BuildToBoolean(Node* input, TypeFeedbackId feedback_id);
     305             :   Node* BuildToObject(Node* input, BailoutId bailout_id);
     306             : 
     307             :   // Builder for adding the [[HomeObject]] to a value if the value came from a
     308             :   // function literal and needs a home object. Do nothing otherwise.
     309             :   Node* BuildSetHomeObject(Node* value, Node* home_object,
     310             :                            LiteralProperty* property, int slot_number = 0);
     311             : 
     312             :   // Builders for error reporting at runtime.
     313             :   Node* BuildThrowError(Node* exception, BailoutId bailout_id);
     314             :   Node* BuildThrowReferenceError(Variable* var, BailoutId bailout_id);
     315             :   Node* BuildThrowConstAssignError(BailoutId bailout_id);
     316             : 
     317             :   // Builders for dynamic hole-checks at runtime.
     318             :   Node* BuildHoleCheckThenThrow(Node* value, Variable* var, Node* not_hole,
     319             :                                 BailoutId bailout_id);
     320             :   Node* BuildHoleCheckElseThrow(Node* value, Variable* var, Node* for_hole,
     321             :                                 BailoutId bailout_id);
     322             : 
     323             :   // Builders for non-local control flow.
     324             :   Node* BuildReturn(Node* return_value);
     325             :   Node* BuildThrow(Node* exception_value);
     326             : 
     327             :   // Builders for binary operations.
     328             :   Node* BuildBinaryOp(Node* left, Node* right, Token::Value op,
     329             :                       TypeFeedbackId feedback_id);
     330             : 
     331             :   // Process arguments to a call by popping {arity} elements off the operand
     332             :   // stack and build a call node using the given call operator.
     333             :   Node* ProcessArguments(const Operator* op, int arity);
     334             : 
     335             :   // ===========================================================================
     336             :   // The following build methods have the same contract as the above ones, but
     337             :   // they can also return {nullptr} to indicate that no fragment was built. Note
     338             :   // that these are optimizations, disabling any of them should still produce
     339             :   // correct graphs.
     340             : 
     341             :   // Optimization for variable load from global object.
     342             :   Node* TryLoadGlobalConstant(Handle<Name> name);
     343             : 
     344             :   // Optimizations for automatic type conversion.
     345             :   Node* TryFastToBoolean(Node* input);
     346             : 
     347             :   // ===========================================================================
     348             :   // The following visitation methods all recursively visit a subtree of the
     349             :   // underlying AST and extent the graph. The operand stack is mutated in a way
     350             :   // consistent with other compilers:
     351             :   //  - Expressions pop operands and push result, depending on {AstContext}.
     352             :   //  - Statements keep the operand stack balanced.
     353             : 
     354             :   // Visit statements.
     355             :   void VisitIfNotNull(Statement* stmt);
     356             : 
     357             :   // Visit expressions.
     358             :   void Visit(Expression* expr);
     359             :   void VisitForTest(Expression* expr);
     360             :   void VisitForEffect(Expression* expr);
     361             :   void VisitForValue(Expression* expr);
     362             :   void VisitForValueOrNull(Expression* expr);
     363             :   void VisitForValueOrTheHole(Expression* expr);
     364             :   void VisitForValues(ZoneList<Expression*>* exprs);
     365             : 
     366             :   // Common for all IterationStatement bodies.
     367             :   void VisitIterationBody(IterationStatement* stmt, LoopBuilder* loop,
     368             :                           BailoutId stack_check_id);
     369             : 
     370             :   // Dispatched from VisitCall.
     371             :   void VisitCallSuper(Call* expr);
     372             : 
     373             :   // Dispatched from VisitCallRuntime.
     374             :   void VisitCallJSRuntime(CallRuntime* expr);
     375             : 
     376             :   // Dispatched from VisitUnaryOperation.
     377             :   void VisitDelete(UnaryOperation* expr);
     378             :   void VisitVoid(UnaryOperation* expr);
     379             :   void VisitTypeof(UnaryOperation* expr);
     380             :   void VisitNot(UnaryOperation* expr);
     381             : 
     382             :   // Dispatched from VisitTypeof, VisitLiteralCompareTypeof.
     383             :   void VisitTypeofExpression(Expression* expr);
     384             : 
     385             :   // Dispatched from VisitBinaryOperation.
     386             :   void VisitComma(BinaryOperation* expr);
     387             :   void VisitLogicalExpression(BinaryOperation* expr);
     388             :   void VisitArithmeticExpression(BinaryOperation* expr);
     389             : 
     390             :   // Dispatched from VisitCompareOperation.
     391             :   void VisitLiteralCompareNil(CompareOperation* expr, Expression* sub_expr,
     392             :                               Node* nil_value);
     393             :   void VisitLiteralCompareTypeof(CompareOperation* expr, Expression* sub_expr,
     394             :                                  Handle<String> check);
     395             : 
     396             :   // Dispatched from VisitObjectLiteral.
     397             :   void VisitObjectLiteralAccessor(Node* home_object,
     398             :                                   ObjectLiteralProperty* property);
     399             : 
     400      894543 :   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
     401             :   DISALLOW_COPY_AND_ASSIGN(AstGraphBuilder);
     402             : };
     403             : 
     404             : 
     405             : // The abstract execution environment for generated code consists of
     406             : // parameter variables, local variables and the operand stack. The
     407             : // environment will perform proper SSA-renaming of all tracked nodes
     408             : // at split and merge points in the control flow. Internally all the
     409             : // values are stored in one list using the following layout:
     410             : //
     411             : //  [parameters (+receiver)] [locals] [operand stack]
     412             : //
     413             : class AstGraphBuilder::Environment : public ZoneObject {
     414             :  public:
     415             :   Environment(AstGraphBuilder* builder, DeclarationScope* scope,
     416             :               Node* control_dependency);
     417             : 
     418             :   int parameters_count() const { return parameters_count_; }
     419             :   int locals_count() const { return locals_count_; }
     420       28276 :   int context_chain_length() { return static_cast<int>(contexts_.size()); }
     421             :   int stack_height() {
     422       40096 :     return static_cast<int>(values()->size()) - parameters_count_ -
     423       20048 :            locals_count_;
     424             :   }
     425             : 
     426             :   // Operations on parameter or local variables.
     427             :   void Bind(Variable* variable, Node* node);
     428             :   Node* Lookup(Variable* variable);
     429             :   void MarkAllLocalsLive();
     430             : 
     431             :   // Raw operations on parameter variables.
     432             :   void RawParameterBind(int index, Node* node);
     433             :   Node* RawParameterLookup(int index);
     434             : 
     435             :   // Operations on the context chain.
     436       82601 :   Node* Context() const { return contexts_.back(); }
     437        2555 :   void PushContext(Node* context) { contexts()->push_back(context); }
     438             :   void PopContext() { contexts()->pop_back(); }
     439             :   void TrimContextChain(int trim_to_length) {
     440        9288 :     contexts()->resize(trim_to_length);
     441             :   }
     442             : 
     443             :   // Operations on the operand stack.
     444             :   void Push(Node* node) {
     445      165082 :     values()->push_back(node);
     446             :   }
     447             :   Node* Top() {
     448             :     DCHECK(stack_height() > 0);
     449         528 :     return values()->back();
     450             :   }
     451             :   Node* Pop() {
     452             :     DCHECK(stack_height() > 0);
     453      162833 :     Node* back = values()->back();
     454             :     values()->pop_back();
     455             :     return back;
     456             :   }
     457             : 
     458             :   // Direct mutations of the operand stack.
     459           2 :   void Poke(int depth, Node* node) {
     460             :     DCHECK(depth >= 0 && depth < stack_height());
     461           4 :     int index = static_cast<int>(values()->size()) - depth - 1;
     462           4 :     values()->at(index) = node;
     463           2 :   }
     464          10 :   Node* Peek(int depth) {
     465             :     DCHECK(depth >= 0 && depth < stack_height());
     466          20 :     int index = static_cast<int>(values()->size()) - depth - 1;
     467          20 :     return values()->at(index);
     468             :   }
     469        1498 :   void Drop(int depth) {
     470             :     DCHECK(depth >= 0 && depth <= stack_height());
     471        2996 :     values()->erase(values()->end() - depth, values()->end());
     472        1498 :   }
     473        9288 :   void TrimStack(int trim_to_height) {
     474        9288 :     int depth = stack_height() - trim_to_height;
     475             :     DCHECK(depth >= 0 && depth <= stack_height());
     476       18576 :     values()->erase(values()->end() - depth, values()->end());
     477        9288 :   }
     478             : 
     479             :   // Preserve a checkpoint of the environment for the IR graph. Any
     480             :   // further mutation of the environment will not affect checkpoints.
     481             :   Node* Checkpoint(BailoutId ast_id, OutputFrameStateCombine combine =
     482             :                                          OutputFrameStateCombine::Ignore(),
     483             :                    bool node_has_exception = false);
     484             : 
     485             :   // Inserts a loop exit control node and renames the environment.
     486             :   // This is useful for loop peeling to insert phis at loop exits.
     487             :   void PrepareForLoopExit(Node* loop, BitVector* assigned_variables);
     488             : 
     489             :   // Control dependency tracked by this environment.
     490             :   Node* GetControlDependency() { return control_dependency_; }
     491             :   void UpdateControlDependency(Node* dependency) {
     492      105302 :     control_dependency_ = dependency;
     493             :   }
     494             : 
     495             :   // Effect dependency tracked by this environment.
     496             :   Node* GetEffectDependency() { return effect_dependency_; }
     497             :   void UpdateEffectDependency(Node* dependency) {
     498      168769 :     effect_dependency_ = dependency;
     499             :   }
     500             : 
     501             :   // Mark this environment as being unreachable.
     502       10955 :   void MarkAsUnreachable() {
     503       10955 :     UpdateControlDependency(builder()->jsgraph()->Dead());
     504       10955 :     liveness_block_ = nullptr;
     505             :   }
     506      210971 :   bool IsMarkedAsUnreachable() {
     507      210971 :     return GetControlDependency()->opcode() == IrOpcode::kDead;
     508             :   }
     509             : 
     510             :   // Merge another environment into this one.
     511             :   void Merge(Environment* other);
     512             : 
     513             :   // Copies this environment at a control-flow split point.
     514             :   Environment* CopyForConditional();
     515             : 
     516             :   // Copies this environment to a potentially unreachable control-flow point.
     517             :   Environment* CopyAsUnreachable();
     518             : 
     519             :   // Copies this environment at a loop header control-flow point.
     520             :   Environment* CopyForLoop(BitVector* assigned, bool is_osr = false);
     521             : 
     522             :   // Copies this environment for Osr entry. This only produces environment
     523             :   // of the right shape, the caller is responsible for filling in the right
     524             :   // values and dependencies.
     525             :   Environment* CopyForOsrEntry();
     526             : 
     527             :  private:
     528             :   AstGraphBuilder* builder_;
     529             :   int parameters_count_;
     530             :   int locals_count_;
     531             :   LivenessAnalyzerBlock* liveness_block_;
     532             :   NodeVector values_;
     533             :   NodeVector contexts_;
     534             :   Node* control_dependency_;
     535             :   Node* effect_dependency_;
     536             :   Node* parameters_node_;
     537             :   Node* locals_node_;
     538             :   Node* stack_node_;
     539             : 
     540             :   explicit Environment(Environment* copy,
     541             :                        LivenessAnalyzerBlock* liveness_block);
     542             :   Environment* CopyAndShareLiveness();
     543             :   void UpdateStateValues(Node** state_values, int offset, int count);
     544       34764 :   Zone* zone() const { return builder_->local_zone(); }
     545       18970 :   Graph* graph() const { return builder_->graph(); }
     546             :   AstGraphBuilder* builder() const { return builder_; }
     547       24582 :   CommonOperatorBuilder* common() { return builder_->common(); }
     548             :   NodeVector* values() { return &values_; }
     549             :   NodeVector* contexts() { return &contexts_; }
     550             :   LivenessAnalyzerBlock* liveness_block() { return liveness_block_; }
     551             :   bool IsLivenessAnalysisEnabled();
     552             :   bool IsLivenessBlockConsistent();
     553             : 
     554             :   // Prepare environment to be used as loop header.
     555             :   void PrepareForLoop(BitVector* assigned);
     556             :   void PrepareForOsrEntry();
     557             : };
     558             : 
     559        2507 : class AstGraphBuilderWithPositions final : public AstGraphBuilder {
     560             :  public:
     561             :   AstGraphBuilderWithPositions(Zone* local_zone, CompilationInfo* info,
     562             :                                JSGraph* jsgraph, float invocation_frequency,
     563             :                                LoopAssignmentAnalysis* loop_assignment,
     564             :                                SourcePositionTable* source_positions,
     565             :                                int inlining_id = SourcePosition::kNotInlined);
     566             : 
     567        2507 :   bool CreateGraph(bool stack_check = true) {
     568        2507 :     SourcePositionTable::Scope pos_scope(source_positions_, start_position_);
     569        5014 :     return AstGraphBuilder::CreateGraph(stack_check);
     570             :   }
     571             : 
     572             : #define DEF_VISIT(type)                                                  \
     573             :   void Visit##type(type* node) override {                                \
     574             :     SourcePositionTable::Scope pos(                                      \
     575             :         source_positions_,                                               \
     576             :         SourcePosition(node->position(), start_position_.InliningId())); \
     577             :     AstGraphBuilder::Visit##type(node);                                  \
     578             :   }
     579     1115045 :   AST_NODE_LIST(DEF_VISIT)
     580             : #undef DEF_VISIT
     581             : 
     582             :  private:
     583             :   SourcePositionTable* const source_positions_;
     584             :   SourcePosition const start_position_;
     585             : };
     586             : 
     587             : }  // namespace compiler
     588             : }  // namespace internal
     589             : }  // namespace v8
     590             : 
     591             : #endif  // V8_COMPILER_AST_GRAPH_BUILDER_H_

Generated by: LCOV version 1.10