[Interpreter] Add support for JS 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 206 matching lines @@
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Return() {
   Output(Bytecode::kReturn);
   return *this;
 }
 
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable,
+                                                 Register receiver,
+                                                 size_t arg_count) {
+  if (FitsInByteOperand(arg_count)) {
+    Output(Bytecode::kCall, callable.ToOperand(), receiver.ToOperand(),
+           static_cast<uint8_t>(arg_count));
+  } else {
+    UNIMPLEMENTED();
+  }
+  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 23 matching lines @@
   temporary_register_next_ = reg_index;
 }
 
 
 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::kCount:
     case OperandType::kImm8:
     case OperandType::kIdx:
       return true;
     case OperandType::kReg: {
       Register reg = Register::FromOperand(operand_value);
       if (reg.is_parameter()) {
         int parameter_index = reg.ToParameterIndex(parameter_count_);
         return parameter_index >= 0 && parameter_index < parameter_count_;
       } else {
         return (reg.index() >= 0 && reg.index() < temporary_register_next_);
@@ skipping 88 matching lines @@
 
 Register TemporaryRegisterScope::NewRegister() {
   count_++;
   last_register_index_ = builder_->BorrowTemporaryRegister();
   return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8