[Interpreter] Add support for CallRuntimeForPair to 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/bytecode-branch-analysis.h"
 #include "src/compiler/js-graph.h"
@@ skipping 10 matching lines @@
  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();
@@ skipping 210 matching lines @@
 
 
 class BytecodeGraphBuilder::Environment : public ZoneObject {
  public:
   Environment(BytecodeGraphBuilder* builder, int register_count,
               int parameter_count, Node* control_dependency, Node* context);
 
   int parameter_count() const { return parameter_count_; }
   int register_count() const { return register_count_; }
 
-  void BindRegister(interpreter::Register the_register, Node* node);
+  Node* LookupAccumulator() const;
   Node* LookupRegister(interpreter::Register the_register) const;
+
   void ExchangeRegisters(interpreter::Register reg0,
                          interpreter::Register reg1);
 
   void BindAccumulator(Node* node, FrameStateBeforeAndAfter* states = nullptr);
-  Node* LookupAccumulator() const;
-
+  void BindRegister(interpreter::Register the_register, Node* node,
+                    FrameStateBeforeAndAfter* states = nullptr);
+  void BindRegistersToProjections(interpreter::Register first_reg, Node* node,
+                                  int count,
+                                  FrameStateBeforeAndAfter* states = nullptr);
   void RecordAfterState(Node* node, FrameStateBeforeAndAfter* states);
 
   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);
+  Node* Checkpoint(BailoutId bytecode_offset, OutputFrameStateCombine combine);
 
   // Returns true if the state values are up to date with the current
-  // environment. If update_mode is AccumulatorUpdateMode::kOutputInAccumulator
-  // then accumulator state can be different from the environment.
-  bool StateValuesAreUpToDate(AccumulatorUpdateMode update_mode);
+  // environment.
+  bool StateValuesAreUpToDate(int output_poke_offset, int output_poke_count);
 
   // 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();
+  bool StateValuesAreUpToDate(Node** state_values, int offset, int count,
+                              int output_poke_start, int output_poke_end);
   bool StateValuesRequireUpdate(Node** state_values, int offset, int count);
   void UpdateStateValues(Node** state_values, int offset, int count);
 
   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_; }
@@ skipping 13 matching lines @@
   Node* accumulator_state_values_;
   int register_base_;
   int accumulator_base_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_