[Interpreter] Local flow control in the bytecode graph builder.

src/compiler/bytecode-graph-builder.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_
 #define V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_
 
 #include "src/compiler.h"
 #include "src/compiler/js-graph.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecodes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+class BytecodeBasicBlock;
+
 // The BytecodeGraphBuilder produces a high-level IR graph based on
 // interpreter bytecodes.
 class BytecodeGraphBuilder {
  public:
   BytecodeGraphBuilder(Zone* local_zone, CompilationInfo* info,
                        JSGraph* jsgraph);
 
   // Creates a graph by visiting bytecodes.
   bool CreateGraph(bool stack_check = true);
 
   Graph* graph() const { return jsgraph_->graph(); }
 
  private:
   class Environment;
+  class BlockEnvironmentInfo;
 
   void CreateGraphBody(bool stack_check);
-  void VisitBytecodes();
+  void VisitBasicBlocks();
+  void VisitBytecodesInBasicBlock(BytecodeBasicBlock* block);
 
   Node* LoadAccumulator(Node* value);
 
   // Get or create the node that represents the outer function closure.
   Node* GetFunctionClosure();
 
   // Get or create the node that represents the outer function context.
   Node* GetFunctionContext();
 
   // Get or create the node that represents the incoming new target value.
@@ skipping 13 matching lines @@
   // a feedback slot.
   VectorSlotPair CreateVectorSlotPair(int slot_id);
 
   // Replaces the frame state inputs with empty frame states.
   void AddEmptyFrameStateInputs(Node* node);
 
   void set_environment(Environment* env) { environment_ = env; }
   const Environment* environment() const { return environment_; }
   Environment* environment() { return environment_; }
 
+  void set_basic_block(const BytecodeBasicBlock* block) {
+    basic_block_ = block;
+  }
+  const BytecodeBasicBlock* basic_block() const { return basic_block_; }
+
   // Node creation helpers
   Node* NewNode(const Operator* op, bool incomplete = false) {
     return MakeNode(op, 0, static_cast<Node**>(NULL), incomplete);
   }
 
   Node* NewNode(const Operator* op, Node* n1) {
     Node* buffer[] = {n1};
     return MakeNode(op, arraysize(buffer), buffer, 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);
   }
 
+  // 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);
+  }
+
+  // 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* effect, Node* other_effect, Node* control);
+  Node* MergeValue(Node* value, Node* other_value, 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);
 
-  Node* MergeControl(Node* control, Node* other);
+  // Helper to indicate a node exits the function body.
+  void UpdateControlDependencyToLeaveFunction(Node* exit);
 
   Node** EnsureInputBufferSize(int size);
 
-  void UpdateControlDependencyToLeaveFunction(Node* exit);
-
   Node* ProcessCallArguments(const Operator* call_op, Node* callee,
                              interpreter::Register receiver, size_t arity);
   Node* ProcessCallNewArguments(const Operator* call_new_op,
                                 interpreter::Register callee,
                                 interpreter::Register first_arg, size_t arity);
   Node* ProcessCallRuntimeArguments(const Operator* call_runtime_op,
                                     interpreter::Register first_arg,
                                     size_t arity);
 
   void BuildLoadGlobal(const interpreter::BytecodeArrayIterator& iterator,
                        TypeofMode typeof_mode);
   void BuildStoreGlobal(const interpreter::BytecodeArrayIterator& iterator);
   void BuildNamedLoad(const interpreter::BytecodeArrayIterator& iterator);
   void BuildKeyedLoad(const interpreter::BytecodeArrayIterator& iterator);
   void BuildNamedStore(const interpreter::BytecodeArrayIterator& iterator);
   void BuildKeyedStore(const interpreter::BytecodeArrayIterator& iterator);
   void BuildCall(const interpreter::BytecodeArrayIterator& iterator);
   void BuildBinaryOp(const Operator* op,
                      const interpreter::BytecodeArrayIterator& iterator);
   void BuildCompareOp(const Operator* op,
                       const interpreter::BytecodeArrayIterator& iterator);
   void BuildDelete(const interpreter::BytecodeArrayIterator& iterator);
   void BuildCastOperator(const Operator* js_op,
                          const interpreter::BytecodeArrayIterator& iterator);
 
+  // Control flow plumbing.
+  void PrepareForNewBasicBlockVisit();
+  void CompleteNewBasicBlockVisit();
+  void BuildReturn();
+  void BuildJump();
+  void BuildConditionalJump(Node* condition);
+  void BuildBackEdgeIfRequired(BytecodeBasicBlock* target);
+
   // Growth increment for the temporary buffer used to construct input lists to
   // new nodes.
   static const int kInputBufferSizeIncrement = 64;
 
   // Field accessors
   CommonOperatorBuilder* common() const { return jsgraph_->common(); }
   Zone* graph_zone() const { return graph()->zone(); }
   CompilationInfo* info() const { return info_; }
   JSGraph* jsgraph() const { return jsgraph_; }
   JSOperatorBuilder* javascript() const { return jsgraph_->javascript(); }
@@ skipping 11 matching lines @@
   void Visit##name(const interpreter::BytecodeArrayIterator& iterator);
   BYTECODE_LIST(DECLARE_VISIT_BYTECODE)
 #undef DECLARE_VISIT_BYTECODE
 
   Zone* local_zone_;
   CompilationInfo* info_;
   JSGraph* jsgraph_;
   Handle<BytecodeArray> bytecode_array_;
   Environment* environment_;
 
+  const BytecodeBasicBlock* basic_block_;
+  ZoneVector<BlockEnvironmentInfo*> block_environment_infos_;
+
   // Temporary storage for building node input lists.
   int input_buffer_size_;
   Node** input_buffer_;
 
   // Nodes representing values in the activation record.
   SetOncePointer<Node> function_context_;
   SetOncePointer<Node> function_closure_;
   SetOncePointer<Node> new_target_;
 
   // Optimization to cache loaded feedback vector.
@@ skipping 31 matching lines @@
 
   // Control dependency tracked by this environment.
   Node* GetControlDependency() const { return control_dependency_; }
   void UpdateControlDependency(Node* dependency) {
     control_dependency_ = dependency;
   }
 
   Node* Context() const { return context_; }
   void SetContext(Node* new_context) { context_ = new_context; }
 
+  Environment* CopyForConditional() const;
+  Environment* CopyForLoop();
+  void Merge(Environment* other);
+
  private:
+  explicit Environment(const Environment* copy);
+  void PrepareForLoop();
+
   int RegisterToValuesIndex(interpreter::Register the_register) const;
-
   Zone* zone() const { return builder_->local_zone(); }
   Graph* graph() const { return builder_->graph(); }
   CommonOperatorBuilder* common() const { return builder_->common(); }
   BytecodeGraphBuilder* builder() const { return builder_; }
   const NodeVector* values() const { return &values_; }
   NodeVector* values() { return &values_; }
   Node* accumulator() { return accumulator_; }
   int register_base() const { return register_base_; }
 
   BytecodeGraphBuilder* builder_;
   int register_count_;
   int parameter_count_;
   Node* accumulator_;
   Node* context_;
   Node* control_dependency_;
   Node* effect_dependency_;
   NodeVector values_;
   int register_base_;
 };
 
+// A class to help passage between the environments associated with basic
+// blocks.
+class BytecodeGraphBuilder::BlockEnvironmentInfo final : public ZoneObject {
+ public:
+  typedef BytecodeGraphBuilder::Environment Environment;
+
+  BlockEnvironmentInfo()
+      : loop_header_env_(nullptr),
+        if_true_env_(nullptr),
+        if_false_env_(nullptr) {}
+
+  Environment* loop_header_environment() const { return loop_header_env_; }
+  Environment* if_true_environment() const { return if_true_env_; }
+  Environment* if_false_environment() const { return if_false_env_; }
+
+  void set_loop_header_environment(Environment* env) { loop_header_env_ = env; }
+  void set_if_true_environment(Environment* env) { if_true_env_ = env; }
+  void set_if_false_environment(Environment* env) { if_false_env_ = env; }
+
+ private:
+  Environment* loop_header_env_;
+  Environment* if_true_env_;
+  Environment* if_false_env_;
+};
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_