[Interpreter] Make ForInPrepare take a kRegTriple8 and ForInNext take kRegPair8 for cache state

src/interpreter/bytecode-array-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/interpreter/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 956 matching lines @@
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Return() {
   Output(Bytecode::kReturn);
   exit_seen_in_block_ = true;
   return *this;
 }
 
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::ForInPrepare(
-    Register cache_type, Register cache_array, Register cache_length) {
-  Output(Bytecode::kForInPrepare, cache_type.ToOperand(),
-         cache_array.ToOperand(), cache_length.ToOperand());
+BytecodeArrayBuilder& BytecodeArrayBuilder::ForInPrepare(Register first_reg) {

[oth, 2016/01/13 15:28:58]

Nit, argument name generic, s/first_reg/cache_info_triple/ 

[rmcilroy, 2016/01/18 09:40:49]

Done.

+  Output(Bytecode::kForInPrepare, first_reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInDone(Register index,
                                                       Register cache_length) {
   Output(Bytecode::kForInDone, index.ToOperand(), cache_length.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInNext(Register receiver,
-                                                      Register cache_type,
-                                                      Register cache_array,
-                                                      Register index) {
-  Output(Bytecode::kForInNext, receiver.ToOperand(), cache_type.ToOperand(),
-         cache_array.ToOperand(), index.ToOperand());
+                                                      Register index,
+                                                      Register cache_reg_pair) {
+  Output(Bytecode::kForInNext, receiver.ToOperand(), index.ToOperand(),
+         cache_reg_pair.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInStep(Register index) {
   Output(Bytecode::kForInStep, index.ToOperand());
   return *this;
 }
 
 
@@ skipping 241 matching lines @@
     // Fall-through to kReg8 case.
     case OperandType::kReg8:
       return RegisterIsValid(
           Register::FromOperand(static_cast<uint8_t>(operand_value)));
     case OperandType::kRegPair8: {
       Register reg0 =
           Register::FromOperand(static_cast<uint8_t>(operand_value));
       Register reg1 = Register(reg0.index() + 1);
       return RegisterIsValid(reg0) && RegisterIsValid(reg1);
     }
+    case OperandType::kRegTriple8: {
+      Register reg0 =
+          Register::FromOperand(static_cast<uint8_t>(operand_value));
+      Register reg1 = Register(reg0.index() + 1);
+      Register reg2 = Register(reg0.index() + 2);
+      return RegisterIsValid(reg0) && RegisterIsValid(reg1) &&
+             RegisterIsValid(reg2);
+    }
     case OperandType::kReg16:
       if (bytecode != Bytecode::kExchange &&
           bytecode != Bytecode::kExchangeWide) {
         return false;
       }
       return RegisterIsValid(
           Register::FromWideOperand(static_cast<uint16_t>(operand_value)));
   }
   UNREACHABLE();
   return false;
@@ skipping 394 matching lines @@
   DCHECK_GT(next_consecutive_count_, 0);
   builder_->BorrowConsecutiveTemporaryRegister(next_consecutive_register_);
   allocated_.push_back(next_consecutive_register_);
   next_consecutive_count_--;
   return Register(next_consecutive_register_++);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8