[Interpreter] Add support for JS runtime calls.

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 91 matching lines @@
 
   Handle<BytecodeArray> output =
       factory->NewBytecodeArray(bytecode_size, &bytecodes_.front(), frame_size,
                                 parameter_count(), constant_pool);
   bytecode_generated_ = true;
   return output;
 }
 
 
 template <size_t N>
-void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t(&operands)[N]) {
+void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t(&operands)[N],
+                                  RegisterValidityCheck reg_check) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), static_cast<int>(N));
   last_bytecode_start_ = bytecodes()->size();
   bytecodes()->push_back(Bytecodes::ToByte(bytecode));
   for (int i = 0; i < static_cast<int>(N); i++) {
-    DCHECK(OperandIsValid(bytecode, i, operands[i]));
+    DCHECK(OperandIsValid(bytecode, i, operands[i], reg_check));
     switch (Bytecodes::GetOperandSize(bytecode, i)) {
       case OperandSize::kNone:
         UNREACHABLE();
       case OperandSize::kByte:
         bytecodes()->push_back(static_cast<uint8_t>(operands[i]));
         break;
       case OperandSize::kShort: {
         uint8_t operand_bytes[2];
         Bytecodes::ShortOperandToBytes(operands[i], operand_bytes);
         bytecodes()->insert(bytecodes()->end(), operand_bytes,
                             operand_bytes + 2);
         break;
       }
     }
   }
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t operand0,
-                                  uint32_t operand1, uint32_t operand2) {
+                                  uint32_t operand1, uint32_t operand2,
+                                  RegisterValidityCheck reg_check) {
   uint32_t operands[] = {operand0, operand1, operand2};
-  Output(bytecode, operands);
+  Output(bytecode, operands, reg_check);
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t operand0,
-                                  uint32_t operand1) {
+                                  uint32_t operand1,
+                                  RegisterValidityCheck reg_check) {
   uint32_t operands[] = {operand0, operand1};
-  Output(bytecode, operands);
+  Output(bytecode, operands, reg_check);
 }
 
 
-void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t operand0) {
+void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t operand0,
+                                  RegisterValidityCheck reg_check) {
   uint32_t operands[] = {operand0};
-  Output(bytecode, operands);
+  Output(bytecode, operands, reg_check);
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 0);
   last_bytecode_start_ = bytecodes()->size();
   bytecodes()->push_back(Bytecodes::ToByte(bytecode));
 }
 
 
@@ skipping 601 matching lines @@
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::New(Register constructor,
                                                 Register first_arg,
                                                 size_t arg_count) {
+  RegisterValidityCheck reg_check = RegisterValidityCheck::kCheckRegisters;
+  if (arg_count == 0) {
+    first_arg = Register(0);
+    reg_check = RegisterValidityCheck::kDontCheckRegisters;
+  }
   DCHECK(FitsInIdx8Operand(arg_count));
   Output(Bytecode::kNew, constructor.ToOperand(), first_arg.ToOperand(),
-         static_cast<uint8_t>(arg_count));
+         static_cast<uint8_t>(arg_count), reg_check);
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntime(
     Runtime::FunctionId function_id, Register first_arg, size_t arg_count) {
   DCHECK(FitsInIdx16Operand(function_id));
   DCHECK(FitsInIdx8Operand(arg_count));
+  RegisterValidityCheck reg_check = RegisterValidityCheck::kCheckRegisters;
+  if (arg_count == 0) {
+    first_arg = Register(0);
+    reg_check = RegisterValidityCheck::kDontCheckRegisters;
+  }
   Output(Bytecode::kCallRuntime, static_cast<uint16_t>(function_id),
-         first_arg.ToOperand(), static_cast<uint8_t>(arg_count));
+         first_arg.ToOperand(), static_cast<uint8_t>(arg_count), reg_check);
   return *this;
 }
 
+
+BytecodeArrayBuilder& BytecodeArrayBuilder::CallJSRuntime(int context_index,
+                                                          Register receiver,
+                                                          size_t arg_count) {
+  DCHECK(FitsInIdx16Operand(context_index));
+  DCHECK(FitsInIdx8Operand(arg_count));
+  Output(Bytecode::kCallJSRuntime, static_cast<uint16_t>(context_index),
+         receiver.ToOperand(), static_cast<uint8_t>(arg_count));
+  return *this;
+}
+
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Delete(Register object,
                                                    LanguageMode language_mode) {
   Output(BytecodeForDelete(language_mode), object.ToOperand());
   return *this;
 }
 
 
 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) {
   // These constants shouldn't be added to the constant pool, the should use
@@ skipping 80 matching lines @@
   if (temporary_register_count_ > 0) {
     DCHECK(reg.index() >= first_temporary_register().index() &&
            reg.index() <= last_temporary_register().index());
     return free_temporaries_.find(reg.index()) == free_temporaries_.end();
   } else {
     return false;
   }
 }
 
 
-bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
-                                          uint32_t operand_value) const {
+bool BytecodeArrayBuilder::OperandIsValid(
+    Bytecode bytecode, int operand_index, uint32_t operand_value,
+    RegisterValidityCheck reg_check) const {
   OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
   switch (operand_type) {
     case OperandType::kNone:
       return false;
     case OperandType::kIdx16:
       return static_cast<uint16_t>(operand_value) == operand_value;
     case OperandType::kCount8:
     case OperandType::kImm8:
     case OperandType::kIdx8:
       return static_cast<uint8_t>(operand_value) == operand_value;
     case OperandType::kReg8: {
       Register reg = Register::FromOperand(static_cast<uint8_t>(operand_value));
-      if (reg.is_function_context() || reg.is_function_closure()) {
+      if (reg_check == RegisterValidityCheck::kDontCheckRegisters) {
+        return true;
+      } else if (reg.is_function_context() || reg.is_function_closure()) {
         return true;
       } else if (reg.is_parameter()) {
         int parameter_index = reg.ToParameterIndex(parameter_count_);
         return parameter_index >= 0 && parameter_index < parameter_count_;
       } else if (reg.index() < fixed_register_count()) {
         return true;
       } else {
         return TemporaryRegisterIsLive(reg);
       }
     }
@@ skipping 324 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