[interpreter]: Changes to interpreter builtins for accumulator and register file registers.

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"
 
+using ::testing::_;
+
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 const interpreter::Bytecode kBytecodes[] = {
 #define DEFINE_BYTECODE(Name, ...) interpreter::Bytecode::k##Name,
     BYTECODE_LIST(DEFINE_BYTECODE)
 #undef DEFINE_BYTECODE
 };
 
@@ skipping 63 matching lines @@
     Matcher<Node*> code_target_matcher = m.IsLoad(
         kMachPtr, IsParameter(Linkage::kInterpreterDispatchTableParameter),
         IsWord32Shl(target_bytecode_matcher,
                     IsInt32Constant(kPointerSizeLog2)));
 
     EXPECT_EQ(CallDescriptor::kCallCodeObject, m.call_descriptor()->kind());
     EXPECT_TRUE(m.call_descriptor()->flags() & CallDescriptor::kCanUseRoots);
     EXPECT_THAT(
         tail_call_node,
         IsTailCall(m.call_descriptor(), code_target_matcher,
+                   IsParameter(Linkage::kInterpreterAccumulatorParameter),
+                   IsParameter(Linkage::kInterpreterRegisterFileParameter),
                    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::kCallCodeObject, m.call_descriptor()->kind());
     EXPECT_TRUE(m.call_descriptor()->flags() & CallDescriptor::kCanUseRoots);
     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::kInterpreterAccumulatorParameter),
+                   IsParameter(Linkage::kInterpreterRegisterFileParameter),
                    IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
                    IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
                    IsParameter(Linkage::kInterpreterDispatchTableParameter),
                    graph->start(), graph->start()));
   }
 }
 
 
 TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     int number_of_operands = interpreter::Bytecodes::NumberOfOperands(bytecode);
     for (int i = 0; i < number_of_operands; i++) {
       Node* load_arg_node = m.BytecodeOperand(i);
       EXPECT_THAT(
           load_arg_node,
           m.IsLoad(
               kMachUint8,
               IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
               IsIntPtrAdd(
                   IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
                   IsInt32Constant(1 + i))));
     }
   }
 }
 
 
-TARGET_TEST_F(InterpreterAssemblerTest, LoadRegisterFixed) {
+TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperandSignExtended) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
-    for (int i = 0; i < m.kMaxRegisterIndex; i++) {
-      Node* load_reg_node = m.LoadRegister(i);
-      EXPECT_THAT(load_reg_node,
-                  m.IsLoad(kMachPtr, IsLoadFramePointer(),
-                           IsInt32Constant(m.kFirstRegisterOffsetFromFp -
-                                           (i << kPointerSizeLog2))));
+    int number_of_operands = interpreter::Bytecodes::NumberOfOperands(bytecode);
+    for (int i = 0; i < number_of_operands; i++) {
+      Node* load_arg_node = m.BytecodeOperandSignExtended(i);
+      Matcher<Node*> load_matcher = m.IsLoad(
+          kMachInt8, IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+          IsIntPtrAdd(IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
+                      IsInt32Constant(1 + i)));
+      if (kPointerSize == 8) {
+        load_matcher = IsChangeInt32ToInt64(load_matcher);
+      }
+      EXPECT_THAT(load_arg_node, load_matcher);
     }
   }
 }
 
 
+TARGET_TEST_F(InterpreterAssemblerTest, GetSetAccumulator) {
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    // Should be incoming accumulator if not set.
+    EXPECT_THAT(m.GetAccumulator(),
+                IsParameter(Linkage::kInterpreterAccumulatorParameter));
+
+    // Should be set by SedtAccumulator.
+    Node* accumulator_value_1 = m.Int32Constant(0xdeadbeef);
+    m.SetAccumulator(accumulator_value_1);
+    EXPECT_THAT(m.GetAccumulator(), accumulator_value_1);
+    Node* accumulator_value_2 = m.Int32Constant(42);
+    m.SetAccumulator(accumulator_value_2);
+    EXPECT_THAT(m.GetAccumulator(), accumulator_value_2);
+
+    // Should be passed to next bytecode handler on dispatch.
+    m.Dispatch();
+    Graph* graph = m.GetCompletedGraph();
+
+    Node* end = graph->end();
+    EXPECT_EQ(1, end->InputCount());
+    Node* tail_call_node = end->InputAt(0);
+
+    EXPECT_THAT(tail_call_node,
+                IsTailCall(m.call_descriptor(), _, accumulator_value_2, _, _, _,
+                           _, graph->start(), graph->start()));
+  }
+}
+
+
 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(),
-                 IsIntPtrSub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
-                             IsWordShl(reg_index_node,
-                                       IsInt32Constant(kPointerSizeLog2)))));
+        m.IsLoad(kMachPtr,
+                 IsParameter(Linkage::kInterpreterRegisterFileParameter),
+                 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);
-      EXPECT_THAT(store_reg_node,
-                  m.IsStore(StoreRepresentation(kMachPtr, kNoWriteBarrier),
-                            IsLoadFramePointer(),
-                            IsInt32Constant(m.kFirstRegisterOffsetFromFp -
-                                            (i << kPointerSizeLog2)),
-                            store_value));
-    }
-  }
-}
-
 
 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(),
-                  IsIntPtrSub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
-                              IsWordShl(reg_index_node,
-                                        IsInt32Constant(kPointerSizeLog2))),
+                  IsParameter(Linkage::kInterpreterRegisterFileParameter),
+                  IsWordShl(reg_index_node, IsInt32Constant(kPointerSizeLog2)),
                   store_value));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8