[Interpreter] Add CallRuntime support to the interpreter.

test/unittests/compiler/interpreter-assembler-unittest.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 "test/unittests/compiler/interpreter-assembler-unittest.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/node.h"
 #include "src/interface-descriptors.h"
@@ skipping 443 matching lines @@
     Node* object = m.IntPtrConstant(0xdeadbeef);
     int offset = 16;
     Node* load_field = m.LoadObjectField(object, offset);
     EXPECT_THAT(load_field,
                 m.IsLoad(kMachAnyTagged, object,
                          IsIntPtrConstant(offset - kHeapObjectTag)));
   }
 }
 
 
-TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime) {
+TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime2) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     Node* arg1 = m.Int32Constant(2);
     Node* arg2 = m.Int32Constant(3);
     Node* call_runtime = m.CallRuntime(Runtime::kAdd, arg1, arg2);
     EXPECT_THAT(call_runtime,
                 m.IsCall(_, _, arg1, arg2, _, IsInt32Constant(2),
                          IsParameter(Linkage::kInterpreterContextParameter)));
   }
 }
 
 
+TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime) {
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    Callable builtin = CodeFactory::InterpreterCEntry(isolate());
+    Node* function_id = m.Int32Constant(0);
+    Node* first_arg = m.Int32Constant(1);
+    Node* arg_count = m.Int32Constant(2);
+    Node* call_runtime = m.CallRuntime(function_id, first_arg, arg_count);
+    EXPECT_THAT(call_runtime,
+                m.IsCall(_, IsHeapConstant(builtin.code()), arg_count,
+                         first_arg, function_id,
+                         IsParameter(Linkage::kInterpreterContextParameter)));
+  }
+}
+
+
 TARGET_TEST_F(InterpreterAssemblerTest, CallIC) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     LoadWithVectorDescriptor descriptor(isolate());
     Node* target = m.Int32Constant(1);
     Node* arg1 = m.Int32Constant(2);
     Node* arg2 = m.Int32Constant(3);
     Node* arg3 = m.Int32Constant(4);
     Node* arg4 = m.Int32Constant(5);
     Node* call_ic = m.CallIC(descriptor, target, arg1, arg2, arg3, arg4);
     EXPECT_THAT(call_ic,
                 m.IsCall(_, target, arg1, arg2, arg3, arg4,
                          IsParameter(Linkage::kInterpreterContextParameter)));
   }
 }
 
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallJS) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
-    Callable builtin = CodeFactory::PushArgsAndCall(isolate());
+    Callable builtin = CodeFactory::InterpreterPushArgsAndCall(isolate());
     Node* function = m.Int32Constant(0);
     Node* first_arg = m.Int32Constant(1);
     Node* arg_count = m.Int32Constant(2);
     Node* call_js = m.CallJS(function, first_arg, arg_count);
     EXPECT_THAT(
         call_js,
         m.IsCall(_, IsHeapConstant(builtin.code()), arg_count, first_arg,
                  function, IsParameter(Linkage::kInterpreterContextParameter)));
   }
 }
@@ skipping 17 matching lines @@
         feedback_vector,
         m.IsLoad(kMachAnyTagged, load_shared_function_info_matcher,
                  IsIntPtrConstant(SharedFunctionInfo::kFeedbackVectorOffset -
                                   kHeapObjectTag)));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8