[Interpreter] Add support for CallRuntimeForPair to Bytecode Graph Builder.

src/compiler/bytecode-graph-builder.cc

 // 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.
 
 #include "src/compiler/bytecode-graph-builder.h"
 
 #include "src/compiler/bytecode-branch-analysis.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/operator-properties.h"
 #include "src/interpreter/bytecodes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Helper for generating frame states for before and after a bytecode.
 class BytecodeGraphBuilder::FrameStateBeforeAndAfter {
  public:
   FrameStateBeforeAndAfter(BytecodeGraphBuilder* builder,
                            const interpreter::BytecodeArrayIterator& iterator)
-      : builder_(builder), id_after_(BailoutId::None()) {
+      : builder_(builder),
+        id_after_(BailoutId::None()),
+        added_to_node_(false),
+        output_poke_offset_(0),
+        output_poke_count_(0) {
     BailoutId id_before(iterator.current_offset());
     frame_state_before_ = builder_->environment()->Checkpoint(
-        id_before, AccumulatorUpdateMode::kOutputIgnored);
+        id_before, OutputFrameStateCombine::Ignore());
     id_after_ = BailoutId(id_before.ToInt() + iterator.current_bytecode_size());
   }
 
   ~FrameStateBeforeAndAfter() {
-    DCHECK(builder_->environment()->StateValuesAreUpToDate(
-        accumulator_update_mode_));
+    DCHECK(added_to_node_);
+    DCHECK(builder_->environment()->StateValuesAreUpToDate(output_poke_offset_,
+                                                           output_poke_count_));
   }
 
  private:
   friend class Environment;
 
-  void AddToNode(Node* node, AccumulatorUpdateMode update_mode) {
+  void AddToNode(Node* node, OutputFrameStateCombine combine, int poke_count) {
+    DCHECK(!added_to_node_);
     int count = OperatorProperties::GetFrameStateInputCount(node->op());
     DCHECK_LE(count, 2);
     if (count >= 1) {
       // Add the frame state for after the operation.
       DCHECK_EQ(IrOpcode::kDead,
                 NodeProperties::GetFrameStateInput(node, 0)->opcode());
       Node* frame_state_after =
-          builder_->environment()->Checkpoint(id_after_, update_mode);
+          builder_->environment()->Checkpoint(id_after_, combine);
       NodeProperties::ReplaceFrameStateInput(node, 0, frame_state_after);
     }
 
     if (count >= 2) {
       // Add the frame state for before the operation.
       DCHECK_EQ(IrOpcode::kDead,
                 NodeProperties::GetFrameStateInput(node, 1)->opcode());
       NodeProperties::ReplaceFrameStateInput(node, 1, frame_state_before_);
     }
-    accumulator_update_mode_ = update_mode;
+
+    if (poke_count) {
+      DCHECK(!combine.IsOutputIgnored());
+      output_poke_offset_ = static_cast<int>(combine.GetOffsetToPokeAt());
+      output_poke_count_ = poke_count;
+    }
+    added_to_node_ = true;
   }
 
   BytecodeGraphBuilder* builder_;
   Node* frame_state_before_;
   BailoutId id_after_;
-  AccumulatorUpdateMode accumulator_update_mode_;
+
+  bool added_to_node_;
+  int output_poke_offset_;
+  int output_poke_count_;
 };
 
 
 // Issues:
 // - Scopes - intimately tied to AST. Need to eval what is needed.
 // - Need to resolve closure parameter treatment.
 BytecodeGraphBuilder::Environment::Environment(BytecodeGraphBuilder* builder,
                                                int register_count,
                                                int parameter_count,
                                                Node* control_dependency,
@@ skipping 56 matching lines @@
 int BytecodeGraphBuilder::Environment::RegisterToValuesIndex(
     interpreter::Register the_register) const {
   if (the_register.is_parameter()) {
     return the_register.ToParameterIndex(parameter_count());
   } else {
     return the_register.index() + register_base();
   }
 }
 
 
-void BytecodeGraphBuilder::Environment::BindRegister(
-    interpreter::Register the_register, Node* node) {
-  int values_index = RegisterToValuesIndex(the_register);
-  values()->at(values_index) = node;
+Node* BytecodeGraphBuilder::Environment::LookupAccumulator() const {
+  return values()->at(accumulator_base_);
 }
 
 
 Node* BytecodeGraphBuilder::Environment::LookupRegister(
     interpreter::Register the_register) const {
   if (the_register.is_function_context()) {
     return builder()->GetFunctionContext();
   } else if (the_register.is_function_closure()) {
     return builder()->GetFunctionClosure();
   } else if (the_register.is_new_target()) {
     return builder()->GetNewTarget();
   } else {
     int values_index = RegisterToValuesIndex(the_register);
     return values()->at(values_index);
   }
 }
 
 
-void BytecodeGraphBuilder::Environment::BindAccumulator(
-    Node* node, FrameStateBeforeAndAfter* states) {
-  if (states) {
-    states->AddToNode(node, AccumulatorUpdateMode::kOutputInAccumulator);
-  }
-  values()->at(accumulator_base_) = node;
-}
-
-
-void BytecodeGraphBuilder::Environment::RecordAfterState(
-    Node* node, FrameStateBeforeAndAfter* states) {
-  states->AddToNode(node, AccumulatorUpdateMode::kOutputIgnored);
-}
-
-
 void BytecodeGraphBuilder::Environment::ExchangeRegisters(
     interpreter::Register reg0, interpreter::Register reg1) {
   int reg0_index = RegisterToValuesIndex(reg0);
   int reg1_index = RegisterToValuesIndex(reg1);
   Node* saved_reg0_value = values()->at(reg0_index);
   values()->at(reg0_index) = values()->at(reg1_index);
   values()->at(reg1_index) = saved_reg0_value;
 }
 
 
-Node* BytecodeGraphBuilder::Environment::LookupAccumulator() const {
-  return values()->at(accumulator_base_);
+void BytecodeGraphBuilder::Environment::BindAccumulator(
+    Node* node, FrameStateBeforeAndAfter* states) {
+  if (states) {
+    states->AddToNode(node, OutputFrameStateCombine::PokeAt(0), 1);
+  }
+  values()->at(accumulator_base_) = node;
 }
 
 
+void BytecodeGraphBuilder::Environment::BindRegister(
+    interpreter::Register the_register, Node* node,
+    FrameStateBeforeAndAfter* states) {
+  int values_index = RegisterToValuesIndex(the_register);
+  if (states) {
+    states->AddToNode(
+        node, OutputFrameStateCombine::PokeAt(accumulator_base_ - values_index),
+        1);
+  }
+  values()->at(values_index) = node;
+}
+
+
+void BytecodeGraphBuilder::Environment::BindRegistersToProjections(
+    interpreter::Register first_reg, Node* node, int count,
+    FrameStateBeforeAndAfter* states) {
+  int values_index = RegisterToValuesIndex(first_reg);
+  if (states) {

[Jarin, 2016/01/08 12:32:55]

I think you should check that 'node->op()->ValueOutputCount() == count' (either
here or in AddToNode). Otherwise, the deopt will not do what you want.

[rmcilroy, 2016/01/08 14:47:20]

Right, actually I think we should just use node->op()->ValueOutputCount() rather
than passing a seperate count around, WDYT?

+    states->AddToNode(
+        node, OutputFrameStateCombine::PokeAt(accumulator_base_ - values_index),
+        count);
+  }
+  for (int i = 0; i < count; i++) {
+    values()->at(values_index + i) =
+        builder()->NewNode(common()->Projection(i), node);
+  }
+}
+
+
+void BytecodeGraphBuilder::Environment::RecordAfterState(
+    Node* node, FrameStateBeforeAndAfter* states) {
+  states->AddToNode(node, OutputFrameStateCombine::Ignore(), 0);
+}
+
+
 bool BytecodeGraphBuilder::Environment::IsMarkedAsUnreachable() const {
   return GetControlDependency()->opcode() == IrOpcode::kDead;
 }
 
 
 void BytecodeGraphBuilder::Environment::MarkAsUnreachable() {
   UpdateControlDependency(builder()->jsgraph()->Dead());
 }
 
 
@@ skipping 84 matching lines @@
                                                           int offset,
                                                           int count) {
   if (StateValuesRequireUpdate(state_values, offset, count)) {
     const Operator* op = common()->StateValues(count);
     (*state_values) = graph()->NewNode(op, count, &values()->at(offset));
   }
 }
 
 
 Node* BytecodeGraphBuilder::Environment::Checkpoint(
-    BailoutId bailout_id, AccumulatorUpdateMode update_mode) {
+    BailoutId bailout_id, OutputFrameStateCombine combine) {
   if (!builder()->info()->is_deoptimization_enabled()) {
     return builder()->jsgraph()->EmptyFrameState();
   }
 
   // TODO(rmcilroy): Consider using StateValuesCache for some state values.
   UpdateStateValues(&parameters_state_values_, 0, parameter_count());
   UpdateStateValues(&registers_state_values_, register_base(),
                     register_count());
   UpdateStateValues(&accumulator_state_values_, accumulator_base(), 1);
 
-  OutputFrameStateCombine combine =
-      update_mode == AccumulatorUpdateMode::kOutputIgnored
-          ? OutputFrameStateCombine::Ignore()
-          : OutputFrameStateCombine::PokeAt(0);
   const Operator* op = common()->FrameState(
       bailout_id, combine, builder()->frame_state_function_info());
-
   Node* result = graph()->NewNode(
       op, parameters_state_values_, registers_state_values_,
       accumulator_state_values_, Context(), builder()->GetFunctionClosure(),
       builder()->graph()->start());
 
   return result;
 }
 
 
 bool BytecodeGraphBuilder::Environment::StateValuesAreUpToDate(
-    AccumulatorUpdateMode update_mode) {
-  return !StateValuesRequireUpdate(&parameters_state_values_, 0,
-                                   parameter_count()) &&
-         !StateValuesRequireUpdate(&registers_state_values_, register_base(),
-                                   register_count()) &&
-         (update_mode == AccumulatorUpdateMode::kOutputInAccumulator ||
-          !StateValuesRequireUpdate(&accumulator_state_values_,
-                                    accumulator_base(), 1));
+    Node** state_values, int offset, int count, int output_poke_start,
+    int output_poke_end) {
+  DCHECK_LE(static_cast<size_t>(offset + count), values()->size());
+  for (int i = 0; i < count; i++, offset++) {
+    if (offset < output_poke_start || offset >= output_poke_end) {
+      if ((*state_values)->InputAt(i) != values()->at(offset)) {
+        return false;
+      }
+    }
+  }
+  return true;
 }
 
 
+bool BytecodeGraphBuilder::Environment::StateValuesAreUpToDate(
+    int output_poke_offset, int output_poke_count) {
+  // Poke offset is relative to the top of the stack (i.e., the accumulator).
+  int output_poke_start = accumulator_base() - output_poke_offset;
+  int output_poke_end = output_poke_start + output_poke_count;
+  return StateValuesAreUpToDate(&parameters_state_values_, 0, parameter_count(),
+                                output_poke_start, output_poke_end) &&
+         StateValuesAreUpToDate(&registers_state_values_, register_base(),
+                                register_count(), output_poke_start,
+                                output_poke_end) &&
+         StateValuesAreUpToDate(&accumulator_state_values_, accumulator_base(),
+                                1, output_poke_start, output_poke_end);
+}
+
+
 BytecodeGraphBuilder::BytecodeGraphBuilder(Zone* local_zone,
                                            CompilationInfo* compilation_info,
                                            JSGraph* jsgraph)
     : local_zone_(local_zone),
       info_(compilation_info),
       jsgraph_(jsgraph),
       bytecode_array_(handle(info()->shared_info()->bytecode_array())),
       frame_state_function_info_(common()->CreateFrameStateFunctionInfo(
           FrameStateType::kInterpretedFunction,
           bytecode_array()->parameter_count(),
@@ skipping 72 matching lines @@
     Node* vector = BuildLoadImmutableObjectField(
         shared, SharedFunctionInfo::kFeedbackVectorOffset);
     feedback_vector_.set(vector);
   }
   return feedback_vector_.get();
 }
 
 
 VectorSlotPair BytecodeGraphBuilder::CreateVectorSlotPair(int slot_id) {
   Handle<TypeFeedbackVector> feedback_vector = info()->feedback_vector();
-  FeedbackVectorSlot slot = feedback_vector->ToSlot(slot_id);
+  FeedbackVectorSlot slot;
+  if (slot_id >= TypeFeedbackVector::kReservedIndexCount) {
+    slot = feedback_vector->ToSlot(slot_id);
+  }
   return VectorSlotPair(feedback_vector, slot);
 }
 
 
 bool BytecodeGraphBuilder::CreateGraph(bool stack_check) {
   // Set up the basic structure of the graph. Outputs for {Start} are
   // the formal parameters (including the receiver) plus context and
   // closure.
 
   // Set up the basic structure of the graph. Outputs for {Start} are the formal
@@ skipping 759 matching lines @@
 
   // Create node to perform the runtime call.
   const Operator* call = javascript()->CallRuntime(functionId, arg_count);
   Node* value = ProcessCallRuntimeArguments(call, first_arg, arg_count);
   environment()->BindAccumulator(value, &states);
 }
 
 
 void BytecodeGraphBuilder::VisitCallRuntimeForPair(
     const interpreter::BytecodeArrayIterator& iterator) {
-  UNIMPLEMENTED();
+  FrameStateBeforeAndAfter states(this, iterator);
+  Runtime::FunctionId functionId =
+      static_cast<Runtime::FunctionId>(iterator.GetIndexOperand(0));
+  interpreter::Register first_arg = iterator.GetRegisterOperand(1);
+  size_t arg_count = iterator.GetCountOperand(2);
+  interpreter::Register first_return = iterator.GetRegisterOperand(3);
+
+  // Create node to perform the runtime call.
+  const Operator* call = javascript()->CallRuntime(functionId, arg_count);
+  Node* return_pair = ProcessCallRuntimeArguments(call, first_arg, arg_count);
+  environment()->BindRegistersToProjections(first_return, return_pair, 2,
+                                            &states);
 }
 
 
 Node* BytecodeGraphBuilder::ProcessCallNewArguments(
     const Operator* call_new_op, interpreter::Register callee,
     interpreter::Register first_arg, size_t arity) {
   Node** all = info()->zone()->NewArray<Node*>(arity);
   all[0] = environment()->LookupRegister(callee);
   int first_arg_index = first_arg.index();
   for (int i = 1; i < static_cast<int>(arity) - 1; ++i) {
@@ skipping 728 matching lines @@
 
 void BytecodeGraphBuilder::UpdateControlDependencyToLeaveFunction(Node* exit) {
   if (environment()->IsMarkedAsUnreachable()) return;
   environment()->MarkAsUnreachable();
   exit_controls_.push_back(exit);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8