[Interpreter] Add CallRuntime support to the interpreter.

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 143 matching lines @@
     Output(Bytecode::kLdaSmi8, static_cast<uint8_t>(raw_smi));
   } else {
     LoadLiteral(Handle<Object>(smi, isolate_));
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(Handle<Object> object) {
   size_t entry = GetConstantPoolEntry(object);
-  if (FitsInIdxOperand(entry)) {
+  if (FitsInIdx8Operand(entry)) {
     Output(Bytecode::kLdaConstant, static_cast<uint8_t>(entry));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadUndefined() {
   Output(Bytecode::kLdaUndefined);
@@ skipping 34 matching lines @@
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister(
     Register reg) {
   Output(Bytecode::kStar, reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(int slot_index) {
   DCHECK(slot_index >= 0);
-  if (FitsInIdxOperand(slot_index)) {
+  if (FitsInIdx8Operand(slot_index)) {
     Output(Bytecode::kLdaGlobal, static_cast<uint8_t>(slot_index));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(
     Register object, int feedback_slot, LanguageMode language_mode) {
   if (!is_sloppy(language_mode)) {
     UNIMPLEMENTED();
   }
 
-  if (FitsInIdxOperand(feedback_slot)) {
+  if (FitsInIdx8Operand(feedback_slot)) {
     Output(Bytecode::kLoadIC, object.ToOperand(),
            static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty(
     Register object, int feedback_slot, LanguageMode language_mode) {
   if (!is_sloppy(language_mode)) {
     UNIMPLEMENTED();
   }
 
-  if (FitsInIdxOperand(feedback_slot)) {
+  if (FitsInIdx8Operand(feedback_slot)) {
     Output(Bytecode::kKeyedLoadIC, object.ToOperand(),
            static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(
     Register object, Register name, int feedback_slot,
     LanguageMode language_mode) {
   if (!is_sloppy(language_mode)) {
     UNIMPLEMENTED();
   }
 
-  if (FitsInIdxOperand(feedback_slot)) {
+  if (FitsInIdx8Operand(feedback_slot)) {
     Output(Bytecode::kStoreIC, object.ToOperand(), name.ToOperand(),
            static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty(
     Register object, Register key, int feedback_slot,
     LanguageMode language_mode) {
   if (!is_sloppy(language_mode)) {
     UNIMPLEMENTED();
   }
 
-  if (FitsInIdxOperand(feedback_slot)) {
+  if (FitsInIdx8Operand(feedback_slot)) {
     Output(Bytecode::kKeyedStoreIC, object.ToOperand(), key.ToOperand(),
            static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToBoolean() {
@@ skipping 75 matching lines @@
   DCHECK_EQ(Bytecodes::Size(jump_bytecode), 2);
   DCHECK_NE(delta, 0);
 
   if (FitsInImm8Operand(delta)) {
     // Just update the operand
     jump_location++;
     *jump_location = static_cast<uint8_t>(delta);
   } else {
     // Update the jump type and operand
     size_t entry = GetConstantPoolEntry(handle(Smi::FromInt(delta), isolate()));
-    if (FitsInIdxOperand(entry)) {
+    if (FitsInIdx8Operand(entry)) {
       jump_bytecode = GetJumpWithConstantOperand(jump_bytecode);
       *jump_location++ = Bytecodes::ToByte(jump_bytecode);
       *jump_location = static_cast<uint8_t>(entry);
     } else {
       // TODO(oth): OutputJump should reserve a constant pool entry
       // when jump is written. The reservation should be used here if
       // needed, or cancelled if not. This is due to the patch needing
       // to match the size of the code it's replacing. In future,
       // there will probably be a jump with 32-bit operand for cases
       // when constant pool is full, but that needs to be emitted in
@@ skipping 17 matching lines @@
     // Label has not yet been bound so this is a forward reference
     // that will be patched when the label is bound.
     label->set_referrer(bytecodes()->size());
     delta = 0;
   }
 
   if (FitsInImm8Operand(delta)) {
     Output(jump_bytecode, static_cast<uint8_t>(delta));
   } else {
     size_t entry = GetConstantPoolEntry(handle(Smi::FromInt(delta), isolate()));
-    if (FitsInIdxOperand(entry)) {
+    if (FitsInIdx8Operand(entry)) {
       Output(GetJumpWithConstantOperand(jump_bytecode),
              static_cast<uint8_t>(entry));
     } else {
       UNIMPLEMENTED();
     }
   }
   return *this;
 }
 
 
@@ skipping 32 matching lines @@
 void BytecodeArrayBuilder::EnsureReturn() {
   if (!return_seen_in_block_) {
     LoadUndefined();
     Return();
   }
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable,
                                                  Register receiver,
                                                  size_t arg_count) {
-  if (FitsInIdxOperand(arg_count)) {
+  if (FitsInIdx8Operand(arg_count)) {
     Output(Bytecode::kCall, callable.ToOperand(), receiver.ToOperand(),
            static_cast<uint8_t>(arg_count));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntime(
+    Runtime::FunctionId function_id, Register first_arg, size_t arg_count) {
+  DCHECK(FitsInIdx16Operand(function_id));
+  DCHECK(FitsInIdx8Operand(arg_count));
+  Output(Bytecode::kCallRuntime, static_cast<uint16_t>(function_id),
+         first_arg.ToOperand(), static_cast<uint8_t>(arg_count));
+  return *this;
+}
+
+
 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) {
   // These constants shouldn't be added to the constant pool, the should use
   // specialzed bytecodes instead.
   DCHECK(!object.is_identical_to(isolate_->factory()->undefined_value()));
   DCHECK(!object.is_identical_to(isolate_->factory()->null_value()));
   DCHECK(!object.is_identical_to(isolate_->factory()->the_hole_value()));
   DCHECK(!object.is_identical_to(isolate_->factory()->true_value()));
   DCHECK(!object.is_identical_to(isolate_->factory()->false_value()));
 
   size_t* entry = constants_map_.Find(object);
@@ skipping 100 matching lines @@
     case Token::Value::IN:
       return Bytecode::kTestIn;
     default:
       UNREACHABLE();
       return static_cast<Bytecode>(-1);
   }
 }
 
 
 // static
-bool BytecodeArrayBuilder::FitsInIdxOperand(int value) {
+bool BytecodeArrayBuilder::FitsInIdx8Operand(int value) {
   return kMinUInt8 <= value && value <= kMaxUInt8;
 }
 
 
 // static
-bool BytecodeArrayBuilder::FitsInIdxOperand(size_t value) {
+bool BytecodeArrayBuilder::FitsInIdx8Operand(size_t value) {
   return value <= static_cast<size_t>(kMaxUInt8);
 }
 
 
 // static
 bool BytecodeArrayBuilder::FitsInImm8Operand(int value) {
   return kMinInt8 <= value && value < kMaxInt8;
 }
 
 
+// static
+bool BytecodeArrayBuilder::FitsInIdx16Operand(int value) {
+  return kMinUInt16 <= value && value <= kMaxUInt16;
+}
+
+
 TemporaryRegisterScope::TemporaryRegisterScope(BytecodeArrayBuilder* builder)
     : builder_(builder), count_(0), last_register_index_(-1) {}
 
 
 TemporaryRegisterScope::~TemporaryRegisterScope() {
   while (count_-- != 0) {
     builder_->ReturnTemporaryRegister(last_register_index_--);
   }
 }
 
 
 Register TemporaryRegisterScope::NewRegister() {
   count_++;
   last_register_index_ = builder_->BorrowTemporaryRegister();
   return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8