Line data Source code
1 : // Copyright 2014 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/compiler/common-operator.h"
6 : #include "src/compiler/graph.h"
7 : #include "src/compiler/machine-operator.h"
8 : #include "src/compiler/node.h"
9 : #include "src/compiler/node-matchers.h"
10 : #include "src/compiler/opcodes.h"
11 :
12 : #include "test/unittests/compiler/graph-unittest.h"
13 : #include "test/unittests/test-utils.h"
14 :
15 : namespace v8 {
16 : namespace internal {
17 : namespace compiler {
18 :
19 : class NodeMatcherTest : public GraphTest {
20 : public:
21 12 : NodeMatcherTest() : machine_(zone()) {}
22 6 : ~NodeMatcherTest() override = default;
23 :
24 2 : MachineOperatorBuilder* machine() { return &machine_; }
25 :
26 : private:
27 : MachineOperatorBuilder machine_;
28 : };
29 :
30 : namespace {
31 :
32 : template <class Matcher>
33 272 : void CheckBaseWithIndexAndDisplacement(
34 : Matcher* matcher, Node* index, int scale, Node* base, Node* displacement,
35 : DisplacementMode displacement_mode = kPositiveDisplacement) {
36 272 : EXPECT_TRUE(matcher->matches());
37 544 : EXPECT_EQ(index, matcher->index());
38 544 : EXPECT_EQ(scale, matcher->scale());
39 544 : EXPECT_EQ(base, matcher->base());
40 544 : EXPECT_EQ(displacement, matcher->displacement());
41 544 : EXPECT_EQ(displacement_mode, matcher->displacement_mode());
42 272 : }
43 :
44 : } // namespace
45 :
46 : #define ADD_ADDRESSING_OPERAND_USES(node) \
47 : graph()->NewNode(machine()->Load(MachineType::Int32()), node, d0, \
48 : graph()->start(), graph()->start()); \
49 : graph()->NewNode(machine()->Store(rep), node, d0, d0, graph()->start(), \
50 : graph()->start()); \
51 : graph()->NewNode(machine()->Int32Add(), node, d0); \
52 : graph()->NewNode(machine()->Int64Add(), node, d0);
53 :
54 : #define ADD_NONE_ADDRESSING_OPERAND_USES(node) \
55 : graph()->NewNode(machine()->Store(rep), b0, d0, node, graph()->start(), \
56 : graph()->start());
57 :
58 15419 : TEST_F(NodeMatcherTest, ScaledWithOffset32Matcher) {
59 1 : graph()->SetStart(graph()->NewNode(common()->Start(0)));
60 :
61 1 : const Operator* d0_op = common()->Int32Constant(0);
62 : Node* d0 = graph()->NewNode(d0_op);
63 : USE(d0);
64 1 : const Operator* d1_op = common()->Int32Constant(1);
65 : Node* d1 = graph()->NewNode(d1_op);
66 : USE(d1);
67 1 : const Operator* d2_op = common()->Int32Constant(2);
68 : Node* d2 = graph()->NewNode(d2_op);
69 : USE(d2);
70 1 : const Operator* d3_op = common()->Int32Constant(3);
71 : Node* d3 = graph()->NewNode(d3_op);
72 : USE(d3);
73 1 : const Operator* d4_op = common()->Int32Constant(4);
74 : Node* d4 = graph()->NewNode(d4_op);
75 : USE(d4);
76 1 : const Operator* d5_op = common()->Int32Constant(5);
77 : Node* d5 = graph()->NewNode(d5_op);
78 : USE(d5);
79 1 : const Operator* d7_op = common()->Int32Constant(7);
80 : Node* d7 = graph()->NewNode(d7_op);
81 : USE(d4);
82 1 : const Operator* d8_op = common()->Int32Constant(8);
83 : Node* d8 = graph()->NewNode(d8_op);
84 : USE(d8);
85 1 : const Operator* d9_op = common()->Int32Constant(9);
86 : Node* d9 = graph()->NewNode(d9_op);
87 : USE(d9);
88 1 : const Operator* d15_op = common()->Int32Constant(15);
89 : Node* d15 = graph()->NewNode(d15_op);
90 : USE(d15);
91 :
92 1 : const Operator* b0_op = common()->Parameter(0);
93 : Node* b0 = graph()->NewNode(b0_op, graph()->start());
94 : USE(b0);
95 1 : const Operator* b1_op = common()->Parameter(1);
96 : Node* b1 = graph()->NewNode(b1_op, graph()->start());
97 : USE(b0);
98 :
99 1 : const Operator* p1_op = common()->Parameter(3);
100 : Node* p1 = graph()->NewNode(p1_op, graph()->start());
101 : USE(p1);
102 :
103 1 : const Operator* a_op = machine()->Int32Add();
104 : USE(a_op);
105 :
106 1 : const Operator* sub_op = machine()->Int32Sub();
107 : USE(sub_op);
108 :
109 1 : const Operator* m_op = machine()->Int32Mul();
110 : Node* m1 = graph()->NewNode(m_op, p1, d1);
111 : Node* m2 = graph()->NewNode(m_op, p1, d2);
112 : Node* m3 = graph()->NewNode(m_op, p1, d3);
113 : Node* m4 = graph()->NewNode(m_op, p1, d4);
114 : Node* m5 = graph()->NewNode(m_op, p1, d5);
115 : Node* m7 = graph()->NewNode(m_op, p1, d7);
116 : Node* m8 = graph()->NewNode(m_op, p1, d8);
117 : Node* m9 = graph()->NewNode(m_op, p1, d9);
118 : USE(m1);
119 : USE(m2);
120 : USE(m3);
121 : USE(m4);
122 : USE(m5);
123 : USE(m7);
124 : USE(m8);
125 : USE(m9);
126 :
127 1 : const Operator* s_op = machine()->Word32Shl();
128 : Node* s0 = graph()->NewNode(s_op, p1, d0);
129 : Node* s1 = graph()->NewNode(s_op, p1, d1);
130 : Node* s2 = graph()->NewNode(s_op, p1, d2);
131 : Node* s3 = graph()->NewNode(s_op, p1, d3);
132 : Node* s4 = graph()->NewNode(s_op, p1, d4);
133 : USE(s0);
134 : USE(s1);
135 : USE(s2);
136 : USE(s3);
137 : USE(s4);
138 :
139 : const StoreRepresentation rep(MachineRepresentation::kWord32,
140 : kNoWriteBarrier);
141 : USE(rep);
142 :
143 : // 1 INPUT
144 :
145 : // Only relevant test dases is Checking for non-match.
146 1 : BaseWithIndexAndDisplacement32Matcher match0(d15);
147 2 : EXPECT_FALSE(match0.matches());
148 :
149 : // 2 INPUT
150 :
151 : // (B0 + B1) -> [B0, 0, B1, NULL]
152 1 : BaseWithIndexAndDisplacement32Matcher match1(graph()->NewNode(a_op, b0, b1));
153 1 : CheckBaseWithIndexAndDisplacement(&match1, b1, 0, b0, nullptr);
154 :
155 : // (B0 + D15) -> [NULL, 0, B0, D15]
156 1 : BaseWithIndexAndDisplacement32Matcher match2(graph()->NewNode(a_op, b0, d15));
157 1 : CheckBaseWithIndexAndDisplacement(&match2, nullptr, 0, b0, d15);
158 :
159 : // (D15 + B0) -> [NULL, 0, B0, D15]
160 1 : BaseWithIndexAndDisplacement32Matcher match3(graph()->NewNode(a_op, d15, b0));
161 1 : CheckBaseWithIndexAndDisplacement(&match3, nullptr, 0, b0, d15);
162 :
163 : // (B0 + M1) -> [p1, 0, B0, NULL]
164 1 : BaseWithIndexAndDisplacement32Matcher match4(graph()->NewNode(a_op, b0, m1));
165 1 : CheckBaseWithIndexAndDisplacement(&match4, p1, 0, b0, nullptr);
166 :
167 : // (M1 + B0) -> [p1, 0, B0, NULL]
168 : m1 = graph()->NewNode(m_op, p1, d1);
169 1 : BaseWithIndexAndDisplacement32Matcher match5(graph()->NewNode(a_op, m1, b0));
170 1 : CheckBaseWithIndexAndDisplacement(&match5, p1, 0, b0, nullptr);
171 :
172 : // (D15 + M1) -> [P1, 0, NULL, D15]
173 : m1 = graph()->NewNode(m_op, p1, d1);
174 1 : BaseWithIndexAndDisplacement32Matcher match6(graph()->NewNode(a_op, d15, m1));
175 1 : CheckBaseWithIndexAndDisplacement(&match6, p1, 0, nullptr, d15);
176 :
177 : // (M1 + D15) -> [P1, 0, NULL, D15]
178 : m1 = graph()->NewNode(m_op, p1, d1);
179 1 : BaseWithIndexAndDisplacement32Matcher match7(graph()->NewNode(a_op, m1, d15));
180 1 : CheckBaseWithIndexAndDisplacement(&match7, p1, 0, nullptr, d15);
181 :
182 : // (B0 + S0) -> [p1, 0, B0, NULL]
183 1 : BaseWithIndexAndDisplacement32Matcher match8(graph()->NewNode(a_op, b0, s0));
184 1 : CheckBaseWithIndexAndDisplacement(&match8, p1, 0, b0, nullptr);
185 :
186 : // (S0 + B0) -> [p1, 0, B0, NULL]
187 : s0 = graph()->NewNode(s_op, p1, d0);
188 1 : BaseWithIndexAndDisplacement32Matcher match9(graph()->NewNode(a_op, s0, b0));
189 1 : CheckBaseWithIndexAndDisplacement(&match9, p1, 0, b0, nullptr);
190 :
191 : // (D15 + S0) -> [P1, 0, NULL, D15]
192 : s0 = graph()->NewNode(s_op, p1, d0);
193 : BaseWithIndexAndDisplacement32Matcher match10(
194 1 : graph()->NewNode(a_op, d15, s0));
195 1 : CheckBaseWithIndexAndDisplacement(&match10, p1, 0, nullptr, d15);
196 :
197 : // (S0 + D15) -> [P1, 0, NULL, D15]
198 : s0 = graph()->NewNode(s_op, p1, d0);
199 : BaseWithIndexAndDisplacement32Matcher match11(
200 1 : graph()->NewNode(a_op, s0, d15));
201 1 : CheckBaseWithIndexAndDisplacement(&match11, p1, 0, nullptr, d15);
202 :
203 : // (B0 + M2) -> [p1, 1, B0, NULL]
204 1 : BaseWithIndexAndDisplacement32Matcher match12(graph()->NewNode(a_op, b0, m2));
205 1 : CheckBaseWithIndexAndDisplacement(&match12, p1, 1, b0, nullptr);
206 :
207 : // (M2 + B0) -> [p1, 1, B0, NULL]
208 : m2 = graph()->NewNode(m_op, p1, d2);
209 1 : BaseWithIndexAndDisplacement32Matcher match13(graph()->NewNode(a_op, m2, b0));
210 1 : CheckBaseWithIndexAndDisplacement(&match13, p1, 1, b0, nullptr);
211 :
212 : // (D15 + M2) -> [P1, 1, NULL, D15]
213 : m2 = graph()->NewNode(m_op, p1, d2);
214 : BaseWithIndexAndDisplacement32Matcher match14(
215 1 : graph()->NewNode(a_op, d15, m2));
216 1 : CheckBaseWithIndexAndDisplacement(&match14, p1, 1, nullptr, d15);
217 :
218 : // (M2 + D15) -> [P1, 1, NULL, D15]
219 : m2 = graph()->NewNode(m_op, p1, d2);
220 : BaseWithIndexAndDisplacement32Matcher match15(
221 1 : graph()->NewNode(a_op, m2, d15));
222 1 : CheckBaseWithIndexAndDisplacement(&match15, p1, 1, nullptr, d15);
223 :
224 : // (B0 + S1) -> [p1, 1, B0, NULL]
225 1 : BaseWithIndexAndDisplacement32Matcher match16(graph()->NewNode(a_op, b0, s1));
226 1 : CheckBaseWithIndexAndDisplacement(&match16, p1, 1, b0, nullptr);
227 :
228 : // (S1 + B0) -> [p1, 1, B0, NULL]
229 : s1 = graph()->NewNode(s_op, p1, d1);
230 1 : BaseWithIndexAndDisplacement32Matcher match17(graph()->NewNode(a_op, s1, b0));
231 1 : CheckBaseWithIndexAndDisplacement(&match17, p1, 1, b0, nullptr);
232 :
233 : // (D15 + S1) -> [P1, 1, NULL, D15]
234 : s1 = graph()->NewNode(s_op, p1, d1);
235 : BaseWithIndexAndDisplacement32Matcher match18(
236 1 : graph()->NewNode(a_op, d15, s1));
237 1 : CheckBaseWithIndexAndDisplacement(&match18, p1, 1, nullptr, d15);
238 :
239 : // (S1 + D15) -> [P1, 1, NULL, D15]
240 : s1 = graph()->NewNode(s_op, p1, d1);
241 : BaseWithIndexAndDisplacement32Matcher match19(
242 1 : graph()->NewNode(a_op, s1, d15));
243 1 : CheckBaseWithIndexAndDisplacement(&match19, p1, 1, nullptr, d15);
244 :
245 : // (B0 + M4) -> [p1, 2, B0, NULL]
246 1 : BaseWithIndexAndDisplacement32Matcher match20(graph()->NewNode(a_op, b0, m4));
247 1 : CheckBaseWithIndexAndDisplacement(&match20, p1, 2, b0, nullptr);
248 :
249 : // (M4 + B0) -> [p1, 2, B0, NULL]
250 : m4 = graph()->NewNode(m_op, p1, d4);
251 1 : BaseWithIndexAndDisplacement32Matcher match21(graph()->NewNode(a_op, m4, b0));
252 1 : CheckBaseWithIndexAndDisplacement(&match21, p1, 2, b0, nullptr);
253 :
254 : // (D15 + M4) -> [p1, 2, NULL, D15]
255 : m4 = graph()->NewNode(m_op, p1, d4);
256 : BaseWithIndexAndDisplacement32Matcher match22(
257 1 : graph()->NewNode(a_op, d15, m4));
258 1 : CheckBaseWithIndexAndDisplacement(&match22, p1, 2, nullptr, d15);
259 :
260 : // (M4 + D15) -> [p1, 2, NULL, D15]
261 : m4 = graph()->NewNode(m_op, p1, d4);
262 : BaseWithIndexAndDisplacement32Matcher match23(
263 1 : graph()->NewNode(a_op, m4, d15));
264 1 : CheckBaseWithIndexAndDisplacement(&match23, p1, 2, nullptr, d15);
265 :
266 : // (B0 + S2) -> [p1, 2, B0, NULL]
267 1 : BaseWithIndexAndDisplacement32Matcher match24(graph()->NewNode(a_op, b0, s2));
268 1 : CheckBaseWithIndexAndDisplacement(&match24, p1, 2, b0, nullptr);
269 :
270 : // (S2 + B0) -> [p1, 2, B0, NULL]
271 : s2 = graph()->NewNode(s_op, p1, d2);
272 1 : BaseWithIndexAndDisplacement32Matcher match25(graph()->NewNode(a_op, s2, b0));
273 1 : CheckBaseWithIndexAndDisplacement(&match25, p1, 2, b0, nullptr);
274 :
275 : // (D15 + S2) -> [p1, 2, NULL, D15]
276 : s2 = graph()->NewNode(s_op, p1, d2);
277 : BaseWithIndexAndDisplacement32Matcher match26(
278 1 : graph()->NewNode(a_op, d15, s2));
279 1 : CheckBaseWithIndexAndDisplacement(&match26, p1, 2, nullptr, d15);
280 :
281 : // (S2 + D15) -> [p1, 2, NULL, D15]
282 : s2 = graph()->NewNode(s_op, p1, d2);
283 : BaseWithIndexAndDisplacement32Matcher match27(
284 1 : graph()->NewNode(a_op, s2, d15));
285 1 : CheckBaseWithIndexAndDisplacement(&match27, p1, 2, nullptr, d15);
286 :
287 : // (B0 + M8) -> [p1, 2, B0, NULL]
288 1 : BaseWithIndexAndDisplacement32Matcher match28(graph()->NewNode(a_op, b0, m8));
289 1 : CheckBaseWithIndexAndDisplacement(&match28, p1, 3, b0, nullptr);
290 :
291 : // (M8 + B0) -> [p1, 2, B0, NULL]
292 : m8 = graph()->NewNode(m_op, p1, d8);
293 1 : BaseWithIndexAndDisplacement32Matcher match29(graph()->NewNode(a_op, m8, b0));
294 1 : CheckBaseWithIndexAndDisplacement(&match29, p1, 3, b0, nullptr);
295 :
296 : // (D15 + M8) -> [p1, 2, NULL, D15]
297 : m8 = graph()->NewNode(m_op, p1, d8);
298 : BaseWithIndexAndDisplacement32Matcher match30(
299 1 : graph()->NewNode(a_op, d15, m8));
300 1 : CheckBaseWithIndexAndDisplacement(&match30, p1, 3, nullptr, d15);
301 :
302 : // (M8 + D15) -> [p1, 2, NULL, D15]
303 : m8 = graph()->NewNode(m_op, p1, d8);
304 : BaseWithIndexAndDisplacement32Matcher match31(
305 1 : graph()->NewNode(a_op, m8, d15));
306 1 : CheckBaseWithIndexAndDisplacement(&match31, p1, 3, nullptr, d15);
307 :
308 : // (B0 + S3) -> [p1, 2, B0, NULL]
309 1 : BaseWithIndexAndDisplacement32Matcher match32(graph()->NewNode(a_op, b0, s3));
310 1 : CheckBaseWithIndexAndDisplacement(&match32, p1, 3, b0, nullptr);
311 :
312 : // (S3 + B0) -> [p1, 2, B0, NULL]
313 : s3 = graph()->NewNode(s_op, p1, d3);
314 1 : BaseWithIndexAndDisplacement32Matcher match33(graph()->NewNode(a_op, s3, b0));
315 1 : CheckBaseWithIndexAndDisplacement(&match33, p1, 3, b0, nullptr);
316 :
317 : // (D15 + S3) -> [p1, 2, NULL, D15]
318 : s3 = graph()->NewNode(s_op, p1, d3);
319 : BaseWithIndexAndDisplacement32Matcher match34(
320 1 : graph()->NewNode(a_op, d15, s3));
321 1 : CheckBaseWithIndexAndDisplacement(&match34, p1, 3, nullptr, d15);
322 :
323 : // (S3 + D15) -> [p1, 2, NULL, D15]
324 : s3 = graph()->NewNode(s_op, p1, d3);
325 : BaseWithIndexAndDisplacement32Matcher match35(
326 1 : graph()->NewNode(a_op, s3, d15));
327 1 : CheckBaseWithIndexAndDisplacement(&match35, p1, 3, nullptr, d15);
328 :
329 : // 2 INPUT - NEGATIVE CASES
330 :
331 : // (M3 + B1) -> [B0, 0, M3, NULL]
332 1 : BaseWithIndexAndDisplacement32Matcher match36(graph()->NewNode(a_op, b1, m3));
333 1 : CheckBaseWithIndexAndDisplacement(&match36, m3, 0, b1, nullptr);
334 :
335 : // (S4 + B1) -> [B0, 0, S4, NULL]
336 1 : BaseWithIndexAndDisplacement32Matcher match37(graph()->NewNode(a_op, b1, s4));
337 1 : CheckBaseWithIndexAndDisplacement(&match37, s4, 0, b1, nullptr);
338 :
339 : // 3 INPUT
340 :
341 : // (D15 + S3) + B0 -> [p1, 2, b0, d15]
342 : s3 = graph()->NewNode(s_op, p1, d3);
343 : BaseWithIndexAndDisplacement32Matcher match38(
344 1 : graph()->NewNode(a_op, graph()->NewNode(a_op, d15, s3), b0));
345 1 : CheckBaseWithIndexAndDisplacement(&match38, p1, 3, b0, d15);
346 :
347 : // (B0 + D15) + S3 -> [p1, 2, b0, d15]
348 : s3 = graph()->NewNode(s_op, p1, d3);
349 : BaseWithIndexAndDisplacement32Matcher match39(
350 1 : graph()->NewNode(a_op, graph()->NewNode(a_op, b0, d15), s3));
351 1 : CheckBaseWithIndexAndDisplacement(&match39, p1, 3, b0, d15);
352 :
353 : // (S3 + B0) + D15 -> [p1, 2, b0, d15]
354 : s3 = graph()->NewNode(s_op, p1, d3);
355 : BaseWithIndexAndDisplacement32Matcher match40(
356 1 : graph()->NewNode(a_op, graph()->NewNode(a_op, s3, b0), d15));
357 1 : CheckBaseWithIndexAndDisplacement(&match40, p1, 3, b0, d15);
358 :
359 : // D15 + (S3 + B0) -> [p1, 2, b0, d15]
360 : s3 = graph()->NewNode(s_op, p1, d3);
361 : BaseWithIndexAndDisplacement32Matcher match41(
362 1 : graph()->NewNode(a_op, d15, graph()->NewNode(a_op, s3, b0)));
363 1 : CheckBaseWithIndexAndDisplacement(&match41, p1, 3, b0, d15);
364 :
365 : // B0 + (D15 + S3) -> [p1, 2, b0, d15]
366 : s3 = graph()->NewNode(s_op, p1, d3);
367 : BaseWithIndexAndDisplacement32Matcher match42(
368 1 : graph()->NewNode(a_op, b0, graph()->NewNode(a_op, d15, s3)));
369 1 : CheckBaseWithIndexAndDisplacement(&match42, p1, 3, b0, d15);
370 :
371 : // S3 + (B0 + D15) -> [p1, 2, b0, d15]
372 : s3 = graph()->NewNode(s_op, p1, d3);
373 : BaseWithIndexAndDisplacement32Matcher match43(
374 1 : graph()->NewNode(a_op, s3, graph()->NewNode(a_op, b0, d15)));
375 1 : CheckBaseWithIndexAndDisplacement(&match43, p1, 3, b0, d15);
376 :
377 : // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
378 : s3 = graph()->NewNode(s_op, p1, d3);
379 : BaseWithIndexAndDisplacement32Matcher match44(
380 1 : graph()->NewNode(a_op, s3, graph()->NewNode(sub_op, b0, d15)));
381 : CheckBaseWithIndexAndDisplacement(&match44, p1, 3, b0, d15,
382 1 : kNegativeDisplacement);
383 :
384 : // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
385 : BaseWithIndexAndDisplacement32Matcher match45(
386 1 : graph()->NewNode(a_op, b0, graph()->NewNode(sub_op, b1, d15)));
387 : CheckBaseWithIndexAndDisplacement(&match45, b1, 0, b0, d15,
388 1 : kNegativeDisplacement);
389 :
390 : // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
391 : s3 = graph()->NewNode(s_op, p1, d3);
392 : BaseWithIndexAndDisplacement32Matcher match46(
393 1 : graph()->NewNode(a_op, graph()->NewNode(sub_op, b0, d15), s3));
394 : CheckBaseWithIndexAndDisplacement(&match46, p1, 3, b0, d15,
395 1 : kNegativeDisplacement);
396 :
397 : // 4 INPUT - with addressing operand uses
398 :
399 : // (B0 + M1) -> [p1, 0, B0, NULL]
400 : m1 = graph()->NewNode(m_op, p1, d1);
401 4 : ADD_ADDRESSING_OPERAND_USES(m1);
402 1 : BaseWithIndexAndDisplacement32Matcher match47(graph()->NewNode(a_op, b0, m1));
403 1 : CheckBaseWithIndexAndDisplacement(&match47, p1, 0, b0, nullptr);
404 :
405 : // (M1 + B0) -> [p1, 0, B0, NULL]
406 : m1 = graph()->NewNode(m_op, p1, d1);
407 4 : ADD_ADDRESSING_OPERAND_USES(m1);
408 1 : BaseWithIndexAndDisplacement32Matcher match48(graph()->NewNode(a_op, m1, b0));
409 1 : CheckBaseWithIndexAndDisplacement(&match48, p1, 0, b0, nullptr);
410 :
411 : // (D15 + M1) -> [P1, 0, NULL, D15]
412 : m1 = graph()->NewNode(m_op, p1, d1);
413 4 : ADD_ADDRESSING_OPERAND_USES(m1);
414 : BaseWithIndexAndDisplacement32Matcher match49(
415 1 : graph()->NewNode(a_op, d15, m1));
416 1 : CheckBaseWithIndexAndDisplacement(&match49, p1, 0, nullptr, d15);
417 :
418 : // (M1 + D15) -> [P1, 0, NULL, D15]
419 : m1 = graph()->NewNode(m_op, p1, d1);
420 4 : ADD_ADDRESSING_OPERAND_USES(m1);
421 : BaseWithIndexAndDisplacement32Matcher match50(
422 1 : graph()->NewNode(a_op, m1, d15));
423 1 : CheckBaseWithIndexAndDisplacement(&match50, p1, 0, nullptr, d15);
424 :
425 : // (B0 + S0) -> [p1, 0, B0, NULL]
426 : s0 = graph()->NewNode(s_op, p1, d0);
427 4 : ADD_ADDRESSING_OPERAND_USES(s0);
428 1 : BaseWithIndexAndDisplacement32Matcher match51(graph()->NewNode(a_op, b0, s0));
429 1 : CheckBaseWithIndexAndDisplacement(&match51, p1, 0, b0, nullptr);
430 :
431 : // (S0 + B0) -> [p1, 0, B0, NULL]
432 : s0 = graph()->NewNode(s_op, p1, d0);
433 4 : ADD_ADDRESSING_OPERAND_USES(s0);
434 1 : BaseWithIndexAndDisplacement32Matcher match52(graph()->NewNode(a_op, s0, b0));
435 1 : CheckBaseWithIndexAndDisplacement(&match52, p1, 0, b0, nullptr);
436 :
437 : // (D15 + S0) -> [P1, 0, NULL, D15]
438 : s0 = graph()->NewNode(s_op, p1, d0);
439 4 : ADD_ADDRESSING_OPERAND_USES(s0);
440 : BaseWithIndexAndDisplacement32Matcher match53(
441 1 : graph()->NewNode(a_op, d15, s0));
442 1 : CheckBaseWithIndexAndDisplacement(&match53, p1, 0, nullptr, d15);
443 :
444 : // (S0 + D15) -> [P1, 0, NULL, D15]
445 : s0 = graph()->NewNode(s_op, p1, d0);
446 4 : ADD_ADDRESSING_OPERAND_USES(s0);
447 : BaseWithIndexAndDisplacement32Matcher match54(
448 1 : graph()->NewNode(a_op, s0, d15));
449 1 : CheckBaseWithIndexAndDisplacement(&match54, p1, 0, nullptr, d15);
450 :
451 : // (B0 + M2) -> [p1, 1, B0, NULL]
452 : m2 = graph()->NewNode(m_op, p1, d2);
453 4 : ADD_ADDRESSING_OPERAND_USES(m2);
454 1 : BaseWithIndexAndDisplacement32Matcher match55(graph()->NewNode(a_op, b0, m2));
455 1 : CheckBaseWithIndexAndDisplacement(&match55, p1, 1, b0, nullptr);
456 :
457 : // (M2 + B0) -> [p1, 1, B0, NULL]
458 : m2 = graph()->NewNode(m_op, p1, d2);
459 4 : ADD_ADDRESSING_OPERAND_USES(m2);
460 1 : BaseWithIndexAndDisplacement32Matcher match56(graph()->NewNode(a_op, m2, b0));
461 1 : CheckBaseWithIndexAndDisplacement(&match56, p1, 1, b0, nullptr);
462 :
463 : // (D15 + M2) -> [P1, 1, NULL, D15]
464 : m2 = graph()->NewNode(m_op, p1, d2);
465 4 : ADD_ADDRESSING_OPERAND_USES(m2);
466 : BaseWithIndexAndDisplacement32Matcher match57(
467 1 : graph()->NewNode(a_op, d15, m2));
468 1 : CheckBaseWithIndexAndDisplacement(&match57, p1, 1, nullptr, d15);
469 :
470 : // (M2 + D15) -> [P1, 1, NULL, D15]
471 : m2 = graph()->NewNode(m_op, p1, d2);
472 4 : ADD_ADDRESSING_OPERAND_USES(m2);
473 : BaseWithIndexAndDisplacement32Matcher match58(
474 1 : graph()->NewNode(a_op, m2, d15));
475 1 : CheckBaseWithIndexAndDisplacement(&match58, p1, 1, nullptr, d15);
476 :
477 : // (B0 + S1) -> [p1, 1, B0, NULL]
478 : s1 = graph()->NewNode(s_op, p1, d1);
479 4 : ADD_ADDRESSING_OPERAND_USES(s1);
480 1 : BaseWithIndexAndDisplacement32Matcher match59(graph()->NewNode(a_op, b0, s1));
481 1 : CheckBaseWithIndexAndDisplacement(&match59, p1, 1, b0, nullptr);
482 :
483 : // (S1 + B0) -> [p1, 1, B0, NULL]
484 : s1 = graph()->NewNode(s_op, p1, d1);
485 4 : ADD_ADDRESSING_OPERAND_USES(s1);
486 1 : BaseWithIndexAndDisplacement32Matcher match60(graph()->NewNode(a_op, s1, b0));
487 1 : CheckBaseWithIndexAndDisplacement(&match60, p1, 1, b0, nullptr);
488 :
489 : // (D15 + S1) -> [P1, 1, NULL, D15]
490 : s1 = graph()->NewNode(s_op, p1, d1);
491 4 : ADD_ADDRESSING_OPERAND_USES(s1);
492 : BaseWithIndexAndDisplacement32Matcher match61(
493 1 : graph()->NewNode(a_op, d15, s1));
494 1 : CheckBaseWithIndexAndDisplacement(&match61, p1, 1, nullptr, d15);
495 :
496 : // (S1 + D15) -> [P1, 1, NULL, D15]
497 : s1 = graph()->NewNode(s_op, p1, d1);
498 4 : ADD_ADDRESSING_OPERAND_USES(s1);
499 : BaseWithIndexAndDisplacement32Matcher match62(
500 1 : graph()->NewNode(a_op, s1, d15));
501 1 : CheckBaseWithIndexAndDisplacement(&match62, p1, 1, nullptr, d15);
502 :
503 : // (B0 + M4) -> [p1, 2, B0, NULL]
504 : m4 = graph()->NewNode(m_op, p1, d4);
505 4 : ADD_ADDRESSING_OPERAND_USES(m4);
506 1 : BaseWithIndexAndDisplacement32Matcher match63(graph()->NewNode(a_op, b0, m4));
507 1 : CheckBaseWithIndexAndDisplacement(&match63, p1, 2, b0, nullptr);
508 :
509 : // (M4 + B0) -> [p1, 2, B0, NULL]
510 : m4 = graph()->NewNode(m_op, p1, d4);
511 4 : ADD_ADDRESSING_OPERAND_USES(m4);
512 1 : BaseWithIndexAndDisplacement32Matcher match64(graph()->NewNode(a_op, m4, b0));
513 1 : CheckBaseWithIndexAndDisplacement(&match64, p1, 2, b0, nullptr);
514 :
515 : // (D15 + M4) -> [p1, 2, NULL, D15]
516 : m4 = graph()->NewNode(m_op, p1, d4);
517 4 : ADD_ADDRESSING_OPERAND_USES(m4);
518 : BaseWithIndexAndDisplacement32Matcher match65(
519 1 : graph()->NewNode(a_op, d15, m4));
520 1 : CheckBaseWithIndexAndDisplacement(&match65, p1, 2, nullptr, d15);
521 :
522 : // (M4 + D15) -> [p1, 2, NULL, D15]
523 : m4 = graph()->NewNode(m_op, p1, d4);
524 4 : ADD_ADDRESSING_OPERAND_USES(m4);
525 : BaseWithIndexAndDisplacement32Matcher match66(
526 1 : graph()->NewNode(a_op, m4, d15));
527 1 : CheckBaseWithIndexAndDisplacement(&match66, p1, 2, nullptr, d15);
528 :
529 : // (B0 + S2) -> [p1, 2, B0, NULL]
530 : s2 = graph()->NewNode(s_op, p1, d2);
531 4 : ADD_ADDRESSING_OPERAND_USES(s2);
532 1 : BaseWithIndexAndDisplacement32Matcher match67(graph()->NewNode(a_op, b0, s2));
533 1 : CheckBaseWithIndexAndDisplacement(&match67, p1, 2, b0, nullptr);
534 :
535 : // (S2 + B0) -> [p1, 2, B0, NULL]
536 : s2 = graph()->NewNode(s_op, p1, d2);
537 4 : ADD_ADDRESSING_OPERAND_USES(s2);
538 1 : BaseWithIndexAndDisplacement32Matcher match68(graph()->NewNode(a_op, s2, b0));
539 1 : CheckBaseWithIndexAndDisplacement(&match68, p1, 2, b0, nullptr);
540 :
541 : // (D15 + S2) -> [p1, 2, NULL, D15]
542 : s2 = graph()->NewNode(s_op, p1, d2);
543 4 : ADD_ADDRESSING_OPERAND_USES(s2);
544 : BaseWithIndexAndDisplacement32Matcher match69(
545 1 : graph()->NewNode(a_op, d15, s2));
546 1 : CheckBaseWithIndexAndDisplacement(&match69, p1, 2, nullptr, d15);
547 :
548 : // (S2 + D15) -> [p1, 2, NULL, D15]
549 : s2 = graph()->NewNode(s_op, p1, d2);
550 4 : ADD_ADDRESSING_OPERAND_USES(s2);
551 : BaseWithIndexAndDisplacement32Matcher match70(
552 1 : graph()->NewNode(a_op, s2, d15));
553 1 : CheckBaseWithIndexAndDisplacement(&match70, p1, 2, nullptr, d15);
554 :
555 : // (B0 + M8) -> [p1, 2, B0, NULL]
556 : m8 = graph()->NewNode(m_op, p1, d8);
557 4 : ADD_ADDRESSING_OPERAND_USES(m8);
558 1 : BaseWithIndexAndDisplacement32Matcher match71(graph()->NewNode(a_op, b0, m8));
559 1 : CheckBaseWithIndexAndDisplacement(&match71, p1, 3, b0, nullptr);
560 :
561 : // (M8 + B0) -> [p1, 2, B0, NULL]
562 : m8 = graph()->NewNode(m_op, p1, d8);
563 4 : ADD_ADDRESSING_OPERAND_USES(m8);
564 1 : BaseWithIndexAndDisplacement32Matcher match72(graph()->NewNode(a_op, m8, b0));
565 1 : CheckBaseWithIndexAndDisplacement(&match72, p1, 3, b0, nullptr);
566 :
567 : // (D15 + M8) -> [p1, 2, NULL, D15]
568 : m8 = graph()->NewNode(m_op, p1, d8);
569 4 : ADD_ADDRESSING_OPERAND_USES(m8);
570 : BaseWithIndexAndDisplacement32Matcher match73(
571 1 : graph()->NewNode(a_op, d15, m8));
572 1 : CheckBaseWithIndexAndDisplacement(&match73, p1, 3, nullptr, d15);
573 :
574 : // (M8 + D15) -> [p1, 2, NULL, D15]
575 : m8 = graph()->NewNode(m_op, p1, d8);
576 4 : ADD_ADDRESSING_OPERAND_USES(m8);
577 : BaseWithIndexAndDisplacement32Matcher match74(
578 1 : graph()->NewNode(a_op, m8, d15));
579 1 : CheckBaseWithIndexAndDisplacement(&match74, p1, 3, nullptr, d15);
580 :
581 : // (B0 + S3) -> [p1, 2, B0, NULL]
582 : s3 = graph()->NewNode(s_op, p1, d3);
583 4 : ADD_ADDRESSING_OPERAND_USES(s3);
584 1 : BaseWithIndexAndDisplacement32Matcher match75(graph()->NewNode(a_op, b0, s3));
585 1 : CheckBaseWithIndexAndDisplacement(&match75, p1, 3, b0, nullptr);
586 :
587 : // (S3 + B0) -> [p1, 2, B0, NULL]
588 : s3 = graph()->NewNode(s_op, p1, d3);
589 4 : ADD_ADDRESSING_OPERAND_USES(s3);
590 1 : BaseWithIndexAndDisplacement32Matcher match76(graph()->NewNode(a_op, s3, b0));
591 1 : CheckBaseWithIndexAndDisplacement(&match76, p1, 3, b0, nullptr);
592 :
593 : // (D15 + S3) -> [p1, 2, NULL, D15]
594 : s3 = graph()->NewNode(s_op, p1, d3);
595 4 : ADD_ADDRESSING_OPERAND_USES(s3);
596 : BaseWithIndexAndDisplacement32Matcher match77(
597 1 : graph()->NewNode(a_op, d15, s3));
598 1 : CheckBaseWithIndexAndDisplacement(&match77, p1, 3, nullptr, d15);
599 :
600 : // (S3 + D15) -> [p1, 2, NULL, D15]
601 : s3 = graph()->NewNode(s_op, p1, d3);
602 4 : ADD_ADDRESSING_OPERAND_USES(s3);
603 : BaseWithIndexAndDisplacement32Matcher match78(
604 1 : graph()->NewNode(a_op, s3, d15));
605 1 : CheckBaseWithIndexAndDisplacement(&match78, p1, 3, nullptr, d15);
606 :
607 : // (D15 + S3) + B0 -> [p1, 2, b0, d15]
608 : s3 = graph()->NewNode(s_op, p1, d3);
609 : Node* temp = graph()->NewNode(a_op, d15, s3);
610 4 : ADD_ADDRESSING_OPERAND_USES(temp);
611 : BaseWithIndexAndDisplacement32Matcher match79(
612 1 : graph()->NewNode(a_op, temp, b0));
613 1 : CheckBaseWithIndexAndDisplacement(&match79, p1, 3, b0, d15);
614 :
615 : // (B0 + D15) + S3 -> [p1, 2, b0, d15]
616 : s3 = graph()->NewNode(s_op, p1, d3);
617 : temp = graph()->NewNode(a_op, b0, d15);
618 4 : ADD_ADDRESSING_OPERAND_USES(temp);
619 : BaseWithIndexAndDisplacement32Matcher match80(
620 1 : graph()->NewNode(a_op, temp, s3));
621 1 : CheckBaseWithIndexAndDisplacement(&match80, p1, 3, b0, d15);
622 :
623 : // (S3 + B0) + D15 -> [NULL, 0, (s3 + b0), d15]
624 : // Avoid changing simple addressing to complex addressing
625 : s3 = graph()->NewNode(s_op, p1, d3);
626 : temp = graph()->NewNode(a_op, s3, b0);
627 4 : ADD_ADDRESSING_OPERAND_USES(temp);
628 : BaseWithIndexAndDisplacement32Matcher match81(
629 1 : graph()->NewNode(a_op, temp, d15));
630 1 : CheckBaseWithIndexAndDisplacement(&match81, nullptr, 0, temp, d15);
631 :
632 : // D15 + (S3 + B0) -> [NULL, 0, (s3 + b0), d15]
633 : // Avoid changing simple addressing to complex addressing
634 : s3 = graph()->NewNode(s_op, p1, d3);
635 : temp = graph()->NewNode(a_op, s3, b0);
636 4 : ADD_ADDRESSING_OPERAND_USES(temp);
637 : BaseWithIndexAndDisplacement32Matcher match82(
638 1 : graph()->NewNode(a_op, d15, temp));
639 1 : CheckBaseWithIndexAndDisplacement(&match82, nullptr, 0, temp, d15);
640 :
641 : // B0 + (D15 + S3) -> [p1, 2, b0, d15]
642 : s3 = graph()->NewNode(s_op, p1, d3);
643 : temp = graph()->NewNode(a_op, d15, s3);
644 4 : ADD_ADDRESSING_OPERAND_USES(temp);
645 : BaseWithIndexAndDisplacement32Matcher match83(
646 1 : graph()->NewNode(a_op, b0, temp));
647 1 : CheckBaseWithIndexAndDisplacement(&match83, p1, 3, b0, d15);
648 :
649 : // S3 + (B0 + D15) -> [p1, 2, b0, d15]
650 : s3 = graph()->NewNode(s_op, p1, d3);
651 : temp = graph()->NewNode(a_op, b0, d15);
652 4 : ADD_ADDRESSING_OPERAND_USES(temp);
653 : BaseWithIndexAndDisplacement32Matcher match84(
654 1 : graph()->NewNode(a_op, s3, temp));
655 1 : CheckBaseWithIndexAndDisplacement(&match84, p1, 3, b0, d15);
656 :
657 : // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
658 : s3 = graph()->NewNode(s_op, p1, d3);
659 : temp = graph()->NewNode(sub_op, b0, d15);
660 4 : ADD_ADDRESSING_OPERAND_USES(temp);
661 : BaseWithIndexAndDisplacement32Matcher match85(
662 1 : graph()->NewNode(a_op, s3, temp));
663 : CheckBaseWithIndexAndDisplacement(&match85, p1, 3, b0, d15,
664 1 : kNegativeDisplacement);
665 :
666 : // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
667 : temp = graph()->NewNode(sub_op, b1, d15);
668 4 : ADD_ADDRESSING_OPERAND_USES(temp);
669 : BaseWithIndexAndDisplacement32Matcher match86(
670 1 : graph()->NewNode(a_op, b0, temp));
671 : CheckBaseWithIndexAndDisplacement(&match86, b1, 0, b0, d15,
672 1 : kNegativeDisplacement);
673 :
674 : // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
675 : s3 = graph()->NewNode(s_op, p1, d3);
676 : temp = graph()->NewNode(sub_op, b0, d15);
677 4 : ADD_ADDRESSING_OPERAND_USES(temp);
678 : BaseWithIndexAndDisplacement32Matcher match87(
679 1 : graph()->NewNode(a_op, temp, s3));
680 : CheckBaseWithIndexAndDisplacement(&match87, p1, 3, b0, d15,
681 1 : kNegativeDisplacement);
682 :
683 : // (B0 + B1) + D15 -> [NULL, 0, (b0 + b1), d15]
684 : // Avoid changing simple addressing to complex addressing
685 : temp = graph()->NewNode(a_op, b0, b1);
686 4 : ADD_ADDRESSING_OPERAND_USES(temp);
687 : BaseWithIndexAndDisplacement32Matcher match88(
688 1 : graph()->NewNode(a_op, temp, d15));
689 1 : CheckBaseWithIndexAndDisplacement(&match88, nullptr, 0, temp, d15);
690 :
691 : // D15 + (B0 + B1) -> [NULL, 0, (b0 + b1), d15]
692 : // Avoid changing simple addressing to complex addressing
693 : temp = graph()->NewNode(a_op, b0, b1);
694 4 : ADD_ADDRESSING_OPERAND_USES(temp);
695 : BaseWithIndexAndDisplacement32Matcher match89(
696 1 : graph()->NewNode(a_op, d15, temp));
697 1 : CheckBaseWithIndexAndDisplacement(&match89, nullptr, 0, temp, d15);
698 :
699 : // 5 INPUT - with none-addressing operand uses
700 :
701 : // (B0 + M1) -> [b0, 0, m1, NULL]
702 : m1 = graph()->NewNode(m_op, p1, d1);
703 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
704 1 : BaseWithIndexAndDisplacement32Matcher match90(graph()->NewNode(a_op, b0, m1));
705 1 : CheckBaseWithIndexAndDisplacement(&match90, b0, 0, m1, nullptr);
706 :
707 : // (M1 + B0) -> [b0, 0, m1, NULL]
708 : m1 = graph()->NewNode(m_op, p1, d1);
709 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
710 1 : BaseWithIndexAndDisplacement32Matcher match91(graph()->NewNode(a_op, m1, b0));
711 1 : CheckBaseWithIndexAndDisplacement(&match91, b0, 0, m1, nullptr);
712 :
713 : // (D15 + M1) -> [NULL, 0, m1, d15]
714 : m1 = graph()->NewNode(m_op, p1, d1);
715 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
716 : BaseWithIndexAndDisplacement32Matcher match92(
717 1 : graph()->NewNode(a_op, d15, m1));
718 1 : CheckBaseWithIndexAndDisplacement(&match92, nullptr, 0, m1, d15);
719 :
720 : // (M1 + D15) -> [NULL, 0, m1, d15]
721 : m1 = graph()->NewNode(m_op, p1, d1);
722 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
723 : BaseWithIndexAndDisplacement32Matcher match93(
724 1 : graph()->NewNode(a_op, m1, d15));
725 1 : CheckBaseWithIndexAndDisplacement(&match93, nullptr, 0, m1, d15);
726 :
727 : // (B0 + S0) -> [b0, 0, s0, NULL]
728 : s0 = graph()->NewNode(s_op, p1, d0);
729 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
730 1 : BaseWithIndexAndDisplacement32Matcher match94(graph()->NewNode(a_op, b0, s0));
731 1 : CheckBaseWithIndexAndDisplacement(&match94, b0, 0, s0, nullptr);
732 :
733 : // (S0 + B0) -> [b0, 0, s0, NULL]
734 : s0 = graph()->NewNode(s_op, p1, d0);
735 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
736 1 : BaseWithIndexAndDisplacement32Matcher match95(graph()->NewNode(a_op, s0, b0));
737 1 : CheckBaseWithIndexAndDisplacement(&match95, b0, 0, s0, nullptr);
738 :
739 : // (D15 + S0) -> [NULL, 0, s0, d15]
740 : s0 = graph()->NewNode(s_op, p1, d0);
741 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
742 : BaseWithIndexAndDisplacement32Matcher match96(
743 1 : graph()->NewNode(a_op, d15, s0));
744 1 : CheckBaseWithIndexAndDisplacement(&match96, nullptr, 0, s0, d15);
745 :
746 : // (S0 + D15) -> [NULL, 0, s0, d15]
747 : s0 = graph()->NewNode(s_op, p1, d0);
748 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
749 : BaseWithIndexAndDisplacement32Matcher match97(
750 1 : graph()->NewNode(a_op, s0, d15));
751 1 : CheckBaseWithIndexAndDisplacement(&match97, nullptr, 0, s0, d15);
752 :
753 : // (B0 + M2) -> [b0, 0, m2, NULL]
754 : m2 = graph()->NewNode(m_op, p1, d2);
755 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
756 1 : BaseWithIndexAndDisplacement32Matcher match98(graph()->NewNode(a_op, b0, m2));
757 1 : CheckBaseWithIndexAndDisplacement(&match98, b0, 0, m2, nullptr);
758 :
759 : // (M2 + B0) -> [b0, 0, m2, NULL]
760 : m2 = graph()->NewNode(m_op, p1, d2);
761 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
762 1 : BaseWithIndexAndDisplacement32Matcher match99(graph()->NewNode(a_op, m2, b0));
763 1 : CheckBaseWithIndexAndDisplacement(&match99, b0, 0, m2, nullptr);
764 :
765 : // (D15 + M2) -> [NULL, 0, m2, d15]
766 : m2 = graph()->NewNode(m_op, p1, d2);
767 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
768 : BaseWithIndexAndDisplacement32Matcher match100(
769 1 : graph()->NewNode(a_op, d15, m2));
770 1 : CheckBaseWithIndexAndDisplacement(&match100, nullptr, 0, m2, d15);
771 :
772 : // (M2 + D15) -> [NULL, 0, m2, d15]
773 : m2 = graph()->NewNode(m_op, p1, d2);
774 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
775 : BaseWithIndexAndDisplacement32Matcher match101(
776 1 : graph()->NewNode(a_op, m2, d15));
777 1 : CheckBaseWithIndexAndDisplacement(&match101, nullptr, 0, m2, d15);
778 :
779 : // (B0 + S1) -> [b0, 0, s1, NULL]
780 : s1 = graph()->NewNode(s_op, p1, d1);
781 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
782 : BaseWithIndexAndDisplacement32Matcher match102(
783 1 : graph()->NewNode(a_op, b0, s1));
784 1 : CheckBaseWithIndexAndDisplacement(&match102, b0, 0, s1, nullptr);
785 :
786 : // (S1 + B0) -> [b0, 0, s1, NULL]
787 : s1 = graph()->NewNode(s_op, p1, d1);
788 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
789 : BaseWithIndexAndDisplacement32Matcher match103(
790 1 : graph()->NewNode(a_op, s1, b0));
791 1 : CheckBaseWithIndexAndDisplacement(&match103, b0, 0, s1, nullptr);
792 :
793 : // (D15 + S1) -> [NULL, 0, s1, d15]
794 : s1 = graph()->NewNode(s_op, p1, d1);
795 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
796 : BaseWithIndexAndDisplacement32Matcher match104(
797 1 : graph()->NewNode(a_op, d15, s1));
798 1 : CheckBaseWithIndexAndDisplacement(&match104, nullptr, 0, s1, d15);
799 :
800 : // (S1 + D15) -> [NULL, 0, s1, d15]
801 : s1 = graph()->NewNode(s_op, p1, d1);
802 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
803 : BaseWithIndexAndDisplacement32Matcher match105(
804 1 : graph()->NewNode(a_op, s1, d15));
805 1 : CheckBaseWithIndexAndDisplacement(&match105, nullptr, 0, s1, d15);
806 :
807 : // (B0 + M4) -> [b0, 0, m4, NULL]
808 : m4 = graph()->NewNode(m_op, p1, d4);
809 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
810 : BaseWithIndexAndDisplacement32Matcher match106(
811 1 : graph()->NewNode(a_op, b0, m4));
812 1 : CheckBaseWithIndexAndDisplacement(&match106, b0, 0, m4, nullptr);
813 :
814 : // (M4 + B0) -> [b0, 0, m4, NULL]
815 : m4 = graph()->NewNode(m_op, p1, d4);
816 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
817 : BaseWithIndexAndDisplacement32Matcher match107(
818 1 : graph()->NewNode(a_op, m4, b0));
819 1 : CheckBaseWithIndexAndDisplacement(&match107, b0, 0, m4, nullptr);
820 :
821 : // (D15 + M4) -> [NULL, 0, m4, d15]
822 : m4 = graph()->NewNode(m_op, p1, d4);
823 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
824 : BaseWithIndexAndDisplacement32Matcher match108(
825 1 : graph()->NewNode(a_op, d15, m4));
826 1 : CheckBaseWithIndexAndDisplacement(&match108, nullptr, 0, m4, d15);
827 :
828 : // (M4 + D15) -> [NULL, 0, m4, d15]
829 : m4 = graph()->NewNode(m_op, p1, d4);
830 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
831 : BaseWithIndexAndDisplacement32Matcher match109(
832 1 : graph()->NewNode(a_op, m4, d15));
833 1 : CheckBaseWithIndexAndDisplacement(&match109, nullptr, 0, m4, d15);
834 :
835 : // (B0 + S2) -> [b0, 0, s2, NULL]
836 : s2 = graph()->NewNode(s_op, p1, d2);
837 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
838 : BaseWithIndexAndDisplacement32Matcher match110(
839 1 : graph()->NewNode(a_op, b0, s2));
840 1 : CheckBaseWithIndexAndDisplacement(&match110, b0, 0, s2, nullptr);
841 :
842 : // (S2 + B0) -> [b0, 0, s2, NULL]
843 : s2 = graph()->NewNode(s_op, p1, d2);
844 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
845 : BaseWithIndexAndDisplacement32Matcher match111(
846 1 : graph()->NewNode(a_op, s2, b0));
847 1 : CheckBaseWithIndexAndDisplacement(&match111, b0, 0, s2, nullptr);
848 :
849 : // (D15 + S2) -> [NULL, 0, s2, d15]
850 : s2 = graph()->NewNode(s_op, p1, d2);
851 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
852 : BaseWithIndexAndDisplacement32Matcher match112(
853 1 : graph()->NewNode(a_op, d15, s2));
854 1 : CheckBaseWithIndexAndDisplacement(&match112, nullptr, 0, s2, d15);
855 :
856 : // (S2 + D15) -> [NULL, 0, s2, d15]
857 : s2 = graph()->NewNode(s_op, p1, d2);
858 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
859 : BaseWithIndexAndDisplacement32Matcher match113(
860 1 : graph()->NewNode(a_op, s2, d15));
861 1 : CheckBaseWithIndexAndDisplacement(&match113, nullptr, 0, s2, d15);
862 :
863 : // (B0 + M8) -> [b0, 0, m8, NULL]
864 : m8 = graph()->NewNode(m_op, p1, d8);
865 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
866 : BaseWithIndexAndDisplacement32Matcher match114(
867 1 : graph()->NewNode(a_op, b0, m8));
868 1 : CheckBaseWithIndexAndDisplacement(&match114, b0, 0, m8, nullptr);
869 :
870 : // (M8 + B0) -> [b0, 0, m8, NULL]
871 : m8 = graph()->NewNode(m_op, p1, d8);
872 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
873 : BaseWithIndexAndDisplacement32Matcher match115(
874 1 : graph()->NewNode(a_op, m8, b0));
875 1 : CheckBaseWithIndexAndDisplacement(&match115, b0, 0, m8, nullptr);
876 :
877 : // (D15 + M8) -> [NULL, 0, m8, d15]
878 : m8 = graph()->NewNode(m_op, p1, d8);
879 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
880 : BaseWithIndexAndDisplacement32Matcher match116(
881 1 : graph()->NewNode(a_op, d15, m8));
882 1 : CheckBaseWithIndexAndDisplacement(&match116, nullptr, 0, m8, d15);
883 :
884 : // (M8 + D15) -> [NULL, 0, m8, d15]
885 : m8 = graph()->NewNode(m_op, p1, d8);
886 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
887 : BaseWithIndexAndDisplacement32Matcher match117(
888 1 : graph()->NewNode(a_op, m8, d15));
889 1 : CheckBaseWithIndexAndDisplacement(&match117, nullptr, 0, m8, d15);
890 :
891 : // (B0 + S3) -> [b0, 0, s3, NULL]
892 : s3 = graph()->NewNode(s_op, p1, d3);
893 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
894 : BaseWithIndexAndDisplacement32Matcher match118(
895 1 : graph()->NewNode(a_op, b0, s3));
896 1 : CheckBaseWithIndexAndDisplacement(&match118, b0, 0, s3, nullptr);
897 :
898 : // (S3 + B0) -> [b0, 0, s3, NULL]
899 : s3 = graph()->NewNode(s_op, p1, d3);
900 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
901 : BaseWithIndexAndDisplacement32Matcher match119(
902 1 : graph()->NewNode(a_op, s3, b0));
903 1 : CheckBaseWithIndexAndDisplacement(&match119, b0, 0, s3, nullptr);
904 :
905 : // (D15 + S3) -> [NULL, 0, s3, d15]
906 : s3 = graph()->NewNode(s_op, p1, d3);
907 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
908 : BaseWithIndexAndDisplacement32Matcher match120(
909 1 : graph()->NewNode(a_op, d15, s3));
910 1 : CheckBaseWithIndexAndDisplacement(&match120, nullptr, 0, s3, d15);
911 :
912 : // (S3 + D15) -> [NULL, 0, s3, d15]
913 : s3 = graph()->NewNode(s_op, p1, d3);
914 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
915 : BaseWithIndexAndDisplacement32Matcher match121(
916 1 : graph()->NewNode(a_op, s3, d15));
917 1 : CheckBaseWithIndexAndDisplacement(&match121, nullptr, 0, s3, d15);
918 :
919 : // (D15 + S3) + B0 -> [b0, 0, (D15 + S3), NULL]
920 : s3 = graph()->NewNode(s_op, p1, d3);
921 : temp = graph()->NewNode(a_op, d15, s3);
922 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
923 : BaseWithIndexAndDisplacement32Matcher match122(
924 1 : graph()->NewNode(a_op, temp, b0));
925 1 : CheckBaseWithIndexAndDisplacement(&match122, b0, 0, temp, nullptr);
926 :
927 : // (B0 + D15) + S3 -> [p1, 3, (B0 + D15), NULL]
928 : s3 = graph()->NewNode(s_op, p1, d3);
929 : temp = graph()->NewNode(a_op, b0, d15);
930 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
931 : BaseWithIndexAndDisplacement32Matcher match123(
932 1 : graph()->NewNode(a_op, temp, s3));
933 1 : CheckBaseWithIndexAndDisplacement(&match123, p1, 3, temp, nullptr);
934 :
935 : // (S3 + B0) + D15 -> [NULL, 0, (S3 + B0), d15]
936 : s3 = graph()->NewNode(s_op, p1, d3);
937 : temp = graph()->NewNode(a_op, s3, b0);
938 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
939 : BaseWithIndexAndDisplacement32Matcher match124(
940 1 : graph()->NewNode(a_op, temp, d15));
941 1 : CheckBaseWithIndexAndDisplacement(&match124, nullptr, 0, temp, d15);
942 :
943 : // D15 + (S3 + B0) -> [NULL, 0, (S3 + B0), d15]
944 : s3 = graph()->NewNode(s_op, p1, d3);
945 : temp = graph()->NewNode(a_op, s3, b0);
946 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
947 : BaseWithIndexAndDisplacement32Matcher match125(
948 1 : graph()->NewNode(a_op, d15, temp));
949 1 : CheckBaseWithIndexAndDisplacement(&match125, nullptr, 0, temp, d15);
950 :
951 : // B0 + (D15 + S3) -> [b0, 0, (D15 + S3), NULL]
952 : s3 = graph()->NewNode(s_op, p1, d3);
953 : temp = graph()->NewNode(a_op, d15, s3);
954 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
955 : BaseWithIndexAndDisplacement32Matcher match126(
956 1 : graph()->NewNode(a_op, b0, temp));
957 1 : CheckBaseWithIndexAndDisplacement(&match126, b0, 0, temp, nullptr);
958 :
959 : // S3 + (B0 + D15) -> [p1, 3, (B0 + D15), NULL]
960 : s3 = graph()->NewNode(s_op, p1, d3);
961 : temp = graph()->NewNode(a_op, b0, d15);
962 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
963 : BaseWithIndexAndDisplacement32Matcher match127(
964 1 : graph()->NewNode(a_op, s3, temp));
965 1 : CheckBaseWithIndexAndDisplacement(&match127, p1, 3, temp, nullptr);
966 :
967 : // S3 + (B0 - D15) -> [p1, 3, (B0 - D15), NULL]
968 : s3 = graph()->NewNode(s_op, p1, d3);
969 : temp = graph()->NewNode(sub_op, b0, d15);
970 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
971 : BaseWithIndexAndDisplacement32Matcher match128(
972 1 : graph()->NewNode(a_op, s3, temp));
973 1 : CheckBaseWithIndexAndDisplacement(&match128, p1, 3, temp, nullptr);
974 :
975 : // B0 + (B1 - D15) -> [b0, 0, (B1 - D15), NULL]
976 : temp = graph()->NewNode(sub_op, b1, d15);
977 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
978 : BaseWithIndexAndDisplacement32Matcher match129(
979 1 : graph()->NewNode(a_op, b0, temp));
980 1 : CheckBaseWithIndexAndDisplacement(&match129, b0, 0, temp, nullptr);
981 :
982 : // (B0 - D15) + S3 -> [p1, 3, temp, NULL]
983 : s3 = graph()->NewNode(s_op, p1, d3);
984 : temp = graph()->NewNode(sub_op, b0, d15);
985 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
986 : BaseWithIndexAndDisplacement32Matcher match130(
987 1 : graph()->NewNode(a_op, temp, s3));
988 1 : CheckBaseWithIndexAndDisplacement(&match130, p1, 3, temp, nullptr);
989 :
990 : // (B0 + B1) + D15 -> [NULL, 0, (B0 + B1), d15]
991 : temp = graph()->NewNode(a_op, b0, b1);
992 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
993 : BaseWithIndexAndDisplacement32Matcher match131(
994 1 : graph()->NewNode(a_op, temp, d15));
995 1 : CheckBaseWithIndexAndDisplacement(&match131, nullptr, 0, temp, d15);
996 :
997 : // D15 + (B0 + B1) -> [NULL, 0, (B0 + B1), d15]
998 : temp = graph()->NewNode(a_op, b0, b1);
999 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1000 : BaseWithIndexAndDisplacement32Matcher match132(
1001 1 : graph()->NewNode(a_op, d15, temp));
1002 1 : CheckBaseWithIndexAndDisplacement(&match132, nullptr, 0, temp, d15);
1003 1 : }
1004 :
1005 :
1006 15419 : TEST_F(NodeMatcherTest, ScaledWithOffset64Matcher) {
1007 1 : graph()->SetStart(graph()->NewNode(common()->Start(0)));
1008 :
1009 1 : const Operator* d0_op = common()->Int64Constant(0);
1010 : Node* d0 = graph()->NewNode(d0_op);
1011 : USE(d0);
1012 1 : const Operator* d1_op = common()->Int64Constant(1);
1013 : Node* d1 = graph()->NewNode(d1_op);
1014 : USE(d1);
1015 1 : const Operator* d2_op = common()->Int64Constant(2);
1016 : Node* d2 = graph()->NewNode(d2_op);
1017 : USE(d2);
1018 1 : const Operator* d3_op = common()->Int64Constant(3);
1019 : Node* d3 = graph()->NewNode(d3_op);
1020 : USE(d3);
1021 1 : const Operator* d4_op = common()->Int64Constant(4);
1022 : Node* d4 = graph()->NewNode(d4_op);
1023 : USE(d4);
1024 1 : const Operator* d5_op = common()->Int64Constant(5);
1025 : Node* d5 = graph()->NewNode(d5_op);
1026 : USE(d5);
1027 1 : const Operator* d7_op = common()->Int64Constant(7);
1028 : Node* d7 = graph()->NewNode(d7_op);
1029 : USE(d7);
1030 1 : const Operator* d8_op = common()->Int64Constant(8);
1031 : Node* d8 = graph()->NewNode(d8_op);
1032 : USE(d8);
1033 1 : const Operator* d9_op = common()->Int64Constant(9);
1034 : Node* d9 = graph()->NewNode(d9_op);
1035 : USE(d8);
1036 1 : const Operator* d15_op = common()->Int64Constant(15);
1037 : Node* d15 = graph()->NewNode(d15_op);
1038 : USE(d15);
1039 1 : const Operator* d15_32_op = common()->Int32Constant(15);
1040 : Node* d15_32 = graph()->NewNode(d15_32_op);
1041 : USE(d15_32);
1042 :
1043 1 : const Operator* b0_op = common()->Parameter(0);
1044 : Node* b0 = graph()->NewNode(b0_op, graph()->start());
1045 : USE(b0);
1046 1 : const Operator* b1_op = common()->Parameter(1);
1047 : Node* b1 = graph()->NewNode(b1_op, graph()->start());
1048 : USE(b0);
1049 :
1050 1 : const Operator* p1_op = common()->Parameter(3);
1051 : Node* p1 = graph()->NewNode(p1_op, graph()->start());
1052 : USE(p1);
1053 :
1054 1 : const Operator* a_op = machine()->Int64Add();
1055 : USE(a_op);
1056 :
1057 1 : const Operator* sub_op = machine()->Int64Sub();
1058 : USE(sub_op);
1059 :
1060 1 : const Operator* m_op = machine()->Int64Mul();
1061 : Node* m1 = graph()->NewNode(m_op, p1, d1);
1062 : Node* m2 = graph()->NewNode(m_op, p1, d2);
1063 : Node* m3 = graph()->NewNode(m_op, p1, d3);
1064 : Node* m4 = graph()->NewNode(m_op, p1, d4);
1065 : Node* m5 = graph()->NewNode(m_op, p1, d5);
1066 : Node* m7 = graph()->NewNode(m_op, p1, d7);
1067 : Node* m8 = graph()->NewNode(m_op, p1, d8);
1068 : Node* m9 = graph()->NewNode(m_op, p1, d9);
1069 : USE(m1);
1070 : USE(m2);
1071 : USE(m3);
1072 : USE(m4);
1073 : USE(m5);
1074 : USE(m7);
1075 : USE(m8);
1076 : USE(m9);
1077 :
1078 1 : const Operator* s_op = machine()->Word64Shl();
1079 : Node* s0 = graph()->NewNode(s_op, p1, d0);
1080 : Node* s1 = graph()->NewNode(s_op, p1, d1);
1081 : Node* s2 = graph()->NewNode(s_op, p1, d2);
1082 : Node* s3 = graph()->NewNode(s_op, p1, d3);
1083 : Node* s4 = graph()->NewNode(s_op, p1, d4);
1084 : USE(s0);
1085 : USE(s1);
1086 : USE(s2);
1087 : USE(s3);
1088 : USE(s4);
1089 :
1090 : const StoreRepresentation rep(MachineRepresentation::kWord32,
1091 : kNoWriteBarrier);
1092 : USE(rep);
1093 :
1094 : // 1 INPUT
1095 :
1096 : // Only relevant test dases is Checking for non-match.
1097 1 : BaseWithIndexAndDisplacement64Matcher match0(d15);
1098 2 : EXPECT_FALSE(match0.matches());
1099 :
1100 : // 2 INPUT
1101 :
1102 : // (B0 + B1) -> [B0, 0, B1, NULL]
1103 1 : BaseWithIndexAndDisplacement64Matcher match1(graph()->NewNode(a_op, b0, b1));
1104 1 : CheckBaseWithIndexAndDisplacement(&match1, b1, 0, b0, nullptr);
1105 :
1106 : // (B0 + D15) -> [NULL, 0, B0, D15]
1107 1 : BaseWithIndexAndDisplacement64Matcher match2(graph()->NewNode(a_op, b0, d15));
1108 1 : CheckBaseWithIndexAndDisplacement(&match2, nullptr, 0, b0, d15);
1109 :
1110 : BaseWithIndexAndDisplacement64Matcher match2_32(
1111 1 : graph()->NewNode(a_op, b0, d15_32));
1112 1 : CheckBaseWithIndexAndDisplacement(&match2_32, nullptr, 0, b0, d15_32);
1113 :
1114 : // (D15 + B0) -> [NULL, 0, B0, D15]
1115 1 : BaseWithIndexAndDisplacement64Matcher match3(graph()->NewNode(a_op, d15, b0));
1116 1 : CheckBaseWithIndexAndDisplacement(&match3, nullptr, 0, b0, d15);
1117 :
1118 : // (B0 + M1) -> [p1, 0, B0, NULL]
1119 1 : BaseWithIndexAndDisplacement64Matcher match4(graph()->NewNode(a_op, b0, m1));
1120 1 : CheckBaseWithIndexAndDisplacement(&match4, p1, 0, b0, nullptr);
1121 :
1122 : // (M1 + B0) -> [p1, 0, B0, NULL]
1123 : m1 = graph()->NewNode(m_op, p1, d1);
1124 1 : BaseWithIndexAndDisplacement64Matcher match5(graph()->NewNode(a_op, m1, b0));
1125 1 : CheckBaseWithIndexAndDisplacement(&match5, p1, 0, b0, nullptr);
1126 :
1127 : // (D15 + M1) -> [P1, 0, NULL, D15]
1128 : m1 = graph()->NewNode(m_op, p1, d1);
1129 1 : BaseWithIndexAndDisplacement64Matcher match6(graph()->NewNode(a_op, d15, m1));
1130 1 : CheckBaseWithIndexAndDisplacement(&match6, p1, 0, nullptr, d15);
1131 :
1132 : // (M1 + D15) -> [P1, 0, NULL, D15]
1133 : m1 = graph()->NewNode(m_op, p1, d1);
1134 1 : BaseWithIndexAndDisplacement64Matcher match7(graph()->NewNode(a_op, m1, d15));
1135 1 : CheckBaseWithIndexAndDisplacement(&match7, p1, 0, nullptr, d15);
1136 :
1137 : // (B0 + S0) -> [p1, 0, B0, NULL]
1138 1 : BaseWithIndexAndDisplacement64Matcher match8(graph()->NewNode(a_op, b0, s0));
1139 1 : CheckBaseWithIndexAndDisplacement(&match8, p1, 0, b0, nullptr);
1140 :
1141 : // (S0 + B0) -> [p1, 0, B0, NULL]
1142 : s0 = graph()->NewNode(s_op, p1, d0);
1143 1 : BaseWithIndexAndDisplacement64Matcher match9(graph()->NewNode(a_op, s0, b0));
1144 1 : CheckBaseWithIndexAndDisplacement(&match9, p1, 0, b0, nullptr);
1145 :
1146 : // (D15 + S0) -> [P1, 0, NULL, D15]
1147 : s0 = graph()->NewNode(s_op, p1, d0);
1148 : BaseWithIndexAndDisplacement64Matcher match10(
1149 1 : graph()->NewNode(a_op, d15, s0));
1150 1 : CheckBaseWithIndexAndDisplacement(&match10, p1, 0, nullptr, d15);
1151 :
1152 : // (S0 + D15) -> [P1, 0, NULL, D15]
1153 : s0 = graph()->NewNode(s_op, p1, d0);
1154 : BaseWithIndexAndDisplacement64Matcher match11(
1155 1 : graph()->NewNode(a_op, s0, d15));
1156 1 : CheckBaseWithIndexAndDisplacement(&match11, p1, 0, nullptr, d15);
1157 :
1158 : // (B0 + M2) -> [p1, 1, B0, NULL]
1159 1 : BaseWithIndexAndDisplacement64Matcher match12(graph()->NewNode(a_op, b0, m2));
1160 1 : CheckBaseWithIndexAndDisplacement(&match12, p1, 1, b0, nullptr);
1161 :
1162 : // (M2 + B0) -> [p1, 1, B0, NULL]
1163 : m2 = graph()->NewNode(m_op, p1, d2);
1164 1 : BaseWithIndexAndDisplacement64Matcher match13(graph()->NewNode(a_op, m2, b0));
1165 1 : CheckBaseWithIndexAndDisplacement(&match13, p1, 1, b0, nullptr);
1166 :
1167 : // (D15 + M2) -> [P1, 1, NULL, D15]
1168 : m2 = graph()->NewNode(m_op, p1, d2);
1169 : BaseWithIndexAndDisplacement64Matcher match14(
1170 1 : graph()->NewNode(a_op, d15, m2));
1171 1 : CheckBaseWithIndexAndDisplacement(&match14, p1, 1, nullptr, d15);
1172 :
1173 : // (M2 + D15) -> [P1, 1, NULL, D15]
1174 : m2 = graph()->NewNode(m_op, p1, d2);
1175 : BaseWithIndexAndDisplacement64Matcher match15(
1176 1 : graph()->NewNode(a_op, m2, d15));
1177 1 : CheckBaseWithIndexAndDisplacement(&match15, p1, 1, nullptr, d15);
1178 :
1179 : // (B0 + S1) -> [p1, 1, B0, NULL]
1180 1 : BaseWithIndexAndDisplacement64Matcher match16(graph()->NewNode(a_op, b0, s1));
1181 1 : CheckBaseWithIndexAndDisplacement(&match16, p1, 1, b0, nullptr);
1182 :
1183 : // (S1 + B0) -> [p1, 1, B0, NULL]
1184 : s1 = graph()->NewNode(s_op, p1, d1);
1185 1 : BaseWithIndexAndDisplacement64Matcher match17(graph()->NewNode(a_op, s1, b0));
1186 1 : CheckBaseWithIndexAndDisplacement(&match17, p1, 1, b0, nullptr);
1187 :
1188 : // (D15 + S1) -> [P1, 1, NULL, D15]
1189 : s1 = graph()->NewNode(s_op, p1, d1);
1190 : BaseWithIndexAndDisplacement64Matcher match18(
1191 1 : graph()->NewNode(a_op, d15, s1));
1192 1 : CheckBaseWithIndexAndDisplacement(&match18, p1, 1, nullptr, d15);
1193 :
1194 : // (S1 + D15) -> [P1, 1, NULL, D15]
1195 : s1 = graph()->NewNode(s_op, p1, d1);
1196 : BaseWithIndexAndDisplacement64Matcher match19(
1197 1 : graph()->NewNode(a_op, s1, d15));
1198 1 : CheckBaseWithIndexAndDisplacement(&match19, p1, 1, nullptr, d15);
1199 :
1200 : // (B0 + M4) -> [p1, 2, B0, NULL]
1201 1 : BaseWithIndexAndDisplacement64Matcher match20(graph()->NewNode(a_op, b0, m4));
1202 1 : CheckBaseWithIndexAndDisplacement(&match20, p1, 2, b0, nullptr);
1203 :
1204 : // (M4 + B0) -> [p1, 2, B0, NULL]
1205 : m4 = graph()->NewNode(m_op, p1, d4);
1206 1 : BaseWithIndexAndDisplacement64Matcher match21(graph()->NewNode(a_op, m4, b0));
1207 1 : CheckBaseWithIndexAndDisplacement(&match21, p1, 2, b0, nullptr);
1208 :
1209 : // (D15 + M4) -> [p1, 2, NULL, D15]
1210 : m4 = graph()->NewNode(m_op, p1, d4);
1211 : BaseWithIndexAndDisplacement64Matcher match22(
1212 1 : graph()->NewNode(a_op, d15, m4));
1213 1 : CheckBaseWithIndexAndDisplacement(&match22, p1, 2, nullptr, d15);
1214 :
1215 : // (M4 + D15) -> [p1, 2, NULL, D15]
1216 : m4 = graph()->NewNode(m_op, p1, d4);
1217 : BaseWithIndexAndDisplacement64Matcher match23(
1218 1 : graph()->NewNode(a_op, m4, d15));
1219 1 : CheckBaseWithIndexAndDisplacement(&match23, p1, 2, nullptr, d15);
1220 :
1221 : // (B0 + S2) -> [p1, 2, B0, NULL]
1222 1 : BaseWithIndexAndDisplacement64Matcher match24(graph()->NewNode(a_op, b0, s2));
1223 1 : CheckBaseWithIndexAndDisplacement(&match24, p1, 2, b0, nullptr);
1224 :
1225 : // (S2 + B0) -> [p1, 2, B0, NULL]
1226 : s2 = graph()->NewNode(s_op, p1, d2);
1227 1 : BaseWithIndexAndDisplacement64Matcher match25(graph()->NewNode(a_op, s2, b0));
1228 1 : CheckBaseWithIndexAndDisplacement(&match25, p1, 2, b0, nullptr);
1229 :
1230 : // (D15 + S2) -> [p1, 2, NULL, D15]
1231 : s2 = graph()->NewNode(s_op, p1, d2);
1232 : BaseWithIndexAndDisplacement64Matcher match26(
1233 1 : graph()->NewNode(a_op, d15, s2));
1234 1 : CheckBaseWithIndexAndDisplacement(&match26, p1, 2, nullptr, d15);
1235 :
1236 : // (S2 + D15) -> [p1, 2, NULL, D15]
1237 : s2 = graph()->NewNode(s_op, p1, d2);
1238 : BaseWithIndexAndDisplacement64Matcher match27(
1239 1 : graph()->NewNode(a_op, s2, d15));
1240 1 : CheckBaseWithIndexAndDisplacement(&match27, p1, 2, nullptr, d15);
1241 :
1242 : // (B0 + M8) -> [p1, 2, B0, NULL]
1243 1 : BaseWithIndexAndDisplacement64Matcher match28(graph()->NewNode(a_op, b0, m8));
1244 1 : CheckBaseWithIndexAndDisplacement(&match28, p1, 3, b0, nullptr);
1245 :
1246 : // (M8 + B0) -> [p1, 2, B0, NULL]
1247 : m8 = graph()->NewNode(m_op, p1, d8);
1248 1 : BaseWithIndexAndDisplacement64Matcher match29(graph()->NewNode(a_op, m8, b0));
1249 1 : CheckBaseWithIndexAndDisplacement(&match29, p1, 3, b0, nullptr);
1250 :
1251 : // (D15 + M8) -> [p1, 2, NULL, D15]
1252 : m8 = graph()->NewNode(m_op, p1, d8);
1253 : BaseWithIndexAndDisplacement64Matcher match30(
1254 1 : graph()->NewNode(a_op, d15, m8));
1255 1 : CheckBaseWithIndexAndDisplacement(&match30, p1, 3, nullptr, d15);
1256 :
1257 : // (M8 + D15) -> [p1, 2, NULL, D15]
1258 : m8 = graph()->NewNode(m_op, p1, d8);
1259 : BaseWithIndexAndDisplacement64Matcher match31(
1260 1 : graph()->NewNode(a_op, m8, d15));
1261 1 : CheckBaseWithIndexAndDisplacement(&match31, p1, 3, nullptr, d15);
1262 :
1263 : // (B0 + S3) -> [p1, 2, B0, NULL]
1264 1 : BaseWithIndexAndDisplacement64Matcher match32(graph()->NewNode(a_op, b0, s3));
1265 1 : CheckBaseWithIndexAndDisplacement(&match32, p1, 3, b0, nullptr);
1266 :
1267 : // (S3 + B0) -> [p1, 2, B0, NULL]
1268 : s3 = graph()->NewNode(s_op, p1, d3);
1269 1 : BaseWithIndexAndDisplacement64Matcher match33(graph()->NewNode(a_op, s3, b0));
1270 1 : CheckBaseWithIndexAndDisplacement(&match33, p1, 3, b0, nullptr);
1271 :
1272 : // (D15 + S3) -> [p1, 2, NULL, D15]
1273 : s3 = graph()->NewNode(s_op, p1, d3);
1274 : BaseWithIndexAndDisplacement64Matcher match34(
1275 1 : graph()->NewNode(a_op, d15, s3));
1276 1 : CheckBaseWithIndexAndDisplacement(&match34, p1, 3, nullptr, d15);
1277 :
1278 : // (S3 + D15) -> [p1, 2, NULL, D15]
1279 : s3 = graph()->NewNode(s_op, p1, d3);
1280 : BaseWithIndexAndDisplacement64Matcher match35(
1281 1 : graph()->NewNode(a_op, s3, d15));
1282 1 : CheckBaseWithIndexAndDisplacement(&match35, p1, 3, nullptr, d15);
1283 :
1284 : // 2 INPUT - NEGATIVE CASES
1285 :
1286 : // (M3 + B1) -> [B0, 0, M3, NULL]
1287 1 : BaseWithIndexAndDisplacement64Matcher match36(graph()->NewNode(a_op, b1, m3));
1288 1 : CheckBaseWithIndexAndDisplacement(&match36, m3, 0, b1, nullptr);
1289 :
1290 : // (S4 + B1) -> [B0, 0, S4, NULL]
1291 1 : BaseWithIndexAndDisplacement64Matcher match37(graph()->NewNode(a_op, b1, s4));
1292 1 : CheckBaseWithIndexAndDisplacement(&match37, s4, 0, b1, nullptr);
1293 :
1294 : // 3 INPUT
1295 :
1296 : // (D15 + S3) + B0 -> [p1, 2, b0, d15]
1297 : s3 = graph()->NewNode(s_op, p1, d3);
1298 : BaseWithIndexAndDisplacement64Matcher match38(
1299 1 : graph()->NewNode(a_op, graph()->NewNode(a_op, d15, s3), b0));
1300 1 : CheckBaseWithIndexAndDisplacement(&match38, p1, 3, b0, d15);
1301 :
1302 : // (B0 + D15) + S3 -> [p1, 2, b0, d15]
1303 : s3 = graph()->NewNode(s_op, p1, d3);
1304 : BaseWithIndexAndDisplacement64Matcher match39(
1305 1 : graph()->NewNode(a_op, graph()->NewNode(a_op, b0, d15), s3));
1306 1 : CheckBaseWithIndexAndDisplacement(&match39, p1, 3, b0, d15);
1307 :
1308 : // (S3 + B0) + D15 -> [p1, 2, b0, d15]
1309 : s3 = graph()->NewNode(s_op, p1, d3);
1310 : BaseWithIndexAndDisplacement64Matcher match40(
1311 1 : graph()->NewNode(a_op, graph()->NewNode(a_op, s3, b0), d15));
1312 1 : CheckBaseWithIndexAndDisplacement(&match40, p1, 3, b0, d15);
1313 :
1314 : // D15 + (S3 + B0) -> [p1, 2, b0, d15]
1315 : s3 = graph()->NewNode(s_op, p1, d3);
1316 : BaseWithIndexAndDisplacement64Matcher match41(
1317 1 : graph()->NewNode(a_op, d15, graph()->NewNode(a_op, s3, b0)));
1318 1 : CheckBaseWithIndexAndDisplacement(&match41, p1, 3, b0, d15);
1319 :
1320 : // B0 + (D15 + S3) -> [p1, 2, b0, d15]
1321 : s3 = graph()->NewNode(s_op, p1, d3);
1322 : BaseWithIndexAndDisplacement64Matcher match42(
1323 1 : graph()->NewNode(a_op, b0, graph()->NewNode(a_op, d15, s3)));
1324 1 : CheckBaseWithIndexAndDisplacement(&match42, p1, 3, b0, d15);
1325 :
1326 : // S3 + (B0 + D15) -> [p1, 2, b0, d15]
1327 : s3 = graph()->NewNode(s_op, p1, d3);
1328 : BaseWithIndexAndDisplacement64Matcher match43(
1329 1 : graph()->NewNode(a_op, s3, graph()->NewNode(a_op, b0, d15)));
1330 1 : CheckBaseWithIndexAndDisplacement(&match43, p1, 3, b0, d15);
1331 :
1332 : // 2 INPUT with non-power of 2 scale
1333 :
1334 : // (M3 + D15) -> [p1, 1, p1, D15]
1335 : m3 = graph()->NewNode(m_op, p1, d3);
1336 : BaseWithIndexAndDisplacement64Matcher match44(
1337 1 : graph()->NewNode(a_op, m3, d15));
1338 1 : CheckBaseWithIndexAndDisplacement(&match44, p1, 1, p1, d15);
1339 :
1340 : // (M5 + D15) -> [p1, 2, p1, D15]
1341 : m5 = graph()->NewNode(m_op, p1, d5);
1342 : BaseWithIndexAndDisplacement64Matcher match45(
1343 1 : graph()->NewNode(a_op, m5, d15));
1344 1 : CheckBaseWithIndexAndDisplacement(&match45, p1, 2, p1, d15);
1345 :
1346 : // (M9 + D15) -> [p1, 3, p1, D15]
1347 : m9 = graph()->NewNode(m_op, p1, d9);
1348 : BaseWithIndexAndDisplacement64Matcher match46(
1349 1 : graph()->NewNode(a_op, m9, d15));
1350 1 : CheckBaseWithIndexAndDisplacement(&match46, p1, 3, p1, d15);
1351 :
1352 : // 3 INPUT negative cases: non-power of 2 scale but with a base
1353 :
1354 : // ((M3 + B0) + D15) -> [m3, 0, b0, D15]
1355 : m3 = graph()->NewNode(m_op, p1, d3);
1356 : Node* temp = graph()->NewNode(a_op, m3, b0);
1357 : BaseWithIndexAndDisplacement64Matcher match47(
1358 1 : graph()->NewNode(a_op, temp, d15));
1359 1 : CheckBaseWithIndexAndDisplacement(&match47, m3, 0, b0, d15);
1360 :
1361 : // (M3 + (B0 + D15)) -> [m3, 0, b0, D15]
1362 : m3 = graph()->NewNode(m_op, p1, d3);
1363 : temp = graph()->NewNode(a_op, d15, b0);
1364 : BaseWithIndexAndDisplacement64Matcher match48(
1365 1 : graph()->NewNode(a_op, m3, temp));
1366 1 : CheckBaseWithIndexAndDisplacement(&match48, m3, 0, b0, d15);
1367 :
1368 : // ((B0 + M3) + D15) -> [m3, 0, b0, D15]
1369 : m3 = graph()->NewNode(m_op, p1, d3);
1370 : temp = graph()->NewNode(a_op, b0, m3);
1371 : BaseWithIndexAndDisplacement64Matcher match49(
1372 1 : graph()->NewNode(a_op, temp, d15));
1373 1 : CheckBaseWithIndexAndDisplacement(&match49, m3, 0, b0, d15);
1374 :
1375 : // (M3 + (D15 + B0)) -> [m3, 0, b0, D15]
1376 : m3 = graph()->NewNode(m_op, p1, d3);
1377 : temp = graph()->NewNode(a_op, b0, d15);
1378 : BaseWithIndexAndDisplacement64Matcher match50(
1379 1 : graph()->NewNode(a_op, m3, temp));
1380 1 : CheckBaseWithIndexAndDisplacement(&match50, m3, 0, b0, d15);
1381 :
1382 : // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
1383 : s3 = graph()->NewNode(s_op, p1, d3);
1384 : BaseWithIndexAndDisplacement64Matcher match51(
1385 1 : graph()->NewNode(a_op, s3, graph()->NewNode(sub_op, b0, d15)));
1386 : CheckBaseWithIndexAndDisplacement(&match51, p1, 3, b0, d15,
1387 1 : kNegativeDisplacement);
1388 :
1389 : // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
1390 : BaseWithIndexAndDisplacement64Matcher match52(
1391 1 : graph()->NewNode(a_op, b0, graph()->NewNode(sub_op, b1, d15)));
1392 : CheckBaseWithIndexAndDisplacement(&match52, b1, 0, b0, d15,
1393 1 : kNegativeDisplacement);
1394 :
1395 : // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
1396 : s3 = graph()->NewNode(s_op, p1, d3);
1397 : BaseWithIndexAndDisplacement64Matcher match53(
1398 1 : graph()->NewNode(a_op, graph()->NewNode(sub_op, b0, d15), s3));
1399 : CheckBaseWithIndexAndDisplacement(&match53, p1, 3, b0, d15,
1400 1 : kNegativeDisplacement);
1401 :
1402 : // 4 INPUT - with addressing operand uses
1403 :
1404 : // (B0 + M1) -> [p1, 0, B0, NULL]
1405 : m1 = graph()->NewNode(m_op, p1, d1);
1406 4 : ADD_ADDRESSING_OPERAND_USES(m1);
1407 1 : BaseWithIndexAndDisplacement64Matcher match54(graph()->NewNode(a_op, b0, m1));
1408 1 : CheckBaseWithIndexAndDisplacement(&match54, p1, 0, b0, nullptr);
1409 :
1410 : // (M1 + B0) -> [p1, 0, B0, NULL]
1411 : m1 = graph()->NewNode(m_op, p1, d1);
1412 4 : ADD_ADDRESSING_OPERAND_USES(m1);
1413 1 : BaseWithIndexAndDisplacement64Matcher match55(graph()->NewNode(a_op, m1, b0));
1414 1 : CheckBaseWithIndexAndDisplacement(&match55, p1, 0, b0, nullptr);
1415 :
1416 : // (D15 + M1) -> [P1, 0, NULL, D15]
1417 : m1 = graph()->NewNode(m_op, p1, d1);
1418 4 : ADD_ADDRESSING_OPERAND_USES(m1);
1419 : BaseWithIndexAndDisplacement64Matcher match56(
1420 1 : graph()->NewNode(a_op, d15, m1));
1421 1 : CheckBaseWithIndexAndDisplacement(&match56, p1, 0, nullptr, d15);
1422 :
1423 : // (M1 + D15) -> [P1, 0, NULL, D15]
1424 : m1 = graph()->NewNode(m_op, p1, d1);
1425 4 : ADD_ADDRESSING_OPERAND_USES(m1);
1426 : BaseWithIndexAndDisplacement64Matcher match57(
1427 1 : graph()->NewNode(a_op, m1, d15));
1428 1 : CheckBaseWithIndexAndDisplacement(&match57, p1, 0, nullptr, d15);
1429 :
1430 : // (B0 + S0) -> [p1, 0, B0, NULL]
1431 : s0 = graph()->NewNode(s_op, p1, d0);
1432 4 : ADD_ADDRESSING_OPERAND_USES(s0);
1433 1 : BaseWithIndexAndDisplacement64Matcher match58(graph()->NewNode(a_op, b0, s0));
1434 1 : CheckBaseWithIndexAndDisplacement(&match58, p1, 0, b0, nullptr);
1435 :
1436 : // (S0 + B0) -> [p1, 0, B0, NULL]
1437 : s0 = graph()->NewNode(s_op, p1, d0);
1438 4 : ADD_ADDRESSING_OPERAND_USES(s0);
1439 1 : BaseWithIndexAndDisplacement64Matcher match59(graph()->NewNode(a_op, s0, b0));
1440 1 : CheckBaseWithIndexAndDisplacement(&match59, p1, 0, b0, nullptr);
1441 :
1442 : // (D15 + S0) -> [P1, 0, NULL, D15]
1443 : s0 = graph()->NewNode(s_op, p1, d0);
1444 4 : ADD_ADDRESSING_OPERAND_USES(s0);
1445 : BaseWithIndexAndDisplacement64Matcher match60(
1446 1 : graph()->NewNode(a_op, d15, s0));
1447 1 : CheckBaseWithIndexAndDisplacement(&match60, p1, 0, nullptr, d15);
1448 :
1449 : // (S0 + D15) -> [P1, 0, NULL, D15]
1450 : s0 = graph()->NewNode(s_op, p1, d0);
1451 4 : ADD_ADDRESSING_OPERAND_USES(s0);
1452 : BaseWithIndexAndDisplacement64Matcher match61(
1453 1 : graph()->NewNode(a_op, s0, d15));
1454 1 : CheckBaseWithIndexAndDisplacement(&match61, p1, 0, nullptr, d15);
1455 :
1456 : // (B0 + M2) -> [p1, 1, B0, NULL]
1457 : m2 = graph()->NewNode(m_op, p1, d2);
1458 4 : ADD_ADDRESSING_OPERAND_USES(m2);
1459 1 : BaseWithIndexAndDisplacement64Matcher match62(graph()->NewNode(a_op, b0, m2));
1460 1 : CheckBaseWithIndexAndDisplacement(&match62, p1, 1, b0, nullptr);
1461 :
1462 : // (M2 + B0) -> [p1, 1, B0, NULL]
1463 : m2 = graph()->NewNode(m_op, p1, d2);
1464 4 : ADD_ADDRESSING_OPERAND_USES(m2);
1465 1 : BaseWithIndexAndDisplacement64Matcher match63(graph()->NewNode(a_op, m2, b0));
1466 1 : CheckBaseWithIndexAndDisplacement(&match63, p1, 1, b0, nullptr);
1467 :
1468 : // (D15 + M2) -> [P1, 1, NULL, D15]
1469 : m2 = graph()->NewNode(m_op, p1, d2);
1470 4 : ADD_ADDRESSING_OPERAND_USES(m2);
1471 : BaseWithIndexAndDisplacement64Matcher match64(
1472 1 : graph()->NewNode(a_op, d15, m2));
1473 1 : CheckBaseWithIndexAndDisplacement(&match64, p1, 1, nullptr, d15);
1474 :
1475 : // (M2 + D15) -> [P1, 1, NULL, D15]
1476 : m2 = graph()->NewNode(m_op, p1, d2);
1477 4 : ADD_ADDRESSING_OPERAND_USES(m2);
1478 : BaseWithIndexAndDisplacement64Matcher match65(
1479 1 : graph()->NewNode(a_op, m2, d15));
1480 1 : CheckBaseWithIndexAndDisplacement(&match65, p1, 1, nullptr, d15);
1481 :
1482 : // (B0 + S1) -> [p1, 1, B0, NULL]
1483 : s1 = graph()->NewNode(s_op, p1, d1);
1484 4 : ADD_ADDRESSING_OPERAND_USES(s1);
1485 1 : BaseWithIndexAndDisplacement64Matcher match66(graph()->NewNode(a_op, b0, s1));
1486 1 : CheckBaseWithIndexAndDisplacement(&match66, p1, 1, b0, nullptr);
1487 :
1488 : // (S1 + B0) -> [p1, 1, B0, NULL]
1489 : s1 = graph()->NewNode(s_op, p1, d1);
1490 4 : ADD_ADDRESSING_OPERAND_USES(s1);
1491 1 : BaseWithIndexAndDisplacement64Matcher match67(graph()->NewNode(a_op, s1, b0));
1492 1 : CheckBaseWithIndexAndDisplacement(&match67, p1, 1, b0, nullptr);
1493 :
1494 : // (D15 + S1) -> [P1, 1, NULL, D15]
1495 : s1 = graph()->NewNode(s_op, p1, d1);
1496 4 : ADD_ADDRESSING_OPERAND_USES(s1);
1497 : BaseWithIndexAndDisplacement64Matcher match68(
1498 1 : graph()->NewNode(a_op, d15, s1));
1499 1 : CheckBaseWithIndexAndDisplacement(&match68, p1, 1, nullptr, d15);
1500 :
1501 : // (S1 + D15) -> [P1, 1, NULL, D15]
1502 : s1 = graph()->NewNode(s_op, p1, d1);
1503 4 : ADD_ADDRESSING_OPERAND_USES(s1);
1504 : BaseWithIndexAndDisplacement64Matcher match69(
1505 1 : graph()->NewNode(a_op, s1, d15));
1506 1 : CheckBaseWithIndexAndDisplacement(&match69, p1, 1, nullptr, d15);
1507 :
1508 : // (B0 + M4) -> [p1, 2, B0, NULL]
1509 : m4 = graph()->NewNode(m_op, p1, d4);
1510 4 : ADD_ADDRESSING_OPERAND_USES(m4);
1511 1 : BaseWithIndexAndDisplacement64Matcher match70(graph()->NewNode(a_op, b0, m4));
1512 1 : CheckBaseWithIndexAndDisplacement(&match70, p1, 2, b0, nullptr);
1513 :
1514 : // (M4 + B0) -> [p1, 2, B0, NULL]
1515 : m4 = graph()->NewNode(m_op, p1, d4);
1516 4 : ADD_ADDRESSING_OPERAND_USES(m4);
1517 1 : BaseWithIndexAndDisplacement64Matcher match71(graph()->NewNode(a_op, m4, b0));
1518 1 : CheckBaseWithIndexAndDisplacement(&match71, p1, 2, b0, nullptr);
1519 :
1520 : // (D15 + M4) -> [p1, 2, NULL, D15]
1521 : m4 = graph()->NewNode(m_op, p1, d4);
1522 4 : ADD_ADDRESSING_OPERAND_USES(m4);
1523 : BaseWithIndexAndDisplacement64Matcher match72(
1524 1 : graph()->NewNode(a_op, d15, m4));
1525 1 : CheckBaseWithIndexAndDisplacement(&match72, p1, 2, nullptr, d15);
1526 :
1527 : // (M4 + D15) -> [p1, 2, NULL, D15]
1528 : m4 = graph()->NewNode(m_op, p1, d4);
1529 4 : ADD_ADDRESSING_OPERAND_USES(m4);
1530 : BaseWithIndexAndDisplacement64Matcher match73(
1531 1 : graph()->NewNode(a_op, m4, d15));
1532 1 : CheckBaseWithIndexAndDisplacement(&match73, p1, 2, nullptr, d15);
1533 :
1534 : // (B0 + S2) -> [p1, 2, B0, NULL]
1535 : s2 = graph()->NewNode(s_op, p1, d2);
1536 4 : ADD_ADDRESSING_OPERAND_USES(s2);
1537 1 : BaseWithIndexAndDisplacement64Matcher match74(graph()->NewNode(a_op, b0, s2));
1538 1 : CheckBaseWithIndexAndDisplacement(&match74, p1, 2, b0, nullptr);
1539 :
1540 : // (S2 + B0) -> [p1, 2, B0, NULL]
1541 : s2 = graph()->NewNode(s_op, p1, d2);
1542 4 : ADD_ADDRESSING_OPERAND_USES(s2);
1543 1 : BaseWithIndexAndDisplacement64Matcher match75(graph()->NewNode(a_op, s2, b0));
1544 1 : CheckBaseWithIndexAndDisplacement(&match75, p1, 2, b0, nullptr);
1545 :
1546 : // (D15 + S2) -> [p1, 2, NULL, D15]
1547 : s2 = graph()->NewNode(s_op, p1, d2);
1548 4 : ADD_ADDRESSING_OPERAND_USES(s2);
1549 : BaseWithIndexAndDisplacement64Matcher match76(
1550 1 : graph()->NewNode(a_op, d15, s2));
1551 1 : CheckBaseWithIndexAndDisplacement(&match76, p1, 2, nullptr, d15);
1552 :
1553 : // (S2 + D15) -> [p1, 2, NULL, D15]
1554 : s2 = graph()->NewNode(s_op, p1, d2);
1555 4 : ADD_ADDRESSING_OPERAND_USES(s2);
1556 : BaseWithIndexAndDisplacement64Matcher match77(
1557 1 : graph()->NewNode(a_op, s2, d15));
1558 1 : CheckBaseWithIndexAndDisplacement(&match77, p1, 2, nullptr, d15);
1559 :
1560 : // (B0 + M8) -> [p1, 2, B0, NULL]
1561 : m8 = graph()->NewNode(m_op, p1, d8);
1562 4 : ADD_ADDRESSING_OPERAND_USES(m8);
1563 1 : BaseWithIndexAndDisplacement64Matcher match78(graph()->NewNode(a_op, b0, m8));
1564 1 : CheckBaseWithIndexAndDisplacement(&match78, p1, 3, b0, nullptr);
1565 :
1566 : // (M8 + B0) -> [p1, 2, B0, NULL]
1567 : m8 = graph()->NewNode(m_op, p1, d8);
1568 4 : ADD_ADDRESSING_OPERAND_USES(m8);
1569 1 : BaseWithIndexAndDisplacement64Matcher match79(graph()->NewNode(a_op, m8, b0));
1570 1 : CheckBaseWithIndexAndDisplacement(&match79, p1, 3, b0, nullptr);
1571 :
1572 : // (D15 + M8) -> [p1, 2, NULL, D15]
1573 : m8 = graph()->NewNode(m_op, p1, d8);
1574 4 : ADD_ADDRESSING_OPERAND_USES(m8);
1575 : BaseWithIndexAndDisplacement64Matcher match80(
1576 1 : graph()->NewNode(a_op, d15, m8));
1577 1 : CheckBaseWithIndexAndDisplacement(&match80, p1, 3, nullptr, d15);
1578 :
1579 : // (M8 + D15) -> [p1, 2, NULL, D15]
1580 : m8 = graph()->NewNode(m_op, p1, d8);
1581 4 : ADD_ADDRESSING_OPERAND_USES(m8);
1582 : BaseWithIndexAndDisplacement64Matcher match81(
1583 1 : graph()->NewNode(a_op, m8, d15));
1584 1 : CheckBaseWithIndexAndDisplacement(&match81, p1, 3, nullptr, d15);
1585 :
1586 : // (B0 + S3) -> [p1, 2, B0, NULL]
1587 : s3 = graph()->NewNode(s_op, p1, d3);
1588 4 : ADD_ADDRESSING_OPERAND_USES(s3);
1589 1 : BaseWithIndexAndDisplacement64Matcher match82(graph()->NewNode(a_op, b0, s3));
1590 1 : CheckBaseWithIndexAndDisplacement(&match82, p1, 3, b0, nullptr);
1591 :
1592 : // (S3 + B0) -> [p1, 2, B0, NULL]
1593 : s3 = graph()->NewNode(s_op, p1, d3);
1594 4 : ADD_ADDRESSING_OPERAND_USES(s3);
1595 1 : BaseWithIndexAndDisplacement64Matcher match83(graph()->NewNode(a_op, s3, b0));
1596 1 : CheckBaseWithIndexAndDisplacement(&match83, p1, 3, b0, nullptr);
1597 :
1598 : // (D15 + S3) -> [p1, 2, NULL, D15]
1599 : s3 = graph()->NewNode(s_op, p1, d3);
1600 4 : ADD_ADDRESSING_OPERAND_USES(s3);
1601 : BaseWithIndexAndDisplacement64Matcher match84(
1602 1 : graph()->NewNode(a_op, d15, s3));
1603 1 : CheckBaseWithIndexAndDisplacement(&match84, p1, 3, nullptr, d15);
1604 :
1605 : // (S3 + D15) -> [p1, 2, NULL, D15]
1606 : s3 = graph()->NewNode(s_op, p1, d3);
1607 4 : ADD_ADDRESSING_OPERAND_USES(s3);
1608 : BaseWithIndexAndDisplacement64Matcher match85(
1609 1 : graph()->NewNode(a_op, s3, d15));
1610 1 : CheckBaseWithIndexAndDisplacement(&match85, p1, 3, nullptr, d15);
1611 :
1612 : // (D15 + S3) + B0 -> [p1, 2, b0, d15]
1613 : s3 = graph()->NewNode(s_op, p1, d3);
1614 : temp = graph()->NewNode(a_op, d15, s3);
1615 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1616 : BaseWithIndexAndDisplacement64Matcher match86(
1617 1 : graph()->NewNode(a_op, temp, b0));
1618 1 : CheckBaseWithIndexAndDisplacement(&match86, p1, 3, b0, d15);
1619 :
1620 : // (B0 + D15) + S3 -> [p1, 2, b0, d15]
1621 : s3 = graph()->NewNode(s_op, p1, d3);
1622 : temp = graph()->NewNode(a_op, b0, d15);
1623 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1624 : BaseWithIndexAndDisplacement64Matcher match87(
1625 1 : graph()->NewNode(a_op, temp, s3));
1626 1 : CheckBaseWithIndexAndDisplacement(&match87, p1, 3, b0, d15);
1627 :
1628 : // (S3 + B0) + D15 -> [NULL, 0, (s3 + b0), d15]
1629 : // Avoid changing simple addressing to complex addressing
1630 : s3 = graph()->NewNode(s_op, p1, d3);
1631 : temp = graph()->NewNode(a_op, s3, b0);
1632 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1633 : BaseWithIndexAndDisplacement64Matcher match88(
1634 1 : graph()->NewNode(a_op, temp, d15));
1635 1 : CheckBaseWithIndexAndDisplacement(&match88, nullptr, 0, temp, d15);
1636 :
1637 : // D15 + (S3 + B0) -> [NULL, 0, (s3 + b0), d15]
1638 : // Avoid changing simple addressing to complex addressing
1639 : s3 = graph()->NewNode(s_op, p1, d3);
1640 : temp = graph()->NewNode(a_op, s3, b0);
1641 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1642 : BaseWithIndexAndDisplacement64Matcher match89(
1643 1 : graph()->NewNode(a_op, d15, temp));
1644 1 : CheckBaseWithIndexAndDisplacement(&match89, nullptr, 0, temp, d15);
1645 :
1646 : // B0 + (D15 + S3) -> [p1, 2, b0, d15]
1647 : s3 = graph()->NewNode(s_op, p1, d3);
1648 : temp = graph()->NewNode(a_op, d15, s3);
1649 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1650 : BaseWithIndexAndDisplacement64Matcher match90(
1651 1 : graph()->NewNode(a_op, b0, temp));
1652 1 : CheckBaseWithIndexAndDisplacement(&match90, p1, 3, b0, d15);
1653 :
1654 : // S3 + (B0 + D15) -> [p1, 2, b0, d15]
1655 : s3 = graph()->NewNode(s_op, p1, d3);
1656 : temp = graph()->NewNode(a_op, b0, d15);
1657 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1658 : BaseWithIndexAndDisplacement64Matcher match91(
1659 1 : graph()->NewNode(a_op, s3, temp));
1660 1 : CheckBaseWithIndexAndDisplacement(&match91, p1, 3, b0, d15);
1661 :
1662 : // S3 + (B0 - D15) -> [p1, 2, b0, d15, true]
1663 : s3 = graph()->NewNode(s_op, p1, d3);
1664 : temp = graph()->NewNode(sub_op, b0, d15);
1665 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1666 : BaseWithIndexAndDisplacement64Matcher match92(
1667 1 : graph()->NewNode(a_op, s3, temp));
1668 : CheckBaseWithIndexAndDisplacement(&match92, p1, 3, b0, d15,
1669 1 : kNegativeDisplacement);
1670 :
1671 : // B0 + (B1 - D15) -> [p1, 2, b0, d15, true]
1672 : temp = graph()->NewNode(sub_op, b1, d15);
1673 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1674 : BaseWithIndexAndDisplacement64Matcher match93(
1675 1 : graph()->NewNode(a_op, b0, temp));
1676 : CheckBaseWithIndexAndDisplacement(&match93, b1, 0, b0, d15,
1677 1 : kNegativeDisplacement);
1678 :
1679 : // (B0 - D15) + S3 -> [p1, 2, b0, d15, true]
1680 : s3 = graph()->NewNode(s_op, p1, d3);
1681 : temp = graph()->NewNode(sub_op, b0, d15);
1682 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1683 : BaseWithIndexAndDisplacement64Matcher match94(
1684 1 : graph()->NewNode(a_op, temp, s3));
1685 : CheckBaseWithIndexAndDisplacement(&match94, p1, 3, b0, d15,
1686 1 : kNegativeDisplacement);
1687 :
1688 : // (B0 + B1) + D15 -> [NULL, 0, (b0 + b1), d15]
1689 : // Avoid changing simple addressing to complex addressing
1690 : temp = graph()->NewNode(a_op, b0, b1);
1691 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1692 : BaseWithIndexAndDisplacement64Matcher match95(
1693 1 : graph()->NewNode(a_op, temp, d15));
1694 1 : CheckBaseWithIndexAndDisplacement(&match95, nullptr, 0, temp, d15);
1695 :
1696 : // D15 + (B0 + B1) -> [NULL, 0, (b0 + b1), d15]
1697 : // Avoid changing simple addressing to complex addressing
1698 : temp = graph()->NewNode(a_op, b0, b1);
1699 4 : ADD_ADDRESSING_OPERAND_USES(temp);
1700 : BaseWithIndexAndDisplacement64Matcher match96(
1701 1 : graph()->NewNode(a_op, d15, temp));
1702 1 : CheckBaseWithIndexAndDisplacement(&match96, nullptr, 0, temp, d15);
1703 :
1704 : // 5 INPUT - with none-addressing operand uses
1705 :
1706 : // (B0 + M1) -> [b0, 0, m1, NULL]
1707 : m1 = graph()->NewNode(m_op, p1, d1);
1708 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
1709 1 : BaseWithIndexAndDisplacement64Matcher match97(graph()->NewNode(a_op, b0, m1));
1710 1 : CheckBaseWithIndexAndDisplacement(&match97, b0, 0, m1, nullptr);
1711 :
1712 : // (M1 + B0) -> [b0, 0, m1, NULL]
1713 : m1 = graph()->NewNode(m_op, p1, d1);
1714 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
1715 1 : BaseWithIndexAndDisplacement64Matcher match98(graph()->NewNode(a_op, m1, b0));
1716 1 : CheckBaseWithIndexAndDisplacement(&match98, b0, 0, m1, nullptr);
1717 :
1718 : // (D15 + M1) -> [NULL, 0, m1, d15]
1719 : m1 = graph()->NewNode(m_op, p1, d1);
1720 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
1721 : BaseWithIndexAndDisplacement64Matcher match99(
1722 1 : graph()->NewNode(a_op, d15, m1));
1723 1 : CheckBaseWithIndexAndDisplacement(&match99, nullptr, 0, m1, d15);
1724 :
1725 : // (M1 + D15) -> [NULL, 0, m1, d15]
1726 : m1 = graph()->NewNode(m_op, p1, d1);
1727 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m1);
1728 : BaseWithIndexAndDisplacement64Matcher match100(
1729 1 : graph()->NewNode(a_op, m1, d15));
1730 1 : CheckBaseWithIndexAndDisplacement(&match100, nullptr, 0, m1, d15);
1731 :
1732 : // (B0 + S0) -> [b0, 0, s0, NULL]
1733 : s0 = graph()->NewNode(s_op, p1, d0);
1734 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
1735 : BaseWithIndexAndDisplacement64Matcher match101(
1736 1 : graph()->NewNode(a_op, b0, s0));
1737 1 : CheckBaseWithIndexAndDisplacement(&match101, b0, 0, s0, nullptr);
1738 :
1739 : // (S0 + B0) -> [b0, 0, s0, NULL]
1740 : s0 = graph()->NewNode(s_op, p1, d0);
1741 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
1742 : BaseWithIndexAndDisplacement64Matcher match102(
1743 1 : graph()->NewNode(a_op, s0, b0));
1744 1 : CheckBaseWithIndexAndDisplacement(&match102, b0, 0, s0, nullptr);
1745 :
1746 : // (D15 + S0) -> [NULL, 0, s0, d15]
1747 : s0 = graph()->NewNode(s_op, p1, d0);
1748 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
1749 : BaseWithIndexAndDisplacement64Matcher match103(
1750 1 : graph()->NewNode(a_op, d15, s0));
1751 1 : CheckBaseWithIndexAndDisplacement(&match103, nullptr, 0, s0, d15);
1752 :
1753 : // (S0 + D15) -> [NULL, 0, s0, d15]
1754 : s0 = graph()->NewNode(s_op, p1, d0);
1755 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s0);
1756 : BaseWithIndexAndDisplacement64Matcher match104(
1757 1 : graph()->NewNode(a_op, s0, d15));
1758 1 : CheckBaseWithIndexAndDisplacement(&match104, nullptr, 0, s0, d15);
1759 :
1760 : // (B0 + M2) -> [b0, 0, m2, NULL]
1761 : m2 = graph()->NewNode(m_op, p1, d2);
1762 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
1763 : BaseWithIndexAndDisplacement64Matcher match105(
1764 1 : graph()->NewNode(a_op, b0, m2));
1765 1 : CheckBaseWithIndexAndDisplacement(&match105, b0, 0, m2, nullptr);
1766 :
1767 : // (M2 + B0) -> [b0, 0, m2, NULL]
1768 : m2 = graph()->NewNode(m_op, p1, d2);
1769 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
1770 : BaseWithIndexAndDisplacement64Matcher match106(
1771 1 : graph()->NewNode(a_op, m2, b0));
1772 1 : CheckBaseWithIndexAndDisplacement(&match106, b0, 0, m2, nullptr);
1773 :
1774 : // (D15 + M2) -> [NULL, 0, m2, d15]
1775 : m2 = graph()->NewNode(m_op, p1, d2);
1776 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
1777 : BaseWithIndexAndDisplacement64Matcher match107(
1778 1 : graph()->NewNode(a_op, d15, m2));
1779 1 : CheckBaseWithIndexAndDisplacement(&match107, nullptr, 0, m2, d15);
1780 :
1781 : // (M2 + D15) -> [NULL, 0, m2, d15]
1782 : m2 = graph()->NewNode(m_op, p1, d2);
1783 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m2);
1784 : BaseWithIndexAndDisplacement64Matcher match108(
1785 1 : graph()->NewNode(a_op, m2, d15));
1786 1 : CheckBaseWithIndexAndDisplacement(&match108, nullptr, 0, m2, d15);
1787 :
1788 : // (B0 + S1) -> [b0, 0, s1, NULL]
1789 : s1 = graph()->NewNode(s_op, p1, d1);
1790 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
1791 : BaseWithIndexAndDisplacement64Matcher match109(
1792 1 : graph()->NewNode(a_op, b0, s1));
1793 1 : CheckBaseWithIndexAndDisplacement(&match109, b0, 0, s1, nullptr);
1794 :
1795 : // (S1 + B0) -> [b0, 0, s1, NULL]
1796 : s1 = graph()->NewNode(s_op, p1, d1);
1797 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
1798 : BaseWithIndexAndDisplacement64Matcher match110(
1799 1 : graph()->NewNode(a_op, s1, b0));
1800 1 : CheckBaseWithIndexAndDisplacement(&match110, b0, 0, s1, nullptr);
1801 :
1802 : // (D15 + S1) -> [NULL, 0, s1, d15]
1803 : s1 = graph()->NewNode(s_op, p1, d1);
1804 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
1805 : BaseWithIndexAndDisplacement64Matcher match111(
1806 1 : graph()->NewNode(a_op, d15, s1));
1807 1 : CheckBaseWithIndexAndDisplacement(&match111, nullptr, 0, s1, d15);
1808 :
1809 : // (S1 + D15) -> [NULL, 0, s1, d15]
1810 : s1 = graph()->NewNode(s_op, p1, d1);
1811 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s1);
1812 : BaseWithIndexAndDisplacement64Matcher match112(
1813 1 : graph()->NewNode(a_op, s1, d15));
1814 1 : CheckBaseWithIndexAndDisplacement(&match112, nullptr, 0, s1, d15);
1815 :
1816 : // (B0 + M4) -> [b0, 0, m4, NULL]
1817 : m4 = graph()->NewNode(m_op, p1, d4);
1818 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
1819 : BaseWithIndexAndDisplacement64Matcher match113(
1820 1 : graph()->NewNode(a_op, b0, m4));
1821 1 : CheckBaseWithIndexAndDisplacement(&match113, b0, 0, m4, nullptr);
1822 :
1823 : // (M4 + B0) -> [b0, 0, m4, NULL]
1824 : m4 = graph()->NewNode(m_op, p1, d4);
1825 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
1826 : BaseWithIndexAndDisplacement64Matcher match114(
1827 1 : graph()->NewNode(a_op, m4, b0));
1828 1 : CheckBaseWithIndexAndDisplacement(&match114, b0, 0, m4, nullptr);
1829 :
1830 : // (D15 + M4) -> [NULL, 0, m4, d15]
1831 : m4 = graph()->NewNode(m_op, p1, d4);
1832 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
1833 : BaseWithIndexAndDisplacement64Matcher match115(
1834 1 : graph()->NewNode(a_op, d15, m4));
1835 1 : CheckBaseWithIndexAndDisplacement(&match115, nullptr, 0, m4, d15);
1836 :
1837 : // (M4 + D15) -> [NULL, 0, m4, d15]
1838 : m4 = graph()->NewNode(m_op, p1, d4);
1839 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m4);
1840 : BaseWithIndexAndDisplacement64Matcher match116(
1841 1 : graph()->NewNode(a_op, m4, d15));
1842 1 : CheckBaseWithIndexAndDisplacement(&match116, nullptr, 0, m4, d15);
1843 :
1844 : // (B0 + S2) -> [b0, 0, s2, NULL]
1845 : s2 = graph()->NewNode(s_op, p1, d2);
1846 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
1847 : BaseWithIndexAndDisplacement64Matcher match117(
1848 1 : graph()->NewNode(a_op, b0, s2));
1849 1 : CheckBaseWithIndexAndDisplacement(&match117, b0, 0, s2, nullptr);
1850 :
1851 : // (S2 + B0) -> [b0, 0, s2, NULL]
1852 : s2 = graph()->NewNode(s_op, p1, d2);
1853 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
1854 : BaseWithIndexAndDisplacement64Matcher match118(
1855 1 : graph()->NewNode(a_op, s2, b0));
1856 1 : CheckBaseWithIndexAndDisplacement(&match118, b0, 0, s2, nullptr);
1857 :
1858 : // (D15 + S2) -> [NULL, 0, s2, d15]
1859 : s2 = graph()->NewNode(s_op, p1, d2);
1860 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
1861 : BaseWithIndexAndDisplacement64Matcher match119(
1862 1 : graph()->NewNode(a_op, d15, s2));
1863 1 : CheckBaseWithIndexAndDisplacement(&match119, nullptr, 0, s2, d15);
1864 :
1865 : // (S2 + D15) -> [NULL, 0, s2, d15]
1866 : s2 = graph()->NewNode(s_op, p1, d2);
1867 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s2);
1868 : BaseWithIndexAndDisplacement64Matcher match120(
1869 1 : graph()->NewNode(a_op, s2, d15));
1870 1 : CheckBaseWithIndexAndDisplacement(&match120, nullptr, 0, s2, d15);
1871 :
1872 : // (B0 + M8) -> [b0, 0, m8, NULL]
1873 : m8 = graph()->NewNode(m_op, p1, d8);
1874 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
1875 : BaseWithIndexAndDisplacement64Matcher match121(
1876 1 : graph()->NewNode(a_op, b0, m8));
1877 1 : CheckBaseWithIndexAndDisplacement(&match121, b0, 0, m8, nullptr);
1878 :
1879 : // (M8 + B0) -> [b0, 0, m8, NULL]
1880 : m8 = graph()->NewNode(m_op, p1, d8);
1881 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
1882 : BaseWithIndexAndDisplacement64Matcher match122(
1883 1 : graph()->NewNode(a_op, m8, b0));
1884 1 : CheckBaseWithIndexAndDisplacement(&match122, b0, 0, m8, nullptr);
1885 :
1886 : // (D15 + M8) -> [NULL, 0, m8, d15]
1887 : m8 = graph()->NewNode(m_op, p1, d8);
1888 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
1889 : BaseWithIndexAndDisplacement64Matcher match123(
1890 1 : graph()->NewNode(a_op, d15, m8));
1891 1 : CheckBaseWithIndexAndDisplacement(&match123, nullptr, 0, m8, d15);
1892 :
1893 : // (M8 + D15) -> [NULL, 0, m8, d15]
1894 : m8 = graph()->NewNode(m_op, p1, d8);
1895 1 : ADD_NONE_ADDRESSING_OPERAND_USES(m8);
1896 : BaseWithIndexAndDisplacement64Matcher match124(
1897 1 : graph()->NewNode(a_op, m8, d15));
1898 1 : CheckBaseWithIndexAndDisplacement(&match124, nullptr, 0, m8, d15);
1899 :
1900 : // (B0 + S3) -> [b0, 0, s3, NULL]
1901 : s3 = graph()->NewNode(s_op, p1, d3);
1902 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
1903 : BaseWithIndexAndDisplacement64Matcher match125(
1904 1 : graph()->NewNode(a_op, b0, s3));
1905 1 : CheckBaseWithIndexAndDisplacement(&match125, b0, 0, s3, nullptr);
1906 :
1907 : // (S3 + B0) -> [b0, 0, s3, NULL]
1908 : s3 = graph()->NewNode(s_op, p1, d3);
1909 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
1910 : BaseWithIndexAndDisplacement64Matcher match126(
1911 1 : graph()->NewNode(a_op, s3, b0));
1912 1 : CheckBaseWithIndexAndDisplacement(&match126, b0, 0, s3, nullptr);
1913 :
1914 : // (D15 + S3) -> [NULL, 0, s3, d15]
1915 : s3 = graph()->NewNode(s_op, p1, d3);
1916 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
1917 : BaseWithIndexAndDisplacement64Matcher match127(
1918 1 : graph()->NewNode(a_op, d15, s3));
1919 1 : CheckBaseWithIndexAndDisplacement(&match127, nullptr, 0, s3, d15);
1920 :
1921 : // (S3 + D15) -> [NULL, 0, s3, d15]
1922 : s3 = graph()->NewNode(s_op, p1, d3);
1923 1 : ADD_NONE_ADDRESSING_OPERAND_USES(s3);
1924 : BaseWithIndexAndDisplacement64Matcher match128(
1925 1 : graph()->NewNode(a_op, s3, d15));
1926 1 : CheckBaseWithIndexAndDisplacement(&match128, nullptr, 0, s3, d15);
1927 :
1928 : // (D15 + S3) + B0 -> [b0, 0, (D15 + S3), NULL]
1929 : s3 = graph()->NewNode(s_op, p1, d3);
1930 : temp = graph()->NewNode(a_op, d15, s3);
1931 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1932 : BaseWithIndexAndDisplacement64Matcher match129(
1933 1 : graph()->NewNode(a_op, temp, b0));
1934 1 : CheckBaseWithIndexAndDisplacement(&match129, b0, 0, temp, nullptr);
1935 :
1936 : // (B0 + D15) + S3 -> [p1, 3, (B0 + D15), NULL]
1937 : s3 = graph()->NewNode(s_op, p1, d3);
1938 : temp = graph()->NewNode(a_op, b0, d15);
1939 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1940 : BaseWithIndexAndDisplacement64Matcher match130(
1941 1 : graph()->NewNode(a_op, temp, s3));
1942 1 : CheckBaseWithIndexAndDisplacement(&match130, p1, 3, temp, nullptr);
1943 :
1944 : // (S3 + B0) + D15 -> [NULL, 0, (S3 + B0), d15]
1945 : s3 = graph()->NewNode(s_op, p1, d3);
1946 : temp = graph()->NewNode(a_op, s3, b0);
1947 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1948 : BaseWithIndexAndDisplacement64Matcher match131(
1949 1 : graph()->NewNode(a_op, temp, d15));
1950 1 : CheckBaseWithIndexAndDisplacement(&match131, nullptr, 0, temp, d15);
1951 :
1952 : // D15 + (S3 + B0) -> [NULL, 0, (S3 + B0), d15]
1953 : s3 = graph()->NewNode(s_op, p1, d3);
1954 : temp = graph()->NewNode(a_op, s3, b0);
1955 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1956 : BaseWithIndexAndDisplacement64Matcher match132(
1957 1 : graph()->NewNode(a_op, d15, temp));
1958 1 : CheckBaseWithIndexAndDisplacement(&match132, nullptr, 0, temp, d15);
1959 :
1960 : // B0 + (D15 + S3) -> [b0, 0, (D15 + S3), NULL]
1961 : s3 = graph()->NewNode(s_op, p1, d3);
1962 : temp = graph()->NewNode(a_op, d15, s3);
1963 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1964 : BaseWithIndexAndDisplacement64Matcher match133(
1965 1 : graph()->NewNode(a_op, b0, temp));
1966 1 : CheckBaseWithIndexAndDisplacement(&match133, b0, 0, temp, nullptr);
1967 :
1968 : // S3 + (B0 + D15) -> [p1, 3, (B0 + D15), NULL]
1969 : s3 = graph()->NewNode(s_op, p1, d3);
1970 : temp = graph()->NewNode(a_op, b0, d15);
1971 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1972 : BaseWithIndexAndDisplacement64Matcher match134(
1973 1 : graph()->NewNode(a_op, s3, temp));
1974 1 : CheckBaseWithIndexAndDisplacement(&match134, p1, 3, temp, nullptr);
1975 :
1976 : // S3 + (B0 - D15) -> [p1, 3, (B0 - D15), NULL]
1977 : s3 = graph()->NewNode(s_op, p1, d3);
1978 : temp = graph()->NewNode(sub_op, b0, d15);
1979 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1980 : BaseWithIndexAndDisplacement64Matcher match135(
1981 1 : graph()->NewNode(a_op, s3, temp));
1982 1 : CheckBaseWithIndexAndDisplacement(&match135, p1, 3, temp, nullptr);
1983 :
1984 : // B0 + (B1 - D15) -> [b0, 0, (B1 - D15), NULL]
1985 : temp = graph()->NewNode(sub_op, b1, d15);
1986 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1987 : BaseWithIndexAndDisplacement64Matcher match136(
1988 1 : graph()->NewNode(a_op, b0, temp));
1989 1 : CheckBaseWithIndexAndDisplacement(&match136, b0, 0, temp, nullptr);
1990 :
1991 : // (B0 - D15) + S3 -> [p1, 3, temp, NULL]
1992 : s3 = graph()->NewNode(s_op, p1, d3);
1993 : temp = graph()->NewNode(sub_op, b0, d15);
1994 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
1995 : BaseWithIndexAndDisplacement64Matcher match137(
1996 1 : graph()->NewNode(a_op, temp, s3));
1997 1 : CheckBaseWithIndexAndDisplacement(&match137, p1, 3, temp, nullptr);
1998 :
1999 : // (B0 + B1) + D15 -> [NULL, 0, (B0 + B1), d15]
2000 : temp = graph()->NewNode(a_op, b0, b1);
2001 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
2002 : BaseWithIndexAndDisplacement64Matcher match138(
2003 1 : graph()->NewNode(a_op, temp, d15));
2004 1 : CheckBaseWithIndexAndDisplacement(&match138, nullptr, 0, temp, d15);
2005 :
2006 : // D15 + (B0 + B1) -> [NULL, 0, (B0 + B1), d15]
2007 : temp = graph()->NewNode(a_op, b0, b1);
2008 1 : ADD_NONE_ADDRESSING_OPERAND_USES(temp);
2009 : BaseWithIndexAndDisplacement64Matcher match139(
2010 1 : graph()->NewNode(a_op, d15, temp));
2011 1 : CheckBaseWithIndexAndDisplacement(&match139, nullptr, 0, temp, d15);
2012 1 : }
2013 :
2014 15419 : TEST_F(NodeMatcherTest, BranchMatcher_match) {
2015 1 : Node* zero = graph()->NewNode(common()->Int32Constant(0));
2016 :
2017 : {
2018 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2019 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2020 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2021 1 : BranchMatcher matcher(branch);
2022 1 : EXPECT_TRUE(matcher.Matched());
2023 2 : EXPECT_EQ(branch, matcher.Branch());
2024 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2025 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2026 : }
2027 :
2028 : {
2029 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2030 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2031 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2032 1 : BranchMatcher matcher(branch);
2033 1 : EXPECT_TRUE(matcher.Matched());
2034 2 : EXPECT_EQ(branch, matcher.Branch());
2035 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2036 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2037 : }
2038 :
2039 : {
2040 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2041 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2042 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2043 1 : Node* other = graph()->NewNode(common()->IfValue(33), branch);
2044 1 : BranchMatcher matcher(branch);
2045 1 : EXPECT_TRUE(matcher.Matched());
2046 2 : EXPECT_EQ(branch, matcher.Branch());
2047 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2048 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2049 : USE(other);
2050 : }
2051 1 : }
2052 :
2053 :
2054 15419 : TEST_F(NodeMatcherTest, BranchMatcher_fail) {
2055 1 : Node* zero = graph()->NewNode(common()->Int32Constant(0));
2056 :
2057 : {
2058 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2059 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2060 1 : BranchMatcher matcher(branch);
2061 2 : EXPECT_FALSE(matcher.Matched());
2062 : USE(if_true);
2063 : }
2064 :
2065 : {
2066 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2067 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2068 1 : BranchMatcher matcher(branch);
2069 2 : EXPECT_FALSE(matcher.Matched());
2070 : USE(if_false);
2071 : }
2072 :
2073 : {
2074 1 : BranchMatcher matcher(zero);
2075 2 : EXPECT_FALSE(matcher.Matched());
2076 : }
2077 :
2078 : {
2079 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2080 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2081 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2082 2 : EXPECT_TRUE(BranchMatcher(branch).Matched());
2083 3 : EXPECT_FALSE(BranchMatcher(if_true).Matched());
2084 3 : EXPECT_FALSE(BranchMatcher(if_false).Matched());
2085 : }
2086 :
2087 : {
2088 1 : Node* sw = graph()->NewNode(common()->Switch(5), zero, graph()->start());
2089 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), sw);
2090 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), sw);
2091 3 : EXPECT_FALSE(BranchMatcher(sw).Matched());
2092 3 : EXPECT_FALSE(BranchMatcher(if_true).Matched());
2093 3 : EXPECT_FALSE(BranchMatcher(if_false).Matched());
2094 : }
2095 :
2096 : {
2097 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2098 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2099 1 : Node* if_value = graph()->NewNode(common()->IfValue(2), branch);
2100 1 : BranchMatcher matcher(branch);
2101 2 : EXPECT_FALSE(matcher.Matched());
2102 3 : EXPECT_FALSE(BranchMatcher(if_true).Matched());
2103 3 : EXPECT_FALSE(BranchMatcher(if_value).Matched());
2104 : }
2105 1 : }
2106 :
2107 :
2108 15419 : TEST_F(NodeMatcherTest, DiamondMatcher_match) {
2109 1 : Node* zero = graph()->NewNode(common()->Int32Constant(0));
2110 :
2111 : {
2112 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2113 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2114 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2115 2 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
2116 1 : DiamondMatcher matcher(merge);
2117 1 : EXPECT_TRUE(matcher.Matched());
2118 2 : EXPECT_EQ(branch, matcher.Branch());
2119 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2120 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2121 2 : EXPECT_EQ(merge, matcher.Merge());
2122 : }
2123 :
2124 : {
2125 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2126 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2127 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2128 2 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
2129 1 : DiamondMatcher matcher(merge);
2130 1 : EXPECT_TRUE(matcher.Matched());
2131 2 : EXPECT_EQ(branch, matcher.Branch());
2132 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2133 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2134 2 : EXPECT_EQ(merge, matcher.Merge());
2135 : }
2136 :
2137 : {
2138 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2139 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2140 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2141 2 : Node* merge = graph()->NewNode(common()->Merge(2), if_false, if_true);
2142 1 : DiamondMatcher matcher(merge);
2143 1 : EXPECT_TRUE(matcher.Matched());
2144 2 : EXPECT_EQ(branch, matcher.Branch());
2145 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2146 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2147 2 : EXPECT_EQ(merge, matcher.Merge());
2148 : }
2149 1 : }
2150 :
2151 :
2152 15419 : TEST_F(NodeMatcherTest, DiamondMatcher_fail) {
2153 1 : Node* zero = graph()->NewNode(common()->Int32Constant(0));
2154 :
2155 : {
2156 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2157 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2158 1 : Node* if_value = graph()->NewNode(common()->IfValue(1), branch);
2159 1 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_value);
2160 1 : DiamondMatcher matcher(merge);
2161 2 : EXPECT_FALSE(matcher.Matched());
2162 : }
2163 :
2164 : {
2165 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2166 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2167 1 : Node* if_value = graph()->NewNode(common()->IfValue(1), branch);
2168 1 : Node* merge = graph()->NewNode(common()->Merge(2), if_false, if_value);
2169 1 : DiamondMatcher matcher(merge);
2170 2 : EXPECT_FALSE(matcher.Matched());
2171 : }
2172 :
2173 : {
2174 2 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2175 2 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2176 2 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2177 2 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
2178 1 : DiamondMatcher matcher(merge);
2179 1 : EXPECT_TRUE(matcher.Matched());
2180 2 : EXPECT_EQ(branch, matcher.Branch());
2181 2 : EXPECT_EQ(if_true, matcher.IfTrue());
2182 2 : EXPECT_EQ(if_false, matcher.IfFalse());
2183 2 : EXPECT_EQ(merge, matcher.Merge());
2184 :
2185 2 : EXPECT_FALSE(DiamondMatcher(branch).Matched()); // Must be the merge.
2186 2 : EXPECT_FALSE(DiamondMatcher(if_true).Matched());
2187 2 : EXPECT_FALSE(DiamondMatcher(if_false).Matched());
2188 : }
2189 :
2190 : {
2191 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2192 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2193 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2194 1 : Node* merge = graph()->NewNode(common()->Merge(3), if_true, if_false,
2195 : graph()->start());
2196 1 : DiamondMatcher matcher(merge);
2197 2 : EXPECT_FALSE(matcher.Matched()); // Too many inputs to merge.
2198 : }
2199 :
2200 : {
2201 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2202 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
2203 : Node* if_false = graph()->start();
2204 1 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
2205 1 : DiamondMatcher matcher(merge);
2206 2 : EXPECT_FALSE(matcher.Matched());
2207 : }
2208 :
2209 : {
2210 1 : Node* branch = graph()->NewNode(common()->Branch(), zero, graph()->start());
2211 : Node* if_true = graph()->start();
2212 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
2213 1 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
2214 1 : DiamondMatcher matcher(merge);
2215 2 : EXPECT_FALSE(matcher.Matched());
2216 : }
2217 :
2218 : {
2219 : Node* branch1 =
2220 1 : graph()->NewNode(common()->Branch(), zero, graph()->start());
2221 : Node* branch2 =
2222 1 : graph()->NewNode(common()->Branch(), zero, graph()->start());
2223 1 : Node* if_true = graph()->NewNode(common()->IfTrue(), branch1);
2224 1 : Node* if_false = graph()->NewNode(common()->IfFalse(), branch2);
2225 1 : Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
2226 1 : DiamondMatcher matcher(merge);
2227 2 : EXPECT_FALSE(matcher.Matched());
2228 : }
2229 1 : }
2230 :
2231 :
2232 : } // namespace compiler
2233 : } // namespace internal
2234 9249 : } // namespace v8
|
