[Interpreter] Maintain a pointer to the current position in the bytecode

test/unittests/interpreter/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/interpreter/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 75 matching lines @@
     const Matcher<Node*>& value_matcher) {
   return ::i::compiler::IsStore(rep_matcher, base_matcher, index_matcher,
                                 value_matcher, _, _);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsUnsignedByteOperand(
     int offset) {
   return IsLoad(
       MachineType::Uint8(),
-      IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
       IsIntPtrAdd(
-          IsParameter(InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-          IsIntPtrConstant(offset)));
+          IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
+          IsParameter(InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+      IsIntPtrConstant(offset));
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedByteOperand(
     int offset) {
   Matcher<Node*> load_matcher = IsLoad(
       MachineType::Int8(),
-      IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
       IsIntPtrAdd(
-          IsParameter(InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-          IsIntPtrConstant(offset)));
+          IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
+          IsParameter(InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+      IsIntPtrConstant(offset));
   if (kPointerSize == 8) {
     load_matcher = IsChangeInt32ToInt64(load_matcher);
   }
   return load_matcher;
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsUnsignedShortOperand(
     int offset) {
   if (TargetSupportsUnalignedAccess()) {
     return IsLoad(
         MachineType::Uint16(),
-        IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
         IsIntPtrAdd(
+            IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
             IsParameter(
-                InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-            IsIntPtrConstant(offset)));
+                InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+        IsIntPtrConstant(offset));
   } else {
 #if V8_TARGET_LITTLE_ENDIAN
     const int kStep = -1;
     const int kMsbOffset = 1;
 #elif V8_TARGET_BIG_ENDIAN
     const int kStep = 1;
     const int kMsbOffset = 0;
 #else
 #error "Unknown Architecture"
 #endif
     Matcher<Node*> bytes[2];
     for (int i = 0; i < static_cast<int>(arraysize(bytes)); i++) {
       bytes[i] = IsLoad(
           MachineType::Uint8(),
-          IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
           IsIntPtrAdd(
               IsParameter(
-                  InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-              IsIntPtrConstant(offset + kMsbOffset + kStep * i)));
+                  InterpreterDispatchDescriptor::kBytecodeArrayParameter),
+              IsParameter(
+                  InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+          IsIntPtrConstant(offset + kMsbOffset + kStep * i));
     }
     return IsWord32Or(IsWord32Shl(bytes[0], IsInt32Constant(kBitsPerByte)),
                       bytes[1]);
   }
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedShortOperand(
     int offset) {
   Matcher<Node*> load_matcher;
   if (TargetSupportsUnalignedAccess()) {
     load_matcher = IsLoad(
         MachineType::Int16(),
-        IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
         IsIntPtrAdd(
+            IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
             IsParameter(
-                InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-            IsIntPtrConstant(offset)));
+                InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+        IsIntPtrConstant(offset));
   } else {
 #if V8_TARGET_LITTLE_ENDIAN
     const int kStep = -1;
     const int kMsbOffset = 1;
 #elif V8_TARGET_BIG_ENDIAN
     const int kStep = 1;
     const int kMsbOffset = 0;
 #else
 #error "Unknown Architecture"
 #endif
@@ skipping 16 matching lines @@
   }
   return load_matcher;
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsUnsignedQuadOperand(
     int offset) {
   if (TargetSupportsUnalignedAccess()) {
     return IsLoad(
         MachineType::Uint32(),
-        IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
         IsIntPtrAdd(
+            IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
             IsParameter(
-                InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-            IsIntPtrConstant(offset)));
+                InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+        IsIntPtrConstant(offset));
   } else {
 #if V8_TARGET_LITTLE_ENDIAN
     const int kStep = -1;
     const int kMsbOffset = 3;
 #elif V8_TARGET_BIG_ENDIAN
     const int kStep = 1;
     const int kMsbOffset = 0;
 #else
 #error "Unknown Architecture"
 #endif
@@ skipping 16 matching lines @@
   }
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedQuadOperand(
     int offset) {
   Matcher<Node*> load_matcher;
   if (TargetSupportsUnalignedAccess()) {
     load_matcher = IsLoad(
         MachineType::Int32(),
-        IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
         IsIntPtrAdd(
+            IsParameter(InterpreterDispatchDescriptor::kBytecodeArrayParameter),
             IsParameter(
-                InterpreterDispatchDescriptor::kBytecodeOffsetParameter),
-            IsIntPtrConstant(offset)));
+                InterpreterDispatchDescriptor::kBytecodeOffsetParameter)),
+        IsIntPtrConstant(offset));
   } else {
 #if V8_TARGET_LITTLE_ENDIAN
     const int kStep = -1;
     int kMsbOffset = 3;
 #elif V8_TARGET_BIG_ENDIAN
     const int kStep = 1;
     int kMsbOffset = 0;
 #else
 #error "Unknown Architecture"
 #endif
@@ skipping 446 matching lines @@
     EXPECT_THAT(feedback_vector,
                 m.IsLoad(MachineType::AnyTagged(), load_literals_matcher,
                          IsIntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
                                           kHeapObjectTag)));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8