[interpreter][stubs] Fixing issues found by machine graph verifier.

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/node.h"
 #include "src/interface-descriptors.h"
 #include "src/isolate.h"
@@ skipping 33 matching lines @@
   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*> IsIntPtrMul(const Matcher<Node*>& lhs_matcher,
+                           const Matcher<Node*>& rhs_matcher) {
+  return kPointerSize == 8 ? IsInt64Mul(lhs_matcher, rhs_matcher)
+                           : IsInt32Mul(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);
 }
 
 Matcher<Node*> IsWordSar(const Matcher<Node*>& lhs_matcher,
                          const Matcher<Node*>& rhs_matcher) {
   return kPointerSize == 8 ? IsWord64Sar(lhs_matcher, rhs_matcher)
                            : IsWord32Sar(lhs_matcher, rhs_matcher);
 }
 
 Matcher<Node*> IsWordOr(const Matcher<Node*>& lhs_matcher,
                         const Matcher<Node*>& rhs_matcher) {
   return kPointerSize == 8 ? IsWord64Or(lhs_matcher, rhs_matcher)
                            : IsWord32Or(lhs_matcher, rhs_matcher);
 }
 
+Matcher<Node*> IsChangeInt32ToIntPtr(const Matcher<Node*>& matcher) {
+  return kPointerSize == 8 ? IsChangeInt32ToInt64(matcher) : matcher;
+}
+
+Matcher<Node*> IsChangeUint32ToWord(const Matcher<Node*>& matcher) {
+  return kPointerSize == 8 ? IsChangeUint32ToUint64(matcher) : matcher;
+}
+
+Matcher<Node*> IsTruncateWordToWord32(const Matcher<Node*>& matcher) {
+  return kPointerSize == 8 ? IsTruncateInt64ToInt32(matcher) : matcher;
+}
+
 InterpreterAssemblerTest::InterpreterAssemblerForTest::
     ~InterpreterAssemblerForTest() {
   // Tests don't necessarily read and write accumulator but
   // InterpreterAssembler checks accumulator uses.
   if (Bytecodes::ReadsAccumulator(bytecode())) {
     GetAccumulator();
   }
   if (Bytecodes::WritesAccumulator(bytecode())) {
     SetAccumulator(nullptr);
   }
 }
 
 Matcher<Node*> InterpreterAssemblerTest::InterpreterAssemblerForTest::IsLoad(
     const Matcher<LoadRepresentation>& rep_matcher,
     const Matcher<Node*>& base_matcher, const Matcher<Node*>& index_matcher) {
   return ::i::compiler::IsLoad(rep_matcher, base_matcher, index_matcher, _, _);
 }
 
 Matcher<Node*> InterpreterAssemblerTest::InterpreterAssemblerForTest::IsStore(
     const Matcher<StoreRepresentation>& rep_matcher,
     const Matcher<Node*>& base_matcher, const Matcher<Node*>& index_matcher,
     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(
+  Matcher<Node*> load_matcher = IsLoad(
       MachineType::Uint8(),
       IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
       IsIntPtrAdd(IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
                   IsIntPtrConstant(offset)));
+  return IsChangeUint32ToWord(load_matcher);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedByteOperand(
     int offset) {
   Matcher<Node*> load_matcher = IsLoad(
       MachineType::Int8(),
       IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
       IsIntPtrAdd(IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
                   IsIntPtrConstant(offset)));
-  if (kPointerSize == 8) {
-    load_matcher = IsChangeInt32ToInt64(load_matcher);
-  }
-  return load_matcher;
+  return IsChangeInt32ToIntPtr(load_matcher);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsUnsignedShortOperand(
     int offset) {
+  Matcher<Node*> load_matcher;
   if (TargetSupportsUnalignedAccess()) {
-    return IsLoad(
+    load_matcher = IsLoad(
         MachineType::Uint16(),
         IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
         IsIntPtrAdd(IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
                     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::kBytecodeArray),
           IsIntPtrAdd(
               IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
               IsIntPtrConstant(offset + kMsbOffset + kStep * i)));
     }
-    return IsWord32Or(IsWord32Shl(bytes[0], IsInt32Constant(kBitsPerByte)),
-                      bytes[1]);
+    load_matcher = IsWord32Or(
+        IsWord32Shl(bytes[0], IsInt32Constant(kBitsPerByte)), bytes[1]);
   }
+  return IsChangeUint32ToWord(load_matcher);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedShortOperand(
     int offset) {
   Matcher<Node*> load_matcher;
   if (TargetSupportsUnalignedAccess()) {
     load_matcher = IsLoad(
         MachineType::Int16(),
         IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
@@ skipping 14 matching lines @@
       bytes[i] = IsLoad(
           (i == 0) ? MachineType::Int8() : MachineType::Uint8(),
           IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
           IsIntPtrAdd(
               IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
               IsIntPtrConstant(offset + kMsbOffset + kStep * i)));
     }
     load_matcher = IsWord32Or(
         IsWord32Shl(bytes[0], IsInt32Constant(kBitsPerByte)), bytes[1]);
   }
-
-  if (kPointerSize == 8) {
-    load_matcher = IsChangeInt32ToInt64(load_matcher);
-  }
-  return load_matcher;
+  return IsChangeInt32ToIntPtr(load_matcher);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsUnsignedQuadOperand(
     int offset) {
+  Matcher<Node*> load_matcher;
   if (TargetSupportsUnalignedAccess()) {
-    return IsLoad(
+    load_matcher = IsLoad(
         MachineType::Uint32(),
         IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
         IsIntPtrAdd(IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
                     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
     Matcher<Node*> bytes[4];
     for (int i = 0; i < static_cast<int>(arraysize(bytes)); i++) {
       bytes[i] = IsLoad(
           MachineType::Uint8(),
           IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
           IsIntPtrAdd(
               IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
               IsIntPtrConstant(offset + kMsbOffset + kStep * i)));
     }
-    return IsWord32Or(
+    load_matcher = IsWord32Or(
         IsWord32Shl(bytes[0], IsInt32Constant(3 * kBitsPerByte)),
         IsWord32Or(
             IsWord32Shl(bytes[1], IsInt32Constant(2 * kBitsPerByte)),
             IsWord32Or(IsWord32Shl(bytes[2], IsInt32Constant(1 * kBitsPerByte)),
                        bytes[3])));
   }
+  return IsChangeUint32ToWord(load_matcher);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedQuadOperand(
     int offset) {
   Matcher<Node*> load_matcher;
   if (TargetSupportsUnalignedAccess()) {
     load_matcher = IsLoad(
         MachineType::Int32(),
         IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
@@ skipping 18 matching lines @@
               IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
               IsIntPtrConstant(offset + kMsbOffset + kStep * i)));
     }
     load_matcher = IsWord32Or(
         IsWord32Shl(bytes[0], IsInt32Constant(3 * kBitsPerByte)),
         IsWord32Or(
             IsWord32Shl(bytes[1], IsInt32Constant(2 * kBitsPerByte)),
             IsWord32Or(IsWord32Shl(bytes[2], IsInt32Constant(1 * kBitsPerByte)),
                        bytes[3])));
   }
-
-  if (kPointerSize == 8) {
-    load_matcher = IsChangeInt32ToInt64(load_matcher);
-  }
-  return load_matcher;
+  return IsChangeInt32ToIntPtr(load_matcher);
 }
 
 Matcher<Node*>
 InterpreterAssemblerTest::InterpreterAssemblerForTest::IsSignedOperand(
     int offset, OperandSize operand_size) {
   switch (operand_size) {
     case OperandSize::kByte:
       return IsSignedByteOperand(offset);
     case OperandSize::kShort:
       return IsSignedShortOperand(offset);
@@ skipping 29 matching lines @@
 
     OperandScale operand_scale = OperandScale::kSingle;
     Matcher<Node*> next_bytecode_offset_matcher =
         IsIntPtrAdd(IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
                     IsIntPtrConstant(
                         interpreter::Bytecodes::Size(bytecode, operand_scale)));
     Matcher<Node*> target_bytecode_matcher =
         m.IsLoad(MachineType::Uint8(),
                  IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
                  next_bytecode_offset_matcher);
-    if (kPointerSize == 8) {
-      target_bytecode_matcher = IsChangeUint32ToUint64(target_bytecode_matcher);
-    }
+    target_bytecode_matcher = IsChangeUint32ToWord(target_bytecode_matcher);
     Matcher<Node*> code_target_matcher = m.IsLoad(
         MachineType::Pointer(),
         IsParameter(InterpreterDispatchDescriptor::kDispatchTable),
         IsWordShl(target_bytecode_matcher, IsIntPtrConstant(kPointerSizeLog2)));
 
     if (interpreter::Bytecodes::IsStarLookahead(bytecode, operand_scale)) {
       Matcher<Node*> after_lookahead_offset =
           IsIntPtrAdd(next_bytecode_offset_matcher,
                       IsIntPtrConstant(interpreter::Bytecodes::Size(
                           Bytecode::kStar, operand_scale)));
       next_bytecode_offset_matcher =
           IsPhi(MachineType::PointerRepresentation(),
                 next_bytecode_offset_matcher, after_lookahead_offset, _);
       Matcher<Node*> after_lookahead_bytecode =
           m.IsLoad(MachineType::Uint8(),
                    IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
                    after_lookahead_offset);
-      if (kPointerSize == 8) {
-        after_lookahead_bytecode =
-            IsChangeUint32ToUint64(after_lookahead_bytecode);
-      }
+      after_lookahead_bytecode = IsChangeUint32ToWord(after_lookahead_bytecode);
       target_bytecode_matcher =
           IsPhi(MachineType::PointerRepresentation(), target_bytecode_matcher,
                 after_lookahead_bytecode, _);
       code_target_matcher =
           m.IsLoad(MachineType::Pointer(),
                    IsParameter(InterpreterDispatchDescriptor::kDispatchTable),
                    IsWordShl(target_bytecode_matcher,
                              IsIntPtrConstant(kPointerSizeLog2)));
     }
 
@@ skipping 19 matching lines @@
 
       InterpreterAssemblerTestState state(this, bytecode);
       InterpreterAssemblerForTest m(&state, bytecode);
       Node* tail_call_node = m.Jump(m.IntPtrConstant(jump_offset));
 
       Matcher<Node*> next_bytecode_offset_matcher = IsIntPtrAdd(
           IsParameter(InterpreterDispatchDescriptor::kBytecodeOffset),
           IsIntPtrConstant(jump_offset));
       Matcher<Node*> target_bytecode_matcher =
           m.IsLoad(MachineType::Uint8(), _, next_bytecode_offset_matcher);
-      if (kPointerSize == 8) {
-        target_bytecode_matcher =
-            IsChangeUint32ToUint64(target_bytecode_matcher);
-      }
+      target_bytecode_matcher = IsChangeUint32ToWord(target_bytecode_matcher);
       Matcher<Node*> code_target_matcher =
           m.IsLoad(MachineType::Pointer(),
                    IsParameter(InterpreterDispatchDescriptor::kDispatchTable),
                    IsWordShl(target_bytecode_matcher,
                              IsIntPtrConstant(kPointerSizeLog2)));
 
       EXPECT_THAT(
           tail_call_node,
           IsTailCall(_, code_target_matcher,
                      IsParameter(InterpreterDispatchDescriptor::kAccumulator),
@@ skipping 194 matching lines @@
     Node* a = m.IntPtrConstant(0);
     Node* add = m.WordShl(a, 10);
     EXPECT_THAT(add, IsWordShl(a, IsIntPtrConstant(10)));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadConstantPoolEntry) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerTestState state(this, bytecode);
     InterpreterAssemblerForTest m(&state, bytecode);
-    Node* index = m.IntPtrConstant(2);
-    Node* load_constant = m.LoadConstantPoolEntry(index);
-    Matcher<Node*> constant_pool_matcher = m.IsLoad(
-        MachineType::AnyTagged(),
-        IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
-        IsIntPtrConstant(BytecodeArray::kConstantPoolOffset - kHeapObjectTag));
-    EXPECT_THAT(
-        load_constant,
-        m.IsLoad(MachineType::AnyTagged(), constant_pool_matcher,
-                 IsIntPtrAdd(
-                     IsIntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
-                     IsWordShl(index, IsIntPtrConstant(kPointerSizeLog2)))));
+    {
+      Node* index = m.IntPtrConstant(2);
+      Node* load_constant = m.LoadConstantPoolEntry(index);
+      Matcher<Node*> constant_pool_matcher =
+          m.IsLoad(MachineType::AnyTagged(),
+                   IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
+                   IsIntPtrConstant(BytecodeArray::kConstantPoolOffset -
+                                    kHeapObjectTag));
+      EXPECT_THAT(load_constant,
+                  m.IsLoad(MachineType::AnyTagged(), constant_pool_matcher,
+                           IsIntPtrConstant(FixedArray::OffsetOfElementAt(2) -
+                                            kHeapObjectTag)));
+    }
+    {
+      Node* index = m.Parameter(2);
+      Node* load_constant = m.LoadConstantPoolEntry(index);
+      Matcher<Node*> constant_pool_matcher =
+          m.IsLoad(MachineType::AnyTagged(),
+                   IsParameter(InterpreterDispatchDescriptor::kBytecodeArray),
+                   IsIntPtrConstant(BytecodeArray::kConstantPoolOffset -
+                                    kHeapObjectTag));
+      EXPECT_THAT(
+          load_constant,
+          m.IsLoad(
+              MachineType::AnyTagged(), constant_pool_matcher,
+              IsIntPtrAdd(
+                  IsIntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
+                  IsWordShl(index, IsIntPtrConstant(kPointerSizeLog2)))));
+    }
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadObjectField) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerTestState state(this, bytecode);
     InterpreterAssemblerForTest m(&state, bytecode);
     Node* object = m.IntPtrConstant(0xdeadbeef);
     int offset = 16;
     Node* load_field = m.LoadObjectField(object, offset);
@@ skipping 17 matching lines @@
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime) {
   const int kResultSizes[] = {1, 2};
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     TRACED_FOREACH(int, result_size, kResultSizes) {
       InterpreterAssemblerTestState state(this, bytecode);
       InterpreterAssemblerForTest m(&state, 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* context = m.Int32Constant(4);
+      Node* function_id = m.IntPtrConstant(0);
+      Node* first_arg = m.IntPtrConstant(1);
+      Node* arg_count = m.IntPtrConstant(2);
+      Node* context = m.IntPtrConstant(4);
 
       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 =
+          IsIntPtrAdd(function_table,
+                      IsIntPtrMul(function_id,
+                                  IsIntPtrConstant(sizeof(Runtime::Function))));
       Matcher<Node*> function_entry =
           m.IsLoad(MachineType::Pointer(), function,
                    IsIntPtrConstant(offsetof(Runtime::Function, entry)));
 
       Node* call_runtime = m.CallRuntimeN(function_id, context, first_arg,
                                           arg_count, result_size);
       EXPECT_THAT(call_runtime,
-                  IsCall(_, IsHeapConstant(builtin.code()), arg_count,
-                         first_arg, function_entry, context, _, _));
+                  IsCall(_, IsHeapConstant(builtin.code()),
+                         IsTruncateWordToWord32(arg_count), first_arg,
+                         function_entry, context, _, _));
     }
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, CallJS) {
   TailCallMode tail_call_modes[] = {TailCallMode::kDisallow,
                                     TailCallMode::kAllow};
   TRACED_FOREACH(TailCallMode, tail_call_mode, tail_call_modes) {
     TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
       InterpreterAssemblerTestState state(this, bytecode);
       InterpreterAssemblerForTest m(&state, bytecode);
       Callable builtin =
           CodeFactory::InterpreterPushArgsAndCall(isolate(), tail_call_mode);
-      Node* function = m.Int32Constant(0);
-      Node* first_arg = m.Int32Constant(1);
-      Node* arg_count = m.Int32Constant(2);
-      Node* context = m.Int32Constant(3);
+      Node* function = m.IntPtrConstant(0);
+      Node* first_arg = m.IntPtrConstant(1);
+      Node* arg_count = m.IntPtrConstant(2);
+      Node* context = m.IntPtrConstant(3);
       Node* call_js =
           m.CallJS(function, context, first_arg, arg_count, tail_call_mode);
-      EXPECT_THAT(call_js, IsCall(_, IsHeapConstant(builtin.code()), arg_count,
-                                  first_arg, function, context, _, _));
+      EXPECT_THAT(call_js, IsCall(_, IsHeapConstant(builtin.code()),
+                                  IsTruncateWordToWord32(arg_count), first_arg,
+                                  function, context, _, _));
     }
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, LoadTypeFeedbackVector) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerTestState state(this, bytecode);
     InterpreterAssemblerForTest m(&state, bytecode);
     Node* feedback_vector = m.LoadTypeFeedbackVector();
 
     Matcher<Node*> load_function_matcher =
         m.IsLoad(MachineType::AnyTagged(), IsLoadParentFramePointer(),
                  IsIntPtrConstant(Register::function_closure().ToOperand()
                                   << kPointerSizeLog2));
     Matcher<Node*> load_literals_matcher = m.IsLoad(
         MachineType::AnyTagged(), load_function_matcher,
         IsIntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag));
 
     EXPECT_THAT(feedback_vector,
                 m.IsLoad(MachineType::AnyTagged(), load_literals_matcher,
                          IsIntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
                                           kHeapObjectTag)));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8