[Interpreter] Generate valid FrameStates 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 {
 
 // 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:
+  enum class AccumulatorUpdateMode {
+    kOutputIgnored,
+    kOutputInAccumulator,
+  };
+
   class Environment;
+  class FrameStateBeforeAndAfter;
 
   void CreateGraphBody(bool stack_check);
   void VisitBytecodes();
 
   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.
   Node* GetNewTarget();
 
   // Builder for accessing a (potentially immutable) object field.
   Node* BuildLoadObjectField(Node* object, int offset);
   Node* BuildLoadImmutableObjectField(Node* object, int offset);
 
   // Builder for accessing type feedback vector.
   Node* BuildLoadFeedbackVector();
 
   // Builder for loading the a native context field.
   Node* BuildLoadNativeContextField(int index);
 
   // Helper function for creating a pair containing type feedback vector and
   // 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_; }
 
   // 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) {
@@ skipping 27 matching lines @@
 
   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 BuildCreateLiteral(const Operator* op);
+  void BuildCreateLiteral(const Operator* op,
+                          const interpreter::BytecodeArrayIterator& iterator);
   void BuildCreateRegExpLiteral(
       const interpreter::BytecodeArrayIterator& iterator);
   void BuildCreateArrayLiteral(
       const interpreter::BytecodeArrayIterator& iterator);
   void BuildCreateObjectLiteral(
       const interpreter::BytecodeArrayIterator& iterator);
   void BuildLoadGlobal(const interpreter::BytecodeArrayIterator& iterator,
                        TypeofMode typeof_mode);
   void BuildStoreGlobal(const interpreter::BytecodeArrayIterator& iterator);
   void BuildNamedLoad(const interpreter::BytecodeArrayIterator& iterator);
@@ skipping 16 matching lines @@
   // 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(); }
   Zone* local_zone() const { return local_zone_; }
   const Handle<BytecodeArray>& bytecode_array() const {
     return bytecode_array_;
   }
+  const FrameStateFunctionInfo* frame_state_function_info() const {
+    return frame_state_function_info_;
+  }
 
   LanguageMode language_mode() const {
     // TODO(mythria): Don't rely on parse information to get language mode.
     return info()->language_mode();
   }
 
 #define DECLARE_VISIT_BYTECODE(name, ...) \
   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_;
+  const FrameStateFunctionInfo* frame_state_function_info_;
   Environment* environment_;
 
   // 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_;
@@ skipping 24 matching lines @@
 
   bool IsMarkedAsUnreachable() const;
   void MarkAsUnreachable();
 
   // Effect dependency tracked by this environment.
   Node* GetEffectDependency() { return effect_dependency_; }
   void UpdateEffectDependency(Node* dependency) {
     effect_dependency_ = dependency;
   }
 
+  // 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, AccumulatorUpdateMode update_mode);
+
   // 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; }
 
  private:
   int RegisterToValuesIndex(interpreter::Register the_register) const;
+  void UpdateStateValues(Node** state_values, int offset, int count);
 
   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_; }
+  int accumulator_base() const { return accumulator_base_; }
 
   BytecodeGraphBuilder* builder_;
   int register_count_;
   int parameter_count_;
   Node* accumulator_;
   Node* context_;
   Node* control_dependency_;
   Node* effect_dependency_;
   NodeVector values_;
   int register_base_;
+  int accumulator_base_;
+  Node* parameters_state_values_;
+  Node* registers_state_values_;
+  Node* accumulator_state_values_;
 };
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_