[Interpreter] Add support for parameter variables.

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 {
 
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate)
     : isolate_(isolate),
       bytecode_generated_(false),
+      parameter_count_(-1),
       local_register_count_(-1),
       temporary_register_count_(0),
       temporary_register_next_(0) {}
 
 
 void BytecodeArrayBuilder::set_locals_count(int number_of_locals) {
   local_register_count_ = number_of_locals;
   temporary_register_next_ = local_register_count_;
 }
 
 
 int BytecodeArrayBuilder::locals_count() const { return local_register_count_; }
 
 
+void BytecodeArrayBuilder::set_parameter_count(int number_of_parameters) {
+  parameter_count_ = number_of_parameters;
+}
+
+
+int BytecodeArrayBuilder::parameter_count() const { return parameter_count_; }
+
+
+Register BytecodeArrayBuilder::Parameter(int param_index) {
+  DCHECK_GE(param_index, 0);
+  DCHECK_LT(param_index, parameter_count_);
+  return Register(kLastParamRegisterIndex - parameter_count_ + param_index + 1);
+}
+
+
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK_EQ(bytecode_generated_, false);
+  DCHECK_GE(parameter_count_, 0);
   DCHECK_GE(local_register_count_, 0);
   int bytecode_size = static_cast<int>(bytecodes_.size());
   int register_count = local_register_count_ + temporary_register_count_;
   int frame_size = register_count * kPointerSize;
   Handle<BytecodeArray> output = isolate_->factory()->NewBytecodeArray(
-      bytecode_size, &bytecodes_.front(), frame_size);
+      bytecode_size, &bytecodes_.front(), frame_size, parameter_count_);
   bytecode_generated_ = true;
   return output;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value binop,
                                                             Register reg) {
   Output(BytecodeForBinaryOperation(binop), reg.ToOperand());
   return *this;
 }
@@ skipping 82 matching lines @@
 
 
 bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
                                           uint8_t operand_value) const {
   OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
   switch (operand_type) {
     case OperandType::kNone:
       return false;
     case OperandType::kImm8:
       return true;
-    case OperandType::kReg:
-      return Register::FromOperand(operand_value).index() <
-             temporary_register_next_;
+    case OperandType::kReg: {
+      int reg_index = Register::FromOperand(operand_value).index();
+      return (reg_index >= 0 && reg_index < temporary_register_next_) ||
+             (reg_index <= kLastParamRegisterIndex &&
+              reg_index > kLastParamRegisterIndex - parameter_count_);
+    }
   }
   UNREACHABLE();
   return false;
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint8_t operand0,
                                   uint8_t operand1, uint8_t operand2) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 3);
   DCHECK(OperandIsValid(bytecode, 0, operand0) &&
@@ skipping 64 matching lines @@
 
 Register TemporaryRegisterScope::NewRegister() {
   count_++;
   last_register_index_ = builder_->BorrowTemporaryRegister();
   return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8