[turbofan] Support subtraction displacements in BaseWithIndexAndDisplacementMatcher

test/unittests/compiler/node-matchers-unittest.cc

 // Copyright 2014 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 "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/opcodes.h"
@@ skipping 12 matching lines @@
 
   MachineOperatorBuilder* machine() { return &machine_; }
 
  private:
   MachineOperatorBuilder machine_;
 };
 
 namespace {
 
 template <class Matcher>
-void CheckBaseWithIndexAndDisplacement(Matcher* matcher, Node* index, int scale,
-                                       Node* base, Node* displacement) {
+void CheckBaseWithIndexAndDisplacement(
+    Matcher* matcher, Node* index, int scale, Node* base, Node* displacement,
+    DisplacementMode displacement_mode = kPositiveDisplacement) {
   EXPECT_TRUE(matcher->matches());
   EXPECT_EQ(index, matcher->index());
   EXPECT_EQ(scale, matcher->scale());
   EXPECT_EQ(base, matcher->base());
   EXPECT_EQ(displacement, matcher->displacement());
+  EXPECT_EQ(displacement_mode, matcher->displacement_mode());
 }
 
 }  // namespace
 
 
 TEST_F(NodeMatcherTest, ScaledWithOffset32Matcher) {
   graph()->SetStart(graph()->NewNode(common()->Start(0)));
 
   const Operator* d0_op = common()->Int32Constant(0);
   Node* d0 = graph()->NewNode(d0_op);
@@ skipping 33 matching lines @@
   Node* b1 = graph()->NewNode(b1_op, graph()->start());
   USE(b0);
 
   const Operator* p1_op = common()->Parameter(3);
   Node* p1 = graph()->NewNode(p1_op, graph()->start());
   USE(p1);
 
   const Operator* a_op = machine()->Int32Add();
   USE(a_op);
 
+  const Operator* sub_op = machine()->Int32Sub();
+  USE(sub_op);
+
   const Operator* m_op = machine()->Int32Mul();
   Node* m1 = graph()->NewNode(m_op, p1, d1);
   Node* m2 = graph()->NewNode(m_op, p1, d2);
   Node* m3 = graph()->NewNode(m_op, p1, d3);
   Node* m4 = graph()->NewNode(m_op, p1, d4);
   Node* m5 = graph()->NewNode(m_op, p1, d5);
   Node* m7 = graph()->NewNode(m_op, p1, d7);
   Node* m8 = graph()->NewNode(m_op, p1, d8);
   Node* m9 = graph()->NewNode(m_op, p1, d9);
   USE(m1);
@@ skipping 244 matching lines @@
   BaseWithIndexAndDisplacement32Matcher match42(
       graph()->NewNode(a_op, b0, graph()->NewNode(a_op, d15, s3)));
   CheckBaseWithIndexAndDisplacement(&match42, p1, 3, b0, d15);
 
   // S3 + (B0 + D15) -> [p1, 2, b0, d15]
   s3 = graph()->NewNode(s_op, p1, d3);
   BaseWithIndexAndDisplacement32Matcher match43(
       graph()->NewNode(a_op, s3, graph()->NewNode(a_op, b0, d15)));
   CheckBaseWithIndexAndDisplacement(&match43, p1, 3, b0, d15);
 
-  // Check that scales that require using the base address work dorrectly.
+  // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  BaseWithIndexAndDisplacement32Matcher match44(
+      graph()->NewNode(a_op, s3, graph()->NewNode(sub_op, b0, d15)));
+  CheckBaseWithIndexAndDisplacement(&match44, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
+
+  // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
+  BaseWithIndexAndDisplacement32Matcher match45(
+      graph()->NewNode(a_op, b0, graph()->NewNode(sub_op, b1, d15)));
+  CheckBaseWithIndexAndDisplacement(&match45, b1, 0, b0, d15,
+                                    kNegativeDisplacement);
+
+  // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  BaseWithIndexAndDisplacement32Matcher match46(
+      graph()->NewNode(a_op, graph()->NewNode(sub_op, b0, d15), s3));
+  CheckBaseWithIndexAndDisplacement(&match46, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
 }
 
 
 TEST_F(NodeMatcherTest, ScaledWithOffset64Matcher) {
   graph()->SetStart(graph()->NewNode(common()->Start(0)));
 
   const Operator* d0_op = common()->Int64Constant(0);
   Node* d0 = graph()->NewNode(d0_op);
   USE(d0);
   const Operator* d1_op = common()->Int64Constant(1);
@@ skipping 34 matching lines @@
   Node* b1 = graph()->NewNode(b1_op, graph()->start());
   USE(b0);
 
   const Operator* p1_op = common()->Parameter(3);
   Node* p1 = graph()->NewNode(p1_op, graph()->start());
   USE(p1);
 
   const Operator* a_op = machine()->Int64Add();
   USE(a_op);
 
+  const Operator* sub_op = machine()->Int64Sub();
+  USE(sub_op);
+
   const Operator* m_op = machine()->Int64Mul();
   Node* m1 = graph()->NewNode(m_op, p1, d1);
   Node* m2 = graph()->NewNode(m_op, p1, d2);
   Node* m3 = graph()->NewNode(m_op, p1, d3);
   Node* m4 = graph()->NewNode(m_op, p1, d4);
   Node* m5 = graph()->NewNode(m_op, p1, d5);
   Node* m7 = graph()->NewNode(m_op, p1, d7);
   Node* m8 = graph()->NewNode(m_op, p1, d8);
   Node* m9 = graph()->NewNode(m_op, p1, d9);
   USE(m1);
@@ skipping 297 matching lines @@
   BaseWithIndexAndDisplacement64Matcher match49(
       graph()->NewNode(a_op, temp, d15));
   CheckBaseWithIndexAndDisplacement(&match49, m3, 0, b0, d15);
 
   // (M3 + (D15 + B0)) -> [m3, 0, b0, D15]
   m3 = graph()->NewNode(m_op, p1, d3);
   temp = graph()->NewNode(a_op, b0, d15);
   BaseWithIndexAndDisplacement64Matcher match50(
       graph()->NewNode(a_op, m3, temp));
   CheckBaseWithIndexAndDisplacement(&match50, m3, 0, b0, d15);
+
+  // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  BaseWithIndexAndDisplacement64Matcher match51(
+      graph()->NewNode(a_op, s3, graph()->NewNode(sub_op, b0, d15)));
+  CheckBaseWithIndexAndDisplacement(&match51, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
+
+  // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
+  BaseWithIndexAndDisplacement64Matcher match52(
+      graph()->NewNode(a_op, b0, graph()->NewNode(sub_op, b1, d15)));
+  CheckBaseWithIndexAndDisplacement(&match52, b1, 0, b0, d15,
+                                    kNegativeDisplacement);
+
+  // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  BaseWithIndexAndDisplacement64Matcher match53(
+      graph()->NewNode(a_op, graph()->NewNode(sub_op, b0, d15), s3));
+  CheckBaseWithIndexAndDisplacement(&match53, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
 }
 
-
 TEST_F(NodeMatcherTest, BranchMatcher_match) {
   Node* zero = graph()->NewNode(common()->Int32Constant(0));
 
   {
     Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
     Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
     Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
     BranchMatcher matcher(branch);
     EXPECT_TRUE(matcher.Matched());
     EXPECT_EQ(branch, matcher.Branch());
@@ skipping 201 matching lines @@
     Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
     DiamondMatcher matcher(merge);
     EXPECT_FALSE(matcher.Matched());
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8