[interpreter] Change interpreter to use an BytecodeArray pointer and and offset.

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 "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/node-test-utils.h"
@@ skipping 34 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*> IsIntPtrConstant(intptr_t value) {
-#ifdef V8_TARGET_ARCH_64_BIT
-  return IsInt64Constant(value);
-#else
-  return IsInt32Constant(value);
-#endif
-}
-
-
 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);
 
-    Matcher<Node*> next_bytecode_matcher =
-        IsIntPtrAdd(IsParameter(Linkage::kInterpreterBytecodeParameter),
+    Matcher<Node*> next_bytecode_offset_matcher =
+        IsIntPtrAdd(IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
                     IsInt32Constant(interpreter::Bytecodes::Size(bytecode)));
-    Matcher<Node*> target_bytecode_matcher =
-        m.IsLoad(kMachUint8, next_bytecode_matcher, IsIntPtrConstant(0));
+    Matcher<Node*> target_bytecode_matcher = m.IsLoad(
+        kMachUint8, IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+        next_bytecode_offset_matcher);
     Matcher<Node*> code_target_matcher = m.IsLoad(
         kMachPtr, IsParameter(Linkage::kInterpreterDispatchTableParameter),
         IsWord32Shl(target_bytecode_matcher,
                     IsInt32Constant(kPointerSizeLog2)));
 
     EXPECT_EQ(CallDescriptor::kInterpreterDispatch,
               m.call_descriptor()->kind());
     EXPECT_THAT(
         tail_call_node,
         IsTailCall(m.call_descriptor(), code_target_matcher,
-                   next_bytecode_matcher,
+                   next_bytecode_offset_matcher,
+                   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,
-                           IsParameter(Linkage::kInterpreterBytecodeParameter),
-                           IsInt32Constant(1 + i)));
+      EXPECT_THAT(
+          load_arg_node,
+          m.IsLoad(
+              kMachUint8,
+              IsParameter(Linkage::kInterpreterBytecodeArrayParameter),
+              IsIntPtrAdd(
+                  IsParameter(Linkage::kInterpreterBytecodeOffsetParameter),
+                  IsInt32Constant(1 + i))));
     }
   }
 }
 
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadRegisterFixed) {
   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);
@@ skipping 51 matching lines @@
                   IsInt32Sub(IsInt32Constant(m.kFirstRegisterOffsetFromFp),
                              IsWord32Shl(reg_index_node,
                                          IsInt32Constant(kPointerSizeLog2))),
                   store_value));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8