[interpreter] Add Interpreter{Entry,Exit}Trampoline builtins.

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/compiler/graph.h"
 #include "src/compiler/node.h"
+#include "src/unique.h"
 #include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/node-test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 const interpreter::Bytecode kBytecodes[] = {
 #define DEFINE_BYTECODE(Name, _) interpreter::Bytecode::k##Name,
     BYTECODE_LIST(DEFINE_BYTECODE)
@@ skipping 26 matching lines @@
 }
 
 
 Matcher<Node*> IsIntPtrAdd(const Matcher<Node*>& lhs_matcher,
                            const Matcher<Node*>& rhs_matcher) {
   return kPointerSize == 8 ? IsInt64Add(lhs_matcher, rhs_matcher)
                            : IsInt32Add(lhs_matcher, rhs_matcher);
 }
 
 
+Matcher<Node*> IsIntPtrSub(const Matcher<Node*>& lhs_matcher,
+                           const Matcher<Node*>& rhs_matcher) {
+  return kPointerSize == 8 ? IsInt64Sub(lhs_matcher, rhs_matcher)
+                           : IsInt32Sub(lhs_matcher, rhs_matcher);
+}
+
+
+Matcher<Node*> IsWordShl(const Matcher<Node*>& lhs_matcher,
+                         const Matcher<Node*>& rhs_matcher) {
+  return kPointerSize == 8 ? IsWord64Shl(lhs_matcher, rhs_matcher)
+                           : IsWord32Shl(lhs_matcher, rhs_matcher);
+}
+
+
 TARGET_TEST_F(InterpreterAssemblerTest, Dispatch) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     m.Dispatch();
     Graph* graph = m.GetCompletedGraph();
 
     Node* end = graph->end();
     EXPECT_EQ(1, end->InputCount());
     Node* tail_call_node = end->InputAt(0);
 
@@ skipping 14 matching lines @@
         tail_call_node,
         IsTailCall(m.call_descriptor(), code_target_matcher,
                    next_bytecode_offset_matcher,
                    IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
                    IsParameter(Linkage::kInterpreterDispatchTableParameter),
                    graph->start(), graph->start()));
   }
 }
 
 
+TARGET_TEST_F(InterpreterAssemblerTest, Return) {
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    m.Return();
+    Graph* graph = m.GetCompletedGraph();
+
+    Node* end = graph->end();
+    EXPECT_EQ(1, end->InputCount());
+    Node* tail_call_node = end->InputAt(0);
+
+    EXPECT_EQ(CallDescriptor::kInterpreterDispatch,
+              m.call_descriptor()->kind());
+    Matcher<Unique<HeapObject>> exit_trampoline(
+        Unique<HeapObject>::CreateImmovable(
+            isolate()->builtins()->InterpreterExitTrampoline()));
+    EXPECT_THAT(
+        tail_call_node,
+        IsTailCall(m.call_descriptor(), IsHeapConstant(exit_trampoline),
+                   IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
+                   IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+                   IsParameter(Linkage::kInterpreterDispatchTableParameter),
+                   graph->start(), graph->start()));
+  }
+}
+
+
 TARGET_TEST_F(InterpreterAssemblerTest, BytecodeArg) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     int number_of_args = interpreter::Bytecodes::NumberOfArguments(bytecode);
     for (int i = 0; i < number_of_args; i++) {
       Node* load_arg_node = m.BytecodeArg(i);
       EXPECT_THAT(
           load_arg_node,
           m.IsLoad(
               kMachUint8,
@@ skipping 21 matching lines @@
 
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadRegister) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     Node* reg_index_node = m.Int32Constant(44);
     Node* load_reg_node = m.LoadRegister(reg_index_node);
     EXPECT_THAT(
         load_reg_node,
         m.IsLoad(kMachPtr, IsLoadFramePointer(),
-                 IsInt32Sub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
-                            IsWord32Shl(reg_index_node,
-                                        IsInt32Constant(kPointerSizeLog2)))));
+                 IsIntPtrSub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
+                             IsWordShl(reg_index_node,
+                                       IsInt32Constant(kPointerSizeLog2)))));
   }
 }
 
 
 TARGET_TEST_F(InterpreterAssemblerTest, StoreRegisterFixed) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     Node* store_value = m.Int32Constant(0xdeadbeef);
     for (int i = 0; i < m.kMaxRegisterIndex; i++) {
       Node* store_reg_node = m.StoreRegister(store_value, i);
@@ skipping 11 matching lines @@
 TARGET_TEST_F(InterpreterAssemblerTest, StoreRegister) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     Node* store_value = m.Int32Constant(0xdeadbeef);
     Node* reg_index_node = m.Int32Constant(44);
     Node* store_reg_node = m.StoreRegister(store_value, reg_index_node);
     EXPECT_THAT(
         store_reg_node,
         m.IsStore(StoreRepresentation(kMachPtr, kNoWriteBarrier),
                   IsLoadFramePointer(),
-                  IsInt32Sub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
-                             IsWord32Shl(reg_index_node,
-                                         IsInt32Constant(kPointerSizeLog2))),
+                  IsIntPtrSub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
+                              IsWordShl(reg_index_node,
+                                        IsInt32Constant(kPointerSizeLog2))),
                   store_value));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8