[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 332 matching lines @@
           break;
         case interpreter::OperandType::kIdx8:
           EXPECT_THAT(m.BytecodeOperandIdx(i), m.IsBytecodeOperand(offset));
           break;
         case interpreter::OperandType::kImm8:
           EXPECT_THAT(m.BytecodeOperandImm(i),
                       m.IsBytecodeOperandSignExtended(offset));
           break;
         case interpreter::OperandType::kMaybeReg8:
         case interpreter::OperandType::kReg8:
+        case interpreter::OperandType::kRegPair8:
           EXPECT_THAT(m.BytecodeOperandReg(i),
                       m.IsBytecodeOperandSignExtended(offset));
           break;
         case interpreter::OperandType::kCount16:
           EXPECT_THAT(m.BytecodeOperandCount(i),
                       m.IsBytecodeOperandShort(offset));
           break;
         case interpreter::OperandType::kIdx16:
           EXPECT_THAT(m.BytecodeOperandIdx(i),
                       m.IsBytecodeOperandShort(offset));
@@ skipping 222 matching lines @@
     Node* call_runtime = m.CallRuntime(Runtime::kAdd, arg1, arg2);
     EXPECT_THAT(
         call_runtime,
         IsCall(_, _, arg1, arg2, _, IsInt32Constant(2),
                IsParameter(Linkage::kInterpreterContextParameter), _, _));
   }
 }
 
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime) {
+  const int kResultSizes[] = {1, 2};
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
-    Callable builtin = CodeFactory::InterpreterCEntry(isolate());
+    TRACED_FOREACH(int, result_size, kResultSizes) {
+      InterpreterAssemblerForTest m(this, bytecode);
+      Callable builtin = CodeFactory::InterpreterCEntry(isolate(), result_size);
 
-    Node* function_id = m.Int32Constant(0);
-    Node* first_arg = m.Int32Constant(1);
-    Node* arg_count = m.Int32Constant(2);
+      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)));
+      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), _, _));
+      Node* call_runtime =
+          m.CallRuntime(function_id, first_arg, arg_count, result_size);
+      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);
@@ skipping 45 matching lines @@
         feedback_vector,
         m.IsLoad(MachineType::AnyTagged(), load_shared_function_info_matcher,
                  IsIntPtrConstant(SharedFunctionInfo::kFeedbackVectorOffset -
                                   kHeapObjectTag)));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8