[Interpreter] Add support for calling runtime functions which return a pair.

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 601 matching lines @@
     Node* call_runtime = m.CallRuntime(function_id, first_arg, arg_count);
     EXPECT_THAT(
         call_runtime,
         IsCall(_, IsHeapConstant(builtin.code()), arg_count, first_arg,
                function_entry,
                IsParameter(Linkage::kInterpreterContextParameter), _, _));
   }
 }
 
 
+TARGET_TEST_F(InterpreterAssemblerTest, CallRuntimePair) {
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    Callable builtin = CodeFactory::InterpreterCEntryPair(isolate());
+
+    Node* function_id = m.Int32Constant(0);
+    Node* first_arg = m.Int32Constant(1);
+    Node* arg_count = m.Int32Constant(2);
+
+    Matcher<Node*> function_table = IsExternalConstant(
+        ExternalReference::runtime_function_table_address(isolate()));
+    Matcher<Node*> function = IsIntPtrAdd(
+        function_table,
+        IsInt32Mul(function_id, IsInt32Constant(sizeof(Runtime::Function))));
+    Matcher<Node*> function_entry =
+        m.IsLoad(MachineType::Pointer(), function,
+                 IsInt32Constant(offsetof(Runtime::Function, entry)));
+
+    Node* call_runtime = m.CallRuntime(function_id, first_arg, arg_count);
+    EXPECT_THAT(
+        call_runtime,
+        IsCall(_, IsHeapConstant(builtin.code()), arg_count, first_arg,
+               function_entry,
+               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);
@@ skipping 41 matching lines @@
         feedback_vector,
         m.IsLoad(MachineType::AnyTagged(), load_shared_function_info_matcher,
                  IsIntPtrConstant(SharedFunctionInfo::kFeedbackVectorOffset -
                                   kHeapObjectTag)));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8