[turbofan] Relax limitation for using BaseWithIndexAndDisplacement for load/stores

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

Index: test/unittests/compiler/node-matchers-unittest.cc
diff --git a/test/unittests/compiler/node-matchers-unittest.cc b/test/unittests/compiler/node-matchers-unittest.cc
index 45d7427494e00948543fc529c289539014a9f07f..7f043049f0b269e3503f5b53258ecb1e6967534b 100644
--- a/test/unittests/compiler/node-matchers-unittest.cc
+++ b/test/unittests/compiler/node-matchers-unittest.cc
@@ -43,6 +43,17 @@ void CheckBaseWithIndexAndDisplacement(
 
 }  // namespace
 
+#define ADD_ADDRESSING_OPERAND_USES(node)                                 \
+  graph()->NewNode(machine()->Load(MachineType::Int32()), node, d0,       \
+                   graph()->start(), graph()->start());                   \
+  graph()->NewNode(machine()->Store(rep), node, d0, d0, graph()->start(), \
+                   graph()->start());                                     \
+  graph()->NewNode(machine()->Int32Add(), node, d0);                      \
+  graph()->NewNode(machine()->Int64Add(), node, d0);
+
+#define ADD_NONE_ADDRESSING_OPERAND_USES(node)                            \
+  graph()->NewNode(machine()->Store(rep), b0, d0, node, graph()->start(), \
+                   graph()->start());
 
 TEST_F(NodeMatcherTest, ScaledWithOffset32Matcher) {
   graph()->SetStart(graph()->NewNode(common()->Start(0)));
@@ -125,6 +136,10 @@ TEST_F(NodeMatcherTest, ScaledWithOffset32Matcher) {
   USE(s3);
   USE(s4);
 
+  const StoreRepresentation rep(MachineRepresentation::kWord32,
+                                kNoWriteBarrier);
+  USE(rep);
+
   // 1 INPUT
 
   // Only relevant test dases is Checking for non-match.
@@ -378,6 +393,613 @@ TEST_F(NodeMatcherTest, ScaledWithOffset32Matcher) {
       graph()->NewNode(a_op, graph()->NewNode(sub_op, b0, d15), s3));
   CheckBaseWithIndexAndDisplacement(&match46, p1, 3, b0, d15,
                                     kNegativeDisplacement);
+
+  // 4 INPUT - with addressing operand uses
+
+  // (B0 + M1) -> [p1, 0, B0, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match47(graph()->NewNode(a_op, b0, m1));
+  CheckBaseWithIndexAndDisplacement(&match47, p1, 0, b0, NULL);
+
+  // (M1 + B0) -> [p1, 0, B0, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match48(graph()->NewNode(a_op, m1, b0));
+  CheckBaseWithIndexAndDisplacement(&match48, p1, 0, b0, NULL);
+
+  // (D15 + M1) -> [P1, 0, NULL, D15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match49(
+      graph()->NewNode(a_op, d15, m1));
+  CheckBaseWithIndexAndDisplacement(&match49, p1, 0, NULL, d15);
+
+  // (M1 + D15) -> [P1, 0, NULL, D15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match50(
+      graph()->NewNode(a_op, m1, d15));
+  CheckBaseWithIndexAndDisplacement(&match50, p1, 0, NULL, d15);
+
+  // (B0 + S0) -> [p1, 0, B0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match51(graph()->NewNode(a_op, b0, s0));
+  CheckBaseWithIndexAndDisplacement(&match51, p1, 0, b0, NULL);
+
+  // (S0 + B0) -> [p1, 0, B0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match52(graph()->NewNode(a_op, s0, b0));
+  CheckBaseWithIndexAndDisplacement(&match52, p1, 0, b0, NULL);
+
+  // (D15 + S0) -> [P1, 0, NULL, D15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match53(
+      graph()->NewNode(a_op, d15, s0));
+  CheckBaseWithIndexAndDisplacement(&match53, p1, 0, NULL, d15);
+
+  // (S0 + D15) -> [P1, 0, NULL, D15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match54(
+      graph()->NewNode(a_op, s0, d15));
+  CheckBaseWithIndexAndDisplacement(&match54, p1, 0, NULL, d15);
+
+  // (B0 + M2) -> [p1, 1, B0, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match55(graph()->NewNode(a_op, b0, m2));
+  CheckBaseWithIndexAndDisplacement(&match55, p1, 1, b0, NULL);
+
+  // (M2 + B0) -> [p1, 1, B0, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match56(graph()->NewNode(a_op, m2, b0));
+  CheckBaseWithIndexAndDisplacement(&match56, p1, 1, b0, NULL);
+
+  // (D15 + M2) -> [P1, 1, NULL, D15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match57(
+      graph()->NewNode(a_op, d15, m2));
+  CheckBaseWithIndexAndDisplacement(&match57, p1, 1, NULL, d15);
+
+  // (M2 + D15) -> [P1, 1, NULL, D15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match58(
+      graph()->NewNode(a_op, m2, d15));
+  CheckBaseWithIndexAndDisplacement(&match58, p1, 1, NULL, d15);
+
+  // (B0 + S1) -> [p1, 1, B0, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match59(graph()->NewNode(a_op, b0, s1));
+  CheckBaseWithIndexAndDisplacement(&match59, p1, 1, b0, NULL);
+
+  // (S1 + B0) -> [p1, 1, B0, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match60(graph()->NewNode(a_op, s1, b0));
+  CheckBaseWithIndexAndDisplacement(&match60, p1, 1, b0, NULL);
+
+  // (D15 + S1) -> [P1, 1, NULL, D15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match61(
+      graph()->NewNode(a_op, d15, s1));
+  CheckBaseWithIndexAndDisplacement(&match61, p1, 1, NULL, d15);
+
+  // (S1 + D15) -> [P1, 1, NULL, D15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match62(
+      graph()->NewNode(a_op, s1, d15));
+  CheckBaseWithIndexAndDisplacement(&match62, p1, 1, NULL, d15);
+
+  // (B0 + M4) -> [p1, 2, B0, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match63(graph()->NewNode(a_op, b0, m4));
+  CheckBaseWithIndexAndDisplacement(&match63, p1, 2, b0, NULL);
+
+  // (M4 + B0) -> [p1, 2, B0, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match64(graph()->NewNode(a_op, m4, b0));
+  CheckBaseWithIndexAndDisplacement(&match64, p1, 2, b0, NULL);
+
+  // (D15 + M4) -> [p1, 2, NULL, D15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match65(
+      graph()->NewNode(a_op, d15, m4));
+  CheckBaseWithIndexAndDisplacement(&match65, p1, 2, NULL, d15);
+
+  // (M4 + D15) -> [p1, 2, NULL, D15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match66(
+      graph()->NewNode(a_op, m4, d15));
+  CheckBaseWithIndexAndDisplacement(&match66, p1, 2, NULL, d15);
+
+  // (B0 + S2) -> [p1, 2, B0, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match67(graph()->NewNode(a_op, b0, s2));
+  CheckBaseWithIndexAndDisplacement(&match67, p1, 2, b0, NULL);
+
+  // (S2 + B0) -> [p1, 2, B0, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match68(graph()->NewNode(a_op, s2, b0));
+  CheckBaseWithIndexAndDisplacement(&match68, p1, 2, b0, NULL);
+
+  // (D15 + S2) -> [p1, 2, NULL, D15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match69(
+      graph()->NewNode(a_op, d15, s2));
+  CheckBaseWithIndexAndDisplacement(&match69, p1, 2, NULL, d15);
+
+  // (S2 + D15) -> [p1, 2, NULL, D15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match70(
+      graph()->NewNode(a_op, s2, d15));
+  CheckBaseWithIndexAndDisplacement(&match70, p1, 2, NULL, d15);
+
+  // (B0 + M8) -> [p1, 2, B0, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match71(graph()->NewNode(a_op, b0, m8));
+  CheckBaseWithIndexAndDisplacement(&match71, p1, 3, b0, NULL);
+
+  // (M8 + B0) -> [p1, 2, B0, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match72(graph()->NewNode(a_op, m8, b0));
+  CheckBaseWithIndexAndDisplacement(&match72, p1, 3, b0, NULL);
+
+  // (D15 + M8) -> [p1, 2, NULL, D15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match73(
+      graph()->NewNode(a_op, d15, m8));
+  CheckBaseWithIndexAndDisplacement(&match73, p1, 3, NULL, d15);
+
+  // (M8 + D15) -> [p1, 2, NULL, D15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match74(
+      graph()->NewNode(a_op, m8, d15));
+  CheckBaseWithIndexAndDisplacement(&match74, p1, 3, NULL, d15);
+
+  // (B0 + S3) -> [p1, 2, B0, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match75(graph()->NewNode(a_op, b0, s3));
+  CheckBaseWithIndexAndDisplacement(&match75, p1, 3, b0, NULL);
+
+  // (S3 + B0) -> [p1, 2, B0, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match76(graph()->NewNode(a_op, s3, b0));
+  CheckBaseWithIndexAndDisplacement(&match76, p1, 3, b0, NULL);
+
+  // (D15 + S3) -> [p1, 2, NULL, D15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match77(
+      graph()->NewNode(a_op, d15, s3));
+  CheckBaseWithIndexAndDisplacement(&match77, p1, 3, NULL, d15);
+
+  // (S3 + D15) -> [p1, 2, NULL, D15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match78(
+      graph()->NewNode(a_op, s3, d15));
+  CheckBaseWithIndexAndDisplacement(&match78, p1, 3, NULL, d15);
+
+  // (D15 + S3) + B0 -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  Node* temp = graph()->NewNode(a_op, d15, s3);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match79(
+      graph()->NewNode(a_op, temp, b0));
+  CheckBaseWithIndexAndDisplacement(&match79, p1, 3, b0, d15);
+
+  // (B0 + D15) + S3 -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match80(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match80, p1, 3, b0, d15);
+
+  // (S3 + B0) + D15 -> [NULL, 0, (s3 + b0), d15]
+  // Avoid changing simple addressing to complex addressing
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match81(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match81, NULL, 0, temp, d15);
+
+  // D15 + (S3 + B0) -> [NULL, 0, (s3 + b0), d15]
+  // Avoid changing simple addressing to complex addressing
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match82(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match82, NULL, 0, temp, d15);
+
+  // B0 + (D15 + S3) -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match83(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match83, p1, 3, b0, d15);
+
+  // S3 + (B0 + D15) -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match84(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match84, p1, 3, b0, d15);
+
+  // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match85(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match85, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
+
+  // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
+  temp = graph()->NewNode(sub_op, b1, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match86(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match86, b1, 0, b0, d15,
+                                    kNegativeDisplacement);
+
+  // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match87(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match87, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
+
+  // (B0 + B1) + D15 -> [NULL, 0, (b0 + b1), d15]
+  // Avoid changing simple addressing to complex addressing
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match88(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match88, NULL, 0, temp, d15);
+
+  // D15 + (B0 + B1) -> [NULL, 0, (b0 + b1), d15]
+  // Avoid changing simple addressing to complex addressing
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match89(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match89, NULL, 0, temp, d15);
+
+  // 5 INPUT - with none-addressing operand uses
+
+  // (B0 + M1) -> [b0, 0, m1, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match90(graph()->NewNode(a_op, b0, m1));
+  CheckBaseWithIndexAndDisplacement(&match90, b0, 0, m1, NULL);
+
+  // (M1 + B0) -> [b0, 0, m1, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match91(graph()->NewNode(a_op, m1, b0));
+  CheckBaseWithIndexAndDisplacement(&match91, b0, 0, m1, NULL);
+
+  // (D15 + M1) -> [NULL, 0, m1, d15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match92(
+      graph()->NewNode(a_op, d15, m1));
+  CheckBaseWithIndexAndDisplacement(&match92, NULL, 0, m1, d15);
+
+  // (M1 + D15) -> [NULL, 0, m1, d15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement32Matcher match93(
+      graph()->NewNode(a_op, m1, d15));
+  CheckBaseWithIndexAndDisplacement(&match93, NULL, 0, m1, d15);
+
+  // (B0 + S0) -> [b0, 0, s0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match94(graph()->NewNode(a_op, b0, s0));
+  CheckBaseWithIndexAndDisplacement(&match94, b0, 0, s0, NULL);
+
+  // (S0 + B0) -> [b0, 0, s0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match95(graph()->NewNode(a_op, s0, b0));
+  CheckBaseWithIndexAndDisplacement(&match95, b0, 0, s0, NULL);
+
+  // (D15 + S0) -> [NULL, 0, s0, d15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match96(
+      graph()->NewNode(a_op, d15, s0));
+  CheckBaseWithIndexAndDisplacement(&match96, NULL, 0, s0, d15);
+
+  // (S0 + D15) -> [NULL, 0, s0, d15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement32Matcher match97(
+      graph()->NewNode(a_op, s0, d15));
+  CheckBaseWithIndexAndDisplacement(&match97, NULL, 0, s0, d15);
+
+  // (B0 + M2) -> [b0, 0, m2, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match98(graph()->NewNode(a_op, b0, m2));
+  CheckBaseWithIndexAndDisplacement(&match98, b0, 0, m2, NULL);
+
+  // (M2 + B0) -> [b0, 0, m2, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match99(graph()->NewNode(a_op, m2, b0));
+  CheckBaseWithIndexAndDisplacement(&match99, b0, 0, m2, NULL);
+
+  // (D15 + M2) -> [NULL, 0, m2, d15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match100(
+      graph()->NewNode(a_op, d15, m2));
+  CheckBaseWithIndexAndDisplacement(&match100, NULL, 0, m2, d15);
+
+  // (M2 + D15) -> [NULL, 0, m2, d15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement32Matcher match101(
+      graph()->NewNode(a_op, m2, d15));
+  CheckBaseWithIndexAndDisplacement(&match101, NULL, 0, m2, d15);
+
+  // (B0 + S1) -> [b0, 0, s1, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match102(
+      graph()->NewNode(a_op, b0, s1));
+  CheckBaseWithIndexAndDisplacement(&match102, b0, 0, s1, NULL);
+
+  // (S1 + B0) -> [b0, 0, s1, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match103(
+      graph()->NewNode(a_op, s1, b0));
+  CheckBaseWithIndexAndDisplacement(&match103, b0, 0, s1, NULL);
+
+  // (D15 + S1) -> [NULL, 0, s1, d15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match104(
+      graph()->NewNode(a_op, d15, s1));
+  CheckBaseWithIndexAndDisplacement(&match104, NULL, 0, s1, d15);
+
+  // (S1 + D15) -> [NULL, 0, s1, d15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement32Matcher match105(
+      graph()->NewNode(a_op, s1, d15));
+  CheckBaseWithIndexAndDisplacement(&match105, NULL, 0, s1, d15);
+
+  // (B0 + M4) -> [b0, 0, m4, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match106(
+      graph()->NewNode(a_op, b0, m4));
+  CheckBaseWithIndexAndDisplacement(&match106, b0, 0, m4, NULL);
+
+  // (M4 + B0) -> [b0, 0, m4, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match107(
+      graph()->NewNode(a_op, m4, b0));
+  CheckBaseWithIndexAndDisplacement(&match107, b0, 0, m4, NULL);
+
+  // (D15 + M4) -> [NULL, 0, m4, d15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match108(
+      graph()->NewNode(a_op, d15, m4));
+  CheckBaseWithIndexAndDisplacement(&match108, NULL, 0, m4, d15);
+
+  // (M4 + D15) -> [NULL, 0, m4, d15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement32Matcher match109(
+      graph()->NewNode(a_op, m4, d15));
+  CheckBaseWithIndexAndDisplacement(&match109, NULL, 0, m4, d15);
+
+  // (B0 + S2) -> [b0, 0, s2, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match110(
+      graph()->NewNode(a_op, b0, s2));
+  CheckBaseWithIndexAndDisplacement(&match110, b0, 0, s2, NULL);
+
+  // (S2 + B0) -> [b0, 0, s2, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match111(
+      graph()->NewNode(a_op, s2, b0));
+  CheckBaseWithIndexAndDisplacement(&match111, b0, 0, s2, NULL);
+
+  // (D15 + S2) -> [NULL, 0, s2, d15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match112(
+      graph()->NewNode(a_op, d15, s2));
+  CheckBaseWithIndexAndDisplacement(&match112, NULL, 0, s2, d15);
+
+  // (S2 + D15) -> [NULL, 0, s2, d15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement32Matcher match113(
+      graph()->NewNode(a_op, s2, d15));
+  CheckBaseWithIndexAndDisplacement(&match113, NULL, 0, s2, d15);
+
+  // (B0 + M8) -> [b0, 0, m8, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match114(
+      graph()->NewNode(a_op, b0, m8));
+  CheckBaseWithIndexAndDisplacement(&match114, b0, 0, m8, NULL);
+
+  // (M8 + B0) -> [b0, 0, m8, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match115(
+      graph()->NewNode(a_op, m8, b0));
+  CheckBaseWithIndexAndDisplacement(&match115, b0, 0, m8, NULL);
+
+  // (D15 + M8) -> [NULL, 0, m8, d15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match116(
+      graph()->NewNode(a_op, d15, m8));
+  CheckBaseWithIndexAndDisplacement(&match116, NULL, 0, m8, d15);
+
+  // (M8 + D15) -> [NULL, 0, m8, d15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement32Matcher match117(
+      graph()->NewNode(a_op, m8, d15));
+  CheckBaseWithIndexAndDisplacement(&match117, NULL, 0, m8, d15);
+
+  // (B0 + S3) -> [b0, 0, s3, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match118(
+      graph()->NewNode(a_op, b0, s3));
+  CheckBaseWithIndexAndDisplacement(&match118, b0, 0, s3, NULL);
+
+  // (S3 + B0) -> [b0, 0, s3, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match119(
+      graph()->NewNode(a_op, s3, b0));
+  CheckBaseWithIndexAndDisplacement(&match119, b0, 0, s3, NULL);
+
+  // (D15 + S3) -> [NULL, 0, s3, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match120(
+      graph()->NewNode(a_op, d15, s3));
+  CheckBaseWithIndexAndDisplacement(&match120, NULL, 0, s3, d15);
+
+  // (S3 + D15) -> [NULL, 0, s3, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement32Matcher match121(
+      graph()->NewNode(a_op, s3, d15));
+  CheckBaseWithIndexAndDisplacement(&match121, NULL, 0, s3, d15);
+
+  // (D15 + S3) + B0 -> [b0, 0, (D15 + S3), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match122(
+      graph()->NewNode(a_op, temp, b0));
+  CheckBaseWithIndexAndDisplacement(&match122, b0, 0, temp, NULL);
+
+  // (B0 + D15) + S3 -> [p1, 3, (B0 + D15), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match123(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match123, p1, 3, temp, NULL);
+
+  // (S3 + B0) + D15 -> [NULL, 0, (S3 + B0), d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match124(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match124, NULL, 0, temp, d15);
+
+  // D15 + (S3 + B0) -> [NULL, 0, (S3 + B0), d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match125(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match125, NULL, 0, temp, d15);
+
+  // B0 + (D15 + S3) -> [b0, 0, (D15 + S3), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match126(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match126, b0, 0, temp, NULL);
+
+  // S3 + (B0 + D15) -> [p1, 3, (B0 + D15), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match127(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match127, p1, 3, temp, NULL);
+
+  // S3 + (B0 - D15) -> [p1, 3, (B0 - D15), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match128(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match128, p1, 3, temp, NULL);
+
+  // B0 + (B1 - D15) -> [b0, 0, (B1 - D15), NULL]
+  temp = graph()->NewNode(sub_op, b1, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match129(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match129, b0, 0, temp, NULL);
+
+  // (B0 - D15) + S3 -> [p1, 3, temp, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match130(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match130, p1, 3, temp, NULL);
+
+  // (B0 + B1) + D15 -> [NULL, 0, (B0 + B1), d15]
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match131(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match131, NULL, 0, temp, d15);
+
+  // D15 + (B0 + B1) -> [NULL, 0, (B0 + B1), d15]
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement32Matcher match132(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match132, NULL, 0, temp, d15);
 }
 
 
@@ -465,6 +1087,10 @@ TEST_F(NodeMatcherTest, ScaledWithOffset64Matcher) {
   USE(s3);
   USE(s4);
 
+  const StoreRepresentation rep(MachineRepresentation::kWord32,
+                                kNoWriteBarrier);
+  USE(rep);
+
   // 1 INPUT
 
   // Only relevant test dases is Checking for non-match.
@@ -635,8 +1261,8 @@ TEST_F(NodeMatcherTest, ScaledWithOffset64Matcher) {
   CheckBaseWithIndexAndDisplacement(&match31, p1, 3, NULL, d15);
 
   // (B0 + S3) -> [p1, 2, B0, NULL]
-  BaseWithIndexAndDisplacement64Matcher match64(graph()->NewNode(a_op, b0, s3));
-  CheckBaseWithIndexAndDisplacement(&match64, p1, 3, b0, NULL);
+  BaseWithIndexAndDisplacement64Matcher match32(graph()->NewNode(a_op, b0, s3));
+  CheckBaseWithIndexAndDisplacement(&match32, p1, 3, b0, NULL);
 
   // (S3 + B0) -> [p1, 2, B0, NULL]
   s3 = graph()->NewNode(s_op, p1, d3);
@@ -772,6 +1398,617 @@ TEST_F(NodeMatcherTest, ScaledWithOffset64Matcher) {
       graph()->NewNode(a_op, graph()->NewNode(sub_op, b0, d15), s3));
   CheckBaseWithIndexAndDisplacement(&match53, p1, 3, b0, d15,
                                     kNegativeDisplacement);
+
+  // 4 INPUT - with addressing operand uses
+
+  // (B0 + M1) -> [p1, 0, B0, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match54(graph()->NewNode(a_op, b0, m1));
+  CheckBaseWithIndexAndDisplacement(&match54, p1, 0, b0, NULL);
+
+  // (M1 + B0) -> [p1, 0, B0, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match55(graph()->NewNode(a_op, m1, b0));
+  CheckBaseWithIndexAndDisplacement(&match55, p1, 0, b0, NULL);
+
+  // (D15 + M1) -> [P1, 0, NULL, D15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match56(
+      graph()->NewNode(a_op, d15, m1));
+  CheckBaseWithIndexAndDisplacement(&match56, p1, 0, NULL, d15);
+
+  // (M1 + D15) -> [P1, 0, NULL, D15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match57(
+      graph()->NewNode(a_op, m1, d15));
+  CheckBaseWithIndexAndDisplacement(&match57, p1, 0, NULL, d15);
+
+  // (B0 + S0) -> [p1, 0, B0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match58(graph()->NewNode(a_op, b0, s0));
+  CheckBaseWithIndexAndDisplacement(&match58, p1, 0, b0, NULL);
+
+  // (S0 + B0) -> [p1, 0, B0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match59(graph()->NewNode(a_op, s0, b0));
+  CheckBaseWithIndexAndDisplacement(&match59, p1, 0, b0, NULL);
+
+  // (D15 + S0) -> [P1, 0, NULL, D15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match60(
+      graph()->NewNode(a_op, d15, s0));
+  CheckBaseWithIndexAndDisplacement(&match60, p1, 0, NULL, d15);
+
+  // (S0 + D15) -> [P1, 0, NULL, D15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match61(
+      graph()->NewNode(a_op, s0, d15));
+  CheckBaseWithIndexAndDisplacement(&match61, p1, 0, NULL, d15);
+
+  // (B0 + M2) -> [p1, 1, B0, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match62(graph()->NewNode(a_op, b0, m2));
+  CheckBaseWithIndexAndDisplacement(&match62, p1, 1, b0, NULL);
+
+  // (M2 + B0) -> [p1, 1, B0, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match63(graph()->NewNode(a_op, m2, b0));
+  CheckBaseWithIndexAndDisplacement(&match63, p1, 1, b0, NULL);
+
+  // (D15 + M2) -> [P1, 1, NULL, D15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match64(
+      graph()->NewNode(a_op, d15, m2));
+  CheckBaseWithIndexAndDisplacement(&match64, p1, 1, NULL, d15);
+
+  // (M2 + D15) -> [P1, 1, NULL, D15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match65(
+      graph()->NewNode(a_op, m2, d15));
+  CheckBaseWithIndexAndDisplacement(&match65, p1, 1, NULL, d15);
+
+  // (B0 + S1) -> [p1, 1, B0, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match66(graph()->NewNode(a_op, b0, s1));
+  CheckBaseWithIndexAndDisplacement(&match66, p1, 1, b0, NULL);
+
+  // (S1 + B0) -> [p1, 1, B0, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match67(graph()->NewNode(a_op, s1, b0));
+  CheckBaseWithIndexAndDisplacement(&match67, p1, 1, b0, NULL);
+
+  // (D15 + S1) -> [P1, 1, NULL, D15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match68(
+      graph()->NewNode(a_op, d15, s1));
+  CheckBaseWithIndexAndDisplacement(&match68, p1, 1, NULL, d15);
+
+  // (S1 + D15) -> [P1, 1, NULL, D15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match69(
+      graph()->NewNode(a_op, s1, d15));
+  CheckBaseWithIndexAndDisplacement(&match69, p1, 1, NULL, d15);
+
+  // (B0 + M4) -> [p1, 2, B0, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match70(graph()->NewNode(a_op, b0, m4));
+  CheckBaseWithIndexAndDisplacement(&match70, p1, 2, b0, NULL);
+
+  // (M4 + B0) -> [p1, 2, B0, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match71(graph()->NewNode(a_op, m4, b0));
+  CheckBaseWithIndexAndDisplacement(&match71, p1, 2, b0, NULL);
+
+  // (D15 + M4) -> [p1, 2, NULL, D15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match72(
+      graph()->NewNode(a_op, d15, m4));
+  CheckBaseWithIndexAndDisplacement(&match72, p1, 2, NULL, d15);
+
+  // (M4 + D15) -> [p1, 2, NULL, D15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match73(
+      graph()->NewNode(a_op, m4, d15));
+  CheckBaseWithIndexAndDisplacement(&match73, p1, 2, NULL, d15);
+
+  // (B0 + S2) -> [p1, 2, B0, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match74(graph()->NewNode(a_op, b0, s2));
+  CheckBaseWithIndexAndDisplacement(&match74, p1, 2, b0, NULL);
+
+  // (S2 + B0) -> [p1, 2, B0, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match75(graph()->NewNode(a_op, s2, b0));
+  CheckBaseWithIndexAndDisplacement(&match75, p1, 2, b0, NULL);
+
+  // (D15 + S2) -> [p1, 2, NULL, D15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match76(
+      graph()->NewNode(a_op, d15, s2));
+  CheckBaseWithIndexAndDisplacement(&match76, p1, 2, NULL, d15);
+
+  // (S2 + D15) -> [p1, 2, NULL, D15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match77(
+      graph()->NewNode(a_op, s2, d15));
+  CheckBaseWithIndexAndDisplacement(&match77, p1, 2, NULL, d15);
+
+  // (B0 + M8) -> [p1, 2, B0, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match78(graph()->NewNode(a_op, b0, m8));
+  CheckBaseWithIndexAndDisplacement(&match78, p1, 3, b0, NULL);
+
+  // (M8 + B0) -> [p1, 2, B0, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match79(graph()->NewNode(a_op, m8, b0));
+  CheckBaseWithIndexAndDisplacement(&match79, p1, 3, b0, NULL);
+
+  // (D15 + M8) -> [p1, 2, NULL, D15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match80(
+      graph()->NewNode(a_op, d15, m8));
+  CheckBaseWithIndexAndDisplacement(&match80, p1, 3, NULL, d15);
+
+  // (M8 + D15) -> [p1, 2, NULL, D15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match81(
+      graph()->NewNode(a_op, m8, d15));
+  CheckBaseWithIndexAndDisplacement(&match81, p1, 3, NULL, d15);
+
+  // (B0 + S3) -> [p1, 2, B0, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match82(graph()->NewNode(a_op, b0, s3));
+  CheckBaseWithIndexAndDisplacement(&match82, p1, 3, b0, NULL);
+
+  // (S3 + B0) -> [p1, 2, B0, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match83(graph()->NewNode(a_op, s3, b0));
+  CheckBaseWithIndexAndDisplacement(&match83, p1, 3, b0, NULL);
+
+  // (D15 + S3) -> [p1, 2, NULL, D15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match84(
+      graph()->NewNode(a_op, d15, s3));
+  CheckBaseWithIndexAndDisplacement(&match84, p1, 3, NULL, d15);
+
+  // (S3 + D15) -> [p1, 2, NULL, D15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match85(
+      graph()->NewNode(a_op, s3, d15));
+  CheckBaseWithIndexAndDisplacement(&match85, p1, 3, NULL, d15);
+
+  // (D15 + S3) + B0 -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match86(
+      graph()->NewNode(a_op, temp, b0));
+  CheckBaseWithIndexAndDisplacement(&match86, p1, 3, b0, d15);
+
+  // (B0 + D15) + S3 -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match87(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match87, p1, 3, b0, d15);
+
+  // (S3 + B0) + D15 -> [NULL, 0, (s3 + b0), d15]
+  // Avoid changing simple addressing to complex addressing
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match88(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match88, NULL, 0, temp, d15);
+
+  // D15 + (S3 + B0) -> [NULL, 0, (s3 + b0), d15]
+  // Avoid changing simple addressing to complex addressing
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match89(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match89, NULL, 0, temp, d15);
+
+  // B0 + (D15 + S3) -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match90(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match90, p1, 3, b0, d15);
+
+  // S3 + (B0 + D15) -> [p1, 2, b0, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match91(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match91, p1, 3, b0, d15);
+
+  // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match92(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match92, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
+
+  // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
+  temp = graph()->NewNode(sub_op, b1, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match93(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match93, b1, 0, b0, d15,
+                                    kNegativeDisplacement);
+
+  // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match94(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match94, p1, 3, b0, d15,
+                                    kNegativeDisplacement);
+
+  // (B0 + B1) + D15 -> [NULL, 0, (b0 + b1), d15]
+  // Avoid changing simple addressing to complex addressing
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match95(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match95, NULL, 0, temp, d15);
+
+  // D15 + (B0 + B1) -> [NULL, 0, (b0 + b1), d15]
+  // Avoid changing simple addressing to complex addressing
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match96(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match96, NULL, 0, temp, d15);
+
+  // 5 INPUT - with none-addressing operand uses
+
+  // (B0 + M1) -> [b0, 0, m1, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match97(graph()->NewNode(a_op, b0, m1));
+  CheckBaseWithIndexAndDisplacement(&match97, b0, 0, m1, NULL);
+
+  // (M1 + B0) -> [b0, 0, m1, NULL]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match98(graph()->NewNode(a_op, m1, b0));
+  CheckBaseWithIndexAndDisplacement(&match98, b0, 0, m1, NULL);
+
+  // (D15 + M1) -> [NULL, 0, m1, d15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match99(
+      graph()->NewNode(a_op, d15, m1));
+  CheckBaseWithIndexAndDisplacement(&match99, NULL, 0, m1, d15);
+
+  // (M1 + D15) -> [NULL, 0, m1, d15]
+  m1 = graph()->NewNode(m_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m1);
+  BaseWithIndexAndDisplacement64Matcher match100(
+      graph()->NewNode(a_op, m1, d15));
+  CheckBaseWithIndexAndDisplacement(&match100, NULL, 0, m1, d15);
+
+  // (B0 + S0) -> [b0, 0, s0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match101(
+      graph()->NewNode(a_op, b0, s0));
+  CheckBaseWithIndexAndDisplacement(&match101, b0, 0, s0, NULL);
+
+  // (S0 + B0) -> [b0, 0, s0, NULL]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match102(
+      graph()->NewNode(a_op, s0, b0));
+  CheckBaseWithIndexAndDisplacement(&match102, b0, 0, s0, NULL);
+
+  // (D15 + S0) -> [NULL, 0, s0, d15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match103(
+      graph()->NewNode(a_op, d15, s0));
+  CheckBaseWithIndexAndDisplacement(&match103, NULL, 0, s0, d15);
+
+  // (S0 + D15) -> [NULL, 0, s0, d15]
+  s0 = graph()->NewNode(s_op, p1, d0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s0);
+  BaseWithIndexAndDisplacement64Matcher match104(
+      graph()->NewNode(a_op, s0, d15));
+  CheckBaseWithIndexAndDisplacement(&match104, NULL, 0, s0, d15);
+
+  // (B0 + M2) -> [b0, 0, m2, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match105(
+      graph()->NewNode(a_op, b0, m2));
+  CheckBaseWithIndexAndDisplacement(&match105, b0, 0, m2, NULL);
+
+  // (M2 + B0) -> [b0, 0, m2, NULL]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match106(
+      graph()->NewNode(a_op, m2, b0));
+  CheckBaseWithIndexAndDisplacement(&match106, b0, 0, m2, NULL);
+
+  // (D15 + M2) -> [NULL, 0, m2, d15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match107(
+      graph()->NewNode(a_op, d15, m2));
+  CheckBaseWithIndexAndDisplacement(&match107, NULL, 0, m2, d15);
+
+  // (M2 + D15) -> [NULL, 0, m2, d15]
+  m2 = graph()->NewNode(m_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m2);
+  BaseWithIndexAndDisplacement64Matcher match108(
+      graph()->NewNode(a_op, m2, d15));
+  CheckBaseWithIndexAndDisplacement(&match108, NULL, 0, m2, d15);
+
+  // (B0 + S1) -> [b0, 0, s1, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match109(
+      graph()->NewNode(a_op, b0, s1));
+  CheckBaseWithIndexAndDisplacement(&match109, b0, 0, s1, NULL);
+
+  // (S1 + B0) -> [b0, 0, s1, NULL]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match110(
+      graph()->NewNode(a_op, s1, b0));
+  CheckBaseWithIndexAndDisplacement(&match110, b0, 0, s1, NULL);
+
+  // (D15 + S1) -> [NULL, 0, s1, d15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match111(
+      graph()->NewNode(a_op, d15, s1));
+  CheckBaseWithIndexAndDisplacement(&match111, NULL, 0, s1, d15);
+
+  // (S1 + D15) -> [NULL, 0, s1, d15]
+  s1 = graph()->NewNode(s_op, p1, d1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s1);
+  BaseWithIndexAndDisplacement64Matcher match112(
+      graph()->NewNode(a_op, s1, d15));
+  CheckBaseWithIndexAndDisplacement(&match112, NULL, 0, s1, d15);
+
+  // (B0 + M4) -> [b0, 0, m4, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match113(
+      graph()->NewNode(a_op, b0, m4));
+  CheckBaseWithIndexAndDisplacement(&match113, b0, 0, m4, NULL);
+
+  // (M4 + B0) -> [b0, 0, m4, NULL]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match114(
+      graph()->NewNode(a_op, m4, b0));
+  CheckBaseWithIndexAndDisplacement(&match114, b0, 0, m4, NULL);
+
+  // (D15 + M4) -> [NULL, 0, m4, d15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match115(
+      graph()->NewNode(a_op, d15, m4));
+  CheckBaseWithIndexAndDisplacement(&match115, NULL, 0, m4, d15);
+
+  // (M4 + D15) -> [NULL, 0, m4, d15]
+  m4 = graph()->NewNode(m_op, p1, d4);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m4);
+  BaseWithIndexAndDisplacement64Matcher match116(
+      graph()->NewNode(a_op, m4, d15));
+  CheckBaseWithIndexAndDisplacement(&match116, NULL, 0, m4, d15);
+
+  // (B0 + S2) -> [b0, 0, s2, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match117(
+      graph()->NewNode(a_op, b0, s2));
+  CheckBaseWithIndexAndDisplacement(&match117, b0, 0, s2, NULL);
+
+  // (S2 + B0) -> [b0, 0, s2, NULL]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match118(
+      graph()->NewNode(a_op, s2, b0));
+  CheckBaseWithIndexAndDisplacement(&match118, b0, 0, s2, NULL);
+
+  // (D15 + S2) -> [NULL, 0, s2, d15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match119(
+      graph()->NewNode(a_op, d15, s2));
+  CheckBaseWithIndexAndDisplacement(&match119, NULL, 0, s2, d15);
+
+  // (S2 + D15) -> [NULL, 0, s2, d15]
+  s2 = graph()->NewNode(s_op, p1, d2);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s2);
+  BaseWithIndexAndDisplacement64Matcher match120(
+      graph()->NewNode(a_op, s2, d15));
+  CheckBaseWithIndexAndDisplacement(&match120, NULL, 0, s2, d15);
+
+  // (B0 + M8) -> [b0, 0, m8, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match121(
+      graph()->NewNode(a_op, b0, m8));
+  CheckBaseWithIndexAndDisplacement(&match121, b0, 0, m8, NULL);
+
+  // (M8 + B0) -> [b0, 0, m8, NULL]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match122(
+      graph()->NewNode(a_op, m8, b0));
+  CheckBaseWithIndexAndDisplacement(&match122, b0, 0, m8, NULL);
+
+  // (D15 + M8) -> [NULL, 0, m8, d15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match123(
+      graph()->NewNode(a_op, d15, m8));
+  CheckBaseWithIndexAndDisplacement(&match123, NULL, 0, m8, d15);
+
+  // (M8 + D15) -> [NULL, 0, m8, d15]
+  m8 = graph()->NewNode(m_op, p1, d8);
+  ADD_NONE_ADDRESSING_OPERAND_USES(m8);
+  BaseWithIndexAndDisplacement64Matcher match124(
+      graph()->NewNode(a_op, m8, d15));
+  CheckBaseWithIndexAndDisplacement(&match124, NULL, 0, m8, d15);
+
+  // (B0 + S3) -> [b0, 0, s3, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match125(
+      graph()->NewNode(a_op, b0, s3));
+  CheckBaseWithIndexAndDisplacement(&match125, b0, 0, s3, NULL);
+
+  // (S3 + B0) -> [b0, 0, s3, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match126(
+      graph()->NewNode(a_op, s3, b0));
+  CheckBaseWithIndexAndDisplacement(&match126, b0, 0, s3, NULL);
+
+  // (D15 + S3) -> [NULL, 0, s3, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match127(
+      graph()->NewNode(a_op, d15, s3));
+  CheckBaseWithIndexAndDisplacement(&match127, NULL, 0, s3, d15);
+
+  // (S3 + D15) -> [NULL, 0, s3, d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(s3);
+  BaseWithIndexAndDisplacement64Matcher match128(
+      graph()->NewNode(a_op, s3, d15));
+  CheckBaseWithIndexAndDisplacement(&match128, NULL, 0, s3, d15);
+
+  // (D15 + S3) + B0 -> [b0, 0, (D15 + S3), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match129(
+      graph()->NewNode(a_op, temp, b0));
+  CheckBaseWithIndexAndDisplacement(&match129, b0, 0, temp, NULL);
+
+  // (B0 + D15) + S3 -> [p1, 3, (B0 + D15), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match130(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match130, p1, 3, temp, NULL);
+
+  // (S3 + B0) + D15 -> [NULL, 0, (S3 + B0), d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match131(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match131, NULL, 0, temp, d15);
+
+  // D15 + (S3 + B0) -> [NULL, 0, (S3 + B0), d15]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, s3, b0);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match132(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match132, NULL, 0, temp, d15);
+
+  // B0 + (D15 + S3) -> [b0, 0, (D15 + S3), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, d15, s3);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match133(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match133, b0, 0, temp, NULL);
+
+  // S3 + (B0 + D15) -> [p1, 3, (B0 + D15), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(a_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match134(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match134, p1, 3, temp, NULL);
+
+  // S3 + (B0 - D15) -> [p1, 3, (B0 - D15), NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match135(
+      graph()->NewNode(a_op, s3, temp));
+  CheckBaseWithIndexAndDisplacement(&match135, p1, 3, temp, NULL);
+
+  // B0 + (B1 - D15) -> [b0, 0, (B1 - D15), NULL]
+  temp = graph()->NewNode(sub_op, b1, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match136(
+      graph()->NewNode(a_op, b0, temp));
+  CheckBaseWithIndexAndDisplacement(&match136, b0, 0, temp, NULL);
+
+  // (B0 - D15) + S3 -> [p1, 3, temp, NULL]
+  s3 = graph()->NewNode(s_op, p1, d3);
+  temp = graph()->NewNode(sub_op, b0, d15);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match137(
+      graph()->NewNode(a_op, temp, s3));
+  CheckBaseWithIndexAndDisplacement(&match137, p1, 3, temp, NULL);
+
+  // (B0 + B1) + D15 -> [NULL, 0, (B0 + B1), d15]
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match138(
+      graph()->NewNode(a_op, temp, d15));
+  CheckBaseWithIndexAndDisplacement(&match138, NULL, 0, temp, d15);
+
+  // D15 + (B0 + B1) -> [NULL, 0, (B0 + B1), d15]
+  temp = graph()->NewNode(a_op, b0, b1);
+  ADD_NONE_ADDRESSING_OPERAND_USES(temp);
+  BaseWithIndexAndDisplacement64Matcher match139(
+      graph()->NewNode(a_op, d15, temp));
+  CheckBaseWithIndexAndDisplacement(&match139, NULL, 0, temp, d15);
 }
 
 TEST_F(NodeMatcherTest, BranchMatcher_match) {